Add files via upload

Author: BrandonTang89

Other_Tasks/CF2093_A_Ideal_Generator.py

@@ -0,0 +1,2 @@
+for _ in range(int(input())):
+    print("YES" if int(input()) % 2 == 1 else "NO")

Other_Tasks/CF2093_B_Expensive_Number.py

@@ -0,0 +1,12 @@
+for _ in range(int(input())):
+    s = list(input())
+    n = len(s)
+    x = 0
+    # number of significant zeros
+    for i in range(n - 1, -1, -1):
+        if s[i] != "0":
+            break
+        else:
+            x += 1
+
+    print(len(s) - s.count("0") + x - 1)

Other_Tasks/CF2093_C_Simple_Repetition.py

@@ -0,0 +1,27 @@
+def is_prime(n):
+    """Check if a number is a prime number."""
+    if n <= 1:
+        return False
+    for i in range(2, int(n**0.5) + 1):
+        if n % i == 0:
+            return False
+    return True
+
+
+for _ in range(int(input())):
+    n, k = map(int, input().split())
+
+    # edge cases
+    if n == 1:
+        if k == 2:
+            print("YES")
+            continue
+
+    if k > 1:
+        print("NO")
+        continue
+    elif is_prime(n):
+        print("YES")
+        continue
+    else:
+        print("NO")

Other_Tasks/CF2093_D_Skibidi_Table.py

@@ -0,0 +1,48 @@
+def coord_to_num(x, y, n):
+    # print(f"coord_to_num({x}, {y}, {n})")
+    if n == 0:
+        assert x == y == 1
+        return 1
+
+    is_top = x <= (1 << (n - 1))
+    is_left = y <= (1 << (n - 1))
+
+    if is_top and is_left:
+        return coord_to_num(x, y, n - 1)
+    elif not is_top and not is_left:
+        return coord_to_num(x - (1 << (n - 1)), y - (1 << (n - 1)), n - 1) + (1 << (2*n - 2))
+    elif not is_top and is_left:
+        return coord_to_num(x - (1 << (n - 1)), y, n - 1) + 2 * (1 << (2*n - 2))
+    else:
+        return coord_to_num(x, y - (1 << (n - 1)), n - 1) + 3 * (1 << (2*n - 2))
+
+def num_to_coord(num, n) -> tuple[int, int]:
+    if n == 0:
+        assert num == 1
+        return (1, 1)
+    
+    if num <= (1<<(2*n - 2)):
+        return num_to_coord(num, n - 1)
+    elif num <= 2 * (1 << (2*n - 2)):
+        x, y = num_to_coord(num - (1 << (2*n - 2)), n - 1)
+        return (x + (1 << (n - 1)), y + (1 << (n - 1)))
+    elif num <= 3 * (1 << (2*n - 2)):
+        x, y = num_to_coord(num - 2 * (1 << (2*n - 2)), n - 1)
+        return (x + (1 << (n - 1)), y)
+    else:
+        x, y = num_to_coord(num - 3 * (1 << (2*n - 2)), n - 1)
+        return (x, y + (1 << (n - 1)))
+
+for _ in range(int(input())):
+    n = int(input())
+    q = int(input())
+
+    for _ in range(q):
+        op, *x = input().split()
+
+        if op == "->":
+            x, y = map(int, x)
+            print(coord_to_num(x, y, n))
+        elif op == "<-":
+            x = int(x[0])
+            print(num_to_coord(x, n)[0], num_to_coord(x, n)[1])

Other_Tasks/CF2093_E_Min_Max_MEX.cpp

@@ -0,0 +1,65 @@
+#pragma GCC optimize("Ofast")
+#pragma GCC optimize("unroll-loops")
+#include <bits/stdc++.h>
+using namespace std;
+
+typedef long long ll;
+typedef vector<int> vi;
+#define fast_cin()                    \
+    ios_base::sync_with_stdio(false); \
+    cin.tie(NULL);                    \
+    cout.tie(NULL);
+
+int n, k;
+vector<int> a;
+
+bool cando(int x) {
+    // can we achieve k segments with all mex >= x?
+    vector<int> achieved_by_segment(n + 2, -1);
+    int idx = 0;
+    for (int i = 0; i < k; i++) {
+        int mex = 0;
+        while (idx < n && mex < x) {
+            if (achieved_by_segment[a[idx]] < i) {
+                achieved_by_segment[a[idx]] = i;
+
+                while (mex < x && achieved_by_segment[mex] == i) {
+                    mex++;
+                }
+            }
+            idx++;
+        }
+
+        if (mex < x) {
+            return false;
+        }
+    }
+    // if we reach here, we can achieve k segments with all mex >= x
+    return true;
+}
+int main() {
+    int tc;
+    cin >> tc;
+    while (tc--) {
+        cin >> n >> k;
+        a.resize(n);
+        for (auto& x : a) {
+            cin >> x;
+            if (x > n + 1) x = n + 1;
+        }
+
+        ll hi = 1e9;
+        ll lo = 0;
+        while (lo < hi) {
+            int mid = (hi + lo + 1) / 2;
+            if (cando(mid)) {
+                lo = mid;
+            } else {
+                hi = mid - 1;
+            }
+        }
+
+        cout << lo << "\n";
+    }
+    return 0;
+}

