Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+HiBench/Paper/contextual_qa/train.json filter=lfs diff=lfs merge=lfs -text

HiBench/.gitattributes

@@ -0,0 +1,59 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

HiBench/Code/c++Selected/1.cpp

@@ -0,0 +1,35 @@
+class Solution {
+public:
+vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
+for (int i = 0; i < matrix.size(); ++i) {
+for (int j = 0; j < matrix[i].size(); ++j) {
+if (!matrix[i][j]) {
+continue;
+}
+matrix[i][j] = numeric_limits<int>::max();
+if (i > 0 && matrix[i - 1][j] != numeric_limits<int>::max()) {
+matrix[i][j] = min(matrix[i][j], matrix[i - 1][j] + 1);
+}
+if (j > 0 && matrix[i][j - 1] != numeric_limits<int>::max()) {
+matrix[i][j] = min(matrix[i][j], matrix[i][j - 1] + 1);
+}
+}
+}
+
+for (int i = matrix.size() - 1; i >= 0; --i) {
+for (int j = matrix[i].size() - 1; j >= 0; --j) {
+if (!matrix[i][j]) {
+continue;
+}
+if (i < matrix.size() - 1 && matrix[i + 1][j] != numeric_limits<int>::max()) {
+matrix[i][j] = min(matrix[i][j], matrix[i + 1][j] + 1);
+}
+if (j < matrix[i].size() - 1 && matrix[i][j + 1] != numeric_limits<int>::max()) {
+matrix[i][j] = min(matrix[i][j], matrix[i][j + 1] + 1);
+}
+}
+}
+
+return matrix;
+}
+};

HiBench/Code/c++Selected/10.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+int maxA(int N) {
+if (N < 7) {
+return N;
+}
+if (N == 10) {  // the following rule doesn't hold when N = 10
+return 20;
+}
+auto n = N / 5 + 1;  // n3 + n4 increases one every 5 keys
+auto n3 = 5 * n - N - 1;
+auto n4 = n - n3;
+return pow(3, n3) * pow(4, n4);
+}
+};
+

HiBench/Code/c++Selected/100.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+vector<int> maxDepthAfterSplit(string seq) {
+vector<int> result(seq.length());
+for (int i = 0; i < seq.length(); ++i) {
+result[i] = (i & 1) ^ (seq[i] == '(');
+}
+return result;
+}
+};

HiBench/Code/c++Selected/11.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
+unordered_map<int, int> A_B_sum;
+for (const auto& a : A) {
+for (const auto& b : B) {
+++A_B_sum[a + b];
+}
+}
+int result = 0;
+for (const auto& c : C) {
+for (const auto& d : D) {
+if (A_B_sum.find(-c - d) != A_B_sum.end()) {
+result += A_B_sum[-c - d];
+}
+}
+}
+return result;
+}
+};

HiBench/Code/c++Selected/12.cpp

@@ -0,0 +1,38 @@
+class Solution {
+public:
+vector<vector<int> > fourSum(vector<int> &nums, int target) {
+sort(begin(nums), end(nums));
+vector<vector<int>> result;
+for (int i = 0; i + 3 < size(nums); ++i) {
+if (i && nums[i] == nums[i - 1]) {
+continue;
+}
+for (int j = i + 1; j + 2 < size(nums); ++j) {
+if (j != i + 1 && nums[j] == nums[j - 1]) {
+continue;
+}
+const auto& total = target - nums[i] - nums[j];
+int left = j + 1, right = size(nums) - 1;
+while (left < right) {
+if (nums[left] + nums[right] == total) {
+result.push_back({nums[i], nums[j], nums[left], nums[right]});
+++left, --right;
+while (left < right && nums[left] == nums[left - 1]) {
+++left;
+}
+while (left < right && nums[right] == nums[right + 1]) {
+--right;
+}
+} else {
+if (nums[left] + nums[right] > total) {
+--right;
+} else {
+++left;
+}
+}
+}
+}
+}
+return result;
+}
+};

HiBench/Code/c++Selected/13.cpp

@@ -0,0 +1,6 @@
+class Solution {
+public:
+bool isSameAfterReversals(int num) {
+return (num == 0 || num % 10);
+}
+};

