Merge pull request #55 from rachitiitr/youtube_live

youtube_live - medium problems speedrun

Discord: https://bit.ly/discord-rachit
Here's the link to the livestream: https://bit.ly/3iJdosx

https://leetcode.com/problems/minimum-number-of-operations-to-move-all-balls-to-each-box/
https://leetcode.com/problems/deepest-leaves-sum
https://leetcode.com/problems/group-the-people-given-the-group-size-they-belong-to/
https://leetcode.com/problems/queries-on-a-permutation-with-key/

Author: rachitiitr

LeetCode/1282.group-the-people-given-the-group-size-they-belong-to.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    vector<vector<int>> groupThePeople(vector<int>& groupSizes) {
+        int n = groupSizes.size();
+        unordered_map<int, vector<int>> peopleInGroupSize = {};
+        for(int i = 0; i < n; i++) {
+            int curSize = groupSizes[i];
+            peopleInGroupSize[curSize].push_back(i);
+        }
+        vector<vector<int>> ans = {};
+        for(auto [groupSize, people]: peopleInGroupSize) {
+            // start making groups of |groupSize|
+            vector<int> cur = {};
+            for(int i = 0; i < people.size(); i++) {
+                cur.push_back(people[i]);
+                if ( cur.size() == groupSize) {
+                    ans.push_back(cur);
+                    cur = {};
+                }
+            }
+        }
+        return ans;
+    }
+};
+/*
+[group_size] --> [ids of people in it]
+[3] --> [0,1,2,3,4,6]
+[1] --> [5]
+    */

LeetCode/1302.deepest-leaves-sum.cpp

@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+    pair<int, int> getDepthAndSum(TreeNode* root) {
+        if (root == NULL) return {0, 0};
+        if (root->left == NULL and root->right == NULL)
+            return {1, root->val};
+        
+        auto [left_depth, left_sum] = getDepthAndSum(root->left);
+        auto [right_depth, right_sum] = getDepthAndSum(root->right);
+        
+        if (left_depth == right_depth)
+            return {1 + left_depth, left_sum + right_sum};
+        if (left_depth > right_depth)
+            return {1 + left_depth, left_sum};
+        return {1 + right_depth, right_sum};
+    }
+public:
+    int deepestLeavesSum(TreeNode* root) {
+        return getDepthAndSum(root).second;
+    }
+};

LeetCode/1409.queries-on-a-permutation-with-key.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    vector<int> processQueries(vector<int>& queries, int m) {
+        unordered_map<int, int> pos, rev_pos; // pos[3] - 10 => 3 occurs at index 10
+        for(int i = 1; i <= m; i++) {
+            pos[i] = i-1, rev_pos[i-1] = i;
+        }
+        
+        vector<int> ans = {};
+        for(int q: queries) {
+            ans.push_back(pos[q]);
+            // increment the pos of all nos from 0 to pos[q]-1
+            for (int i = pos[q]-1 ; i >= 0; i--) {
+                int cur = rev_pos[i];
+                pos[cur] = i+1; // shift to right side
+                rev_pos[i+1] = cur;
+            }
+            pos[q] = 0;
+            rev_pos[0] = q;
+        }
+        return ans;
+    }
+};
+// 1,2,3,4,5
+// 3,1,2,4,5
+
+// _ _ _ _ _ _ _ _ _ _ _ 
+          // ^ 

LeetCode/1769.minimum-number-of-operations-to-move-all-balls-to-each-box.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+    vector<int> minOperations(string boxes) {
+        int n = boxes.size();
+        int left_cnt = 0, tot_cnt = 0; // cnt of 1s
+        int left_sum = 0, tot_sum = 0; // sum of indices where its a 1
+        
+        
+        for(int i = 0; i < n; i++) {
+            if (boxes[i] == '1') tot_cnt++, tot_sum += i;    
+        }
+        
+        vector<int> ans = {};
+        for(int i = 0; i < n; i++) {
+            int right_cnt = tot_cnt - left_cnt;
+            int right_sum = tot_sum - left_sum;
+            
+            int left = left_cnt * i - left_sum;
+            int right = right_sum - right_cnt * i;
+            ans.push_back(left + right);
+            
+            if (boxes[i] == '1') left_cnt++, left_sum += i;
+        }  
+        return ans;
+    }
+};
+
+
+/*
+i=13
+j<13
+i-j1 + i-j2 => 2*i - (j1+j2)
+
+j>13
+j1-i + j2-i => (j1+j2) - 2 *(i)
+*/
+