C++ Program To Find The Winner Of A Unique Building Game

There exist numerous thrilling obstacles within the realm of competitive programming, with one intriguing task being determining the victor in a distinctive building game scenario. In this particular game, participants make decisions on which building to incorporate into their assortment as they encounter an array of buildings, each possessing a distinct height. The challenge lies in the fact that a player can exclusively select a building that stands taller than all previously chosen buildings. The ultimate champion is the player who amasses the highest count of buildings in their collection by the game's conclusion, with no further selections permitted.

Assuming there are n elements in an array denoted as A, where each element A[i] corresponds to the i-th participant out of n total participants in a bidding contest. Each participant selects a distinct and minimal number from the array. The participant with the winning bid should have their index identified. If this task is not achievable, the program will return -1. The solution entails a C++ script designed to streamline this procedure and declare the triumphant player in this tactical challenge.

Problem statement:

There exist numerous strategies for addressing various programming challenges. Formulating an algorithm stands as the initial phase in resolving a problem, necessitating a comprehensive examination of the specified issue. Recursion is at times employed when a problem recurs persistently; alternatively, iterative frameworks are also occasionally employed in such scenarios. Control structures such as if-else statements and switch cases can be employed to manage the flow of a program's logic. Skillful utilization of variables and data structures can lead to the development of a compact program that consumes minimal memory. It is imperative to explore the existing programming methodologies like divide and conquer, greedy programming, and dynamic programming to determine their applicability. Employing elementary logic or a brute-force technique can serve as viable solutions to tackle the problem at hand. Refer to the subsequent sections to enhance your comprehension of the approach. The participant who has chosen 3 emerges victorious in the game; hence, for the input A = [2, 3, 2, 4, 2], the output will be 1.

Steps to be followed:

size: size of the list arr.
i := 0
for i from 0 to size - 1:
element := arr[i]
Increase the count of element + 1 in countMap by 1.
Set the position of element + 1 in positionMap to i.
answer := -1
for each pair in countMap:
if the value of pair is equal to 1:
Set answer to the value associated with the key pair in positionMap.
Break out of the loop.
Return answer

Example 1:

Let's consider a scenario to determine the champion of an exclusive construction simulation in C++.

#include <bits/stdc++.h>
using namespace std;

// Function to find the position of the unique element
int findUniqueElementPosition(const vector<int>& arr) {
    map<int, int> countMap, positionMap;
    int size = arr.size();

    // Count occurrences and store positions of elements
    for (int i = 0; i < size; i++) {
        int element = arr[i];
        countMap[element + 1]++;
        positionMap[element + 1] = i;
    }

    // Find the position of the unique element
    int answer = -1;
    for (auto& it : countMap) {
        if (it.second == 1) {
            answer = positionMap[it.first];
            break;
        }
    }

    return answer;
}

int main() {
    // Example usage
    vector<int> arr = { 2, 3, 2, 4, 2 };
    int position = findUniqueElementPosition(arr);
    cout << "Position of the unique element: " << position << endl;
    return 0;
}

Output:

Position of the unique element: 1

Example 2:

Let's consider another instance to determine the victor of a distinctive construction game in C++.

#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;

// Function to find the position of the unique element
int findUniqueElementPosition(const vector<int>& arr) {
    unordered_map<int, int> countMap, positionMap;
    int size = arr.size();

    // Count occurrences and store positions of elements
    for (int i = 0; i < size; i++) {
        int element = arr[i];
        countMap[element]++;
        positionMap[element] = i;
    }

    // Find the position of the unique element
    int answer = -1;
    for (auto& it : countMap) {
        if (it.second == 1) {
            answer = positionMap[it.first];
            break;
        }
    }

    return answer;
}

int main() {
    // Example usage
    vector<int> arr = { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5 };
    int position = findUniqueElementPosition(arr);
    if (position != -1) {
        cout << "Position of the unique element: " << position << endl;
    } else {
        cout << "No unique element found!" << endl;
    }
    return 0;
}

Output:

Position of the unique element: 7