Other_Tasks/CF2093_F_Hackers_and_Neural_Networks.cpp

@@ -0,0 +1,74 @@
+#pragma GCC optimize("Ofast")
+#pragma GCC optimize("unroll-loops")
+#include <bits/stdc++.h>
+using namespace std;
+
+typedef long long ll;
+typedef vector<int> vi;
+#define fast_cin()                    \
+    ios_base::sync_with_stdio(false); \
+    cin.tie(NULL);                    \
+    cout.tie(NULL);
+
+int n, m;
+vector<string> a;
+vector<vector<string>> b;
+int main() {
+    int tc;
+    cin >> tc;
+    while (tc--) {
+        cin >> n >> m;
+        a.resize(n);
+        b.assign(m, vector<string>(n));
+        for (int i = 0; i < n; i++) {
+            cin >> a[i];
+        }
+        for (int j = 0; j < m; j++) {
+            for (int i = 0; i < n; i++) {
+                cin >> b[j][i];
+            }
+        }
+
+        // check that for each i, there is a j such that a[i] = b[j][i]
+        // if not, return -1
+        bool all_there = true;
+        for (int i = 0; i < n; i++) {
+            bool found = false;
+            for (int j = 0; j < m; j++) {
+                if (a[i] == b[j][i]) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                all_there = false;
+                break;
+            }
+        }
+        if (!all_there) {
+            cout << -1 << endl;
+            continue;
+        }
+
+        // find the j with the most common elements with a[i]
+        int max_count = 0;
+        int max_j = -1;
+        for (int j = 0; j < m; j++) {
+            int count = 0;
+            for (int i = 0; i < n; i++) {
+                if (a[i] == b[j][i]) {
+                    count++;
+                }
+            }
+            if (count > max_count) {
+                max_count = count;
+                max_j = j;
+            }
+        }
+
+        int manually_fill = n - max_count;
+        cout << n + 2 * manually_fill << endl;
+    }
+
+    return 0;
+}

Other_Tasks/CF2093_G_Shorten_the_Array.cpp

@@ -0,0 +1,78 @@
+// CF2093G
+// Line sweep, maintaining 32 sets of last seen hash_maps based on masked versions of the array elements.
+// Time: O(n log n), Space: O(n)
+#pragma GCC optimize("Ofast")
+#pragma GCC optimize("unroll-loops")
+#include <bits/stdc++.h>
+using namespace std;
+
+int n, k;
+vector<int> a;
+int main() {
+    int tc;
+    cin >> tc;
+    while (tc--) {
+        cin >> n >> k;
+        a.resize(n);
+        for (auto& x : a) {
+            cin >> x;
+        }
+
+        // check single
+        if (k == 0) {
+            cout << 1 << endl;
+            continue;
+        }
+
+        // check adjacent
+        bool found_shortcut = false;
+        for (int i = 0; i < n - 1; i++) {
+            if ((a[i] ^ a[i + 1]) >= k) {
+                found_shortcut = true;
+                break;
+            }
+        }
+        if (found_shortcut) {
+            cout << 2 << endl;
+            continue;
+        }
+
+        int best = 1e9;
+        unordered_map<int, int> last_seen[32];  // last_seen[i][j] is the last seen index of j (masking out the least significant i bits)
+        for (int i = 0; i < n; i++) {
+            int looking_for = 0;
+            for (int j = 31; j >= 0; j--) {
+                if ((1 << j) & k) {  // must follow along differently
+                    looking_for = looking_for | ((1 << j) ^ ((1 << j) & a[i]));
+                } else {  // we can try to find someone who has a different version at this point
+                    looking_for = looking_for | ((1 << j) ^ ((1 << j) & a[i]));
+                    if (last_seen[j].contains(looking_for)) {
+                        int idx = last_seen[j][looking_for];
+                        best = min(best, i - idx + 1);
+                    }
+                    // otherwise assume this bit will be the same
+                    looking_for = looking_for ^ (1 << j);
+                }
+            }
+
+            // also check non-masked
+            if (last_seen[0].contains(looking_for)) {
+                int idx = last_seen[0][looking_for];
+                best = min(best, i - idx + 1);
+            }
+
+            int mask = ~0;
+            for (int j = 0; j < 32; j++) {
+                last_seen[j][a[i] & mask] = i;
+                mask = mask ^ (1 << j);
+            }
+        }
+
+        if (best == 1e9) {
+            cout << -1 << endl;
+        } else {
+            cout << best << endl;
+        }
+    }
+    return 0;
+}