From a75af5325436cdafd28baaf454a708da0ed91350 Mon Sep 17 00:00:00 2001 From: Sakshi Arora <59931342+iam-sakshi@users.noreply.github.com> Date: Sat, 27 Nov 2021 13:24:50 +0530 Subject: [PATCH 1/8] Competitive programming (#8) * Merge two arrays according to constraints added. * Create MagicNumber.md * Rename MagicNumber.md to NthMagicNumber.md * header file and heading added. * Rename Competitive_Programming/Python/Maths & Number Theory/MagicNumber/NthMagicNumber.md to Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber/NthMagicNumber.md Co-authored-by: BootLook <73538645+priyankapiba@users.noreply.github.com> Co-authored-by: Jinal4502 <65852362+Jinal4502@users.noreply.github.com> Co-authored-by: Ahana Pal <59911272+ErzaTitania-2001@users.noreply.github.com> --- .../C++/Array/Merge-two-arrays.md | 106 ++++++++++++++++++ .../NthMagicNumber/NthMagicNumber.md | 66 +++++++++++ 2 files changed, 172 insertions(+) create mode 100644 Competitive_Programming/C++/Array/Merge-two-arrays.md create mode 100644 Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber/NthMagicNumber.md diff --git a/Competitive_Programming/C++/Array/Merge-two-arrays.md b/Competitive_Programming/C++/Array/Merge-two-arrays.md new file mode 100644 index 0000000000..80d0fc3846 --- /dev/null +++ b/Competitive_Programming/C++/Array/Merge-two-arrays.md @@ -0,0 +1,106 @@ +# Merge two arrays by satisfying given constraints +Given two sorted arrays X[] and Y[] of size m and n each where m >= n and X[] has exactly n vacant cells, merge elements of Y[] in their correct position in array X[], i.e., merge (X, Y) by keeping the sorted order. + +For example, + +## Input: + +X[] = { 0, 2, 0, 3, 0, 5, 6, 0, 0 } +Y[] = { 1, 8, 9, 10, 15 } + +The vacant cells in X[] is represented by 0 + +## Output: + +X[] = { 1, 2, 3, 5, 6, 8, 9, 10, 15 } + +## Approach: +The idea is simple – move non-empty elements of X[] at the beginning of X[] and then merge X[] with Y[] starting from the end. The merge process is similar to the merge routine of the merge sort algorithm. + +## Code: +``` Cpp +#include= 0 && n >= 0) + { + // put the next greater element in the next free position in `X[]` from the end + if (X[m] > Y[n]) { + X[k--] = X[m--]; + } + else { + X[k--] = Y[n--]; + } + } + + // copy the remaining elements of `Y[]` (if any) to `X[]` + while (n >= 0) { + X[k--] = Y[n--]; + } + + // fill `Y[]` with all zeroes + for (int i = 0; i < n; i++) { + Y[i] = 0; + } +} + +// The function moves non-empty elements in `X[]` in the +// beginning and then merge them with `Y[]` +void rearrange(int X[], int Y[], int m, int n) +{ + // return if `X` is empty + if (m == 0) { + return; + } + + // moves non-empty elements of `X[]` at the beginning + int k = 0; + for (int i = 0; i < m; i++) + { + if (X[i] != 0) { + X[k++] = X[i]; + } + } + + // merge `X[0 … k-1]` and `Y[0 … n-1]` into `X[0 … m-1]` + merge(X, Y, k - 1, n - 1); +} + +int main() +{ + // vacant cells in `X[]` is represented by 0 + int X[] = { 0, 2, 0, 3, 0, 5, 6, 0, 0 }; + int Y[] = { 1, 8, 9, 10, 15 }; + + int m = sizeof(X) / sizeof(X[0]); + int n = sizeof(Y) / sizeof(Y[0]); + + /* Validate input before calling `rearrange()` + 1. Both arrays `X[]` and `Y[]` should be sorted (ignore 0's in `X[]`) + 2. Size of array `X[]` >= size of array `Y[]` (i.e., `m >= n`) + 3. Total number of vacant cells in array `X[]` = size of array `Y[]` */ + + // merge `Y[]` into `X[]` + rearrange(X, Y, m, n); + + // print merged array + for (int i = 0; i < m; i++) { + printf("%d ", X[i]); + } + + return 0; +} +``` + +## Output: + +1 2 3 5 6 8 9 10 15 + +## Time Complexity +Time complexity of the above solution is O(m + n) and runs in constant space. Here, m and n are the size of the first and second array, respectively. diff --git a/Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber/NthMagicNumber.md b/Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber/NthMagicNumber.md new file mode 100644 index 0000000000..055d512092 --- /dev/null +++ b/Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber/NthMagicNumber.md @@ -0,0 +1,66 @@ +# Nth Magic Number + +A number that can be represented as a power of 5 or sum of unique powers of 5 is called a magic number. + +Initial magic numbers are: + +5, 25, 30(5+25), 125, 130(5+125), 150(25 + 125), 155(5+25+125), 625, 630(5+625), 650(25+625), 655(5+25+625), 750(125+625), 755(5+125+625), 775(25+125+625), 780(5+25+125+625), 3125, .... + +| value of n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | +|------------------|---|----|----|-----|-----|-----|-----|-----|-----|-----| +| nth magic number | 5 | 25 | 30 | 125 | 130 | 150 | 155 | 625 | 630 | 650 | + + +Also, for n-values can be represented in binary as 0001(1), 0010(2), 0011(3), 0100(4), 0101(5), ... + +| value of n | 0001 | 0010 | 0011 | 0100 | 0101 | 0110 | 0111 | 1000 | 1001 | 1010 | +|------------------|------|------|------|------|------|------|------|------|------|------| +| nth magic number | 5 | 25 | 30 | 125 | 130 | 150 | 155 | 625 | 630 | 650 | + +For example, take n = 0011 i.e. n = 3, so we can get the nth magic number in this way, + +``` +0*pow(5,4) + 0*pow(5,3) + 1*pow(5,2) + 1*pow(5,1) += 0 + 0 + 25 + 5 += 30 +``` + +## Implementation in Python: + +```Python3 +def magic_number(n): + + temp = 1 + nth_magic_num = 0 + + # Continue till all the bits of n are not zero + while (n): + + temp = temp*5 + + # if the rightmost bit of n is 1 + if (n & 1): + nth_magic_num += temp + + # right-shift by one bit i.e. it will return half of a given number + # example: + # 5 -> 0101 + # 5 >>=1 -> 0010 -> 2 + # or 5 // 2 = 2 + n >>= 1 # or n = n//2 + + return nth_magic_num + + +# Input function +n = 7 +print(f"{n}th magic number is {magic_number(n)}.") +``` + +### Output: + +7th magic number is 155. + +## Time Complexity: + +The time complexity of this algorithm will be O(logn) as everytime we reduce the number by a factor of 2. From 322bc4805bf241c7889c5d894621b1caf768fb00 Mon Sep 17 00:00:00 2001 From: Sakshi Arora <59931342+iam-sakshi@users.noreply.github.com> Date: Sat, 27 Nov 2021 15:16:17 +0530 Subject: [PATCH 2/8] Competitive programming (#10) * Merge two arrays according to constraints added. * Create MagicNumber.md * Rename MagicNumber.md to NthMagicNumber.md * header file and heading added. * Rename Competitive_Programming/Python/Maths & Number Theory/MagicNumber/NthMagicNumber.md to Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber/NthMagicNumber.md Co-authored-by: BootLook <73538645+priyankapiba@users.noreply.github.com> Co-authored-by: Jinal4502 <65852362+Jinal4502@users.noreply.github.com> Co-authored-by: Ahana Pal <59911272+ErzaTitania-2001@users.noreply.github.com> From 9f05397b9004a182efc1ad9a2896058f927ea8db Mon Sep 17 00:00:00 2001 From: Sakshi Arora <59931342+iam-sakshi@users.noreply.github.com> Date: Sat, 27 Nov 2021 15:18:49 +0530 Subject: [PATCH 3/8] Delete Merge-two-arrays.md --- .../C++/Array/Merge-two-arrays.md | 106 ------------------ 1 file changed, 106 deletions(-) delete mode 100644 Competitive_Programming/C++/Array/Merge-two-arrays.md diff --git a/Competitive_Programming/C++/Array/Merge-two-arrays.md b/Competitive_Programming/C++/Array/Merge-two-arrays.md deleted file mode 100644 index 80d0fc3846..0000000000 --- a/Competitive_Programming/C++/Array/Merge-two-arrays.md +++ /dev/null @@ -1,106 +0,0 @@ -# Merge two arrays by satisfying given constraints -Given two sorted arrays X[] and Y[] of size m and n each where m >= n and X[] has exactly n vacant cells, merge elements of Y[] in their correct position in array X[], i.e., merge (X, Y) by keeping the sorted order. - -For example, - -## Input: - -X[] = { 0, 2, 0, 3, 0, 5, 6, 0, 0 } -Y[] = { 1, 8, 9, 10, 15 } - -The vacant cells in X[] is represented by 0 - -## Output: - -X[] = { 1, 2, 3, 5, 6, 8, 9, 10, 15 } - -## Approach: -The idea is simple – move non-empty elements of X[] at the beginning of X[] and then merge X[] with Y[] starting from the end. The merge process is similar to the merge routine of the merge sort algorithm. - -## Code: -``` Cpp -#include= 0 && n >= 0) - { - // put the next greater element in the next free position in `X[]` from the end - if (X[m] > Y[n]) { - X[k--] = X[m--]; - } - else { - X[k--] = Y[n--]; - } - } - - // copy the remaining elements of `Y[]` (if any) to `X[]` - while (n >= 0) { - X[k--] = Y[n--]; - } - - // fill `Y[]` with all zeroes - for (int i = 0; i < n; i++) { - Y[i] = 0; - } -} - -// The function moves non-empty elements in `X[]` in the -// beginning and then merge them with `Y[]` -void rearrange(int X[], int Y[], int m, int n) -{ - // return if `X` is empty - if (m == 0) { - return; - } - - // moves non-empty elements of `X[]` at the beginning - int k = 0; - for (int i = 0; i < m; i++) - { - if (X[i] != 0) { - X[k++] = X[i]; - } - } - - // merge `X[0 … k-1]` and `Y[0 … n-1]` into `X[0 … m-1]` - merge(X, Y, k - 1, n - 1); -} - -int main() -{ - // vacant cells in `X[]` is represented by 0 - int X[] = { 0, 2, 0, 3, 0, 5, 6, 0, 0 }; - int Y[] = { 1, 8, 9, 10, 15 }; - - int m = sizeof(X) / sizeof(X[0]); - int n = sizeof(Y) / sizeof(Y[0]); - - /* Validate input before calling `rearrange()` - 1. Both arrays `X[]` and `Y[]` should be sorted (ignore 0's in `X[]`) - 2. Size of array `X[]` >= size of array `Y[]` (i.e., `m >= n`) - 3. Total number of vacant cells in array `X[]` = size of array `Y[]` */ - - // merge `Y[]` into `X[]` - rearrange(X, Y, m, n); - - // print merged array - for (int i = 0; i < m; i++) { - printf("%d ", X[i]); - } - - return 0; -} -``` - -## Output: - -1 2 3 5 6 8 9 10 15 - -## Time Complexity -Time complexity of the above solution is O(m + n) and runs in constant space. Here, m and n are the size of the first and second array, respectively. From c7ed738ccffdc5cfaa347def24b805c3ab20c8c1 Mon Sep 17 00:00:00 2001 From: Sakshi Arora <59931342+iam-sakshi@users.noreply.github.com> Date: Sat, 27 Nov 2021 15:19:54 +0530 Subject: [PATCH 4/8] Delete Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber directory --- .../NthMagicNumber/NthMagicNumber.md | 66 ------------------- 1 file changed, 66 deletions(-) delete mode 100644 Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber/NthMagicNumber.md diff --git a/Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber/NthMagicNumber.md b/Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber/NthMagicNumber.md deleted file mode 100644 index 055d512092..0000000000 --- a/Competitive_Programming/Python/Maths & Number Theory/NthMagicNumber/NthMagicNumber.md +++ /dev/null @@ -1,66 +0,0 @@ -# Nth Magic Number - -A number that can be represented as a power of 5 or sum of unique powers of 5 is called a magic number. - -Initial magic numbers are: - -5, 25, 30(5+25), 125, 130(5+125), 150(25 + 125), 155(5+25+125), 625, 630(5+625), 650(25+625), 655(5+25+625), 750(125+625), 755(5+125+625), 775(25+125+625), 780(5+25+125+625), 3125, .... - -| value of n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -|------------------|---|----|----|-----|-----|-----|-----|-----|-----|-----| -| nth magic number | 5 | 25 | 30 | 125 | 130 | 150 | 155 | 625 | 630 | 650 | - - -Also, for n-values can be represented in binary as 0001(1), 0010(2), 0011(3), 0100(4), 0101(5), ... - -| value of n | 0001 | 0010 | 0011 | 0100 | 0101 | 0110 | 0111 | 1000 | 1001 | 1010 | -|------------------|------|------|------|------|------|------|------|------|------|------| -| nth magic number | 5 | 25 | 30 | 125 | 130 | 150 | 155 | 625 | 630 | 650 | - -For example, take n = 0011 i.e. n = 3, so we can get the nth magic number in this way, - -``` -0*pow(5,4) + 0*pow(5,3) + 1*pow(5,2) + 1*pow(5,1) -= 0 + 0 + 25 + 5 -= 30 -``` - -## Implementation in Python: - -```Python3 -def magic_number(n): - - temp = 1 - nth_magic_num = 0 - - # Continue till all the bits of n are not zero - while (n): - - temp = temp*5 - - # if the rightmost bit of n is 1 - if (n & 1): - nth_magic_num += temp - - # right-shift by one bit i.e. it will return half of a given number - # example: - # 5 -> 0101 - # 5 >>=1 -> 0010 -> 2 - # or 5 // 2 = 2 - n >>= 1 # or n = n//2 - - return nth_magic_num - - -# Input function -n = 7 -print(f"{n}th magic number is {magic_number(n)}.") -``` - -### Output: - -7th magic number is 155. - -## Time Complexity: - -The time complexity of this algorithm will be O(logn) as everytime we reduce the number by a factor of 2. From 6ef87fb8e43bc2b9a0fa34e8d1ed5f9689ae3c83 Mon Sep 17 00:00:00 2001 From: Sakshi Arora <59931342+iam-sakshi@users.noreply.github.com> Date: Sat, 27 Nov 2021 15:21:51 +0530 Subject: [PATCH 5/8] Create TopKthFrequentElement.md --- .../C++/Heap/TopKthFrequentElement.md | 121 ++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 Competitive_Programming/C++/Heap/TopKthFrequentElement.md diff --git a/Competitive_Programming/C++/Heap/TopKthFrequentElement.md b/Competitive_Programming/C++/Heap/TopKthFrequentElement.md new file mode 100644 index 0000000000..a785997ba2 --- /dev/null +++ b/Competitive_Programming/C++/Heap/TopKthFrequentElement.md @@ -0,0 +1,121 @@ +# Top K Frequent Elements + +## Brute Force Approach +- In this the brute force approach, first form a map to keep the record of the frequency of each element. +- then store the map values to the vector in the form of pair that is vector< pair > . +- sort the vector in decreasing order of frequency. +-now the first k elements of the sorted array , are the required result. + +```c++ + //c++ + #include + + using namespace std; + typedef pair < int, int > pi; + + bool compare(pi p1, pi p2) { + if (p1.second == p2.second) + return p1.first > p2.first; + return p1.second > p2.second; + } + + vector < int > topKFrequent(vector < int > nums, int k) { + int n = nums.size(); + vector < int > r; + unordered_map < int, int > m; + for (int i = 0; i < n; i++) + m[arr[i]]++; + vector < pi > tmp(m.begin(), m.end()); + sort(tmp.begin(), tmp.end(), compare); + for (int i = 0; i < k; i++) { + r.push_back(tmp[i].first); + + } + } + + int main() { + vector < int > v = { 1, 1, 1, 2, 2, 2, 3 }; + int k = 2; + vector < int > r; + r = topKFrequent(v, k); + for (auto e: r) { + cout << e << " "; + } + return 0; + } +``` +>OUTPUT: +> +> 1 2 +> + +> +>*Time Complexity* +> +>*O(d log d)* + + where d is the count of distinct elements in the vector/array. +In the brute force approach we are maintaining a map with its frequency count . +and then we are iterating to each element of the map and +then create a vector that has **all the elements** and then from that map, +we are printing starting k elements. + +by creating a vector with all the elements in their decreasing frequency is the extra work done in brute force. + +So heap can be used to maintain only k size for maintaining frequency and element , this will save time as it is not doing extra work. + +## The Optimize approach is to use heap, + +- after forming a map, we can insert the pair of the frequency and the element in the min heap. +- the element at the bottom will be the answer of the top k elements. +- by this method it will take O(k log d) complexity. +where d is the count of distinct elements in the vector/array. +```c++ + //c++ + #include + + using namespace std; + typedef pair < int, int > pi; + + vector < int > topKFrequent(vector < int > nums, int k) { + priority_queue < pi, vector < pi > , greater < pi >> pr; + unordered_map < int, int > mp; + for (auto nm: nums) { + mp[nm]++; + } + vector < int > r; + for (auto m: mp) { + pr.push({ + m.second, + m.first + }); + if (pr.size() > k) + pr.pop(); + } + while (pr.size() > 0) { + r.push_back(pr.top().second); + pr.pop(); + } + return r; + } + + int main() { + vector < int > v = { 1, 1, 1, 2, 2, 2, 3}; + int k = 2; + vector < int > r; + r = topKFrequent(v, k); + for (auto e: r) { + cout << e << " "; + } + return 0; + } +``` +>OUTPUT: +> +> 1 2 +> + +> +>*Time Complexity* +> +>*O(k log d)* From 39a05e2a618d0b2b1d85a3c234be1a453c505def Mon Sep 17 00:00:00 2001 From: Sakshi Arora <59931342+iam-sakshi@users.noreply.github.com> Date: Sun, 28 Nov 2021 00:39:02 +0530 Subject: [PATCH 6/8] Create TLE.md --- .../C++/Time Limit Exceeded Error/TLE.md | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 Competitive_Programming/C++/Time Limit Exceeded Error/TLE.md diff --git a/Competitive_Programming/C++/Time Limit Exceeded Error/TLE.md b/Competitive_Programming/C++/Time Limit Exceeded Error/TLE.md new file mode 100644 index 0000000000..5ea7df0475 --- /dev/null +++ b/Competitive_Programming/C++/Time Limit Exceeded Error/TLE.md @@ -0,0 +1,81 @@ +# TLE - Time Limit Exceeded Error + +In CP, we face this error when the code submitted takes more time to execute than accepted. There are few assumptions made by C++ programmer which is not true. + +1. Header File + + ``` c++ + #include + using namespace std; + +``` + +normally you find this on the top of the code of c++ coders. is a very large header file . +It has all the headers that one could need for CP in it but also have many other headers that take more compilation time. +This would not effect Time execution online but it should be avoided if we want a very efficient solution. + +2. The best method to avoid TLE is to work more on bits than on operators or prebuild functions + +like: + +**for swapping two numbers** +```c++ + +//for swapping two numbers +a^=b +b^=a +a^=b + +``` + **for determing if a number is even or odd** +```c++ + +// for determining if a number is even or odd +if(number & 1) + cout<<"number is odd"; +else + cout<<"number is even"; + +``` + +**for multiplication a number with 2^n** +```c++ + +//for multiplication of a number with 2^n +number<>n; + +``` + +**check if a number is a power of 2** + +```c++ + +bool isPowerOf2( int n ) +{ + return ( n && (!(n & ( n-1 ) ) ); + } + +``` + +3. Input Output + +In C++, scanf and printf work faster than cin and cout this happens due to synchronization. +So if we don't want to use scanf and printf in C++. we should turn off the synchronization. + +```c++ + +ios_base :: sync_with_stdio(false); + +``` +4. Time Space Trade + If we want less time , we can increase the space it might help in reducing the space similarly, + if we wish to use less space than time might increase. + + These are some observations and tricks to save yourself from TLE error. From 7aae5e8eaecea6983cec4f7f053eb70165b79a87 Mon Sep 17 00:00:00 2001 From: Sakshi Arora <59931342+iam-sakshi@users.noreply.github.com> Date: Sun, 28 Nov 2021 00:42:55 +0530 Subject: [PATCH 7/8] Delete TopKthFrequentElement.md --- .../C++/Heap/TopKthFrequentElement.md | 121 ------------------ 1 file changed, 121 deletions(-) delete mode 100644 Competitive_Programming/C++/Heap/TopKthFrequentElement.md diff --git a/Competitive_Programming/C++/Heap/TopKthFrequentElement.md b/Competitive_Programming/C++/Heap/TopKthFrequentElement.md deleted file mode 100644 index a785997ba2..0000000000 --- a/Competitive_Programming/C++/Heap/TopKthFrequentElement.md +++ /dev/null @@ -1,121 +0,0 @@ -# Top K Frequent Elements - -## Brute Force Approach -- In this the brute force approach, first form a map to keep the record of the frequency of each element. -- then store the map values to the vector in the form of pair that is vector< pair > . -- sort the vector in decreasing order of frequency. --now the first k elements of the sorted array , are the required result. - -```c++ - //c++ - #include - - using namespace std; - typedef pair < int, int > pi; - - bool compare(pi p1, pi p2) { - if (p1.second == p2.second) - return p1.first > p2.first; - return p1.second > p2.second; - } - - vector < int > topKFrequent(vector < int > nums, int k) { - int n = nums.size(); - vector < int > r; - unordered_map < int, int > m; - for (int i = 0; i < n; i++) - m[arr[i]]++; - vector < pi > tmp(m.begin(), m.end()); - sort(tmp.begin(), tmp.end(), compare); - for (int i = 0; i < k; i++) { - r.push_back(tmp[i].first); - - } - } - - int main() { - vector < int > v = { 1, 1, 1, 2, 2, 2, 3 }; - int k = 2; - vector < int > r; - r = topKFrequent(v, k); - for (auto e: r) { - cout << e << " "; - } - return 0; - } -``` ->OUTPUT: -> -> 1 2 -> - -> ->*Time Complexity* -> ->*O(d log d)* - - where d is the count of distinct elements in the vector/array. -In the brute force approach we are maintaining a map with its frequency count . -and then we are iterating to each element of the map and -then create a vector that has **all the elements** and then from that map, -we are printing starting k elements. - -by creating a vector with all the elements in their decreasing frequency is the extra work done in brute force. - -So heap can be used to maintain only k size for maintaining frequency and element , this will save time as it is not doing extra work. - -## The Optimize approach is to use heap, - -- after forming a map, we can insert the pair of the frequency and the element in the min heap. -- the element at the bottom will be the answer of the top k elements. -- by this method it will take O(k log d) complexity. -where d is the count of distinct elements in the vector/array. -```c++ - //c++ - #include - - using namespace std; - typedef pair < int, int > pi; - - vector < int > topKFrequent(vector < int > nums, int k) { - priority_queue < pi, vector < pi > , greater < pi >> pr; - unordered_map < int, int > mp; - for (auto nm: nums) { - mp[nm]++; - } - vector < int > r; - for (auto m: mp) { - pr.push({ - m.second, - m.first - }); - if (pr.size() > k) - pr.pop(); - } - while (pr.size() > 0) { - r.push_back(pr.top().second); - pr.pop(); - } - return r; - } - - int main() { - vector < int > v = { 1, 1, 1, 2, 2, 2, 3}; - int k = 2; - vector < int > r; - r = topKFrequent(v, k); - for (auto e: r) { - cout << e << " "; - } - return 0; - } -``` ->OUTPUT: -> -> 1 2 -> - -> ->*Time Complexity* -> ->*O(k log d)* From d63c068b144fedc1ffa361f283a678b98a7594ea Mon Sep 17 00:00:00 2001 From: Sakshi Arora <59931342+iam-sakshi@users.noreply.github.com> Date: Sun, 28 Nov 2021 23:09:52 +0530 Subject: [PATCH 8/8] Competitive programming (#13) updated