Add files via upload

Author: MathProgrammer

2022/Contests/Div 2/767/Programs/Download More RAM.cpp

@@ -0,0 +1,46 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+void solve()
+{
+    int no_of_elements, present_RAM;
+    cin >> no_of_elements >> present_RAM;
+
+    vector <pair <int, int> > ram(no_of_elements);
+    for(int i = 0; i < no_of_elements; i++)
+    {
+        cin >> ram[i].first;
+    }
+
+    for(int i = 0; i < no_of_elements; i++)
+    {
+        cin >> ram[i].second;
+    }
+
+    sort(ram.begin(), ram.end());
+
+    int answer = present_RAM;
+    for(int i = 0; i < no_of_elements; i++)
+    {
+        if(ram[i].first <= answer)
+        {
+            answer += ram[i].second;
+        }
+    }
+
+    cout << answer << "\n";
+}
+
+int main()
+{
+    int no_of_test_cases;
+    cin >> no_of_test_cases;
+
+    while(no_of_test_cases--)
+        solve();
+
+    return 0;
+}

2022/Contests/Div 2/767/Programs/GCD Arrays.cpp

@@ -0,0 +1,32 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+int odd_till(int n)
+{
+    return (n/2) + n%2;
+}
+
+void solve()
+{
+    int left, right, no_of_operations;
+    cin >> left >> right >> no_of_operations;
+
+    int odd_integers = odd_till(right) - odd_till(left - 1);
+
+    cout << (no_of_operations >= odd_integers || (left == right && left != 1) ? "YES" : "NO") << "\n";
+}
+
+int main()
+{
+    int no_of_test_cases;
+    cin >> no_of_test_cases;
+
+    while(no_of_test_cases--)
+        solve();
+
+    return 0;
+}
+

2022/Contests/Div 2/767/Programs/Game On Sum Easy Version.cpp

@@ -0,0 +1,68 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+long long power_mod(long long x, long long power, long long m)
+{
+    long long result = 1;
+
+    while(power > 0)
+    {
+        if(power%2 == 1)
+            result = (result*x)%m;
+
+        x = (x*x)%m;
+        power = power >> 1;
+    }
+
+    return result;
+}
+
+long long inverse(long long x, long long m)
+{
+    return power_mod(x, m - 2, m);
+}
+
+void solve()
+{
+    long long no_of_moves, add_moves, range;
+    cin >> no_of_moves >> add_moves >> range;
+
+    const int MOD = 1e9 + 7;
+    vector <vector <long long> > score(no_of_moves + 1, vector <long long> (add_moves + 1, 0));
+    for(int i = 0; i <= no_of_moves; i++)
+    {
+        for(int j = 0; j <= add_moves; j++)
+        {
+            if(i == 0 || j == 0)
+            {
+                score[i][j] = 0;
+                continue;
+            }
+            if(j == i)
+            {
+                score[i][j] = (range*j)%MOD;
+                continue;
+            }
+
+            score[i][j] = (score[i - 1][j - 1] + score[i - 1][j])%MOD;
+            score[i][j] *= inverse(2, MOD);
+            score[i][j] %= MOD; //cout << "F(" << i << "," << j << ") = " << score[i][j] << "\n";
+        }
+    }
+
+    cout << score[no_of_moves][add_moves] << "\n";
+}
+
+int main()
+{
+    int no_of_test_cases;
+    cin >> no_of_test_cases;
+
+    while(no_of_test_cases--)
+        solve();
+
+    return 0;
+}
+

2022/Contests/Div 2/767/Programs/Grid XOR.cpp

@@ -0,0 +1,92 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+const int BLACK = 0, WHITE = 1;
+
+int get_colour(int x, int y)
+{
+    return (x + y)%2;
+}
+
+int is_inside(int i, int j, int rows, int columns)
+{
+    return (1 <= i && i <= rows && 1 <= j && j <= columns);
+}
+
+int get_xor_sum(vector <vector <int> > &G, int n, int colour)
+{
+    vector <vector <int> > counted(n + 1, vector <int> (n + 1, false));
+
+    const int NO_OF_NEIGHBOURS = 4;
+    int next_x[NO_OF_NEIGHBOURS] = {-1, 0, 0, 1}, next_y[NO_OF_NEIGHBOURS] = {0, 1, -1, 0};
+    int xor_sum = 0;
+    for(int i = 1; i <= n; i++)
+    {
+        for(int j = 1; j <= n; j++)
+        {
+            if(get_colour(i, j) != colour)
+            {
+                continue;
+            }
+
+            int counted_neighbours = 0;
+            for(int k = 0; k < NO_OF_NEIGHBOURS; k++)
+            {
+                int next_i = i + next_x[k], next_j = j + next_y[k];
+
+                if(is_inside(next_i, next_j, n, n) && counted[next_i][next_j])
+                {
+                    counted_neighbours++;
+                }
+            }
+
+            if(counted_neighbours == 0)
+            {
+                xor_sum ^= G[i][j];
+
+                for(int k = 0; k < NO_OF_NEIGHBOURS; k++)
+                {
+                    int next_i = i + next_x[k], next_j = j + next_y[k];
+
+                    if(is_inside(next_i, next_j, n, n))
+                    {
+                        counted[next_i][next_j] = true;
+                    }
+                }
+            }
+        }
+    }
+
+    return xor_sum;
+}
+
+void solve()
+{
+    int n;
+    cin >> n;
+
+    vector <vector <int> > grid(n + 1, vector <int> (n + 1, 0));
+    for(int i = 1; i <= n; i++)
+    {
+        for(int j = 1; j <= n; j++)
+        {
+            cin >> grid[i][j];
+        }
+    }
+
+    int answer = get_xor_sum(grid, n, BLACK)^get_xor_sum(grid, n, WHITE);
+    cout << answer << "\n";
+}
+
+int main()
+{
+    int no_of_test_cases;
+    cin >> no_of_test_cases;
+
+    while(no_of_test_cases--)
+        solve();
+
+    return 0;
+}