.

Author: DhruvPasricha

Practice/.cph/.Playing_with_digits.cpp_af9218bd9a1f01ac9c7fe321eb0081ed.prob

@@ -1 +1 @@
-{"name":"Playing with digits","group":"HackerEarth","url":"https://www.hackerearth.com/problem/algorithm/playing-with-digits-4e25844f/","interactive":false,"memoryLimit":256,"timeLimit":1000,"tests":[{"input":"5 86 4\n","output":"7\n","id":1618372966642}],"testType":"single","input":{"type":"stdin"},"output":{"type":"stdout"},"languages":{"java":{"mainClass":"Main","taskClass":"PlayingWithDigits"}},"batch":{"id":"2bfe465b-a194-49fb-b80b-5a0510776f00","size":1},"srcPath":"c:\\Users\\Dhruv\\myGithub\\Competitive-Programming\\Practice\\Playing_with_digits.cpp"}
+{"name":"Playing with digits","group":"HackerEarth","url":"https://www.hackerearth.com/problem/algorithm/playing-with-digits-4e25844f/","interactive":false,"memoryLimit":256,"timeLimit":1000,"tests":[{"id":1618372966642,"input":"5 86 4","output":"7"}],"testType":"single","input":{"type":"stdin"},"output":{"type":"stdout"},"languages":{"java":{"mainClass":"Main","taskClass":"PlayingWithDigits"}},"batch":{"id":"2bfe465b-a194-49fb-b80b-5a0510776f00","size":1},"srcPath":"c:\\Users\\Dhruv\\myGithub\\Competitive-Programming\\Practice\\Playing_with_digits.cpp"}

Practice/.cph/.Prime_Time.cpp_ed665d13b9c46eb50449a9f7f5ae8325.prob

@@ -0,0 +1 @@
+{"name":"Prime Time","group":"Google Coding Competitions - Round 1A 2021 - Code Jam 2021","url":"https://codingcompetitions.withgoogle.com/codejam/round/000000000043585d/00000000007543d8","interactive":false,"memoryLimit":1024,"timeLimit":45000,"tests":[{"id":1618375783450,"input":"4\n5\n2 2\n3 1\n5 2\n7 1\n11 1\n1\n17 2\n2\n2 2\n3 1\n1\n2 7","output":"Case #1: 25\nCase #2: 17\nCase #3: 0\nCase #4: 8"}],"testType":"multiNumber","input":{"type":"stdin"},"output":{"type":"stdout"},"languages":{"java":{"mainClass":"Solution","taskClass":"PrimeTime"}},"batch":{"id":"c2f72542-f2ad-4acf-b9d6-8f62b9f79036","size":1},"srcPath":"c:\\Users\\Dhruv\\myGithub\\Competitive-Programming\\Practice\\Prime_Time.cpp"}

Practice/CodeForces Edu/Segment Tree 1/.cph/.C_Number_of_Minimums_on_a_Segment.cpp_a9f7875e7850b7b52d1b8d39a50e1847.prob

@@ -0,0 +1 @@
+{"name":"C. Number of Minimums on a Segment","group":"Codeforces - ITMO Academy: pilot course - Segment Tree, part 1 - Step 1","url":"https://codeforces.com/edu/course/2/lesson/4/1/practice/contest/273169/problem/C","interactive":false,"memoryLimit":1024,"timeLimit":1000,"tests":[{"id":1618482535275,"input":"5 5\n3 4 3 5 2\n2 0 3\n1 1 2\n2 0 3\n1 0 2\n2 0 5","output":"3 2\n2 1\n2 3"}],"testType":"single","input":{"type":"stdin"},"output":{"type":"stdout"},"languages":{"java":{"mainClass":"Main","taskClass":"CNumberOfMinimumsOnASegment"}},"batch":{"id":"4e2fc343-76ce-4d64-a913-e1eb882a898c","size":1},"srcPath":"c:\\Users\\Dhruv\\myGithub\\Competitive-Programming\\Practice\\CodeForces Edu\\Segment Tree 1\\C_Number_of_Minimums_on_a_Segment.cpp"}

Practice/CodeForces Edu/Segment Tree 1/A_Segment_Tree_for_the_Sum.bin

@@ -18,171 +18,116 @@ using namespace std;
     int T;    \
     cin >> T; \
     while (T--)
-#define int long long int
+// #define int long long int
 #define mod 1000000007ll
 #define endl "\n"
-//------------------------------------------------------------------------------
-// Any fucntion can be called using Math.function_name();
-//------------------------------------------------------------------------------
-class Math
-{
-public:
-    //Returns gcd of two numbers
-    int gcd(int a, int b)
-    {
-        return (a % b == 0) ? b : gcd(b, a % b);
-    }
 
-    //Returns lcm of two numbers
-    int lcm(int a, int b)
-    {
-        return a * (b / gcd(a, b));
-    }
-
-    // Returns flag array isPrime
-    // isPrime[i] = true (if i is Prime)
-    // isPrime[i] = false (if i is not Prime)
-    vector<bool> *seiveOfEratosthenes(const int N)
-    {
-        vector<bool> *isPrime = new vector<bool>(N + 1, true);
-        (*isPrime)[0] = (*isPrime)[1] = false;
-        for (int i = 2; i * i <= N; ++i)
-            if ((*isPrime)[i])
-                for (int j = i * i; j <= N; j += i)
-                    (*isPrime)[j] = false;
-
-        return isPrime;
-    }
-
-    //Returns (x ^ n)
-    int pow(const int &x, int n)
-    {
-        if (n == 0)
-            return 1;
-        int h = pow(x, n / 2);
-        return (n & 1) ? h * h * x : h * h;
-    }
-
-    //Returns (x ^ n) % M
-    int pow(const int &x, int n, const int &M)
-    {
-        if (n == 0)
-            return 1;
-        int h = pow(x, n / 2) % M;
-        return (n & 1) ? (h * h * x) % M : (h * h) % M;
-    }
-
-    //Returns all Primes <= N
-    vector<int> *primesUptoN(const int N)
-    {
-        vector<bool> *isPrime = seiveOfEratosthenes(N);
-        vector<int> *Primes = new vector<int>;
-        if (2 <= N)
-            (*Primes).push_back(2);
-        for (int i = 3; i <= N; i += 2)
-            if ((*isPrime)[i])
-                (*Primes).push_back(i);
-        return Primes;
-    }
-
-} Math;
-//------------------------------------------------------------------------------
+struct Node
+{
+    int val = 0;
+};
 
