├── .github └── ISSUE_TEMPLATE │ └── feature_request.md ├── .gitignore ├── Cpp ├── Arrays │ ├── Examples │ │ └── spiral-order-matrix-i.cpp │ ├── Primers │ │ └── arraybug.cpp │ └── Problems │ │ ├── add-one-to-number.cpp │ │ ├── anti-diagonals.cpp │ │ ├── find-duplicate-in-array.cpp │ │ ├── find-permutation.cpp │ │ ├── first-missing-integer.cpp │ │ ├── flip.cpp │ │ ├── kth-row-of-pascals-triangle.cpp │ │ ├── largest-number.cpp │ │ ├── max-distance.cpp │ │ ├── max-non-negative-subarray.cpp │ │ ├── max-sum-contiguous-subarray.cpp │ │ ├── maximum-absolute-difference.cpp │ │ ├── maximum-consecutive-gap.cpp │ │ ├── maximum-special-product.cpp │ │ ├── maximum-unsorted-subarray.cpp │ │ ├── merge-intervals.cpp │ │ ├── merge-overlapping-intervals.cpp │ │ ├── min-steps-in-infinite-grid.cpp │ │ ├── n3-repeat-number.cpp │ │ ├── next-permutation.cpp │ │ ├── noble-integer.cpp │ │ ├── pascal-triangle.cpp │ │ ├── repeat-and-missing-number-array.cpp │ │ ├── rotate-matrix.cpp │ │ ├── set-matrix-zeros.cpp │ │ ├── spiral-order-matrix-ii.cpp │ │ └── wave-array.cpp ├── Backtracking │ ├── Examples │ │ ├── modular-expression.cpp │ │ └── reverse-link-list-recursion.cpp │ └── Problems │ │ ├── combination-sum-ii.cpp │ │ ├── combination-sum.cpp │ │ ├── combinations.cpp │ │ ├── generate-all-parentheses-ii.cpp │ │ ├── gray-code.cpp │ │ ├── letter-phone.cpp │ │ ├── palindrome-partitioning.cpp │ │ ├── permutations.cpp │ │ ├── subset.cpp │ │ └── subsets-ii.cpp ├── Binary-Search │ ├── allocate-books.cpp │ ├── implement-power-function.cpp │ ├── matrix-median.cpp │ ├── matrix-search.cpp │ ├── painters-partition-problem.cpp │ ├── rotated-sorted-array-search.cpp │ ├── search-for-a-range.cpp │ ├── sorted-insert-position.cpp │ └── square-root-of-integer.cpp ├── Bit-Manipulation │ ├── different-bits-sum-pairwise.cpp │ ├── divide-integers.cpp │ ├── min-xor-value.cpp │ ├── number-of-1-bits.cpp │ ├── reverse-bits.cpp │ ├── single-number-ii.cpp │ └── single-number.cpp ├── Checkpoints │ └── Level3 │ │ └── prettyprint.cpp ├── Hashing │ ├── 2-sum.cpp │ ├── 4-sum.cpp │ ├── anagrams.cpp │ ├── colorful-number.cpp │ ├── copy-list.cpp │ ├── diffk-ii.cpp │ ├── largest-continuous-sequence-zero-sum.cpp │ ├── longest-substring-without-repeat.cpp │ ├── points-on-the-straight-line.cpp │ └── valid-sudoku.cpp ├── Heaps-And-Maps │ └── magician-and-chocolates.cpp ├── Linked-Lists │ ├── Examples │ │ ├── intersection-of-linked-lists.cpp │ │ └── reverse-linked-list.cpp │ └── Problems │ │ ├── add-two-numbers-as-lists.cpp │ │ ├── insertion-sort-list.cpp │ │ ├── k-reverse-linked-list.cpp │ │ ├── list-cycle.cpp │ │ ├── merge-two-sorted-lists.cpp │ │ ├── palindrome-list.cpp │ │ ├── partition-list.cpp │ │ ├── remove-duplicates-from-sorted-list-ii.cpp │ │ ├── remove-duplicates-from-sorted-list.cpp │ │ ├── remove-nth-node-from-list-end.cpp │ │ ├── reorder-list.cpp │ │ ├── reverse-link-list-ii.cpp │ │ ├── rotate-list.cpp │ │ ├── sort-list.cpp │ │ └── swap-list-nodes-in-pairs.cpp ├── Math │ ├── Examples │ │ ├── all-factors.cpp │ │ ├── binary-representation.cpp │ │ ├── prime-numbers.cpp │ │ └── verify-prime.cpp │ ├── MathBugs │ │ ├── mathbug01.cpp │ │ └── mathbug02.cpp │ └── Problems │ │ ├── city-tour.cpp │ │ ├── excel-column-number.cpp │ │ ├── excel-column-title.cpp │ │ ├── fizzbuzz.cpp │ │ ├── greatest-common-divisor.cpp │ │ ├── grid-unique-paths.cpp │ │ ├── largest-coprime-divisor.cpp │ │ ├── numbers-of-length-n-and-value-less-than-k.cpp │ │ ├── palindrome-integer.cpp │ │ ├── power-of-two-integers.cpp │ │ ├── prime-sum.cpp │ │ ├── rearrange-array.cpp │ │ ├── reverse-integer.cpp │ │ ├── sorted-permutation-rank-with-repeats.cpp │ │ ├── sorted-permutation-ranks.cpp │ │ ├── sum-of-pairwise-hamming-distance.cpp │ │ └── trailing-zeros-in-factorial.cpp ├── Stacks-and-Queues │ ├── Examples │ │ ├── generate-all-parentheses.cpp │ │ └── reverse-string.cpp │ └── Problems │ │ ├── evaluate-expression.cpp │ │ ├── largest-rectangle-in-histogram.cpp │ │ ├── min-stack.cpp │ │ ├── nearest-smaller-element.cpp │ │ ├── rain-water-trapped.cpp │ │ ├── redundant-braces.cpp │ │ └── simplify-directory-path.cpp ├── Strings │ ├── .justified-text.cpp.swp │ ├── add-binary-strings.cpp │ ├── amazing-subarrays.cpp │ ├── atoi.cpp │ ├── compare-version-numbers.cpp │ ├── count-and-say.cpp │ ├── implement-strstr.cpp │ ├── integer-to-roman.cpp │ ├── justified-text.cpp │ ├── length-of-last-word.cpp │ ├── longest-common-prefix.cpp │ ├── longest-palindromic-substring.cpp │ ├── minimum-characters-required-to-make-a-string-palindromic.cpp │ ├── multiply-strings.cpp │ ├── palindrome-string.cpp │ ├── power-of-2.cpp │ ├── pretty-json.cpp │ ├── reverse-the-string.cpp │ ├── roman-to-integer.cpp │ ├── stringoholics.cpp │ ├── valid-ip-addresses.cpp │ ├── valid-number.cpp │ └── zigzag-string.cpp ├── Trees │ ├── Examples │ │ └── next-greater-number-bst.cpp │ └── Problems │ │ ├── 2sum-binary-tree.cpp │ │ ├── balanced-binary-tree.cpp │ │ ├── binary-tree-from-inorder-and-postorder.cpp │ │ ├── bst-iterator.cpp │ │ ├── construct-binary-tree-from-inorder-and-preorder.cpp │ │ ├── flatten-binary-tree-to-linked-list.cpp │ │ ├── hotel-reviews.cpp │ │ ├── identical-binary-trees.cpp │ │ ├── inorder-traversal-of-cartesian-tree.cpp │ │ ├── inorder-traversal.cpp │ │ ├── invert-the-binary-tree.cpp │ │ ├── kth-smallest-element-in-tree.cpp │ │ ├── least-common-ancestor.cpp │ │ ├── max-depth-of-binary-tree.cpp │ │ ├── min-depth-of-binary-tree.cpp │ │ ├── path-sum.cpp │ │ ├── populate-next-right-pointers-tree.cpp │ │ ├── postorder-traversal.cpp │ │ ├── preorder-traversal.cpp │ │ ├── recover-binary-search-tree.cpp │ │ ├── root-to-leaf-paths-with-sum.cpp │ │ ├── shortest-unique-prefix.cpp │ │ ├── sorted-array-to-balanced-bst.cpp │ │ ├── sum-root-to-leaf-numbers.cpp │ │ ├── symmetric-binary-tree.cpp │ │ ├── vertical-order-traversal-of-binary-tree.cpp │ │ └── zigzag-level-order-traversal-bt.cpp └── Two-Pointers │ ├── 3-sum-zero.cpp │ ├── 3-sum.cpp │ ├── array-3-pointers.cpp │ ├── container-with-most-water.cpp │ ├── counting-triangles.cpp │ ├── diffk.cpp │ ├── intersection-of-sorted-arrays.cpp │ ├── merge-two-sorted-lists-ii.cpp │ ├── minimize-the-absolute-difference.cpp │ ├── remove-duplicates-from-sorted-array-ii.cpp │ ├── remove-duplicates-from-sorted-array.cpp │ ├── remove-element-from-array.cpp │ └── sort-by-color.cpp ├── LICENSE ├── Python └── Arrays │ ├── Examples │ ├── max-non-negative-subarray.py │ └── spiral-order-matrix-i.py │ └── Problems │ ├── max-min.py │ ├── pick-from-both-sides.py │ └── wave-array.py ├── README.md └── assets └── images └── ib.png /.github/ISSUE_TEMPLATE/feature_request.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Feature request 3 | about: Suggest an idea for this project 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Is your feature request related to a problem? Please describe.** 11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] 12 | 13 | **Describe the solution you'd like** 14 | A clear and concise description of what you want to happen. 15 | 16 | **Describe alternatives you've considered** 17 | A clear and concise description of any alternative solutions or features you've considered. 18 | 19 | **Additional context** 20 | Add any other context or screenshots about the feature request here. 21 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | .tags* 3 | /.idea/ 4 | /build/ 5 | /dist/ 6 | /node_modules/ 7 | debug.log 8 | npm-debug.log* 9 | /user/ -------------------------------------------------------------------------------- /Cpp/Arrays/Examples/spiral-order-matrix-i.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::spiralOrder(const vector > &A) { 2 | vector B; 3 | 4 | // Corner cases 5 | 6 | if (A.size() == 0) { 7 | return B; 8 | } 9 | if (A[0].size() == 0) { 10 | return B; 11 | } 12 | int t = 0, r = A[0].size() - 1, l = 0, b = A.size() - 1; 13 | int dir; 14 | 15 | // Keep 4 variables to mark the 4 corners of the traversal and dir for direction 16 | 17 | while (t <= b && l <= r) { 18 | dir = 0; 19 | if (dir == 0) { 20 | for (int i = l; i <= r; i ++) { 21 | B.push_back(A[t][i]); 22 | } 23 | t ++; 24 | if (t <= b) { 25 | dir ++; 26 | } 27 | } 28 | if (dir == 1) { 29 | for (int i = t; i <= b; i ++) { 30 | B.push_back(A[i][r]); 31 | } 32 | r --; 33 | if (l <= r) { 34 | dir ++; 35 | } 36 | } 37 | if (dir == 2) { 38 | for (int i = r; i >= l; i --) { 39 | B.push_back(A[b][i]); 40 | } 41 | b --; 42 | if (t <= b) { 43 | dir ++; 44 | } 45 | } 46 | if (dir == 3) { 47 | for (int i = b; i >= t; i --) { 48 | B.push_back(A[i][l]); 49 | } 50 | l ++; 51 | if (l <= r) { 52 | dir ++; 53 | } 54 | } 55 | } 56 | return B; 57 | } 58 | -------------------------------------------------------------------------------- /Cpp/Arrays/Primers/arraybug.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::rotateArray(vector &A, int B) { 2 | vector ret; 3 | for (int i = 0; i < A.size(); i++) { 4 | ret.push_back(A[i + B]); 5 | } 6 | return ret; 7 | } -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/add-one-to-number.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::plusOne(vector &A) { 2 | 3 | //Corner case 4 | 5 | vector B; 6 | if (A.size() <= 0) { 7 | return B; 8 | } 9 | 10 | // Get rid of all the empty values at the beginning 11 | 12 | int start = 0; 13 | for (int i = 0; i < A.size(); i ++) { 14 | if (A[i] != 0) { 15 | start = i; 16 | break; 17 | } 18 | } 19 | 20 | // Check 2 cases of A[i] equal to or not equal to 9 21 | 22 | for (int i = A.size() - 1; i >= start; i --) { 23 | if (A[i] != 9) { 24 | A[i] ++; 25 | break; 26 | } else if (A[i] == 9) { 27 | A[i] = 0; 28 | if (i == start) { 29 | A.push_back(1); 30 | 31 | // Reverse the array on completion 32 | 33 | reverse(A.begin(), A.end()); 34 | break; 35 | } 36 | } 37 | } 38 | 39 | // Erase empty spots 40 | 41 | if (start != 0) { 42 | A.erase(A.begin(), A.begin() + start); 43 | } 44 | return A; 45 | } 46 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/anti-diagonals.cpp: -------------------------------------------------------------------------------- 1 | vector > Solution::diagonal(vector > &A) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 0) { 6 | vector> B; 7 | return B; 8 | } 9 | vector> B(2 * A.size() - 1); 10 | 11 | for (int j = 0; j < A.size(); j ++) { 12 | int temp = 0; 13 | for (int i = 0; i <= j; i ++) { 14 | B[j].push_back(A[i][j - temp]); 15 | temp ++; 16 | } 17 | } 18 | for (int i = 1; i < A.size(); i ++) { 19 | int temp = 0; 20 | for (int j = A.size() - 1; i <= j; j --) { 21 | B[i + A.size() - 1].push_back(A[i + temp][j]); 22 | temp ++; 23 | } 24 | } 25 | return B; 26 | } 27 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/find-duplicate-in-array.cpp: -------------------------------------------------------------------------------- 1 | int Solution::repeatedNumber(const vector &arr) { 2 | int slow = arr[0]; 3 | int fast = arr[0]; 4 | 5 | // Flloyd's cycle finding algorithm 6 | 7 | do 8 | { 9 | slow = arr[slow]; 10 | fast = arr[arr[fast]]; 11 | } while (slow != fast); 12 | 13 | // Find the entrance to the cycle 14 | int ptr1 = arr[0]; 15 | int ptr2 = slow; 16 | while (ptr1 != ptr2) 17 | { 18 | ptr1 = arr[ptr1]; 19 | ptr2 = arr[ptr2]; 20 | } 21 | 22 | return ptr1; 23 | } 24 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/find-permutation.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::findPerm(const string A, int B) { 2 | vector C; 3 | int low = 1; 4 | int high = B; 5 | 6 | // Add low and high alternatively for H and I respectively 7 | 8 | for (int i = 0; i < A.size(); i ++) { 9 | if (A[i] == 'I') { 10 | C.push_back(low); 11 | low ++; 12 | } else if (A[i] == 'D') { 13 | C.push_back(high); 14 | high --; 15 | } 16 | } 17 | C.push_back(low); 18 | return C; 19 | } -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/first-missing-integer.cpp: -------------------------------------------------------------------------------- 1 | int Solution::firstMissingPositive(vector &A) { 2 | int i = 0; 3 | 4 | // The answer will be a positive integer will be in the range [1, N+1] 5 | // so we try to make A[i] = i + 1 and return the integer that doesn't follow this behavior 6 | 7 | while (i < A.size()) { 8 | if (A[i] == i + 1) { 9 | i ++; 10 | } else if (A[i] >= 1 && A[i] <= A.size()) { 11 | if (A[i] == A[A[i] - 1]) { 12 | i ++; 13 | } else { 14 | swap(A[i], A[A[i] - 1]); 15 | } 16 | } else { 17 | i ++; 18 | } 19 | } 20 | for (int i = 0; i < A.size(); i ++) { 21 | if (A[i] != i + 1) { 22 | return i + 1; 23 | } else continue; 24 | } 25 | return A.size() + 1; 26 | } 27 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/flip.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::flip(string A) { 2 | vector B; 3 | 4 | // Corner case 5 | 6 | if (A.length() <= 0) { 7 | return B; 8 | } 9 | 10 | // Inialize values(LOTS OF THEM!!) 11 | 12 | int i = 0, j = i + 1, flag = 0, maxi = INT_MIN, curCount = 0, curL = i, L = -1, R = -1; 13 | 14 | // Count number of 1s and 0s 15 | 16 | for (j = 0; j < A.size(); j ++) { 17 | if (A[j] == '0') { 18 | curCount ++; 19 | } else if (A[j] == '1') { 20 | curCount --; 21 | } 22 | 23 | // Apply Kadane's Algorithm 24 | 25 | if (curCount > maxi && curCount > 0) { 26 | maxi = curCount; 27 | R = j; 28 | L = curL; 29 | } 30 | if (curCount < 0) { 31 | curCount = 0; 32 | curL = j + 1; 33 | } 34 | 35 | } 36 | if (L == -1 && R == -1) { 37 | return B; 38 | } 39 | else { 40 | B.push_back(L + 1); 41 | B.push_back(R + 1); 42 | } 43 | return B; 44 | } 45 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/kth-row-of-pascals-triangle.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::getRow(int A) { 2 | vector C; 3 | 4 | // Corner case 5 | 6 | if (A < 0) { 7 | return C; 8 | } 9 | 10 | // Resultant matrix is initialized to size A + 1 11 | 12 | vector > B(A + 1, vector(1)); 13 | for (int i = 0; i < A + 1; i ++) { 14 | B[i][0] = 1; 15 | } 16 | for (int i = 1; i < A + 1; i ++) { 17 | for (int j = 1; j <= i; j ++) { 18 | if (i == j) { 19 | B[i].push_back(B[i - 1][j - 1]); 20 | } else { 21 | B[i].push_back(B[i - 1][j] + B[i - 1][j - 1]); 22 | } 23 | } 24 | 25 | } 26 | return B[A]; 27 | } 28 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/largest-number.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to compare values in the array 2 | 3 | bool comp (int A, int B) { 4 | string tempAa = to_string(A); 5 | string tempBb = to_string(B); 6 | string c1 = tempAa + tempBb; 7 | string c2 = tempBb + tempAa; 8 | return c1.compare(c2) > 0 ? 1 : 0; 9 | } 10 | string Solution::largestNumber(const vector &A) { 11 | vector B = A; 12 | sort(B.begin(), B.end(), comp); 13 | string ans; 14 | int countZero = 0; 15 | for (int i = 0; i < B.size(); i ++) { 16 | if (B[i] == 0) { 17 | countZero ++; 18 | } 19 | ans += to_string(B[i]); 20 | } 21 | if (countZero == B.size()) { 22 | return string(to_string(0)); 23 | } 24 | return ans; 25 | } 26 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/max-distance.cpp: -------------------------------------------------------------------------------- 1 | int Solution::maximumGap(const vector &A) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 0) { 6 | return 0; 7 | } 8 | 9 | // We make 2 max, min arrays for checking min value and max value in the array before and after the element respectively 10 | 11 | vector leftMin(A); 12 | vector rightMax(A); 13 | 14 | int mini = INT_MIN; 15 | int maxi = INT_MAX; 16 | 17 | leftMin[0] = A[0]; 18 | for (int i = 1; i < A.size(); i ++) { 19 | leftMin[i] = min(A[i], leftMin[i - 1]); 20 | } 21 | rightMax[A.size() - 1] = A[A.size() - 1]; 22 | for (int i = A.size() - 2; i >= 0; i --) { 23 | rightMax[i] = max(A[i], rightMax[i + 1]); 24 | } 25 | 26 | //Iterate over the array and find the maximum j - i 27 | 28 | int i = 0, j = 0, result = -1; 29 | while (j < A.size() && i < A.size()) { 30 | if (leftMin[i] <= rightMax[j]) { 31 | result = max(result, j - i); 32 | j ++; 33 | } else { 34 | i ++; 35 | } 36 | } 37 | return result; 38 | } 39 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/max-non-negative-subarray.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::maxset(vector &A) { 2 | vector B; 3 | vector> C; 4 | 5 | // Corner case 6 | 7 | if (A.size() <= 0) { 8 | return B; 9 | } 10 | 11 | // Initialize current left, maxleft and max right(index will be current right) 12 | 13 | int L = -1, curL = 0, R = -1; 14 | long long int until_here = 0, maxi = INT_MIN; 15 | 16 | // Modified Kadane's algorithm 17 | 18 | for (int i = 0; i < A.size(); i ++) { 19 | until_here += A[i]; 20 | 21 | if (until_here > maxi && until_here >= 0) { 22 | maxi = until_here; 23 | R = i; 24 | L = curL; 25 | C.clear(); 26 | pair temp; 27 | temp.first = L; 28 | temp.second = R; 29 | C.push_back(temp); 30 | } else if (until_here == maxi) { 31 | pair temp; 32 | temp.first = curL; 33 | temp.second = i; 34 | C.push_back(temp); 35 | } 36 | 37 | if (until_here < 0 || A[i] < 0) { 38 | until_here = 0; 39 | curL = i + 1; 40 | } 41 | 42 | } 43 | int minI, maxI, maxV = INT_MIN; 44 | if (L == -1 && R == -1) { 45 | return B; 46 | } else { 47 | for (int i = 0; i < C.size(); i ++) { 48 | int diff = C[i].second - C[i].first; 49 | if (diff > maxV) { 50 | maxV = diff; 51 | minI = C[i].first; 52 | maxI = C[i].second; 53 | } 54 | } 55 | } 56 | for (int i = minI; i <= maxI; i ++) { 57 | B.push_back(A[i]); 58 | } 59 | return B; 60 | } 61 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/max-sum-contiguous-subarray.cpp: -------------------------------------------------------------------------------- 1 | int Solution::maxSubArray(const vector &A) { 2 | 3 | // Apply Kadane's algorithm 4 | 5 | int max_so_far = INT_MIN, max_ending_here = 0; 6 | 7 | for (int i = 0; i < A.size(); i++) 8 | { 9 | max_ending_here = max_ending_here + A[i]; 10 | 11 | // If max, set to maximum 12 | 13 | if (max_so_far < max_ending_here) 14 | max_so_far = max_ending_here; 15 | 16 | if (max_ending_here < 0) 17 | max_ending_here = 0; 18 | } 19 | return max_so_far; 20 | } 21 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/maximum-absolute-difference.cpp: -------------------------------------------------------------------------------- 1 | int Solution::maxArr(vector &A) { 2 | 3 | // Solution is an extension of the manhattan distance problem 4 | 5 | vector plus = A; 6 | vector minus = A; 7 | if (A.size() == 1) { 8 | return 0; 9 | } 10 | 11 | // Set array values for A[i] + i 12 | 13 | for (int i = 0; i < plus.size(); i ++) { 14 | plus[i] = plus[i] + i; 15 | } 16 | 17 | // Set array values for A[i] - i 18 | 19 | for (int i = 0; i < minus.size(); i ++) { 20 | minus[i] = minus[i] - i; 21 | } 22 | sort(plus.begin(), plus.end()); 23 | sort(minus.begin(), minus.end()); 24 | return max(plus[plus.size() - 1] - plus[0], minus[minus.size() - 1] - minus[0]); 25 | } 26 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/maximum-consecutive-gap.cpp: -------------------------------------------------------------------------------- 1 | int Solution::maximumGap(const vector &A) { 2 | if (A.size() < 2) { 3 | return 0; 4 | } 5 | 6 | // check max and min for the bucket distribution 7 | 8 | int maxi = INT_MIN; 9 | int mini = INT_MAX; 10 | for (int i = 0; i < A.size(); i ++) { 11 | if (A[i] > maxi) { 12 | maxi = A[i]; 13 | } 14 | if (A[i] < mini) { 15 | mini = A[i]; 16 | } 17 | } 18 | if (maxi == mini) { 19 | return 0; 20 | } 21 | 22 | // calculate the gap 23 | 24 | int gap = (maxi - mini - 1) / (A.size() - 1) + 1; 25 | 26 | vector maxBucket(A.size() - 1, INT_MIN); 27 | vector minBucket(A.size() - 1, INT_MAX); 28 | 29 | for (int i = 0; i < A.size(); i ++) { 30 | if (A[i] != maxi && A[i] != mini) { 31 | int multip = (A[i] - mini) / gap; 32 | if (A[i] > maxBucket[multip]) { 33 | maxBucket[multip] = A[i]; 34 | } 35 | if (A[i] < minBucket[multip]) { 36 | minBucket[multip] = A[i]; 37 | } 38 | } 39 | } 40 | int maxim = INT_MIN; 41 | int previous = mini; 42 | for (int i = 0; i < A.size() - 1; i ++) { 43 | if (minBucket[i] == INT_MAX && maxBucket[i] == INT_MIN) 44 | continue; 45 | if (minBucket[i] - previous > maxim) { 46 | maxim = minBucket[i] - previous; 47 | } 48 | previous = maxBucket[i]; 49 | } 50 | return max(maxim, maxi - previous); 51 | } 52 | 53 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/maximum-special-product.cpp: -------------------------------------------------------------------------------- 1 | #define MOD 1000000007 2 | int Solution::maxSpecialProduct(vector &A) { 3 | if (A.size() <= 0) { 4 | return 0; 5 | } 6 | vector next(A.size()); 7 | vector prev(A.size()); 8 | stack> st; 9 | 10 | // Make next greater array 11 | 12 | for (int i = A.size() - 1; i >= 0; i --) { 13 | if (st.empty()) { 14 | next[i] = 0; 15 | } else { 16 | while (!st.empty() && st.top().first <= A[i]) { 17 | st.pop(); 18 | } 19 | if (!st.empty()) { 20 | next[i] = st.top().second; 21 | } else next[i] = 0; 22 | } 23 | st.push(make_pair(A[i] % MOD, i)); 24 | } 25 | while (!st.empty()) { 26 | st.pop(); 27 | } 28 | 29 | // Make prev greater array 30 | 31 | for (int i = 0; i < A.size(); i ++) { 32 | if (st.empty()) { 33 | prev[i] = 0; 34 | } else { 35 | while (!st.empty() && st.top().first <= A[i]) { 36 | st.pop(); 37 | } 38 | if (!st.empty()) { 39 | prev[i] = st.top().second; 40 | } else prev[i] = 0; 41 | } 42 | st.push(make_pair(A[i] % MOD, i)); 43 | } 44 | long long maxi = 0; 45 | for (int i = 0; i < A.size(); i ++) { 46 | long long temp = ((long long)next[i] * (long long)prev[i]); 47 | maxi = max(maxi, temp); 48 | } 49 | return maxi % MOD; 50 | } 51 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/maximum-unsorted-subarray.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::subUnsort(vector &A) { 2 | vector B; 3 | int l = -1; 4 | int r; 5 | 6 | // Find the first index where A[i + 1] < A[i] 7 | 8 | for (int i = 0; i < A.size() - 1; i ++) { 9 | if (A[i + 1] < A[i]) { 10 | l = i; 11 | break; 12 | } 13 | } 14 | if (l == -1) { 15 | return vector(1, -1); 16 | } 17 | 18 | // Find the first index where A[i - 1] > A[i] 19 | 20 | for (int i = A.size() - 1; i >= 1; i --) { 21 | if (A[i - 1] > A[i]) { 22 | r = i; 23 | break; 24 | } 25 | } 26 | 27 | // Find min and max from positions l to r 28 | 29 | int mini = INT_MAX, maxi = INT_MIN; 30 | for (int i = l; i <= r; i ++) { 31 | if (A[i] > maxi) { 32 | maxi = A[i]; 33 | } 34 | if (A[i] < mini) { 35 | mini = A[i]; 36 | } 37 | } 38 | 39 | // Check for left index 40 | 41 | for (int i = 0; i < l; i ++) { 42 | if (A[i] > mini) { 43 | l = i; 44 | } 45 | } 46 | 47 | // check for right index 48 | 49 | for (int i = A.size() - 1; i > r; i --) { 50 | if (A[i] < maxi) { 51 | r = i; 52 | } 53 | } 54 | B.push_back(l); 55 | B.push_back(r); 56 | return B; 57 | } 58 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/merge-intervals.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for an interval. 3 | * struct Interval { 4 | * int start; 5 | * int end; 6 | * Interval() : start(0), end(0) {} 7 | * Interval(int s, int e) : start(s), end(e) {} 8 | * }; 9 | */ 10 | 11 | // Helper function to compare the values in Interval 12 | 13 | bool operator > (const Interval &a, const Interval &b) { 14 | if (a.start > b.start) { 15 | return false; 16 | } else if (a.start < b.start) { 17 | return true; 18 | } else { 19 | a.end < b.end ? 1 : 0; 20 | } 21 | } 22 | vector Solution::insert(vector &intervals, Interval newInterval) { 23 | vector B; 24 | intervals.push_back(newInterval); 25 | 26 | // sort the intervals using the helper function 27 | 28 | sort(intervals.begin(), intervals.end(), greater()); 29 | 30 | B.push_back(intervals[0]); 31 | 32 | // Compare the intervals end points 33 | 34 | for (int i = 1; i < intervals.size(); i ++) { 35 | if (B[B.size() - 1].end >= intervals[i].start) { 36 | B[B.size() - 1].end = max(B[B.size() - 1].end, intervals[i].end); 37 | } else { 38 | B.push_back(intervals[i]); 39 | } 40 | } 41 | return B; 42 | } 43 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/merge-overlapping-intervals.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for an interval. 3 | * struct Interval { 4 | * int start; 5 | * int end; 6 | * Interval() : start(0), end(0) {} 7 | * Interval(int s, int e) : start(s), end(e) {} 8 | * }; 9 | */ 10 | 11 | // Helper function to for comparing Intervals 12 | 13 | bool operator > (const Interval &i1, const Interval &i2) { 14 | if (i1.start < i2.start) { 15 | return true; 16 | } else if (i1.start == i2.start) { 17 | return i1.end > i2.end; 18 | } else return false; 19 | } 20 | vector Solution::merge(vector &A) { 21 | vector B; 22 | 23 | // corner cases 24 | 25 | if (A.size() <= 0) { 26 | return B; 27 | } else if (A.size() == 1) { 28 | return A; 29 | } 30 | map C; 31 | 32 | // sort the intervals 33 | 34 | sort(A.begin(), A.end(), greater()); 35 | int flag = 1; 36 | int x = INT_MAX, y=INT_MAX; 37 | B.push_back(A[0]); 38 | 39 | // check the interval endpoints 40 | 41 | for (int i = 1; i < A.size(); i ++) { 42 | if (A[i].start > B[B.size() - 1].end) { 43 | B.push_back(A[i]); 44 | } else { 45 | B[B.size() - 1].end = max(B[B.size() - 1].end, A[i].end); 46 | } 47 | } 48 | return B; 49 | } 50 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/min-steps-in-infinite-grid.cpp: -------------------------------------------------------------------------------- 1 | int Solution::coverPoints(vector &A, vector &B) { 2 | /* 3 | if (A.size() == 0 || B.size() == 0) { 4 | return 0; 5 | } 6 | */ 7 | 8 | // Max value of absolute difference between x and y coordinates 9 | 10 | int total = 0; 11 | for (int i = 0; i < A.size() - 1; i ++) { 12 | total += max(abs((A[i + 1]) - (A[i])), abs((B[i + 1]) - (B[i]))); 13 | //cout << total << " "; 14 | } 15 | return total; 16 | } 17 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/n3-repeat-number.cpp: -------------------------------------------------------------------------------- 1 | int Solution::repeatedNumber(const vector &A) { 2 | 3 | // Moore's voting algorithm 4 | 5 | int cand1 = INT_MAX, cand2 = INT_MAX; 6 | int count1 = 0, count2 = 0; 7 | 8 | // Here we pick 2 candidates for the solution. 9 | // If a candidate occurs, we increase the count 10 | // else we decrease the count and make a new candidate 11 | 12 | for (int i = 0; i < A.size(); i ++) { 13 | if (A[i] == cand1) { 14 | count1 ++; 15 | } else if (A[i] == cand2) { 16 | count2 ++; 17 | } else if (count1 == 0) { 18 | cand1 = A[i]; 19 | count1 ++; 20 | } else if (count2 == 0) { 21 | cand2 = A[i]; 22 | count2 ++; 23 | } else { 24 | count1 --; 25 | count2 --; 26 | } 27 | } 28 | count1 = 0; 29 | count2 = 0; 30 | 31 | // Here we check if the candidates are worthy or not 32 | 33 | for (int i = 0; i < A.size(); i ++) { 34 | if (A[i] == cand1) { 35 | count1++; 36 | } else if (A[i] == cand2) { 37 | count2 ++; 38 | } 39 | } 40 | if (count1 > A.size() / 3) { 41 | return cand1; 42 | } 43 | if (count2 > A.size() / 3) { 44 | return cand2; 45 | } 46 | return -1; 47 | } 48 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/next-permutation.cpp: -------------------------------------------------------------------------------- 1 | void Solution::nextPermutation(vector &A) { 2 | 3 | // corner case 4 | 5 | if (A.size() <= 1) { 6 | return; 7 | } 8 | int i = A.size() - 1; 9 | int j = i - 1; 10 | int diff = 0; 11 | 12 | // Check for the next permutation 13 | 14 | while (j >= 0) { 15 | if (A[j] >= A[i]) { 16 | j --; 17 | i --; 18 | } else { 19 | int mini = INT_MAX; 20 | int l = -1; 21 | for (int k = i; k < A.size(); k ++) { 22 | int diff = A[k] - A[j]; 23 | if (diff > 0 && diff < mini) { 24 | mini = diff; 25 | l = k; 26 | } 27 | } 28 | swap(A[j], A[l]); 29 | break; 30 | } 31 | } 32 | if (j == -1) { 33 | sort(A.begin(), A.end()); 34 | } 35 | sort(A.begin() + j + 1, A.end()); 36 | return; 37 | } 38 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/noble-integer.cpp: -------------------------------------------------------------------------------- 1 | int Solution::solve(vector &A) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 0) { 6 | return -1; 7 | } 8 | 9 | // sort the array 10 | 11 | sort(A.begin(), A.end()); 12 | 13 | // check the values 14 | 15 | for(int i = 0; i < A.size(); i ++) { 16 | int j; 17 | for (j = i + 1; j < A.size(); j ++) { 18 | if (A[i] != A[j]) { 19 | if (A[i] == A.size() - j) { 20 | //cout << i << j; 21 | return 1; 22 | } 23 | break; 24 | } 25 | } 26 | if (j == A.size() && A[i] == 0) { 27 | return 1; 28 | } 29 | } 30 | return -1; 31 | } 32 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/pascal-triangle.cpp: -------------------------------------------------------------------------------- 1 | vector > Solution::solve(int A) { 2 | vector > C; 3 | 4 | // Corner case 5 | 6 | if (A <= 0) { 7 | return C; 8 | } 9 | vector > B(A); 10 | for (int i = 0; i < A; i ++) { 11 | B[i].push_back(1); 12 | } 13 | for (int i = 1; i < A; i ++) { 14 | for (int j = 1; j <= i; j ++) { 15 | if (i == j) { 16 | B[i].push_back(B[i - 1][j - 1]); 17 | } else { 18 | B[i].push_back(B[i - 1][j] + B[i - 1][j - 1]); 19 | } 20 | } 21 | } 22 | return B; 23 | } 24 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/repeat-and-missing-number-array.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::repeatedNumber(const vector &A) { 2 | vector C; 3 | 4 | // Corner case 5 | 6 | if (A.size() <= 1) { 7 | return C; 8 | } 9 | 10 | // Get 2 equations from sum of all numbers of A and sum of all numbers from 1 to N 11 | 12 | long long int S = (A.size() * (A.size() + 1)) / 2; 13 | long long int tot= 0; 14 | for (int i = 0; i < A.size(); i ++) { 15 | tot += A[i]; 16 | } 17 | int diff = S - tot; 18 | long long int ST = 0, tT = 0; 19 | for (int i = 0; i < A.size(); i ++) { 20 | ST += (long long int)(i + 1) * (long long int)(i + 1); 21 | } 22 | for (int i = 0; i < A.size(); i ++) { 23 | tT += (long long int)(A[i]) * (long long int)(A[i]); 24 | } 25 | int sum = (ST - tT) / diff; 26 | int B = (sum + diff) / 2; 27 | int a = sum - B; 28 | C.push_back(a); 29 | C.push_back(B); 30 | return C; 31 | } 32 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/rotate-matrix.cpp: -------------------------------------------------------------------------------- 1 | void Solution::rotate(vector > &A) { 2 | 3 | // corner case 4 | 5 | if (A.size() <= 0) { 6 | return; 7 | } 8 | for (int i = 0; i < A.size(); i ++) { 9 | for (int j = i; j < A.size(); j ++) { 10 | swap(A[i][j], A[j][i]); 11 | } 12 | } 13 | for (int i = 0; i < A.size(); i ++) { 14 | reverse(A[i].begin(), A[i].end()); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/set-matrix-zeros.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to check if a value exists in an array 2 | 3 | bool exists(vector A, int val) { 4 | for (int i = 0; i < A.size(); i ++) { 5 | if (A[i] == val) { 6 | return 1; 7 | } 8 | } 9 | return false; 10 | } 11 | void Solution::setZeroes(vector > &A) { 12 | 13 | // Corner case 14 | 15 | if (A.size() <= 0 || A[0].size() <= 0) { 16 | return; 17 | } 18 | vector B, C; 19 | 20 | // Store the row and columns which go zero 21 | 22 | for (int i = 0; i < A.size(); i ++) { 23 | for (int j = 0; j < A[0].size(); j ++) { 24 | if (A[i][j] == 0) { 25 | if (!exists(B, i)) { 26 | B.push_back(i); 27 | } 28 | if (!exists(C, j)) { 29 | C.push_back(j); 30 | } 31 | } 32 | } 33 | } 34 | 35 | // set rows and columns to zero 36 | 37 | for (int i = 0; i < B.size(); i ++) { 38 | for (int j = 0; j < A[0].size(); j ++) { 39 | A[B[i]][j] = 0; 40 | } 41 | } 42 | for (int i = 0; i < C.size(); i ++) { 43 | for (int j = 0; j < A.size(); j ++) { 44 | A[j][C[i]] = 0; 45 | } 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/spiral-order-matrix-ii.cpp: -------------------------------------------------------------------------------- 1 | vector > Solution::generateMatrix(int A) { 2 | vector > B(A, vector(A)); 3 | 4 | // Corner case 5 | 6 | if (A <= 0) { 7 | return B; 8 | } 9 | int temp = 1; 10 | 11 | // I know variables are usually supposed to start with a lowercase letter, I know *sigh* 12 | 13 | // Keep 4 variables to mark the 4 corners of the traversal and dir for direction 14 | 15 | int T = 0, Be = A - 1, L = 0, R = A - 1, dir = 0; 16 | while (Be >= T && R >= L) { 17 | if (dir == 0) { 18 | for (int j = L; j <= R; j ++) { 19 | B[T][j] = temp; 20 | temp ++; 21 | } 22 | T ++; 23 | if (T <= Be) { 24 | dir ++; 25 | } else 26 | break; 27 | } 28 | if (dir == 1) { 29 | for (int i = T; i <= Be; i ++) { 30 | B[i][R] = temp; 31 | temp ++; 32 | } 33 | R --; 34 | if (L <= R) { 35 | dir ++; 36 | } else 37 | break; 38 | } 39 | if (dir == 2) { 40 | for (int j = R; j >= L; j --) { 41 | B[Be][j] = temp; 42 | temp ++; 43 | } 44 | Be --; 45 | if (T <= Be) { 46 | dir ++; 47 | } else 48 | break; 49 | } 50 | if (dir == 3) { 51 | for (int i = Be; i >= T; i --) { 52 | B[i][L] = temp; 53 | temp ++; 54 | } 55 | L ++; 56 | if (L <= R) { 57 | dir ++; 58 | } else 59 | break; 60 | } 61 | dir = 0; 62 | } 63 | return B; 64 | } 65 | -------------------------------------------------------------------------------- /Cpp/Arrays/Problems/wave-array.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::wave(vector &A) { 2 | vector B; 3 | 4 | // Corner case 5 | 6 | if (A.size() == 0) { 7 | return B; 8 | } 9 | 10 | // Sort the array 11 | 12 | sort(A.begin(), A.end()); 13 | 14 | if (A.size() == 1) { 15 | return A; 16 | } 17 | 18 | // Pick elements alternatively from the front and the back 19 | 20 | for (int i = 0; i < A.size(); i += 2) { 21 | if (i == A.size() - 1) { 22 | B.push_back(A[i]); 23 | break; 24 | } else { 25 | B.push_back(A[i + 1]); 26 | B.push_back(A[i]); 27 | } 28 | } 29 | return B; 30 | } 31 | -------------------------------------------------------------------------------- /Cpp/Backtracking/Examples/modular-expression.cpp: -------------------------------------------------------------------------------- 1 | int Solution::Mod(int A, int B, int C) { 2 | 3 | // Corner case 4 | 5 | if (B == 0) { 6 | return 1 % C; 7 | } else if (A == 0) { 8 | return 0; 9 | } 10 | long long int x; 11 | 12 | // Use binary exponentiation 13 | // Also check for overflow cases 14 | 15 | if (B % 2 == 1) { 16 | x = (long long)((A % C) * (long long)(Mod(A, B - 1, C) % C)) % C; 17 | } else { 18 | x = (Mod(A, B / 2, C)); 19 | x = x * x % C; 20 | } 21 | while (x < 0) { 22 | x += C; 23 | } 24 | return x; 25 | } 26 | -------------------------------------------------------------------------------- /Cpp/Backtracking/Examples/reverse-link-list-recursion.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* reverse(ListNode* cur, ListNode* prev) { 10 | 11 | // Corner case 12 | 13 | if (cur == NULL) { 14 | return prev; 15 | } 16 | 17 | // Reverse a linked list just like when iterating it 18 | 19 | ListNode* next = cur -> next; 20 | cur -> next = prev; 21 | prev = cur; 22 | cur = next; 23 | return reverse(cur, prev); 24 | } 25 | ListNode* Solution::reverseList(ListNode* A) { 26 | 27 | // Corner case 28 | 29 | if (A == NULL || A -> next == NULL) { 30 | return A; 31 | } 32 | return reverse(A, NULL); 33 | } 34 | -------------------------------------------------------------------------------- /Cpp/Backtracking/Problems/combination-sum-ii.cpp: -------------------------------------------------------------------------------- 1 | void combine(vector A, int index, vector temp, int B, vector > &C) { 2 | 3 | // If the desired sum is less than the required sum, return 4 | // If the desired sum is equal to the required sum, push it 5 | 6 | if (B < 0) { 7 | return; 8 | } 9 | if (B == 0) { 10 | sort(temp.begin(), temp.end()); 11 | C.push_back(temp); 12 | return; 13 | } 14 | 15 | // Unlike the similar question, this time, we increment the index to not use the same element more than once 16 | 17 | for (int i = index; i < A.size(); i ++) { 18 | temp.push_back(A[i]); 19 | combine(A, i + 1, temp, B - A[i], C); 20 | temp.pop_back(); 21 | } 22 | } 23 | vector > Solution::combinationSum(vector &A, int B) { 24 | vector > C; 25 | 26 | // Sort the original array to get a sorted matrix 27 | 28 | sort(A.begin(), A.end()); 29 | combine(A, 0, vector(), B, C); 30 | 31 | // Remove the duplicates 32 | 33 | C.erase(unique(C.begin(), C.end()), C.end()); 34 | return C; 35 | } 36 | -------------------------------------------------------------------------------- /Cpp/Backtracking/Problems/combination-sum.cpp: -------------------------------------------------------------------------------- 1 | void combine(vector &A, int B, vector temp, int index, vector > &C) { 2 | 3 | // If the desired sum is less than the required sum, return 4 | // If the desired sum is equal to the required sum, push it 5 | 6 | if (B < 0) { 7 | return; 8 | } 9 | 10 | if (B == 0) { 11 | sort(temp.begin(), temp.end()); 12 | C.push_back(temp); 13 | temp.clear(); 14 | return; 15 | } 16 | 17 | // Try out all the combinations consisting of an element A[i] and reduce the required sum by the same amount 18 | 19 | for (int i = index; i < A.size(); i ++) { 20 | temp.push_back(A[i]); 21 | combine(A, B - A[i], temp, i, C); 22 | temp.pop_back(); 23 | } 24 | } 25 | vector > Solution::combinationSum(vector &A, int B) { 26 | vector > C; 27 | 28 | // Sort and remove all the duplicates in A 29 | 30 | sort(A.begin(), A.end()); 31 | A.erase(unique(A.begin(), A.end()), A.end()); 32 | combine(A, B, vector(), 0, C); 33 | return C; 34 | } 35 | -------------------------------------------------------------------------------- /Cpp/Backtracking/Problems/combinations.cpp: -------------------------------------------------------------------------------- 1 | void combination(int A, int num, int pos, vector temp, vector > &C) { 2 | 3 | // If the size of the combination is equal to the required size, push it 4 | 5 | if (temp.size() == num) { 6 | sort(temp.begin(), temp.end()); 7 | C.push_back(temp); 8 | temp.clear(); 9 | return; 10 | } 11 | 12 | // Make all the combinations consisting of an element A[i] and recurse 13 | 14 | for (int i = pos; i <= A; i ++) { 15 | vector temp2 = temp; 16 | temp2.push_back(i); 17 | combination(A, num, i + 1, temp2, C); 18 | } 19 | 20 | } 21 | vector > Solution::combine(int A, int num) { 22 | vector > C; 23 | if (num > A) { 24 | return C; 25 | } 26 | combination(A, num, 1, vector(), C); 27 | return C; 28 | } 29 | -------------------------------------------------------------------------------- /Cpp/Backtracking/Problems/generate-all-parentheses-ii.cpp: -------------------------------------------------------------------------------- 1 | void paranthesis(vector &s, string temp, int a, int n){ 2 | if (a > n) 3 | return; 4 | if (a == 0) { 5 | while (n--) 6 | temp += ")"; 7 | s.push_back(temp); 8 | return; 9 | } 10 | temp += '('; 11 | paranthesis(s, temp, a-1, n); 12 | temp[temp.length() - 1] = ')'; 13 | paranthesis(s, temp, a, n-1); 14 | } 15 | 16 | vector Solution::generateParenthesis(int A) { 17 | vector s; 18 | string temp = ""; 19 | paranthesis(s, temp, A, A); 20 | return s; 21 | } -------------------------------------------------------------------------------- /Cpp/Backtracking/Problems/gray-code.cpp: -------------------------------------------------------------------------------- 1 | int binaryToInt(string A) { 2 | int val = 0; 3 | for (int i = A.size() - 1; i >= 0; i --) { 4 | val += (A[i] - '0') * pow(2, A.size() - i - 1); 5 | } 6 | return val; 7 | } 8 | void grayCodeUtil(vector& res, int n, int& num) { 9 | if (n == 0) { 10 | res.push_back(num); 11 | return; 12 | } 13 | grayCodeUtil(res, n - 1, num); 14 | num = num ^ (1 << (n - 1)); 15 | grayCodeUtil(res, n - 1, num); 16 | } 17 | vector Solution::grayCode(int A) { 18 | string B; 19 | vector C; 20 | vector D; 21 | for (int i = 0; i < A; i ++) { 22 | B += '0'; 23 | } 24 | int num = 0; 25 | grayCodeUtil(D, A, num); 26 | for (vector::iterator it = C.begin(); it != C.end(); it ++) { 27 | D.push_back(binaryToInt(*it)); 28 | } 29 | return D; 30 | } 31 | -------------------------------------------------------------------------------- /Cpp/Backtracking/Problems/letter-phone.cpp: -------------------------------------------------------------------------------- 1 | unordered_map createMap(unordered_map map) { 2 | map['1'] = "1"; 3 | map['2'] = "abc"; 4 | map['3'] = "def"; 5 | map['4'] = "ghi"; 6 | map['5'] = "jkl"; 7 | map['6'] = "mno"; 8 | map['7'] = "pqrs"; 9 | map['8'] = "tuv"; 10 | map['9'] = "wxyz"; 11 | map['0'] = "0"; 12 | return map; 13 | } 14 | 15 | void combinations(string &A, vector &B, unordered_map &map, string temp, int start, int start2) { 16 | if (temp.size() == A.size()) { 17 | B.push_back(temp); 18 | temp.clear(); 19 | return; 20 | } 21 | for (int i = start2; i < A.size(); i ++) { 22 | string temp1 = map[A[i]]; 23 | start = 0; 24 | for (int j = start; j < temp1.size(); j ++) { 25 | temp.push_back(temp1[j]); 26 | combinations(A, B, map, temp, j + 1, i + 1); 27 | temp.pop_back(); 28 | } 29 | } 30 | } 31 | vector Solution::letterCombinations(string A) { 32 | unordered_map map; 33 | map = createMap(map); 34 | vector B; 35 | combinations(A, B, map, string(), 0, 0); 36 | return B; 37 | } -------------------------------------------------------------------------------- /Cpp/Backtracking/Problems/palindrome-partitioning.cpp: -------------------------------------------------------------------------------- 1 | bool isPalindrome(string A) { 2 | string B = A; 3 | reverse(A.begin(), A.end()); 4 | return A == B; 5 | } 6 | void palindromePartition(string A, vector temp, vector> &B, int index) { 7 | if (index == A.size()) { 8 | B.push_back(temp); 9 | return; 10 | } 11 | if (index > A.size()) { 12 | return; 13 | } 14 | int i = index; 15 | for (int j = 1; j <= A.size(); j ++) { 16 | string temp1 = A.substr(i, j); 17 | if (isPalindrome(temp1)) { 18 | temp.push_back(A.substr(i, j)); 19 | palindromePartition(A, temp, B, i + j); 20 | temp.pop_back(); 21 | } 22 | } 23 | return; 24 | } 25 | vector > Solution::partition(string A) { 26 | vector > B; 27 | palindromePartition(A, vector(), B, 0); 28 | return B; 29 | } 30 | -------------------------------------------------------------------------------- /Cpp/Backtracking/Problems/permutations.cpp: -------------------------------------------------------------------------------- 1 | void recursePermute(vector A, int start, int end, vector > &B) { 2 | 3 | // If the starting index is equal to the ending index, push the permutation 4 | 5 | if (start == end) { 6 | B.push_back(A); 7 | return; 8 | } 9 | 10 | // If not, swap every element with the first element and recurse to get all the combinations 11 | 12 | if (start < end) { 13 | for (int i = start; i <= end; i ++) { 14 | swap(A[i], A[start]); 15 | recursePermute(A, start + 1, end, B); 16 | } 17 | } 18 | } 19 | vector > Solution::permute(vector &A) { 20 | vector > B; 21 | 22 | // Corner case 23 | 24 | if (A.size() <= 1) { 25 | B.push_back(A); 26 | return B; 27 | } 28 | recursePermute(A, 0, A.size() - 1, B); 29 | return B; 30 | } 31 | -------------------------------------------------------------------------------- /Cpp/Backtracking/Problems/subset.cpp: -------------------------------------------------------------------------------- 1 | void subsetsByLength(vector &A, int n, vector temp, int index, vector > &B) { 2 | 3 | // If the size of the subset is equal to the required size, push it 4 | 5 | if (temp.size() == n) { 6 | sort(temp.begin(), temp.end()); 7 | B.push_back(temp); 8 | temp.clear(); 9 | return; 10 | } 11 | 12 | // Make all the subsets consisting of an element A[i] and recurse 13 | 14 | for (int i = index; i < A.size(); i ++) { 15 | temp.push_back(A[i]); 16 | subsetsByLength(A, n, temp, i + 1, B); 17 | temp.pop_back(); 18 | } 19 | } 20 | vector > Solution::subsets(vector &A) { 21 | vector > B; 22 | 23 | // Iterate for getting all the subsets from length 0 to length A.size() 24 | 25 | for (int i = 0; i <= A.size(); i ++) { 26 | subsetsByLength(A, i, vector(), 0, B); 27 | } 28 | sort(B.begin(), B.end()); 29 | return B; 30 | } 31 | -------------------------------------------------------------------------------- /Cpp/Backtracking/Problems/subsets-ii.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mailtokartik1/InterviewBit-Solutions/8a9be25cf55947aff456c7c138e2ee6f518aa6a5/Cpp/Backtracking/Problems/subsets-ii.cpp -------------------------------------------------------------------------------- /Cpp/Binary-Search/allocate-books.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to check if the number of students required overflows for a value 2 | 3 | bool isPossible(vector A, int mid, int B) { 4 | int studentsRequired = 1; 5 | int curr_sum = 0; 6 | 7 | for (int i = 0; i < A.size(); i++) { 8 | if (A[i] > mid) 9 | return false; 10 | if (curr_sum + A[i] > mid) { 11 | studentsRequired++; 12 | curr_sum = A[i]; 13 | if (studentsRequired > B) 14 | return false; 15 | } 16 | else 17 | curr_sum += A[i]; 18 | } 19 | return true; 20 | } 21 | int Solution::books(vector &A, int B) { 22 | 23 | // Corner case 24 | 25 | if (B > A.size()) { 26 | return -1; 27 | } 28 | 29 | long long sum = 0; 30 | 31 | // Binary Search from start to end(possible values) 32 | 33 | for (int i = 0; i < A.size(); i ++) { 34 | sum += A[i]; 35 | } 36 | int start = 0; 37 | int end = sum; 38 | int result = INT_MAX; 39 | while (start <= end) { 40 | int mid = start + (end - start) / 2; 41 | if (isPossible(A, mid, B)) { 42 | result = min(result, mid); 43 | end = mid - 1; 44 | } else { 45 | start = mid + 1; 46 | } 47 | } 48 | return result; 49 | } 50 | -------------------------------------------------------------------------------- /Cpp/Binary-Search/implement-power-function.cpp: -------------------------------------------------------------------------------- 1 | int Solution::pow(int A, int n, int d) { 2 | 3 | // Corner cases 4 | 5 | long long x = A; 6 | if (n == 0) { 7 | return 1 % d; 8 | } 9 | if (x == 0) { 10 | return 0; 11 | } 12 | if (d == 1) { 13 | return 0; 14 | } 15 | long long int ans = 1; 16 | 17 | // Separation of concerns based on whether the exponent is divisible by 2 or not 18 | 19 | bool sign; 20 | if (x < 0) { 21 | if (n % 2 == 1) { 22 | sign = false; 23 | } else { 24 | sign = true; 25 | } 26 | } else if (x >= 0) { 27 | sign = true; 28 | } 29 | x = abs(x); 30 | 31 | // Binary Exponentiation 32 | 33 | while (n > 0) { 34 | if (n % 2 == 1) { 35 | ans = (ans * x) % d; 36 | } 37 | x = (x * x) % d; 38 | n = n / 2; 39 | } 40 | if (!sign) { 41 | ans = -1 * ans; 42 | } 43 | if (ans < 0) { 44 | while (ans < 0) { 45 | ans += d; 46 | } 47 | } 48 | return ans; 49 | } 50 | -------------------------------------------------------------------------------- /Cpp/Binary-Search/matrix-median.cpp: -------------------------------------------------------------------------------- 1 | int Solution::findMedian(vector > &A) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 0) { 6 | return 0; 7 | } 8 | if (A[0].size() <= 0) { 9 | return 0; 10 | } 11 | vector B; 12 | 13 | // simply find the median by returning the mid element 14 | 15 | for (int i = 0; i < A.size(); i ++) { 16 | for (int j = 0; j < A[0].size(); j ++) { 17 | B.push_back(A[i][j]); 18 | } 19 | } 20 | sort(B.begin(), B.end()); 21 | int mid = (B.size() - 1) / 2; 22 | return B[mid]; 23 | } 24 | -------------------------------------------------------------------------------- /Cpp/Binary-Search/matrix-search.cpp: -------------------------------------------------------------------------------- 1 | int Solution::searchMatrix(vector > &A, int B) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 0) { 6 | return 0; 7 | } 8 | if (A[0].size() <= 0) { 9 | return 0; 10 | } 11 | 12 | // Finds which row to perform Binary Search in 13 | 14 | int start = 0; 15 | int end = A[0].size() - 1; 16 | int index = 0; 17 | int widthIndex = A[0].size() - 1; 18 | for (int i = 0; i < A.size(); i ++) { 19 | if (B > A[i][A[i].size() - 1]) { 20 | index = i + 1; 21 | } else break; 22 | } 23 | if (index == A.size()) { 24 | return 0; 25 | } 26 | 27 | // Binary Search from start to end(possible values) 28 | 29 | while (start <= end) { 30 | int mid = start + (end - start) / 2; 31 | if (A[index][mid] == B) { 32 | return 1; 33 | } else if (A[index][mid] > B) { 34 | end = mid - 1; 35 | } else if (A[index][mid] < B) { 36 | start = mid + 1; 37 | } 38 | } 39 | return 0; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /Cpp/Binary-Search/painters-partition-problem.cpp: -------------------------------------------------------------------------------- 1 | #define MOD 10000003 2 | 3 | // isPossibleFunction to check if the number of painters exceed for a value 4 | 5 | bool isPossible(int A, int B, vector &C, long long int minTime) { 6 | long long int curMin = 0; 7 | int count = 1; 8 | for (int i = 0; i < C.size(); i ++) { 9 | if ((C[i]) % MOD > minTime) { 10 | return false; 11 | } 12 | 13 | if ((curMin + C[i]) % MOD <= minTime) { 14 | (curMin += C[i]) % MOD; 15 | } else { 16 | count ++; 17 | (curMin = C[i]) % MOD; 18 | } 19 | } 20 | if (count > A) { 21 | return false; 22 | } 23 | return 1; 24 | } 25 | int Solution::paint(int A, int B, vector &C) { 26 | long long int sum = 0; 27 | 28 | // Sum of all the elements 29 | 30 | for (int i = 0; i < C.size(); i ++) { 31 | sum += C[i]; 32 | } 33 | 34 | // Binary Search from start to end(possible values) 35 | 36 | long long int maxi = INT_MIN; 37 | long long int end = ((sum % MOD)); 38 | long long int start = 0; 39 | long long res = INT_MAX; 40 | while (start <= end) { 41 | long long int mid = (start + (end - start) / 2); 42 | if (isPossible(A, B, C, mid)) { 43 | res = min(mid, res); 44 | end = mid - 1; 45 | } else { 46 | start = mid + 1; 47 | } 48 | } 49 | return (res * (long long) B) % MOD; 50 | } 51 | -------------------------------------------------------------------------------- /Cpp/Binary-Search/rotated-sorted-array-search.cpp: -------------------------------------------------------------------------------- 1 | int Solution::search(const vector &A, int B) { 2 | int start = 0; 3 | int end = A.size() - 1; 4 | int pivot; 5 | start = 0; 6 | end = A.size() - 1; 7 | 8 | // Binary Search based on different cases for a rotated matrix 9 | 10 | while (start <= end) { 11 | int mid = ((start + end) / 2) % A.size(); 12 | if (A[mid] == B) { 13 | return mid; 14 | } else if (A[mid] <= A[end]) { 15 | if (B >= A[mid] && B <= A[end]) { 16 | start = mid + 1; 17 | } else { 18 | end = mid - 1; 19 | } 20 | } else if (A[start] <= A[mid]) { 21 | if (B >= A[start] && B <= A[mid]) { 22 | end = mid - 1; 23 | } else { 24 | start = mid + 1; 25 | } 26 | } 27 | } 28 | return -1; 29 | } 30 | -------------------------------------------------------------------------------- /Cpp/Binary-Search/search-for-a-range.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to implement Binary Search 2 | 3 | int findIndex(const vector &A, int B, bool check) { 4 | int result = -1; 5 | int start = 0, end = A.size() - 1; 6 | while (start <= end) { 7 | int mid = start + (end - start) / 2; 8 | if (A[mid] == B) { 9 | result = mid; 10 | if (check) { 11 | end = mid - 1; 12 | } else { 13 | start = mid + 1; 14 | } 15 | } else if (A[mid] > B) { 16 | end = mid - 1; 17 | } else if (A[mid] < B) { 18 | start = mid + 1; 19 | } 20 | } 21 | return result; 22 | } 23 | vector Solution::searchRange(const vector &A, int B) { 24 | 25 | // Corner case 26 | 27 | vector C; 28 | if (A.size() <= 0) { 29 | return C; 30 | } 31 | 32 | // Boolean value indicates lower or upper bound index 33 | 34 | C.push_back(findIndex(A, B, 1)); 35 | C.push_back(findIndex(A, B, 0)); 36 | return C; 37 | } 38 | 39 | -------------------------------------------------------------------------------- /Cpp/Binary-Search/sorted-insert-position.cpp: -------------------------------------------------------------------------------- 1 | int Solution::searchInsert(vector &A, int B) { 2 | 3 | // Binary Search from start to end 4 | 5 | int start = 0, end = A.size() - 1; 6 | while (start <= end) { 7 | int mid = start + (end - start) / 2; 8 | if (A[mid] == B) { 9 | return mid; 10 | } else if (A[mid] > B) { 11 | end = mid - 1; 12 | } else if (A[mid] < B) { 13 | start = mid + 1; 14 | } 15 | } 16 | return start; 17 | } 18 | -------------------------------------------------------------------------------- /Cpp/Binary-Search/square-root-of-integer.cpp: -------------------------------------------------------------------------------- 1 | int Solution::sqrt(int A) { 2 | 3 | // Corner case 4 | 5 | if (A == 1) { 6 | return 1; 7 | } 8 | 9 | // Binary search from start to end(possible values of square roor) 10 | 11 | int start = 1, end = A / 2; 12 | int result; 13 | while (start <= end) { 14 | long long mid = start + (end - start) / 2; 15 | if (mid * mid < A) { 16 | result = mid; 17 | start = mid + 1; 18 | } else if (mid * mid > A) { 19 | end = mid - 1; 20 | } else if (mid * mid == A) { 21 | return mid; 22 | } 23 | } 24 | return result; 25 | } 26 | -------------------------------------------------------------------------------- /Cpp/Bit-Manipulation/different-bits-sum-pairwise.cpp: -------------------------------------------------------------------------------- 1 | int Solution::cntBits(vector &A) { 2 | 3 | // Same concept as Hamming Distance problem 4 | 5 | long long countT = 0; 6 | int count1 = 0; 7 | int count2 = 0; 8 | for (int i = 0; i < 32; i ++) { 9 | for (int j = 0; j < A.size(); j ++) { 10 | if (((A[j] >> i) & 1U)) { 11 | count1 ++; 12 | } 13 | } 14 | countT += (count1 * (A.size() - count1) * 2); 15 | count1 = 0; 16 | } 17 | return (countT) % (int)(pow(10, 9) + 7); 18 | } 19 | -------------------------------------------------------------------------------- /Cpp/Bit-Manipulation/divide-integers.cpp: -------------------------------------------------------------------------------- 1 | int Solution::divide(int A, int B) { 2 | int sign = 1; 3 | 4 | // Use A and B as long long ints 5 | 6 | long long int q = 0, tmp = 0, ANew = A, BNew = B; 7 | 8 | // store the sign of the result 9 | 10 | if (ANew * BNew < 0) sign = -1; 11 | 12 | // Corner case 13 | 14 | if ((ANew == INT_MIN && BNew == -1) || BNew == 0) return INT_MAX; 15 | 16 | // Change A and B to positive values 17 | 18 | ANew = abs(ANew); 19 | BNew = abs(BNew); 20 | 21 | // Find the first bit for which B << i is less than A 22 | 23 | for (int i = 31; i >= 0; i--) { 24 | if (tmp + (BNew << i) <= ANew) { 25 | tmp += BNew << i; 26 | q |= 1LL << i; 27 | } 28 | } 29 | return (int)(sign * q); 30 | } -------------------------------------------------------------------------------- /Cpp/Bit-Manipulation/min-xor-value.cpp: -------------------------------------------------------------------------------- 1 | int Solution::findMinXor(vector &A) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 1) { 6 | return 0; 7 | } 8 | 9 | // We sort the array and check adjacent items for min XOR value 10 | 11 | sort(A.begin(), A.end()); 12 | int mini = INT_MAX; 13 | for (int i = 0; i < A.size() - 1; i ++) { 14 | if ((A[i] ^ A[i + 1]) < mini) { 15 | mini = (A[i] ^ A[i + 1]); 16 | } 17 | } 18 | return mini; 19 | } 20 | -------------------------------------------------------------------------------- /Cpp/Bit-Manipulation/number-of-1-bits.cpp: -------------------------------------------------------------------------------- 1 | // A & A - 1 unsets the lowest set bit 2 | // so we just count until A == 0 3 | 4 | int Solution::numSetBits(unsigned int A) { 5 | int tot = 0; 6 | while (A != 0) { 7 | A = A & (A - 1); 8 | tot ++; 9 | } 10 | return tot; 11 | } 12 | -------------------------------------------------------------------------------- /Cpp/Bit-Manipulation/reverse-bits.cpp: -------------------------------------------------------------------------------- 1 | // We just shift the bits and use the XOR operator to reverse bits 2 | 3 | int swapBits(unsigned int x, int i, int j) { 4 | int lo = ((x >> i) & 1); 5 | int hi = ((x >> j) & 1); 6 | if (lo ^ hi) { 7 | x ^= ((1U << i) | (1U << j)); 8 | } 9 | return x; 10 | } 11 | unsigned int Solution::reverse(unsigned int x) { 12 | for (int i = 0; i < 16; i ++) { 13 | x = swapBits(x, i, 32 - i - 1); 14 | } 15 | return x; 16 | } 17 | -------------------------------------------------------------------------------- /Cpp/Bit-Manipulation/single-number-ii.cpp: -------------------------------------------------------------------------------- 1 | int Solution::singleNumber(const vector &A) { 2 | 3 | // We will have 3x + 1 bits in one position 4 | // we find the remainder on division by 3 5 | // and return the element 6 | 7 | int count[32] = {0}; 8 | int result = 0; 9 | for (int i = 0; i < 32; i++) { 10 | for (int j = 0; j < A.size(); j++) { 11 | if ((A[j] >> i) & 1) { 12 | count[i]++; 13 | } 14 | } 15 | result |= ((count[i] % 3) << i); 16 | } 17 | return result; 18 | } -------------------------------------------------------------------------------- /Cpp/Bit-Manipulation/single-number.cpp: -------------------------------------------------------------------------------- 1 | int Solution::singleNumber(const vector &A) { 2 | 3 | // The XOR of a number with itself is zero 4 | // However the XOR of a number with 0 is 0 5 | 6 | int num = 0; 7 | for (int i = 0; i < A.size(); i ++) { 8 | num = num ^ A[i]; 9 | } 10 | return num; 11 | } 12 | -------------------------------------------------------------------------------- /Cpp/Checkpoints/Level3/prettyprint.cpp: -------------------------------------------------------------------------------- 1 | vector > Solution::prettyPrint(int A) { 2 | vector> res(2 * A - 1, vector(2 * A - 1)); 3 | int top = 0, bottom = res.size() - 1, left = 0, right = res[0].size() - 1; 4 | 5 | // Proceed in the same way as spiral matrix 6 | 7 | while (left <= right && top <= bottom) { 8 | for (int i = left; i <= right; i ++) { 9 | res[top][i] = A; 10 | } 11 | top ++; 12 | for (int i = top; i <= bottom; i ++) { 13 | res[i][right] = A; 14 | } 15 | right --; 16 | for (int i = right; i >= left; i --) { 17 | res[bottom][i] = A; 18 | } 19 | bottom --; 20 | for (int i = bottom; i >= top; i --) { 21 | res[i][left] = A; 22 | } 23 | left ++; 24 | A --; 25 | } 26 | return res; 27 | } 28 | -------------------------------------------------------------------------------- /Cpp/Hashing/2-sum.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::twoSum(const vector &A, int B) { 2 | vector C; 3 | 4 | // Corner case 5 | 6 | if (A.size() < 2) { 7 | return C; 8 | } 9 | 10 | // Use an unordered map that takes key as the element and value as an array of indices of the element in the array 11 | 12 | unordered_map> map; 13 | 14 | // Insert the indices into the map(1 bases indices) 15 | 16 | for (int i = 0; i < A.size(); i ++) { 17 | map[A[i]].push_back(i + 1); 18 | } 19 | 20 | // Loop through the array and check if for an element A[i], B - A[i] exists 21 | // If it does, check if the index is not equal to the current index(for corner case when both the elements are same) 22 | 23 | int index2 = INT_MAX, index1 = INT_MIN; 24 | int i = 0; int j = A.size() - 1; 25 | for (int i = 0; i < A.size(); i ++) { 26 | if (map.find(B - A[i]) != map.end()) { 27 | int index1Temp = INT_MAX; 28 | 29 | // Loop through the list in the map and choose the first index which is not equal to the current index 30 | 31 | for (int j = 0; j < map[B - A[i]].size(); j ++) { 32 | if (map[B - A[i]][j] != i + 1) { 33 | index1Temp = map[B - A[i]][j]; 34 | break; 35 | } 36 | } 37 | 38 | // Choose index2Temp as the larger element 39 | 40 | int index2Temp = i + 1; 41 | if (index1Temp > index2Temp) { 42 | swap(index1Temp, index2Temp); 43 | } 44 | 45 | // If index2Temp is the smallest one yet, set it to the current one 46 | 47 | if (index2Temp < index2) { 48 | index2 = index2Temp; 49 | index1 = index1Temp; 50 | } 51 | } 52 | } 53 | if (index1 == INT_MIN || index2 == INT_MAX) { 54 | return C; 55 | } 56 | C.push_back(index1); 57 | C.push_back(index2); 58 | return C; 59 | } 60 | -------------------------------------------------------------------------------- /Cpp/Hashing/4-sum.cpp: -------------------------------------------------------------------------------- 1 | vector > Solution::fourSum(vector &A, int B) { 2 | vector> C; 3 | vector temp; 4 | 5 | // Run 4 loops and check for the solution(I know this is the naive solution, I'll work on it again later) 6 | // Watch this space for a cleaner solution in the future 7 | 8 | for (int i = 0; i < A.size(); i ++) { 9 | for (int j = i + 1; j < A.size(); j ++) { 10 | for (int m = j + 1; m < A.size(); m ++) { 11 | for (int n = m + 1; n < A.size(); n ++) { 12 | if (A[i] + A[j] + A[m] + A[n] == B && i != j && j != m && m != n) { 13 | temp.push_back(A[i]); 14 | temp.push_back(A[j]); 15 | temp.push_back(A[m]); 16 | temp.push_back(A[n]); 17 | sort(temp.begin(), temp.end()); 18 | C.push_back(temp); 19 | temp.clear(); 20 | } 21 | } 22 | } 23 | } 24 | } 25 | sort(C.begin(), C.end()); 26 | C.erase(unique(C.begin(), C.end()), C.end()); 27 | return C; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /Cpp/Hashing/anagrams.cpp: -------------------------------------------------------------------------------- 1 | vector > Solution::anagrams(const vector &A) { 2 | vector> B; 3 | vector C = A; 4 | 5 | // Use a map with key as the sorted value of a string and value as a vector of integers 6 | 7 | unordered_map> umap; 8 | 9 | string temp; 10 | 11 | // Corner case 12 | 13 | if (A.size() <= 0) { 14 | return B; 15 | } 16 | 17 | // Push the indices in the specified array based on the sorting value 18 | 19 | for (int i = 0; i < C.size(); i ++) { 20 | temp = C[i]; 21 | sort(C[i].begin(), C[i].end()); 22 | umap[C[i]].push_back(i + 1); 23 | } 24 | 25 | // Iterate through the map 26 | 27 | for (unordered_map>::iterator it = umap.begin(); it != umap.end(); it ++) { 28 | sort(it -> second.begin(), it -> second.end()); 29 | B.push_back(it -> second); 30 | } 31 | return B; 32 | } 33 | -------------------------------------------------------------------------------- /Cpp/Hashing/colorful-number.cpp: -------------------------------------------------------------------------------- 1 | int Solution::colorful(int A) { 2 | string B = to_string(A); 3 | string k; 4 | long long int mul = 1; 5 | unordered_map> C; 6 | 7 | // Hash the values according to the multiplication value of individual digits in the substrings 8 | 9 | for (int i = 1; i <= B.size(); i ++) { 10 | for (int j = 0; j < B.size(); j += 1) { 11 | if (j + i > B.size()) { 12 | break; 13 | } 14 | k = B.substr(j, i); 15 | for (int p = 0; p < k.size(); p ++) { 16 | mul = mul * (k[p] - '0'); 17 | } 18 | C[mul].push_back(k); 19 | mul = 1; 20 | } 21 | } 22 | 23 | // If any subsequence has more than one member, return 0 else return 1 24 | 25 | for (unordered_map>::iterator it = C.begin(); it != C.end(); it ++) { 26 | if (it -> second.size() > 1) { 27 | return 0; 28 | } 29 | } 30 | return 1; 31 | } 32 | -------------------------------------------------------------------------------- /Cpp/Hashing/copy-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct RandomListNode { 4 | * int label; 5 | * RandomListNode *next, *random; 6 | * RandomListNode(int x) : label(x), next(NULL), random(NULL) {} 7 | * }; 8 | */ 9 | RandomListNode* Solution::copyRandomList(RandomListNode* A) { 10 | 11 | // Use 2 maps 12 | // One to map new nodes to orignal nodes 13 | // Other to map original nodes to the new nodes 14 | 15 | unordered_map map; 16 | unordered_map map2; 17 | RandomListNode* head = A; 18 | RandomListNode* newHead, *B, *prev = NULL; 19 | 20 | // Corner case 21 | 22 | if (A == NULL) { 23 | return NULL; 24 | } 25 | 26 | // Create a copy of the nodes and assign correct pointers 27 | // Also store the values in the 2 maps 28 | 29 | while (A) { 30 | newHead = new RandomListNode(A -> label); 31 | if (prev) { 32 | prev -> next = newHead; 33 | } else { 34 | B = newHead; 35 | } 36 | prev = newHead; 37 | map[newHead] = A; 38 | map2[A] = newHead; 39 | A = A -> next; 40 | } 41 | newHead = B; 42 | 43 | // Map random pointers of the new nodes in 2 steps: 44 | // 1) Point new node to the original node 45 | // 2) Map random pointer of the original node to the new node 46 | 47 | while (newHead) { 48 | newHead -> random = map2[map[newHead] -> random]; 49 | newHead = newHead -> next; 50 | } 51 | return B; 52 | } 53 | -------------------------------------------------------------------------------- /Cpp/Hashing/diffk-ii.cpp: -------------------------------------------------------------------------------- 1 | int Solution::diffPossible(const vector &A, int B) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 0) { 6 | return 0; 7 | } 8 | bool flag = false; 9 | unordered_map umap; 10 | 11 | // Use a map to check the existence of elements in the array 12 | 13 | for (int i = 0; i < A.size(); i ++) { 14 | if (umap.find(A[i]) != umap.end()) { 15 | flag = true; 16 | } else { 17 | umap[A[i]] = 1; 18 | } 19 | } 20 | 21 | // Flag identifies the case when B = 0 22 | 23 | if (B != 0) { 24 | 25 | // Check if there exists an element A[i] + B or A[i] - B 26 | 27 | for (int i = 0; i < A.size(); i ++) { 28 | if (umap.find(A[i] + B) != umap.end() || umap.find(A[i] - B) != umap.end()) { 29 | return 1; 30 | } 31 | } 32 | } else return flag; 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /Cpp/Hashing/largest-continuous-sequence-zero-sum.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::lszero(vector &A) { 2 | int maxi = INT_MIN, i = 0, j = i + 1, sum = 0, index1 = -1, index2 = -1; 3 | unordered_map map; 4 | bool newCheck = false; 5 | vector C; 6 | map[0] = -1; 7 | 8 | // Store the subarray values according to the sum of the subsequence 9 | 10 | for (int i = 0; i < A.size(); i ++) { 11 | sum += A[i]; 12 | if (map.find(sum) != map.end()) { 13 | newCheck = true; 14 | 15 | // Compare for the maximum length 16 | 17 | if (i - (map[sum] + 1) + 1 > maxi) { 18 | maxi = i - (map[sum] + 1) + 1; 19 | index1 = (map[sum] + 1); 20 | index2 = i; 21 | } 22 | } else { 23 | map[sum] = i; 24 | } 25 | } 26 | if (newCheck) { 27 | for (int i = index1; i <= index2 && index1 != -1 && index2 != -1; i ++) { 28 | C.push_back(A[i]); 29 | } 30 | } 31 | return C; 32 | } 33 | -------------------------------------------------------------------------------- /Cpp/Hashing/longest-substring-without-repeat.cpp: -------------------------------------------------------------------------------- 1 | int Solution::lengthOfLongestSubstring(string A) { 2 | unordered_map map; 3 | int i = 0; 4 | int j = i + 1; 5 | 6 | // Corner case 7 | 8 | if (A.size() < 2) { 9 | return A.size(); 10 | } 11 | int maxi = INT_MIN; 12 | 13 | // Start with 2 pointers at the beginning 14 | // Store the indices of the values in the map 15 | // Compare for the longeest length 16 | 17 | while (i < A.size() && j < A.size()) { 18 | map[A[i]] = i; 19 | if (j == i && j < A.size()) { 20 | j ++; 21 | } 22 | if (map.find(A[j]) != map.end()) { 23 | maxi = max(maxi, j - i); 24 | i = map[A[j]] + 1; 25 | j = i; 26 | map.clear(); 27 | } else { 28 | map[A[j]] = j; 29 | j ++; 30 | } 31 | } 32 | int size = A.size(); 33 | if (j == A.size()) { 34 | maxi = max(maxi, size - i); 35 | } 36 | return maxi; 37 | } 38 | -------------------------------------------------------------------------------- /Cpp/Hashing/points-on-the-straight-line.cpp: -------------------------------------------------------------------------------- 1 | int Solution::maxPoints(vector &A, vector &B) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 0) { 6 | return 0; 7 | } 8 | int maxi = 1; 9 | unordered_map map; 10 | 11 | // Store the slopes of the lines in a map 12 | // Also keep a track of the identical points and points on a vertical line 13 | // Every non-identical points will be on a line 14 | 15 | for (int i = 0; i < A.size(); i ++) { 16 | int duplicates = 1, verticals = 0; 17 | for (int j = i + 1; j < B.size(); j ++) { 18 | float slope; 19 | if (A[i] == A[j]) { 20 | if (B[i] == B[j]) { 21 | duplicates ++; 22 | } else { 23 | verticals ++; 24 | } 25 | } else { 26 | if (B[i] != B[j]) { 27 | slope = (A[j] - A[i]) / (float)(B[j] - B[i]); 28 | } else slope = 0.0; 29 | if (map.find(slope) != map.end()) { 30 | map[slope] ++; 31 | } else map[slope] = 1; 32 | } 33 | } 34 | 35 | // Find the maximum number of points from the map 36 | // Whilst keeping track of the verticals and the duplicates 37 | 38 | for (unordered_map::iterator it = map.begin(); it != map.end(); it ++) { 39 | maxi = max(maxi, it -> second + duplicates); 40 | } 41 | maxi = max(verticals + duplicates, maxi); 42 | map.clear(); 43 | } 44 | return maxi; 45 | } 46 | -------------------------------------------------------------------------------- /Cpp/Hashing/valid-sudoku.cpp: -------------------------------------------------------------------------------- 1 | int Solution::isValidSudoku(const vector &A) { 2 | unordered_map map; 3 | 4 | // Check if a number is repeated in every row 5 | 6 | for (int i = 0; i < A.size(); i ++) { 7 | for (int j = 0; j < A[i].size();j ++) { 8 | if (A[i][j] != '.') { 9 | if (map.find(A[i][j] - '0') != map.end()) { 10 | return 0; 11 | } else { 12 | map[A[i][j] - '0'] = 1; 13 | } 14 | } 15 | } 16 | map.clear(); 17 | } 18 | 19 | // Check if a number is repeated in every column 20 | 21 | for (int i = 0; i < A.size(); i ++) { 22 | for (int j = 0; j < A[i].size();j ++) { 23 | if (A[j][i] != '.') { 24 | if (map.find(A[j][i] - '0') != map.end()) { 25 | return 0; 26 | } else { 27 | map[A[j][i] - '0'] = 1; 28 | } 29 | } 30 | } 31 | map.clear(); 32 | } 33 | 34 | // Check the 3X3 matrices for a repeated number 35 | 36 | for (int m = 0; m < 3; m ++) { 37 | for (int n = 0; n < 3; n ++) { 38 | for (int i = m * 3; i < m * 3 + 3; i ++) { 39 | for (int j = n * 3; j < n * 3 + 3;j ++) { 40 | if (A[i][j] != '.') { 41 | if (map[A[i][j] - '0'] == 1) { 42 | return 0; 43 | } else { 44 | map[A[i][j] - '0'] = 1; 45 | } 46 | } 47 | } 48 | } 49 | map.clear(); 50 | } 51 | } 52 | return 1; 53 | } 54 | 55 | -------------------------------------------------------------------------------- /Cpp/Heaps-And-Maps/magician-and-chocolates.cpp: -------------------------------------------------------------------------------- 1 | #define DIV 1000000007 2 | int Solution::nchoc(int A, vector &B) { 3 | long long res = 0; 4 | priority_queue q; 5 | for (int i = 0; i < B.size(); i ++) { 6 | q.push(B[i]); 7 | } 8 | for (int i = 0; i < A; i ++) { 9 | if (!q.empty()) { 10 | int temp = q.top(); 11 | res += temp % DIV; 12 | q.pop(); 13 | if (floor(temp / 2) != 0) { 14 | q.push(floor(temp / 2)); 15 | } 16 | } else { 17 | break; 18 | } 19 | } 20 | return res % DIV; 21 | } 22 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Examples/intersection-of-linked-lists.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::getIntersectionNode(ListNode* A, ListNode* B) { 10 | 11 | // Get lengths of both the lists 12 | 13 | ListNode* headA = A; 14 | ListNode* headB = B; 15 | int length1 = 0, length2 = 0; 16 | while (B) { 17 | length2 ++; 18 | B = B -> next; 19 | } 20 | while (A) { 21 | length1 ++; 22 | A = A -> next; 23 | } 24 | A = headA; 25 | B = headB; 26 | 27 | // Compare both pointer values until at least one of the list ends 28 | 29 | if (length1 < length2) { 30 | for (int i = 0; i < length2 - length1; i ++) { 31 | B = B -> next; 32 | } 33 | } else if (length1 > length2) { 34 | for (int i = 0; i < length1 - length2; i ++) { 35 | A = A -> next; 36 | } 37 | } 38 | 39 | // Append the remaining part to the list 40 | 41 | while (A && B) { 42 | if (A != B) { 43 | A = A -> next; 44 | B = B -> next; 45 | } else { 46 | return A; 47 | } 48 | } 49 | return NULL; 50 | } 51 | 52 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Examples/reverse-linked-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::reverseList(ListNode* A) { 10 | ListNode* head = A; 11 | ListNode* next = NULL; 12 | ListNode* prev = NULL; 13 | ListNode* cur = A; 14 | 15 | // Reverse a Linked List by keeping track of prev and next nodes 16 | 17 | while (cur && cur -> next) { 18 | next = cur -> next; 19 | cur -> next = prev; 20 | prev = cur; 21 | cur = next; 22 | } 23 | cur -> next = prev; 24 | return cur; 25 | } -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/add-two-numbers-as-lists.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::addTwoNumbers(ListNode* A, ListNode* B) { 10 | int C = 0; 11 | ListNode* head = A; 12 | ListNode *prev = NULL; 13 | 14 | // Corner cases 15 | 16 | if (A == NULL) { 17 | return B; 18 | } else if (B == NULL) { 19 | return A; 20 | } 21 | 22 | // Perform normal addition with sum and carry terems 23 | 24 | while (A && B) { 25 | int num = A -> val + B -> val + C; 26 | int val = num % 10; 27 | A -> val = val; 28 | C = num / 10; 29 | prev = A; 30 | A = A -> next; 31 | B = B -> next; 32 | } 33 | 34 | // Perform link handling on addition 35 | 36 | if (A == NULL && B == NULL) { 37 | if (C == 0) { 38 | return head; 39 | } else { 40 | prev -> next = new ListNode(C); 41 | return head; 42 | } 43 | } else if (A == NULL) { 44 | prev -> next = B; 45 | while (B) { 46 | int num = B -> val + C; 47 | int val = num % 10; 48 | B -> val = val; 49 | C = num / 10; 50 | prev = B; 51 | B = B -> next; 52 | } 53 | if (C == 0) { 54 | return head; 55 | } else { 56 | prev -> next = new ListNode(C); 57 | return head; 58 | } 59 | return head; 60 | } else if (B == NULL) { 61 | prev -> next = A; 62 | while (A) { 63 | int num = A -> val + C; 64 | int val = num % 10; 65 | A -> val = val; 66 | C = num / 10; 67 | prev = A; 68 | A = A -> next; 69 | } 70 | if (C == 0) { 71 | return head; 72 | } else { 73 | prev -> next = new ListNode(C); 74 | return head; 75 | } 76 | return head; 77 | } 78 | return head; 79 | } 80 | 81 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/insertion-sort-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | // Global variable used for checking of the new Element inserted at the beginning 10 | 11 | bool isHead = false; 12 | 13 | // Helper function to insert a node into the list 14 | 15 | ListNode* insert(ListNode* head, ListNode* A, ListNode* B, ListNode* prev, ListNode* next, int count) { 16 | if (prev == NULL) { 17 | ListNode* temp = head; 18 | return NULL; 19 | } 20 | ListNode* pre = NULL; 21 | for (int i = 0; i < count; i ++) { 22 | if (B -> val >= A -> val) { 23 | if (pre == NULL) { 24 | head = A; 25 | A -> next = B; 26 | prev -> next = next; 27 | ListNode* temp = head; 28 | while (temp) { 29 | temp = temp -> next; 30 | } 31 | isHead = true; 32 | return head; 33 | } else { 34 | pre -> next = A; 35 | } 36 | A -> next = B; 37 | prev -> next = next; 38 | ListNode* temp = head; 39 | return B; 40 | } 41 | pre = B; 42 | B = B -> next; 43 | } 44 | return NULL; 45 | } 46 | ListNode* Solution::insertionSortList(ListNode* A) { 47 | isHead = false; 48 | ListNode* head = A; 49 | int length = 0; 50 | 51 | // Find the length of the list 52 | 53 | while (A) { 54 | length ++; 55 | A = A -> next; 56 | } 57 | A = head; 58 | ListNode* B = A; 59 | ListNode* next = NULL; 60 | ListNode* prev = NULL; 61 | ListNode* cur = A; 62 | int count = -1; 63 | 64 | // Perform insertions in the list one by one 65 | 66 | while (cur) { 67 | isHead = false; 68 | count ++; 69 | next = cur -> next; 70 | ListNode* tempNode = insert(head, cur, B, prev, next, count); 71 | if (isHead) { 72 | head = tempNode; 73 | isHead = false; 74 | } 75 | if (tempNode == NULL) { 76 | prev = cur; 77 | } 78 | cur = next; 79 | B = head; 80 | } 81 | return head; 82 | } 83 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/k-reverse-linked-list.cpp: -------------------------------------------------------------------------------- 1 | ListNode* Solution::reverseList(ListNode* A, int B) { 2 | 3 | // Corner case 4 | 5 | if (B == 1) { 6 | return A; 7 | } 8 | ListNode* head = A; 9 | ListNode* next = NULL; 10 | ListNode* prev = NULL; 11 | ListNode* cur = A; 12 | ListNode* prevReal = cur; 13 | 14 | // Get k reverse Linked List by using Recursion 15 | 16 | for (int i = 0; i < B && cur; i ++) { 17 | next = cur -> next; 18 | cur -> next = prev; 19 | prev = cur; 20 | cur = next; 21 | } 22 | if (prevReal) { 23 | prevReal -> next = reverseList(cur, B); 24 | } 25 | return prev; 26 | } 27 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/list-cycle.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::detectCycle(ListNode* A) { 10 | 11 | // Alternate solution 12 | 13 | /* 14 | map B; 15 | while (A) { 16 | if (B[A]) { 17 | return A; 18 | } else { 19 | B[A] = 1; 20 | } 21 | A = A -> next; 22 | } 23 | return NULL; 24 | */ 25 | 26 | ListNode* slow = A; 27 | ListNode* fast = A; 28 | bool isCycle = false; 29 | 30 | // Use 2 pointers fast and slow where fast moves twice the pace of slow 31 | // Flloyd's Cycle Finding alogorithm 32 | 33 | while (fast && fast -> next) { 34 | fast = fast -> next; 35 | if (fast -> next) { 36 | slow = slow -> next; 37 | fast = fast -> next; 38 | } else break; 39 | if (slow == fast) { 40 | isCycle = true; 41 | break; 42 | } 43 | } 44 | if (isCycle) { 45 | slow = A; 46 | while (slow != fast) { 47 | fast = fast -> next; 48 | slow = slow -> next; 49 | } 50 | return slow; 51 | } else return NULL; 52 | } 53 | 54 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/merge-two-sorted-lists.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::mergeTwoLists(ListNode* A, ListNode* B) { 10 | ListNode *C, *D; 11 | bool isFirst = true; 12 | 13 | // Compare the 2 pointers to the lists and merge them by moving the pointer with smaller value 14 | 15 | while (A != NULL && B != NULL) { 16 | if (A -> val <= B -> val) { 17 | if (isFirst) { 18 | C = new ListNode(A -> val); 19 | D = C; 20 | isFirst = false; 21 | } else { 22 | C -> next = new ListNode(A -> val); 23 | C = C -> next; 24 | } 25 | A = A -> next; 26 | } else { 27 | if (isFirst) { 28 | C = new ListNode(B -> val); 29 | D = C; 30 | isFirst = false; 31 | } else { 32 | C -> next = new ListNode(B -> val); 33 | C = C -> next; 34 | } 35 | B = B -> next; 36 | } 37 | } 38 | 39 | // Append non null list to the end of the list 40 | 41 | if (A == NULL && B == NULL) { 42 | return D; 43 | } else if (B == NULL) { 44 | while (A != NULL) { 45 | C -> next = new ListNode(A -> val); 46 | C = C -> next; 47 | A = A -> next; 48 | } 49 | } else if (A == NULL) { 50 | while (B != NULL) { 51 | C -> next = new ListNode(B -> val); 52 | C = C -> next; 53 | B = B -> next; 54 | } 55 | } 56 | return D; 57 | } 58 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/palindrome-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | int Solution::lPalin(ListNode* A) { 10 | int length = 0; 11 | ListNode *head = A; 12 | 13 | // Find the length of the Linked List 14 | 15 | while (A) { 16 | length ++; 17 | A = A -> next; 18 | } 19 | A = head; 20 | 21 | // Determine where to reverse the Linked List 22 | 23 | ListNode *B = head; 24 | if (length % 2 == 1) { 25 | for (int i = 0; i < length / 2 + 1; i ++) { 26 | B = B -> next; 27 | } 28 | } else { 29 | for (int i = 0; i < length / 2; i ++) { 30 | B = B -> next; 31 | } 32 | } 33 | ListNode *prev = NULL; 34 | ListNode *cur = B; 35 | ListNode *next; 36 | while (cur) { 37 | next = cur -> next; 38 | cur -> next = prev; 39 | prev = cur; 40 | cur = next; 41 | } 42 | 43 | // Compare the values from start of the first half and end of the second reversed half of the Linked List 44 | 45 | while (prev) { 46 | if (prev -> val == head -> val) { 47 | prev = prev -> next; 48 | head = head -> next; 49 | } else { 50 | return 0; 51 | } 52 | } 53 | return 1; 54 | } 55 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/partition-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::partition(ListNode* A, int B) { 10 | ListNode* head = A; 11 | ListNode* prev = NULL; 12 | 13 | // Find pointer where A -> val >= B 14 | 15 | while (A && A -> val < B) { 16 | prev = A; 17 | A = A -> next; 18 | } 19 | ListNode* tempHead = A; 20 | if (A == NULL) { 21 | return head; 22 | } 23 | A = tempHead -> next; 24 | if (A == NULL) { 25 | return head; 26 | } 27 | ListNode* next = NULL; 28 | ListNode* pre = tempHead; 29 | 30 | // Loop until the end of the list and swap the elements before A found above 31 | 32 | while (A) { 33 | if (A -> val < B) { 34 | next = A -> next; 35 | pre -> next = next; 36 | if (prev == NULL) { 37 | head = A; 38 | } else { 39 | prev -> next = A; 40 | } 41 | A -> next = tempHead; 42 | prev = A; 43 | A = next; 44 | } else { 45 | pre = A; 46 | A = A -> next; 47 | } 48 | } 49 | return head; 50 | } 51 | 52 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/remove-duplicates-from-sorted-list-ii.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::deleteDuplicates(ListNode* A) { 10 | 11 | // Removing duplicates by comparing adjacent elements and keeping track of previous pointer 12 | 13 | ListNode* head = A; 14 | ListNode *prev = NULL; 15 | while (A != NULL && A -> next != NULL) { 16 | //cout << "here" << A -> val; 17 | if (A -> val == A -> next -> val) { 18 | //cout << "here" << A -> val; 19 | ListNode *B = A -> next; 20 | //cout << B -> val; 21 | while (B != NULL && B -> val == A -> val) { 22 | B = B -> next; 23 | } 24 | if (B == NULL) { 25 | if (prev == NULL) { 26 | return NULL; 27 | } else { 28 | prev -> next = NULL; 29 | return head; 30 | } 31 | } else { 32 | if (prev == NULL) { 33 | head = B; 34 | A = B; 35 | } else { 36 | prev -> next = B; 37 | A = B; 38 | } 39 | continue; 40 | } 41 | } 42 | prev = A; 43 | A = A -> next; 44 | } 45 | 46 | return head; 47 | } 48 | 49 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/remove-duplicates-from-sorted-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::deleteDuplicates(ListNode* A) { 10 | ListNode* head = A; 11 | 12 | // Removing duplicates by comparing adjacent elements 13 | 14 | while (A -> next != NULL) { 15 | if (A -> val == A -> next -> val) { 16 | ListNode* B = A -> next; 17 | while (B -> val == A -> val && B -> next != NULL) { 18 | B = B -> next; 19 | } 20 | if (B -> val == A -> val) { 21 | A -> next = NULL; 22 | break; 23 | } else { 24 | A -> next = B; 25 | } 26 | } 27 | A = A -> next; 28 | } 29 | return head; 30 | } -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/remove-nth-node-from-list-end.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::removeNthFromEnd(ListNode* A, int B) { 10 | int length = 0; 11 | ListNode *head = A; 12 | 13 | // Find the length of the list 14 | 15 | while (A != NULL) { 16 | length ++; 17 | A = A -> next; 18 | } 19 | A = head; 20 | 21 | // Corner case 22 | 23 | if (B >= length) { 24 | return A -> next; 25 | } 26 | 27 | // (N - k)th from the Front = Nth Node from the End 28 | 29 | for (int i = 0; i < length - B - 1; i ++) { 30 | A = A -> next; 31 | } 32 | if (A -> next != NULL) { 33 | A -> next = A -> next -> next; 34 | } else { 35 | A = A -> next; 36 | } 37 | if (length == 1) { 38 | return A; 39 | } 40 | return head; 41 | } 42 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/reorder-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::reorderList(ListNode* A) { 10 | ListNode* head = A; 11 | int length = 0; 12 | 13 | // Get length of the list 14 | 15 | while (A) { 16 | A = A -> next; 17 | length ++; 18 | } 19 | 20 | // Corner case 21 | 22 | if (length <= 2) { 23 | return head; 24 | } 25 | A = head; 26 | 27 | // Find the middle element for reversing the latter half 28 | 29 | ListNode* prev = NULL; 30 | if (length % 2 == 1) { 31 | for (int i = 0; i < length / 2 + 1; i ++) { 32 | prev = A; 33 | A = A -> next; 34 | } 35 | } else { 36 | for (int i = 0; i < length / 2; i ++) { 37 | prev = A; 38 | A = A -> next; 39 | } 40 | } 41 | 42 | // rotate the 2nd half of the list 43 | 44 | ListNode* next = NULL; 45 | ListNode* cur = A; 46 | ListNode* pre = NULL; 47 | while (cur && cur -> next) { 48 | next = cur -> next; 49 | cur -> next = pre; 50 | pre = cur; 51 | cur = next; 52 | } 53 | if (cur) { 54 | cur -> next = pre; 55 | } 56 | 57 | // Get the sequence by alternating nodes 58 | 59 | ListNode* tempNext; 60 | ListNode* tempNext2; 61 | ListNode* tempPre = NULL; 62 | ListNode* tempPre2 = NULL; 63 | bool toggle = false; 64 | ListNode* realHead = head; 65 | A = cur; 66 | if (length % 2 == 0) { 67 | while (head && head -> next && A && A -> next) { 68 | if (!toggle) { 69 | tempNext = head -> next; 70 | tempNext2 = A -> next; 71 | head -> next = A; 72 | head = tempNext; 73 | toggle = true; 74 | } else { 75 | tempNext = head -> next; 76 | tempNext2 = A -> next; 77 | A -> next = head; 78 | A = tempNext2; 79 | toggle = false; 80 | } 81 | } 82 | return realHead; 83 | } else { 84 | prev -> next = NULL; 85 | while (head && head -> next && A) { 86 | if (!toggle) { 87 | tempNext = head -> next; 88 | tempNext2 = A -> next; 89 | head -> next = A; 90 | head = tempNext; 91 | toggle = true; 92 | } else { 93 | tempNext = head -> next; 94 | tempNext2 = A -> next; 95 | A -> next = head; 96 | A = tempNext2; 97 | toggle = false; 98 | } 99 | } 100 | A -> next = prev; 101 | return realHead; 102 | } 103 | } 104 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/reverse-link-list-ii.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::reverseBetween(ListNode* A, int D, int C) { 10 | ListNode *head = A; 11 | ListNode *prev = NULL; 12 | ListNode *temp = A; 13 | int length = 0; 14 | 15 | // Find length of the list 16 | 17 | while (temp) { 18 | length ++; 19 | temp = temp -> next; 20 | } 21 | if (length == 1) { 22 | return A; 23 | } 24 | 25 | // Sort from index n to index m by keeping track of prev and next nodes 26 | 27 | for (int i = 0; i < D - 1; i ++) { 28 | prev = A; 29 | A = A -> next; 30 | } 31 | ListNode *B = A; 32 | for (int i = 0; i < C - D; i ++) { 33 | A = A -> next; 34 | } 35 | ListNode* next = A -> next; 36 | ListNode* pre = next; 37 | ListNode* realNext = NULL; 38 | ListNode* cur = B; 39 | for (int i = 0; i < C - D + 1; i ++) { 40 | realNext = cur -> next; 41 | cur -> next = pre; 42 | pre = cur; 43 | cur = realNext; 44 | } 45 | if (prev == NULL) { 46 | head = pre; 47 | } else { 48 | prev -> next = pre; 49 | } 50 | return head; 51 | } 52 | 53 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/rotate-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::rotateRight(ListNode* A, int B) { 10 | ListNode * head = A; 11 | int length = 0; 12 | 13 | // Find length of the lists 14 | 15 | while (A) { 16 | length ++; 17 | A = A -> next; 18 | } 19 | if (length == 1) { 20 | return head; 21 | } 22 | 23 | // Set rotation length and point end node to the beginning and prev to NULL for rotating the list 24 | 25 | B = B % length; 26 | A = head; 27 | if (B == 0) { 28 | return A; 29 | } 30 | ListNode *prev = NULL; 31 | for (int i = 0; i < length - B; i ++) { 32 | prev = A; 33 | A = A -> next; 34 | } 35 | prev -> next = NULL; 36 | ListNode *C = A; 37 | while (C -> next != NULL) { 38 | C = C -> next; 39 | } 40 | C -> next = head; 41 | return A; 42 | } 43 | -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/sort-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | // Helper function to merge 2 Linked Lists 10 | 11 | ListNode* sortedMerge(ListNode* A, ListNode* B){ 12 | if(A == NULL){ 13 | return B; 14 | } 15 | if(B == NULL){ 16 | return A; 17 | } 18 | 19 | ListNode* head = NULL; 20 | 21 | if(A -> val < B -> val) { 22 | head = A; 23 | A = A -> next; 24 | } 25 | else{ 26 | head = B; 27 | B = B -> next; 28 | } 29 | 30 | ListNode* temp = head; 31 | 32 | while(A != NULL && B != NULL) { 33 | if(A -> val < B -> val) { 34 | temp -> next = A; 35 | A = A -> next; 36 | } else{ 37 | temp -> next = B; 38 | B = B -> next; 39 | } 40 | temp = temp -> next; 41 | } 42 | 43 | if (A != NULL) { 44 | temp -> next = A; 45 | } else { 46 | temp -> next = B; 47 | } 48 | 49 | return head; 50 | } 51 | ListNode* Solution::sortList(ListNode* A) { 52 | ListNode* head = A; 53 | 54 | // Corner case 55 | 56 | if (head == NULL || head->next == NULL) { 57 | return head; 58 | } 59 | 60 | ListNode* start = A; 61 | ListNode* end = A -> next; 62 | 63 | // Split the list into 2 halves for mergeSort 64 | 65 | while (end != NULL && end -> next != NULL) { 66 | start = start -> next; 67 | end = (end -> next) -> next; 68 | } 69 | 70 | end = start -> next; 71 | start -> next = NULL; 72 | 73 | return sortedMerge(sortList(head), sortList(end)); 74 | } -------------------------------------------------------------------------------- /Cpp/Linked-Lists/Problems/swap-list-nodes-in-pairs.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | ListNode* Solution::swapPairs(ListNode* A) { 10 | ListNode *head = A; 11 | ListNode *prev = NULL; 12 | ListNode* pre = NULL; 13 | ListNode *next = NULL; 14 | ListNode *cur = A; 15 | 16 | // Swap nodes in pairs by keeping track of prev and next nodess 17 | 18 | while (cur && cur -> next) { 19 | next = cur -> next; 20 | cur -> next = next -> next; 21 | ListNode *temp = next -> next; 22 | next -> next = cur; 23 | if (pre) { 24 | pre -> next = next; 25 | pre = cur; 26 | } else { 27 | head = next; 28 | pre = cur; 29 | } 30 | cur = temp; 31 | } 32 | 33 | return head; 34 | } 35 | -------------------------------------------------------------------------------- /Cpp/Math/Examples/all-factors.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::allFactors(int A) { 2 | vector B; 3 | 4 | // corner case 5 | 6 | if (A <= 0) { 7 | return B; 8 | } 9 | else if (A == 1) { 10 | B.push_back(1); 11 | return B; 12 | } 13 | 14 | // Iterate through 1 to sqrt(i) 15 | 16 | for (int i = 1; i <= (int)sqrt(A); i ++) { 17 | if (A % i == 0) { 18 | if (i == A / i) { 19 | B.push_back(i); 20 | } else { 21 | B.push_back(i); 22 | B.push_back(A/i); 23 | } 24 | } 25 | } 26 | sort(B.begin(), B.end()); 27 | return B; 28 | } 29 | -------------------------------------------------------------------------------- /Cpp/Math/Examples/binary-representation.cpp: -------------------------------------------------------------------------------- 1 | string Solution::findDigitsInBinary(int A) { 2 | string sol; 3 | 4 | // corner case 5 | 6 | if (A == 0) { 7 | sol.push_back(48); 8 | return sol; 9 | } 10 | 11 | // get divisor and remainder via the loop 12 | 13 | while (A >= 1) { 14 | if (A % 2 == 0) { 15 | sol.push_back(48); 16 | } else if (A % 2 == 1) { 17 | sol.push_back(49); 18 | } 19 | A = A / 2; 20 | } 21 | reverse(sol.begin(), sol.end()); 22 | return sol; 23 | } 24 | -------------------------------------------------------------------------------- /Cpp/Math/Examples/prime-numbers.cpp: -------------------------------------------------------------------------------- 1 | bool isPrime(int num) { 2 | if (num <= 1) { 3 | return 0; 4 | } else if (num == 2 || num == 3) { 5 | return 1; 6 | } else { 7 | for (int i = 2; i <= (int)sqrt(num) ; i ++) { 8 | if (num % i == 0) { 9 | return 0; 10 | } 11 | } 12 | return 1; 13 | } 14 | } 15 | vector Solution::sieve(int A) { 16 | 17 | // Alternate solution 18 | 19 | /* 20 | vector B; 21 | for (int i = 2; i <= A; i ++) { 22 | if (i == 2 || i == 3) { 23 | B.push_back(i); 24 | } else { 25 | int j = 2; 26 | for (j = 2; j <= (int)sqrt(i); j ++) { 27 | if (i % j == 0) { 28 | break; 29 | } 30 | } 31 | if (j == (int)sqrt(i) + 1) { 32 | B.push_back(i); 33 | } 34 | } 35 | } 36 | return B; 37 | */ 38 | 39 | // Sieve of Eratosthenes 40 | 41 | vector B(A + 1, 1); 42 | vector C; 43 | B[0] = 0; 44 | B[1] = 0; 45 | for (int i = 2; i <= A; i ++) { 46 | if (B[i]) { 47 | int j = i * 2; 48 | while (j <= A) { 49 | B[j] = 0; 50 | j += i; 51 | } 52 | } 53 | } 54 | for (int i = 0; i < B.size(); i ++) { 55 | if (B[i] == 1) { 56 | C.push_back(i); 57 | } 58 | } 59 | return C; 60 | } 61 | -------------------------------------------------------------------------------- /Cpp/Math/Examples/verify-prime.cpp: -------------------------------------------------------------------------------- 1 | int Solution::isPrime(int A) { 2 | if (A <= 1) { 3 | return 0; 4 | } else if (A == 2 || A == 3) { 5 | return 1; 6 | } else { 7 | for (int i = 2; i <= (int)(A/2); i ++) { 8 | if (A % i == 0) { 9 | return 0; 10 | } 11 | } 12 | } 13 | return 1; 14 | } -------------------------------------------------------------------------------- /Cpp/Math/MathBugs/mathbug01.cpp: -------------------------------------------------------------------------------- 1 | // Return 1 if A is prime, else 0 2 | 3 | int Solution::isPrime(int A) { 4 | int upperLimit = (int)(sqrt(A)); 5 | if (A == 1) { 6 | return 0; 7 | } else if (A <= 0) { 8 | return 0; 9 | } else if (A == 2 || A == 3) { 10 | return 1; 11 | } 12 | for (int i = 2; i <= upperLimit; i++) { 13 | if (i < A && A % i == 0) return 0; 14 | } 15 | return 1; 16 | } 17 | -------------------------------------------------------------------------------- /Cpp/Math/MathBugs/mathbug02.cpp: -------------------------------------------------------------------------------- 1 | vector > Solution::squareSum(int A) { 2 | vector > ans; 3 | for (long long int a = 0; a * a < A; a++) { 4 | for (long long int b = a; b * b < A; b++) { 5 | if (a * a + b * b == A) { 6 | vector newEntry; 7 | newEntry.push_back(a); 8 | newEntry.push_back(b); 9 | ans.push_back(newEntry); 10 | } 11 | } 12 | } 13 | return ans; 14 | } 15 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/city-tour.cpp: -------------------------------------------------------------------------------- 1 | // Alternative solution using DFS is provided below however, it exceeds the time limit 2 | 3 | #define MOD 1000000007 4 | typedef long long ll; 5 | ll exponent[1001] = {0}; 6 | ll ncr[1001][1001] = {0}; 7 | 8 | // Precompute ncr 9 | 10 | void preComputencr() { 11 | for (int i = 1; i <= 1000; i ++) { 12 | for (int j = 0; j <= i; j ++) { 13 | if (j == 0 || j == i) { 14 | ncr[i][j] = 1; 15 | } else ncr[i][j] = (ncr[i - 1][j] + ncr[i - 1][j - 1]) % MOD; 16 | } 17 | } 18 | return; 19 | } 20 | 21 | // Precompute exponent of 2 22 | 23 | void preComputeExponent() { 24 | exponent[0] = 1; 25 | for (int i = 1; i <= 1000; i ++) { 26 | exponent[i] = (exponent[i - 1] * 2) % MOD; 27 | } 28 | return; 29 | } 30 | int Solution::solve(int A, vector &B) { 31 | if (B.size() <= 0 || A <= 0) { 32 | return 0; 33 | } 34 | preComputencr(); 35 | preComputeExponent(); 36 | ll res = 1; 37 | 38 | // Sort the visited array to find packets of unvisited cities 39 | 40 | sort(B.begin(), B.end()); 41 | int num = B[0] - 1; 42 | for (int i = 1; i < B.size(); i ++) { 43 | int sizePacket = B[i] - B[i - 1] - 1; 44 | if (sizePacket > 0) { 45 | 46 | // Use the fact that (n1 + n2)C(n2) = (n1 + n2)!/(n1!){n2!) and eliminate the numerator (n1 + n2)! in future terms(Cumulative combination) 47 | 48 | num += sizePacket; 49 | ll expo = exponent[sizePacket - 1]; 50 | res = ((res * expo) % MOD * ncr[num][sizePacket]) % MOD; 51 | } 52 | } 53 | return (res * ncr[num + A - B[B.size() - 1]][A - B[B.size() - 1]]) % MOD; 54 | } 55 | 56 | 57 | // Below solution exceeds the time limit!!! 58 | 59 | // we can pick up K places in our walk list N!/(N-K)!/K! different ways 60 | 61 | vector mem(1000); 62 | vector eligible1(vector visit) { 63 | vector eligible; 64 | for (int i = 0; i < visit.size(); i ++) { 65 | if (visit[i] == 0) { 66 | if (i != 0 && i != visit.size() - 1) { 67 | if (visit[i - 1] == 1 || visit[i + 1] == 1) { 68 | eligible.push_back(i + 1); 69 | } 70 | } else if (i == 0) { 71 | if (visit[i + 1] == 1) { 72 | eligible.push_back(i + 1); 73 | } 74 | } else if (i == visit.size() - 1) { 75 | if (visit[i - 1] == 1) { 76 | eligible.push_back(i + 1); 77 | } 78 | } 79 | } 80 | } 81 | return eligible; 82 | } 83 | vector orign(vector visit, int A) { 84 | visit[A - 1] = 1; 85 | return visit; 86 | } 87 | long long int tot(vector visit, vector eligibleV) { 88 | mem.clear(); 89 | if (eligibleV.size() == 0) { 90 | return 1; 91 | } else { 92 | long long int sum = 0; 93 | for (int i = 0; i < eligibleV.size(); i ++) { 94 | sum += tot(orign(visit, eligibleV[i]), eligible1(orign(visit, eligibleV[i]))) % (int)(pow(10, 9) + 7); 95 | } 96 | return sum; 97 | } 98 | } 99 | int Solution::solve(int A, vector &B) { 100 | 101 | // Corner case 102 | 103 | if (A <= 0 || B.size() <= 0) { 104 | return 0; 105 | } 106 | vector visit(A); 107 | for (int i = 0; i < B.size(); i ++) { 108 | visit[B[i] - 1] = 1; 109 | } 110 | vector temp = eligible1(visit); 111 | return tot(visit, temp) % (int)(pow(10, 9) + 7); 112 | } -------------------------------------------------------------------------------- /Cpp/Math/Problems/excel-column-number.cpp: -------------------------------------------------------------------------------- 1 | int Solution::titleToNumber(string A) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 0) { 6 | return 0; 7 | } 8 | int j = 0; 9 | int num = 0; 10 | 11 | // Equivalent to number system in base 26 12 | 13 | for (int i = A.size() - 1; i >= 0; i --) { 14 | int temp = A[i]; 15 | num += pow(26, A.size() - 1 - i) * (temp - 64); 16 | 17 | } 18 | return num; 19 | } 20 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/excel-column-title.cpp: -------------------------------------------------------------------------------- 1 | string Solution::convertToTitle(int A) { 2 | int initial = A; 3 | string B; 4 | char c; 5 | 6 | // convert 1 - 26 range to 0 - 25 range by subtracting 1 from the number 7 | 8 | while (A >= 1) { 9 | if (A % 26 == 0) { 10 | c = ((A - 1) % 26) + 65; 11 | } else { 12 | c = ((A - 1) % 26) + 65; 13 | } 14 | B += c; 15 | A = (A - 1)/ 26; 16 | } 17 | reverse(B.begin(), B.end()); 18 | return B; 19 | } 20 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/fizzbuzz.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::fizzBuzz(int A) { 2 | vector B(A); 3 | 4 | // check if (i + 1) is divisible by 3 or 5 5 | 6 | for (int i = 0; i < B.size(); i ++) { 7 | if ((i + 1) % 3 == 0 && (i + 1) % 5 == 0) { 8 | B[i] = "FizzBuzz"; 9 | continue; 10 | } else if ((i + 1) % 3 == 0) { 11 | B[i] = "Fizz"; 12 | continue; 13 | } else if ((i + 1) % 5 == 0) { 14 | B[i] = "Buzz"; 15 | continue; 16 | } else { 17 | B[i] = to_string(i + 1); 18 | continue; 19 | } 20 | } 21 | return B; 22 | } 23 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/greatest-common-divisor.cpp: -------------------------------------------------------------------------------- 1 | // Euclidean algorithm 2 | 3 | int getGcd(int A, int B) { 4 | if (B == 0) { 5 | return A; 6 | } else return getGcd(B, A % B); 7 | } 8 | int Solution::gcd(int A, int B) { 9 | return getGcd(max(A, B), min(A, B)); 10 | } 11 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/grid-unique-paths.cpp: -------------------------------------------------------------------------------- 1 | // Total paths = (m - 1) + (n - 1) C (m - 1) 2 | 3 | int Solution::uniquePaths(int A, int B) { 4 | if (A <= 0 && B <= 0) { 5 | return 0; 6 | } else if (A <= 0 || B <= 0) { 7 | return 1; 8 | } 9 | float tot = 1; 10 | for (int i = 0; i < A - 1; i ++) { 11 | tot *= (float)(B + i)/(float)(i + 1); 12 | } 13 | return tot; 14 | } 15 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/largest-coprime-divisor.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to get the gdc 2 | 3 | int gcd (int m, int n) { 4 | if (m < n) { 5 | swap(m, n); 6 | } 7 | if (n == 0) { 8 | return m; 9 | } else { 10 | return gcd(n, m % n); 11 | } 12 | } 13 | int Solution::cpFact(int A, int B) { 14 | 15 | // Remove all the common factors between A and Bs 16 | 17 | while (gcd(A, B) != 1) { 18 | A = A / gcd(A, B); 19 | } 20 | if (gcd(A, B) == 1) { 21 | return A; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/numbers-of-length-n-and-value-less-than-k.cpp: -------------------------------------------------------------------------------- 1 | int all(bool digits[], int B, int total) { 2 | bool isZero = digits[0] ? 1 : 0; 3 | long long int count = 1; 4 | if (B == 1) { 5 | return total; 6 | } 7 | count *= isZero ? total - 1 : total; 8 | count *= pow(total, B - 1); 9 | return count; 10 | } 11 | int compare(bool digits[], int B, int C, int total) { 12 | string c = to_string(C); 13 | 14 | // To count the numbers less than a given digit 15 | 16 | vector count(10); 17 | for (int i = 1; i < 10; i ++) { 18 | count[i] = digits[i - 1] + count[i - 1]; 19 | } 20 | 21 | // To store the numbers until any certain digit i 22 | 23 | int dp[B + 1]; 24 | dp[0] = 0; 25 | bool flag = 1; 26 | for (int i = 1; i <= B; i ++) { 27 | dp[i] = dp[i - 1] * total; 28 | if (flag || i == 1) { 29 | int smallCount = count[c[i - 1] - '0']; 30 | if (B != 1 && i == 1 && digits[0]) { 31 | smallCount --; 32 | } 33 | dp[i] += smallCount; 34 | if (!digits[c[i - 1] - '0']) { 35 | flag = false; 36 | } 37 | } 38 | } 39 | return dp[B]; 40 | } 41 | int Solution::solve(vector &A, int B, int C) { 42 | int length = log10(C) + 1; 43 | bool digits[10] = {0}; 44 | int total = 0; 45 | for (int i = 0; i < A.size(); i ++) { 46 | digits[A[i]] = 1; 47 | total ++; 48 | } 49 | if (B > length || B == 0) { 50 | return 0; 51 | } else if (B < length) { 52 | return all(digits, B, total); 53 | } else { 54 | return compare(digits, B, C, total); 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/palindrome-integer.cpp: -------------------------------------------------------------------------------- 1 | int Solution::isPalindrome(int A) { 2 | 3 | // Corner case 4 | 5 | if (A < 0) { 6 | return 0; 7 | } 8 | if (A == 0) { 9 | return 1; 10 | } 11 | vector B; 12 | int C = A; 13 | 14 | // Extract the digits 15 | 16 | while (A >= 1) { 17 | B.push_back(A % 10); 18 | A = A / 10; 19 | } 20 | 21 | // check if reverse of the number is the same as the number 22 | 23 | long long int num = 0; 24 | for (int i = 0; i < B.size(); i ++) { 25 | num += B[i] * pow(10, B.size() - 1 - i); 26 | } 27 | return num == C; 28 | } 29 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/power-of-two-integers.cpp: -------------------------------------------------------------------------------- 1 | 2 | int Solution::isPower(int A) { 3 | 4 | // corner case 5 | 6 | if (A == 1) { 7 | return 1; 8 | } 9 | for (int i = 2; i <= sqrt(A); i ++) { 10 | if (i == sqrt(A)) { 11 | return 1; 12 | } else { 13 | 14 | // absolute difference of float can vary hence a random small number is chosen for comparison 15 | 16 | float temp = (float)log(A)/(float)log(i); 17 | if ((abs(temp) - (int)(temp) < 0.00001) && (int)temp > 1) { 18 | return 1; 19 | } 20 | } 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/prime-sum.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::primesum(int A) { 2 | vector B; 3 | vector C(A, 1); 4 | C[0] = 0; 5 | C[1] = 0; 6 | 7 | // Loop from 0 through A - 1 to check for the existence of the numbers 8 | 9 | for (int i = 0; i < A; i ++) { 10 | if (C[i] == 1) { 11 | for (int j = 2; j * i < A; j ++) { 12 | if (C[i] == 1) { 13 | C[i * j] = 0; 14 | } 15 | } 16 | } 17 | } 18 | for (int i = 2; i <= floor(A/2); i ++) { 19 | if (C[i] == 1 && C[A - i] == 1) { 20 | B.push_back(i); 21 | B.push_back(A - i); 22 | break; 23 | } 24 | } 25 | return B; 26 | } -------------------------------------------------------------------------------- /Cpp/Math/Problems/rearrange-array.cpp: -------------------------------------------------------------------------------- 1 | // We need to remember the indices of the array elements 2 | // so we encode A[i] like A[i] = A[i] + A[A[i]] * n 3 | // % operator on A[i] will give us A[i] 4 | // / operator on A[i] will give us A[A[i]] 5 | 6 | void Solution::arrange(vector &A) { 7 | vector B = A; 8 | for (int i = 0; i < A.size(); i ++) { 9 | A[i] += (A[A[i]] % A.size()) * A.size(); 10 | } 11 | for (int i = 0; i < A.size(); i ++) { 12 | A[i] = A[i] / A.size(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/reverse-integer.cpp: -------------------------------------------------------------------------------- 1 | int Solution::reverse(int A) { 2 | 3 | // Corner case 4 | 5 | if (A == 0) { 6 | return 0; 7 | } 8 | 9 | // Store the sign of the number and perform operations on it by making it positive 10 | 11 | vector B; 12 | int C = A; 13 | A = abs(A); 14 | while (A >= 1) { 15 | B.push_back(A % 10); 16 | A = A / 10; 17 | } 18 | long long num = 0; 19 | for (int i = 0; i < B.size(); i ++) { 20 | num += B[i] * pow(10, B.size() - 1 - i); 21 | } 22 | if (num > INT_MAX) { 23 | return 0; 24 | } 25 | 26 | // Return the answer according to the sign 27 | 28 | if (C < 0) { 29 | return -1 * num; 30 | } else return num; 31 | } 32 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/sorted-permutation-rank-with-repeats.cpp: -------------------------------------------------------------------------------- 1 | #define MOD 1000003 2 | long long int fact(int n) { 3 | if (n == 0 || n == 1) { 4 | return 1; 5 | } 6 | return (fact(n - 1) * n) % MOD; 7 | } 8 | long long int inverseNumber(int num) { 9 | long long int ans = 1, base = (long long) num; 10 | int power = MOD - 2; 11 | while (power > 0) { 12 | if (power == 1) { 13 | return (ans * base) % MOD; 14 | } 15 | if (power % 2 == 0) { 16 | base = (base * base) % MOD; 17 | power /= 2; 18 | } else { 19 | ans = (ans * base) % MOD; 20 | power--; 21 | } 22 | } 23 | return ans; 24 | } 25 | int Solution::findRank(string A) { 26 | if (A.size() <= 0) { 27 | return 0; 28 | } 29 | 30 | // Store in an array 31 | 32 | int alpha[52] = {0}; 33 | for (int i = 0; i < A.size(); i ++) { 34 | if (islower(A[i])) { 35 | alpha[A[i] - 'a' + 26] ++; 36 | } else { 37 | alpha[A[i] - 'A'] ++; 38 | } 39 | } 40 | 41 | // Loop through the string and add values individually 42 | 43 | long long int total = 0; 44 | for (int i = 0; i < A.size(); i ++) { 45 | long long localCount = 0; 46 | int size = islower(A[i]) ? A[i] - 'a' + 26 : A[i] - 'A'; 47 | long long int count = (fact(A.size() - i - 1)); 48 | for (int j = 0; j < size; j ++) { 49 | if (alpha[j]) { 50 | alpha[j] --; 51 | localCount = count; 52 | for (int k = 0; k < 52; k ++) { 53 | if (alpha[k]) { 54 | localCount = (localCount * inverseNumber(fact(alpha[k]))) % MOD; 55 | } 56 | } 57 | alpha[j] ++; 58 | total = (total + localCount) % MOD; 59 | } 60 | } 61 | if (islower(A[i])) { 62 | alpha[A[i] - 'a' + 26] --; 63 | } else { 64 | alpha[A[i] - 'A'] --; 65 | } 66 | } 67 | return (total + 1) % MOD; 68 | } 69 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/sorted-permutation-ranks.cpp: -------------------------------------------------------------------------------- 1 | #define MOD 1000003 2 | long long int fact(int n) { 3 | if (n == 0 || n == 1) { 4 | return 1; 5 | } 6 | return (fact(n - 1) * n) % MOD; 7 | } 8 | int Solution::findRank(string A) { 9 | 10 | // Store in an array 11 | 12 | bool alpha[52] = {0}; 13 | for (int i = 0; i < A.size(); i ++) { 14 | if (islower(A[i])) { 15 | alpha[A[i] - 'a' + 26] = 1; 16 | } else { 17 | alpha[A[i] - 'A'] = 1; 18 | } 19 | } 20 | 21 | // Traverse the string to find combinations 22 | 23 | long long int total = 0; 24 | for (int i = 0; i < A.size(); i ++) { 25 | int countLess = 0; 26 | long long localCount = 0; 27 | int size = islower(A[i]) ? A[i] - 'a' + 26 : A[i] - 'A'; 28 | for (int j = 0; j < size; j ++) { 29 | countLess += alpha[j] ? 1 : 0; 30 | } 31 | if (islower(A[i])) { 32 | alpha[A[i] - 'a' + 26] = 0; 33 | } else { 34 | alpha[A[i] - 'A'] = 0; 35 | } 36 | localCount = (countLess * fact(A.size() - i - 1)) % MOD; 37 | total = total + localCount; 38 | } 39 | return (total + 1) % MOD; 40 | } -------------------------------------------------------------------------------- /Cpp/Math/Problems/sum-of-pairwise-hamming-distance.cpp: -------------------------------------------------------------------------------- 1 | int Solution::hammingDistance(const vector &A) { 2 | 3 | // The trick is imagine if all the elements were either 0 or 1 4 | // then the value required will be 2 * (number of 1s) * (number of 0s) 5 | // We imagine each bit of the number and perform operations on them 6 | 7 | long long tot = 0; 8 | for (int i = 0; i < 32; i ++) { 9 | int count = 0; 10 | for (int j = 0; j < A.size(); j ++) { 11 | if (A[j] & 1 << i) { 12 | count ++; 13 | } 14 | } 15 | tot += (2 * count * (A.size() - count)) % 1000000007; 16 | } 17 | return tot % 1000000007; 18 | } 19 | -------------------------------------------------------------------------------- /Cpp/Math/Problems/trailing-zeros-in-factorial.cpp: -------------------------------------------------------------------------------- 1 | // Number of 5s combine with 2s to make 10 2 | 3 | int Solution::trailingZeroes(int A) { 4 | int tot = 0, i = 1; 5 | while (floor(A/pow(5, i)) != 0) { 6 | tot += floor(A/pow(5, i)); 7 | i ++; 8 | } 9 | return tot; 10 | } 11 | -------------------------------------------------------------------------------- /Cpp/Stacks-and-Queues/Examples/generate-all-parentheses.cpp: -------------------------------------------------------------------------------- 1 | int Solution::isValid(string A) { 2 | stack s; 3 | 4 | // Corner case 5 | 6 | if (A.size() <= 0) { 7 | return 0; 8 | } else if (A[0] == ')' || A[0] == ']' || A[0] == '}') { 9 | return 0; 10 | } 11 | 12 | // Close corresponding brackets and if the stack is empty or the brackets do not match, return 0 13 | // At the end, if the stack is empty return 1 else 0 14 | 15 | for (int i = 0; i < A.size(); i ++) { 16 | if (A[i] == '(' || A[i] == '[' || A[i] == '{') { 17 | s.push(A[i]); 18 | } else if (A[i] == ')') { 19 | if (s.top() == '(') { 20 | s.pop(); 21 | } else return 0; 22 | } else if (A[i] == ']') { 23 | if (s.top() == '[') { 24 | s.pop(); 25 | } else return 0; 26 | } else if (A[i] == '}') { 27 | if (s.top() == '{') { 28 | s.pop(); 29 | } else return 0; 30 | } 31 | } 32 | return s.empty(); 33 | } 34 | -------------------------------------------------------------------------------- /Cpp/Stacks-and-Queues/Examples/reverse-string.cpp: -------------------------------------------------------------------------------- 1 | string Solution::reverseString(string A) { 2 | stack B; 3 | 4 | // Push sequentially in the stack 5 | 6 | for (int i = 0; i < A.size(); i ++) { 7 | B.push(A[i]); 8 | } 9 | A.clear(); 10 | 11 | // Pop from the stack and push in the returning string 12 | 13 | while (!B.empty()) { 14 | A.push_back(B.top()); 15 | B.pop(); 16 | } 17 | return A; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /Cpp/Stacks-and-Queues/Problems/evaluate-expression.cpp: -------------------------------------------------------------------------------- 1 | int val(int A, int B, string c) { 2 | if (c == "+") { 3 | return A + B; 4 | } else if (c == "-") { 5 | return A - B; 6 | } else if (c == "*") { 7 | return A * B; 8 | } else if (c == "/") { 9 | return A / B; 10 | } 11 | } 12 | int Solution::evalRPN(vector &A) { 13 | stack B; 14 | 15 | // Corner case 16 | 17 | if (A.size() <= 0) { 18 | return 0; 19 | } 20 | 21 | // Loop through the array and push numbers on the stack 22 | // Resolve the operator with the elements in the stack 23 | // Push the resultant element on the stack 24 | 25 | for (int i = 0; i < A.size(); i ++) { 26 | if (A[i] != "+" && A[i] != "-" && A[i] != "*" && A[i] != "/") { 27 | B.push(stoi(A[i])); 28 | } else { 29 | int temp1 = B.top(); 30 | B.pop(); 31 | int temp2 = B.top(); 32 | B.pop(); 33 | B.push(val(temp2, temp1, A[i])); 34 | } 35 | } 36 | if (!B.empty()) { 37 | return B.top(); 38 | } 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /Cpp/Stacks-and-Queues/Problems/largest-rectangle-in-histogram.cpp: -------------------------------------------------------------------------------- 1 | int Solution::largestRectangleArea(vector &A) { 2 | stack st; 3 | int sol = 0; 4 | int i = 0, n = A.size(); 5 | 6 | while(i < n){ 7 | 8 | // Push the elements on to the stack if it is empty or if the current element is greater than the top element 9 | 10 | if(st.empty() || A[st.top()] <= A[i]){ 11 | st.push(i); 12 | i++; 13 | } 14 | 15 | // Else find the area all of the elements in the stack and take its maximum 16 | 17 | else{ 18 | int top = st.top(); 19 | st.pop(); 20 | 21 | int area = 0; 22 | 23 | if(st.empty()){ 24 | area = A[top] * i; 25 | } 26 | else{ 27 | area = A[top] * (i - st.top() - 1); 28 | } 29 | 30 | sol = max(sol, area); 31 | } 32 | } 33 | 34 | // Do the same procedure for the end 35 | 36 | while(!st.empty()){ 37 | int top = st.top(); 38 | st.pop(); 39 | 40 | int area = 0; 41 | 42 | if(st.empty()){ 43 | area = A[top] * i; 44 | } 45 | else{ 46 | area = A[top] * (i - st.top() - 1); 47 | } 48 | 49 | sol = max(sol, area); 50 | } 51 | 52 | return sol; 53 | 54 | } -------------------------------------------------------------------------------- /Cpp/Stacks-and-Queues/Problems/min-stack.cpp: -------------------------------------------------------------------------------- 1 | vector s; 2 | vector A; 3 | MinStack::MinStack() { 4 | 5 | // Clear the environment variables 6 | 7 | s.clear(); 8 | A.clear(); 9 | } 10 | 11 | void MinStack::push(int x) { 12 | 13 | // Push the minimum value of the vector cooresponding to the indices 14 | 15 | s.push_back(x); 16 | if (A.size() == 0) { 17 | A.push_back(x); 18 | } else { 19 | A.push_back(min(x, A[A.size() - 1])); 20 | } 21 | } 22 | 23 | void MinStack::pop() { 24 | 25 | // Remove the last element from the arrays 26 | 27 | if (s.size()) { 28 | s.erase(s.end() - 1); 29 | A.erase(A.end() - 1); 30 | return; 31 | } else return; 32 | } 33 | 34 | int MinStack::top() { 35 | 36 | // Return the last element from the original array 37 | 38 | if (s.size()) { 39 | return s[s.size() - 1]; 40 | } else return -1; 41 | } 42 | 43 | int MinStack::getMin() { 44 | 45 | // Return the last element from the min array 46 | 47 | if (!s.size()) { 48 | return -1; 49 | } else { 50 | return A[A.size() - 1]; 51 | } 52 | } 53 | 54 | -------------------------------------------------------------------------------- /Cpp/Stacks-and-Queues/Problems/nearest-smaller-element.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::prevSmaller(vector &A) { 2 | stack B; 3 | vector C; 4 | 5 | // Keep popping from the stack until a value smaller than A[i] is found or the stack is empty 6 | 7 | for (int i = 0; i < A.size(); i ++) { 8 | if (B.empty()) { 9 | C.push_back(-1); 10 | B.push(A[i]); 11 | } else { 12 | while (!B.empty() && B.top() >= A[i]) { 13 | B.pop(); 14 | } 15 | if (B.empty()) { 16 | C.push_back(-1); 17 | B.push(A[i]); 18 | } else { 19 | C.push_back(B.top()); 20 | B.push(A[i]); 21 | } 22 | } 23 | } 24 | return C; 25 | } 26 | -------------------------------------------------------------------------------- /Cpp/Stacks-and-Queues/Problems/rain-water-trapped.cpp: -------------------------------------------------------------------------------- 1 | int Solution::trap(const vector &A) { 2 | int n = A.size(), i = 0, ma, tmp = 0, ans = 0; 3 | stack s; 4 | 5 | // Move ahead to the first non-zero value 6 | 7 | while (i < n && A[i] == 0) 8 | i++; 9 | 10 | // Loop through the array 11 | 12 | if (i < n) { 13 | for (int j = i; j < n; j++) { 14 | tmp = 0; 15 | 16 | // If stack is empty, push the element 17 | 18 | if (s.empty()) { 19 | s.push(A[j]); 20 | ma = A[j]; 21 | 22 | } else { 23 | 24 | // If the element is less than the previous max, push the element 25 | 26 | if (A[j] < ma) 27 | s.push(A[j]); 28 | else { 29 | 30 | // Loop until the stack is empty and add the values to the total 31 | // Push the new max element later 32 | 33 | while (!s.empty()) { 34 | tmp += (ma - s.top()); 35 | s.pop(); 36 | } 37 | s.push(A[j]); 38 | ma = A[j]; 39 | ans += tmp; 40 | } 41 | } 42 | } 43 | } 44 | 45 | // Handle the ending case 46 | 47 | ma = 0,tmp = 0; 48 | while (!s.empty()) { 49 | if (s.top() > ma) ma = s.top(); 50 | else tmp += ma-s.top(); 51 | s.pop(); 52 | } 53 | return ans + tmp; 54 | } -------------------------------------------------------------------------------- /Cpp/Stacks-and-Queues/Problems/redundant-braces.cpp: -------------------------------------------------------------------------------- 1 | int Solution::braces(string A) { 2 | stack B; 3 | 4 | // Push elements in the stack except ending brace and characters 5 | // We cancel corresponding braces by popping from stack 6 | // If there is no operator between 2 braces, there is redundancy 7 | 8 | for (int i = 0; i < A.size(); i ++) { 9 | if (A[i] =='(' || A[i] == '+' || A[i] == '*' || A[i] == '-' || A[i] == '/') { 10 | B.push(A[i]); 11 | } else if (A[i] == ')') { 12 | if (B.top() == '(') { 13 | return 1; 14 | } else { 15 | while (!B.empty() && B.top() != '(') { 16 | B.pop(); 17 | } 18 | B.pop(); 19 | } 20 | } 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /Cpp/Stacks-and-Queues/Problems/simplify-directory-path.cpp: -------------------------------------------------------------------------------- 1 | string Solution::simplifyPath(string A) { 2 | stack s; 3 | 4 | // Maintain a stack of all the values between the / / slashes 5 | // Pop and push the values according to A[i] 6 | 7 | for (int i = 0; i < A.size(); i ++) { 8 | if (A[i] == '/') { 9 | string p = ""; 10 | i ++; 11 | while (A[i] != '/' && i < A.size()) { 12 | p += A[i]; 13 | i ++; 14 | } 15 | if (p == "..") { 16 | if (!s.empty()) { 17 | s.pop(); 18 | } 19 | } else if (p != "" && p != ".") { 20 | s.push(p); 21 | } 22 | i --; 23 | } 24 | } 25 | 26 | // Now we have the final directoy structure but we need to reverse the stack 27 | 28 | stack temp; 29 | string ans; 30 | if (s.empty()) { 31 | return "/"; 32 | } 33 | 34 | while (!s.empty()) { 35 | temp.push(s.top()); 36 | s.pop(); 37 | } 38 | 39 | // Append '/' to the values of the stack 40 | 41 | while (!temp.empty()) { 42 | ans += "/"; 43 | ans += temp.top(); 44 | temp.pop(); 45 | } 46 | return ans; 47 | } -------------------------------------------------------------------------------- /Cpp/Strings/.justified-text.cpp.swp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mailtokartik1/InterviewBit-Solutions/8a9be25cf55947aff456c7c138e2ee6f518aa6a5/Cpp/Strings/.justified-text.cpp.swp -------------------------------------------------------------------------------- /Cpp/Strings/add-binary-strings.cpp: -------------------------------------------------------------------------------- 1 | string Solution::addBinary(string A, string B) { 2 | string temp; 3 | 4 | // Append zeroes at the end of the shorter string to make both string lengths equal 5 | 6 | if (A.length() != B.length()) { 7 | int mini = min(A.length(), B.length()); 8 | if (mini == A.length()) { 9 | for (int i = 0; i < B.length() - A.length(); i ++) { 10 | temp += '0'; 11 | } 12 | A = temp + A; 13 | } else if (mini == B.length()) { 14 | for (int i = 0; i < A.length() - B.length(); i ++) { 15 | temp += '0'; 16 | } 17 | B = temp + B; 18 | } 19 | } 20 | int C = 0; 21 | temp.clear(); 22 | 23 | // Ordinary division using sum and carry 24 | 25 | for (int i = A.size() - 1; i >= 0; i --) { 26 | int a = A[i] - '0'; 27 | int b = B[i] - '0'; 28 | int sum = a + b + C; 29 | int add = sum % 2; 30 | C = sum / 2; 31 | temp += add + '0'; 32 | } 33 | if (C) { 34 | temp += '1'; 35 | } 36 | reverse(temp.begin(), temp.end()); 37 | return temp; 38 | } -------------------------------------------------------------------------------- /Cpp/Strings/amazing-subarrays.cpp: -------------------------------------------------------------------------------- 1 | int Solution::solve(string A) { 2 | int count = 0; 3 | 4 | // Store the vowels in a map 5 | 6 | map B; 7 | B['A'] = 1; 8 | B['a'] = 1; 9 | B['E'] = 1; 10 | B['e'] = 1; 11 | B['I'] = 1; 12 | B['i'] = 1; 13 | B['O'] = 1; 14 | B['o'] = 1; 15 | B['U'] = 1; 16 | B['u'] = 1; 17 | 18 | // Loop through the array and if the value exists, increment the count 19 | 20 | for (int i = 0; i < A.size(); i ++) { 21 | if (B[A[i]]) { 22 | count += (A.size() - i) % 10003; 23 | } 24 | } 25 | return count % 10003; 26 | } 27 | -------------------------------------------------------------------------------- /Cpp/Strings/atoi.cpp: -------------------------------------------------------------------------------- 1 | int Solution::atoi(const string A) { 2 | string B; 3 | int i; 4 | bool neg = false; 5 | 6 | // Loop through the sting to check if the number is negative and handle space charcaters 7 | 8 | for (i = 0; i < A.size(); i ++) { 9 | int temp = A[i]; 10 | if (temp >= 48 && temp <= 57) { 11 | break; 12 | } else if (A[i] == '-' && i != A.size() - 1 && ((int)A[i + 1] >= 48 && (int)A[i + 1] <= 57)) { 13 | neg = true; 14 | i ++; 15 | break; 16 | } else if (A[i] == '+' && i != A.size() - 1 && ((int)A[i + 1] >= 48 && (int)A[i + 1] <= 57)) { 17 | i ++; 18 | break; 19 | } else if (A[i] != ' ') { 20 | return 0; 21 | } 22 | } 23 | int j; 24 | 25 | // Get the index of number character in the string 26 | 27 | for (j = A.size() - 1; j >= 0; j --) { 28 | int temp = A[j]; 29 | if (temp >= 48 && temp <= 57) { 30 | break; 31 | } 32 | } 33 | int start; 34 | start = i; 35 | 36 | // Loop through the string to add the values for the corresponding numbers 37 | 38 | for (int k = start; k <= j; k ++) { 39 | int temp = A[k]; 40 | if (temp >= 48 && temp <= 57) { 41 | B += A[k]; 42 | } else { 43 | break; 44 | } 45 | } 46 | 47 | // reverse the string and comvert it into a number 48 | 49 | long long mag = 0; 50 | bool maxi = false; 51 | reverse(B.begin(), B.end()); 52 | int count = 0; 53 | for (i = 0; i < B.size(); i ++, count ++) { 54 | mag += (B[i] - '0') * pow(10, count); 55 | if (mag > INT_MAX) { 56 | maxi = true; 57 | break; 58 | } 59 | } 60 | 61 | // apply overflow and sign check 62 | 63 | if (maxi) { 64 | if (neg) { 65 | return INT_MIN; 66 | } else return INT_MAX; 67 | } 68 | if (neg) { 69 | return -1 * mag; 70 | } 71 | return mag; 72 | } 73 | -------------------------------------------------------------------------------- /Cpp/Strings/compare-version-numbers.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to compare 2 version strings 2 | 3 | int stringVal(string A, string B) { 4 | int i = 0; 5 | while (A[i] == '0') { 6 | i ++; 7 | } 8 | A.erase(A.begin(), A.begin() + i); 9 | i = 0; 10 | while (B[i] == '0') { 11 | i ++; 12 | } 13 | B.erase(B.begin(), B.begin() + i); 14 | if (A.size() > B.size()) { 15 | return 1; 16 | } else if (A.size() < B.size()) { 17 | return -1; 18 | } else { 19 | for (int j = 0; j < A.size(); j ++) { 20 | if (A[j] != B[j]) { 21 | if (A[j] > B[j]) { 22 | return 1; 23 | } else if (A[j] < B[j]) { 24 | return -1; 25 | } 26 | } 27 | } 28 | } 29 | return 0; 30 | } 31 | int Solution::compareVersion(string A, string B) { 32 | int dotA = 0; 33 | int dotB = 0; 34 | 35 | // Count the number of . characters in the version numbers 36 | 37 | for(int i = 0; i < A.size(); i ++) { 38 | if (A[i] == '.') { 39 | dotA ++; 40 | } 41 | } 42 | for(int i = 0; i < B.size(); i ++) { 43 | if (B[i] == '.') { 44 | dotB ++; 45 | } 46 | } 47 | 48 | // Make the number of dot characters equal in both strings by appending '.0' 49 | 50 | if (dotA > dotB) { 51 | for (int i = 0; i < dotA - dotB; i ++) { 52 | B += ".0"; 53 | } 54 | } else if (dotA < dotB) { 55 | for (int i = 0; i < dotB - dotA; i ++) { 56 | A += ".0"; 57 | } 58 | } 59 | int dots = max(dotA, dotB); 60 | int i = 0; 61 | int j = 0; 62 | if (dots == 0) { 63 | return stringVal(A, B); 64 | } 65 | 66 | // Compare the version numbers by looping through the arrays and the number of dots 67 | 68 | for (int k = 0; k <= dots; k ++) { 69 | string tempA; 70 | string tempB; 71 | while (A[i] != '.' && i < A.size()) { 72 | tempA += A[i]; 73 | i ++; 74 | } 75 | while (B[j] != '.' && j < B.size()) { 76 | tempB += B[j]; 77 | j ++; 78 | } 79 | if (stringVal(tempA, tempB) == 1) { 80 | return 1; 81 | } else if (stringVal(tempA, tempB) == -1) { 82 | return -1; 83 | } else if (stringVal(tempA, tempB) == 0) { 84 | i ++; 85 | j ++; 86 | continue; 87 | } 88 | } 89 | return 0; 90 | } 91 | -------------------------------------------------------------------------------- /Cpp/Strings/count-and-say.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to get the new string value from the old one 2 | 3 | string answer(string s) { 4 | if (s.length() == 1 && s[0] == '1') { 5 | return to_string(11); 6 | } 7 | int count = 1; 8 | string p; 9 | int i; 10 | bool flag = false; 11 | 12 | // Loop through the array and count the instances of a number to append it in the next turn 13 | 14 | for (i = 0; i < s.length() - 1; i ++) { 15 | if (s[i + 1] == s[i]) { 16 | count ++; 17 | flag = true; 18 | } else { 19 | p += (to_string(count)); 20 | p += (s[i]); 21 | flag = false; 22 | count = 1; 23 | } 24 | } 25 | if (flag) { 26 | p += (to_string(count)); 27 | p += (s[s.length() - 1]); 28 | } else { 29 | p += (to_string(1)); 30 | p += (s[s.length() - 1]); 31 | } 32 | return p; 33 | } 34 | 35 | string Solution::countAndSay(int A) { 36 | 37 | // Corner case 38 | 39 | if (A == 1) { 40 | return to_string(1); 41 | } 42 | string s = to_string(1); 43 | 44 | // Consistently generate new state strings from the previous state 45 | 46 | while (A > 1) { 47 | s = answer(s); 48 | A --; 49 | } 50 | return s; 51 | } 52 | -------------------------------------------------------------------------------- /Cpp/Strings/implement-strstr.cpp: -------------------------------------------------------------------------------- 1 | int Solution::strStr(const string A, const string B) { 2 | 3 | // Corner case 4 | 5 | if (A.size() == 0 || B.size() == 0) { 6 | return -1; 7 | } 8 | int start = -1, j = 0, i = 0; 9 | bool isCheck = false; 10 | 11 | // Keep one pointer in the needle and one in the hay 12 | 13 | while (j < B.size() && i < A.size()) { 14 | if (isCheck) { 15 | if (A[i] == B[j]) { 16 | j ++; 17 | i ++; 18 | } else { 19 | j = 0; 20 | i = start + 1; 21 | isCheck = false; 22 | } 23 | } else { 24 | start = i; 25 | isCheck = true; 26 | } 27 | } 28 | if (j == B.size()) { 29 | return start; 30 | } 31 | return -1; 32 | } 33 | -------------------------------------------------------------------------------- /Cpp/Strings/integer-to-roman.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to return the closest lower bound string/character of a number 2 | 3 | string val(int A) { 4 | if (A >= 1000) { 5 | return "M"; 6 | } else if (A >= 900) { 7 | return "CM"; 8 | } else if (A >= 500) { 9 | return "D"; 10 | } else if (A >= 400) { 11 | return "CD"; 12 | } else if (A >= 100) { 13 | return "C"; 14 | } else if (A >= 90) { 15 | return "XC"; 16 | } else if (A >= 50) { 17 | return "L"; 18 | } else if (A >= 40) { 19 | return "XL"; 20 | } else if (A >= 10) { 21 | return "X"; 22 | } else if (A >= 9) { 23 | return "IX"; 24 | } else if (A >= 5) { 25 | return "V"; 26 | } else if (A >= 4) { 27 | return "IV"; 28 | } else if (A >= 1) { 29 | return "I"; 30 | } 31 | } 32 | 33 | // Helper function to return the value associated with a number 34 | 35 | int valAct(string B) { 36 | if (B == "M") { 37 | return 1000; 38 | } else if (B == "CM") { 39 | return 900; 40 | } else if (B == "D") { 41 | return 500; 42 | } else if (B == "CD") { 43 | return 400; 44 | } else if (B == "C") { 45 | return 100; 46 | } else if (B == "XC") { 47 | return 90; 48 | } else if (B == "L") { 49 | return 50; 50 | } else if (B == "XL") { 51 | return 40; 52 | } else if (B == "X") { 53 | return 10; 54 | } else if (B == "IX") { 55 | return 9; 56 | } else if (B == "V") { 57 | return 5; 58 | } else if (B == "IV") { 59 | return 4; 60 | } else if (B == "I") { 61 | return 1; 62 | } 63 | } 64 | string Solution::intToRoman(int A) { 65 | string B; 66 | string closest; 67 | B += closest; 68 | 69 | // Loop through the int and keep reducing the actual value 70 | // Keep increasing the closest value 71 | 72 | while (A > 0) { 73 | closest = val(A); 74 | B += closest; 75 | A -= valAct(closest); 76 | } 77 | return B; 78 | } 79 | -------------------------------------------------------------------------------- /Cpp/Strings/length-of-last-word.cpp: -------------------------------------------------------------------------------- 1 | int Solution::lengthOfLastWord(const string A) { 2 | int count = 0; 3 | int i; 4 | 5 | // Handle space characters 6 | 7 | for (i = A.size() - 1; i >= 0; i --) { 8 | if (A[i] == ' ') { 9 | } else { 10 | break; 11 | } 12 | } 13 | 14 | // Count the length of the last word from the end 15 | 16 | for (; i >= 0; i --) { 17 | if (A[i] == ' ') { 18 | return count; 19 | } else count ++; 20 | } 21 | return count; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /Cpp/Strings/longest-common-prefix.cpp: -------------------------------------------------------------------------------- 1 | string Solution::longestCommonPrefix(vector &A) { 2 | int mini = INT_MAX; 3 | 4 | // Get minimum size in the string array 5 | 6 | for (int i = 0; i < A.size(); i ++) { 7 | if (A[i].size() < mini) { 8 | mini = A[i].size(); 9 | } 10 | } 11 | string prefix; 12 | int j = 0; 13 | 14 | // Compare by looping through the array 15 | 16 | for (int i = 0; i < mini; i ++) { 17 | for (j = 0; j < A.size() - 1; j ++) { 18 | if (A[j + 1][i] != A[j][i]) { 19 | return prefix; 20 | } 21 | } 22 | if (j == A.size() - 1) { 23 | prefix.push_back(A[j][i]); 24 | } 25 | } 26 | return prefix; 27 | } 28 | -------------------------------------------------------------------------------- /Cpp/Strings/longest-palindromic-substring.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to check if a string is a palindrome 2 | 3 | bool isPalindrome(int start, int end, string A) { 4 | while (start <= end) { 5 | if (A[start] != A[end]) { 6 | return 0; 7 | } 8 | start ++; 9 | end --; 10 | } 11 | return 1; 12 | } 13 | string Solution::longestPalindrome(string A) { 14 | 15 | // Corner case 16 | 17 | if (A.size() <= 0) { 18 | return string(); 19 | } 20 | string B; 21 | int startIndex = -1; 22 | int endIndex = -1; 23 | int max = INT_MIN; 24 | 25 | // Run 2 loops and check for the longest palindromic substring 26 | 27 | for (int i = 0; i < A.size(); i ++) { 28 | for (int j = A.size() - 1; j >= i; j --) { 29 | if (j - i + 1 > max) { 30 | if (isPalindrome(i, j, A)) { 31 | if (j - i + 1 > max) { 32 | startIndex = i; 33 | endIndex = j; 34 | max = j - i + 1; 35 | break; 36 | } 37 | } 38 | } else break; 39 | } 40 | } 41 | return A.substr(startIndex, endIndex - startIndex + 1); 42 | } 43 | -------------------------------------------------------------------------------- /Cpp/Strings/minimum-characters-required-to-make-a-string-palindromic.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to check if a string is a palidrome 2 | 3 | bool isPalindrome(int start, int end, string A) { 4 | 5 | while (start <= end) { 6 | if (A[start] != A[end]) { 7 | return false; 8 | } 9 | start ++; 10 | end --; 11 | } 12 | return true; 13 | } 14 | int Solution::solve(string A) { 15 | 16 | // Corner case 17 | 18 | if(A.size() <= 0) { 19 | return 0; 20 | } 21 | int compareIndex = A.size() - 1; 22 | int chars = 0; 23 | 24 | // Reach the non palindromic part of the string 25 | 26 | for (int i = compareIndex; i >= 0; i --) { 27 | if (isPalindrome(0, i, A)) { 28 | chars = A.size() - i - 1; 29 | break; 30 | } 31 | } 32 | return chars; 33 | } 34 | -------------------------------------------------------------------------------- /Cpp/Strings/multiply-strings.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to add 2 strings 2 | 3 | string addition(string A, string B) { 4 | int mini = min(A.size(), B.size()); 5 | if (A.size() == mini) { 6 | int diff = B.size() - A.size(); 7 | for (int i = 0; i < diff; i ++) { 8 | A = "0" + A; 9 | } 10 | } else if (B.size() == mini) { 11 | int diff = A.size() - B.size(); 12 | for (int i = 0; i < diff; i ++) { 13 | B = "0" + B; 14 | } 15 | } 16 | int carry = 0; 17 | string ans = ""; 18 | for (int i = A.size() - 1; i >= 0; i --) { 19 | int sum = (A[i] - '0') + (B[i] - '0') + carry; 20 | ans.push_back((sum % 10) + '0'); 21 | carry = sum / 10; 22 | } 23 | if (carry) { 24 | ans.push_back(carry + '0'); 25 | } 26 | reverse(ans.begin(), ans.end()); 27 | return ans; 28 | } 29 | string Solution::multiply(string A, string B) { 30 | 31 | // Corner case 32 | 33 | if ((A.size() == 1 && A[0] == '0') || (B.size() == 1 && B[0] == '0')) { 34 | return string("0"); 35 | } 36 | int mini = min(A.size(), B.size()); 37 | if (B.size() == mini) { 38 | swap(A, B); 39 | } 40 | int count = 0; 41 | string ans; 42 | 43 | // Loop through the strings to proceed multiplying like in the handwritten way 44 | 45 | for (int i = A.size() - 1; i >= 0; i --) { 46 | string temp; 47 | int carry = 0; 48 | for (int j = B.size() - 1; j >= 0; j --) { 49 | int mul = (A[i] - '0') * (B[j] - '0') + carry; 50 | temp.push_back((mul % 10) + '0'); 51 | carry = mul / 10; 52 | } 53 | if (carry) { 54 | temp.push_back(carry + '0'); 55 | } 56 | reverse(temp.begin(), temp.end()); 57 | for (int i = 0; i < count; i ++) { 58 | temp += '0'; 59 | } 60 | ans = addition(ans, temp); 61 | count ++; 62 | } 63 | int i = 0; 64 | while (ans[i] == '0') { 65 | i ++; 66 | } 67 | if (i != 0) { 68 | ans.erase(ans.begin(), ans.begin() + i); 69 | } 70 | return ans; 71 | } 72 | -------------------------------------------------------------------------------- /Cpp/Strings/palindrome-string.cpp: -------------------------------------------------------------------------------- 1 | int Solution::isPalindrome(string A) { 2 | string B, C; 3 | 4 | // Loop through the string and convert the string to lowercase 5 | // Push the alphanumeric characters into a new string 6 | // Reverse the new string for comparison 7 | 8 | for (int i = 0; i < A.size(); i ++) { 9 | int temp = A[i]; 10 | if ((temp >= 48 && temp <= 57) || (temp >= 65 && temp < 91) || (temp >= 97 && temp < 123)) { 11 | if (temp >= 65 && temp < 91) { 12 | char c = temp + 32; 13 | A[i] = c; 14 | } 15 | B.push_back(A[i]); 16 | } 17 | } 18 | C = B; 19 | reverse(C.begin(), C.end()); 20 | //cout << B << " " << C; 21 | return B == C; 22 | } 23 | -------------------------------------------------------------------------------- /Cpp/Strings/power-of-2.cpp: -------------------------------------------------------------------------------- 1 | int Solution::power(string A) 2 | { 3 | long long int k = 0; 4 | int i = 0; 5 | int len = A.size(); 6 | 7 | // Create the number and check (num & num - 1) 8 | 9 | while (i < len) 10 | { 11 | k = k * 10 + (A[i] - '0'); 12 | i ++; 13 | } 14 | if (k == 1) 15 | return 0; 16 | int p = k-1; 17 | if ((k & p) == 0) 18 | return 1; 19 | else 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /Cpp/Strings/pretty-json.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to add tabs to text 2 | 3 | string makeTab(string a, int curTab) { 4 | string res; 5 | while (curTab) { 6 | res += '\t'; 7 | curTab --; 8 | } 9 | res += a; 10 | return res; 11 | } 12 | 13 | // Driver 14 | 15 | vector Solution::prettyJSON(string A) { 16 | vector res; 17 | int curTab = 0; 18 | string temp; 19 | for (int i = 0; i < A.size(); i ++) { 20 | if (A[i] == '{' || A[i] == '[') { 21 | if (temp.size()) { 22 | res.push_back(makeTab(temp, curTab)); 23 | } 24 | temp.clear(); 25 | res.push_back(makeTab(string(1, A[i]), curTab)); 26 | curTab ++; 27 | } else if (A[i] == ',') { 28 | if (temp.size()) { 29 | res.push_back(makeTab(temp, curTab) + ","); 30 | } else res[res.size() - 1] += ','; 31 | temp.clear(); 32 | } else if (A[i] == '}' || A[i] == ']') { 33 | if (temp.size()) { 34 | res.push_back(makeTab(temp, curTab)); 35 | } 36 | curTab --; 37 | res.push_back(makeTab(string(1, A[i]), curTab)); 38 | temp.clear(); 39 | } else if (A[i] == ' ') { 40 | continue; 41 | } else { 42 | temp.push_back(A[i]); 43 | } 44 | } 45 | return res; 46 | } 47 | 48 | // Alternate solution 49 | 50 | vector Solution::prettyJSON(string A) { 51 | 52 | // Corner case 53 | 54 | vector B; 55 | if (A.size() <= 0) { 56 | return B; 57 | } 58 | int countBraces = 0; 59 | string temp, temp2; 60 | 61 | // Space character handling 62 | 63 | for (int i = 0; i < A.size(); i ++) { 64 | if (A[i] == ' ' && i != A.size() - 1) { 65 | A.erase(A.begin() + i, A.begin() + i + 1); 66 | i --; 67 | } 68 | } 69 | if (A[A.size() - 1] == ' ') { 70 | A.erase(A.end() - 1, A.end()); 71 | } 72 | bool sameLine = true; 73 | 74 | // Loop through the string to check for indentation 75 | 76 | for (int i = 0; i < A.size(); i ++) { 77 | if (sameLine) { 78 | temp += A[i]; 79 | 80 | // Specific character handling 81 | 82 | if (A[i] == '{' || A[i] == '[') { 83 | countBraces ++; 84 | sameLine = false; 85 | B.push_back(temp); 86 | temp.clear(); 87 | } else if (A[i] == ',' || (A[i] == ':' && (A[i + 1] == '{' || A[i + 1] == '['))) { 88 | sameLine = false; 89 | B.push_back(temp); 90 | temp.clear(); 91 | } else if (A[i] == '}' || A[i] == ']') { 92 | temp.erase(temp.end() - 1, temp.end()); 93 | countBraces --; 94 | sameLine = false; 95 | B.push_back(temp); 96 | temp.clear(); 97 | i --; 98 | } 99 | } else { 100 | if (A[i] == '}' || A[i] == ']') { 101 | for (int j = 0; j < countBraces; j ++) { 102 | temp += '\t'; 103 | } 104 | temp += A[i]; 105 | if (A[i + 1] == ',') { 106 | temp += A[i + 1]; 107 | sameLine = false; 108 | B.push_back(temp); 109 | temp.clear(); 110 | i ++; 111 | continue; 112 | } 113 | B.push_back(temp); 114 | temp.clear(); 115 | countBraces --; 116 | } else { 117 | for (int j = 0; j < countBraces; j ++) { 118 | temp += '\t'; 119 | } 120 | sameLine = true; 121 | i --; 122 | } 123 | } 124 | } 125 | return B; 126 | } 127 | -------------------------------------------------------------------------------- /Cpp/Strings/reverse-the-string.cpp: -------------------------------------------------------------------------------- 1 | void Solution::reverseWords(string &A) { 2 | int spaceCount = 0; 3 | int i, start, end; 4 | 5 | // Handle space characters 6 | 7 | for (i = 0; i < A.size(); i ++) { 8 | if (A[i] != ' ') { 9 | break; 10 | } 11 | } 12 | start = i; 13 | if (start == A.size()) { 14 | return; 15 | } 16 | for (i = A.size() - 1; i >= 0; i --) { 17 | if (A[i] != ' ') { 18 | break; 19 | } 20 | } 21 | end = i; 22 | for (i = start; i <= end; i ++) { 23 | if (A[i] == ' ') { 24 | if (A[i + 1] == ' ') { 25 | A.erase(A.begin() + i, A.begin() + i + 1); 26 | i --; 27 | } 28 | } 29 | } 30 | string s, temp; 31 | reverse(A.begin(), A.end()); 32 | 33 | // Get the last word from the end of the word-reversed string 34 | 35 | for (i = 0; i < A.size(); i ++) { 36 | if (A[i] != ' ') { 37 | temp.push_back(A[i]); 38 | } else { 39 | reverse(temp.begin(), temp.end()); 40 | s += temp; 41 | s += ' '; 42 | temp.clear(); 43 | } 44 | } 45 | if (temp.size() != 0) { 46 | reverse(temp.begin(), temp.end()); 47 | s += temp; 48 | } 49 | A = s; 50 | } 51 | -------------------------------------------------------------------------------- /Cpp/Strings/roman-to-integer.cpp: -------------------------------------------------------------------------------- 1 | // Helper function to return the value associated with a Roman character 2 | 3 | int val(char i) { 4 | if (i == 'M') { 5 | return 1000; 6 | } else if (i == 'D') { 7 | return 500; 8 | } else if (i == 'C') { 9 | return 100; 10 | } else if (i == 'L') { 11 | return 50; 12 | } else if (i == 'X') { 13 | return 10; 14 | } else if (i == 'V') { 15 | return 5; 16 | } else if (i == 'I') { 17 | return 1; 18 | } 19 | } 20 | int Solution::romanToInt(string A) { 21 | int count = 0; 22 | 23 | // Loop through the string from the end 24 | // If a character with more value is encountered 25 | // Add the subtracted value of the 2 to the count 26 | 27 | for (int i = A.size() - 1; i >= 0; i --) { 28 | int cur = val(A[i]); 29 | int pre; 30 | count += cur; 31 | if (i != 0) { 32 | pre = val(A[i - 1]); 33 | if (pre < cur) { 34 | count -= pre; 35 | i --; 36 | } 37 | } 38 | } 39 | return count; 40 | } 41 | -------------------------------------------------------------------------------- /Cpp/Strings/stringoholics.cpp: -------------------------------------------------------------------------------- 1 | #define MOD 1000000007 2 | typedef long long ll; 3 | 4 | // Helper function to return progressive sum 5 | 6 | ll prod(ll n) { 7 | return ((n * (n + 1))) / 2; 8 | } 9 | 10 | // Function to return the min time taken to get the original string after rotation 11 | 12 | ll timeTaken(string s) { 13 | if (s.size() == 1) { 14 | return 1; 15 | } 16 | while (s.size() % 2 == 0) { 17 | string firstHalf = string(s.begin(), s.begin() + s.size() / 2); 18 | string secondHalf = string(s.begin() + s.size() / 2, s.end()); 19 | if (firstHalf == secondHalf) { 20 | s = firstHalf; 21 | } else break; 22 | } 23 | ll res = 1; 24 | int i = 1; 25 | for (; i < 2 * s.size(); i ++) { 26 | if (prod(i) % s.size() == 0) { 27 | return i; 28 | } 29 | } 30 | return i; 31 | } 32 | 33 | // Create sieve of erastothenes and map prime numbers 34 | 35 | unordered_map makeSieve(int n = 500) { 36 | unordered_map umap; 37 | vector num(n, 1); 38 | for (int i = 2; i * i <= n; i ++) { 39 | for (int j = 2; j * i <= n; j ++) { 40 | num[i * j] = 0; 41 | } 42 | } 43 | for (int i = 2; i < num.size(); i ++) { 44 | if (num[i]) { 45 | umap[i] = 0; 46 | } 47 | } 48 | return umap; 49 | } 50 | 51 | // Seperate the factors of the min. time to get LCM 52 | 53 | void seperateFactors(ll num, unordered_map &umap) { 54 | for (auto it: umap) { 55 | ll exponentVal = 0; 56 | if (num % it.first == 0) { 57 | while (num % it.first == 0) { 58 | exponentVal ++; 59 | num /= it.first; 60 | } 61 | if (exponentVal > it.second) { 62 | umap[it.first] = exponentVal; 63 | } 64 | } 65 | } 66 | if (num != 1) { 67 | umap[num] = 1; 68 | } 69 | return; 70 | } 71 | 72 | // Driver 73 | 74 | int Solution::solve(vector &A) { 75 | ll res = 1; 76 | auto umap = makeSieve(); 77 | for (int i = 0; i < A.size(); i ++) { 78 | long long val = timeTaken(A[i]); 79 | seperateFactors(val, umap); 80 | } 81 | for (auto it: umap) { 82 | ll expVal = 1; 83 | ll maxExp = it.second; 84 | while (maxExp) { 85 | expVal = (expVal * it.first) % MOD; 86 | maxExp --; 87 | } 88 | res = (res * expVal) % MOD; 89 | } 90 | return res; 91 | } 92 | 93 | // Alternate solution: Below solution exceeds time limit 94 | 95 | long long int mod = 1000000007; 96 | string s2; 97 | 98 | // Helper function to calculate the gcd 99 | 100 | long long int lcm (int a, int b) { 101 | long long int temp = ((a % mod) * (b % mod)); 102 | return (int)(temp / (float)__gcd(a, b)) % mod; 103 | } 104 | 105 | // Helper function to return rotated string 106 | 107 | string rotate (string s, int k) { 108 | k = k % s.size(); 109 | s2.clear(); 110 | for (int i = k; i < s.size(); i ++) { 111 | s2 += s[i]; 112 | } 113 | for (int i = 0; i < k; i ++) { 114 | s2 += s[i]; 115 | } 116 | return s2; 117 | } 118 | 119 | // Helper function to calculate the minimum count for rotation 120 | 121 | long long minCount (string s) { 122 | int turns = 0; 123 | long long count = 1; 124 | s2.clear(); 125 | while (1) { 126 | string s3 = rotate(s, (int)(count * (count + 1))/(float)2); 127 | if (s3 == s) { 128 | return count; 129 | } else { 130 | count ++; 131 | } 132 | } 133 | return count; 134 | 135 | } 136 | int Solution::solve(vector &A) { 137 | vector B; 138 | for (int i = 0; i < A.size(); i ++) { 139 | B.push_back(minCount(A[i])); 140 | } 141 | 142 | // Corner case 143 | 144 | if (A.size() == 1) { 145 | return B[0]; 146 | } 147 | int len = B.size(); 148 | vector v = B; 149 | long long ans=1; 150 | for(int i=0;i 255) 7 | return false; 8 | string y = to_string(x); 9 | if(y != s) 10 | return false; 11 | return true; 12 | } 13 | vector Solution::restoreIpAddresses(string A) { 14 | vector B; 15 | 16 | // Corner case 17 | 18 | if (A.size() < 4 || A.size() > 12) { 19 | return B; 20 | } 21 | 22 | // Loop through the string to split it into 3 parts for the numbers and check them individually 23 | 24 | for (int i = 1; i < A.size(); i ++) { 25 | for (int j = i + 1; j < A.size(); j ++) { 26 | for (int k = j + 1; k < A.size(); k ++) { 27 | int first = stoi(A.substr(0, i)); 28 | int second = stoi(A.substr(i, j - i)); 29 | int third = stoi(A.substr(j, k - j)); 30 | int fourth = stoi(A.substr(k)); 31 | if (first >= 0 && first <= 255 && second >= 0 && second <= 255 && third >= 0 && third <= 255 && fourth >= 0 && fourth <= 255 && check(A.substr(0, i)) && check(A.substr(i, j - i)) && check(A.substr(j, k - j)) && check(A.substr(k))) { 32 | string temp = to_string(first) + "." + to_string(second) + "." + to_string(third) + "." + to_string(fourth); 33 | B.push_back(temp); 34 | } 35 | } 36 | } 37 | } 38 | return B; 39 | } 40 | 41 | // Alternate solution using recursion 42 | 43 | // Helper function to check validity of a string 44 | 45 | bool checkValidNum(string a) { 46 | return a.size() > 1 && a[0] == '0' ? 0 : stoll(a) >= 0 && stoll(a) <= 255; 47 | } 48 | 49 | // Helper function to check validity of a whole IP 50 | 51 | bool checkValidIP(string a) { 52 | int occurences = count(a.begin(), a.end(), '.'); 53 | if (occurences != 3) { 54 | return 0; 55 | } 56 | int start = 0; 57 | while (a.find('.', start) != string::npos) { 58 | string temp = a.substr(start, a.find('.', start) - start); 59 | if (!checkValidNum(temp)) { 60 | return 0; 61 | } 62 | start = a.find('.', start) + 1; 63 | } 64 | return checkValidNum(a.substr(start)); 65 | } 66 | 67 | // Helper function to generate all possibilities 68 | 69 | void generate (string A, vector &res, int index, string local) { 70 | if (index >= A.size()) { 71 | if (checkValidIP(local)) { 72 | res.push_back(local); 73 | } 74 | return; 75 | } 76 | for (int i = 1; i <= A.size() - index; i ++) { 77 | string temp = A.substr(index, i); 78 | generate(A, res, index + i, local.size() ? local + "." + temp : temp); 79 | } 80 | return; 81 | } 82 | vector Solution::restoreIpAddresses(string A) { 83 | vector res; 84 | generate(A, res, 0, string()); 85 | return res; 86 | } 87 | 88 | 89 | -------------------------------------------------------------------------------- /Cpp/Strings/valid-number.cpp: -------------------------------------------------------------------------------- 1 | bool checkNumber(string A, int i){ 2 | 3 | // Handle spcae characters 4 | 5 | while (isspace(A[i])) { 6 | i ++; 7 | } 8 | 9 | if (i == A.size()) { 10 | return 0; 11 | } 12 | 13 | while (isspace(A[A.size()-1])) { 14 | A.pop_back(); 15 | } 16 | 17 | int eflag = 0; 18 | int sflag = 0; 19 | int dflag = 0; 20 | int nflag = 0; 21 | 22 | // Handle number characters 23 | 24 | while (i < A.size()) { 25 | if (isdigit(A[i])) { 26 | i++; 27 | nflag = 1; 28 | } 29 | else { 30 | 31 | // Handle e character 32 | 33 | if (A[i] == 'e') { 34 | if (nflag == 0) { 35 | return 0; 36 | } 37 | eflag = 1; 38 | sflag = 0; 39 | dflag = 0; 40 | nflag = 0; 41 | i ++; 42 | if (i == A.size()) { 43 | return 0; 44 | } 45 | } 46 | else if (A[i] == '+' || A[i] == '-') { 47 | i ++; 48 | if (i == A.size()) { 49 | return 0; 50 | } 51 | if (sflag == 0) { 52 | sflag = 1; 53 | } 54 | else { 55 | return 0; 56 | } 57 | if (nflag == 0) { 58 | sflag = 1; 59 | } 60 | else { 61 | return 0; 62 | } 63 | } 64 | 65 | // Handle . character 66 | 67 | else if (A[i] == '.') { 68 | if (dflag == 0) { 69 | dflag = 1; 70 | } 71 | else { 72 | return 0; 73 | } 74 | if (eflag == 1) { 75 | return 0; 76 | } 77 | nflag = 1; 78 | i ++; 79 | if (i == A.size()) { 80 | return 0; 81 | } 82 | else if (!isdigit (A[i])) { 83 | return 0; 84 | } 85 | } 86 | else { 87 | return 0; 88 | } 89 | } 90 | } 91 | 92 | return 1; 93 | } 94 | 95 | int Solution::isNumber(const string B) { 96 | return checkNumber(B, 0); 97 | } 98 | -------------------------------------------------------------------------------- /Cpp/Strings/zigzag-string.cpp: -------------------------------------------------------------------------------- 1 | string Solution::convert(string A, int B) { 2 | 3 | // Corner case 4 | 5 | if (B >= A.size()) { 6 | return A; 7 | } else if (B == 1) { 8 | return A; 9 | } 10 | int temp = B; 11 | string C; 12 | int i; 13 | 14 | // Logic to get to the next position 15 | 16 | for (i = 0; i < temp; i ++) { 17 | for (int j = i; j < A.size(); j += 2 * ((B - 1) - (j % (B - 1)))) { 18 | C += A[j]; 19 | } 20 | } 21 | return C; 22 | } 23 | -------------------------------------------------------------------------------- /Cpp/Trees/Examples/next-greater-number-bst.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | vector B; 11 | TreeNode* findMin(TreeNode* A) { 12 | if (A == NULL) { 13 | return NULL; 14 | } 15 | while (A -> left) { 16 | A = A -> left; 17 | } 18 | return A; 19 | } 20 | TreeNode* findCur(TreeNode* A, int B) { 21 | if (A == NULL) { 22 | return NULL; 23 | } 24 | if (A -> val == B) { 25 | return A; 26 | } else if (A -> val > B) { 27 | return findCur(A -> left, B); 28 | } else { 29 | return findCur(A -> right, B); 30 | } 31 | return NULL; 32 | } 33 | TreeNode* Solution::getSuccessor(TreeNode* A, int C) { 34 | TreeNode* cur = findCur(A, C); 35 | if (cur == NULL) { 36 | return NULL; 37 | } 38 | if (cur -> right != NULL) { 39 | TreeNode* temp = cur -> right; 40 | return findMin(temp); 41 | } 42 | else { 43 | TreeNode* ancestor = A; 44 | TreeNode* successor = NULL; 45 | while (ancestor != cur) { 46 | if (cur -> val < ancestor -> val) { 47 | successor = ancestor; 48 | ancestor = ancestor -> left; 49 | } else { 50 | ancestor = ancestor -> right; 51 | } 52 | } 53 | return successor; 54 | } 55 | 56 | return A; 57 | } -------------------------------------------------------------------------------- /Cpp/Trees/Problems/2sum-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | void inOrder(TreeNode* A, vector &temp) { 11 | if (A == NULL) { 12 | return; 13 | } 14 | inOrder(A -> left, temp); 15 | temp.push_back(A -> val); 16 | inOrder(A -> right, temp); 17 | return; 18 | } 19 | int Solution::t2Sum(TreeNode* A, int B) { 20 | vector temp; 21 | inOrder(A, temp); 22 | int i = 0; 23 | int j = temp.size() - 1; 24 | while (i < j) { 25 | if (temp[i] + temp[j] == B) { 26 | return 1; 27 | } else if (temp[i] + temp[j] < B) { 28 | i ++; 29 | } else if (temp[i] + temp[j] > B) { 30 | j --; 31 | } 32 | } 33 | return 0; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/balanced-binary-tree.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mailtokartik1/InterviewBit-Solutions/8a9be25cf55947aff456c7c138e2ee6f518aa6a5/Cpp/Trees/Problems/balanced-binary-tree.cpp -------------------------------------------------------------------------------- /Cpp/Trees/Problems/binary-tree-from-inorder-and-postorder.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | TreeNode* build(vector &in, vector &post, int start, int end, int &index, unordered_map &map) { 11 | if (start > end) { 12 | return NULL; 13 | } 14 | TreeNode* root = new TreeNode(post[index ++]); 15 | if (start == end) { 16 | return root; 17 | } 18 | int index1 = map[root -> val]; 19 | root -> right = build(in, post, start, index1 - 1, index, map); 20 | root -> left = build(in, post, index1 + 1, end, index, map); 21 | return root; 22 | } 23 | TreeNode* Solution::buildTree(vector &in, vector &post) { 24 | if (in.size() != post.size()) { 25 | return NULL; 26 | } 27 | if (in.size() == 0 || post.size() == 0) { 28 | return NULL; 29 | } 30 | reverse(post.begin(), post.end()); 31 | reverse(in.begin(), in.end()); 32 | unordered_map map; 33 | for (int i = 0; i < in.size(); i ++) { 34 | map[in[i]] = i; 35 | } 36 | int index = 0; 37 | return build(in, post, 0, in.size() - 1, index, map); 38 | } 39 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/bst-iterator.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | vector temp; 11 | bool isEmpty = false; 12 | vector::iterator it; 13 | void inOrder(TreeNode* A) { 14 | if (A == NULL) { 15 | return; 16 | } 17 | inOrder(A -> left); 18 | temp.push_back(A -> val); 19 | inOrder(A -> right); 20 | return; 21 | } 22 | BSTIterator::BSTIterator(TreeNode *root) { 23 | temp.clear(); 24 | inOrder(root); 25 | if (temp.size()) { 26 | isEmpty = false; 27 | it = temp.begin(); 28 | } else isEmpty = true; 29 | } 30 | 31 | /** @return whether we have a next smallest number */ 32 | bool BSTIterator::hasNext() { 33 | if (isEmpty) { 34 | return 0; 35 | } else { 36 | if (it != temp.end()) { 37 | return 1; 38 | } 39 | return 0; 40 | } 41 | } 42 | 43 | /** @return the next smallest number */ 44 | int BSTIterator::next() { 45 | if (isEmpty) { 46 | return -1; 47 | } else { 48 | if (it != temp.end()) { 49 | int temp1 = *it; 50 | it ++; 51 | return temp1; 52 | } else { 53 | return -1; 54 | } 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/construct-binary-tree-from-inorder-and-preorder.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | /* 11 | int findIndex(vector &B, int temp, int start, int end) { 12 | for (int i = start; i <= end; i ++) { 13 | if (B[i] == temp) { 14 | return i; 15 | } 16 | } 17 | return -1; 18 | } 19 | */ 20 | TreeNode* build(vector &A, vector &B, int start, int end, int &index, unordered_map &map) { 21 | if (start > end) { 22 | return NULL; 23 | } 24 | TreeNode* root = new TreeNode(A[index ++]); 25 | if (start == end) { 26 | return root; 27 | } 28 | int index1 = map[root -> val]; 29 | root -> left = build(A, B, start, index1 - 1, index, map); 30 | root -> right = build(A, B, index1 + 1, end, index, map); 31 | return root; 32 | } 33 | TreeNode* Solution::buildTree(vector &A, vector &B) { 34 | if (A.size() == 0 || B.size() == 0) { 35 | return NULL; 36 | } 37 | if (A.size() != B.size()) { 38 | return NULL; 39 | } 40 | unordered_map map; 41 | for (int i = 0; i < B.size(); i ++) { 42 | map[B[i]] = i; 43 | } 44 | int index = 0; 45 | return build(A, B, 0, A.size() - 1, index, map); 46 | } 47 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/flatten-binary-tree-to-linked-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | TreeNode* findTail(TreeNode* A) { 11 | if (A == NULL) { 12 | return A; 13 | } 14 | if (A -> right == NULL) { 15 | return A; 16 | } 17 | return findTail(A -> right); 18 | } 19 | TreeNode* findRight(TreeNode* A) { 20 | if (A == NULL) { 21 | return A; 22 | } 23 | if (A -> right == NULL) { 24 | return A; 25 | } 26 | return findRight(A -> right); 27 | } 28 | TreeNode* Solution::flatten(TreeNode* A) { 29 | if (A == NULL) { 30 | return NULL; 31 | } 32 | TreeNode* temp = A -> right; 33 | A -> right = flatten(A -> left); 34 | TreeNode* temp1 = findTail(A -> right); 35 | A -> left = NULL; 36 | if (temp1) { 37 | temp1 -> right = flatten(temp); 38 | } else { 39 | A -> right = flatten(temp); 40 | } 41 | return A; 42 | } 43 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/hotel-reviews.cpp: -------------------------------------------------------------------------------- 1 | struct Trie { 2 | bool exist; 3 | Trie* next[26]; 4 | Trie(bool val = false) { 5 | exist = val; 6 | for (int i = 0; i < 26; i ++) { 7 | next[i] = NULL; 8 | } 9 | } 10 | }; 11 | void add(Trie* A, string s) { 12 | if (s.size() == 0) { 13 | return; 14 | } 15 | for (int i = 0; i < s.size(); i ++) { 16 | if (!A -> next[s[i] - 'a']) { 17 | A -> next[s[i] - 'a'] = new Trie(); 18 | } 19 | A = A -> next[s[i] - 'a']; 20 | } 21 | A -> exist = true; 22 | return; 23 | } 24 | bool search(Trie* A, string s) { 25 | if (A == NULL) { 26 | return 0; 27 | } 28 | for (int i = 0; i < s.size(); i ++) { 29 | if (!A -> next[s[i] - 'a']) { 30 | return 0; 31 | } else { 32 | A = A -> next[s[i] - 'a']; 33 | } 34 | } 35 | if (A -> exist) { 36 | return 1; 37 | } 38 | return 0; 39 | } 40 | int returnMaxIndex(vector &A, unordered_map &map) { 41 | int maxi = INT_MIN; 42 | int index = -1; 43 | for (int i = 0; i < A.size(); i ++) { 44 | if (A[i] > maxi && map[i] != 1) { 45 | maxi = A[i]; 46 | index = i; 47 | } 48 | } 49 | map[index] = 1; 50 | return index; 51 | } 52 | vector Solution::solve(string A, vector &B) { 53 | Trie* root = new Trie(); 54 | unordered_map map; 55 | unordered_map map2; 56 | string temp; 57 | for (int i = 0; i < A.size(); i ++) { 58 | if (A[i] == '_') { 59 | add(root, temp); 60 | temp.clear(); 61 | } else { 62 | temp += A[i]; 63 | } 64 | i ++; 65 | if (i == A.size()) { 66 | add(root, temp); 67 | temp.clear(); 68 | } 69 | i --; 70 | } 71 | vector scores(B.size()), res; 72 | temp = ""; 73 | for (int i = 0; i < B.size(); i ++) { 74 | int score = 0; 75 | for (int j = 0; j < B[i].size(); j ++) { 76 | if (B[i][j] == '_') { 77 | if (search(root, temp) == 1) { 78 | score ++; 79 | } 80 | temp.clear(); 81 | } else { 82 | temp += B[i][j]; 83 | } 84 | j ++; 85 | if (j == B[i].size()) { 86 | if (search(root, temp) == 1) { 87 | score ++; 88 | } 89 | temp.clear(); 90 | } 91 | j --; 92 | } 93 | scores[i] = score; 94 | score = 0; 95 | temp.clear(); 96 | } 97 | int size = scores.size(); 98 | map2.clear(); 99 | for (int i = 0; i < size; i ++) { 100 | res.push_back(returnMaxIndex(scores, map2)); 101 | } 102 | return res; 103 | } 104 | // Brute force solution 105 | /* 106 | int returnMaxIndex(vector &A, unordered_map &map) { 107 | int maxi = INT_MIN; 108 | int index = -1; 109 | for (int i = 0; i < A.size(); i ++) { 110 | if (A[i] > maxi && map[i] != 1) { 111 | maxi = A[i]; 112 | index = i; 113 | } 114 | } 115 | map[index] = 1; 116 | return index; 117 | } 118 | vector Solution::solve(string A, vector &B) { 119 | unordered_map map; 120 | unordered_map map2; 121 | string temp; 122 | for (int i = 0; i < A.size(); i ++) { 123 | if (A[i] == '_') { 124 | //cout << temp; 125 | map[temp] = 1; 126 | temp.clear(); 127 | } else { 128 | temp += A[i]; 129 | } 130 | i ++; 131 | if (i == A.size()) { 132 | //cout << temp; 133 | map[temp] = 1; 134 | temp.clear(); 135 | } 136 | i --; 137 | } 138 | for (unordered_map::iterator it = map.begin(); it != map.end(); it ++) { 139 | //cout << "key " << it -> first << " second " << it -> second << " "; 140 | } 141 | vector scores(B.size()), res; 142 | temp = ""; 143 | for (int i = 0; i < B.size(); i ++) { 144 | int score = 0; 145 | for (int j = 0; j < B[i].size(); j ++) { 146 | if (B[i][j] == '_') { 147 | //cout << temp << " "; 148 | if (map[temp] == 1) { 149 | score ++; 150 | } 151 | //map[temp] = 1; 152 | temp.clear(); 153 | } else { 154 | temp += B[i][j]; 155 | } 156 | j ++; 157 | if (j == B[i].size()) { 158 | //cout << temp; 159 | if (map[temp] == 1) { 160 | score ++; 161 | } 162 | temp.clear(); 163 | } 164 | j --; 165 | } 166 | scores[i] = score; 167 | score = 0; 168 | temp.clear(); 169 | } 170 | int size = scores.size(); 171 | map2.clear(); 172 | for (int i = 0; i < size; i ++) { 173 | res.push_back(returnMaxIndex(scores, map2)); 174 | } 175 | return res; 176 | } 177 | */ -------------------------------------------------------------------------------- /Cpp/Trees/Problems/identical-binary-trees.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | int Solution::isSameTree(TreeNode* A, TreeNode* B) { 11 | if (A == NULL && B == NULL) { 12 | return 1; 13 | } else if (A == NULL || B == NULL) { 14 | return 0; 15 | } 16 | if (A -> val != B -> val) { 17 | return 0; 18 | } else { 19 | return isSameTree(A -> left, B -> left) && isSameTree(A -> right, B -> right); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/inorder-traversal-of-cartesian-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | TreeNode* buildCartesianTree(vector &A, int start, int end) { 11 | if (start == end) { 12 | return new TreeNode(A[start]); 13 | } else if (start > end) { 14 | return NULL; 15 | } 16 | TreeNode* root = NULL; 17 | int index, maxi = INT_MIN; 18 | for (int i = start; i <= end; i ++) { 19 | if (A[i] > maxi) { 20 | index = i; 21 | maxi = A[i]; 22 | } 23 | } 24 | root = new TreeNode(maxi); 25 | root -> left = buildCartesianTree(A, start, index - 1); 26 | root -> right = buildCartesianTree(A, index + 1, end); 27 | return root; 28 | } 29 | TreeNode* Solution::buildTree(vector &A) { 30 | if (A.size() <= 0) { 31 | return NULL; 32 | } 33 | return buildCartesianTree(A, 0, A.size() - 1); 34 | } 35 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/inorder-traversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | vector Solution::inorderTraversal(TreeNode* A) { 11 | stack s; 12 | vector temp; 13 | if (A == NULL) { 14 | return temp; 15 | } 16 | s.push(A); 17 | while (!s.empty()) { 18 | TreeNode* node = s.top(); 19 | if (node -> left) { 20 | s.push(node -> left); 21 | node -> left = NULL; 22 | } else { 23 | temp.push_back(node -> val); 24 | s.pop(); 25 | if (node -> right) { 26 | s.push(node -> right); 27 | } 28 | } 29 | } 30 | return temp; 31 | } 32 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/invert-the-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | TreeNode* Solution::invertTree(TreeNode* A) { 11 | if (A == NULL) { 12 | return A; 13 | } 14 | TreeNode* tempL = invertTree(A -> left); 15 | TreeNode* tempR = invertTree(A -> right); 16 | A -> left = tempR; 17 | A -> right = tempL; 18 | return A; 19 | } 20 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/kth-smallest-element-in-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | void inOrder(TreeNode* A, vector &temp) { 11 | if (A == NULL) { 12 | return; 13 | } 14 | inOrder(A -> left, temp); 15 | temp.push_back(A -> val); 16 | inOrder(A -> right, temp); 17 | return; 18 | } 19 | int Solution::kthsmallest(TreeNode* A, int B) { 20 | vector temp; 21 | inOrder(A, temp); 22 | return temp[B - 1]; 23 | } 24 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/least-common-ancestor.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | void findPathToNode(TreeNode* A, vector temp, vector > &D, int C) { 11 | if (A == NULL) { 12 | return; 13 | } 14 | temp.push_back(A -> val); 15 | if (A -> val == C) { 16 | D.push_back(temp); 17 | return; 18 | } 19 | findPathToNode(A -> left, temp, D, C); 20 | findPathToNode(A -> right, temp, D, C); 21 | return; 22 | } 23 | int Solution::lca(TreeNode* A, int B, int C) { 24 | if (A == NULL) { 25 | return -1; 26 | } 27 | vector > D; 28 | vector temp, temp2; 29 | findPathToNode(A, temp, D, C); 30 | findPathToNode(A, temp2, D, B); 31 | if (B == C) { 32 | if (D.size() == 0) { 33 | return -1; 34 | } else if (D.size() == 1) { 35 | return B; 36 | } 37 | } 38 | if (D.size() <= 1) { 39 | return -1; 40 | } 41 | int index = -1; 42 | int size = min(D[0].size(), D[1].size()); 43 | for (int i = 0; i < size; i ++) { 44 | if (D[0][i] == D[1][i]) { 45 | index = D[0][i]; 46 | } else { 47 | break; 48 | } 49 | } 50 | return index; 51 | } 52 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/max-depth-of-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | int maxi = 0; 11 | int Solution::maxDepth(TreeNode* A) { 12 | if (A == NULL) { 13 | return 0; 14 | } 15 | if (A -> left == NULL && A -> right == NULL) { 16 | return 1; 17 | } else { 18 | int maxim = max(maxDepth(A -> left), maxDepth(A -> right)); 19 | maxi = maxim + 1; 20 | } 21 | return maxi; 22 | } 23 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/min-depth-of-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | int Solution::minDepth(TreeNode* A) { 11 | if (A == NULL) { 12 | return 0; 13 | } 14 | if (A -> left == NULL && A -> right == NULL) { 15 | return 1; 16 | } 17 | if (!A -> left) { 18 | return 1 + minDepth(A -> right); 19 | } 20 | if (!A -> right) { 21 | return 1 + minDepth(A -> left); 22 | } 23 | return (1 + min(minDepth(A -> left), minDepth(A -> right))); 24 | } 25 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/path-sum.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | bool pathSum(TreeNode* A, int curSum, int target) { 11 | if (A == NULL) { 12 | return 0; 13 | } 14 | if (A -> left == NULL && A -> right == NULL) { 15 | return curSum + A -> val == target; 16 | } 17 | return (pathSum(A -> left, A -> val + curSum, target) || pathSum(A -> right, A -> val + curSum, target)); 18 | } 19 | int Solution::hasPathSum(TreeNode* A, int B) { 20 | if (A == NULL) { 21 | return 0; 22 | } 23 | return pathSum(A, 0, B); 24 | } 25 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/populate-next-right-pointers-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree with next pointer. 3 | * struct TreeLinkNode { 4 | * int val; 5 | * TreeLinkNode *left, *right, *next; 6 | * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} 7 | * }; 8 | */ 9 | int height(TreeLinkNode* A) { 10 | if (A == NULL) { 11 | return 0; 12 | } 13 | return 1 + max(height(A -> left), height(A -> right)); 14 | } 15 | void lOT(TreeLinkNode* A, vector> &B, int index) { 16 | if (A == NULL) { 17 | return; 18 | } 19 | B[index].push_back(A); 20 | lOT(A -> left, B, index + 1); 21 | lOT(A -> right, B, index + 1); 22 | } 23 | void Solution::connect(TreeLinkNode* A) { 24 | 25 | // Approach 1 26 | 27 | /* 28 | vector > B(height(A)); 29 | lOT(A, B, 0); 30 | for (int i = 0; i < B.size(); i ++) { 31 | for (int j = 0; j < B[i].size() - 1; j ++) { 32 | B[i][j] -> next = B[i][j + 1]; 33 | } 34 | } 35 | return; 36 | */ 37 | 38 | // Approach 2 39 | 40 | queue queue1; 41 | queue queue2; 42 | stack curLevel; 43 | stack nextLevel; 44 | if (A == NULL) { 45 | return; 46 | } 47 | queue1.push(A); 48 | TreeLinkNode* temp = NULL; 49 | while (!queue1.empty()) { 50 | TreeLinkNode* temp1 = queue1.front(); 51 | temp1 -> next = temp; 52 | temp = temp1; 53 | queue1.pop(); 54 | if (temp1 -> right) { 55 | queue2.push(temp1 -> right); 56 | } 57 | if (temp1 -> left) { 58 | queue2.push(temp1 -> left); 59 | } 60 | if (queue1.empty()) { 61 | temp = NULL; 62 | queue1.swap(queue2); 63 | } 64 | } 65 | return; 66 | } 67 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/postorder-traversal.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mailtokartik1/InterviewBit-Solutions/8a9be25cf55947aff456c7c138e2ee6f518aa6a5/Cpp/Trees/Problems/postorder-traversal.cpp -------------------------------------------------------------------------------- /Cpp/Trees/Problems/preorder-traversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | vector Solution::preorderTraversal(TreeNode* A) { 11 | vector B; 12 | stack s; 13 | if (A == NULL) { 14 | return B; 15 | } 16 | s.push(A); 17 | while (!s.empty()) { 18 | TreeNode* node = s.top(); 19 | s.pop(); 20 | B.push_back(node -> val); 21 | if (node -> right) { 22 | s.push(node -> right); 23 | } 24 | if (node -> left) { 25 | s.push(node -> left); 26 | } 27 | } 28 | return B; 29 | } 30 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/recover-binary-search-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | void inOrder(TreeNode *A, vector &temp) { 11 | if (A == NULL) { 12 | return; 13 | } 14 | inOrder(A -> left, temp); 15 | temp.push_back(A -> val); 16 | inOrder(A -> right, temp); 17 | return; 18 | } 19 | vector Solution::recoverTree(TreeNode* A) { 20 | vector B; 21 | inOrder(A, B); 22 | int first = -1, second = -1; 23 | int i = 0; 24 | for (i = 0; i < B.size() - 1; i ++) { 25 | if (B[i + 1] < B[i]) { 26 | second = B[i]; 27 | break; 28 | } 29 | } 30 | for (i = B.size() - 1; i >= 1; i --) { 31 | if (B[i - 1] > B[i]) { 32 | first = B[i]; 33 | break; 34 | } 35 | } 36 | vector temp = {first, second}; 37 | return temp; 38 | } 39 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/root-to-leaf-paths-with-sum.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | void findSum(TreeNode* A, int B, vector temp, vector > &C, int sum) { 11 | if (A == NULL) { 12 | return; 13 | } 14 | sum += A -> val; 15 | temp.push_back(A -> val); 16 | if (A -> left == NULL && A -> right == NULL) { 17 | if (sum == B) { 18 | C.push_back(temp); 19 | } 20 | return; 21 | } 22 | findSum(A -> left, B, temp, C, sum); 23 | findSum(A -> right, B, temp, C, sum); 24 | return; 25 | } 26 | vector > Solution::pathSum(TreeNode* A, int B) { 27 | vector temp; 28 | vector > C; 29 | findSum(A, B, temp, C, 0); 30 | return C; 31 | } 32 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/shortest-unique-prefix.cpp: -------------------------------------------------------------------------------- 1 | struct Trie { 2 | bool exist; 3 | int count; 4 | Trie* next[26]; 5 | Trie(bool val = false) { 6 | exist = val; 7 | for (int i = 0; i < 26; i ++) { 8 | next[i] = NULL; 9 | } 10 | count = 0; 11 | } 12 | }; 13 | void add(Trie* A, string s) { 14 | if (s.size() == 0) { 15 | return; 16 | } 17 | for (int i = 0; i < s.size(); i ++) { 18 | if (!A -> next[s[i] - 'a']) { 19 | A -> next[s[i] - 'a'] = new Trie(); 20 | } 21 | A -> count ++; 22 | A = A -> next[s[i] - 'a']; 23 | } 24 | A -> exist = true; 25 | return; 26 | } 27 | bool search(Trie* A, string s) { 28 | if (A == NULL) { 29 | return 0; 30 | } 31 | for (int i = 0; i < s.size(); i ++) { 32 | if (!A -> next[s[i] - 'a']) { 33 | return 0; 34 | } else { 35 | A = A -> next[s[i] - 'a']; 36 | } 37 | } 38 | if (A -> exist) { 39 | return 1; 40 | } 41 | return 0; 42 | } 43 | int lup(Trie* A, string s) { 44 | if (s.size() == 0) { 45 | return 0; 46 | } 47 | if (A == NULL) { 48 | return s.size(); 49 | } 50 | int count = 1; 51 | for (int i = 0; i < s.size(); i ++) { 52 | if (A -> next[s[i] - 'a'] -> count == 1) { 53 | return count; 54 | } else { 55 | count ++; 56 | } 57 | A = A -> next[s[i] - 'a']; 58 | } 59 | return count; 60 | } 61 | vector Solution::prefix(vector &A) { 62 | vector B; 63 | if (A.size() <= 0) { 64 | return B; 65 | } 66 | Trie* trie = new Trie(); 67 | for (int i = 0; i < A.size(); i ++) { 68 | add(trie, A[i]); 69 | } 70 | for (int i = 0; i < A.size(); i ++) { 71 | if (lup(trie, A[i]) >= A[i].size()) { 72 | B.push_back(A[i]); 73 | } else { 74 | B.push_back(A[i].substr(0, lup(trie, A[i]))); 75 | } 76 | } 77 | B = B; 78 | return B; 79 | } 80 | 81 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/sorted-array-to-balanced-bst.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | void preOrder(TreeNode* A) { 11 | if (A == NULL) { 12 | return; 13 | } 14 | cout << A -> val << " "; 15 | preOrder(A -> left); 16 | preOrder(A -> right); 17 | } 18 | void inOrder(TreeNode* A) { 19 | if (A == NULL) { 20 | return; 21 | } 22 | inOrder(A -> left); 23 | cout << A -> val << " "; 24 | inOrder(A -> right); 25 | } 26 | TreeNode* buildTree(const vector &A, int start, int end) { 27 | TreeNode* root = NULL; 28 | if (start > end) { 29 | return NULL; 30 | } 31 | if (start <= end) { 32 | int mid = start + (end - start) / 2; 33 | root = new TreeNode(A[mid]); 34 | root -> left = buildTree(A, start, mid - 1); 35 | root -> right = buildTree(A, mid + 1, end); 36 | } 37 | return root; 38 | } 39 | TreeNode* Solution::sortedArrayToBST(const vector &A) { 40 | if (A.size() <= 0) { 41 | return NULL; 42 | } 43 | TreeNode* temp = buildTree(A, 0, A.size() - 1); 44 | return temp; 45 | } 46 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/sum-root-to-leaf-numbers.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | #define DIVI 1003 11 | int sumNum(TreeNode* A, int temp) { 12 | if (A == NULL) { 13 | return 0; 14 | } 15 | temp = (temp % DIVI) * 10; 16 | temp = ((temp % DIVI) + A -> val) % 1003; 17 | if (A -> left == NULL && A -> right == NULL) { 18 | int total = temp % DIVI; 19 | return total % DIVI; 20 | } 21 | int total = (sumNum(A -> left, temp)) % DIVI + (sumNum(A -> right, temp)) % DIVI; 22 | return total % DIVI; 23 | } 24 | int Solution::sumNumbers(TreeNode* A) { 25 | return sumNum(A, 0) % DIVI; 26 | } 27 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/symmetric-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | bool isIdentical(TreeNode* A, TreeNode* B) { 11 | if (A == NULL && B == NULL) { 12 | return 1; 13 | } else if (A == NULL || B == NULL) { 14 | return 0; 15 | } 16 | if (A -> val == B -> val && isIdentical(A -> left, B -> right) && isIdentical(A -> right, B -> left)) { 17 | return 1; 18 | } 19 | return 0; 20 | } 21 | int Solution::isSymmetric(TreeNode* A) { 22 | if (A == NULL) { 23 | return 1; 24 | } 25 | TreeNode* node = A; 26 | return isIdentical(A, A); 27 | } 28 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/vertical-order-traversal-of-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | vector > Solution::verticalOrderTraversal(TreeNode* A) { 11 | vector > B; 12 | if (A == NULL) { 13 | return B; 14 | } 15 | map> mapp; 16 | queue> queue; 17 | int level = 0; 18 | queue.push(make_pair(A, level)); 19 | while (!queue.empty()) { 20 | pair temp = queue.front(); 21 | queue.pop(); 22 | mapp[temp.second].push_back(temp.first -> val); 23 | if (temp.first -> left) { 24 | queue.push(make_pair(temp.first -> left, temp.second - 1)); 25 | } 26 | if (temp.first -> right) { 27 | queue.push(make_pair(temp.first -> right, temp.second + 1)); 28 | } 29 | } 30 | B.resize(mapp.size()); 31 | int i = 0; 32 | for (map>::iterator it = mapp.begin(); it != mapp.end(); it ++) { 33 | B[i] = it -> second; 34 | i ++; 35 | } 36 | return B; 37 | } 38 | -------------------------------------------------------------------------------- /Cpp/Trees/Problems/zigzag-level-order-traversal-bt.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | int height(TreeNode* A) { 11 | if (A == NULL) { 12 | return 0; 13 | } 14 | return 1 + max(height(A -> left), height(A -> right)); 15 | } 16 | void getLevelOrderTraversal(TreeNode* A, vector > &B, int index) { 17 | if (A == NULL) { 18 | return; 19 | } 20 | B[index].push_back(A -> val); 21 | getLevelOrderTraversal(A -> left, B, index + 1); 22 | getLevelOrderTraversal(A -> right, B, index + 1); 23 | return; 24 | } 25 | vector > Solution::zigzagLevelOrder(TreeNode* A) { 26 | vector > B(height(A)); 27 | getLevelOrderTraversal(A, B, 0); 28 | bool flag = false; 29 | for (int i = 0; i < B.size(); i ++) { 30 | if (flag) { 31 | reverse(B[i].begin(), B[i].end()); 32 | } 33 | flag = !flag; 34 | } 35 | return B; 36 | } 37 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/3-sum-zero.cpp: -------------------------------------------------------------------------------- 1 | vector > Solution::threeSum(vector &A) { 2 | 3 | // Sorting is necessary at the beginning 4 | 5 | sort(A.begin(), A.end()); 6 | vector> B; 7 | 8 | // Corner case 9 | 10 | if (A.size() <= 2) { 11 | return B; 12 | } 13 | 14 | // We use 3 pointers and proceed the sane way as 3-sum 15 | 16 | int i = 0, j = A.size() - 1, k = 1; 17 | for (i = 0; i < A.size() - 2; i ++) { 18 | k = i + 1; j = A.size() - 1; 19 | while (k < j) { 20 | if (A[i] + A[j] + A[k] == 0) { 21 | vector temp; 22 | temp.push_back(A[i]); 23 | temp.push_back(A[k]); 24 | temp.push_back(A[j]); 25 | B.push_back(temp); 26 | j --; 27 | k ++; 28 | } else if (A[i] + A[j] + A[k] > 0) { 29 | j --; 30 | } else if (A[i] + A[j] + A[k] < 0) { 31 | k ++; 32 | } 33 | } 34 | } 35 | sort(B.begin(), B.end()); 36 | B.erase(unique(B.begin(), B.end()), B.end()); 37 | return B; 38 | } 39 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/3-sum.cpp: -------------------------------------------------------------------------------- 1 | 2 | int Solution::threeSumClosest(vector &num, int target) { 3 | sort(num.begin(), num.end()); 4 | int bestSum = 1000000000, sum = 0; 5 | // Fix the smallest number in the three integers 6 | for (int i = 0; i < num.size() - 2; i++) { 7 | // Now num[i] is the smallest number in the three integers in the solution 8 | int ptr1 = i + 1, ptr2 = num.size() - 1; 9 | while (ptr1 < ptr2) { 10 | sum = num[i] + num[ptr1] + num[ptr2]; 11 | if (abs(target - sum) < abs(target - bestSum)) { 12 | bestSum = sum; 13 | } 14 | if (sum > target) { 15 | ptr2--; 16 | } else { 17 | ptr1++; 18 | } 19 | } 20 | } 21 | return bestSum; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/array-3-pointers.cpp: -------------------------------------------------------------------------------- 1 | int Solution::minimize(const vector &A, const vector &B, const vector &C) { 2 | int i = 0, j = 0, k = 0; 3 | int mini = INT_MAX; 4 | 5 | // Do exactly what is told and increment the pointer with minimum value 6 | 7 | while (i < A.size() && j < B.size() && k < C.size()) { 8 | if (max(max(abs(A[i] - B[j]), abs(B[j] - C[k])), abs(C[k] - A[i])) < mini) { 9 | mini = max(max(abs(A[i] - B[j]), abs(B[j] - C[k])), abs(C[k] - A[i])); 10 | } 11 | if (A[i] == min(min(A[i], B[j]), C[k])) { 12 | i ++; 13 | } else if (B[j] == min(min(A[i], B[j]), C[k])) { 14 | j ++; 15 | } else if (C[k] == min(min(A[i], B[j]), C[k])) { 16 | k ++; 17 | } 18 | } 19 | return mini; 20 | } 21 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/container-with-most-water.cpp: -------------------------------------------------------------------------------- 1 | int Solution::maxArea(vector &A) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 1) { 6 | return 0; 7 | } 8 | int i = 0; 9 | int j = A.size() - 1; 10 | int maxi = INT_MIN; 11 | 12 | // Keep one pointer at the start and one at the end 13 | // That will give the maximum width of the area 14 | // Keep changing the pointers until the values are the same 15 | 16 | for (int i = 0; i < A.size(); i ++) { 17 | for (j = A.size() - 1; j > i; j --) { 18 | if (A[i] <= A[j]) { 19 | int area = A[i] * (j - i); 20 | if (area > maxi) { 21 | maxi = area; 22 | } 23 | break; 24 | } else { 25 | int area = A[j] * (j - i); 26 | if (area > maxi) { 27 | maxi = area; 28 | } 29 | } 30 | } 31 | } 32 | return maxi; 33 | } 34 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/counting-triangles.cpp: -------------------------------------------------------------------------------- 1 | int Solution::nTriang(vector &A) { 2 | sort(A.begin(), A.end()); 3 | if (A.size() < 3) { 4 | return 0; 5 | } 6 | int i = 0, j; 7 | int k; 8 | int ans = 0; 9 | 10 | // A triangle is formed when the sum of 2 sides is greater than the 3rd side 11 | // It would not be wise choice to start one pointer at the end because the sum goes monotonically 12 | // So we start the pointers at the start 13 | 14 | for (i = 0; i < A.size() - 2; i ++) { 15 | k = i + 2; 16 | j = i + 1; 17 | for(int j = i + 1; j < A.size(); j++) { 18 | for(; (k < A.size()) && (A[i] + A[j] > A[k]); k++); 19 | ans = ans + (k - 1 - j); 20 | if(ans >= pow(10, 9) + 7) ans = ans % (int)(pow(10, 9) + 7); 21 | } 22 | } 23 | return ans; 24 | } 25 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/diffk.cpp: -------------------------------------------------------------------------------- 1 | int Solution::diffPossible(vector &A, int B) { 2 | 3 | // Corner case 4 | 5 | if (A.size() <= 1) { 6 | return 0; 7 | } 8 | int i = 0; 9 | int j = i + 1; 10 | 11 | // Check for the difference by keeping both pointers at the start 12 | 13 | while (j < A.size() && i < A.size() && j > i) { 14 | if (A[j] - A[i] == B) { 15 | return 1; 16 | } else if (A[j] - A[i] > B) { 17 | if (j - i == 1) { 18 | i ++; 19 | j ++; 20 | } else { 21 | i ++; 22 | } 23 | } else if (A[j] - A[i] < B) { 24 | j ++; 25 | } 26 | } 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/intersection-of-sorted-arrays.cpp: -------------------------------------------------------------------------------- 1 | vector Solution::intersect(const vector &A, const vector &B) { 2 | vector C; 3 | 4 | // We compare corresponding elements of the lists 5 | // and add them to the solution until they are not equal 6 | 7 | int size; 8 | if (A.size() >= B.size()) { 9 | size = A.size(); 10 | } else { 11 | size = B.size(); 12 | } 13 | int i = 0, j = 0; 14 | while (i < A.size() && j < B.size()) { 15 | if (A[i] == B[j]) { 16 | C.push_back(A[i]); 17 | i ++; 18 | j ++; 19 | } else if (A[i] < B[j]) { 20 | i ++; 21 | } else { 22 | j ++; 23 | } 24 | } 25 | return C; 26 | } 27 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/merge-two-sorted-lists-ii.cpp: -------------------------------------------------------------------------------- 1 | void Solution::merge(vector &A, vector &B) { 2 | vector C; 3 | 4 | // Since the lists are already sorted, we compare the corresponding elements 5 | // After reaching the end, we append the other list to the solution 6 | 7 | int i = 0, j = 0; 8 | while (i < A.size() && j < B.size()) { 9 | if (A[i] > B[j]) { 10 | C.push_back(B[j]); 11 | j ++; 12 | } else if (B[j] > A[i]) { 13 | C.push_back(A[i]); 14 | i ++; 15 | } else { 16 | C.push_back(A[i]); 17 | C.push_back(B[j]); 18 | i ++; 19 | j ++; 20 | } 21 | } 22 | if (i == A.size() && j == B.size()) { 23 | 24 | } else if (i == A.size()) { 25 | for (; j < B.size(); j ++) { 26 | C.push_back(B[j]); 27 | } 28 | } else if (j == B.size()) { 29 | for (; i < A.size(); i ++) { 30 | C.push_back(A[i]); 31 | } 32 | } 33 | A = C; 34 | } 35 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/minimize-the-absolute-difference.cpp: -------------------------------------------------------------------------------- 1 | int Solution::solve(vector &A, vector &B, vector &C) { 2 | int i = 0, j = 0, k = 0; 3 | int mini = INT_MAX; 4 | 5 | // We use 3 pointers to keep track of the pointers 6 | // We match the corresponding elements on the lists 7 | // and increment the smallest one 8 | 9 | while (i < A.size() && j < B.size() && k < C.size()) { 10 | int diff = abs(max(max(A[i], B[j]), C[k]) - min(min(A[i], B[j]), C[k])); 11 | if (diff < mini) { 12 | mini = diff; 13 | } 14 | if (A[i] == min(min(A[i], B[j]), C[k])) { 15 | i ++; 16 | } else if (B[j] == min(min(A[i], B[j]), C[k])) { 17 | j ++; 18 | } else if (C[k] == min(min(A[i], B[j]), C[k])) { 19 | k ++; 20 | } 21 | } 22 | return mini; 23 | } 24 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/remove-duplicates-from-sorted-array-ii.cpp: -------------------------------------------------------------------------------- 1 | int Solution::removeDuplicates(vector &A) { 2 | bool check = false; 3 | int start = 0; 4 | int count = 0; 5 | 6 | // Loop through the array and check adjacent elements 7 | // This time keep the pointer one step ahead the duplicate element 8 | 9 | for (int i = 0; i < A.size() - 1; i ++) { 10 | if (check) { 11 | if (A[i + 1] != A[i]) { 12 | if (count >= 2) { 13 | A.erase(A.begin() + start + 1, A.begin() + i); 14 | check = false; 15 | i = start + 1; 16 | i --; 17 | count = 0; 18 | } else { 19 | check = false; 20 | count = 0; 21 | } 22 | } else { 23 | count ++; 24 | } 25 | } else { 26 | if (A[i] == A[i + 1]) { 27 | count = 2; 28 | check = true; 29 | start = i; 30 | } 31 | } 32 | } 33 | if (check) { 34 | if (count >= 2) { 35 | A.erase(A.begin() + start + 1, A.end() - 1); 36 | } 37 | } 38 | return A.size(); 39 | } 40 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/remove-duplicates-from-sorted-array.cpp: -------------------------------------------------------------------------------- 1 | int Solution::removeDuplicates(vector &A) { 2 | bool check = false; 3 | int start = 0; 4 | 5 | // Loop through the array and check adjacent elements 6 | 7 | for (int i = 0; i < A.size() - 1; i ++) { 8 | if (check) { 9 | if (A[i + 1] != A[i]) { 10 | A.erase(A.begin() + start, A.begin() + i); 11 | i = start; 12 | i --; 13 | check = false; 14 | } 15 | } else { 16 | if (A[i + 1] == A[i]) { 17 | //A.erase(A.begin() + i, A.begin() + i + 1); 18 | //i --; 19 | //cout << i; 20 | start = i; 21 | check = true; 22 | } 23 | } 24 | } 25 | if (check) { 26 | A.erase(A.begin() + start, A.end() - 1); 27 | } 28 | return A.size(); 29 | } 30 | 31 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/remove-element-from-array.cpp: -------------------------------------------------------------------------------- 1 | int Solution::removeElement(vector &A, int B) { 2 | 3 | // count the number of elements in the array other than the given element 4 | 5 | int count = 0; 6 | for (int i = 0; i < A.size(); i++) { 7 | if (A[i] == B) continue; 8 | else { 9 | A[count] = A[i]; 10 | count++; 11 | } 12 | } 13 | return count; 14 | } 15 | -------------------------------------------------------------------------------- /Cpp/Two-Pointers/sort-by-color.cpp: -------------------------------------------------------------------------------- 1 | void Solution::sortColors(vector &A) { 2 | int countA = 0, countB = 0, countC = 0; 3 | 4 | // Keep 3 count variables and push them one by one after clearing the array 5 | 6 | for (int i = 0; i < A.size(); i ++) { 7 | if (A[i] == 0) { 8 | countA ++; 9 | } else if (A[i] == 1) { 10 | countB ++; 11 | } else if (A[i] == 2) { 12 | countC ++; 13 | } 14 | } 15 | A.clear(); 16 | for (int i = 0; i < countA; i ++) { 17 | A.push_back(0); 18 | } 19 | for (int i = 0; i < countB; i ++) { 20 | A.push_back(1); 21 | } 22 | for (int i = 0; i < countC; i ++) { 23 | A.push_back(2); 24 | }] 25 | } 26 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Kartik 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Python/Arrays/Examples/max-non-negative-subarray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of integers 4 | def maxset(self, A): 5 | maxlen, maxsum, maxstart = -1, -1, -1 6 | curlen, cursum, curstart = 0, 0, 0 7 | for i in range(len(A)): 8 | if A[i] >= 0: 9 | cursum += A[i] 10 | curlen += 1 11 | if cursum > maxsum: 12 | maxsum = cursum 13 | maxstart = curstart 14 | maxlen = curlen 15 | elif cursum == maxsum: 16 | if curlen > maxlen: 17 | maxlen = curlen 18 | maxstart = curstart 19 | else: 20 | cursum = 0 21 | curstart = i + 1 22 | curlen = 0 23 | return A[maxstart:maxstart + maxlen] -------------------------------------------------------------------------------- /Python/Arrays/Examples/spiral-order-matrix-i.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of list of integers 3 | # @return a list of integers 4 | def spiralOrder(self, A): 5 | left = top = 0 6 | right = len(A[0]) - 1 7 | bottom = len(A) - 1 8 | B = [] 9 | while top <= bottom and left <= right: 10 | for i in range(left, right + 1): 11 | B.append(A[top][i]) 12 | 13 | top += 1 14 | if top <= bottom: 15 | for i in range(top, bottom + 1): 16 | B.append(A[i][right]) 17 | else: 18 | break 19 | 20 | right -= 1 21 | if left <= right: 22 | for i in range(right, left - 1, -1): 23 | B.append(A[bottom][i]) 24 | else: 25 | break 26 | 27 | bottom -= 1 28 | if top <= bottom: 29 | for i in range(bottom, top - 1, -1): 30 | B.append(A[i][left]) 31 | else: 32 | break 33 | 34 | left += 1 35 | return B -------------------------------------------------------------------------------- /Python/Arrays/Problems/max-min.py: -------------------------------------------------------------------------------- 1 | def maxmin(A): 2 | if len(A) == 1: 3 | return A[0], A[0] 4 | elif len(A) == 2: 5 | return max(A[0], A[1]), min(A[0], A[1]) 6 | 7 | maxl, minl = maxmin(A[:int(len(A) / 2)]) 8 | maxr, minr = maxmin(A[int(len(A) / 2):]) 9 | return max(maxl, maxr), min(minl, minr) 10 | class Solution: 11 | # @param A : list of integers 12 | # @return an integer 13 | def solve(self, A): 14 | return sum(maxmin(A)) 15 | 16 | # Explanation of complexity: 17 | 18 | # T(n) denotes the number of comparisons for input of size number 19 | # T(0) = 0, T(1) = 0, T(2) = 1 20 | 21 | # Base equation 22 | # T(n) = 2T(n / 2) + 2 23 | 24 | # Derived equation 25 | # T(n) = 2^kT(n / 2^k) + 2^k+1 - 2 26 | 27 | # Since T(2) = 1, 28 | # n / 2^k = 2 => k = log(n) - 1 where base(log) = 2 29 | 30 | # Replacing the value of k in the derived equation above: 31 | # T(n) = 3n / 2 - 2 -------------------------------------------------------------------------------- /Python/Arrays/Problems/pick-from-both-sides.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return an integer 5 | def solve(self, A, B): 6 | cursum = sum(A[:B]) 7 | j = len(A) - 1 8 | maxsum = cursum 9 | for i in range(B - 1, -1, -1): 10 | cursum += A[j] - A[i] 11 | maxsum = max(maxsum, cursum) 12 | j -= 1 13 | return maxsum -------------------------------------------------------------------------------- /Python/Arrays/Problems/wave-array.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of integers 4 | def wave(self, A): 5 | A.sort() 6 | for i in range(0, len(A), 2): 7 | if i + 1 < len(A): 8 | A[i + 1], A[i] = A[i], A[i + 1] 9 | return A -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # InterviewBit Solutions 2 | 3 | ![](assets/images/ib.png?raw=true) 4 | 5 | These are my solutions for InterviewBit solutions in C++ and Python. 6 | New solutions are still a work in progress. 7 | 8 | - Conceptual 9 | - Comments enabled 10 | - Topic-wise distribution 11 | 12 | # Topics covered 💻 13 | 14 | - Arrays 15 | - Math 16 | - Binary Search 17 | - Strings 18 | - Bit Manipulation 19 | - 2 Pointers 20 | - Linked Lists 21 | - Stacks and Queues 22 | - Hashing 23 | - Backtracking 24 | - Trees 25 | - *MORE COMING SOON* 26 | 27 | # Things to do 📝 28 | 29 | - Take help from the repository. 30 | - Provide your support to the repository by *starring*🌟 the repository. 31 | - Fork this repository and add your own solutions in different languages. 32 | - Buy me a coffee ☕️ 33 | 34 | If you want to collaborate as well, feel free to send me a request and we shall do this together 😊 35 | 36 | > Don't ever, for any reason, do anything for anyone, for any reason, ever, no matter what. No matter where. Or who, or who you are with, or where you are going or... or where you've been... ever. For any reason, whatsoever. 37 | 38 | #### InterviewBit 39 | 40 | See https://www.interviewbit.com 41 | 42 | ### Todos 43 | 44 | - Add missing chapters 45 | - Add Javascript Solutions 46 | - Add JAVA solutions 47 | 48 | License 49 | ---- 50 | MIT 51 | 52 | Copyright 53 | ---- 54 | All questions used here are property of Interviewbit 55 | 56 | 57 | Peace✌️ -------------------------------------------------------------------------------- /assets/images/ib.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mailtokartik1/InterviewBit-Solutions/8a9be25cf55947aff456c7c138e2ee6f518aa6a5/assets/images/ib.png --------------------------------------------------------------------------------