# Weekly and Biweekly Contests | July | Leetcode

Posted on Dec 25, 2020

## 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.

``````    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, amount, and amount 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.

``````int fillCups(vector<int>& a) {
int ans = 0;
while(1){
sort(a.begin(), a.end());
if(a == 0 and a == 0){
ans += a;
break;
}
a--;
a--;
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

``````    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;
}

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.

``````    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.

``````    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

``````    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).

``````    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;

}
``````