HiBench/Code/c++Selected/14.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+string abbreviateProduct(int left, int right) {
+static const int PREFIX_LEN = 5;
+static const int SUFFIX_LEN = 5;
+static const int64_t MOD = pow(10, PREFIX_LEN + SUFFIX_LEN);
+
+int64_t curr = 1, zeros = 0;
+bool abbr = false;
+double decimal = 0.0;
+for (int64_t i = left; i <= right; ++i, curr %= MOD) {
+curr *= i;
+decimal += log10(i);
+while (curr % 10 == 0) {
+curr /= 10;
+++zeros;
+}
+if (curr >= MOD) {
+abbr = true;
+}
+}
+if (!abbr) {
+return to_string(curr) + "e" + to_string(zeros);
+}
+decimal -= int(decimal);
+const auto& prefix = to_string(static_cast<int>(pow(10, decimal + (PREFIX_LEN - 1))));
+const auto& suffix = to_string(curr % static_cast<int>(pow(10, SUFFIX_LEN)));
+return prefix + "..." + string(SUFFIX_LEN - size(suffix), '0') + suffix + "e" + to_string(zeros);
+}
+};

HiBench/Code/c++Selected/15.cpp

@@ -0,0 +1,6 @@
+class Solution {
+public:
+int accountBalanceAfterPurchase(int purchaseAmount) {
+return 100 - (purchaseAmount + 5) / 10 * 10;
+}
+};

HiBench/Code/c++Selected/16.cpp

@@ -0,0 +1,60 @@
+class Solution {
+public:
+vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
+UnionFind union_find;
+unordered_map<string, string> email_to_name;
+unordered_map<string, int> email_to_id;
+for (const auto& account : accounts) {
+const auto& name = account[0];
+for (int i = 1; i < account.size(); ++i) {
+if (!email_to_id.count(account[i])) {
+email_to_name[account[i]] = name;
+email_to_id[account[i]] = union_find.get_id();
+}
+union_find.union_set(email_to_id[account[1]], email_to_id[account[i]]);
+}
+}
+
+unordered_map<int, set<string>> lookup;
+for (const auto& kvp : email_to_name) {
+const auto& email = kvp.first;
+lookup[union_find.find_set(email_to_id[email])].emplace(email);
+}
+vector<vector<string>> result;
+for (const auto& kvp : lookup) {
+const auto& emails = kvp.second;
+vector<string> tmp{email_to_name[*emails.begin()]};
+for (const auto& email : emails) {
+tmp.emplace_back(email);
+}
+result.emplace_back(move(tmp));
+}
+return result;
+}
+
+private:
+class UnionFind {
+public:
+int get_id() {
+set_.emplace_back(set_.size());
+return set_.size() - 1;
+}
+
+int find_set(const int x) {
+if (set_[x] != x) {
+set_[x] = find_set(set_[x]);  // Path compression.
+}
+return set_[x];
+}
+
+void union_set(const int x, const int y) {
+int x_root = find_set(x), y_root = find_set(y);
+if (x_root != y_root) {
+set_[min(x_root, y_root)] = max(x_root, y_root);
+}
+}
+
+private:
+vector<int> set_;
+};
+};

HiBench/Code/c++Selected/17.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+string addBinary(string a, string b) {
+string res;
+size_t res_len = max(a.length(), b.length()) ;
+
+size_t carry = 0;
+for (int i = 0; i < res_len; ++i) {
+const size_t a_bit_i = i < a.length() ? a[a.length() - 1 - i] - '0' : 0;
+const size_t b_bit_i = i < b.length() ? b[b.length() - 1 - i] - '0' : 0;
+size_t sum = carry + a_bit_i + b_bit_i;
+carry = sum / 2;
+sum %= 2;
+res.push_back('0' + sum);
+}
+if (carry) {
+res.push_back('0' + carry);
+}
+reverse(res.begin(), res.end());
+
+return res;
+}
+};

HiBench/Code/c++Selected/18.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+string addBoldTag(string s, vector<string>& dict) {
+vector<bool> lookup(s.length());
+for (const auto& d: dict) {
+auto pos = -1;
+while ((pos = s.find(d, pos + 1)) != string::npos) {
+fill(lookup.begin() + pos, lookup.begin() + pos + d.length(), true);
+}
+}
+string result;
+for (int i = 0; i < s.length(); ++i) {
+if (lookup[i] && (i == 0 || !lookup[i - 1])) {
+result += "<b>";
+}
+result.push_back(s[i]);
+if (lookup[i] && (i == (s.length() - 1) || !lookup[i + 1])) {
+result += "</b>";
+}
+}
+return result;
+}
+};

HiBench/Code/c++Selected/19.cpp

@@ -0,0 +1,6 @@
+class Solution {
+public:
+int addDigits(int num) {
+return (num - 1) % 9 + 1;
+}
+};

HiBench/Code/c++Selected/2.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+bool isOneBitCharacter(vector<int>& bits) {
+auto parity = 0;
+for (int i = static_cast<int>(bits.size()) - 2;
+i >= 0 && bits[i]; --i) {
+parity ^= bits[i];
+}
+return parity == 0;
+}
+};

HiBench/Code/c++Selected/20.cpp

