## Biweekly Contest 82

### 2331. Evaluate Boolean Binary Tree

You are given the root of a full binary tree with the following properties:

- Leaf nodes have either the value 0 or 1, where 0 represents False and 1 represents True.
- Non-leaf nodes have either the value 2 or 3, where 2 represents the boolean OR and 3 represents the boolean AND.

The evaluation of a node is as follows:

- If the node is a leaf node, the evaluation is the value of the node, i.e. True or False.
- Otherwise, evaluate the node’s two children and apply the boolean operation of its value with the children’s evaluations.

*Return the boolean result of evaluating the root node.*

A full binary tree is a binary tree where each node has either 0 or 2 children.

A leaf node is a node that has zero children.

1
2
3
4
5
6
7
8
9
10

bool evaluateTree(TreeNode* root) {
if(root->val < 2)
return root->val;
if(root->val == 2)
return evaluateTree(root->left) || evaluateTree(root->right);
return evaluateTree(root->left) && evaluateTree(root->right);
}

## Biweekly Contest 82

### 2335. Minimum Amount of Time to Fill Cups

You have a water dispenser that can dispense cold, warm, and hot water. Every second, you can either fill up 2 cups with different types of water, or 1 cup of any type of water.

You are given a 0-indexed integer array amount of length 3 where amount[0], amount[1], and amount[2] denote the number of cold, warm, and hot water cups you need to fill respectively. Return the minimum number of seconds needed to fill up all the cups.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int fillCups(vector<int>& a) {
int ans = 0;
while(1){
sort(a.begin(), a.end());
if(a[0] == 0 and a[1] == 0){
ans += a[2];
break;
}
a[2]--;
a[1]--;
ans++;
}
return ans;
}

### 2336. Smallest Number in Infinite Set

You have a set which contains all positive integers [1, 2, 3, 4, 5, …].

Implement the SmallestInfiniteSet class:

`SmallestInfiniteSet()`

Initializes the SmallestInfiniteSet object to contain all positive integers.- int
`popSmallest()`

Removes and returns the smallest integer contained in the infinite set. `void addBack(int num)`

Adds a positive integer num back into the infinite set, if it is not already in the infinite set.- Practice

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

priority_queue<int, vector<int>, greater<int> > heap;
unordered_map<int, int> mp;
SmallestInfiniteSet() {
for(int i=1; i<=1000; i++)
{
heap.push(i);
mp[i]++;
}
}
int popSmallest() {
int ans = heap.top();
mp[ans]--;
heap.pop();
return ans;
}
void addBack(int num) {
if(mp[num]) return;
heap.push(num);
mp[num]++;
}

## Biweekly Contest 83

### 2347. Best Poker Hand

You are given an integer array ranks and a character array suits. You have 5 cards where the ith card has a rank of $ranks[i]$ and a suit of $suits[i]$.

The following are the types of poker hands you can make from best to worst:

`"Flush"`

: Five cards of the same suit.`"Three of a Kind"`

: Three cards of the same rank.`"Pair"`

: Two cards of the same rank.`"High Card"`

: Any single card.

Return a string representing the best type of poker hand you can make with the given cards.

*Note that the return values are case-sensitive.*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

string bestHand(vector<int>& ranks, vector<char>& suits) {
unordered_map<int, int> rank;
unordered_map<char, int> suit;
for(auto r:ranks)
rank[r]++;
for(auto s:suits)
suit[s]++;
int bestRank = INT_MIN, bestSuit = INT_MIN;
for(auto r: rank)
bestRank = max(bestRank, r.second);
for(auto s:suit)
bestSuit = max(bestSuit, s.second);
if(bestSuit == 5) return "Flush";
if(bestRank > 2) return "Three of a Kind";
if(bestRank == 2) return "Pair";
return "High Card";
}

### 2348. Number of Zero-Filled Subarrays

Given an integer array nums, return the number of subarrays filled with 0.

A subarray is a contiguous non-empty sequence of elements within an array.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

long long zeroFilledSubarray(vector<int>& nums) {
long long zero(0), ans(0), i=0, n = nums.size();
while(i<n){
if(nums[i] == 0)
zero++;
else{
ans += zero*(zero+1)/2;
zero = 0;
}
i++;
}
if(zero) ans += zero*(zero+1)/2;
return ans;
}

## Weekly Contest 303

### 2351. First Letter to Appear Twice

Given a string s consisting of lowercase English letters, return the first letter to appear twice.

**Note:**

- A letter a appears twice before another letter b if the second occurrence of a is before the second occurrence of b.
s will contain at least one letter that appears twic

- Practice

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

char repeatedCharacter(string s) {
vector<int> index(26, -1);
vector<int> dist(26, 101);
char ans;
int idx, mini = 101;
for(int i=0; i<s.size(); i++){
idx = s[i] - 'a';
if(index[idx] == -1)
index[idx] = i;
else if (dist[idx] == 101)
dist[idx] = i;
}
for(int i=0; i<26; i++){
// cout << i << " -> " << dist[i] << endl;
if(dist[i] < mini){
mini = dist[i];
ans = i + 'a';
}
}
return ans;
}

### 2352. Equal Row and Column Pairs

Given a `0-indexed`

$n x n$ integer matrix grid, return the number of pairs $(R_i, C_j)$ such that row $R_i$ and column $C_j$ are equal.

A row and column pair is considered equal if they contain the same elements in the same order (i.e. an equal array).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

char repeatedCharacter(string s) {
vector<int> index(26, -1);
vector<int> dist(26, 101);
char ans;
int idx, mini = 101;
for(int i=0; i<s.size(); i++){
idx = s[i] - 'a';
if(index[idx] == -1)
index[idx] = i;
else if (dist[idx] == 101)
dist[idx] = i;
}
for(int i=0; i<26; i++)
if(dist[i] < mini){
mini = dist[i];
ans = i + 'a';
}
return ans;
}