There is four possible outcomes to this problem, if there has been both a '>' and '<' in your string , then you cant determine the winner so you return '?'. with that case out of the way you just need to keep track of if theres been a '<' or '>' since we know both couldnt have been there, so which ever one you find, you print, if its neither , you can return '='.

for _ in range(int(input())):
	s = input()
	if '<' in s and '>' in s:
		print('?')
	elif '<' in s:
		print('<')
	elif '>' in s:
		print('>')
	else:
		print('=')

The problem requires selecting k computers with the highest possible equal internet speed, given that we can only decrease speeds but not increase them. A simple and efficient approach is to sort the array in descending order and directly pick the k-th largest speed, as this ensures we select the highest possible speed that at least k computers can have. Alternatively, a brute-force approach involves iterating through potential speeds and counting how many computers can support them, keeping track of the maximum valid speed. Due to the weak constraints (n ≤ 100), both approaches work efficiently, with sorting providing an O(n log n) solution.

n, k = map(int, input().split())
print(sorted(map(int, input().split()))[n - k])

The problem involves ensuring that at least B liters of water flow out of the first hole by blocking the minimum number of holes. The flow from each hole is proportional to its size, and the goal is to maximize the flow from the first hole. We calculate the total sum of hole sizes and sort the remaining holes. By iteratively blocking the smallest holes, we reduce the total size until the flow from the first hole meets or exceeds B. The solution involves sorting and a greedy approach to block the smallest contributors first.

n, a, b = list(map(int, input().split()))
arr = list(map(int, input().split()))

s = sum(arr)
res = sorted(arr[1:])
count = 0

while arr[0] * a / s < b:
    s -= res.pop()
    count += 1

print(count)

You’re given an NXM grid where each cell has an initial color. A stranger set is a group of cells that:

1. All share the same color.
2. No two cells in the set share a side (cells can touch diagonally but not edge-to-edge).

In a single step, you can choose any such stranger set and repaint all its cells in any other color. The objective is to make all cells the same color using the fewest steps.

Key Insight

For each color(c):

• If no pair of adjacent cells has color(c), you can repaint all of those cells in 1 step. (They’re already pairwise strangers.)
• If at least one pair of adjacent cells has color color(c), you need 2 steps to repaint all cells of that color. (Because you can split the connected component into two “stranger” groups.)

Hence, define for each color(c):

• color(c) = 0 if (c) does not appear in the grid.
• color(c) = 1 if (c) appears, but never in two adjacent cells.
• color(c) = 2 if (c) appears and there is at least one pair of adjacent cells color(c).

Choosing the Final Color

• Let S be the sum of color(c) over every color c that appears.
  • In code, this is computed as sum(has_color ) + sum(adj_found), where has_color [c] is 1 if c appears, and adj_found[c] is 1 if c has adjacent cells.
• If you select some color C* as the final color, you do not need to repaint cells already in C*.
• The minimum steps required to unify the grid into a single color is:

result = S - max(cost(c))

In the code, max(cost(c)) = 1 + max(adj_found[c]). Hence, the final result is:

result = (sum(has_color ) + sum(adj_found)) - 1 - max(adj_found)

Complexity Analysis:

• Time Complexity: O(n*m):

  • O(n*m) to read the grid and determine adjacent cells.
  • O(n*m) to compute costs and find the maximum cost.

• Space Complexity: O(n*m):

  • We store the entire grid n*m elements.
  • We also maintain two arrays of size (n*m) + 1 to track which colors appear and whether they have adjacent cells.

import sys 
input = sys.stdin.readline 

def solve():
    n, m = map(int, input().split())
    grid = [list(map(int, input().split())) for i in range(n)]
    has_color = [0] * (n * m + 1)
    adj_found= [0] * (n * m + 1)

    for i in range(n):
        for j in range(m):
            has_color[grid[i][j]] = 1

            if i + 1 < n and grid[i][j] == grid[i + 1][j]:
                adj_found[grid[i][j]] = 1
            if j + 1 < m and grid[i][j] == grid[i][j + 1]:
                adj_found[grid[i][j]] = 1

    print(sum(has_color) + sum(adj_found) - 1 - max(adj_found))

if __name__ == '__main__':
    for _ in range(int(input())):
        solve()