@@ -0,0 +1,33 @@
+class Solution {
+public:
+bool isPossible(int n, vector<vector<int>>& edges) {
+vector<unordered_set<int>> adj(n);
+for (const auto& e : edges) {
+adj[e[0] - 1].emplace(e[1] - 1);
+adj[e[1] - 1].emplace(e[0] - 1);
+}
+vector<int> odds;
+for (int u = 0; u < n; ++u) {
+if (size(adj[u]) % 2) {
+odds.emplace_back(u);
+}
+}
+if (size(odds) == 0) {
+return true;
+}
+if (size(odds) == 2) {
+for (int u = 0; u < n; ++u) {
+if (!adj[u].count(odds[0]) && !adj[u].count(odds[1])) {
+return true;
+}
+}
+return false;
+}
+if (size(odds) == 4) {
+return ((!adj[odds[1]].count(odds[0]) && !adj[odds[3]].count(odds[2])) ||
+(!adj[odds[2]].count(odds[0]) && !adj[odds[3]].count(odds[1])) ||
+(!adj[odds[3]].count(odds[0]) && !adj[odds[2]].count(odds[1])));
+}
+return false;
+}
+};

HiBench/Code/c++Selected/21.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+int addRungs(vector<int>& rungs, int dist) {
+int result = 0, prev = 0;
+for (const auto& curr : rungs) {
+result += ceil_divide(curr - prev, dist) - 1;
+prev = curr;
+}
+return result;
+}
+
+private:
+int ceil_divide(int a, int b) {
+return (a + (b - 1)) / b;
+}
+};

HiBench/Code/c++Selected/22.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+TreeNode* addOneRow(TreeNode* root, int v, int d) {
+if (d == 0 || d == 1) {
+auto node = new TreeNode(v);
+(d == 1 ? node->left : node->right) = root;
+return node;
+}
+if (root && d >= 2) {
+root->left  = addOneRow(root->left,  v, d > 2 ? d - 1 : 1);
+root->right = addOneRow(root->right, v, d > 2 ? d - 1 : 0);
+}
+return root;
+}
+};

HiBench/Code/c++Selected/23.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+string addStrings(string num1, string num2) {
+string result;
+
+for (int i = num1.size() - 1, j = num2.size() - 1, carry = 0;
+i >= 0 || j >= 0 || carry;
+carry /= 10) {
+
+if (i >= 0) {
+carry += num1[i--] - '0';
+}
+if (j >= 0) {
+carry += num2[j--] - '0';
+}
+result += to_string(carry % 10);
+}
+reverse(result.begin(), result.end());
+
+return result;
+}
+};

HiBench/Code/c++Selected/24.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+vector<int> addToArrayForm(vector<int>& A, int K) {
+reverse(A.begin(), A.end());
+int carry = K, i = 0;
+A[i] += carry;
+carry = A[i] / 10;
+A[i] %= 10;
+while (carry) {
+++i;
+if (i < A.size()) {
+A[i] += carry;
+} else {
+A.emplace_back(carry);
+}
+carry = A[i] / 10;
+A[i] %= 10;
+}
+reverse(A.begin(), A.end());
+return A;
+}
+};

HiBench/Code/c++Selected/25.cpp

@@ -0,0 +1,6 @@
+class Solution {
+public:
+int sum(int num1, int num2) {
+return num1 + num2;
+}
+};

HiBench/Code/c++Selected/26.cpp

@@ -0,0 +1,40 @@
+class Solution {
+public:
+ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+stack<int> stk1, stk2;
+while (l1) {
+stk1.emplace(l1->val);
+l1 = l1->next;
+}
+while (l2) {
+stk2.emplace(l2->val);
+l2 = l2->next;
+}
+
+ListNode *prev = nullptr, *head = nullptr;
+int sum = 0;
+while (!stk1.empty() || !stk2.empty()) {
+sum /= 10;
+if (!stk1.empty()) {
+sum += stk1.top();
+stk1.pop();
+}
+
+if (!stk2.empty()) {
+sum += stk2.top();
+stk2.pop();
+}
+
+head = new ListNode(sum % 10);
+head->next = prev;
+prev = head;
+}
+
+if (sum >= 10) {
+head = new ListNode(sum / 10);
+head->next = prev;
+}
+
+return head;
+}
+};

HiBench/Code/c++Selected/27.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+ListNode dummy{0};
+auto curr = &dummy;
+
+auto carry = 0;
+while (l1 || l2 || carry) {
+auto a = l1? l1->val : 0, b = l2? l2->val : 0;
+auto val = carry + a + b;
+curr->next = new ListNode(val % 10);
+carry = val / 10;
+l1 = l1 ? l1->next : nullptr;
+l2 = l2 ? l2->next : nullptr;
+curr = curr->next;
+}
+
+return dummy.next;
+}
+};