-struct SegTree
+struct SegmentTree
 {
-    v(int) t;
+private:
+    v(Node) tree;
     int size;
+    Node neutralValue;
+    Node base;
 
-    int init = 0;
-
-    int f(int &a, int &b)
+    Node merge(Node &a, Node &b)
     {
-        return a + b;
-    }
-
-    SegTree(v(int) & A)
-    {
-        size = 1;
-        int n = A.size();
-        while (size < n)
-            size *= 2;
-        t.assign(2 * size, INT32_MAX);
-        build(A, 0, 0, size);
+        Node ans;
+        ans.val = a.val + b.val;
+        return ans;
     }
 
     void build(v(int) & A, int x, int lx, int rx)
     {
+
         if (rx - lx == 1)
         {
             if (lx < A.size())
-                t[x] = A[lx];
+            {
+                base.val = A[lx];
+                tree[x] = base;
+            }
             return;
         }
 
-        int m = (lx + rx) >> 1;
-
-        build(A, 2 * x + 1, lx, m);
-        build(A, 2 * x + 2, m, rx);
+        int mx = (lx + rx) >> 1;
+        build(A, (2 * x) + 1, lx, mx);
+        build(A, (2 * x) + 2, mx, rx);
 
-        t[x] = f(t[2 * x + 1], t[2 * x + 2]);
+        tree[x] = merge(tree[(2 * x) + 1], tree[(2 * x) + 2]);
     }
 
-    void set(int &i, int &v, int x, int lx, int rx)
+    void update(int &idx, int &val, int x, int lx, int rx)
     {
+
         if (rx - lx == 1)
         {
-            t[x] = v;
+            base.val = val;
+            tree[x] = base;
             return;
         }
 
-        int m = (lx + rx) >> 1;
+        int mx = (lx + rx) >> 1;
 
-        if (i < m)
-            set(i, v, 2 * x + 1, lx, m);
+        if (idx < mx)
+            update(idx, val, (2 * x) + 1, lx, mx);
         else
-            set(i, v, 2 * x + 2, m, rx);
+            update(idx, val, (2 * x) + 2, mx, rx);
 
-        t[x] = f(t[2 * x + 1], t[2 * x + 2]);
+        tree[x] = merge(tree[(2 * x) + 1], tree[(2 * x) + 2]);
     }
 
-    int query(int &l, int &r, int x, int lx, int rx)
+    Node query(int &l, int &r, int x, int lx, int rx)
     {
         if (lx >= r or l >= rx)
-            return init;
-
-        if (l <= lx and rx <= r)
-            return t[x];
+            return neutralValue;
 
-        int m = (lx + rx) >> 1;
+        if (rx - lx == 1)
+            return tree[x];
 
-        int ans1 = query(l, r, 2 * x + 1, lx, m);
-        int ans2 = query(l, r, 2 * x + 2, m, rx);
+        int mx = (lx + rx) >> 1;
+        Node ans1 = query(l, r, 2 * x + 1, lx, mx);
+        Node ans2 = query(l, r, 2 * x + 2, mx, rx);
+        Node ans = merge(ans1, ans2);
+        return ans;
+    }
 
-        return f(ans1, ans2);
+public:
+    SegmentTree(v(int) & A)
+    {
+        size = 1;
+        int n = A.size();
+        while (size < n)
+            size *= 2;
+        tree.assign((2 * size) + 1, neutralValue);
+        build(A, 0, 0, size);
     }
 
-    void set(int &i, int &v)
+    void update(int &idx, int &val)
     {
-        set(i, v, 0, 0, size);
+        update(idx, val, 0, 0, size);
     }
 
-    int query(int &l, int &r)
+    Node query(int &l, int &r)
     {
         return query(l, r, 0, 0, size);
     }
 };
 
+//------------------------------------------------------------------------------
 void solve()
 {
     int n, q;
     cin >> n >> q;
-
     v(int) A(n);
-    for (int &x : A)
-        cin >> x;
-
-    SegTree st(A);
-
+    for (int i = 0; i < n; i++)
+        cin >> A[i];
+    SegmentTree st(A);
     while (q--)
     {
         int op;
@@ -192,13 +137,14 @@ void solve()
         {
             int i, v;
             cin >> i >> v;
-            st.set(i, v);
+            st.update(i, v);
         }
         else
         {
             int l, r;
             cin >> l >> r;
-            cout << st.query(l, r) << endl;
+            Node ans = st.query(l, r);
+            cout << ans.val << endl;
         }
     }
 }