# leetcode biweekly-contest-83

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

1. "Flush": Five cards of the same suit.
2. "Three of a Kind": Three cards of the same rank.
3. "Pair": Two cards of the same rank.
4. "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.

Example 1:

Input: ranks = [13,2,3,1,9], suits = ["a","a","a","a","a"]
Output: "Flush"
Explanation: The hand with all the cards consists of 5 cards with the same suit, so we have a "Flush".

class Solution {
public:
string bestHand(vector<int> &ranks, vector<char> &suits) {
bool a = false;
for (auto &n: suits) {
if (n != suits[0]) {
a = 1;
break;
}
}
if (!a) {
return "Flush";
}
map<int, int> m;
int ma = 0;
for (auto &n: ranks) {
m[n]++;
ma = max(ma, m[n]);
}
if (ma >= 3) {
return "Three of a Kind";
}
if (ma == 2) {
return "Pair";
}
return "High Card";
}
};

### 2348. Number of Zero-Filled Subarrays

• User Accepted: 10283
• User Tried: 11095
• Total Accepted: 10547
• Total Submissions: 19823
• Difficulty: Medium

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.

Example 1:

Input: nums = [1,3,0,0,2,0,0,4]
Output: 6
Explanation:
There are 4 occurrences of [0] as a subarray.
There are 2 occurrences of [0,0] as a subarray.
There is no occurrence of a subarray with a size more than 2 filled with 0. Therefore, we return 6.

$c_i=\frac{(l_i+1)*l_i}{2}$

class Solution {
public:
long long zeroFilledSubarray(vector<int> &nums) {
int now = 0;
long long ans=0;
for (auto &n: nums) {
if (n == 0) {
now++;
} else {
ans += (1ll + now) * now / 2ll;
now = 0;
}
}
ans += (1ll + now) * now / 2ll;
return ans;
}
};

### Design a Number Container System

Design a number container system that can do the following:

• Insert or Replace a number at the given index in the system.
• Return the smallest index for the given number in the system.

Implement the NumberContainers class:

• NumberContainers() Initializes the number container system.
• void change(int index, int number) Fills the container at index with the number. If there is already a number at that index, replace it.
• int find(int number) Returns the smallest index for the given number, or -1 if there is no index that is filled by number in the system.

Example 1:

Input
["NumberContainers", "find", "change", "change", "change", "change", "find", "change", "find"]
[[], [10], [2, 10], [1, 10], [3, 10], [5, 10], [10], [1, 20], [10]]
Output
[null, -1, null, null, null, null, 1, null, 2]

Explanation
NumberContainers nc = new NumberContainers();
nc.find(10); // There is no index that is filled with number 10. Therefore, we return -1.
nc.change(2, 10); // Your container at index 2 will be filled with number 10.
nc.change(1, 10); // Your container at index 1 will be filled with number 10.
nc.change(3, 10); // Your container at index 3 will be filled with number 10.
nc.change(5, 10); // Your container at index 5 will be filled with number 10.
nc.find(10); // Number 10 is at the indices 1, 2, 3, and 5. Since the smallest index that is filled with 10 is 1, we return 1.
nc.change(1, 20); // Your container at index 1 will be filled with number 20. Note that index 1 was filled with 10 and then replaced with 20.
nc.find(10); // Number 10 is at the indices 2, 3, and 5. The smallest index that is filled with 10 is 2. Therefore, we return 2.

class NumberContainers {
public:
map<int, int> m;
map<int, set<int>> as;

NumberContainers() {

}

void change(int index, int number) {
if (m.count(index)) {
as[m[index]].erase(index);
}
as[number].insert(index);
m[index] = number;
}

int find(int number) {
if (as[number].size() == 0) {
return -1;
}
return *as[number].begin();
}
};

/**
* Your NumberContainers object will be instantiated and called as such:
* NumberContainers* obj = new NumberContainers();
* obj->change(index,number);
* int param_2 = obj->find(number);
*/

### Shortest Impossible Sequence of Rolls

You are given an integer array rolls of length n and an integer k. You roll a k sided dice numbered from 1 to k, n times, where the result of the ith roll is rolls[i].

Return the length of the shortest sequence of rolls that cannot be taken from rolls.

A sequence of rolls of length len is the result of rolling a k sided dice len times.

Note that the sequence taken does not have to be consecutive as long as it is in order.

Example 1:

Input: rolls = [4,2,1,2,3,3,2,4,1], k = 4
Output: 3
Explanation: Every sequence of rolls of length 1, [1], [2], [3], [4], can be taken from rolls.
Every sequence of rolls of length 2, [1, 1], [1, 2], ..., [4, 4], can be taken from rolls.
The sequence [1, 4, 2] cannot be taken from rolls, so we return 3.
Note that there are other sequences that cannot be taken from rolls.

class Solution {
public:
int shortestSequence(vector<int> &rolls, int k) {
set<int> f;
int ans = 1;
for (auto &n: rolls) {
f.insert(n);
if (f.size() == k) {
ans++;
f.clear();
}
}
return ans;
}
};