HiBench/Code/c++Selected/28.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+PolyNode* addPoly(PolyNode* poly1, PolyNode* poly2) {
+PolyNode dummy;
+auto curr = &dummy;
+while (poly1 && poly2) {
+if (poly1->power > poly2->power) {
+curr->next = poly1;
+curr = curr->next;
+poly1 = poly1->next;
+} else if (poly1->power < poly2->power) {
+curr->next = poly2;
+curr = curr->next;
+poly2 = poly2->next;
+} else {
+auto coef = poly1->coefficient + poly2->coefficient;
+if (coef) {
+curr->next = new PolyNode(coef, poly1->power);
+curr = curr->next;
+}
+poly1 = poly1->next;
+poly2 = poly2->next;
+}
+}
+curr->next = poly1 ? poly1 : poly2;
+return dummy.next;
+}
+};

HiBench/Code/c++Selected/29.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+string addSpaces(string s, vector<int>& spaces) {
+int prev = size(s);
+s.resize(size(s) + size(spaces));
+for(int i = size(spaces) - 1; i >= 0; --i) {
+for (int j = prev - 1; j >= spaces[i]; --j) {
+s[j + 1 + i] = s[j];
+}
+s[spaces[i] + i] = ' ';
+prev = spaces[i];
+}
+return s;
+}
+};

HiBench/Code/c++Selected/3.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+bool find132pattern(vector<int>& nums) {
+int ak = numeric_limits<int>::min();
+vector<int> stk;
+for (int i = size(nums) - 1; i >= 0; --i) {
+if (nums[i] < ak) {
+return true;
+}
+while (!empty(stk) && stk.back() < nums[i]) {
+ak = stk.back(), stk.pop_back();
+}
+stk.emplace_back(nums[i]);
+}
+return false;
+}
+};

HiBench/Code/c++Selected/30.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+vector<int> addNegabinary(vector<int>& arr1, vector<int>& arr2) {
+vector<int> result;
+int carry = 0, i = arr1.size() - 1, j = arr2.size() - 1;
+while (i >= 0 || j >= 0 || carry) {
+if (i >= 0) {
+carry += arr1[i--];
+}
+if (j >= 0) {
+carry += arr2[j--];
+}
+result.emplace_back(carry & 1);
+carry = -(carry >> 1);
+}
+while (result.size() > 1 && result.back() == 0) {
+result.pop_back();
+}
+reverse(result.begin(), result.end());
+return result;
+}
+};

HiBench/Code/c++Selected/31.cpp

@@ -0,0 +1,49 @@
+class Solution {
+public:
+bool isAdditiveNumber(string num) {
+for (int i = 1; i < num.length(); ++i) {
+for (int j = i + 1; j < num.length(); ++j) {
+string s1 = num.substr(0, i), s2 = num.substr(i, j - i);
+if ((s1.length() > 1 && s1[0] == '0') ||
+(s2.length() > 1 && s2[0] == '0')) {
+continue;
+}
+
+string next = add(s1, s2);
+string cur = s1 + s2 + next;
+while (cur.length() < num.length()) {
+s1 = s2;
+s2 = next;
+next = add(s1, s2);
+cur += next;
+}
+if (cur == num) {
+return true;
+}
+}
+}
+return false;
+}
+
+private:
+string add(const string& m, const string& n) {
+string res;
+int res_length = max(m.length(), n.length()) ;
+
+int carry = 0;
+for (int i = 0; i < res_length; ++i) {
+int m_digit_i = i < m.length() ? m[m.length() - 1 - i] - '0' : 0;
+int n_digit_i = i < n.length() ? n[n.length() - 1 - i] - '0' : 0;
+int sum = carry + m_digit_i + n_digit_i;
+carry = sum / 10;
+sum %= 10;
+res.push_back('0' + sum);
+}
+if (carry) {
+res.push_back('0' + carry);
+}
+reverse(res.begin(), res.end());
+
+return res;
+}
+};

HiBench/Code/c++Selected/32.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+bool hasIncreasingSubarrays(vector<int>& nums, int k) {
+int result = 0;
+int curr = 1, prev = 0;
+for (int i = 0; i + 1 < size(nums); ++i) {
+if (nums[i] < nums[i + 1]) {
+++curr;
+} else {
+prev = curr;
+curr = 1;
+}
+result = max({result, curr / 2, min(prev, curr)});
+}
+return result >= k;
+}
+};

HiBench/Code/c++Selected/33.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+int maxIncreasingSubarrays(vector<int>& nums) {
+int result = 0;
+int curr = 1, prev = 0;
+for (int i = 0; i + 1 < size(nums); ++i) {
+if (nums[i] < nums[i + 1]) {
+++curr;
+} else {
+prev = curr;
+curr = 1;
+}
+result = max({result, curr / 2, min(prev, curr)});
+}
+return result;
+}
+};

HiBench/Code/c++Selected/34.cpp

@@ -0,0 +1,32 @@
+class Solution {
+public:
+vector<int> advantageCount(vector<int>& A, vector<int>& B) {
+vector<int> sortedA(A.cbegin(), A.cend());
+sort(sortedA.begin(), sortedA.end());
+vector<int> sortedB(B.cbegin(), B.cend());
+sort(sortedB.begin(), sortedB.end());
+
+unordered_map<int, vector<int>> candidates;
+vector<int> others;
+int j = 0;
+for (const auto& a : sortedA) {
+if (a > sortedB[j]) {
+candidates[sortedB[j]].emplace_back(a);
+++j;
+} else {
+others.emplace_back(a);
+}
+}
+vector<int> result;
+for (const auto& b : B) {
+if (!candidates[b].empty()) {
+result.emplace_back(candidates[b].back());
+candidates[b].pop_back();
+} else {
+result.emplace_back(others.back());
+others.pop_back();
+}
+}
+return result;
+}
+};

HiBench/Code/c++Selected/35.cpp

@@ -0,0 +1,6 @@
+class Solution {
+public:
+double nthPersonGetsNthSeat(int n) {
+return n != 1 ? 0.5 : 1.0;
+}
+};

HiBench/Code/c++Selected/36.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+vector<string> alertNames(vector<string>& keyName, vector<string>& keyTime) {
+static const int THRESHOLD = 3;
+unordered_map<string, vector<int>> name_to_times;
+for (int i = 0; i < size(keyName); ++i) {
+int hour = stoi(keyTime[i].substr(0, 2));
+int minute = stoi(keyTime[i].substr(3));
+name_to_times[keyName[i]].emplace_back(hour * 60 + minute);
+}
+vector<string> result;
+for (auto& [name, times] : name_to_times) {
+sort(begin(times), end(times));
+for (int left = 0, right = 0; right < size(times); ++right) {
+while (times[right] - times[left] > 60) {
+++left;
+}
+if (right - left + 1 >= THRESHOLD) {
+result.emplace_back(name);
+break;
+}
+}
+}
+sort(begin(result), end(result));
+return result;
+}
+};

HiBench/Code/c++Selected/37.cpp

@@ -0,0 +1,6 @@
+class Solution {
+public:
+long long flowerGame(int n, int m) {
+return (1ll * n * m) / 2;
+}
+};

HiBench/Code/c++Selected/38.cpp

@@ -0,0 +1,62 @@
+class Solution {
+public:
+string alienOrder(vector<string>& words) {
+unordered_set<char> nodes;
+unordered_map<char, unordered_set<char>> in_degree, out_degree;
+queue<char> zero_in_degree_queue;
+for (const auto& word : words) {
+for (const auto& c : word) {
+nodes.emplace(c);
+}
+}
+for (int i = 1; i < words.size(); ++i) {
+if (words[i - 1].length() > words[i].length() &&
+words[i - 1].substr(0, words[i].length()) == words[i]) {
+return "";
+}
+findEdges(words[i - 1], words[i], &in_degree, &out_degree);
+}
+for (const auto& node : nodes) {
+if (in_degree.find(node) == in_degree.end()) {
+zero_in_degree_queue.emplace(node);
+}
+}
+
+string result;
+while (!zero_in_degree_queue.empty()) {
+const auto& precedence = zero_in_degree_queue.front();
+zero_in_degree_queue.pop();
+result.push_back(precedence);
+
+if (out_degree.find(precedence) != out_degree.end()) {
+for (const auto& c : out_degree[precedence]) {
+in_degree[c].erase(precedence);
+if (in_degree[c].empty()) {
+zero_in_degree_queue.emplace(c);
+}
+}
+out_degree.erase(precedence);
+}
+}
+
+if (!out_degree.empty()) {
+return "";
+}
+
+return result;
+}
+
+private:
+void findEdges(const string &word1, const string &word2,
+unordered_map<char, unordered_set<char>> *in_degree,
+unordered_map<char, unordered_set<char>> *out_degree) {
+const int len = min(word1.length(), word2.length());
+for (int i = 0; i < len; ++i) {
+if (word1[i] != word2[i]) {
+(*in_degree)[word2[i]].emplace(word1[i]);
+(*out_degree)[word1[i]].emplace(word2[i]);
+break;
+}
+}
+}
+};

HiBench/Code/c++Selected/39.cpp

@@ -0,0 +1,34 @@
+class Solution {
+public:
+vector<vector<int>> getAncestors(int n, vector<vector<int>>& edges) {
+vector<vector<int>> adj(n);
+for (const auto& e : edges) {
+adj[e[0]].emplace_back(e[1]);
+}
+vector<vector<int>> result(n);
+for (int u = 0; u < n; ++u) {
+iter_dfs(adj, u, &result);
+}
+return result;
+}
+
+private:
+void iter_dfs(const vector<vector<int>>& adj,
+int i,
+vector<vector<int>> *result) {
+
+vector<bool> lookup(size(adj));
+vector<int> stk = {i};
+while (!empty(stk)) {
+const auto u = stk.back(); stk.pop_back();
+for (const auto& v: adj[u]) {
+if (lookup[v]) {
+continue;
+}
+lookup[v] = true;
+stk.emplace_back(v);
+(*result)[v].emplace_back(i);
+}
+}
+}
+};

HiBench/Code/c++Selected/4.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+int minSteps(int n) {
+auto result = 0;
+for (auto p = 2 ; p * p <= n; ++p) {
+while (n % p == 0) {
+result += p;
+n /= p;
+}
+}
+result += (n > 1) ? n : 0;
+return result;
+}
+};

HiBench/Code/c++Selected/40.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+vector<int> maxScoreIndices(vector<int>& nums) {
+const int total = accumulate(cbegin(nums), cend(nums), 0);
+vector<int> result;
+for (int i = 0, zeros = 0, mx = 0; i <= size(nums); ++i) {
+zeros += static_cast<int>(((i - 1 >= 0) ? nums[i - 1] : 0) == 0);
+if (zeros + (total - (i - zeros)) > mx) {
+mx = zeros + (total - (i - zeros));
+result.clear();
+}
+if (zeros + (total - (i - zeros)) == mx) {
+result.emplace_back(i);
+}
+}
+return result;
+}
+};

HiBench/Code/c++Selected/41.cpp

@@ -0,0 +1,55 @@
+class Solution {
+public:
+vector<int> getAllElements(TreeNode* root1, TreeNode* root2) {
+vector<int> result;
+Iterator<TreeNode*> left(root1), right(root2);
+while (*left || *right) {
+if (!*right || ((*left) && (*left)->val < (*right)->val)) {
+result.emplace_back((*left)->val);
+++left;
+} else {
+result.emplace_back((*right)->val);
+++right;
+}
+}
+return result;
+}
+
+private:
+template<typename T>
+class Iterator {
+public:
+Iterator(T root)
+: stack_{{root, false}}
+, curr_{} {
+++(*this);
+}
+
+Iterator& operator++() {
+while (!stack_.empty()) {
+T root; bool is_visited;
+tie(root, is_visited) = stack_.back(); stack_.pop_back();
+if (!root) {
+continue;
+}
+if (is_visited) {
+curr_ = root;
+return *this;
+}
+stack_.emplace_back(root->right, false);
+stack_.emplace_back(root, true);
+stack_.emplace_back(root->left, false);
+}
+curr_ = T{};
+return *this;
+}
+
+const T& operator*() const {
+return curr_;
+}
+
+private:
+vector<pair<T, bool>> stack_;
+T curr_;
+};
+};

HiBench/Code/c++Selected/42.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+vector<int> distanceK(TreeNode* root, TreeNode* target, int K) {
+unordered_map<int, vector<int>> neighbors;
+dfs(nullptr, root, &neighbors);
+
+vector<int> bfs{target->val};
+unordered_set<int> lookup{target->val};
+for (int i = 0; i < K; ++i) {
+vector<int> curr;
+for (const auto& node : bfs) {
+for (const auto& nei : neighbors[node]) {
+if (!lookup.count(nei)) {
+curr.emplace_back(nei);
+lookup.emplace(nei);
+}
+}
+}
+swap(bfs, curr);
+}
+return bfs;
+}
+
+private:
+void dfs(TreeNode *parent, TreeNode *child,
+unordered_map<int, vector<int>> *neighbors) {
+if (!child) {
+return;
+}
+if (parent) {
+(*neighbors)[parent->val].emplace_back(child->val);
+(*neighbors)[child->val].emplace_back(parent->val);
+}
+dfs(child, child->left, neighbors);
+dfs(child, child->right, neighbors);
+}
+};

HiBench/Code/c++Selected/43.cpp

@@ -0,0 +1,40 @@
+class Solution {
+public:
+enum Status { UNVISITED, VISITING, DONE };
+
+bool leadsToDestination(int n, vector<vector<int>>& edges, int source, int destination) {
+unordered_map<int, vector<int>> children;
+for (const auto& edge : edges) {
+children[edge[0]].emplace_back(edge[1]);
+}
+vector<Status> status(n);
+return dfs(children, source, destination, &status);
+}
+
+private:
+bool dfs(const unordered_map<int, vector<int>>& children,
+int node,
+int destination,
+vector<Status> *status) {
+
+if ((*status)[node] == DONE) {
+return true;
+}
+if ((*status)[node] == VISITING) {
+return false;
+}
+(*status)[node] = VISITING;
+if (!children.count(node) && node != destination) {
+return false;
+}
+if (children.count(node)) {
+for (const auto& child : children.at(node)) {
+if (!dfs(children, child, destination, status)) {
+return false;
+}
+}
+}
+(*status)[node] = DONE;
+return true;
+}
+};

HiBench/Code/c++Selected/44.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
+vector<vector<int>> result;
+vector<int> path{0};
+dfs(graph, 0, &path, &result);
+return result;
+}
+
+private:
+void dfs(const vector<vector<int>>& graph,
+int curr, vector<int> *path,
+vector<vector<int>> *result) {
+if (curr == graph.size() - 1) {
+result->emplace_back(*path);
+return;
+}
+for (const auto& node: graph[curr]) {
+path->emplace_back(node);
+dfs(graph, node, path, result);
+path->pop_back();
+}
+}
+};

HiBench/Code/c++Selected/45.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+vector<TreeNode*> allPossibleFBT(int N) {
+if (!memo_.count(N)) {
+vector<TreeNode*> result;
+if (N == 1) {
+result.emplace_back(new TreeNode(0));
+} else if (N % 2 == 1) {
+for (int i = 0; i < N; ++i) {
+for (const auto& left: allPossibleFBT(i)) {
+for (const auto& right: allPossibleFBT(N - 1 - i)) {
+auto node = new TreeNode(0);
+node->left = left;
+node->right = right;
+result.emplace_back(node);
+}
+}
+}
+}
+memo_[N] = move(result);
+}
+return memo_[N];
+}
+
+private:
+unordered_map<int, vector<TreeNode*>> memo_;
+};

HiBench/Code/c++Selected/46.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+int minDistance(vector<int>& houses, int k) {
+sort(begin(houses), end(houses));
+vector<int> prefix(houses.size() + 1);
+for (int i = 0; i < houses.size(); ++i) {
+prefix[i + 1] = prefix[i] + houses[i];
+}
+vector<int> dp(houses.size());
+for (int j = 0; j < houses.size(); ++j) {
+dp[j] = cost(prefix, 0, j);
+}
+for (int m = 1; m < k; ++m) {
+for (int j = houses.size() - 1; j >= 0; --j) {
+for (int i = m; i <= j; ++i) {
+dp[j] = min(dp[j], dp[i - 1] + cost(prefix, i, j));
+}
+}
+}
+return dp.back();
+}
+
+private:
+int cost(const vector<int>& prefix, int i, int j) {
+return (prefix[j + 1] - prefix[(i + j + 1) / 2]) -
+(prefix[(i + j) / 2 + 1] - prefix[i]);
+}
+};

HiBench/Code/c++Selected/47.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+string alphabetBoardPath(string target) {
+string result;
+int x = 0, y = 0;
+for (const auto& c : target) {
+int x1 = (c - 'a') % 5, y1 = (c - 'a') / 5;
+result += string(max(y - y1, 0), 'U');
+result += string(max(x - x1, 0), 'L');
+result += string(max(x1 - x, 0), 'R');
+result += string(max(y1 - y, 0), 'D');
+result += "!";
+x = x1, y = y1;
+}
+return result;
+}
+};

HiBench/Code/c++Selected/48.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+vector<int> simulationResult(vector<int>& windows, vector<int>& queries) {
+vector<bool> lookup(size(windows));
+vector<int> result;
+for (int i = size(queries) - 1; i >= 0; --i) {
+if (lookup[queries[i]]) {
+continue;
+}
+lookup[queries[i]] = true;
+result.emplace_back(queries[i]);
+}
+for (const auto& x : windows) {
+if (lookup[x]) {
+continue;
+}
+result.emplace_back(x);
+}
+return result;
+}
+};

HiBench/Code/c++Selected/49.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+int alternateDigitSum(int n) {
+int result = 0, sign = 1;
+for (; n; n /= 10) {
+sign *= -1;
+result += sign * (n % 10);
+}
+return sign * result;
+}
+};

HiBench/Code/c++Selected/5.cpp

@@ -0,0 +1,150 @@
+class Solution {
+public:
+bool judgePoint24(vector<int>& nums) {
+vector<double> doubles;
+std::transform(nums.begin(), nums.end(), std::back_inserter(doubles),
+[](const int num) { return double(num); });
+return dfs(doubles);
+}
+
+private:
+bool dfs(const vector<double>& nums) {
+if (nums.size() == 1) {
+return fabs(nums[0] - 24) < 1e-6;
+}
+static unordered_map<char, std::function<double(double, double)>> ops =
+{
+{'+', std::plus<double>()},
+{'-', std::minus<double>()},
+{'*', std::multiplies<double>()},
+{'/', std::divides<double>()},
+};
+for (int i = 0; i < nums.size(); ++i) {
+for (int j = 0; j < nums.size(); ++j) {
+if (i == j) {
+continue;
+}
+vector<double> next_nums;
+for (int k = 0; k < nums.size(); ++k) {
+if (k == i || k == j) {
+continue;
+}
+next_nums.emplace_back(nums[k]);
+}
+for (const auto& op : ops) {
+if (((op.first == '+' || op.first == '*') && i > j) ||
+(op.first == '/' && nums[j] == 0)) {
+continue;
+}
+next_nums.emplace_back(op.second(nums[i], nums[j]));
+if (dfs(next_nums)) {
+return true;
+}
+next_nums.pop_back();
+}
+}
+}
+return false;
+}
+};
+
+
+class Fraction {
+public:
+Fraction() = default;
+Fraction(int n)
+: Fraction(n, 1)
+{
+}
+Fraction(int n, int d)
+: numerator_(n)
+, denominator_(d)
+{
+}
+~Fraction() = default;
+
+void set_num(int value) { numerator_ = value; }
+void set_den(int value) { denominator_ = value; }
+int get_num() const { return numerator_; }
+int get_den() const { return denominator_; }
+void reduce();
+int calculate_gcd(int, int) const;
+private:
+int numerator_, denominator_;
+};
+
+void Fraction::reduce()
+{
+const auto gcd = calculate_gcd(numerator_, denominator_);
+numerator_ = numerator_ / gcd;
+denominator_ = denominator_ / gcd;
+}
+
+int Fraction::calculate_gcd(int a, int b) const
+{
+a = std::abs(a);
+b = std::abs(b);
+while (b != 0) {
+int tmp = b;
+b = a % b;
+a = tmp;
+}
+return a;
+}
+
+Fraction operator+(const Fraction& lhs, const Fraction& rhs)
+{
+Fraction result{};
+
+result.set_num((lhs.get_num() * rhs.get_den()) + (lhs.get_den() * rhs.get_num()));
+result.set_den(lhs.get_den() * rhs.get_den());
+
+result.reduce();
+
+return result;
+}
+
+Fraction operator-(const Fraction& lhs, const Fraction& rhs)
+{
+Fraction result{};
+
+result.set_num((lhs.get_num() * rhs.get_den()) - (lhs.get_den() * rhs.get_num()));
+result.set_den(lhs.get_den() * rhs.get_den());
+
+result.reduce();
+
+return result;
+}
+
+Fraction operator*(const Fraction& lhs, const Fraction& rhs)
+{
+Fraction result{};
+
+result.set_num(lhs.get_num() * rhs.get_num());
+result.set_den(lhs.get_den() * rhs.get_den());
+
+result.reduce();
+
+return result;
+}
+
+Fraction operator/(const Fraction& lhs, const Fraction& rhs)
+{
+Fraction result{};
+
+result.set_num(lhs.get_num() * rhs.get_den());
+result.set_den(lhs.get_den() * rhs.get_num());
+
+result.reduce();
+
+return result;
+}
+
+bool operator==(const Fraction &lhs, const Fraction &rhs) {
+return (((lhs.get_num() * rhs.get_den()) - (rhs.get_num() * lhs.get_den())) == 0);
+}
+
+std::ostream &operator<<(std::ostream &os, const Fraction &value) {
+os << value.get_num() << "/" << value.get_den();
+return os;
+}

HiBench/Code/c++Selected/50.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+int numberOfAlternatingGroups(vector<int>& colors) {
+static const int k = 3;
+
+int result = 0;
+for (int right = 0, left = 0, curr = 0; right < size(colors) + k - 1; ++right) {
+if (right - left + 1 == k) {
+result += curr == k - 1 ? 1 : 0;
+curr -= colors[left] != colors[(left + 1) % size(colors)] ? 1 : 0;
+++left;
+}
+curr += colors[right % size(colors)] != colors[(right + 1) % size(colors)] ? 1 : 0;
+}
+return result;
+}
+};

HiBench/Code/c++Selected/51.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+int numberOfAlternatingGroups(vector<int>& colors, int k) {
+int result = 0;
+for (int right = 0, left = 0, curr = 0; right < size(colors) + k - 1; ++right) {
+if (right - left + 1 == k) {
+result += curr == k - 1 ? 1 : 0;
+curr -= colors[left] != colors[(left + 1) % size(colors)] ? 1 : 0;
+++left;
+}
+curr += colors[right % size(colors)] != colors[(right + 1) % size(colors)] ? 1 : 0;
+}
+return result;
+}
+};