├── Binary_Tree ├── bst_height.cpp ├── bst_insert.cpp ├── iterative_inorder_traversal.cpp ├── check_binary_search_tree.cpp ├── delete_range.cpp ├── fix_bst.cpp ├── path_node_to_root.cpp ├── level_order_traversal.cpp ├── morris_inorder_traversal.cpp ├── left_view.cpp ├── check_height_balanced_tree.cpp ├── bst_delete.cpp ├── right_view.cpp ├── tree_diameter.cpp ├── construct_tree.cpp ├── num_node_at_k.cpp ├── next_pointer_binary_tree.cpp └── vertical_order_traversal.cpp ├── Binary_Search_Tree ├── lca.cpp └── max_sized_bst.cpp ├── Maths ├── gcd.cpp ├── check_prime.cpp ├── find_sq_root.cpp ├── gcd_seq.cpp ├── smallest_prime_factors.cpp ├── rearrange.cpp ├── count_divisors.cpp ├── count_pairs.cpp └── sieve_of_eratosthenes.cpp ├── String ├── Toggle_case.cpp └── longest_substring_palindrome.cpp ├── Combinatorics ├── nCr_mod_m.cpp └── nCr_mod_p.cpp ├── Recusion ├── check_palin_recusion.cpp ├── tower_of_hanoi.cpp └── Power_function.cpp ├── Dynamic_Programming ├── num_paths.cpp ├── count_ways.cpp ├── lis.cpp ├── num_ways_dice.cpp ├── house_robbers.cpp ├── lcs.cpp ├── min_num_perfect_sq.cpp ├── knapsack_01.cpp ├── longest_palindromic_subseq.cpp ├── num_str.cpp ├── knapsack_0_infi.cpp ├── coin_change_problem.cpp ├── wildcard_match.cpp ├── decode_ways.cpp ├── eq_array_parti.cpp ├── convert_str.cpp ├── min_abs_diff.cpp └── dungeon_princess.cpp ├── Stack ├── delete_adj_dup.cpp ├── double_char_trouble.cpp ├── nearest_smallest_element.cpp ├── stack_using_array.cpp ├── postfix_notation.cpp ├── largest_rectangle_area_histogram.cpp ├── stack_using_ll.cpp ├── get_minimum.cpp ├── sort_array_using_stack.cpp └── max_min_sum.cpp ├── Bit_Manipulation ├── Decimal_to_binary.cpp ├── single_number.cpp ├── Add_binary_strings.cpp ├── Sum_xor_pairs.cpp └── max_and_val.cpp ├── Array_and_Subarray ├── Sum_of_all_subarrays.cpp ├── Max_contagious_sum.cpp ├── Max_sum_of_subarray_len_K.cpp ├── Subarray_sum_for_queries.cpp ├── Majority_element.cpp └── Increasing_subarray.cpp ├── 2D_Matrix ├── All_submatrices_sum.cpp ├── Print_upper_triangle.cpp ├── transpose.cpp ├── Max_sum_submatrix.cpp ├── Print_RtoL_diagonals.cpp ├── Rotate_by_90.cpp └── Submatrix_sum.cpp ├── Tries └── tries.cpp ├── Linked_List ├── find_intersection.cpp ├── deep_copy.cpp ├── stack_using_ll.cpp ├── reverse_first_k.cpp ├── insert_in_sorted_ll.cpp ├── reverse_ll.cpp ├── count_node_pairs.cpp ├── singly_ll.cpp ├── find_middle_node.cpp ├── doublylinkedlist.cpp ├── moveevenbeforodd.cpp └── linkedlistwithloop.cpp ├── Sorting ├── Count_sort.cpp ├── Insertion Sort │ ├── C++ │ │ └── insertionsort.cpp │ └── insertionSort.py ├── Selection Sort │ ├── selectionSort.py │ └── C++ │ │ └── selectionsort.cpp ├── Heapsort │ ├── C++ │ │ └── heapsort.cpp │ └── heapSort.py ├── Quick Sort │ ├── C++ │ │ └── quicksort.cpp │ └── quickSort.py ├── inversion_count.cpp └── Merge Sort │ ├── mergeSort.py │ └── C++ │ └── mergesort.cpp ├── Subset_&_Subsequence ├── subsets_sum.cpp └── subsets_using_bit.cpp ├── Queue ├── Queue_using_stack.cpp ├── Queue_using_array.cpp └── max_val_windows.cpp ├── Hashing ├── min_dist_dup_pairs.cpp ├── longest_consecutive_seq.cpp ├── subarray_sum_0.cpp └── dup_pairs.cpp ├── Bubble Sort └── bubbleSort.py ├── Binary_Search ├── find_floor_element.cpp ├── local_minima.cpp ├── find_freq.cpp ├── max_len_k.cpp ├── kth_pos_element.cpp ├── index_sorted_rotated_arr.cpp ├── maximize_min_dist.cpp └── kth_pos_element_in_two_arrays.cpp ├── Two_Pointers └── most_water.cpp ├── Pattern_Matching ├── lps_array.cpp ├── same_rotation_string.cpp ├── check_pattern_in_text.cpp └── count_permutations.cpp ├── Heaps ├── k_smaller_elements.cpp ├── nearly_sorted_array.cpp └── min_heap.cpp ├── Sorting according to Frequency of Elements └── C++ │ └── sortacctofreq.cpp ├── Graph_Algorithms ├── Depth First Seacrh │ ├── num_connected_components.cpp │ ├── dfs.cpp │ ├── conflicted_area.cpp │ └── Using Adjacency List │ │ └── dfswithlist.cpp ├── topological_sort.cpp └── Breadth First Search │ ├── Using Adjacency List │ └── bfswithlist.cpp │ ├── bfs_shortest_path.cpp │ ├── bfs_min_dist_hospital.cpp │ └── bfs.cpp ├── Huffman Coding └── C++ │ └── Huffman.cpp ├── Maximum Priority Queue └── C++ │ └── maxpriorityqueue.cpp └── Bellman Ford └── C++ └── bellmanford.cpp /Binary_Tree/bst_height.cpp: -------------------------------------------------------------------------------- 1 | int bst_height(BST* root) 2 | { 3 | if (root == NULL) 4 | return -1; 5 | 6 | int left_height = bst_height(root->left); 7 | int right_height = bst_height(root->right); 8 | 9 | return 1+max(left_height, right_height); 10 | } 11 | -------------------------------------------------------------------------------- /Binary_Tree/bst_insert.cpp: -------------------------------------------------------------------------------- 1 | TreeNode* insert(TreeNode* root, int value) 2 | { 3 | if (root == NULL) 4 | { 5 | return new TreeNode(value); 6 | } 7 | 8 | if (root->val > value) 9 | { 10 | root->left = insert(root->left, value); 11 | } 12 | else if (root->val < value) 13 | { 14 | root->right = insert(root->right, value); 15 | } 16 | return root; 17 | } 18 | -------------------------------------------------------------------------------- /Binary_Search_Tree/lca.cpp: -------------------------------------------------------------------------------- 1 | int lca_bst(TreeNode* root, int n1, int n2) 2 | { 3 | if (root == NULL) 4 | { 5 | return -1; 6 | } 7 | 8 | if (root->val >= n1 && root->val <= n2) 9 | { 10 | return root->val; 11 | } 12 | 13 | if (root->val > n1 && root->val > n2) 14 | { 15 | return lca_bst(root->left, int n1, int n2); 16 | } 17 | 18 | if (root->val < n1 && root->val < n2) 19 | { 20 | return lca_bst(root->right, int n1, int n2); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Binary_Tree/iterative_inorder_traversal.cpp: -------------------------------------------------------------------------------- 1 | void iterative_inorder_traversal(TreeNode* root) 2 | { 3 | stack st; 4 | 5 | TreeNode* curr = root; 6 | 7 | while (curr != NULL || (!st.empty())) 8 | { 9 | if (curr != NULL) 10 | { 11 | st.push(curr); 12 | curr = curr->left; 13 | } 14 | else 15 | { 16 | TreeNode* tmp = st.pop(); 17 | cout << tmp->val << "\n"; 18 | curr = tmp->right(); 19 | } 20 | } 21 | } 22 | 23 | //TC O(N) 24 | //SC O(N) 25 | -------------------------------------------------------------------------------- /Maths/gcd.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int gcd(int a, int b) 7 | { 8 | if (a == 0) return b; 9 | 10 | return gcd(b, a % b); 11 | } 12 | 13 | int main() 14 | { 15 | #ifndef FILE_INOUT 16 | 17 | freopen("in.txt", "r", stdin); 18 | 19 | freopen("out.txt", "w", stdout); 20 | 21 | #endif 22 | 23 | int a, b; 24 | std::cin >> a >> b; 25 | 26 | std::cout << gcd(a, b) << "\n"; 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /Binary_Tree/check_binary_search_tree.cpp: -------------------------------------------------------------------------------- 1 | int isValidBST(TreeNode* A) { 2 | if (A == NULL) 3 | { 4 | return 1; 5 | } 6 | bool l = true, r = true; 7 | 8 | if (A->left != NULL && A->val > A->left->val) 9 | { 10 | l = isValidBST(A->left); 11 | } 12 | else 13 | { 14 | l = false; 15 | } 16 | 17 | if (A->right != NULL && A->val < A->right->val) 18 | { 19 | r = isValidBST(A->right); 20 | } 21 | else 22 | { 23 | r = false; 24 | } 25 | 26 | return l && r; 27 | } 28 | -------------------------------------------------------------------------------- /Binary_Tree/delete_range.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given a BST. Given a range l to h. Delete every node which has a 3 | * value outside the range [l, h] 4 | **/ 5 | 6 | TreeNode* trim_bst(TreeNode* root, int l, int h) 7 | { 8 | if (root == NULL) 9 | { 10 | return NULL; 11 | } 12 | 13 | if (root->val < l) 14 | { 15 | return trim_bst(root->right, l, h); 16 | } 17 | 18 | if (root->val > h) 19 | { 20 | return trim_bst(root->left, l, h); 21 | } 22 | 23 | root->left = trim_bst(root->left, l, h); 24 | root->right = trim_bst(root->right, l, h); 25 | return root; 26 | } 27 | -------------------------------------------------------------------------------- /String/Toggle_case.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void toggle_case(std::string& s) 7 | { 8 | for (int i = 0; i < s.size(); ++i) 9 | { 10 | s[i] = (s[i] ^ 32); 11 | } 12 | } 13 | 14 | int main() 15 | { 16 | #ifndef FILE_INOUT 17 | 18 | freopen("in.txt", "r", stdin); 19 | 20 | freopen("out.txt", "w", stdout); 21 | 22 | #endif 23 | 24 | std::string s; 25 | std::cin >> s; 26 | 27 | toggle_case(s); 28 | 29 | std::cout << s << "\n"; 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /Binary_Tree/fix_bst.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given a BST where two nodes have been swapped. Fix the BST 3 | **/ 4 | 5 | void fix_bst(TreeNode* root) 6 | { 7 | TreeNode* prev = NULL; 8 | TreeNode* n1 = NULL; 9 | TreeNode* n2 = NULL; 10 | 11 | if (root == NULL) 12 | { 13 | return; 14 | } 15 | 16 | fix_bst(root->left); 17 | if (prev != NULL) 18 | { 19 | if (prev->val > root->val) 20 | { 21 | if (n1 == NULL) 22 | { 23 | n1 = prev; 24 | n2 = root; 25 | } 26 | else 27 | { 28 | n2 = root; 29 | } 30 | } 31 | } 32 | prev = root; 33 | fix_bst(root->right); 34 | } 35 | -------------------------------------------------------------------------------- /Maths/check_prime.cpp: -------------------------------------------------------------------------------- 1 | //Check if a number is a prime number 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | bool is_prime(int n) 8 | { 9 | for (int i = 2; i*i <= n; ++i) 10 | { 11 | if (n % i == 0) 12 | return false; 13 | } 14 | return true; 15 | } 16 | 17 | int main() 18 | { 19 | #ifndef FILE_INOUT 20 | 21 | freopen("in.txt", "r", stdin); 22 | 23 | freopen("out.txt", "w", stdout); 24 | 25 | #endif 26 | 27 | int n; 28 | std::cin >> n; 29 | 30 | bool res = is_prime(n); 31 | 32 | std::cout << res << "\n"; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /Combinatorics/nCr_mod_m.cpp: -------------------------------------------------------------------------------- 1 | //using Dynamic Programming 2 | //A = n, B = r and C = m (mod) where C is not prime 3 | int nCr_mod_m_DP(int A, int B, int C) { 4 | if (B == 1) return A % C; 5 | 6 | if (B == A || B == 0) return 1; 7 | 8 | vector< vector > mat(A+1, vector(B+1, 0)); 9 | 10 | for (int i = 0; i <= A; ++i) 11 | { 12 | mat[i][0] = 1; 13 | } 14 | 15 | for (int i = 1; i <= A; ++i) 16 | { 17 | for (int j = 1; j <= B; ++j) 18 | { 19 | mat[i][j] = (mat[i-1][j] + mat[i-1][j-1]) % C; 20 | } 21 | } 22 | 23 | return mat[A][B] % C; 24 | } 25 | -------------------------------------------------------------------------------- /Binary_Tree/path_node_to_root.cpp: -------------------------------------------------------------------------------- 1 | //Find path from givrn node to root node in BT 2 | 3 | bool add_path(vector& path, TreeNode* root, int k) 4 | { 5 | if (root == NULL) 6 | { 7 | return false; 8 | } 9 | 10 | if (root->val == k) 11 | { 12 | path.push_back(root); 13 | return true; 14 | } 15 | 16 | if (add_path(path, root->left, k) || add_path(path, root->right, k)) 17 | { 18 | path.push_back(root); 19 | return true; 20 | } 21 | return false; 22 | } 23 | 24 | vector find_path(TreeNode* root, int k) 25 | { 26 | vector path; 27 | bool val = add_path(path, root, k); 28 | return path; 29 | } 30 | -------------------------------------------------------------------------------- /Recusion/check_palin_recusion.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | bool palindrome(std::string& str, int s, int e) 7 | { 8 | if (s >= e) return true; 9 | 10 | if (str[s] == str[e]) 11 | return palindrome(str, s+1, e-1); 12 | 13 | return false; 14 | } 15 | 16 | int main() 17 | { 18 | #ifndef FILE_INOUT 19 | 20 | freopen("in.txt", "r", stdin); 21 | 22 | freopen("out.txt", "w", stdout); 23 | 24 | #endif 25 | 26 | std::string s; 27 | std::cin >> s; 28 | 29 | std::cout << palindrome(s, 0, s.size()-1) << "\n"; 30 | 31 | return 0; 32 | 33 | } 34 | -------------------------------------------------------------------------------- /Dynamic_Programming/num_paths.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int num_paths(int N, int M) 7 | { 8 | std::vector> dp(N, std::vector(M, 1)); 9 | 10 | dp[0][0] = 0; 11 | 12 | for (int i = 1; i < N; ++i) 13 | { 14 | for (int j = 1; j < M; ++j) 15 | { 16 | dp[i][j] = dp[i-1][j] + dp[i][j-1]; 17 | } 18 | } 19 | 20 | return dp[N-1][M-1]; 21 | } 22 | 23 | int main() 24 | { 25 | #ifndef FILE_INOUT 26 | 27 | freopen("in.txt", "r", stdin); 28 | 29 | freopen("out.txt", "w", stdout); 30 | 31 | #endif 32 | 33 | std::cout << num_paths(6, 4) << "\n"; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /Binary_Tree/level_order_traversal.cpp: -------------------------------------------------------------------------------- 1 | std::vector> level_order_traversal(TreeNode* root) 2 | { 3 | if (root == NULL) 4 | return NULL; 5 | 6 | std::vector> res; 7 | 8 | std::queue q; 9 | q.push(root); 10 | 11 | while (!q.empty()) 12 | { 13 | std::vector level; 14 | int q_sz = q.size(); 15 | 16 | for (int i = 0; i < q_sz; ++i) 17 | { 18 | TreeNode* tmp = q.front(); 19 | q.pop(); 20 | 21 | level.push(tmp->val); 22 | 23 | if (tmp->left != NULL) 24 | { 25 | q.push(tmp->left); 26 | } 27 | 28 | if (tmp->right != NULL) 29 | { 30 | q.push(tmp->right); 31 | } 32 | } 33 | res.push_back(level); 34 | } 35 | return res; 36 | } 37 | -------------------------------------------------------------------------------- /Stack/delete_adj_dup.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | std::string & removeDuplicate(std::string& str) 6 | { 7 | int length = str.length(); 8 | for(unsigned int i = 0; i < length; i++) 9 | { 10 | char currChar = str[i]; //holds current character 11 | for(unsigned int j = i+1; j < length; j++) 12 | { 13 | if(currChar == str[j]) 14 | str.erase (std::remove(str.begin()+j, str.end(), str[j]), str.end()); 15 | } 16 | } 17 | return str; 18 | } 19 | 20 | int main() 21 | { 22 | std::string str; 23 | std::cout << "Enter string \n"; 24 | std::getline(std::cin, str); 25 | str = removeDuplicate(str); 26 | std::cout <<"New String is " << str << "\n"; 27 | } 28 | -------------------------------------------------------------------------------- /Binary_Tree/morris_inorder_traversal.cpp: -------------------------------------------------------------------------------- 1 | void morris_inorder_traversal(TreeNode* root) 2 | { 3 | TreeNode* curr = root; 4 | 5 | while (curr != NULL) 6 | { 7 | if (curr->left == NULL) 8 | { 9 | cout << curr->val << "\n"; 10 | curr = curr->right; 11 | } 12 | else 13 | { 14 | TreeNode* tmp = curr->left; 15 | 16 | while (tmp->right != NULL && tmp->right != curr) 17 | { 18 | tmp = tmp->right; 19 | } 20 | 21 | if (tmp->right == NULL) 22 | { 23 | tmp->right = curr; 24 | curr = curr->left; 25 | } 26 | else 27 | { 28 | tmp->right = NULL; 29 | cout << curr->val << "\n"; 30 | curr = curr->right; 31 | } 32 | } 33 | } 34 | } 35 | 36 | //TC = O(3N) = O(N) 37 | //Sc = O(1) 38 | -------------------------------------------------------------------------------- /Recusion/tower_of_hanoi.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void tower_of_hanoi(int n, std::string& src, std::string& dest, std::string& temp) 7 | { 8 | if (n == 0) 9 | {return;} 10 | 11 | tower_of_hanoi(n-1, src, temp, dest); 12 | std::cout << "from " << src << " to " << dest << "\n"; 13 | tower_of_hanoi(n-1, temp, dest, src); 14 | } 15 | 16 | int main() 17 | { 18 | #ifndef FILE_INOUT 19 | 20 | freopen("in.txt", "r", stdin); 21 | 22 | freopen("out.txt", "w", stdout); 23 | 24 | #endif 25 | 26 | int n; 27 | std::cin >> n; 28 | 29 | std::string src, temp, dest; 30 | std::cin >> src >> temp >> dest; 31 | 32 | tower_of_hanoi(n, src, dest, temp); 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /Bit_Manipulation/Decimal_to_binary.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | std::vector decimal_to_binary(int n) 6 | { 7 | std::vector binary; 8 | 9 | while (n) 10 | { 11 | if (n % 2 == 1) 12 | binary.push_back(1); 13 | else 14 | binary.push_back(0); 15 | 16 | n = (n >> 1); 17 | } 18 | std::reverse(binary.begin(), binary.end()); 19 | 20 | return binary; 21 | } 22 | 23 | int main() 24 | { 25 | #ifndef FILE_INOUT 26 | 27 | freopen("in.txt", "r", stdin); 28 | 29 | freopen("out.txt", "w", stdout); 30 | 31 | #endif 32 | 33 | int n; 34 | std::cin >> n; 35 | 36 | std::vector r = decimal_to_binary(n); 37 | 38 | for (int x : r) 39 | std::cout << x; 40 | 41 | return 0; 42 | 43 | } 44 | -------------------------------------------------------------------------------- /Recusion/Power_function.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int pow_fun(int b, int p, int m) 7 | { 8 | if (b == 1 || p == 0) return 1; 9 | 10 | int half_pow = pow_fun(b, p/2, m); 11 | int half_ans = ((half_pow % m) * (half_pow % m)) % m; 12 | 13 | if (p % 2 == 0) 14 | return (half_ans % m); 15 | else 16 | return ((half_ans % m) * (b % m)) % m; 17 | } 18 | 19 | int main() 20 | { 21 | #ifndef FILE_INOUT 22 | 23 | freopen("in.txt", "r", stdin); 24 | 25 | freopen("out.txt", "w", stdout); 26 | 27 | #endif 28 | 29 | int base, pow, mod; 30 | std::cin >> base >> pow >> mod; 31 | 32 | std::cout << pow_fun(base, pow, mod) << "\n"; 33 | 34 | return 0; 35 | 36 | } 37 | -------------------------------------------------------------------------------- /Dynamic_Programming/count_ways.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given N stairs. Count the number of ways of going 3 | * from 0th to nth step. 4 | * Given that from ith step you can go to (i+1) or (i+2)th step 5 | **/ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int num_ways(int n) 13 | { 14 | std::vector dp(n+1); 15 | dp[0] = 1; 16 | dp[1] = 1; 17 | 18 | for (int i = 2; i <= n; ++i) 19 | { 20 | dp[i] = dp[i-1] + dp[i-2]; 21 | } 22 | 23 | return dp[n]; 24 | } 25 | 26 | int main() 27 | { 28 | #ifndef FILE_INOUT 29 | 30 | freopen("in.txt", "r", stdin); 31 | 32 | freopen("out.txt", "w", stdout); 33 | 34 | #endif 35 | 36 | int n; 37 | std::cin >> n; 38 | 39 | std::cout << num_ways(n) << "\n"; 40 | 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /Array_and_Subarray/Sum_of_all_subarrays.cpp: -------------------------------------------------------------------------------- 1 | //Given an array. Return the sum of all possible subarrays. 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | int subarray_sum(std::vector& vec, int n) 8 | { 9 | int sum = 0; 10 | 11 | for (int i = 0; i < n; ++i) 12 | { 13 | sum += (vec[i] * (i+1) * (n-i)); 14 | } 15 | 16 | return sum; 17 | } 18 | 19 | int main() 20 | { 21 | #ifndef FILE_INOUT 22 | 23 | freopen("in.txt", "r", stdin); 24 | 25 | freopen("out.txt", "w", stdout); 26 | 27 | #endif 28 | 29 | int n; 30 | std::cin >> n; 31 | 32 | std::vector vec(n); 33 | 34 | for (int i = 0; i < n; ++i) 35 | { 36 | std::cin >> vec[i]; 37 | } 38 | 39 | std::cout << subarray_sum(vec, n) << "\n"; 40 | 41 | return 0; 42 | 43 | } 44 | -------------------------------------------------------------------------------- /2D_Matrix/All_submatrices_sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int sum_submatrices(std::vector< std::vector >& mat) 7 | { 8 | int sum = 0; 9 | int r = mat.size(), c = mat[0].size(); 10 | 11 | for (int i = 0; i < r; ++i) 12 | { 13 | for (int j = 0; j < c; ++j) 14 | { 15 | int top_l = (i+1) * (j+1); 16 | int bottom_r = (r-i) * (c-j); 17 | 18 | sum += (top_l * bottom_r) * mat[i][j]; 19 | } 20 | } 21 | return sum; 22 | } 23 | 24 | int main() 25 | { 26 | #ifndef FILE_INOUT 27 | 28 | freopen("in.txt", "r", stdin); 29 | 30 | freopen("out.txt", "w", stdout); 31 | 32 | #endif 33 | 34 | std::vector> mat = {{1, 1}, 35 | {1, 1}}; 36 | 37 | std::cout << sum_submatrices(mat) << "\n"; 38 | 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /Dynamic_Programming/lis.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int lis(std::vector& vec) 7 | { 8 | int n = vec.size(); 9 | std::vector dp(n); 10 | dp[0] = 1; 11 | 12 | for (int i = 1; i < n; ++i) 13 | { 14 | int curr = 0; 15 | for (int j = 0; j < i; ++j) 16 | { 17 | if (vec[j] < vec[i]) 18 | { 19 | curr = std::max(curr, dp[j]); 20 | } 21 | } 22 | dp[i] = curr + 1; 23 | } 24 | return *max_element(dp.begin(), dp.end()); 25 | } 26 | 27 | int main() 28 | { 29 | #ifndef FILE_INOUT 30 | 31 | freopen("in.txt", "r", stdin); 32 | 33 | freopen("out.txt", "w", stdout); 34 | 35 | #endif 36 | 37 | std::vector vec = {10, 3, 12, 7, 2, 9, 11, 20, 11, 13, 6, 8}; 38 | std::cout << lis(vec) << "\n"; 39 | 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /Dynamic_Programming/num_ways_dice.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given a dice and a number N. COunt the num of ways to get 3 | * a sum N if you can roll the dice as may times as required 4 | **/ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int num_ways_dice(int N) 12 | { 13 | std::vector dp(N+1, 0); 14 | dp[0] = 1; 15 | 16 | for (int i = 1; i <= N; ++i) 17 | { 18 | for (int j = 1; j <= 6; ++j) 19 | { 20 | if (i-j >= 0) 21 | { 22 | dp[i] += dp[i-j]; 23 | } 24 | } 25 | } 26 | return dp[N]; 27 | } 28 | 29 | int main() 30 | { 31 | #ifndef FILE_INOUT 32 | 33 | freopen("in.txt", "r", stdin); 34 | 35 | freopen("out.txt", "w", stdout); 36 | 37 | #endif 38 | 39 | int n = 4; 40 | std::cout << num_ways_dice(n) << "\n"; 41 | 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /Tries/tries.cpp: -------------------------------------------------------------------------------- 1 | class TrieNode 2 | { 3 | public: 4 | unordered_map um; 5 | bool end; 6 | 7 | TrieNode() 8 | { 9 | end = false; 10 | } 11 | }; 12 | 13 | class Trie 14 | { 15 | TrieNode root; 16 | }; 17 | 18 | 19 | //TC : O(l), l = length of word 20 | void insert(string word) 21 | { 22 | TrieNode curr = root; 23 | for (int i = 0; i < word.length(); ++i) 24 | { 25 | char ch = word[i]; 26 | 27 | if (!curr.um[ch]) 28 | { 29 | curr.um.insert({ch, new TrieNode()}); 30 | } 31 | curr = curr.um[ch]; 32 | } 33 | curr.end = true; 34 | } 35 | 36 | //TC : O(l), l = length of word 37 | bool search(string word) 38 | { 39 | TrieNode curr = root; 40 | for (int i = 0; i < word.length(); ++i) 41 | { 42 | char ch = word[i]; 43 | 44 | if (!curr.um[ch]) 45 | { 46 | return false; 47 | } 48 | return curr.end; 49 | } 50 | } 51 | 52 | -------------------------------------------------------------------------------- /2D_Matrix/Print_upper_triangle.cpp: -------------------------------------------------------------------------------- 1 | //Print upper triangle in a square matrix 2 | 3 | #include 4 | #include 5 | 6 | void print(std::vector< std::vector>& vec, int n) 7 | { 8 | for (int i = 0; i < n-1; ++i) 9 | { 10 | for (int j = i+1; j < n; ++j) 11 | { 12 | std::cout << vec[i][j] << " "; 13 | } 14 | std::cout << "\n"; 15 | } 16 | } 17 | 18 | int main() 19 | { 20 | #ifndef FILE_INOUT 21 | 22 | freopen("in.txt", "r", stdin); 23 | 24 | freopen("out.txt", "w", stdout); 25 | 26 | #endif 27 | 28 | int n; 29 | std::cin >> n; 30 | 31 | std::vector< std::vector > vec(n, std::vector(n)); 32 | 33 | for (int i = 0; i < n; ++i) 34 | { 35 | for (int j = 0; j < n; ++j) 36 | { 37 | std::cin >> vec[i][j]; 38 | } 39 | } 40 | 41 | print(vec, n); 42 | 43 | return 0; 44 | 45 | } 46 | -------------------------------------------------------------------------------- /Linked_List/find_intersection.cpp: -------------------------------------------------------------------------------- 1 | /** Find intersection point of two LLs **/ 2 | 3 | 4 | Node* find_intersection(Node* head1, Node* head2) 5 | { 6 | int len1 = 0, len2 = 0; 7 | 8 | Node *node1 = head1, *node2 = head2; 9 | 10 | while (node1 != NULL) 11 | { 12 | len1++; 13 | node1 = node1->next; 14 | } 15 | 16 | while (node2 != NULL) 17 | { 18 | len2++; 19 | node2 = node2->next; 20 | } 21 | node1 = head1; 22 | node2 = head2; 23 | 24 | if (len1 > len2) 25 | { 26 | int diff = len1 - len2; 27 | 28 | while (diff > 0) 29 | { 30 | node1 = node1->next; 31 | diff--; 32 | } 33 | } 34 | else if (len1 < len2) 35 | { 36 | int diff = len2 - len1; 37 | 38 | while (diff > 0) 39 | { 40 | node2 = node2->next; 41 | diff--; 42 | } 43 | } 44 | 45 | while (node1 != node2) 46 | { 47 | node1 = node1-next; 48 | node2 = node2->next; 49 | } 50 | return node1; 51 | } 52 | -------------------------------------------------------------------------------- /Dynamic_Programming/house_robbers.cpp: -------------------------------------------------------------------------------- 1 | //Maximum sum without adjacent elements 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int max_sum(std::vector& vec) 9 | { 10 | std::vector money(vec.size()); 11 | money[0] = vec[0]; 12 | money[1] = vec[1]; 13 | 14 | for (int i = 2; i < vec.size(); ++i) 15 | { 16 | money[i] = std::max(vec[i] + money[i-2], money[i-1]); 17 | } 18 | 19 | return money[vec.size()-1]; 20 | } 21 | 22 | int main() 23 | { 24 | #ifndef FILE_INOUT 25 | 26 | freopen("in.txt", "r", stdin); 27 | 28 | freopen("out.txt", "w", stdout); 29 | 30 | #endif 31 | 32 | int n; 33 | std::cin >> n; 34 | 35 | std::vector vec(n); 36 | 37 | for (int i = 0; i < n; ++i) 38 | { 39 | std::cin >> vec[i]; 40 | } 41 | 42 | std::cout << max_sum(vec) << "\n"; 43 | 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /Maths/find_sq_root.cpp: -------------------------------------------------------------------------------- 1 | //Given a perfect square. Find the square root 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | int linear_search_mtd(int n) 8 | { 9 | for (int i = 1; i <= n; ++i) 10 | { 11 | if (i*i == n) 12 | return i; 13 | } 14 | } 15 | 16 | int binary_search_mtd(int n) 17 | { 18 | int l = 1, r = n; 19 | 20 | while (l <= r) 21 | { 22 | int mid = (l+r)/2; 23 | 24 | if (mid*mid == n) 25 | return mid; 26 | else if (mid*mid < n) 27 | l = mid+1; 28 | else 29 | r = mid-1; 30 | } 31 | } 32 | 33 | int main() 34 | { 35 | #ifndef FILE_INOUT 36 | 37 | freopen("in.txt", "r", stdin); 38 | 39 | freopen("out.txt", "w", stdout); 40 | 41 | #endif 42 | 43 | int n; 44 | std::cin >> n; 45 | 46 | std::cout << linear_search_mtd(n) << "\n"; 47 | std::cout << binary_search_mtd(n) << "\n"; 48 | 49 | return 0; 50 | 51 | } 52 | -------------------------------------------------------------------------------- /Sorting/Count_sort.cpp: -------------------------------------------------------------------------------- 1 | //Swapping of non-consecutive indices is not allowed 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | void count_sort(std::vector& vec, int n) 9 | { 10 | for (int i = 0; i < n; ++i) 11 | { 12 | for (int j = 0; j < n-1-i; ++j) 13 | { 14 | if (vec[j] > vec[j+1]) 15 | std::swap(vec[j], vec[j+1]); 16 | } 17 | } 18 | } 19 | 20 | int main() 21 | { 22 | #ifndef FILE_INOUT 23 | 24 | freopen("in.txt", "r", stdin); 25 | 26 | freopen("out.txt", "w", stdout); 27 | 28 | #endif 29 | 30 | int n; 31 | std::cin >> n; 32 | 33 | std::vector vec(n); 34 | 35 | for (int i = 0; i < n; ++i) 36 | { 37 | std::cin >> vec[i]; 38 | } 39 | 40 | count_sort(vec, n); 41 | 42 | for (int i = 0; i < n; ++i) 43 | { 44 | std::cout << vec[i] << "\n"; 45 | } 46 | 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /Linked_List/deep_copy.cpp: -------------------------------------------------------------------------------- 1 | /** Clone (Deep copy) a LL with random pointer **/ 2 | 3 | /** 4 | * class Node 5 | * { 6 | * int val; 7 | * Node* next; 8 | * Node* random; 9 | * }; 10 | **/ 11 | 12 | #include 13 | 14 | Node* deep_copy(Node* head) 15 | { 16 | std::unordered_map nodes_map; 17 | 18 | Node* new_head = new Node(head->val); 19 | nodes_map.insert({head, new_head}); 20 | 21 | Node* curr = head->next; 22 | Node* prev = new_head; 23 | 24 | while (curr != NULL) 25 | { 26 | Node* node = new Node(curr->val); 27 | nodes_map.insert({curr, node}); 28 | 29 | prev->next = node; 30 | prev = node; 31 | 32 | curr = curr->next; 33 | } 34 | 35 | curr = head; 36 | Node* curr_copy = new_head; 37 | 38 | while (curr != NULL) 39 | { 40 | curr_copy->random = nodes_map[curr->random]; 41 | curr = curr->next; 42 | curr_copy = curr_copy->next; 43 | } 44 | 45 | return new_head; 46 | } 47 | -------------------------------------------------------------------------------- /Dynamic_Programming/lcs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int lcs(std::string& s1, std::string& s2) 7 | { 8 | int n1 = s1.size(); 9 | int n2 = s2.size(); 10 | 11 | std::vector> dp(n1+1, std::vector(n2+1, 0)); 12 | 13 | for (int i = 1; i <= n1; ++i) 14 | { 15 | for (int j = 1; j <= n2; ++j) 16 | { 17 | if (s1[i-1] == s2[j-1]) 18 | { 19 | dp[i][j] = 1 + dp[i-1][j-1]; 20 | } 21 | else 22 | { 23 | dp[i][j] = std::max(dp[i-1][j], dp[i][j-1]); 24 | } 25 | } 26 | } 27 | 28 | return dp[n1][n2]; 29 | } 30 | 31 | int main() 32 | { 33 | #ifndef FILE_INOUT 34 | 35 | freopen("in.txt", "r", stdin); 36 | 37 | freopen("out.txt", "w", stdout); 38 | 39 | #endif 40 | 41 | std::string s1 = "ABCDGH"; 42 | std::string s2 = "AEDFHR"; 43 | 44 | std::cout << lcs(s1, s2) << "\n"; 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /Bit_Manipulation/single_number.cpp: -------------------------------------------------------------------------------- 1 | //In an array, every element appears thrice except one. Find the single number 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int single_number(std::vector& vec, int n) 9 | { 10 | int ans = 0; 11 | for (int i = 0; i < 32; ++i) 12 | { 13 | int count = 0; 14 | for (int j = 0; j < n; ++j) 15 | { 16 | if ((vec[j]&(1<> n; 39 | 40 | std::vector vec(n); 41 | 42 | for (int i = 0; i < n; ++i) 43 | std::cin >> vec[i]; 44 | 45 | std::cout << single_number(vec, n) << "\n"; 46 | 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /Maths/gcd_seq.cpp: -------------------------------------------------------------------------------- 1 | //Check if there exists any subsequence in the array such that 2 | // gcd(subsequence) == 1 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | int gcd(int a, int b) 10 | { 11 | if (a == 0) 12 | return b; 13 | 14 | return gcd(b % a, a); 15 | } 16 | 17 | bool gcd_seq(std::vector& vec, int n) 18 | { 19 | int curr = vec[0]; 20 | 21 | for (int i = 1; i < n; ++i) 22 | { 23 | curr = gcd(curr, vec[i]); 24 | 25 | if (curr == 1) 26 | return true; 27 | } 28 | return false; 29 | } 30 | 31 | int main() 32 | { 33 | #ifndef FILE_INOUT 34 | 35 | freopen("in.txt", "r", stdin); 36 | 37 | freopen("out.txt", "w", stdout); 38 | 39 | #endif 40 | 41 | int n; 42 | std::cin >> n; 43 | 44 | std::vector vec(n); 45 | 46 | for (int i = 0; i < n; ++i) 47 | std::cin >> vec[i]; 48 | 49 | std::cout << gcd_seq(vec, n) << "\n"; 50 | 51 | return 0; 52 | } 53 | -------------------------------------------------------------------------------- /Subset_&_Subsequence/subsets_sum.cpp: -------------------------------------------------------------------------------- 1 | // Find sum of all subsets sum 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | int sum_subsets(std::vector& vec) 10 | { 11 | int n = vec.size(); 12 | int sum = 0; 13 | 14 | for (int i = 0; i < n; ++i) 15 | { 16 | sum += (vec[i] * (1<<(n-1))); 17 | } 18 | 19 | return sum; 20 | } 21 | 22 | int main() 23 | { 24 | #ifndef FILE_INOUT 25 | 26 | freopen("in.txt", "r", stdin); 27 | 28 | freopen("out.txt", "w", stdout); 29 | 30 | #endif 31 | 32 | std::string input; 33 | std::getline(std::cin, input); 34 | 35 | std::vector vec; 36 | 37 | std::stringstream ss(input); 38 | 39 | for (int i; ss >> i;) 40 | { 41 | if (ss.peek() == ',' || ss.peek() == ' ') 42 | ss.ignore(); 43 | 44 | vec.push_back(i); 45 | } 46 | 47 | std::cout << sum_subsets(vec) << "\n"; 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /Maths/smallest_prime_factors.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | std::vector smallest_prime_factors(int n) 7 | { 8 | std::vector factors(n+1); 9 | 10 | for (int i = 0; i <= n; ++i) 11 | factors[i] = i; 12 | 13 | for (int i = 2; i*i <= n; ++i) 14 | { 15 | if (factors[i] == i) 16 | { 17 | for (int j = i*i; j <= n; j += i) 18 | { 19 | if (factors[j] == j) 20 | factors[j] = i; 21 | } 22 | } 23 | } 24 | 25 | return factors; 26 | } 27 | 28 | int main() 29 | { 30 | #ifndef FILE_INOUT 31 | 32 | freopen("in.txt", "r", stdin); 33 | 34 | freopen("out.txt", "w", stdout); 35 | 36 | #endif 37 | 38 | int n; 39 | std::cin >> n; 40 | 41 | std::vector factors = smallest_prime_factors(n); 42 | 43 | for (int i = 2; i < factors.size(); ++i) 44 | { 45 | std::cout << i << ":" << factors[i] << " "; 46 | } 47 | 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /String/longest_substring_palindrome.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int expand(std::string& s, int l, int r) 7 | { 8 | int n = s.size(); 9 | int i = l, j = r; 10 | 11 | while (i >= 0 && j < n && s[i] == s[j]) 12 | { 13 | i--; 14 | j++; 15 | } 16 | 17 | return j-i-1; 18 | } 19 | 20 | int largest_palin(std::string& s) 21 | { 22 | int ans = 1; 23 | 24 | for (int i = 0; i < s.size(); ++i) 25 | { 26 | //Odd length palindrome 27 | ans = std::max(ans, expand(s, i, i)); 28 | 29 | //Even length palindrome 30 | ans = std::max(ans, expand(s, i, i+1)); 31 | } 32 | 33 | return ans; 34 | } 35 | 36 | int main() 37 | { 38 | #ifndef FILE_INOUT 39 | 40 | freopen("in.txt", "r", stdin); 41 | 42 | freopen("out.txt", "w", stdout); 43 | 44 | #endif 45 | 46 | std::string s; 47 | std::cin >> s; 48 | 49 | std::cout << largest_palin(s) << "\n"; 50 | 51 | return 0; 52 | 53 | } 54 | -------------------------------------------------------------------------------- /Sorting/Insertion Sort/C++/insertionsort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void insertion_sort(std::vector& vec, int n) 7 | { 8 | for(std::size_t j = 1; j < n; j++) 9 | { 10 | int key = vec[j]; 11 | int i = j-1; 12 | 13 | while(i >= 0 && vec[i] > key) 14 | { 15 | vec[i+1] = vec[i]; 16 | i--; 17 | } 18 | vec[i+1] = key; 19 | } 20 | } 21 | 22 | int main() 23 | { 24 | #ifndef FILE_INOUT 25 | 26 | freopen("in.txt", "r", stdin); 27 | 28 | freopen("out.txt", "w", stdout); 29 | 30 | #endif 31 | 32 | int n; 33 | std::cin >> n; 34 | 35 | std::vector vec(n); 36 | for (int i = 0; i < n; ++i) 37 | { 38 | std::cin >> vec[i]; 39 | } 40 | 41 | insertion_sort(vec, n); 42 | 43 | for (int x : vec) 44 | { 45 | std::cout << x << " "; 46 | } 47 | std::cout << "\n"; 48 | 49 | return 0; 50 | } 51 | -------------------------------------------------------------------------------- /Array_and_Subarray/Max_contagious_sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int max_contagious_sum(std::vector& vec) 9 | { 10 | int ans = INT_MIN, sum = 0; 11 | for (int i = 0; i < vec.size(); ++i) 12 | { 13 | sum += vec[i]; 14 | ans = std::max(ans, sum); 15 | 16 | if (sum < 0) 17 | sum = 0; 18 | } 19 | return ans; 20 | } 21 | 22 | int main() 23 | { 24 | #ifndef FILE_INOUT 25 | 26 | freopen("in.txt", "r", stdin); 27 | 28 | freopen("out.txt", "w", stdout); 29 | 30 | #endif 31 | 32 | std::string input; 33 | std::getline(std::cin, input); 34 | 35 | std::vector vec; 36 | 37 | std::stringstream ss(input); 38 | for (int i; ss >> i;) 39 | { 40 | vec.push_back(i); 41 | 42 | if (ss.peek() == ',' || ss.peek() == ' ') 43 | ss.ignore(); 44 | } 45 | 46 | std::cout << max_contagious_sum(vec) << "\n"; 47 | 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /Queue/Queue_using_stack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | class Queue 8 | { 9 | public: 10 | std::stack st1, st2; 11 | Queue() {} 12 | 13 | void enqueue(int); 14 | void dequeue(); 15 | }; 16 | 17 | void Queue::enqueue(int x) 18 | { 19 | st1.push(x); 20 | } 21 | 22 | void Queue::dequeue() 23 | { 24 | if (st2.empty()) 25 | { 26 | while (!st1.empty()) 27 | { 28 | st2.push(st1.top()); 29 | st1.pop(); 30 | } 31 | } 32 | 33 | if (!st2.empty()) 34 | { 35 | st2.pop(); 36 | } 37 | } 38 | 39 | int main() 40 | { 41 | #ifndef FILE_INOUT 42 | 43 | freopen("in.txt", "r", stdin); 44 | 45 | freopen("out.txt", "w", stdout); 46 | 47 | #endif 48 | 49 | Queue queue; 50 | queue.enqueue(1); 51 | queue.enqueue(2); 52 | queue.enqueue(3); 53 | queue.dequeue(); 54 | queue.enqueue(4); 55 | queue.enqueue(5); 56 | queue.enqueue(6); 57 | queue.enqueue(7); 58 | return 0; 59 | } 60 | -------------------------------------------------------------------------------- /Binary_Tree/left_view.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 left_view(TreeNode* A) { 11 | if (A == NULL) 12 | { 13 | return {}; 14 | } 15 | 16 | vector res; 17 | 18 | queue q; 19 | q.push(A); 20 | 21 | while (!q.empty()) 22 | { 23 | int q_sz = q.size(); 24 | 25 | for (int i = 0; i < q_sz; ++i) 26 | { 27 | TreeNode* tmp = q.front(); 28 | q.pop(); 29 | 30 | if (i == 0) 31 | { 32 | res.push_back(tmp->val); 33 | } 34 | 35 | if (tmp->left != NULL) 36 | { 37 | q.push(tmp->left); 38 | } 39 | 40 | if (tmp->right != NULL) 41 | { 42 | q.push(tmp->right); 43 | } 44 | } 45 | } 46 | return res; 47 | } 48 | -------------------------------------------------------------------------------- /Maths/rearrange.cpp: -------------------------------------------------------------------------------- 1 | //Given an array of size N of all distinct integers from 0 to N-1. Rearrange 2 | // the array such that A[i] = A[A[i]] 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | void rearrange(std::vector& vec, int n) 10 | { 11 | for (int i = 0; i < n; ++i) 12 | vec[i] = vec[i]*n; 13 | 14 | for (int i = 0; i < n; ++i) 15 | { 16 | int idx = vec[i]/n; 17 | 18 | int val = vec[idx]/n; 19 | vec[i] = vec[i] + val; 20 | } 21 | 22 | for (int i = 0; i < n; ++i) 23 | { 24 | vec[i] = vec[i] % n; 25 | } 26 | } 27 | 28 | int main() 29 | { 30 | #ifndef FILE_INOUT 31 | 32 | freopen("in.txt", "r", stdin); 33 | 34 | freopen("out.txt", "w", stdout); 35 | 36 | #endif 37 | 38 | int n; 39 | std::cin >> n; 40 | 41 | std::vector vec(n); 42 | 43 | for (int i = 0; i < n; ++i) 44 | { 45 | std::cin >> vec[i]; 46 | } 47 | 48 | rearrange(vec, n); 49 | 50 | for (int x : vec) 51 | std::cout << x << " "; 52 | 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /Array_and_Subarray/Max_sum_of_subarray_len_K.cpp: -------------------------------------------------------------------------------- 1 | //Given an array of size N. Find the maximum sum of subarray of 2 | //length K. 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | //Using sliding window technique 11 | int max_sum(std::vector& vec, int n, int k) 12 | { 13 | int sum = 0, mx = INT_MIN; 14 | 15 | for (int i = 0; i < k; ++i) 16 | { 17 | sum += vec[i]; 18 | } 19 | 20 | mx = std::max(sum, mx); 21 | 22 | for (int i = 1; i <= n-k; ++i) 23 | { 24 | sum += vec[i+k-1] - vec[i-1]; 25 | mx = std::max(sum, mx); 26 | } 27 | 28 | return mx; 29 | } 30 | 31 | int main() 32 | { 33 | #ifndef FILE_INOUT 34 | 35 | freopen("in.txt", "r", stdin); 36 | 37 | freopen("out.txt", "w", stdout); 38 | 39 | #endif 40 | 41 | int n, k; 42 | std::cin >> n >> k; 43 | 44 | std::vector vec(n); 45 | 46 | for (int i = 0; i < n; ++i) 47 | { 48 | std::cin >> vec[i]; 49 | } 50 | 51 | std::cout << max_sum(vec, n, k) << "\n"; 52 | 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /Bit_Manipulation/Add_binary_strings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | std::string add_binary(std::string& a, std::string& b) 7 | { 8 | std::string res = ""; 9 | 10 | int carry = 0, sum; 11 | int i = a.size() - 1, j = b.size() - 1; 12 | 13 | while (i >= 0 || j >= 0 || carry) 14 | { 15 | sum = carry; 16 | if (i >= 0) 17 | { 18 | sum += (a[i] - '0'); 19 | } 20 | 21 | if (j >= 0) 22 | { 23 | sum += (b[j] - '0'); 24 | } 25 | 26 | int rem = sum % 2; 27 | carry = sum / 2; 28 | 29 | res.push_back((char)('0' + rem)); 30 | 31 | i--; 32 | j--; 33 | } 34 | 35 | std::reverse(res.begin(), res.end()); 36 | return res; 37 | } 38 | 39 | int main() 40 | { 41 | #ifndef FILE_INOUT 42 | 43 | freopen("in.txt", "r", stdin); 44 | 45 | freopen("out.txt", "w", stdout); 46 | 47 | #endif 48 | 49 | std::string a, b; 50 | std::cin >> a >> b; 51 | 52 | std::string r = add_binary(a, b); 53 | 54 | std::cout << r << "\n"; 55 | 56 | return 0; 57 | 58 | } 59 | -------------------------------------------------------------------------------- /Hashing/min_dist_dup_pairs.cpp: -------------------------------------------------------------------------------- 1 | //Given an array of size N. Return the minimum distance b/w any 2 | //two duplicate elements 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int min_dist(std::vector& vec, int n) 11 | { 12 | std::unordered_map um; 13 | int dist = INT_MAX; 14 | 15 | for (int i = 0; i < n; ++i) 16 | { 17 | if (um.find(vec[i]) != um.end()) 18 | { 19 | dist = std::min(dist, i-um[vec[i]]); 20 | um[vec[i]] = i; 21 | } 22 | else 23 | { 24 | um.insert({vec[i], i}); 25 | } 26 | } 27 | return dist; 28 | } 29 | 30 | int main() 31 | { 32 | #ifndef FILE_INOUT 33 | 34 | freopen("in.txt", "r", stdin); 35 | 36 | freopen("out.txt", "w", stdout); 37 | 38 | #endif 39 | 40 | int n; 41 | std::cin >> n; 42 | 43 | std::vector vec(n); 44 | for (int i = 0; i < n; ++i) 45 | { 46 | std::cin >> vec[i]; 47 | } 48 | 49 | std::cout << min_dist(vec, n) << "\n"; 50 | 51 | return 0; 52 | 53 | } 54 | -------------------------------------------------------------------------------- /Dynamic_Programming/min_num_perfect_sq.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given a number K. Find the minimum number of perfect square 3 | * needed to get the sum K 4 | **/ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int min_num_perfect_sq(int K) 12 | { 13 | std::vector dp(K+1); 14 | dp[0] = 0; 15 | dp[1] = 1; 16 | dp[2] = 2; 17 | dp[3] = 3; 18 | 19 | for (int i = 4; i <= K; ++i) 20 | { 21 | dp[i] = i; 22 | for (int j = 1; j*j <= i; ++j) 23 | { 24 | int tmp = j*j; 25 | 26 | if (tmp > i) 27 | { 28 | break; 29 | } 30 | else 31 | { 32 | dp[i] = std::min(dp[i], 1+dp[i-tmp]); 33 | } 34 | } 35 | } 36 | 37 | // for (int x : dp) 38 | // { 39 | // std::cout << x << " "; 40 | // } 41 | return dp[K]; 42 | } 43 | 44 | int main() 45 | { 46 | #ifndef FILE_INOUT 47 | 48 | freopen("in.txt", "r", stdin); 49 | 50 | freopen("out.txt", "w", stdout); 51 | 52 | #endif 53 | 54 | int n = 6; 55 | std::cout << min_num_perfect_sq(n) << "\n"; 56 | 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /Bubble Sort/bubbleSort.py: -------------------------------------------------------------------------------- 1 | def get_input(): 2 | """ 3 | get input from user 4 | """ 5 | input_str = input("Enter elements to be sorted: ") 6 | try: 7 | elements = [int(e) for e in input_str.split()] #make a list of integers from input string 8 | except ValueError: 9 | print("Please enter a list of integers only, seperated by a space!!") 10 | return elements 11 | 12 | def bubble_sort(thelist): 13 | """ 14 | Bubble Sort algorithm 15 | """ 16 | if len(thelist) == 0: 17 | print("Empty list!!") 18 | 19 | elif len(thelist) == 1: 20 | print("Only one element!!") 21 | 22 | else: 23 | for i in range(len(thelist) - 1): 24 | 25 | for j in range(len(thelist) - i - 1): 26 | if thelist[j] > thelist[j+1]: #if element is greater than from next element 27 | thelist[j], thelist[j+1] = thelist[j+1], thelist[j] #swapping 28 | 29 | if __name__ == '__main__': 30 | input_list = get_input() 31 | bubble_sort(input_list) 32 | print(*input_list, sep = ", ") 33 | -------------------------------------------------------------------------------- /Binary_Search/find_floor_element.cpp: -------------------------------------------------------------------------------- 1 | //Given sorted array in ascending order. Find floor of 2 | //given target k. 3 | 4 | //greatest element <= k 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int find_floor(std::vector& arr, int n, int k) 12 | { 13 | int ans = -1; 14 | int l = 0, r = n-1; 15 | 16 | while (l <= r) 17 | { 18 | int mid = (l+r)/2; 19 | 20 | if (arr[mid] == k) 21 | { 22 | return arr[mid]; 23 | } 24 | else if (arr[mid] < k) 25 | { 26 | ans = arr[mid]; 27 | l = mid+1; 28 | } 29 | else 30 | { 31 | r = mid-1; 32 | } 33 | } 34 | return ans; 35 | } 36 | 37 | int main() 38 | { 39 | #ifndef FILE_INOUT 40 | 41 | freopen("in.txt", "r", stdin); 42 | 43 | freopen("out.txt", "w", stdout); 44 | 45 | #endif 46 | 47 | int n; 48 | std::cin >> n; 49 | 50 | std::vector vec(n); 51 | for (int i = 0; i < n; ++i) 52 | { 53 | std::cin >> vec[i]; 54 | } 55 | 56 | std::cout << find_floor(vec, n, 19); 57 | 58 | return 0; 59 | } 60 | -------------------------------------------------------------------------------- /Stack/double_char_trouble.cpp: -------------------------------------------------------------------------------- 1 | // Remove any 2 consecutive duplicate characters 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | std::string remove_consecutive_duplicates(std::string& str) 10 | { 11 | std::stack st; 12 | std::string res = ""; 13 | 14 | for (char c : str) 15 | { 16 | if (st.empty()) 17 | { 18 | st.push(c); 19 | } 20 | else 21 | { 22 | if (st.top() == c) 23 | { 24 | st.pop(); 25 | } 26 | else 27 | { 28 | st.push(c); 29 | } 30 | } 31 | } 32 | 33 | while (!st.empty()) 34 | { 35 | res += st.top(); 36 | st.pop(); 37 | } 38 | std::reverse(res.begin(), res.end()); 39 | 40 | return res; 41 | } 42 | 43 | int main() 44 | { 45 | #ifndef FILE_INOUT 46 | 47 | freopen("in.txt", "r", stdin); 48 | 49 | freopen("out.txt", "w", stdout); 50 | 51 | #endif 52 | 53 | std::string str = "abcdeedcaabxxdad"; 54 | std::string res = remove_consecutive_duplicates(str); 55 | 56 | std::cout << res; 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /Two_Pointers/most_water.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given n elements, where A[i] = height of ith wall. 3 | * Pick any two walls such that the water collected between them 4 | * is maximum 5 | **/ 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int container_with_most_water(std::vector& vec, int n) 12 | { 13 | int ans = 0, i = 0, j = n-1; 14 | 15 | while (i < j) 16 | { 17 | int x = (j - i) * std::min(vec[i], vec[j]); 18 | ans = std::max(ans, x); 19 | 20 | if (vec[i] < vec[j]) 21 | { 22 | i++; 23 | } 24 | else 25 | { 26 | j--; 27 | } 28 | } 29 | return ans; 30 | } 31 | 32 | int main() 33 | { 34 | #ifndef FILE_INOUT 35 | 36 | freopen("in.txt", "r", stdin); 37 | 38 | freopen("out.txt", "w", stdout); 39 | 40 | #endif 41 | 42 | int n; 43 | std::cin >> n; 44 | 45 | std::vector vec(n); 46 | 47 | for (int i = 0; i < n; ++i) 48 | { 49 | std::cin >> vec[i]; 50 | } 51 | 52 | std::cout << container_with_most_water(vec, n) << "\n"; 53 | 54 | return 0; 55 | } 56 | -------------------------------------------------------------------------------- /Combinatorics/nCr_mod_p.cpp: -------------------------------------------------------------------------------- 1 | //A = n, B = r, p = mod, where p is prime 2 | 3 | int iter_pow(int base, int exp, int mod) 4 | { 5 | if (base == 1 || exp == 0) 6 | { 7 | return 1; 8 | } 9 | 10 | int ans = 1; 11 | 12 | while (exp > 0) 13 | { 14 | if (exp % 2 == 1) 15 | { 16 | ans = (ans * base) % mod; 17 | } 18 | 19 | exp = exp >> 1; 20 | 21 | base = (base * base) % mod; 22 | } 23 | return ans % mod; 24 | } 25 | 26 | int nCr_mod_p(int A, int B, int C) { 27 | int term1 = 1; 28 | 29 | for (int i = 2; i <= A; ++i) 30 | { 31 | term1 = (term1 * i) % C; 32 | } 33 | 34 | int A_B_fact = 1; 35 | 36 | for (int i = 2; i <= A-B; ++i) 37 | { 38 | A_B_fact = (A_B_fact * i) % C; 39 | } 40 | 41 | int B_fact = 1; 42 | 43 | for (int i = 2; i <= B; ++i) 44 | { 45 | B_fact = (B_fact * i) % C; 46 | } 47 | 48 | int term2 = iter_pow(A_B_fact, C-2, C); 49 | int temr3 = iter_pow(B_fact, C-2, C); 50 | 51 | return (term1 * term2 * temr3) % C; 52 | } 53 | -------------------------------------------------------------------------------- /Bit_Manipulation/Sum_xor_pairs.cpp: -------------------------------------------------------------------------------- 1 | //Given an array of N elements. Calculate the sum of xor of all 2 | // the pairs 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | int sum_xor_pairs(std::vector& vec, int n) 10 | { 11 | int sum = 0; 12 | for (int i = 0; i < 32; ++i) 13 | { 14 | int count_1 = 0; 15 | for (int j = 0; j < n; ++j) 16 | { 17 | // std::cout << "i : " << i << " vec[j] : " << vec[j] << "\n"; 18 | // std::cout << (vec[j]&(1<> n; 42 | 43 | std::vector vec(n); 44 | for (int i = 0; i < n; ++i) 45 | std::cin >> vec[i]; 46 | 47 | std::cout << sum_xor_pairs(vec, n) << "\n"; 48 | 49 | return 0; 50 | } 51 | -------------------------------------------------------------------------------- /2D_Matrix/transpose.cpp: -------------------------------------------------------------------------------- 1 | //Given a square matrix. Convert it to its transpose without 2 | //using any extra space. 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | void transpose(std::vector< std::vector >& vec, int n) 9 | { 10 | for (int i = 0; i < n-1; ++i) 11 | { 12 | for (int j = i+1; j < n; ++j) 13 | { 14 | std::swap(vec[i][j], vec[j][i]); 15 | } 16 | } 17 | } 18 | 19 | int main() 20 | { 21 | #ifndef FILE_INOUT 22 | 23 | freopen("in.txt", "r", stdin); 24 | 25 | freopen("out.txt", "w", stdout); 26 | 27 | #endif 28 | 29 | int n; 30 | std::cin >> n; 31 | 32 | std::vector< std::vector > vec(n, std::vector(n)); 33 | 34 | for (int i = 0; i < n; ++i) 35 | { 36 | for (int j = 0; j < n; ++j) 37 | { 38 | std::cin >> vec[i][j]; 39 | } 40 | } 41 | 42 | transpose(vec, n); 43 | 44 | for (int i = 0; i < n; ++i) 45 | { 46 | for (int j = 0; j < n; ++j) 47 | { 48 | std::cout << vec[i][j] << " "; 49 | } 50 | std::cout << "\n"; 51 | } 52 | 53 | return 0; 54 | 55 | } 56 | -------------------------------------------------------------------------------- /Maths/count_divisors.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | // N = p1^a1 * p2^a2 * p3^a3.. 7 | // divisors = (a1+1)(a2+1)(a3+1) 8 | 9 | int count_divisors(int n) 10 | { 11 | std::vector factors(n+1); 12 | 13 | for (int i = 0; i <= n; ++i) 14 | factors[i] = i; 15 | 16 | for (int i = 2; i*i <= n; ++i) 17 | { 18 | if (factors[i] == i) 19 | { 20 | for (int j = i*i; j <= n; j += i) 21 | { 22 | if (factors[j] == j) 23 | { 24 | factors[j] = i; 25 | } 26 | } 27 | } 28 | } 29 | 30 | int ans = 1; 31 | 32 | while (n > 1) 33 | { 34 | int x = factors[n]; 35 | int count = 0; 36 | 37 | while (n % x == 0) 38 | { 39 | count++; 40 | n = n/x; 41 | } 42 | 43 | ans = ans * (count+1); 44 | } 45 | 46 | return ans; 47 | } 48 | 49 | int main() 50 | { 51 | #ifndef FILE_INOUT 52 | 53 | freopen("in.txt", "r", stdin); 54 | 55 | freopen("out.txt", "w", stdout); 56 | 57 | #endif 58 | 59 | int n; 60 | std::cin >> n; 61 | 62 | std::cout << count_divisors(n) << "\n"; 63 | 64 | return 0; 65 | } 66 | -------------------------------------------------------------------------------- /Binary_Tree/check_height_balanced_tree.cpp: -------------------------------------------------------------------------------- 1 | 2 | //TC O(N^2) 3 | bool is_balanced(TreeNode* root) 4 | { 5 | if (root == NULL) 6 | { 7 | return true; 8 | } 9 | 10 | int left_height = height(root->left); 11 | int right_height = height(root->right); 12 | 13 | if (abs(left_height - right_height) > 1) 14 | { 15 | return false; 16 | } 17 | 18 | return is_balanced(root->left) && is_balanced(root->right); 19 | } 20 | 21 | //Optimization using Post order approach 22 | 23 | class NodeInfo 24 | { 25 | bool balanced; 26 | int height; 27 | 28 | public: 29 | NodeInfo(bool bal, int h) : balanced(bal), 30 | height(h) 31 | {} 32 | }; 33 | 34 | NodeInfo is_balanced(TreeNode* root) 35 | { 36 | if (root == NULL) 37 | { 38 | return NodeInfo(true, -1); 39 | } 40 | 41 | NodeInfo l_info = is_balanced(root->left); 42 | NodeInfo r_info = is_balanced(root->right); 43 | 44 | if (l_info.balanced && r_info.balanced 45 | && abs(l_info.height - r_info.height) <= 1) 46 | { 47 | return NodeInfo(true, max(l_info.height, r_info.height)+1); 48 | } 49 | return NodeInfo(false, max(l_info.height, r_info.height)+1) 50 | } 51 | 52 | -------------------------------------------------------------------------------- /Binary_Search/local_minima.cpp: -------------------------------------------------------------------------------- 1 | //Given array of distince elements. Find any one local minima 2 | 3 | //a[i-1] > a[i] < a[i+1] 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int local_minima(std::vector& arr, int n) 11 | { 12 | if (arr[0] < arr[1]) 13 | return arr[0]; 14 | 15 | if (arr[n-1] < arr[n-2]) 16 | return arr[n-1]; 17 | 18 | int l = 1, r = n-2; 19 | 20 | while (l <= r) 21 | { 22 | int mid = (l+r)/2; 23 | 24 | if (arr[mid-1] > arr[mid] && arr[mid+1] > arr[mid]) 25 | { 26 | return arr[mid]; 27 | } 28 | else if (arr[mid-1] < arr[mid]) 29 | { 30 | r = mid - 1; 31 | } 32 | else 33 | { 34 | l = mid + 1; 35 | } 36 | } 37 | } 38 | 39 | int main() 40 | { 41 | #ifndef FILE_INOUT 42 | 43 | freopen("in.txt", "r", stdin); 44 | 45 | freopen("out.txt", "w", stdout); 46 | 47 | #endif 48 | 49 | int n; 50 | std::cin >> n; 51 | 52 | std::vector vec(n); 53 | for (int i = 0; i < n; ++i) 54 | { 55 | std::cin >> vec[i]; 56 | } 57 | 58 | std::cout << local_minima(vec, n); 59 | 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /Maths/count_pairs.cpp: -------------------------------------------------------------------------------- 1 | //Find number of pairs in an integer array A whose sum is divisible by M 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | int count_pairs(std::vector& vec, int m) 10 | { 11 | std::unordered_map um; 12 | int ans = 0; 13 | 14 | for (int x : vec) 15 | { 16 | int val = x % m; 17 | 18 | if (um.find(val) != um.end()) 19 | um[val]++; 20 | else 21 | um.insert({val, 1}); 22 | } 23 | 24 | for (auto u : um) 25 | { 26 | if (u.first == 0) 27 | ans += (u.second * (u.second -1)); 28 | else 29 | ans += (u.second * um[m - u.first]); 30 | } 31 | 32 | return ans/2; 33 | } 34 | 35 | int main() 36 | { 37 | #ifndef FILE_INOUT 38 | 39 | freopen("in.txt", "r", stdin); 40 | 41 | freopen("out.txt", "w", stdout); 42 | 43 | #endif 44 | 45 | int n, m; 46 | std::cin >> n >> m; 47 | 48 | std::vector vec(n); 49 | 50 | for (int i = 0; i < n; ++i) 51 | { 52 | std::cin >> vec[i]; 53 | } 54 | 55 | std::cout << count_pairs(vec, m) << "\n"; 56 | 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /Sorting/Insertion Sort/insertionSort.py: -------------------------------------------------------------------------------- 1 | def get_input(): 2 | """ 3 | get input from user 4 | """ 5 | input_str = input("Enter elements to be sorted: ") 6 | try: 7 | elements = [int(e) for e in input_str.split()] #make a list of integers from input string 8 | except ValueError: 9 | print("Please enter a list of integers only, seperated by a space!!") 10 | return elements 11 | 12 | def insertion_sort(thelist): 13 | """ 14 | Insertion sort algorithm 15 | """ 16 | if len(thelist) == 0: 17 | print("Empty list!!") 18 | 19 | elif len(thelist) == 1: 20 | print("Only one element!!") 21 | 22 | else: 23 | for index in range(1, len(thelist)): 24 | key = thelist[index] 25 | position = index - 1 26 | while position >= 0 and thelist[position] >= key: 27 | thelist[position + 1] = thelist[position] 28 | position = position - 1 29 | thelist[position + 1] = key 30 | 31 | if __name__ == '__main__': 32 | input_list = get_input() 33 | insertion_sort(input_list) 34 | print(*input_list, sep = ", ") 35 | -------------------------------------------------------------------------------- /Pattern_Matching/lps_array.cpp: -------------------------------------------------------------------------------- 1 | //Given a string of length N. Return LPS array. 2 | //LPS[i] = LPS of substring from index 0 to i. 3 | //LPS - Largest prefix suffix 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | std::vector lps_array(std::string& s) 11 | { 12 | int n = s.size(); 13 | 14 | std::vector lps(n); 15 | lps[0] = 0; 16 | 17 | int len = 0, i = 1; 18 | 19 | while (i < n) 20 | { 21 | if (s[i] == s[len]) 22 | { 23 | lps[i] = ++len; 24 | i++; 25 | } 26 | else 27 | { 28 | if (len != 0) 29 | { 30 | len = lps[len-1]; 31 | } 32 | else 33 | { 34 | lps[i] = 0; 35 | i++; 36 | } 37 | } 38 | } 39 | 40 | return lps; 41 | } 42 | 43 | int main() 44 | { 45 | #ifndef FILE_INOUT 46 | 47 | freopen("in.txt", "r", stdin); 48 | 49 | freopen("out.txt", "w", stdout); 50 | 51 | #endif 52 | 53 | std::string str; 54 | std::getline(std::cin, str); 55 | 56 | auto res = lps_array(str); 57 | 58 | for (int i = 0; i < res.size(); ++i) 59 | { 60 | std::cout << res[i] << " "; 61 | } 62 | 63 | return 0; 64 | } 65 | -------------------------------------------------------------------------------- /Sorting/Selection Sort/selectionSort.py: -------------------------------------------------------------------------------- 1 | def get_input(): 2 | """ 3 | get input from user 4 | """ 5 | input_str = input("Enter elements to be sorted: ") 6 | try: 7 | elements = [int(e) for e in input_str.split()] #make a list of integers from input string 8 | except ValueError: 9 | print("Please enter a list of integers only, seperated by a space!!") 10 | return elements 11 | 12 | def selection_sort(thelist): 13 | """ 14 | Selection sort Algorithm 15 | """ 16 | if len(thelist) == 0: 17 | print("Empty list!!") 18 | 19 | elif len(thelist) == 1: 20 | print("Only one element!!") 21 | 22 | else: 23 | for i in range(len(thelist)-1): 24 | min_idx = i #assigning first index as minimum index 25 | 26 | for j in range(i+1, len(thelist)): 27 | if thelist[j] < thelist[min_idx]: 28 | min_idx = j 29 | 30 | thelist[i], thelist[min_idx] = thelist[min_idx], thelist[i] #swapping 31 | 32 | 33 | if __name__ == '__main__': 34 | input_list = get_input() 35 | selection_sort(input_list) 36 | print(*input_list, sep = ", ") 37 | -------------------------------------------------------------------------------- /Heaps/k_smaller_elements.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | std::vector k_smaller_ele(std::vector& vec, int k) 7 | { 8 | std::priority_queue max_heap; 9 | 10 | for (int i = 0; i < k; ++i) 11 | { 12 | max_heap.push(vec[i]); 13 | } 14 | 15 | for (int i = k; i < vec.size(); ++i) 16 | { 17 | if (vec[i] < max_heap.top()) 18 | { 19 | max_heap.pop(); 20 | max_heap.push(vec[i]); 21 | } 22 | } 23 | std::vector res; 24 | 25 | while (!max_heap.empty()) 26 | { 27 | res.push_back(max_heap.top()); 28 | max_heap.pop(); 29 | } 30 | return res; 31 | } 32 | 33 | int main() 34 | { 35 | #ifndef FILE_INOUT 36 | 37 | freopen("in.txt", "r", stdin); 38 | 39 | freopen("out.txt", "w", stdout); 40 | 41 | #endif 42 | 43 | int n, k; 44 | std::cin >> n >> k; 45 | 46 | std::vector vec(n); 47 | for (int i = 0; i < n; ++i) 48 | { 49 | std::cin >> vec[i]; 50 | } 51 | 52 | std::vector res = k_smaller_ele(vec, k); 53 | 54 | for (int x : res) 55 | { 56 | std::cout << x << " "; 57 | } 58 | 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /Stack/nearest_smallest_element.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given an array of positive integers. For every index i, 3 | * find the nearest element on left side of i which is 4 | * smaller than A[i] 5 | **/ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | std::vector nearest_smallest_element(std::vector& vec) 14 | { 15 | std::vector ans; 16 | std::stack st; 17 | 18 | for (int x : vec) 19 | { 20 | while (!st.empty() && st.top() >= x) 21 | { 22 | st.pop(); 23 | } 24 | 25 | if (st.empty()) 26 | { 27 | ans.push_back(-1); 28 | } 29 | else if (st.top() < x) 30 | { 31 | ans.push_back(st.top()); 32 | } 33 | st.push(x); 34 | } 35 | return ans; 36 | } 37 | 38 | int main() 39 | { 40 | #ifndef FILE_INOUT 41 | 42 | freopen("in.txt", "r", stdin); 43 | 44 | freopen("out.txt", "w", stdout); 45 | 46 | #endif 47 | 48 | std::vector arr = {4, 5, 2, 10, 18, 2}; 49 | std::vector res = nearest_smallest_element(arr); 50 | 51 | for (int x : res) 52 | { 53 | std::cout << x << " "; 54 | } 55 | 56 | return 0; 57 | } 58 | -------------------------------------------------------------------------------- /Binary_Search_Tree/max_sized_bst.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given a Binary Tree. Find the size of max sized BST subtree 3 | * in the tree 4 | **/ 5 | 6 | class NodeInfo 7 | { 8 | public : 9 | bool is_bst; 10 | int mx_size; 11 | int own_size; 12 | int mx; 13 | int mn; 14 | 15 | NodeInfo(bool is_bst, int mx_size, int own_size, int mx, 16 | int mn) : is_bst(is_bst), mx_size(mx_size), 17 | own_size(own_size), mx(mx), mn(mn) {} 18 | }; 19 | 20 | NodeInfo max_size_bst(TreeNode* root) 21 | { 22 | if (root == NULL) 23 | { 24 | return NodeInfo(true, 0, 0, INT_MIN, INT_MAX); 25 | } 26 | 27 | NodeInfo l = max_size_bst(root->left); 28 | NodeInfo r = max_size_bst(root->right); 29 | 30 | int own_size = l.own_size + r.own_size + 1; 31 | 32 | if (l.is_bst && r.is_bst && l.mx < root->val && r.mn > root->val) 33 | { 34 | return NodeInfo(true, max(l.mx_size, r.mx_size, own_size), 35 | own_size, max(root->val, l.mx, r.mx), 36 | min(root->val, l.mn, r.mn)); 37 | } 38 | else 39 | { 40 | return NodeInfo(false, max(l.mx_size, r.mx_size), own_size, 41 | max(root->val, l.mx, r.mx), 42 | min(root->val, l.mn, r.mn)); 43 | } 44 | } 45 | 46 | //TC O(N) 47 | //SC O(N) 48 | -------------------------------------------------------------------------------- /Dynamic_Programming/knapsack_01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int max_value(std::vector& wt, std::vector& val, 7 | int k) 8 | { 9 | int val_sz = val.size(); 10 | 11 | std::vector> dp(val_sz+1, std::vector(k+1, 0)); 12 | 13 | for (int i = 1; i <= val_sz; ++i) 14 | { 15 | for (int j = 1; j <= k; ++j) 16 | { 17 | dp[i][j] = dp[i-1][j]; 18 | 19 | if (j >= wt[i-1]) 20 | { 21 | dp[i][j] = std::max(dp[i][j], dp[i-1][j-wt[i-1]] + val[i-1]); 22 | } 23 | } 24 | } 25 | 26 | // for (int i = 0; i <= val_sz; ++i) 27 | // { 28 | // for (int j = 0; j <= k; ++j) 29 | // { 30 | // std::cout << dp[i][j] << " "; 31 | // } 32 | // std::cout << "\n"; 33 | // } 34 | return dp[val_sz][k]; 35 | } 36 | 37 | int main() 38 | { 39 | #ifndef FILE_INOUT 40 | 41 | freopen("in.txt", "r", stdin); 42 | 43 | freopen("out.txt", "w", stdout); 44 | 45 | #endif 46 | 47 | std::vector vals = {100, 60, 120, 150}; 48 | std::vector wt = {20, 10, 30, 40}; 49 | int k = 50; 50 | 51 | std::cout << max_value(wt, vals, k) << "\n"; 52 | 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /2D_Matrix/Max_sum_submatrix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | int max_sum_submatrix(std::vector>& mat) 8 | { 9 | int r = mat.size(); 10 | int c = mat[0].size(); 11 | 12 | int ans = INT_MIN; 13 | 14 | for (int row_s = 0; row_s < r; ++row_s) 15 | { 16 | std::vector ps_col(c, 0); 17 | 18 | for (int row_e = row_s; row_e < r; ++row_e) 19 | { 20 | int sum = 0; 21 | for (int i = 0; i < c; ++i) 22 | { 23 | ps_col[i] = ps_col[i] + mat[row_e][i]; 24 | sum += ps_col[i]; 25 | 26 | ans = std::max(ans, sum); 27 | 28 | if (sum < 0) 29 | sum = 0; 30 | } 31 | } 32 | } 33 | 34 | return ans; 35 | } 36 | 37 | int main() 38 | { 39 | #ifndef FILE_INOUT 40 | 41 | freopen("in.txt", "r", stdin); 42 | 43 | freopen("out.txt", "w", stdout); 44 | 45 | #endif 46 | 47 | std::vector > mat = { 48 | {0, -2, -7, 0}, 49 | {9, 2, -6, 2}, 50 | {-4, 1, -4, 1}, 51 | {-1, 8, 0, -2} 52 | }; 53 | 54 | std::cout << max_sum_submatrix(mat) << "\n"; 55 | 56 | return 0; 57 | } 58 | -------------------------------------------------------------------------------- /Bit_Manipulation/max_and_val.cpp: -------------------------------------------------------------------------------- 1 | //Given an array of N elements. Return max(A[i]&A[j]) where i != j 2 | // the pairs 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | int max_and_val(std::vector& vec, int n) 10 | { 11 | int ans = 0; 12 | 13 | //from i = 30 bcoz for if 31st pos is 1 means negative num 14 | for (int i = 30; i >= 0; i--) 15 | { 16 | int set_bits = 0; 17 | for (int j = 0; j < n; ++j) 18 | { 19 | if ((vec[j] & (1<= 2) 26 | { 27 | ans = (ans | (1<> n; 53 | 54 | std::vector vec(n); 55 | for (int i = 0; i < n; ++i) 56 | std::cin >> vec[i]; 57 | 58 | std::cout << max_and_val(vec, n) << "\n"; 59 | 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /Binary_Tree/bst_delete.cpp: -------------------------------------------------------------------------------- 1 | bool is_leaf(TreeNode* root) 2 | { 3 | if (root->left == NULL && root->right == NULL) 4 | { 5 | return true; 6 | } 7 | return false; 8 | } 9 | 10 | TreeNode* get_max(TreeNode* root) 11 | { 12 | while (root->right != NULL) 13 | { 14 | root = root->right; 15 | } 16 | return root; 17 | } 18 | 19 | TreeNode* delete_node(TreeNode* root, int value) 20 | { 21 | if (root == NULL) 22 | { 23 | return NULL; 24 | } 25 | 26 | if (root->val > value) 27 | { 28 | root->left = delete_node(root->left, value); 29 | } 30 | else if (root->val < value) 31 | { 32 | root->right = delete_node(root->right, value); 33 | } 34 | else //root is the node to be deleted 35 | { 36 | //case 1 : root is a leaf node 37 | if (is_leaf(root)) 38 | { 39 | return NULL; 40 | } 41 | 42 | //case 2 : root has 1 child 43 | if (root->left == NULL) 44 | { 45 | return root->right; 46 | } 47 | else if (root->right == NULL) 48 | { 49 | return root->left; 50 | } 51 | 52 | //case 3 : root has both childs 53 | TreeNode* mx_value_node = get_max(root->left); 54 | root->val = mx_value_node->val; 55 | root->left = delete_node(root->left, mx_value_node->val); 56 | return root; 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /Pattern_Matching/same_rotation_string.cpp: -------------------------------------------------------------------------------- 1 | //Given a string. Find number of end-start rotation giving the same string 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int count_same_rotation_string(std::string& str) 9 | { 10 | int s_sz = str.size(); 11 | std::string text = str + str; 12 | text = str + '$' + text; 13 | 14 | int n = text.size(); 15 | int len = 0, i = 1; 16 | std::vector lps(n); 17 | lps[0] = 0; 18 | 19 | int count = 0; 20 | while (i < n) 21 | { 22 | if (text[i] == text[len]) 23 | { 24 | lps[i] = ++len; 25 | i++; 26 | 27 | if (len == s_sz) 28 | { 29 | count++; 30 | } 31 | } 32 | else 33 | { 34 | if (len != 0) 35 | { 36 | len = lps[len-1]; 37 | } 38 | else 39 | { 40 | lps[i] = 0; 41 | i++; 42 | } 43 | } 44 | } 45 | return count-1; 46 | } 47 | 48 | int main() 49 | { 50 | #ifndef FILE_INOUT 51 | 52 | freopen("in.txt", "r", stdin); 53 | 54 | freopen("out.txt", "w", stdout); 55 | 56 | #endif 57 | 58 | std::string str; 59 | std::getline(std::cin, str); 60 | 61 | std::cout << count_same_rotation_string(str) << "\n"; 62 | 63 | return 0; 64 | } 65 | -------------------------------------------------------------------------------- /Binary_Tree/right_view.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::solve(TreeNode* A) { 11 | if (A == NULL) 12 | { 13 | return {}; 14 | } 15 | 16 | vector res; 17 | 18 | queue q; 19 | q.push(A); 20 | 21 | while (!q.empty()) 22 | { 23 | int q_sz = q.size(); 24 | 25 | for (int i = 0; i < q_sz; ++i) 26 | { 27 | TreeNode* tmp = q.front(); 28 | q.pop(); 29 | 30 | res.push_back(tmp->val); 31 | 32 | if (tmp->left != NULL) 33 | { 34 | q.push(tmp->left); 35 | } 36 | 37 | if (tmp->right != NULL) 38 | { 39 | q.push(tmp->right); 40 | } 41 | } 42 | res.push_back(-1); 43 | } 44 | 45 | vector ans; 46 | 47 | for (int i = 0; i < res.size()-1; ++i) 48 | { 49 | if (res[i+1] == -1) 50 | { 51 | ans.push_back(res[i]); 52 | } 53 | } 54 | return ans; 55 | } 56 | -------------------------------------------------------------------------------- /Dynamic_Programming/longest_palindromic_subseq.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int longest_palindromic_subsequence(std::string& A) 7 | { 8 | int la = A.size(); 9 | std::vector> dp(la, std::vector(la, 0)); 10 | 11 | for (int i = 0; i < la; ++i) 12 | { 13 | dp[i][i] = 1; 14 | } 15 | 16 | for (int i = 1; i < la; ++i) 17 | { 18 | int r = 0, c = i; 19 | 20 | while (r+i < la && c < la) 21 | { 22 | if (A[r] == A[c]) 23 | { 24 | dp[r][c] = 2 + dp[r+1][c-1]; 25 | } 26 | else 27 | { 28 | dp[r][c] = std::max(dp[r+1][c], dp[r][c-1]); 29 | } 30 | r++; 31 | c++; 32 | } 33 | } 34 | 35 | // for (int i = 0; i < la; ++i) 36 | // { 37 | // for (int j = 0; j < la; ++j) 38 | // { 39 | // std::cout << dp[i][j] << " "; 40 | // } 41 | // std::cout << "\n"; 42 | // } 43 | return dp[0][la-1]; 44 | } 45 | 46 | int main() 47 | { 48 | #ifndef FILE_INOUT 49 | 50 | freopen("in.txt", "r", stdin); 51 | 52 | freopen("out.txt", "w", stdout); 53 | 54 | #endif 55 | 56 | std::string str = "agbdba"; 57 | 58 | std::cout << longest_palindromic_subsequence(str) << "\n"; 59 | 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /Maths/sieve_of_eratosthenes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | std::vector sieve(int n) 7 | { 8 | std::vector primes(n+1, true); 9 | primes[0] = primes[1] = false; 10 | 11 | for (int i = 2; i <= n; ++i) 12 | { 13 | if (primes[i]) 14 | { 15 | for (int j = i*2; j <= n; j += i) 16 | { 17 | primes[j] = false; 18 | } 19 | } 20 | } 21 | 22 | return primes; 23 | } 24 | 25 | std::vector optimised_sieve(int n) 26 | { 27 | std::vector primes(n+1, true); 28 | primes[0] = primes[1] = false; 29 | 30 | for (int i = 2; i*i <= n; ++i) 31 | { 32 | if (primes[i]) 33 | { 34 | for (int j = i*i; j <= n; j += i) 35 | { 36 | primes[j] = false; 37 | } 38 | } 39 | } 40 | 41 | return primes; 42 | } 43 | 44 | int main() 45 | { 46 | #ifndef FILE_INOUT 47 | 48 | freopen("in.txt", "r", stdin); 49 | 50 | freopen("out.txt", "w", stdout); 51 | 52 | #endif 53 | 54 | int n; 55 | std::cin >> n; 56 | 57 | std::vector primes = optimised_sieve(n); 58 | 59 | for (int i = 2; i < primes.size(); ++i) 60 | { 61 | std::cout << i << ":" << primes[i] << " "; 62 | } 63 | 64 | return 0; 65 | } 66 | -------------------------------------------------------------------------------- /Dynamic_Programming/num_str.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given two strings A and B. 3 | * Count num of unique ways in which we can create B 4 | * as a subseq of A 5 | **/ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int num_str(std::string& s1, std::string& s2) 13 | { 14 | int n1 = s1.size(); 15 | int n2 = s2.size(); 16 | 17 | std::vector> dp(n1+1, std::vector(n2+1)); 18 | 19 | dp[0][0] = 1; 20 | for (int i = 1; i <= n1; ++i) 21 | { 22 | dp[i][0] = 1; 23 | } 24 | 25 | for (int j = 1; j <= n2; ++j) 26 | { 27 | dp[0][j] = 0; 28 | } 29 | 30 | for (int i = 1; i <= n1; ++i) 31 | { 32 | for (int j = 1; j <= n2; ++j) 33 | { 34 | if (s1[i-1] != s2[j-1]) 35 | { 36 | dp[i][j] = dp[i-1][j]; 37 | } 38 | else 39 | { 40 | dp[i][j] = dp[i-1][j-1] + dp[i-1][j]; 41 | } 42 | } 43 | } 44 | 45 | return dp[n1][n2]; 46 | } 47 | 48 | int main() 49 | { 50 | #ifndef FILE_INOUT 51 | 52 | freopen("in.txt", "r", stdin); 53 | 54 | freopen("out.txt", "w", stdout); 55 | 56 | #endif 57 | 58 | std::string s1 = "RABBBIT"; 59 | std::string s2 = "RABBIT"; 60 | 61 | std::cout << num_str(s1, s2) << "\n"; 62 | 63 | return 0; 64 | } 65 | -------------------------------------------------------------------------------- /Pattern_Matching/check_pattern_in_text.cpp: -------------------------------------------------------------------------------- 1 | //Given a text of length N and a pattern of length M. 2 | //Check if the pattern exists in the text. (N >> M) 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | bool check_pattern(std::string& pattern, std::string& text) 10 | { 11 | text = pattern + '$' + text; 12 | 13 | int n = text.size(); 14 | int len = 0, i = 1; 15 | std::vector lps(n); 16 | lps[0] = 0; 17 | 18 | while (i < n) 19 | { 20 | if (text[i] == text[len]) 21 | { 22 | lps[i] = ++len; 23 | i++; 24 | 25 | if (len == pattern.size()) 26 | { 27 | return true; 28 | } 29 | } 30 | else 31 | { 32 | if (len != 0) 33 | { 34 | len = lps[len-1]; 35 | } 36 | else 37 | { 38 | lps[i] = 0; 39 | i++; 40 | } 41 | } 42 | } 43 | return false; 44 | } 45 | 46 | int main() 47 | { 48 | #ifndef FILE_INOUT 49 | 50 | freopen("in.txt", "r", stdin); 51 | 52 | freopen("out.txt", "w", stdout); 53 | 54 | #endif 55 | 56 | std::string pattern, text; 57 | std::getline(std::cin, pattern); 58 | std::getline(std::cin, text); 59 | 60 | std::cout << check_pattern(pattern, text) << "\n"; 61 | 62 | return 0; 63 | } 64 | -------------------------------------------------------------------------------- /Binary_Tree/tree_diameter.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Diameter of tree = Length of the longest path b/w any two nodes 3 | * of the tree. 4 | **/ 5 | 6 | /** 7 | * Definition for binary tree 8 | * struct TreeNode { 9 | * int val; 10 | * TreeNode *left; 11 | * TreeNode *right; 12 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 13 | * }; 14 | */ 15 | 16 | class NodeInfo 17 | { 18 | public: 19 | int height; 20 | int diameter; 21 | 22 | NodeInfo(int h, int d) : height(h), 23 | diameter(d) 24 | {} 25 | }; 26 | 27 | int tree_height(TreeNode* A) 28 | { 29 | if (A == NULL) 30 | { 31 | return -1; 32 | } 33 | 34 | return 1 + max(tree_height(A->left), tree_height(A->right)); 35 | } 36 | 37 | NodeInfo tree_diameter(TreeNode* A) 38 | { 39 | if (A == NULL) 40 | { 41 | return NodeInfo(-1, -1); 42 | } 43 | 44 | NodeInfo l = tree_diameter(A->left); 45 | NodeInfo r = tree_diameter(A->right); 46 | 47 | return NodeInfo(max(l.height, r.height)+1, max(max(l.diameter, r.diameter), l.height + r.height + 2)); 48 | } 49 | 50 | int solve(TreeNode* A) { 51 | NodeInfo obj = tree_diameter(A); 52 | return obj.diameter; 53 | } 54 | 55 | -------------------------------------------------------------------------------- /Dynamic_Programming/knapsack_0_infi.cpp: -------------------------------------------------------------------------------- 1 | //A single item can be picked as many times as we want 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int max_value(std::vector& wt, std::vector& val, 9 | int k) 10 | { 11 | int val_sz = val.size(); 12 | 13 | std::vector> dp(val_sz+1, std::vector(k+1, 0)); 14 | 15 | for (int i = 1; i <= val_sz; ++i) 16 | { 17 | for (int j = 1; j <= k; ++j) 18 | { 19 | dp[i][j] = dp[i-1][j]; 20 | 21 | if (j >= wt[i-1]) 22 | { 23 | dp[i][j] = std::max(dp[i][j], dp[i][j-wt[i-1]] + val[i-1]); 24 | } 25 | } 26 | } 27 | 28 | // for (int i = 0; i <= val_sz; ++i) 29 | // { 30 | // for (int j = 0; j <= k; ++j) 31 | // { 32 | // std::cout << dp[i][j] << " "; 33 | // } 34 | // std::cout << "\n"; 35 | // } 36 | return dp[val_sz][k]; 37 | } 38 | 39 | int main() 40 | { 41 | #ifndef FILE_INOUT 42 | 43 | freopen("in.txt", "r", stdin); 44 | 45 | freopen("out.txt", "w", stdout); 46 | 47 | #endif 48 | 49 | std::vector vals = {100, 60, 40, 150}; 50 | std::vector wt = {20, 13, 10, 40}; 51 | int k = 50; 52 | 53 | std::cout << max_value(wt, vals, k) << "\n"; 54 | 55 | return 0; 56 | } 57 | -------------------------------------------------------------------------------- /Array_and_Subarray/Subarray_sum_for_queries.cpp: -------------------------------------------------------------------------------- 1 | //Given an array and Q queries. In every query you get start and end index 2 | //of a subarray. Print the sum of the subarray for every query. 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | std::vector prefix_sum_array(std::vector& vec, int n) 9 | { 10 | std::vector ps(n); 11 | ps[0] = vec[0]; 12 | 13 | for (int i = 1; i < n; ++i) 14 | { 15 | ps[i] = ps[i-1] + vec[i]; 16 | } 17 | 18 | return ps; 19 | } 20 | 21 | int subarray_sum(std::vector& ps, int start, int end) 22 | { 23 | return (ps[end] - ps[start-1]); 24 | } 25 | 26 | int main() 27 | { 28 | #ifndef FILE_INOUT 29 | 30 | freopen("in.txt", "r", stdin); 31 | 32 | freopen("out.txt", "w", stdout); 33 | 34 | #endif 35 | 36 | int n; 37 | std::cin >> n; 38 | 39 | std::vector vec(n); 40 | 41 | for (int i = 0; i < n; ++i) 42 | { 43 | std::cin >> vec[i]; 44 | } 45 | 46 | std::vector ps = prefix_sum_array(vec, n); 47 | 48 | int q; 49 | std::cin >> q; 50 | 51 | while (q--) 52 | { 53 | int s, e; 54 | std::cin >> s >> e; 55 | 56 | std::cout << subarray_sum(ps, s, e) << "\n"; 57 | } 58 | 59 | 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /Array_and_Subarray/Majority_element.cpp: -------------------------------------------------------------------------------- 1 | //Finf majority element in an array which is occurring more than 2 | // n/2 times 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | int majority_element(std::vector& vec, int n) 9 | { 10 | int maj = -1, freq = 0; 11 | 12 | for (int i = 0; i < n; ++i) 13 | { 14 | if (maj == -1) 15 | { 16 | maj = vec[i]; 17 | freq++; 18 | } 19 | else 20 | { 21 | if (vec[i] == maj) 22 | { 23 | freq++; 24 | } 25 | else 26 | { 27 | freq--; 28 | 29 | if (freq == 0) 30 | { 31 | maj = -1; 32 | } 33 | } 34 | } 35 | } 36 | 37 | int count = 0; 38 | 39 | for (int i = 0; i < n; ++i) 40 | { 41 | if (vec[i] == maj) 42 | count++; 43 | } 44 | 45 | if (count > n/2) 46 | return maj; 47 | 48 | return -1; 49 | } 50 | 51 | int main() 52 | { 53 | #ifndef FILE_INOUT 54 | 55 | freopen("in.txt", "r", stdin); 56 | 57 | freopen("out.txt", "w", stdout); 58 | 59 | #endif 60 | 61 | int n; 62 | std::cin >> n; 63 | 64 | std::vector vec(n); 65 | 66 | for (int i = 0; i < n; ++i) 67 | { 68 | std::cin >> vec[i]; 69 | } 70 | 71 | std::cout << majority_element(vec, n) << "\n"; 72 | 73 | return 0; 74 | 75 | } 76 | -------------------------------------------------------------------------------- /Sorting/Heapsort/C++/heapsort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void max_heapify(std::vector& arr, int i, int size_) 6 | { 7 | int largest, l = (2*i) + 1, r = l + 1; 8 | 9 | if(l < size_ && arr[l] > arr[i]) 10 | largest = l; 11 | else 12 | largest = i; 13 | 14 | if(r < size_ && arr[r] > arr[largest]) 15 | largest = r; 16 | 17 | if(largest != i) 18 | { 19 | std::swap(arr[i], arr[largest]); 20 | max_heapify(arr, largest, size_); 21 | } 22 | } 23 | 24 | void build_max_heap(std::vector& arr) 25 | { 26 | for(int i = (arr.size() / 2); i >= 0; i--) 27 | max_heapify(arr, i, arr.size()); 28 | } 29 | 30 | void heap_sort(std::vector& arr) 31 | { 32 | build_max_heap(arr); 33 | int sz = arr.size(); 34 | for(int i = arr.size() - 1; i > 0; i--) 35 | { 36 | std::swap(arr[0], arr[i]); 37 | sz--; 38 | max_heapify(arr, 0, sz); 39 | } 40 | } 41 | 42 | int main() 43 | { 44 | std::vector arr = {4, 1, 3, 2, 16, 9, 10, 14, 8, 7}; 45 | heap_sort(arr); 46 | 47 | for(int i = 0; i < arr.size(); i++) 48 | { 49 | std::cout << arr[i] << " "; 50 | } 51 | std::cout << "\n"; 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /2D_Matrix/Print_RtoL_diagonals.cpp: -------------------------------------------------------------------------------- 1 | //Print all diagonals from Right to Left 2 | //Total diagonals = m + n - 1 3 | 4 | #include 5 | #include 6 | 7 | void print_diag(std::vector< std::vector >& vec, int s_row, int s_col, int rows, int cols) 8 | { 9 | int i = s_row, j = s_col; 10 | 11 | while (i < rows && j >= 0) 12 | { 13 | std::cout << vec[i][j] << " "; 14 | i++; 15 | j--; 16 | } 17 | } 18 | 19 | void diagonals(std::vector< std::vector >& vec, int n, int m) 20 | { 21 | for (int j = 0; j < m; ++j) 22 | { 23 | print_diag(vec, 0, j, n, m); 24 | std::cout << "\n"; 25 | } 26 | 27 | for (int i = 0; i < n; ++i) 28 | { 29 | print_diag(vec, i, m-1, n, m); 30 | std::cout << "\n"; 31 | } 32 | } 33 | 34 | int main() 35 | { 36 | #ifndef FILE_INOUT 37 | 38 | freopen("in.txt", "r", stdin); 39 | 40 | freopen("out.txt", "w", stdout); 41 | 42 | #endif 43 | 44 | int rows, cols; 45 | std::cin >> rows >> cols; 46 | 47 | std::vector< std::vector > vec(rows, std::vector(cols)); 48 | 49 | for (int i = 0; i < rows; ++i) 50 | { 51 | for (int j = 0; j < cols; ++j) 52 | { 53 | std::cin >> vec[i][j]; 54 | } 55 | } 56 | 57 | diagonals(vec, rows, cols); 58 | 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /Hashing/longest_consecutive_seq.cpp: -------------------------------------------------------------------------------- 1 | //Find the length of the longest set of consecutive elements 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int consecutive_seq(std::vector& vec) 12 | { 13 | std::set st; 14 | int mx = INT_MIN; 15 | 16 | for (int x : vec) 17 | { 18 | st.insert(x); 19 | } 20 | 21 | for (int x : vec) 22 | { 23 | if (st.find(x-1) == st.end()) 24 | { 25 | int ans = 0; 26 | int v = x; 27 | 28 | while (st.find(v) != st.end()) 29 | { 30 | v++; 31 | ans++; 32 | } 33 | mx = std::max(mx, ans); 34 | } 35 | } 36 | return mx; 37 | } 38 | 39 | int main() 40 | { 41 | #ifndef FILE_INOUT 42 | 43 | freopen("in.txt", "r", stdin); 44 | 45 | freopen("out.txt", "w", stdout); 46 | 47 | #endif 48 | 49 | std::string input; 50 | std::getline(std::cin, input); 51 | 52 | std::vector vec; 53 | 54 | std::stringstream ss(input); 55 | 56 | for (int i; ss >> i;) 57 | { 58 | if (ss.peek() == ',' || ss.peek() == ' ') 59 | ss.ignore(); 60 | 61 | vec.push_back(i); 62 | } 63 | 64 | std::cout << consecutive_seq(vec) << "\n"; 65 | 66 | return 0; 67 | } 68 | -------------------------------------------------------------------------------- /Sorting according to Frequency of Elements/C++/sortacctofreq.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | struct greater 7 | { 8 | template 9 | bool operator()(T const &a, T const &b) const { return a.second > b.second; } 10 | }; 11 | 12 | template 13 | void printSortByFreq(std::vector& v) 14 | { 15 | std::map count; 16 | 17 | for (T x : v){ 18 | count[x]++; 19 | } 20 | 21 | std::vector> mapcopy; 22 | 23 | for(auto itr = count.begin(); itr != count.end(); itr++) 24 | { 25 | mapcopy.push_back(*itr); 26 | } 27 | 28 | std::sort(mapcopy.begin(), mapcopy.end(), greater()); 29 | 30 | std::cout << "Elements sorted according to Frequency \n"; 31 | 32 | auto itr = mapcopy.begin(); 33 | while(itr != mapcopy.end()) 34 | { 35 | for(size_t i = 0; i < itr->second; i++) 36 | { 37 | std::cout << itr->first <<" "; 38 | } 39 | itr++; 40 | } 41 | std::cout<<"\n"; 42 | } 43 | 44 | int main() 45 | { 46 | std::vector vec = {2, 3, 2, 4, 5, 12, 12, 3, 4, 3}; 47 | printSortByFreq(vec); 48 | std::vector c = { 'e', 't', 'r', 'e', 't', 't', 'f'}; 49 | printSortByFreq(c); 50 | return 0; 51 | } 52 | -------------------------------------------------------------------------------- /Sorting/Quick Sort/C++/quicksort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int rearrange(std::vector& arr, int l, int r) 7 | { 8 | int p1 = l+1, p2 = r; 9 | 10 | while (p1 <= p2) 11 | { 12 | if (arr[p1] <= arr[l]) 13 | { 14 | p1++; 15 | } 16 | else if (arr[p2] > arr[l]) 17 | { 18 | p2--; 19 | } 20 | else 21 | { 22 | std::swap(arr[p1], arr[p2]); 23 | p1++; 24 | p2--; 25 | } 26 | } 27 | std::swap(arr[l], arr[p1-1]); 28 | return p1-1; 29 | } 30 | 31 | void quick_sort(std::vector& arr, int l, int r) 32 | { 33 | if (l >= r) 34 | return; 35 | 36 | int index = rearrange(arr, l, r); 37 | quick_sort(arr, l, index-1); 38 | quick_sort(arr, index+1, r); 39 | } 40 | 41 | int main() 42 | { 43 | #ifndef FILE_INOUT 44 | 45 | freopen("in.txt", "r", stdin); 46 | 47 | freopen("out.txt", "w", stdout); 48 | 49 | #endif 50 | 51 | int n; 52 | std::cin >> n; 53 | 54 | std::vector vec(n); 55 | for (int i = 0; i < n; ++i) 56 | { 57 | std::cin >> vec[i]; 58 | } 59 | 60 | quick_sort(vec, 0, n-1); 61 | 62 | for (int i = 0; i < n; ++i) 63 | { 64 | std::cout << vec[i] <<" "; 65 | } 66 | std::cout << "\n"; 67 | return 0; 68 | } 69 | -------------------------------------------------------------------------------- /Dynamic_Programming/coin_change_problem.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given N coins and a sum K 3 | * Find number of ways to form the sum K if one coin can be 4 | * picke at most once. (0/1) 5 | **/ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int num_ways(std::vector& coins, int k) 13 | { 14 | int n = coins.size(); 15 | std::vector> dp(n+1, std::vector(k+1, 0)); 16 | 17 | for (int i = 0; i <= n; ++i) 18 | { 19 | dp[i][0] = 1; 20 | } 21 | 22 | for (int i = 1; i <= n; ++i) 23 | { 24 | for (int j = 1; j <= k; ++j) 25 | { 26 | int ans = dp[i-1][j]; //skip 27 | 28 | if (j >= coins[i-1]) 29 | { 30 | ans += dp[i-1][j-coins[i-1]]; //pick 31 | } 32 | dp[i][j] = ans; 33 | } 34 | } 35 | 36 | for (int i = 0; i <= n; ++i) 37 | { 38 | for (int j = 0; j <= k; ++j) 39 | { 40 | std::cout << dp[i][j] << " "; 41 | } 42 | std::cout << "\n"; 43 | } 44 | 45 | return dp[n][k]; 46 | } 47 | 48 | int main() 49 | { 50 | #ifndef FILE_INOUT 51 | 52 | freopen("in.txt", "r", stdin); 53 | 54 | freopen("out.txt", "w", stdout); 55 | 56 | #endif 57 | 58 | std::vector coins = {1, 2, 3, 6, 7}; 59 | int k = 10; 60 | 61 | std::cout << num_ways(coins, k) << "\n"; 62 | 63 | return 0; 64 | } 65 | -------------------------------------------------------------------------------- /2D_Matrix/Rotate_by_90.cpp: -------------------------------------------------------------------------------- 1 | //Given a square matrix. Rotate it by 90 degree in clockwise direction 2 | // without using any extra space. 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | void rotate_90(std::vector< std::vector >& vec, int n) 9 | { 10 | int l = 0, r = n-1; 11 | 12 | while (l <= r) 13 | { 14 | int t = l, b = r; 15 | 16 | for (int i = t; i < b; ++i) 17 | { 18 | int tmp = vec[t][l+i]; 19 | vec[t][l+i] = vec[b-i][l]; 20 | vec[b-i][l] = vec[b][r-i]; 21 | vec[b][r-i] = vec[t+i][r]; 22 | vec[t+i][r] = tmp; 23 | } 24 | l++; 25 | r--; 26 | } 27 | } 28 | 29 | int main() 30 | { 31 | #ifndef FILE_INOUT 32 | 33 | freopen("in.txt", "r", stdin); 34 | 35 | freopen("out.txt", "w", stdout); 36 | 37 | #endif 38 | 39 | int n; 40 | std::cin >> n; 41 | 42 | std::vector< std::vector > vec(n, std::vector(n)); 43 | 44 | for (int i = 0; i < n; ++i) 45 | { 46 | for (int j = 0; j < n; ++j) 47 | { 48 | std::cin >> vec[i][j]; 49 | } 50 | } 51 | 52 | rotate_90(vec, n); 53 | 54 | for (int i = 0; i < n; ++i) 55 | { 56 | for (int j = 0; j < n; ++j) 57 | { 58 | std::cout << vec[i][j] << " "; 59 | } 60 | std::cout << "\n"; 61 | } 62 | 63 | return 0; 64 | 65 | } 66 | -------------------------------------------------------------------------------- /Binary_Tree/construct_tree.cpp: -------------------------------------------------------------------------------- 1 | //Given the preorder and inorder traversal of a tree with no duplicates. 2 | //Contruct the tree 3 | 4 | //Map node's valuw with its index using preorder vector 5 | std::unordered_map map_value_index(std::vector& preorder) 6 | { 7 | std::unordered_mapum; 8 | 9 | for (int i = 0; i < preorder.size(); ++i) 10 | { 11 | um.insert({ preorder[i], i}); 12 | } 13 | } 14 | 15 | TreeNode* build_tree(std::unordered_map& um, 16 | std::vector& inorder, int start_in, int end_in, 17 | std::vector& preorder, int start_pre, int end_pre) 18 | { 19 | if (start_in > end_in || start_pre > end_pre) 20 | { 21 | return NULL; 22 | } 23 | 24 | TreeNode* root = new TreeNode(preorder[start_pre]); 25 | int idx = um[preorder[start_pre]]; 26 | int x = idx = start_in; 27 | 28 | root->left = build_tree(um, inorder, start_in, idx-1, 29 | preorder, start_pre+1, start_pre+x); 30 | 31 | root->right = build_tree(um, inorder, idx+1, end_in, 32 | preorder, start_pre+x+1, end_pre); 33 | 34 | return root; 35 | } 36 | 37 | TreeNode* solve(std::vector& inorder, std::vector& preorder) 38 | { 39 | std::unordered_map preorde_val_idx = map_value_index(preorder); 40 | 41 | return build_tree(um, inorder, 0, inorder.size()-1, 42 | preorder, 0, preorder.size()-1); 43 | } 44 | -------------------------------------------------------------------------------- /Graph_Algorithms/Depth First Seacrh/num_connected_components.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void dfs(int u, std::vector>& adj_list, std::vector& visited) 7 | { 8 | visited[u] = 1; 9 | auto v = adj_list[u]; 10 | for (int x : v) 11 | { 12 | x = x-1; 13 | if (visited[x] == 0) 14 | { 15 | dfs(x, adj_list, visited); 16 | } 17 | } 18 | } 19 | 20 | int num_connected_components(std::vector>& adj_list) 21 | { 22 | int connected = 0; 23 | std::vector visited(adj_list.size(), 0); 24 | for (int i = 0; i < adj_list.size(); ++i) 25 | { 26 | int u = i; // vertex; 27 | if (visited[u] == 0) 28 | { 29 | connected++; 30 | dfs(u, adj_list, visited); 31 | } 32 | } 33 | return connected; 34 | } 35 | 36 | int main() 37 | { 38 | #ifndef FILE_INOUT 39 | 40 | freopen("in.txt", "r", stdin); 41 | 42 | freopen("out.txt", "w", stdout); 43 | 44 | #endif 45 | 46 | std::vector> adj_list = {{2, 4}, 47 | {1, 3}, 48 | {2, 4}, 49 | {1, 3}, 50 | {6}, 51 | {5}, 52 | {8}, 53 | {7, 9, 10}, 54 | {8}, 55 | {8}, 56 | {}}; 57 | std::cout << num_connected_components(adj_list) << "\n"; 58 | 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /Graph_Algorithms/topological_sort.cpp: -------------------------------------------------------------------------------- 1 | vector solve(int A, vector > &B) { 2 | map indegree; 3 | 4 | vector> adj_list; 5 | adj_list.resize(A+1); 6 | 7 | for (int i = 1; i <= A; ++i) 8 | { 9 | indegree.insert({i, 0}); 10 | } 11 | 12 | for (int i = 0; i < B.size(); ++i) 13 | { 14 | adj_list[B[i][0]].push_back(B[i][1]); 15 | indegree[B[i][1]]++; 16 | } 17 | vector ans; 18 | priority_queue, greater> q; 19 | 20 | for (auto [k, v] : indegree) 21 | { 22 | if (v == 0) 23 | { 24 | q.push(k); 25 | } 26 | } 27 | 28 | while (!q.empty()) 29 | { 30 | int u = q.top(); 31 | 32 | if (indegree[u] == 0) 33 | { 34 | ans.push_back(u); 35 | } 36 | 37 | q.pop(); 38 | vector arr; 39 | 40 | for (int v : adj_list[u]) 41 | { 42 | if (indegree[v] > 0) 43 | { 44 | indegree[v]--; 45 | if (indegree[v] == 0) 46 | { 47 | arr.push_back(v); 48 | } 49 | } 50 | } 51 | sort(arr.begin(), arr.end()); 52 | for (int x : arr) 53 | { 54 | q.push(x); 55 | } 56 | } 57 | return ans; 58 | } 59 | -------------------------------------------------------------------------------- /Dynamic_Programming/wildcard_match.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int match_str(std::string& s1, std::string& s2) 7 | { 8 | int n1 = s1.size(); 9 | int n2 = s2.size(); 10 | 11 | std::vector> dp(n1+1, std::vector(n2+1)); 12 | dp[0][0] = true; 13 | 14 | for (int i = 1; i <= n1; ++i) 15 | { 16 | dp[i][0] = false; 17 | } 18 | 19 | for (int j = 1; j <= n2; ++j) 20 | { 21 | if (s2[j-1] == '*') 22 | { 23 | dp[0][j] = dp[0][j-1]; 24 | } 25 | else 26 | { 27 | dp[0][j] = false; 28 | } 29 | } 30 | 31 | for (int i = 1; i <= n1; ++i) 32 | { 33 | for (int j = 1; j <= n2; ++j) 34 | { 35 | if (s2[j-1] >= 'a' && s2[j-1] <= 'z') 36 | { 37 | if (s1[i-1] == s2[j-1]) 38 | { 39 | dp[i][j] = dp[i-1][j-1]; 40 | } 41 | } 42 | else if (s2[j-1] == '?') 43 | { 44 | dp[i][j] = dp[i-1][j-1]; 45 | } 46 | else if (s2[j-1] == '*') 47 | { 48 | dp[i][j] = (dp[i-1][j] || dp[i][j-1]); 49 | } 50 | } 51 | } 52 | return dp[n1][n2]; 53 | } 54 | 55 | int main() 56 | { 57 | #ifndef FILE_INOUT 58 | 59 | freopen("in.txt", "r", stdin); 60 | 61 | freopen("out.txt", "w", stdout); 62 | 63 | #endif 64 | 65 | std::string s1 = "aaabbasdfadfdb"; 66 | std::string s2 = "a*b"; 67 | 68 | std::cout << match_str(s1, s2) << "\n"; 69 | 70 | return 0; 71 | } 72 | -------------------------------------------------------------------------------- /Heaps/nearly_sorted_array.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given a nearly sorted array. Sort the array. 3 | * k-sorted : every element is atmost k positions away from 4 | * its sorted position 5 | **/ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | std::vector sort_array(std::vector& vec, int k) 13 | { 14 | std::priority_queue, std::greater> min_heap; 15 | std::vector res; 16 | 17 | for (int i = 0; i <= k; ++i) 18 | { 19 | min_heap.push(vec[i]); 20 | } 21 | res.push_back(min_heap.top()); 22 | min_heap.pop(); 23 | 24 | for (int i = k+1; i < vec.size(); ++i) 25 | { 26 | min_heap.push(vec[i]); 27 | res.push_back(min_heap.top()); 28 | min_heap.pop(); 29 | } 30 | 31 | 32 | while (!min_heap.empty()) 33 | { 34 | res.push_back(min_heap.top()); 35 | min_heap.pop(); 36 | } 37 | return res; 38 | } 39 | 40 | int main() 41 | { 42 | #ifndef FILE_INOUT 43 | 44 | freopen("in.txt", "r", stdin); 45 | 46 | freopen("out.txt", "w", stdout); 47 | 48 | #endif 49 | 50 | int n, k; 51 | std::cin >> n >> k; 52 | 53 | std::vector vec(n); 54 | for (int i = 0; i < n; ++i) 55 | { 56 | std::cin >> vec[i]; 57 | } 58 | 59 | std::vector res = sort_array(vec, k); 60 | 61 | for (int x : res) 62 | { 63 | std::cout << x << " "; 64 | } 65 | 66 | return 0; 67 | } 68 | -------------------------------------------------------------------------------- /Binary_Search/find_freq.cpp: -------------------------------------------------------------------------------- 1 | //Given sorted array in ascending order. Find freq of 2 | //given target k. 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | int find_freq(std::vector& arr, int n, int k) 10 | { 11 | int f = -1, lst = -1; 12 | 13 | //finding first occurrence 14 | int l = 0, r = n-1; 15 | 16 | while (l <= r) 17 | { 18 | int mid = (l+r)/2; 19 | 20 | if (arr[mid] == k) 21 | { 22 | f = mid; 23 | r = mid - 1; 24 | } 25 | else if (arr[mid] < k) 26 | { 27 | l = mid + 1; 28 | } 29 | else 30 | { 31 | r = mid - 1; 32 | } 33 | } 34 | 35 | //finding last occurrence 36 | l = f, r = n-1; 37 | 38 | while (l <= r) 39 | { 40 | int mid = (l+r)/2; 41 | 42 | if (arr[mid] == k) 43 | { 44 | lst = mid; 45 | l = mid + 1; 46 | } 47 | else if (arr[mid] < k) 48 | { 49 | l = mid + 1; 50 | } 51 | else 52 | { 53 | r = mid - 1; 54 | } 55 | } 56 | 57 | return (lst - f + 1); 58 | } 59 | 60 | int main() 61 | { 62 | #ifndef FILE_INOUT 63 | 64 | freopen("in.txt", "r", stdin); 65 | 66 | freopen("out.txt", "w", stdout); 67 | 68 | #endif 69 | 70 | int n; 71 | std::cin >> n; 72 | 73 | std::vector vec(n); 74 | for (int i = 0; i < n; ++i) 75 | { 76 | std::cin >> vec[i]; 77 | } 78 | 79 | std::cout << find_freq(vec, n, 7); 80 | 81 | return 0; 82 | } 83 | -------------------------------------------------------------------------------- /Dynamic_Programming/decode_ways.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int decode_ways(std::string& str) 7 | { 8 | int n = str.size(); 9 | std::vector dp(n, 0); 10 | 11 | if (str[0]-'0' > 0) 12 | { 13 | dp[0] = 1; 14 | } 15 | else 16 | { 17 | dp[0] = 0; 18 | } 19 | 20 | int num = ((str[0]-'0') * 10) + ((str[1]-'0')); 21 | 22 | if (num >= 10 && num <= 26) 23 | { 24 | dp[1] = dp[0]+1; 25 | } 26 | else 27 | { 28 | dp[1] = dp[0]; 29 | } 30 | 31 | for (int i = 2; i < n; ++i) 32 | { 33 | num = ((str[i-1]-'0') * 10) + ((str[i]-'0')); 34 | dp[i] = dp[i-1]; 35 | if (str[i] != '0') 36 | { 37 | if (num >= 10 && num <= 26) 38 | { 39 | dp[i] += dp[i-2]; 40 | } 41 | } 42 | else 43 | { 44 | if (num >= 10 && num <= 26) 45 | { 46 | dp[i] += dp[i-2]; 47 | } 48 | // else if (str[i-1] == '0' || str[i-1] > '2') 49 | // { 50 | // dp[i] += dp[i-1]; 51 | // } 52 | } 53 | } 54 | 55 | // for (int x : dp) 56 | // { 57 | // std::cout << x << " "; 58 | // } 59 | // std::cout << "\n"; 60 | return dp[n-1]; 61 | } 62 | 63 | int main() 64 | { 65 | #ifndef FILE_INOUT 66 | 67 | freopen("in.txt", "r", stdin); 68 | 69 | freopen("out.txt", "w", stdout); 70 | 71 | #endif 72 | 73 | std::string str = "173"; 74 | std::cout << decode_ways(str) <<"\n"; 75 | 76 | return 0; 77 | } 78 | -------------------------------------------------------------------------------- /Binary_Search/max_len_k.cpp: -------------------------------------------------------------------------------- 1 | //Given an array of positive numbers. Find maximum length K, 2 | //such that there is no subarray of length K with sum >= B 3 | 4 | //All subarrays of length K have sum < B 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | bool check_sum(std::vector& arr, int n, int k, int B) 12 | { 13 | int sum = 0; 14 | for (int i = 0; i < k; ++i) 15 | { 16 | sum += arr[i]; 17 | } 18 | 19 | if (sum >= B) 20 | return false; 21 | 22 | for (int i = k; i < n; ++i) 23 | { 24 | sum += arr[i]; 25 | sum -= arr[i-k]; 26 | 27 | if (sum >= B) 28 | return false; 29 | } 30 | return true; 31 | } 32 | 33 | int max_len(std::vector& arr, int n, int B) 34 | { 35 | int l = 0, r = n-1; 36 | int ans; 37 | 38 | while (l <= r) 39 | { 40 | int mid = (l+r)/2; 41 | 42 | if (check_sum(arr, n, mid, B)) 43 | { 44 | ans = mid; 45 | l = mid+1; 46 | } 47 | else 48 | { 49 | r = mid-1; 50 | } 51 | } 52 | return ans; 53 | } 54 | 55 | int main() 56 | { 57 | #ifndef FILE_INOUT 58 | 59 | freopen("in.txt", "r", stdin); 60 | 61 | freopen("out.txt", "w", stdout); 62 | 63 | #endif 64 | 65 | int n; 66 | std::cin >> n; 67 | 68 | std::vector vec(n); 69 | for (int i = 0; i < n; ++i) 70 | { 71 | std::cin >> vec[i]; 72 | } 73 | 74 | std::cout << max_len(vec, n, 20); 75 | 76 | return 0; 77 | } 78 | -------------------------------------------------------------------------------- /Binary_Search/kth_pos_element.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given an unsorted array. Find kth position element if it was 3 | * sorted. 4 | * No modification of array and no extra space. 5 | **/ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int count_smaller(std::vector&vec, int n, int mid) 13 | { 14 | int count = 0; 15 | 16 | for (int i = 0; i < n; ++i) 17 | { 18 | if (vec[i] < mid) 19 | { 20 | count++; 21 | } 22 | } 23 | return count; 24 | } 25 | 26 | int k_pos_element(std::vector&vec, int n, int k) 27 | { 28 | int low = *std::min_element(vec.begin(), vec.end()); 29 | int high = *std::max_element(vec.begin(), vec.end()); 30 | int ans = -1; 31 | 32 | while (low <= high) 33 | { 34 | int mid = (low + high)/2; 35 | 36 | int count = count_smaller(vec, n, mid); 37 | 38 | if (count <= k) 39 | { 40 | ans = mid; 41 | low = mid + 1; 42 | } 43 | else 44 | { 45 | high = mid - 1; 46 | } 47 | } 48 | return ans; 49 | } 50 | 51 | int main() 52 | { 53 | #ifndef FILE_INOUT 54 | 55 | freopen("in.txt", "r", stdin); 56 | 57 | freopen("out.txt", "w", stdout); 58 | 59 | #endif 60 | 61 | int n, k; 62 | std::cin >> n >> k; 63 | 64 | std::vector vec(n); 65 | 66 | for (int i = 0; i < n; ++i) 67 | { 68 | std::cin >> vec[i]; 69 | } 70 | 71 | std::cout << k_pos_element(vec, n, k) << "\n"; 72 | 73 | return 0; 74 | } 75 | -------------------------------------------------------------------------------- /Binary_Search/index_sorted_rotated_arr.cpp: -------------------------------------------------------------------------------- 1 | //Given array of distinct elements which is sorted then rotated. 2 | //Find index of target K in this array 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | int target_index(std::vector& arr, int n, int k) 10 | { 11 | if (arr[0] == k) 12 | return 0; 13 | 14 | int l = 0, r = n-1; 15 | 16 | 17 | while (l <= r) 18 | { 19 | int mid = (l+r)/2; 20 | 21 | if (k > arr[0]) // element in left side 22 | { 23 | if (arr[mid] >= arr[0]) 24 | { 25 | if (arr[mid] == k) 26 | return mid; 27 | else if (arr[mid] > k) 28 | r = mid - 1; 29 | else 30 | l = mid + 1; 31 | } 32 | else 33 | { 34 | r = mid - 1; 35 | } 36 | } 37 | else 38 | { 39 | if (arr[mid] < arr[0]) 40 | { 41 | if (arr[mid] == k) 42 | return mid; 43 | else if (arr[mid] > k) 44 | r = mid - 1; 45 | else 46 | l = mid + 1; 47 | } 48 | else 49 | { 50 | l = mid + 1; 51 | } 52 | } 53 | } 54 | } 55 | 56 | int main() 57 | { 58 | #ifndef FILE_INOUT 59 | 60 | freopen("in.txt", "r", stdin); 61 | 62 | freopen("out.txt", "w", stdout); 63 | 64 | #endif 65 | 66 | int n; 67 | std::cin >> n; 68 | 69 | std::vector vec(n); 70 | for (int i = 0; i < n; ++i) 71 | { 72 | std::cin >> vec[i]; 73 | } 74 | 75 | std::cout << target_index(vec, n, 5); 76 | 77 | return 0; 78 | } 79 | -------------------------------------------------------------------------------- /Binary_Tree/num_node_at_k.cpp: -------------------------------------------------------------------------------- 1 | //Calculate number of nodes a a distance k from source node 2 | 3 | bool add_path(vector& path, TreeNode* root, int v) 4 | { 5 | if (root == NULL) 6 | { 7 | return false; 8 | } 9 | 10 | if (root->val == v) 11 | { 12 | path.push_back(root); 13 | return true; 14 | } 15 | 16 | if (add_path(path, root->left, v) || add_path(path, root->right, v)) 17 | { 18 | path.push_back(root); 19 | return true; 20 | } 21 | return false; 22 | } 23 | 24 | int below_nodes_at_k(TreeNode* node, int k) 25 | { 26 | if (node == NULL || k < 0) 27 | { 28 | return 0; 29 | } 30 | 31 | if (k == 0) 32 | { 33 | return 1; 34 | } 35 | 36 | int l = below_nodes_at_k(node->left, k-1); 37 | int r = below_nodes_at_k(node->right, k-1); 38 | 39 | return l+r; 40 | } 41 | 42 | int count_all(TreeNode* root, int v, int k) 43 | { 44 | //calculate path from given node to root node 45 | vector path; 46 | bool res = add_path(path, root, v); 47 | 48 | int count = below_nodes_at_k(path[0], k); 49 | 50 | for (int i = 1; i < path.size(); ++i) 51 | { 52 | //curr node path[i] and child node path[i-1] 53 | if (path[i]->left == path[i-1]) 54 | { 55 | //goto right and search 56 | count = count + below_nodes_at_k(path[i]->right, k-i-1); 57 | } 58 | else 59 | { 60 | //goto left and search 61 | count = count + below_nodes_at_k(path[i]->left, k-i-1); 62 | } 63 | } 64 | 65 | return count; 66 | } 67 | 68 | //TC O(N) 69 | //SC O(H) 70 | -------------------------------------------------------------------------------- /Dynamic_Programming/eq_array_parti.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given an array of N elements. Count the number of ways 3 | * of dividing all the elements into 2 subsets such that 4 | * the sum is same 5 | **/ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int num_ways(std::vector& arr) 13 | { 14 | int n = arr.size(); 15 | int tot_sum = 0; 16 | 17 | for (int x : arr) 18 | { 19 | tot_sum += x; 20 | } 21 | 22 | if (tot_sum % 2) 23 | { 24 | return 0; 25 | } 26 | 27 | int k = tot_sum/2; 28 | 29 | std::vector> dp(n+1, std::vector(k+1, 0)); 30 | 31 | for (int i = 0; i <= n; ++i) 32 | { 33 | dp[i][0] = 1; 34 | } 35 | 36 | for (int i = 1; i <= n; ++i) 37 | { 38 | for (int j = 1; j <= k; ++j) 39 | { 40 | int ans = dp[i-1][j]; //skip 41 | 42 | if (j >= arr[i-1]) 43 | { 44 | ans += dp[i-1][j-arr[i-1]]; //pick 45 | } 46 | dp[i][j] = ans; 47 | } 48 | } 49 | 50 | // for (int i = 0; i <= n; ++i) 51 | // { 52 | // for (int j = 0; j <= k; ++j) 53 | // { 54 | // std::cout << dp[i][j] << " "; 55 | // } 56 | // std::cout << "\n"; 57 | // } 58 | 59 | return dp[n][k]/2; 60 | } 61 | 62 | int main() 63 | { 64 | #ifndef FILE_INOUT 65 | 66 | freopen("in.txt", "r", stdin); 67 | 68 | freopen("out.txt", "w", stdout); 69 | 70 | #endif 71 | 72 | std::vector arr = {1, 5, 3, 6, 9, 2}; 73 | 74 | std::cout << num_ways(arr) << "\n"; 75 | 76 | return 0; 77 | } 78 | -------------------------------------------------------------------------------- /Stack/stack_using_array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define max 1000 4 | class Stack 5 | { 6 | int top; 7 | 8 | public: 9 | int a[max]; 10 | Stack() 11 | { 12 | top=-1; 13 | } 14 | bool stack_empty(); 15 | void push(int x); 16 | int pop(); 17 | void display(); 18 | }; 19 | 20 | bool Stack::stack_empty() 21 | { 22 | if(top == -1) 23 | return true; 24 | else 25 | return false; 26 | } 27 | 28 | void Stack::push(int x) 29 | { 30 | int s = max-1; 31 | if(top < s) 32 | { 33 | top = top+1; 34 | a[top] = x; 35 | } 36 | else 37 | std::cout << "overflow" << "\n"; 38 | } 39 | 40 | int Stack::pop() 41 | { 42 | if (stack_empty()) 43 | { 44 | std::cout << "Underflow" << "\n"; 45 | } 46 | else 47 | { 48 | --top; 49 | return a[top + 1]; 50 | } 51 | } 52 | 53 | void Stack::display() 54 | { 55 | for(int i = top; i >= 0; i--) 56 | { 57 | std::cout << a[i] << " "; 58 | } 59 | } 60 | 61 | int main() 62 | { 63 | #ifndef FILE_INOUT 64 | 65 | freopen("in.txt", "r", stdin); 66 | 67 | freopen("out.txt", "w", stdout); 68 | 69 | #endif 70 | 71 | Stack stack1; 72 | stack1.push(15); 73 | stack1.push(6); 74 | stack1.push(2); 75 | stack1.push(9); 76 | stack1.push(3); 77 | stack1.display(); 78 | std::cout<<"\n"; 79 | std::cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | std::vector> subsets(std::vector& vec) 8 | { 9 | std::vector> res; 10 | int n = vec.size(); 11 | for (int i = 0; i < (1< sub; 14 | for (int j = 0; j < n; ++j) 15 | { 16 | if ((i & (1< vec; 40 | 41 | for (int i; ss >> i;) 42 | { 43 | if (ss.peek() == ',' || ss.peek() == ' ') 44 | ss.ignore(); 45 | 46 | vec.push_back(i); 47 | } 48 | 49 | // for (int i = 0; i < vec.size(); ++i) 50 | // { 51 | // std::cout << vec[i] <<" "; 52 | // } 53 | 54 | auto res = subsets(vec); 55 | 56 | for (int i = 0; i < res.size(); ++i) 57 | { 58 | for (int j = 0; j < res[i].size(); ++j) 59 | { 60 | std::cout << res[i][j] << " "; 61 | } 62 | std::cout << "\n"; 63 | } 64 | 65 | return 0; 66 | 67 | } 68 | -------------------------------------------------------------------------------- /Dynamic_Programming/convert_str.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Givwn two strings s1 and s2 3 | * Convert s1 to s2 in minimum cost. 4 | * The operations can be performed on s1 5 | * insert - cost : i 6 | * delete - cost : d 7 | * update - cost : u 8 | **/ 9 | 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | int convert_cost(std::string& s1, std::string& s2, int insert, int dlt, int update) 16 | { 17 | int n1 = s1.size(); 18 | int n2 = s2.size(); 19 | 20 | std::vector> dp(n1+1, std::vector(n2+1)); 21 | dp[0][0] = 0; 22 | 23 | for (int i = 1; i <= n1; ++i) 24 | { 25 | dp[i][0] = dp[i-1][0] + dlt; 26 | } 27 | 28 | for (int j = 1; j <= n2; ++j) 29 | { 30 | dp[0][j] = dp[0][j-1] + insert; 31 | } 32 | 33 | for (int i = 1; i <= n1; ++i) 34 | { 35 | for (int j = 1; j <= n2; ++j) 36 | { 37 | if (s1[i-1] == s2[j-1]) 38 | { 39 | dp[i][j] = dp[i-1][j-1]; 40 | } 41 | else 42 | { 43 | dp[i][j] = std::min(std::min(dlt + dp[i-1][j], insert + dp[i][j-1]), 44 | update + dp[i-1][j-1]); 45 | } 46 | } 47 | } 48 | return dp[n1][n2]; 49 | } 50 | 51 | int main() 52 | { 53 | #ifndef FILE_INOUT 54 | 55 | freopen("in.txt", "r", stdin); 56 | 57 | freopen("out.txt", "w", stdout); 58 | 59 | #endif 60 | 61 | std::string s1 = "abcd"; 62 | std::string s2 = "abe"; 63 | int insert = 2, dlt = 2, update = 3; 64 | 65 | std::cout << convert_cost(s1, s2, insert, dlt, update) << "\n"; 66 | 67 | return 0; 68 | } 69 | -------------------------------------------------------------------------------- /Sorting/inversion_count.cpp: -------------------------------------------------------------------------------- 1 | //Find total pairs (i, j) such that i < j && A[i] > A[j] 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int merge(std::vector& vec, int l, int y, int r) 9 | { 10 | int a = l; 11 | int b = y; 12 | int c = 0, count = 0; 13 | std::vector tmp(r-l+1); 14 | 15 | while (a < y && b <= r) 16 | { 17 | if (vec[a] <= vec[b]) 18 | { 19 | tmp[c++] = vec[a++]; 20 | } 21 | else 22 | { 23 | tmp[c++] = vec[b++]; 24 | count = count + (y - a); 25 | } 26 | } 27 | 28 | while (a < y) 29 | tmp[c++] = vec[a++]; 30 | 31 | while (b <= r) 32 | tmp[c++] = vec[b++]; 33 | 34 | c = 0; 35 | for (int i = l; i <= r; ++i) 36 | vec[i] = tmp[c++]; 37 | 38 | return count; 39 | } 40 | 41 | int inversion_count(std::vector& vec, int l, int r) 42 | { 43 | 44 | if (l < r) 45 | { 46 | int mid = (l+r)/2; 47 | 48 | int x = inversion_count(vec, l, mid); 49 | int y = inversion_count(vec, mid+1, r); 50 | int z = merge(vec, l, mid+1, r); 51 | 52 | return x+y+z; 53 | } 54 | 55 | return 0; 56 | } 57 | 58 | int main() 59 | { 60 | #ifndef FILE_INOUT 61 | 62 | freopen("in.txt", "r", stdin); 63 | 64 | freopen("out.txt", "w", stdout); 65 | 66 | #endif 67 | 68 | int n; 69 | std::cin >> n; 70 | 71 | std::vector vec(n); 72 | 73 | for (int i = 0; i < n; ++i) 74 | { 75 | std::cin >> vec[i]; 76 | } 77 | 78 | std::cout << inversion_count(vec, 0, n-1) << "\n"; 79 | 80 | return 0; 81 | } 82 | -------------------------------------------------------------------------------- /Hashing/subarray_sum_0.cpp: -------------------------------------------------------------------------------- 1 | //Return number of subarrays with sum = 0 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int subarrays_0_sum(std::vector& vec, int n) 9 | { 10 | int count0 = 0; 11 | std::vector ps(n); 12 | std::unordered_map um; 13 | 14 | ps[0] = vec[0]; 15 | 16 | um.insert({ps[0], 1}); 17 | 18 | for (int i = 1; i < n; ++i) 19 | { 20 | ps[i] = ps[i-1] + vec[i]; 21 | 22 | if (vec[i] == 0) 23 | { 24 | count0++; 25 | } 26 | 27 | if (um.find(ps[i]) != um.end()) 28 | { 29 | um[ps[i]]++; 30 | } 31 | else 32 | { 33 | um.insert({ps[i], 1}); 34 | } 35 | } 36 | 37 | for (auto it : um) 38 | { 39 | if (it.first == 0) 40 | count0 += it.second; 41 | else 42 | { 43 | if (it.second > 1) 44 | { 45 | count0 += (it.second/2); 46 | } 47 | } 48 | } 49 | 50 | return count0; 51 | } 52 | 53 | int main() 54 | { 55 | #ifndef FILE_INOUT 56 | 57 | freopen("in.txt", "r", stdin); 58 | 59 | freopen("out.txt", "w", stdout); 60 | 61 | #endif 62 | 63 | int n; 64 | std::cin >> n; 65 | 66 | std::vector vec(n); 67 | for (int i = 0; i < n; ++i) 68 | { 69 | std::cin >> vec[i]; 70 | } 71 | 72 | std::cout << subarrays_0_sum(vec, n) << "\n"; 73 | 74 | return 0; 75 | 76 | } 77 | -------------------------------------------------------------------------------- /Binary_Search/maximize_min_dist.cpp: -------------------------------------------------------------------------------- 1 | //Given an arry having positions of rooms where we can keep cows. 2 | //Sorted in ascending order. K = number of cows 3 | //Return the maximum vlue of minimum possible distance between any two cows 4 | 5 | //Maximize the minimum distance 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | bool check_dist(std::vector& vec, int n, int d, int num_cows) 13 | { 14 | int last_pos = vec[0]; 15 | int cows_placed = 1; 16 | 17 | for (int i = 1; i < n; ++i) 18 | { 19 | if ((vec[i] - last_pos) >= d) 20 | { 21 | cows_placed++; 22 | last_pos = vec[i]; 23 | } 24 | 25 | if (cows_placed == num_cows) 26 | return true; 27 | } 28 | return false; 29 | } 30 | 31 | int maximize_min_dist(std::vector& vec, int n, int num_cows) 32 | { 33 | int l = 1, r = vec[n-1] - vec[0]; 34 | int ans; 35 | 36 | while (l <= r) 37 | { 38 | int mid = (l+r)/2; 39 | 40 | if (check_dist(vec, n, mid, num_cows)) 41 | { 42 | ans = mid; 43 | l = mid+1; 44 | } 45 | else 46 | { 47 | r = mid - 1; 48 | } 49 | } 50 | return ans; 51 | } 52 | 53 | int main() 54 | { 55 | #ifndef FILE_INOUT 56 | 57 | freopen("in.txt", "r", stdin); 58 | 59 | freopen("out.txt", "w", stdout); 60 | 61 | #endif 62 | 63 | int n; 64 | std::cin >> n; 65 | 66 | std::vector vec(n); 67 | for (int i = 0; i < n; ++i) 68 | { 69 | std::cin >> vec[i]; 70 | } 71 | 72 | std::cout << maximize_min_dist(vec, n, 4); 73 | 74 | return 0; 75 | } 76 | -------------------------------------------------------------------------------- /Hashing/dup_pairs.cpp: -------------------------------------------------------------------------------- 1 | //Given an array of N elements. Count the number of duplicate 2 | // pairs i. e. A[i] == A[j], i != j 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | int dup_pairs_mtd1(std::vector& vec) 11 | { 12 | std::unordered_map um; 13 | 14 | for (int x : vec) 15 | { 16 | if (um.find(x) != um.end()) 17 | um[x]++; 18 | else 19 | um.insert({x, 1}); 20 | } 21 | 22 | // for (auto it : um) 23 | // { 24 | // std::cout << it.first << " " << it.second << "\n"; 25 | // } 26 | 27 | int sum = 0; 28 | 29 | for (auto it : um) 30 | { 31 | if (it.second > 1) 32 | { 33 | sum += (((it.second) * (it.second - 1))/2); 34 | } 35 | } 36 | return sum; 37 | } 38 | 39 | int dup_pairs_mtd2(std::vector& vec) 40 | { 41 | std::unordered_map um; 42 | int sum = 0; 43 | 44 | for (int x : vec) 45 | { 46 | if (um.find(x) != um.end()) 47 | { 48 | sum += um[x]; 49 | um[x]++; 50 | } 51 | else 52 | um.insert({x, 1}); 53 | } 54 | 55 | return sum; 56 | } 57 | 58 | int main() 59 | { 60 | #ifndef FILE_INOUT 61 | 62 | freopen("in.txt", "r", stdin); 63 | 64 | freopen("out.txt", "w", stdout); 65 | 66 | #endif 67 | 68 | int n; 69 | std::cin >> n; 70 | 71 | std::vector vec(n); 72 | 73 | for (int i = 0; i < n; ++i) 74 | { 75 | std::cin >> vec[i]; 76 | } 77 | 78 | std::cout << dup_pairs_mtd1(vec) << "\n"; 79 | std::cout << dup_pairs_mtd2(vec) << "\n"; 80 | 81 | return 0; 82 | 83 | } 84 | -------------------------------------------------------------------------------- /Array_and_Subarray/Increasing_subarray.cpp: -------------------------------------------------------------------------------- 1 | //Return true if subarray from L to R is increasing 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | bool increasing_subarray(std::vector& binary_vec, int s, int e) 8 | { 9 | for (int i = s+1; i <= e; ++i) 10 | { 11 | if (binary_vec[i]) 12 | return false; 13 | } 14 | return true; 15 | } 16 | 17 | std::vector check(std::vector& vec) 18 | { 19 | std::vector binary_vec(vec.size()); 20 | binary_vec[0] = 0; 21 | 22 | std::vector res; 23 | 24 | for (int i = 1; i < vec.size(); ++i) 25 | { 26 | if (vec[i-1] > vec[i]) 27 | { 28 | binary_vec[i] = 1; 29 | } 30 | else 31 | { 32 | binary_vec[i] = 0; 33 | } 34 | } 35 | 36 | // for (int x : binary_vec) 37 | // { 38 | // std::cout << x << " "; 39 | // } 40 | // std::cout << "\n"; 41 | 42 | int q; 43 | std::cin >> q; 44 | 45 | while (q--) 46 | { 47 | int l, r; 48 | std::cin >> l >> r; 49 | 50 | res.push_back(increasing_subarray(binary_vec, l, r)); 51 | } 52 | 53 | return res; 54 | } 55 | 56 | int main() 57 | { 58 | #ifndef FILE_INOUT 59 | 60 | freopen("in.txt", "r", stdin); 61 | 62 | freopen("out.txt", "w", stdout); 63 | 64 | #endif 65 | 66 | int n; 67 | std::cin >> n; 68 | 69 | std::vector vec(n); 70 | 71 | for (int i = 0; i < n; ++i) 72 | { 73 | std::cin >> vec[i]; 74 | } 75 | 76 | auto res = check(vec); 77 | 78 | for (auto r : res) 79 | { 80 | std::cout << r << "\n"; 81 | } 82 | 83 | return 0; 84 | } 85 | -------------------------------------------------------------------------------- /Dynamic_Programming/min_abs_diff.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given an array of N elements. Divide all elements into 3 | * 2 subsets such that the absolute difference in their 4 | * sum is minimum. 5 | **/ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int min_abs_diff(std::vector& arr) 13 | { 14 | int n = arr.size(); 15 | int tot_sum = 0; 16 | 17 | for (int x : arr) 18 | { 19 | tot_sum += x; 20 | } 21 | 22 | int k = tot_sum/2; 23 | 24 | std::vector> dp(n+1, std::vector(k+1, 0)); 25 | 26 | for (int i = 0; i <= n; ++i) 27 | { 28 | dp[i][0] = 1; 29 | } 30 | 31 | for (int i = 1; i <= n; ++i) 32 | { 33 | for (int j = 1; j <= k; ++j) 34 | { 35 | int ans = dp[i-1][j]; //skip 36 | 37 | if (j >= arr[i-1]) 38 | { 39 | ans += dp[i-1][j-arr[i-1]]; //pick 40 | } 41 | dp[i][j] = ans; 42 | } 43 | } 44 | 45 | // for (int i = 0; i <= n; ++i) 46 | // { 47 | // for (int j = 0; j <= k; ++j) 48 | // { 49 | // std::cout << dp[i][j] << " "; 50 | // } 51 | // std::cout << "\n"; 52 | // } 53 | 54 | int j = k; 55 | 56 | while (dp[n][j] == 0) 57 | { 58 | j--; 59 | } 60 | 61 | int ans = 2*(k-j); 62 | 63 | if (tot_sum % 2) 64 | { 65 | ans++; 66 | } 67 | return ans; 68 | } 69 | 70 | int main() 71 | { 72 | #ifndef FILE_INOUT 73 | 74 | freopen("in.txt", "r", stdin); 75 | 76 | freopen("out.txt", "w", stdout); 77 | 78 | #endif 79 | 80 | std::vector arr = {3, 6, 2, 9, 26}; 81 | 82 | std::cout << min_abs_diff(arr) << "\n"; 83 | 84 | return 0; 85 | } 86 | -------------------------------------------------------------------------------- /Queue/Queue_using_array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #define max 5 7 | 8 | class Queue 9 | { 10 | int f, r, sz; 11 | public: 12 | int arr[max]; 13 | Queue() 14 | { 15 | f = -1; 16 | r = -1; 17 | sz = 0; 18 | } 19 | 20 | void enqueue(int); 21 | void dequeue(); 22 | int front(); 23 | bool is_empty(); 24 | }; 25 | 26 | void Queue::enqueue(int x) 27 | { 28 | if (sz == max) 29 | { 30 | std::cout << "Queue is Full\n"; 31 | return; 32 | } 33 | r = (r + 1) % max; 34 | arr[r] = x; 35 | sz++; 36 | } 37 | 38 | void Queue::dequeue() 39 | { 40 | if (sz == 0) 41 | { 42 | std::cout << "Queue is Empty\n"; 43 | return; 44 | } 45 | f = (f + 1) % max; 46 | sz--; 47 | } 48 | 49 | int Queue::front() 50 | { 51 | if (sz == 0) 52 | { 53 | std::cout << "Queue is Empty\n"; 54 | return -1; 55 | } 56 | 57 | return arr[(f + 1) % max]; 58 | } 59 | 60 | bool Queue::is_empty() 61 | { 62 | if (sz == 0) 63 | { 64 | return true; 65 | } 66 | return false; 67 | } 68 | 69 | int main() 70 | { 71 | #ifndef FILE_INOUT 72 | 73 | freopen("in.txt", "r", stdin); 74 | 75 | freopen("out.txt", "w", stdout); 76 | 77 | #endif 78 | 79 | Queue queue; 80 | queue.enqueue(1); 81 | queue.enqueue(2); 82 | queue.enqueue(3); 83 | std::cout << "front " << queue.front() << "\n"; 84 | queue.dequeue(); 85 | std::cout << "front " << queue.front() << "\n"; 86 | queue.enqueue(4); 87 | queue.enqueue(5); 88 | queue.enqueue(6); 89 | queue.enqueue(7); 90 | return 0; 91 | } 92 | -------------------------------------------------------------------------------- /Binary_Search/kth_pos_element_in_two_arrays.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given two sorted arrays. Find kth position element if it was 3 | * sorted. 4 | **/ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int count_smaller(std::vector&vec, int n, int mid) 12 | { 13 | int count = 0; 14 | 15 | for (int i = 0; i < n; ++i) 16 | { 17 | if (vec[i] < mid) 18 | { 19 | count++; 20 | } 21 | } 22 | return count; 23 | } 24 | 25 | int k_pos_element(std::vector&vec1, int n, std::vector&vec2, int m, int k) 26 | { 27 | int low = std::min(vec1[0], vec2[0]); 28 | int high = std::max(vec1[n-1], vec2[m-1]); 29 | int ans = -1; 30 | 31 | while (low <= high) 32 | { 33 | int mid = (low + high)/2; 34 | 35 | int count = count_smaller(vec1, n, mid); 36 | count += count_smaller(vec2, m, mid); 37 | 38 | if (count <= k) 39 | { 40 | ans = mid; 41 | low = mid + 1; 42 | } 43 | else 44 | { 45 | high = mid - 1; 46 | } 47 | } 48 | return ans; 49 | } 50 | 51 | int main() 52 | { 53 | #ifndef FILE_INOUT 54 | 55 | freopen("in.txt", "r", stdin); 56 | 57 | freopen("out.txt", "w", stdout); 58 | 59 | #endif 60 | 61 | int n, k; 62 | std::cin >> n >> k; 63 | 64 | std::vector vec1(n); 65 | 66 | for (int i = 0; i < n; ++i) 67 | { 68 | std::cin >> vec1[i]; 69 | } 70 | 71 | int m; 72 | std::cin >> m; 73 | 74 | std::vector vec2(m); 75 | 76 | for (int i = 0; i < m; ++i) 77 | { 78 | std::cin >> vec2[i]; 79 | } 80 | 81 | std::cout << k_pos_element(vec1, n, vec2, m, k) << "\n"; 82 | 83 | return 0; 84 | } 85 | -------------------------------------------------------------------------------- /Queue/max_val_windows.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given an array. Return an array containg the max value of 3 | * every windows of size k 4 | **/ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | std::vector max_val_window(std::vector& arr, int k) 13 | { 14 | std::deque dq; 15 | std::vector res; 16 | int n = arr.size(); 17 | 18 | for (int i = 0; i < k; ++i) 19 | { 20 | if (dq.empty() || dq.back() >= arr[i]) 21 | { 22 | dq.push_back(arr[i]); 23 | } 24 | else if (dq.back() < arr[i]) 25 | { 26 | while (!dq.empty() && dq.back() < arr[i]) 27 | { 28 | dq.pop_back(); 29 | } 30 | dq.push_back(arr[i]); 31 | } 32 | } 33 | 34 | res.push_back(dq.front()); 35 | 36 | for (int i = 1; i <= n-k; ++i) 37 | { 38 | if (arr[i-1] == dq.front()) 39 | { 40 | dq.pop_front(); 41 | } 42 | 43 | if (dq.empty() || dq.back() >= arr[i+k-1]) 44 | { 45 | dq.push_back(arr[i+k-1]); 46 | } 47 | else if (dq.back() < arr[i+k-1]) 48 | { 49 | while (!dq.empty() && dq.back() < arr[i+k-1]) 50 | { 51 | dq.pop_back(); 52 | } 53 | dq.push_back(arr[i+k-1]); 54 | } 55 | res.push_back(dq.front()); 56 | } 57 | return res; 58 | } 59 | 60 | int main() 61 | { 62 | #ifndef FILE_INOUT 63 | 64 | freopen("in.txt", "r", stdin); 65 | 66 | freopen("out.txt", "w", stdout); 67 | 68 | #endif 69 | 70 | std::vector arr = {1, 3, -1, -3, 5, 3, 6, 7}; 71 | 72 | auto res = max_val_window(arr, 3); 73 | 74 | for (int x : res) 75 | { 76 | std::cout << x << " "; 77 | } 78 | std::cout << "\n"; 79 | 80 | return 0; 81 | } 82 | -------------------------------------------------------------------------------- /Graph_Algorithms/Depth First Seacrh/dfs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class Graph 5 | { 6 | int vertexCount; //no of Vertices 7 | enum class Color { WHITE, GRAY, BLACK }; 8 | 9 | struct Vertex 10 | { 11 | int id; 12 | Color color; 13 | Vertex(int vertex, Color clr) : id(vertex), color(clr) {} 14 | }; 15 | std::vector< std::vector > adjMatrix; //adjacency Matrix 16 | std::vector vertices; 17 | 18 | public: 19 | Graph(int); 20 | void addEdge(int, int); 21 | void depthFirstSearch(int); 22 | }; 23 | 24 | Graph::Graph(int v) 25 | { 26 | vertexCount = v; 27 | adjMatrix.resize(vertexCount, std::vector(vertexCount)); 28 | for(int i = 0; i < vertexCount; i++) 29 | { 30 | vertices.push_back( Vertex(i, Color::WHITE)); 31 | for(int j = 0; j < vertexCount; j++) 32 | { 33 | adjMatrix[i][j] = false; 34 | } 35 | } 36 | } 37 | 38 | void Graph::addEdge(int a, int b) 39 | { 40 | adjMatrix[a][b] = true; 41 | adjMatrix[b][a] = true; 42 | } 43 | 44 | void Graph::depthFirstSearch(int u) 45 | { 46 | vertices[u].color = Color::GRAY; 47 | std::cout << vertices[u].id <<" "; 48 | 49 | for(int j = 0; j < vertexCount; j++) 50 | { 51 | if(adjMatrix[u][j] == true) 52 | { 53 | if(vertices[j].color == Color::WHITE) 54 | depthFirstSearch(j); 55 | } 56 | } 57 | 58 | vertices[u].color = Color::BLACK; //blacken u, it is finished 59 | } 60 | 61 | int main() 62 | { 63 | Graph grp(4); 64 | grp.addEdge(0, 1); 65 | grp.addEdge(1, 2); 66 | grp.addEdge(2, 3); 67 | grp.addEdge(2, 1); 68 | grp.addEdge(0, 3); 69 | 70 | grp.depthFirstSearch(2); 71 | return 0; 72 | } 73 | -------------------------------------------------------------------------------- /Stack/postfix_notation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | std::string postfix_notation(std::string& str) 9 | { 10 | std::string res = ""; 11 | std::stack st; 12 | std::unordered_map um; 13 | um.insert({'*', 4}); 14 | um.insert({'/', 4}); 15 | um.insert({'-', 3}); 16 | um.insert({'+', 3}); 17 | 18 | for (char c : str) 19 | { 20 | if (c != '+' && c != '-' && c != '*' && c != '/' 21 | && c != '(' && c != ')' ) 22 | { 23 | res += c; 24 | } 25 | else 26 | { 27 | if (st.empty()) 28 | { 29 | st.push(c); 30 | } 31 | else 32 | { 33 | if (c == '(' || um[c] > um[st.top()]) 34 | { 35 | st.push(c); 36 | } 37 | else if (c == ')') 38 | { 39 | while (st.top() != '(') 40 | { 41 | res += st.top(); 42 | st.pop(); 43 | } 44 | 45 | if (st.top() == '(') 46 | { 47 | st.pop(); 48 | } 49 | } 50 | else if (um[c] <= um[st.top()]) 51 | { 52 | while (!st.empty() && um[c] <= um[st.top()]) 53 | { 54 | res += st.top(); 55 | st.pop(); 56 | } 57 | st.push(c); 58 | } 59 | } 60 | } 61 | } 62 | 63 | while (!st.empty()) 64 | { 65 | res += st.top(); 66 | st.pop(); 67 | } 68 | 69 | return res; 70 | } 71 | 72 | int main() 73 | { 74 | #ifndef FILE_INOUT 75 | 76 | freopen("in.txt", "r", stdin); 77 | 78 | freopen("out.txt", "w", stdout); 79 | 80 | #endif 81 | 82 | std::string str; 83 | std::cin >> str; 84 | std::string res = postfix_notation(str); 85 | 86 | std::cout << res << "\n"; 87 | 88 | return 0; 89 | } 90 | -------------------------------------------------------------------------------- /Sorting/Quick Sort/quickSort.py: -------------------------------------------------------------------------------- 1 | def get_input(): 2 | """ 3 | get input from user 4 | """ 5 | input_str = input("Enter elements to be sorted: ") 6 | try: 7 | elements = [int(e) for e in input_str.split()] #make a list of integers from input string 8 | except ValueError: 9 | print("Please enter a list of integers only, seperated by a space!!") 10 | return elements 11 | 12 | def partition(thelist, start_idx: int, end_idx: int): 13 | """ 14 | partition list according to pivot and return index of pivot 15 | """ 16 | pivot = thelist[end_idx] #select last element as the pivot 17 | idx = start_idx - 1 18 | 19 | for curr_idx in range(start_idx, end_idx): 20 | if thelist[curr_idx] <= pivot: 21 | idx += 1 #increment 22 | thelist[idx], thelist[curr_idx] = thelist[curr_idx], thelist[idx] #swapping 23 | 24 | thelist[idx+1], thelist[end_idx] = thelist[end_idx], thelist[idx+1] #swapping 25 | return idx+1 #returning pivot index 26 | 27 | def quick_sort(thelist, start_idx: int, end_idx: int): 28 | """ 29 | Quick Sort Algorithm 30 | """ 31 | if len(thelist) == 0: 32 | print("Empty list!!") 33 | 34 | elif len(thelist) == 1: 35 | print("Only one element!!") 36 | 37 | elif start_idx < end_idx: 38 | pivot_idx = partition(thelist, start_idx, end_idx) #get pivot index 39 | quick_sort(thelist, start_idx, pivot_idx - 1) #apply algorithm for smaller list 40 | quick_sort(thelist, pivot_idx + 1, end_idx) #apply algorithm for smaller list 41 | 42 | if __name__ == '__main__': 43 | input_list = get_input() 44 | quick_sort(input_list, 0, len(input_list) - 1) 45 | print(*input_list, sep = ", ") 46 | -------------------------------------------------------------------------------- /Stack/largest_rectangle_area_histogram.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | void clear_stack(std::stack& st) 9 | { 10 | while (!st.empty()) 11 | { 12 | st.pop(); 13 | } 14 | } 15 | 16 | int largest_rectangle_area(std::vector &A) { 17 | 18 | int n = A.size(); 19 | 20 | std::vector NSL(n), NSR(n); 21 | 22 | std::stack st; 23 | 24 | for (int i = 0; i < n; ++i) 25 | { 26 | while (!st.empty() && A[st.top()] >= A[i]) 27 | { 28 | st.pop(); 29 | } 30 | 31 | if (st.empty()) 32 | { 33 | NSL[i] = -1; 34 | } 35 | else if (A[st.top()] < A[i]) 36 | { 37 | NSL[i] = st.top(); 38 | } 39 | 40 | st.push(i); 41 | } 42 | 43 | clear_stack(st); 44 | 45 | for (int i = n-1; i >= 0; --i) 46 | { 47 | while (!st.empty() && A[st.top()] >= A[i]) 48 | { 49 | st.pop(); 50 | } 51 | 52 | if (st.empty()) 53 | { 54 | NSR[i] = n; 55 | } 56 | else if (A[st.top()] < A[i]) 57 | { 58 | NSR[i] = st.top(); 59 | } 60 | 61 | st.push(i); 62 | } 63 | 64 | int mx = INT_MIN; 65 | 66 | for (int i = 0; i < n; ++i) 67 | { 68 | int wd = NSR[i] - NSL[i] - 1; 69 | mx = std::max(mx, (wd*A[i])); 70 | } 71 | return mx; 72 | } 73 | 74 | 75 | int main() 76 | { 77 | #ifndef FILE_INOUT 78 | 79 | freopen("in.txt", "r", stdin); 80 | 81 | freopen("out.txt", "w", stdout); 82 | 83 | #endif 84 | 85 | std::vector arr = {6, 2, 5, 4, 5, 1, 6}; 86 | std::cout << largest_rectangle_area(arr); 87 | 88 | return 0; 89 | } 90 | -------------------------------------------------------------------------------- /Heaps/min_heap.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | class Min_heap 6 | { 7 | int *arr; 8 | int heap_sz = -1; 9 | int capacity; 10 | 11 | public: 12 | Min_heap(int sz) 13 | { 14 | capacity = sz; 15 | arr = new int[sz]; 16 | } 17 | void insert(int val); 18 | void delete_min(); 19 | void print() 20 | { 21 | for (int i = 0; i <= heap_sz; ++i) 22 | { 23 | std::cout << arr[i] << " "; 24 | } 25 | std::cout << "\n"; 26 | } 27 | }; 28 | 29 | //TC : O(logN) 30 | void Min_heap::insert(int val) 31 | { 32 | heap_sz++; 33 | int i = heap_sz; 34 | arr[i] = val; 35 | 36 | while (i > 0) 37 | { 38 | int p_idx = (i-1)/2; 39 | if (arr[p_idx] > arr[i]) 40 | { 41 | std::swap(arr[p_idx], arr[i]); 42 | i = p_idx; 43 | } 44 | else 45 | { 46 | break; 47 | } 48 | } 49 | } 50 | 51 | void Min_heap::delete_min() 52 | { 53 | std::swap(arr[heap_sz], arr[0]); 54 | heap_sz--; 55 | int i = 0; 56 | 57 | while (i < capacity) 58 | { 59 | int min = i; 60 | int l = 2*i + 1; 61 | int r = 2*i + 2; 62 | 63 | if (l < capacity && arr[l] < arr[min]) 64 | { 65 | min = l; 66 | } 67 | 68 | if (r < capacity && arr[r] < arr[min]) 69 | { 70 | min = r; 71 | } 72 | 73 | if (i == min) 74 | { 75 | break; 76 | } 77 | 78 | std::swap(arr[i], arr[min]); 79 | i = min; 80 | } 81 | } 82 | 83 | int main() 84 | { 85 | #ifndef FILE_INOUT 86 | 87 | freopen("in.txt", "r", stdin); 88 | 89 | freopen("out.txt", "w", stdout); 90 | 91 | #endif 92 | 93 | Min_heap obj(100); 94 | obj.insert(2); 95 | obj.insert(4); 96 | obj.insert(6); 97 | obj.insert(9); 98 | obj.insert(12); 99 | obj.insert(10); 100 | obj.insert(20); 101 | obj.insert(11); 102 | obj.insert(3); 103 | obj.delete_min(); 104 | obj.print(); 105 | } 106 | -------------------------------------------------------------------------------- /Sorting/Selection Sort/C++/selectionsort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | //Generic 6 | template 7 | void selection_sort(std::vector& array) 8 | { 9 | typedef typename std::vector::iterator Itr; 10 | Itr itr = array.begin(); 11 | while(itr != array.end()) 12 | { 13 | Itr itr_min = itr; 14 | for(Itr i = itr + 1; i != array.end(); i++) 15 | { 16 | if(*i < *itr_min) 17 | { 18 | itr_min = i; 19 | } 20 | } 21 | std::iter_swap(itr, itr_min); 22 | itr++; 23 | } 24 | } 25 | 26 | template 27 | void print(const std::vector& array) 28 | { 29 | for(auto itr = array.begin(); itr != array.end(); itr++) 30 | { 31 | std::cout << *itr << " "; 32 | } 33 | std::cout << '\n'; 34 | } 35 | 36 | void selection_sort(std::vector& vec, int n) 37 | { 38 | for (int i = 0; i < n; ++i) 39 | { 40 | int mn = vec[i], idx = i; 41 | 42 | for (int j = i; j < n; j++) 43 | { 44 | if (vec[j] < mn) 45 | { 46 | mn = vec[j]; 47 | idx = j; 48 | } 49 | } 50 | std::swap(vec[i], vec[idx]); 51 | } 52 | } 53 | 54 | int main() 55 | { 56 | std::vector v({5, 3, 12, 2, 8}); 57 | std::cout << "Original Array :"; 58 | print(v); 59 | selection_sort(v); 60 | std::cout <<"Sorted Array :"; 61 | print(v); 62 | std::cout << '\n'; 63 | 64 | std::vector c({'t', 'q', 'a', 'r', 'p'}); 65 | std::cout << "Original Array :"; 66 | print(c); 67 | selection_sort(c); 68 | std::cout <<"Sorted Array :"; 69 | print(c); 70 | std::cout << '\n'; 71 | 72 | std::vector str({"code", "live", "love", "sing", "create"}); 73 | std::cout << "Original Array :"; 74 | print(str); 75 | selection_sort(str); 76 | std::cout <<"Sorted Array :"; 77 | print(str); 78 | std::cout << '\n'; 79 | } 80 | 81 | -------------------------------------------------------------------------------- /Dynamic_Programming/dungeon_princess.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Can move in right or down direction 3 | * The starting cell is 0,0 and ending cell is N-1, M-1 4 | * if health <= 0 then dead 5 | * 6 | * Return the minimum amount of health with which he should 7 | * start so that he reaches the princess in living condition 8 | * (health > 0) 9 | **/ 10 | 11 | #include 12 | #include 13 | #include 14 | #include 15 | 16 | int min_health(std::vector>& vec, int r, int c) 17 | { 18 | std::vector> dp(r, std::vector(c)); 19 | 20 | if (1-vec[r-1][c-1] > 0) 21 | { 22 | dp[r-1][c-1] = 1-vec[r-1][c-1]; 23 | } 24 | else 25 | { 26 | dp[r-1][c-1] = 1; 27 | } 28 | 29 | for (int i = r-2; i >= 0; i--) 30 | { 31 | if (dp[i+1][c-1] - vec[i][c-1] > 0) 32 | { 33 | dp[i][c-1] = dp[i+1][c-1] - vec[i][c-1]; 34 | } 35 | else 36 | { 37 | dp[i][c-1] = 1; 38 | } 39 | } 40 | 41 | for (int i = c-2; i >= 0; i--) 42 | { 43 | if (dp[r-1][i+1] - vec[r-1][i] > 0) 44 | { 45 | dp[r-1][i] = dp[r-1][i+1] - vec[r-1][i]; 46 | } 47 | else 48 | { 49 | dp[r-1][i] = 1; 50 | } 51 | } 52 | 53 | for (int i = r-2; i >= 0; i--) 54 | { 55 | for (int j = c-2; j >= 0; j--) 56 | { 57 | 58 | if (std::min(dp[i+1][j], dp[i][j+1]) - vec[i][j] > 0) 59 | { 60 | dp[i][j] = std::min(dp[i+1][j], dp[i][j+1]) - vec[i][j]; 61 | } 62 | else 63 | { 64 | dp[i][j] = 1; 65 | } 66 | } 67 | } 68 | 69 | // for (int i = 0; i < r; ++i) 70 | // { 71 | // for (int j = 0; j < c; ++j) 72 | // { 73 | // std::cout << dp[i][j] << " "; 74 | // } 75 | // std::cout << "\n"; 76 | // } 77 | return dp[0][0]; 78 | } 79 | 80 | int main() 81 | { 82 | #ifndef FILE_INOUT 83 | 84 | freopen("in.txt", "r", stdin); 85 | 86 | freopen("out.txt", "w", stdout); 87 | 88 | #endif 89 | 90 | std::vector> vec = {{-2, -3, 3}, 91 | {-5, -10, 1}, 92 | {10, 30, -5}}; 93 | 94 | std::cout << min_health(vec, 3, 3) << "\n"; 95 | 96 | return 0; 97 | } 98 | -------------------------------------------------------------------------------- /Sorting/Heapsort/heapSort.py: -------------------------------------------------------------------------------- 1 | def get_input(): 2 | """ 3 | get input from user 4 | """ 5 | input_str = input("Enter elements to be sorted: ") 6 | try: 7 | elements = [int(e) for e in input_str.split()] #make a list of integers from input string 8 | except ValueError: 9 | print("Please enter a list of integers only, seperated by a space!!") 10 | return elements 11 | 12 | def max_heapify(thelist, lst_size: int, idx: int): 13 | """ 14 | Building maximum heap at index passed as argument 15 | """ 16 | largest = idx 17 | left_child = 2 * idx + 1 18 | right_child = 2 * idx + 2 19 | 20 | #comparing left child and largest 21 | if left_child < lst_size and thelist[left_child] > thelist[largest]: 22 | largest = left_child 23 | 24 | #comparing right child and largest 25 | if right_child < lst_size and thelist[right_child] > thelist[largest]: 26 | largest = right_child 27 | 28 | if largest != idx: #if largest is changed 29 | thelist[idx], thelist[largest] = thelist[largest], thelist[idx] #swapping 30 | max_heapify(thelist, lst_size, largest) 31 | 32 | def build_max_heap(thelist, lst_size: int): 33 | """ 34 | Building maximum heap from the list passed as argument 35 | """ 36 | for curr_idx in range(lst_size // 2 - 1, -1, -1): #loop from higher index to lower index 37 | max_heapify(thelist, lst_size, curr_idx) 38 | 39 | def heap_sort(thelist): 40 | """ 41 | Heap sort Algorithm 42 | """ 43 | if len(thelist) == 0: 44 | print("Empty list!!") 45 | 46 | elif len(thelist) == 1: 47 | print("Only one element!!") 48 | 49 | else: 50 | build_max_heap(thelist, len(thelist)) 51 | 52 | for curr_idx in range(len(thelist) -1, 0, -1): #loop from higher index to lower index 53 | thelist[curr_idx], thelist[0] = thelist[0], thelist[curr_idx] #swapping 54 | max_heapify(thelist, curr_idx, 0) 55 | 56 | if __name__ == '__main__': 57 | input_list = get_input() 58 | heap_sort(input_list) 59 | print(*input_list, sep = ", ") 60 | -------------------------------------------------------------------------------- /Linked_List/stack_using_ll.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | template 4 | class Stack 5 | { 6 | struct Node 7 | { 8 | T data; 9 | Node *next; 10 | Node(T val):data(val),next(nullptr) {} 11 | }; 12 | Node *head; int top; 13 | 14 | public: 15 | Stack() 16 | { 17 | top=-1; 18 | head=nullptr; 19 | } 20 | ~Stack(); 21 | bool stack_empty(); 22 | void push(T); 23 | T pop(); 24 | 25 | void display(std::ostream& out = std::cout) const 26 | { 27 | Node *node=head; 28 | while(node!=nullptr) 29 | { 30 | out<data<<" "; 31 | node=node->next; 32 | } 33 | } 34 | }; 35 | 36 | template 37 | bool Stack::stack_empty() 38 | { 39 | if(top==-1) 40 | return true; 41 | else 42 | return false; 43 | } 44 | 45 | template 46 | void Stack::push(T val) 47 | { 48 | top++; 49 | Node *node=new Node(val); 50 | node->next = head; 51 | head=node; 52 | } 53 | 54 | template 55 | T Stack::pop() 56 | { 57 | if(stack_empty()==true) 58 | std::cout<<"Underflow"<next; 64 | T tmp = std::move(node->data); 65 | delete node; 66 | return tmp; 67 | } 68 | } 69 | 70 | template 71 | std::ostream & operator <<(std::ostream& os, const Stack& s) 72 | { 73 | s.display(os); 74 | return os; 75 | } 76 | 77 | template 78 | Stack::~Stack() 79 | { 80 | Node *tmp=nullptr; 81 | while(head) 82 | { 83 | tmp=head; 84 | head=head->next; 85 | delete tmp; 86 | } 87 | head=nullptr; 88 | } 89 | 90 | int main() 91 | { 92 | Stack stack1; 93 | stack1.push(3); 94 | stack1.push(4); 95 | stack1.push(11); 96 | stack1.push(30); 97 | std::cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | class Graph 8 | { 9 | int vertex_count; 10 | enum Color {WHITE, GRAY, BLACK}; 11 | 12 | enum { INFINITY = std::numeric_limits::max() }; 13 | 14 | struct Vertex 15 | { 16 | int id; 17 | int distance; 18 | Color color; 19 | 20 | Vertex(int _id) : id(_id), 21 | color(Color::WHITE), 22 | distance(INFINITY) 23 | {} 24 | }; 25 | 26 | public: 27 | 28 | std::vector vertices; 29 | std::vector< std::list > adjList; 30 | 31 | Graph(int); 32 | void addEdge(int, int); 33 | void breadthFirstSearch(int); 34 | }; 35 | 36 | Graph::Graph(int v) 37 | { 38 | vertex_count = v; 39 | adjList.resize(vertex_count); 40 | for (int i = 0; i < vertex_count; i++) 41 | { 42 | vertices.push_back( Vertex(i) ); 43 | } 44 | } 45 | 46 | void Graph::addEdge(int src, int dest) 47 | { 48 | //undirected graph 49 | adjList[src].push_back(dest); 50 | adjList[dest].push_back(src); 51 | } 52 | 53 | void Graph::breadthFirstSearch(int s) 54 | { 55 | vertices[s].color = GRAY; 56 | vertices[s].distance = 0; 57 | std::queue q; 58 | q.push(vertices[s]); 59 | while (!q.empty()) 60 | { 61 | auto u = q.front(); 62 | q.pop(); 63 | for (const auto& v : adjList[u.id]) 64 | { 65 | if (vertices[v].color == WHITE) 66 | { 67 | vertices[v].color = GRAY; 68 | vertices[v].distance = u.distance + 1; 69 | q.push(vertices[v]); 70 | } 71 | } 72 | u.color = BLACK; 73 | std::cout << vertices[u.id].id << " at level " << vertices[u.id].distance <<'\n'; 74 | } 75 | } 76 | 77 | int main() 78 | { 79 | Graph grp(5); 80 | grp.addEdge(0, 1); 81 | grp.addEdge(0, 4); 82 | grp.addEdge(1, 3); 83 | grp.addEdge(1, 4); 84 | grp.addEdge(1, 2); 85 | grp.addEdge(2, 3); 86 | grp.addEdge(3, 4); 87 | grp.breadthFirstSearch(2); 88 | } 89 | -------------------------------------------------------------------------------- /Huffman Coding/C++/Huffman.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | class HuffmanCodes 6 | { 7 | struct Node 8 | { 9 | char data; 10 | size_t freq; 11 | Node* left; 12 | Node* right; 13 | 14 | Node() 15 | { 16 | data = '\0'; 17 | freq = 0; 18 | } 19 | Node(char data, size_t freq) : data(data), 20 | freq(freq), 21 | left(nullptr), 22 | right(nullptr) 23 | {} 24 | ~Node() 25 | { 26 | delete left; 27 | delete right; 28 | } 29 | }; 30 | 31 | struct compare 32 | { 33 | bool operator()(Node* l, Node* r) 34 | { 35 | return (l->freq > r->freq); 36 | } 37 | }; 38 | 39 | Node* top; 40 | 41 | void printCode(Node* root, std::string str) 42 | { 43 | if(root == nullptr) 44 | return; 45 | 46 | if(root->data != '$') 47 | { 48 | std::cout << root->data << " : " << str << "\n"; 49 | } 50 | printCode(root->left, str + "0"); 51 | printCode(root->right, str + "1"); 52 | } 53 | 54 | public: 55 | HuffmanCodes() {} 56 | ~HuffmanCodes() 57 | { 58 | delete top; 59 | } 60 | void GenerateCode(const std::vector& data, const std::vector& freq) 61 | { 62 | Node* left; 63 | Node* right; 64 | 65 | std::priority_queue, compare > minHeap; 66 | 67 | for(size_t i = 0; i < data.size(); ++i) 68 | { 69 | minHeap.push(new Node(data[i], freq[i])); 70 | } 71 | 72 | while(minHeap.size() != 1) 73 | { 74 | left = minHeap.top(); 75 | minHeap.pop(); 76 | 77 | right = minHeap.top(); 78 | minHeap.pop(); 79 | 80 | top = new Node('$', left->freq + right->freq); 81 | top->left = left; 82 | top->right = right; 83 | minHeap.push(top); 84 | } 85 | printCode(minHeap.top(), ""); 86 | } 87 | }; 88 | 89 | int main() 90 | { 91 | HuffmanCodes set1; 92 | std::vector data({'d', 'e', 'b', 'c', 'a', 'f'}); 93 | std::vector freq({16, 9, 13, 12, 45, 5}); 94 | size_t size = data.size(); 95 | set1.GenerateCode(data, freq); 96 | 97 | return 0; 98 | } 99 | -------------------------------------------------------------------------------- /Binary_Tree/next_pointer_binary_tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given a binary tree, 3 | * 4 | * Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL. 5 | * 6 | * Initially, all next pointers are set to NULL. 7 | * 8 | * Assume perfect binary tree and try to solve this in constant extra space. 9 | **/ 10 | 11 | /** 12 | * Definition for binary tree with next pointer. 13 | * struct TreeLinkNode { 14 | * int val; 15 | * TreeLinkNode *left, *right, *next; 16 | * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} 17 | * }; 18 | */ 19 | 20 | TreeLinkNode* next_right_child(TreeLinkNode* A) 21 | { 22 | if (A == NULL) 23 | { 24 | return NULL; 25 | } 26 | 27 | TreeLinkNode* tmp = A->next; 28 | 29 | while (tmp != NULL) 30 | { 31 | if (tmp->left != NULL) 32 | { 33 | return tmp->left; 34 | } 35 | 36 | if (tmp->right != NULL) 37 | { 38 | return tmp->right; 39 | } 40 | 41 | tmp = tmp->next; 42 | } 43 | return NULL; 44 | } 45 | 46 | void connect(TreeLinkNode* A) { 47 | TreeLinkNode* level = A; 48 | 49 | while (level != NULL) 50 | { 51 | TreeLinkNode* curr = level; 52 | 53 | while (curr != NULL) 54 | { 55 | if (curr->left != NULL) 56 | { 57 | if (curr->right != NULL) 58 | { 59 | curr->left->next =curr->right; 60 | } 61 | else 62 | { 63 | curr->left->next = next_right_child(curr); 64 | } 65 | } 66 | 67 | if (curr->right != NULL) 68 | { 69 | curr->right->next = next_right_child(curr); 70 | } 71 | curr = curr->next; 72 | } 73 | 74 | if (level->left != NULL) 75 | { 76 | level = level->left; 77 | } 78 | else if (level->right != NULL) 79 | { 80 | level = level->right; 81 | } 82 | else 83 | { 84 | level = next_right_child(level); 85 | } 86 | } 87 | } 88 | -------------------------------------------------------------------------------- /Stack/stack_using_ll.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | class LinkedList 7 | { 8 | struct Node 9 | { 10 | int data; 11 | Node * next = nullptr; 12 | Node(int value) : data(value), next(nullptr) {} 13 | }; 14 | Node *head; 15 | 16 | public: 17 | LinkedList() : head(nullptr) {} 18 | ~LinkedList() 19 | { 20 | Node *tmp = nullptr; 21 | while (head) 22 | { 23 | tmp = head; 24 | head = head->next; 25 | delete tmp; 26 | } 27 | head = nullptr; 28 | } 29 | 30 | void push(int); 31 | int pop(); 32 | int top(); 33 | void printList() const; 34 | }; 35 | 36 | void LinkedList::push(int value) 37 | { 38 | Node *node = new Node(value); 39 | Node *tmp = head; 40 | if (head == nullptr) 41 | { 42 | head = node; 43 | } 44 | else 45 | { 46 | node->next = head; 47 | head = node; 48 | } 49 | } 50 | 51 | int LinkedList::pop() 52 | { 53 | Node* node = head; 54 | head = head->next; 55 | node->next = nullptr; 56 | 57 | return node->data; 58 | } 59 | 60 | int LinkedList::top() 61 | { 62 | return head->data; 63 | } 64 | 65 | void LinkedList::printList() const 66 | { 67 | if (head == nullptr) 68 | { 69 | std::cout << "Empty List \n"; 70 | return; 71 | } 72 | 73 | Node *node = head; 74 | 75 | while (node != nullptr) 76 | { 77 | std::cout << node->data << " "; 78 | node = node->next; 79 | } 80 | 81 | std::cout << "\n"; 82 | } 83 | 84 | int main() 85 | { 86 | #ifndef FILE_INOUT 87 | 88 | freopen("in.txt", "r", stdin); 89 | 90 | freopen("out.txt", "w", stdout); 91 | 92 | #endif 93 | 94 | LinkedList stack; 95 | stack.push(3); 96 | stack.push(1); 97 | std::cout << "Top : " << stack.top() << "\n"; 98 | stack.push(7); 99 | std::cout << "Pop : " << stack.pop() << "\n"; 100 | std::cout << "Top : " << stack.top() << "\n"; 101 | stack.push(9); 102 | std::cout << "Stack : "; 103 | stack.printList(); 104 | } 105 | -------------------------------------------------------------------------------- /Binary_Tree/vertical_order_traversal.cpp: -------------------------------------------------------------------------------- 1 | //If Vertical Order doesn't matter 2 | 3 | // map 4 | std::unordered_map > um; 5 | 6 | // starts dist with 0 7 | void vertical_order_traversal(TreeNode* root, int dist) 8 | { 9 | if (root == NULL) 10 | return NULL; 11 | 12 | if (um.find(dist) == um.end()) 13 | { 14 | um.insert({dist, {}}); 15 | } 16 | 17 | um[dist] = root->val; 18 | vertical_order_traversal(root->left, dist-1); 19 | vertical_order_traversal(root->right, dist+1); 20 | } 21 | 22 | //If vertical order matters 23 | 24 | /** 25 | * Definition for binary tree 26 | * struct TreeNode { 27 | * int val; 28 | * TreeNode *left; 29 | * TreeNode *right; 30 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 31 | * }; 32 | */ 33 | vector > vertical_order_traversal(TreeNode* A) { 34 | //map dist and values 35 | if (A == NULL) 36 | { 37 | return {{}}; 38 | } 39 | unordered_map> um; 40 | vector distances; 41 | 42 | //queue dist and node 43 | queue>q; 44 | q.push({0, A}); 45 | 46 | while (!q.empty()) 47 | { 48 | int q_sz = q.size(); 49 | 50 | for (int i = 0; i < q_sz; ++i) 51 | { 52 | pair p = q.front(); 53 | q.pop(); 54 | 55 | int dist = p.first; 56 | TreeNode*tmp = p.second; 57 | 58 | if (um.find(dist) == um.end()) 59 | { 60 | std::vector v_tmp = {tmp->val}; 61 | um.insert({dist, v_tmp}); 62 | distances.push_back(dist); 63 | } 64 | else 65 | { 66 | um[dist].push_back(tmp->val); 67 | } 68 | 69 | if (tmp->left != NULL) 70 | { 71 | q.push({dist-1, tmp->left}); 72 | } 73 | 74 | if (tmp->right != NULL) 75 | { 76 | q.push({dist+1, tmp->right}); 77 | } 78 | } 79 | } 80 | 81 | vector> res; 82 | sort(distances.begin(), distances.end()); 83 | 84 | for (int i = 0; i < distances.size(); ++i) 85 | { 86 | res.push_back(um[distances[i]]); 87 | } 88 | return res; 89 | } 90 | -------------------------------------------------------------------------------- /Graph_Algorithms/Breadth First Search/bfs_shortest_path.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | class Coordinate 8 | { 9 | public: 10 | int x; 11 | int y; 12 | 13 | Coordinate(int x, int y) : x(x), y(y) {} 14 | }; 15 | 16 | class NodeData 17 | { 18 | public: 19 | Coordinate cord; 20 | int dist; 21 | 22 | NodeData(Coordinate c, int d) : cord(c), dist(d) {} 23 | }; 24 | 25 | std::vector ROW = {-1, 0, 0, 1}; 26 | std::vector COL = {0, -1, 1, 0}; 27 | 28 | int shortest_path(std::vector>& mat, int source_row, 29 | int source_col, int dest_row, int dest_col) 30 | { 31 | int r = mat.size(); 32 | int c = mat[0].size(); 33 | 34 | std::vector> visited(r, std::vector(c, 0)); 35 | 36 | std::queue q; 37 | q.push(NodeData(Coordinate(source_row, source_col), 0)); 38 | visited[source_row][source_col] = 1; 39 | 40 | while (!q.empty()) 41 | { 42 | NodeData curr = q.front(); 43 | q.pop(); 44 | 45 | Coordinate curr_cord = curr.cord; 46 | int i = curr_cord.x; 47 | int j = curr_cord.y; 48 | int curr_dist = curr.dist; 49 | 50 | for (int k = 0; k < 4; ++k) 51 | { 52 | int nxt_row = i+ROW[k]; 53 | int nxt_col = j+COL[k]; 54 | if (nxt_row >= 0 && nxt_row < r 55 | && nxt_col >= 0 && nxt_col < c 56 | && mat[nxt_row][nxt_col] == 0 57 | && visited[nxt_row][nxt_col] == 0) 58 | { 59 | if (nxt_row == dest_row && nxt_col == dest_col) 60 | { 61 | return 1+curr_dist; 62 | } 63 | else 64 | { 65 | q.push(NodeData(Coordinate(nxt_row, nxt_col), curr_dist+1)); 66 | visited[nxt_row][nxt_col] = 1; 67 | } 68 | } 69 | } 70 | } 71 | return -1; 72 | } 73 | 74 | int main() 75 | { 76 | #ifndef FILE_INOUT 77 | 78 | freopen("in.txt", "r", stdin); 79 | 80 | freopen("out.txt", "w", stdout); 81 | 82 | #endif 83 | 84 | //0 means empty path, 1 means blocked 85 | std::vector> mat = {{0, 0, 0, 1, 0}, 86 | {0, 1, 0, 0, 0}, 87 | {0, 0, 1, 0, 0}, 88 | {0, 1, 0, 0, 0}, 89 | {1, 0, 0, 1, 0}}; 90 | 91 | int s_r = 1, s_c = 0; 92 | int d_r = 3, d_c = 4; 93 | 94 | std::cout << shortest_path(mat, s_r, s_c, d_r, d_c) << "\n"; 95 | 96 | return 0; 97 | } 98 | -------------------------------------------------------------------------------- /Stack/get_minimum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define max 1000 5 | class Stack 6 | { 7 | int top; 8 | int top_min; 9 | int mn_val = INT_MAX; 10 | 11 | public: 12 | int a[max]; 13 | int min_stack[max]; 14 | 15 | Stack() 16 | { 17 | top = -1; 18 | top_min = -1; 19 | } 20 | 21 | bool stack_empty(); 22 | void push(int x); 23 | int pop(); 24 | int get_min(); 25 | void display(); 26 | }; 27 | 28 | bool Stack::stack_empty() 29 | { 30 | if(top == -1) 31 | return true; 32 | else 33 | return false; 34 | } 35 | 36 | void Stack::push(int x) 37 | { 38 | int s = max-1; 39 | if(top < s) 40 | { 41 | top = top+1; 42 | a[top] = x; 43 | 44 | if (x <= mn_val) 45 | { 46 | mn_val = x; 47 | top_min++; 48 | min_stack[top_min] = mn_val; 49 | } 50 | } 51 | else 52 | std::cout << "overflow" << "\n"; 53 | } 54 | 55 | int Stack::pop() 56 | { 57 | if (stack_empty()) 58 | { 59 | std::cout << "Underflow" << "\n"; 60 | } 61 | else 62 | { 63 | --top; 64 | 65 | if (min_stack[top_min] == a[top + 1]) 66 | { 67 | top_min--; 68 | mn_val = min_stack[top_min]; 69 | } 70 | return a[top + 1]; 71 | } 72 | } 73 | 74 | int Stack::get_min() 75 | { 76 | return mn_val; 77 | } 78 | 79 | void Stack::display() 80 | { 81 | for(int i = top; i >= 0; i--) 82 | { 83 | std::cout << a[i] << " "; 84 | } 85 | } 86 | 87 | int main() 88 | { 89 | #ifndef FILE_INOUT 90 | 91 | freopen("in.txt", "r", stdin); 92 | 93 | freopen("out.txt", "w", stdout); 94 | 95 | #endif 96 | 97 | Stack stack1; 98 | stack1.push(3); 99 | stack1.push(5); 100 | std::cout << "curr min : " << stack1.get_min() << "\n"; 101 | stack1.push(2); 102 | std::cout << "curr min : " << stack1.get_min() << "\n"; 103 | stack1.push(7); 104 | stack1.push(1); 105 | std::cout << "curr min : " << stack1.get_min() << "\n"; 106 | stack1.push(4); 107 | stack1.pop(); 108 | stack1.pop(); 109 | std::cout << "curr min : " << stack1.get_min() << "\n"; 110 | return 0; 111 | } 112 | -------------------------------------------------------------------------------- /Pattern_Matching/count_permutations.cpp: -------------------------------------------------------------------------------- 1 | //Count all permutations of string A in another string B 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | bool window_equal(std::string& a, std::unordered_map& req_count, 10 | std::unordered_map& curr_count) 11 | { 12 | for (char c : a) 13 | { 14 | if (req_count[c] != curr_count[c]) 15 | return false; 16 | } 17 | return true; 18 | } 19 | 20 | int count_permutations(std::string& a, std::string& b) 21 | { 22 | std::unordered_map req_count, curr_count; 23 | for (char c : a) 24 | { 25 | if (req_count.find(c) != req_count.end()) 26 | { 27 | req_count[c]++; 28 | } 29 | else 30 | { 31 | req_count.insert({c, 1}); 32 | } 33 | } 34 | 35 | // std::cout << "Req : \n"; 36 | // for (auto it : req_count) 37 | // { 38 | // std::cout << it.first << " : " << it.second << " "; 39 | // } 40 | // std::cout << "\n"; 41 | 42 | for (int i = 0; i < a.size(); ++i) 43 | { 44 | if (curr_count.find(b[i]) != curr_count.end()) 45 | { 46 | curr_count[b[i]]++; 47 | } 48 | else 49 | { 50 | curr_count.insert({b[i], 1}); 51 | } 52 | } 53 | 54 | // std::cout << "Curr : \n"; 55 | // for (auto it : curr_count) 56 | // { 57 | // std::cout << it.first << " : " << it.second << " "; 58 | // } 59 | // std::cout << "\n"; 60 | 61 | int count = 0; 62 | 63 | if (window_equal(a, req_count, curr_count)) 64 | { 65 | count++; 66 | } 67 | 68 | for (int i = 1; i <= (b.size()-a.size()); ++i) 69 | { 70 | curr_count[b[i-1]]--; 71 | 72 | if (curr_count.find(b[i+a.size()-1]) != curr_count.end()) 73 | { 74 | curr_count[b[i+a.size()-1]]++; 75 | } 76 | else 77 | { 78 | curr_count.insert({b[i+a.size()-1], 1}); 79 | } 80 | 81 | if (window_equal(a, req_count, curr_count)) 82 | { 83 | count++; 84 | } 85 | } 86 | 87 | return count; 88 | } 89 | 90 | int main() 91 | { 92 | #ifndef FILE_INOUT 93 | 94 | freopen("in.txt", "r", stdin); 95 | 96 | freopen("out.txt", "w", stdout); 97 | 98 | #endif 99 | 100 | std::string a, b; 101 | std::getline(std::cin, a); 102 | std::getline(std::cin, b); 103 | 104 | std::cout << count_permutations(a, b) << "\n"; 105 | 106 | return 0; 107 | } 108 | -------------------------------------------------------------------------------- /Stack/sort_array_using_stack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define max 1000 5 | class Stack 6 | { 7 | int top; 8 | 9 | public: 10 | int a[max]; 11 | Stack() 12 | { 13 | top=-1; 14 | } 15 | bool stack_empty(); 16 | void push(int x); 17 | int pop(); 18 | int get_top(); 19 | void display(); 20 | }; 21 | 22 | bool Stack::stack_empty() 23 | { 24 | if(top == -1) 25 | return true; 26 | else 27 | return false; 28 | } 29 | 30 | void Stack::push(int x) 31 | { 32 | int s = max-1; 33 | if(top < s) 34 | { 35 | top = top+1; 36 | a[top] = x; 37 | } 38 | else 39 | std::cout << "overflow" << "\n"; 40 | } 41 | 42 | int Stack::pop() 43 | { 44 | if (stack_empty()) 45 | { 46 | std::cout << "Underflow" << "\n"; 47 | } 48 | else 49 | { 50 | --top; 51 | return a[top + 1]; 52 | } 53 | } 54 | 55 | int Stack::get_top() 56 | { 57 | if (top == -1) 58 | { 59 | std::cout << "Underflow\n"; 60 | } 61 | return a[top]; 62 | } 63 | 64 | void Stack::display() 65 | { 66 | for(int i = top; i >= 0; i--) 67 | { 68 | std::cout << a[i] << " "; 69 | } 70 | } 71 | 72 | int main() 73 | { 74 | #ifndef FILE_INOUT 75 | 76 | freopen("in.txt", "r", stdin); 77 | 78 | freopen("out.txt", "w", stdout); 79 | 80 | #endif 81 | 82 | std::vector vec = {9, 5, 7, 3, 8, 2, 6, 1}; 83 | 84 | Stack stack; 85 | Stack tmp; 86 | 87 | for (int x : vec) 88 | { 89 | if (stack.stack_empty()) 90 | { 91 | stack.push(x); 92 | } 93 | else 94 | { 95 | if (stack.get_top() < x) 96 | { 97 | while (stack.get_top() < x) 98 | { 99 | tmp.push(stack.pop()); 100 | } 101 | 102 | stack.push(x); 103 | while (!tmp.stack_empty()) 104 | { 105 | stack.push(tmp.pop()); 106 | } 107 | } 108 | else 109 | { 110 | stack.push(x); 111 | } 112 | } 113 | } 114 | 115 | stack.display(); 116 | return 0; 117 | } 118 | -------------------------------------------------------------------------------- /Graph_Algorithms/Breadth First Search/bfs_min_dist_hospital.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | class Coordinate 8 | { 9 | public: 10 | int x; 11 | int y; 12 | 13 | Coordinate(int x, int y) : x(x), y(y) {} 14 | }; 15 | 16 | class NodeData 17 | { 18 | public: 19 | Coordinate cord; 20 | int dist; 21 | 22 | NodeData(Coordinate c, int d) : cord(c), dist(d) {} 23 | }; 24 | 25 | std::vector ROW = {-1, 0, 0, 1}; 26 | std::vector COL = {0, -1, 1, 0}; 27 | 28 | std::vector> shortest_path(std::vector>& mat) 29 | { 30 | int r = mat.size(); 31 | int c = mat[0].size(); 32 | 33 | std::vector> visited(r, std::vector(c, 0)); 34 | std::vector> result(r, std::vector(c)); 35 | 36 | std::queue q; 37 | for (int i = 0; i < r; ++i) 38 | { 39 | for (int j = 0; j < c; ++j) 40 | { 41 | if (mat[i][j] == 'H') 42 | { 43 | q.push(NodeData(Coordinate(i, j), 0)); 44 | visited[i][j] = 1; 45 | } 46 | } 47 | } 48 | 49 | while (!q.empty()) 50 | { 51 | NodeData curr = q.front(); 52 | q.pop(); 53 | 54 | Coordinate curr_cord = curr.cord; 55 | int i = curr_cord.x; 56 | int j = curr_cord.y; 57 | int curr_dist = curr.dist; 58 | 59 | result[i][j] = curr_dist; 60 | 61 | for (int k = 0; k < 4; ++k) 62 | { 63 | int nxt_row = i+ROW[k]; 64 | int nxt_col = j+COL[k]; 65 | if (nxt_row >= 0 && nxt_row < r 66 | && nxt_col >= 0 && nxt_col < c 67 | && visited[nxt_row][nxt_col] == 0) 68 | { 69 | 70 | q.push(NodeData(Coordinate(nxt_row, nxt_col), curr_dist+1)); 71 | visited[nxt_row][nxt_col] = 1; 72 | } 73 | } 74 | } 75 | return result; 76 | } 77 | 78 | int main() 79 | { 80 | #ifndef FILE_INOUT 81 | 82 | freopen("in.txt", "r", stdin); 83 | 84 | freopen("out.txt", "w", stdout); 85 | 86 | #endif 87 | 88 | //R means residency, H means house 89 | std::vector> mat = {{'R', 'R', 'R', 'H'}, 90 | {'R', 'R', 'H', 'H'}, 91 | {'R', 'H', 'H', 'R'}}; 92 | 93 | auto res = shortest_path(mat); 94 | 95 | for (int i = 0; i < res.size(); ++i) 96 | { 97 | for (int j = 0; j < res[0].size(); ++j) 98 | { 99 | std::cout << res[i][j] << " "; 100 | } 101 | std::cout << "\n"; 102 | } 103 | 104 | return 0; 105 | } 106 | -------------------------------------------------------------------------------- /2D_Matrix/Submatrix_sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int submatrix_sum(std::vector>& mat, std::pair& top_left, std::pair& bottom_right) 7 | { 8 | int r = mat.size(); 9 | int c = mat[0].size(); 10 | 11 | std::vector> ps_rows(r, std::vector(c)); 12 | std::vector> ps(r, std::vector(c)); 13 | 14 | for (int i = 0; i < r; ++i) 15 | { 16 | for (int j = 0; j < c; ++j) 17 | { 18 | if (j == 0) 19 | { 20 | ps_rows[i][j] = mat[i][j]; 21 | } 22 | else 23 | { 24 | ps_rows[i][j] = ps_rows[i][j-1] + mat[i][j]; 25 | } 26 | } 27 | } 28 | 29 | // for (int i = 0; i < r; ++i) 30 | // { 31 | // for (int j = 0; j < c; ++j) 32 | // { 33 | // std::cout << ps_rows[i][j] << " "; 34 | // } 35 | // std::cout << "\n"; 36 | // } 37 | 38 | for (int i = 0; i < r; ++i) 39 | { 40 | for (int j = 0; j < c; ++j) 41 | { 42 | if (i == 0) 43 | { 44 | ps[i][j] = ps_rows[i][j]; 45 | } 46 | else 47 | { 48 | ps[i][j] = ps[i-1][j] + ps_rows[i][j]; 49 | } 50 | } 51 | } 52 | 53 | // for (int i = 0; i < r; ++i) 54 | // { 55 | // for (int j = 0; j < c; ++j) 56 | // { 57 | // std::cout << ps[i][j] << " "; 58 | // } 59 | // std::cout << "\n"; 60 | // } 61 | 62 | int start_i = top_left.first, start_j = top_left.second; 63 | int end_i = bottom_right.first, end_j = bottom_right.second; 64 | 65 | int ans = ps[end_i][end_j]; 66 | 67 | if (start_i > 0) 68 | { 69 | ans = ans - ps[start_i-1][end_j]; 70 | } 71 | 72 | if (start_j > 0) 73 | { 74 | ans = ans - ps[end_i][start_j-1]; 75 | } 76 | 77 | if (start_i > 0 && start_j > 0) 78 | { 79 | ans = ans + ps[start_i-1][start_j-1]; 80 | } 81 | 82 | return ans; 83 | } 84 | 85 | int main() 86 | { 87 | #ifndef FILE_INOUT 88 | 89 | freopen("in.txt", "r", stdin); 90 | 91 | freopen("out.txt", "w", stdout); 92 | 93 | #endif 94 | 95 | std::vector> mat = { 96 | {1, 2, 3}, 97 | {4, 5, 6}, 98 | {7, 8, 9} 99 | }; 100 | 101 | std::pair top_left = {0, 0}; 102 | std::pair bottom_right = {1, 1}; 103 | 104 | std::cout << submatrix_sum(mat, top_left, bottom_right) << "\n"; 105 | 106 | return 0; 107 | } 108 | -------------------------------------------------------------------------------- /Graph_Algorithms/Depth First Seacrh/conflicted_area.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Given the map of conflicted area b/w two countries, I and P. 3 | * 'I' will take back all land that is completely surrounded by 'I'. 4 | * Return the final state of map. 5 | **/ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | std::vector ROW = {1, 0, 0, -1}; 13 | std::vector COL = {0, 1, -1, 0}; 14 | 15 | void dfs(int i, int j, std::vector>& mat) 16 | { 17 | if (i < 0 || i >= mat.size() || j < 0 || j >= mat[0].size() 18 | || mat[i][j] == 'I' || mat[i][j] == 'F') 19 | { 20 | return; 21 | } 22 | mat[i][j] = 'F'; //free 23 | 24 | for (int k = 0; k < 4; ++k) 25 | { 26 | int nx_r = i + ROW[k]; 27 | int nx_c = j + COL[k]; 28 | 29 | dfs(nx_r, nx_c, mat); 30 | } 31 | } 32 | 33 | void new_map_state(std::vector>& mat) 34 | { 35 | for (int i = 0; i < mat.size(); ++i) 36 | { 37 | if (i == 0 || i == mat.size()-1) 38 | { 39 | for (int j = 0; j < mat[0].size(); ++j) 40 | { 41 | if (mat[i][j] == 'P') 42 | { 43 | dfs(i, j, mat); 44 | } 45 | } 46 | } 47 | } 48 | 49 | for (int i = 0; i < mat.size(); ++i) 50 | { 51 | for (int j = 0; j < mat[0].size(); ++j) 52 | { 53 | if (j == 0 || j == mat[0].size()-1 && mat[i][j] == 'P') 54 | { 55 | dfs(i, j, mat); 56 | } 57 | } 58 | } 59 | 60 | 61 | for (int i = 0; i < mat.size(); ++i) 62 | { 63 | for (int j = 0; j < mat[0].size(); ++j) 64 | { 65 | if (mat[i][j] == 'F') 66 | { 67 | mat[i][j] = 'P'; 68 | } 69 | else if (mat[i][j] == 'P') 70 | { 71 | mat[i][j] = 'I'; 72 | } 73 | } 74 | } 75 | } 76 | 77 | int main() 78 | { 79 | #ifndef FILE_INOUT 80 | 81 | freopen("in.txt", "r", stdin); 82 | 83 | freopen("out.txt", "w", stdout); 84 | 85 | #endif 86 | 87 | std::vector> mat = { 88 | {'I', 'I', 'P', 'I', 'I'}, 89 | {'I', 'P', 'P', 'I', 'I'}, 90 | {'I', 'I', 'I', 'I', 'I'}, 91 | {'I', 'P', 'I', 'I', 'P'}, 92 | {'I', 'P', 'P', 'I', 'P'}, 93 | {'I', 'I', 'I', 'I', 'P'}, 94 | {'I', 'I', 'I', 'P', 'I'} 95 | }; 96 | 97 | new_map_state(mat); 98 | 99 | for (int i = 0; i < mat.size(); ++i) 100 | { 101 | for (int j = 0; j < mat[0].size(); ++j) 102 | { 103 | std::cout << mat[i][j] << " "; 104 | } 105 | std::cout << "\n"; 106 | } 107 | 108 | return 0; 109 | } 110 | -------------------------------------------------------------------------------- /Maximum Priority Queue/C++/maxpriorityqueue.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int parent(int index) 5 | { 6 | return (index - 1)/2; 7 | } 8 | 9 | template 10 | void max_heapify(std::vector& array, size_t index) 11 | { 12 | size_t largest; 13 | size_t left = (2*index) + 1; 14 | size_t right = left + 1; 15 | 16 | if(left < array.size() && array[left] > array[index]) 17 | largest = left; 18 | else 19 | largest = index; 20 | 21 | if(right < array.size() && array[right] > array[largest]) 22 | largest = right; 23 | 24 | if(largest != index) 25 | { 26 | std::swap(array[index], array[largest]); 27 | max_heapify(array, largest); 28 | } 29 | } 30 | 31 | template 32 | void build_max_heap(std::vector& array) 33 | { 34 | for(int64_t i = (int64_t(array.size())/2) - 1; i >= 0; i--) 35 | max_heapify(array, i); 36 | } 37 | 38 | template 39 | T heap_maximum(std::vector& array) 40 | { 41 | return array[0]; 42 | } 43 | 44 | template 45 | T heap_extract_max(std::vector& array) 46 | { 47 | T max = array[0]; 48 | array[0] = array[array.size() - 1]; 49 | array.resize(array.size() - 1); 50 | max_heapify(array, 0); 51 | return max; 52 | } 53 | 54 | template 55 | void heap_increase_key(std::vector& array, size_t index, T value) 56 | { 57 | if(value < array[index]) 58 | { 59 | std::cerr <<"New value is smaller than the current value\n"; 60 | return; 61 | } 62 | else 63 | { 64 | array[index] = value; 65 | while(index > 0 && array[parent(index)] < array[index]) 66 | { 67 | std::swap(array[index], array[parent(index)]); 68 | index = parent(index); 69 | } 70 | } 71 | } 72 | 73 | template 74 | void max_heap_insert(std::vector& array, T value) 75 | { 76 | array.resize(array.size() + 1); 77 | array[array.size() - 1] = -1; 78 | heap_increase_key(array, array.size() - 1, value); 79 | } 80 | 81 | template 82 | void print_heap(const std::vector& array) 83 | { 84 | for(size_t i = 0; i < array.size(); i++) 85 | { 86 | std::cout << array[i] << " "; 87 | } 88 | } 89 | 90 | int main() 91 | { 92 | std::vector v({1, 2, 6, 3, 7}); 93 | build_max_heap(v); 94 | std::cout << "Max-Heap: "; 95 | print_heap(v); 96 | std::cout << "\n"; 97 | std::cout << "Extract-Maximum: " << heap_extract_max(v) << "\n"; 98 | std::cout << "New Heap: "; 99 | print_heap(v); 100 | max_heap_insert(v, 17); 101 | std::cout << "\nNew Heap after inserting 17: "; 102 | print_heap(v); 103 | max_heap_insert(v, 10); 104 | std::cout << "\nNew Heap after inserting 10: "; 105 | print_heap(v); 106 | std::cout << '\n'; 107 | } 108 | -------------------------------------------------------------------------------- /Sorting/Merge Sort/mergeSort.py: -------------------------------------------------------------------------------- 1 | def get_input(): 2 | """ 3 | get input from user 4 | """ 5 | input_str = input("Enter elements to be sorted: ") 6 | try: 7 | elements = [int(e) for e in input_str.split()] #make a list of integers from input string 8 | except ValueError: 9 | print("Please enter a list of integers only, seperated by a space!!") 10 | return elements 11 | 12 | def merge(thelist, start_idx: int, mid_idx: int, last_idx: int): 13 | """ 14 | Merge two lists to form a single sorted list 15 | """ 16 | size_left = mid_idx - start_idx + 1 #size of left list 17 | size_right = last_idx - mid_idx #size of right list 18 | 19 | left_lst = [] 20 | right_lst = [] 21 | 22 | for i in range(size_left): #appending elements in left list 23 | left_lst.append(thelist[start_idx + i]) 24 | 25 | for j in range(size_right): #appending elements in right list 26 | right_lst.append(thelist[mid_idx + 1 + j]) 27 | 28 | left_idx = 0 29 | right_idx = 0 30 | curr_idx = start_idx 31 | 32 | #left index should be less than size of left list 33 | #right index should be less than size of right list 34 | while left_idx < size_left and right_idx < size_right: 35 | 36 | if left_lst[left_idx] <= right_lst[right_idx]: #comparing first elements of left list and right list 37 | thelist[curr_idx] = left_lst[left_idx] 38 | left_idx += 1 #increment 39 | 40 | else: 41 | thelist[curr_idx] = right_lst[right_idx] 42 | right_idx += 1 #increment 43 | 44 | curr_idx += 1 #increment 45 | 46 | #elemets in left list are not compared and all elements in right list are compared 47 | while left_idx < size_left: 48 | thelist[curr_idx] = left_lst[left_idx] 49 | curr_idx += 1 #increment 50 | left_idx += 1 #increment 51 | 52 | #elemets in right list are not compared and all elements in left list are compared 53 | while right_idx < size_right: 54 | thelist[curr_idx] = right_lst[right_idx] 55 | curr_idx += 1 #increment 56 | right_idx += 1 #increment 57 | 58 | def merge_sort(thelist, start_idx: int, last_idx: int): 59 | """ 60 | Merge Sort Algorithm 61 | """ 62 | if len(thelist) == 0: 63 | print("Empty list!!") 64 | 65 | elif len(thelist) == 1: 66 | print("Only one element!!") 67 | 68 | elif start_idx < last_idx: 69 | mid_idx = (start_idx + last_idx) // 2 #middle element index 70 | merge_sort(thelist, start_idx, mid_idx) 71 | merge_sort(thelist, mid_idx + 1, last_idx) 72 | merge(thelist, start_idx, mid_idx, last_idx) 73 | 74 | if __name__ == '__main__': 75 | input_list = get_input() 76 | merge_sort(input_list, 0, len(input_list) - 1) 77 | print(*input_list, sep = ", ") 78 | -------------------------------------------------------------------------------- /Linked_List/reverse_first_k.cpp: -------------------------------------------------------------------------------- 1 | //Reverse first k nodes of a LL 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | class LinkedList 9 | { 10 | struct Node 11 | { 12 | int data; 13 | Node * next = nullptr; 14 | Node(int value) : data(value), next(nullptr) {} 15 | }; 16 | Node *head; 17 | 18 | public: 19 | LinkedList() : head(nullptr) {} 20 | ~LinkedList() 21 | { 22 | Node *tmp = nullptr; 23 | while (head) 24 | { 25 | tmp = head; 26 | head = head->next; 27 | delete tmp; 28 | } 29 | head = nullptr; 30 | } 31 | 32 | void insert(int); 33 | void reverse_first_k(int); 34 | void printList() const; 35 | Node* reverse_first_k_(Node* head, int k) 36 | { 37 | if (head == nullptr || k <= 1) 38 | { 39 | return head; 40 | } 41 | 42 | Node* next_node = head; 43 | Node* h2 = nullptr; 44 | 45 | while (k > 0 && next_node != nullptr) 46 | { 47 | Node* tmp = next_node; 48 | next_node = next_node->next; 49 | tmp->next = h2; 50 | h2 = tmp; 51 | k--; 52 | } 53 | head->next = next_node; 54 | return h2; 55 | } 56 | }; 57 | 58 | void LinkedList::insert(int value) 59 | { 60 | Node *node = new Node(value); 61 | Node *tmp = head; 62 | if (tmp == nullptr) 63 | { 64 | head = node; 65 | } 66 | else 67 | { 68 | while (tmp->next != nullptr) 69 | { 70 | tmp = tmp->next; 71 | } 72 | tmp->next = node; 73 | } 74 | } 75 | 76 | void LinkedList::reverse_first_k(int k) 77 | { 78 | head = reverse_first_k_(head, k); 79 | } 80 | 81 | void LinkedList::printList() const 82 | { 83 | if (head == nullptr) 84 | { 85 | std::cout << "Empty List \n"; 86 | return; 87 | } 88 | 89 | Node *node = head; 90 | 91 | while (node != nullptr) 92 | { 93 | std::cout << node->data << " "; 94 | node = node->next; 95 | } 96 | 97 | std::cout << "\n"; 98 | } 99 | 100 | int main() 101 | { 102 | #ifndef FILE_INOUT 103 | 104 | freopen("in.txt", "r", stdin); 105 | 106 | freopen("out.txt", "w", stdout); 107 | 108 | #endif 109 | 110 | LinkedList ll1; 111 | ll1.insert(1); 112 | ll1.insert(2); 113 | ll1.insert(3); 114 | ll1.insert(4); 115 | ll1.insert(5); 116 | ll1.insert(6); 117 | ll1.insert(7); 118 | std::cout << "Original List : "; 119 | ll1.printList(); 120 | 121 | ll1.reverse_first_k(9); 122 | std::cout << "New List : "; 123 | ll1.printList(); 124 | } 125 | -------------------------------------------------------------------------------- /Linked_List/insert_in_sorted_ll.cpp: -------------------------------------------------------------------------------- 1 | //Given a LL, sorted in ascending order. Insert a value 2 | //maintaing the sorted order 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | class LinkedList 10 | { 11 | struct Node 12 | { 13 | int data; 14 | Node * next = nullptr; 15 | Node(int value) : data(value), next(nullptr) {} 16 | }; 17 | Node *head; 18 | 19 | public: 20 | LinkedList() : head(nullptr) {} 21 | ~LinkedList() 22 | { 23 | Node *tmp = nullptr; 24 | while (head) 25 | { 26 | tmp = head; 27 | head = head->next; 28 | delete tmp; 29 | } 30 | head = nullptr; 31 | } 32 | 33 | void insert(int); 34 | void insert_in_sorted(int); 35 | void printList() const; 36 | Node* insert_in_sorted_(Node* head, int k) 37 | { 38 | Node* new_node = new Node(k); 39 | 40 | if (head == nullptr) 41 | { 42 | return new_node; 43 | } 44 | 45 | if (k <= head->data) 46 | { 47 | new_node->next = head; 48 | return new_node; 49 | } 50 | 51 | Node* tmp = head; 52 | 53 | while(tmp->next != nullptr && tmp->next->data < k) 54 | { 55 | tmp = tmp->next; 56 | } 57 | 58 | new_node->next = tmp->next; 59 | tmp->next = new_node; 60 | return head; 61 | } 62 | }; 63 | 64 | void LinkedList::insert(int value) 65 | { 66 | Node *node = new Node(value); 67 | Node *tmp = head; 68 | if (tmp == nullptr) 69 | { 70 | head = node; 71 | } 72 | else 73 | { 74 | while (tmp->next != nullptr) 75 | { 76 | tmp = tmp->next; 77 | } 78 | tmp->next = node; 79 | } 80 | } 81 | 82 | void LinkedList::insert_in_sorted(int k) 83 | { 84 | head = insert_in_sorted_(head, k); 85 | } 86 | 87 | void LinkedList::printList() const 88 | { 89 | if (head == nullptr) 90 | { 91 | std::cout << "Empty List \n"; 92 | return; 93 | } 94 | 95 | Node *node = head; 96 | 97 | while (node != nullptr) 98 | { 99 | std::cout << node->data << " "; 100 | node = node->next; 101 | } 102 | 103 | std::cout << "\n"; 104 | } 105 | 106 | int main() 107 | { 108 | #ifndef FILE_INOUT 109 | 110 | freopen("in.txt", "r", stdin); 111 | 112 | freopen("out.txt", "w", stdout); 113 | 114 | #endif 115 | 116 | LinkedList ll1; 117 | ll1.insert(1); 118 | ll1.insert(2); 119 | ll1.insert(3); 120 | ll1.insert(4); 121 | ll1.insert(5); 122 | ll1.insert(6); 123 | ll1.insert(7); 124 | std::cout << "Original List : "; 125 | ll1.printList(); 126 | 127 | ll1.insert_in_sorted(4); 128 | std::cout << "New List : "; 129 | ll1.printList(); 130 | } 131 | -------------------------------------------------------------------------------- /Linked_List/reverse_ll.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | class LinkedList 6 | { 7 | struct Node 8 | { 9 | T data; 10 | Node * next; 11 | Node(T value) : data(std::move(value)), next(nullptr) {} 12 | }; 13 | Node *head; 14 | 15 | public: 16 | LinkedList() : head(nullptr) {} 17 | LinkedList(const LinkedList& ll) = delete; //copy constructor 18 | LinkedList(const LinkedList&& ll) = delete; //move constructor 19 | LinkedList& operator=(const LinkedList& ll) = delete; //copy assignment 20 | LinkedList& operator=(const LinkedList&& ll) = delete; //move assignment 21 | ~LinkedList(); 22 | void insert(T); 23 | void printList(); 24 | void recursiveReverse() 25 | { 26 | head = recursiveReverse(head); 27 | } 28 | 29 | void iterativeReverse() 30 | { 31 | head = iterativeReverse(head); 32 | } 33 | private: 34 | Node* recursiveReverse(Node* head) 35 | { 36 | if(head == nullptr) 37 | return nullptr; 38 | 39 | if(head->next == nullptr) 40 | return head; 41 | 42 | Node *firstElement = head; 43 | Node *secondElement = firstElement->next; 44 | head = firstElement->next; 45 | firstElement->next = nullptr; //unlink first node 46 | Node *remainingList = recursiveReverse(head); 47 | secondElement->next = firstElement; 48 | return remainingList; 49 | } 50 | 51 | Node* iterativeReverse(Node* head) 52 | { 53 | Node *previous = nullptr; 54 | Node *nextNode = nullptr; 55 | while(head) 56 | { 57 | nextNode = head->next; 58 | head->next = previous; 59 | previous = head; 60 | head = nextNode; 61 | } 62 | return previous; 63 | } 64 | }; 65 | 66 | template 67 | void LinkedList::insert(T data) 68 | { 69 | Node *node = new Node(std::move(data)); 70 | Node *tmp = head; 71 | if(tmp == nullptr) 72 | { 73 | head = node; 74 | } 75 | else 76 | { 77 | while(tmp->next != nullptr) 78 | { 79 | tmp = tmp->next; 80 | } 81 | tmp->next = node; 82 | } 83 | } 84 | 85 | template 86 | void LinkedList::printList() 87 | { 88 | Node *node = head; 89 | while(node) 90 | { 91 | std::cout << node->data << " "; 92 | node = node->next; 93 | } 94 | std::cout<<"\n"; 95 | } 96 | template 97 | LinkedList::~LinkedList() 98 | { 99 | Node *tmp = nullptr; 100 | while(head) 101 | { 102 | tmp = head; 103 | head = head->next; 104 | delete tmp; 105 | } 106 | head = nullptr; 107 | } 108 | 109 | int main() 110 | { 111 | LinkedList ll1; 112 | ll1.insert(2); 113 | ll1.insert(3); 114 | ll1.insert(4); 115 | ll1.insert(5); 116 | ll1.insert(6); 117 | ll1.printList(); 118 | ll1.recursiveReverse(); 119 | ll1.printList(); 120 | } 121 | -------------------------------------------------------------------------------- /Graph_Algorithms/Breadth First Search/bfs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | class Graph 7 | { 8 | int vertexCount; 9 | //WHITE means Undiscovered, GRAY means Discovered, BLACK menas Processed 10 | enum class Color{ WHITE, GRAY, BLACK }; 11 | 12 | const int imax = std::numeric_limits::max(); 13 | 14 | struct Vertex 15 | { 16 | int id; 17 | Color color; 18 | size_t distance; 19 | 20 | Vertex(const int vertex, Color clr, int imax) : id(vertex), 21 | color(clr), 22 | distance(imax) 23 | {}; 24 | }; 25 | std::vector< std::vector > adjMatrix; //adjacency adjMatrix 26 | std::vector vertices; 27 | public: 28 | Graph(int size) 29 | { 30 | vertexCount = size; 31 | adjMatrix.resize(vertexCount, std::vector(vertexCount)); 32 | for(int i = 0; i < vertexCount; i++) 33 | { 34 | vertices.push_back( Vertex(i, Color::WHITE, imax)); 35 | for(int j = 0; j < vertexCount; j++) 36 | adjMatrix[i][j] = false; 37 | } 38 | } 39 | ~Graph() {}; 40 | 41 | void BFS(const int); 42 | void addEdge(int, int); 43 | void printMatrix(); 44 | }; 45 | 46 | void Graph::BFS(const int src) 47 | { 48 | const auto s = vertices[src].id; 49 | vertices[s].color = Color::GRAY; 50 | vertices[s].distance = 0; 51 | 52 | 53 | std::queue Q; 54 | Q.push(vertices[s].id); 55 | 56 | while(!Q.empty()) 57 | { 58 | auto u = Q.front(); 59 | Q.pop(); 60 | 61 | for (int j = 0; j < vertexCount; j++) 62 | { 63 | if(vertices[j].color == Color::WHITE && adjMatrix[u][j] == true) 64 | { 65 | vertices[j].color = Color::GRAY; 66 | vertices[j].distance = vertices[u].distance + 1; 67 | Q.push(j); 68 | } 69 | } 70 | vertices[u].color = Color::BLACK; 71 | std::cout << vertices[u].id << " at level " << vertices[u].distance <<'\n'; 72 | } 73 | } 74 | 75 | void Graph::addEdge(int u, int v) 76 | { 77 | adjMatrix[u][v] = true; 78 | adjMatrix[v][u] = true; 79 | } 80 | 81 | void Graph::printMatrix() 82 | { 83 | for(int i = 0; i < vertexCount; i++) 84 | { 85 | for(int j = 0; j < vertexCount; j++) 86 | { 87 | std::cout << adjMatrix[i][j] << " "; 88 | } 89 | std::cout << '\n'; 90 | } 91 | } 92 | 93 | int main() 94 | { 95 | Graph grp1(8); 96 | grp1.addEdge(0, 1); 97 | grp1.addEdge(0, 2); 98 | grp1.addEdge(1, 3); 99 | grp1.addEdge(1, 4); 100 | grp1.addEdge(2, 5); 101 | grp1.addEdge(3, 4); 102 | grp1.addEdge(3, 6); 103 | grp1.addEdge(4, 6); 104 | grp1.addEdge(4, 7); 105 | grp1.addEdge(6, 7); 106 | 107 | grp1.BFS(0); 108 | std::cout << "\nAdjacency Matrix for the Graph is \n"; 109 | grp1.printMatrix(); 110 | } 111 | -------------------------------------------------------------------------------- /Graph_Algorithms/Depth First Seacrh/Using Adjacency List/dfswithlist.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class Graph 5 | { 6 | int vertex_count; 7 | enum Color {WHITE, GRAY, BLACK}; 8 | 9 | struct Vertex 10 | { 11 | int id; 12 | Color color; 13 | Vertex(int _id) : id(_id), 14 | color(Color::WHITE) 15 | {} 16 | }; 17 | 18 | struct Adj_list_node 19 | { 20 | int dest_id; 21 | Adj_list_node * next; 22 | Adj_list_node(int _dest_id) : dest_id(_dest_id), 23 | next (nullptr) 24 | {} 25 | }; 26 | 27 | struct Adj_list 28 | { 29 | Adj_list_node *head; 30 | }; 31 | 32 | std::vector vertices; 33 | std::vector adjacent; 34 | 35 | public: 36 | Graph(int); 37 | void add_edge(int, int); 38 | void depth_first_search(); 39 | 40 | private: 41 | void depth_first_search_visit(int); 42 | }; 43 | 44 | Graph::Graph(int v) 45 | { 46 | vertex_count = v; 47 | adjacent.resize(vertex_count); 48 | 49 | for (int i = 0; i < vertex_count; i++) 50 | { 51 | vertices.push_back( Vertex(i) ); 52 | adjacent[i].head = nullptr; 53 | } 54 | } 55 | 56 | void Graph::depth_first_search() 57 | { 58 | for (const auto& u: vertices) 59 | { 60 | if (vertices[u.id].color == WHITE) 61 | { 62 | depth_first_search_visit(u.id); 63 | } 64 | } 65 | } 66 | 67 | void Graph::depth_first_search_visit(int u) 68 | { 69 | vertices[u].color = GRAY; 70 | std::cout << vertices[u].id <<" "; 71 | const auto& v = adjacent[u].head; 72 | if (vertices[v->dest_id].color == WHITE) 73 | { 74 | depth_first_search_visit(v->dest_id); 75 | } 76 | vertices[u].color = BLACK; 77 | } 78 | 79 | void Graph::add_edge(int src, int dest) 80 | { 81 | Adj_list_node *node = new Adj_list_node(dest); 82 | if (adjacent[src].head == nullptr) 83 | { 84 | adjacent[src].head = node; 85 | } 86 | else 87 | { 88 | Adj_list_node *tmp = adjacent[src].head; 89 | while (tmp->next != nullptr) 90 | tmp = tmp->next; 91 | 92 | tmp->next = node; 93 | } 94 | 95 | //undirected graph 96 | node = new Adj_list_node(src); 97 | if (adjacent[dest].head == nullptr) 98 | { 99 | adjacent[dest].head = node; 100 | } 101 | else 102 | { 103 | Adj_list_node *tmp = adjacent[dest].head; 104 | while (tmp->next != nullptr) 105 | tmp = tmp->next; 106 | 107 | tmp->next = node; 108 | } 109 | } 110 | 111 | int main() 112 | { 113 | Graph grp(4); 114 | grp.add_edge(0, 1); 115 | grp.add_edge(1, 2); 116 | grp.add_edge(2, 3); 117 | grp.add_edge(2, 1); 118 | grp.add_edge(0, 3); 119 | grp.depth_first_search(); 120 | std::cout << "\n"; 121 | } 122 | -------------------------------------------------------------------------------- /Linked_List/count_node_pairs.cpp: -------------------------------------------------------------------------------- 1 | //Given sorted Doubly LL of unique integers. Count number of 2 | //pairs of node whose sum of value is equal to k. 3 | 4 | #include 5 | 6 | class DoublyLinkedList 7 | { 8 | struct Node 9 | { 10 | int data; 11 | Node* next; 12 | Node* prev; 13 | Node(int val): data(val), next(nullptr), prev(nullptr) {} 14 | }; 15 | Node *head, *tail; 16 | 17 | public: 18 | DoublyLinkedList(): head(nullptr), tail(nullptr) {} 19 | 20 | ~DoublyLinkedList() 21 | { 22 | Node *tmp = nullptr; 23 | while (head) 24 | { 25 | tmp = head; 26 | head = head->next; 27 | delete tmp; 28 | } 29 | head = nullptr; 30 | } 31 | 32 | void insertFront(int val) 33 | { 34 | Node *node = new Node(val); 35 | Node *tmp = head; 36 | if (head == nullptr) 37 | { 38 | head = node; 39 | tail = node; 40 | } 41 | else 42 | { 43 | node->next = head; 44 | head = node; 45 | node->next->prev = node; 46 | } 47 | } 48 | 49 | void insertBack(int val) 50 | { 51 | Node *node = new Node(val); 52 | if(tail->next == nullptr) 53 | { 54 | tail->next = node; 55 | node->prev = tail; 56 | tail = node; 57 | } 58 | } 59 | 60 | void display() 61 | { 62 | Node *node = head; 63 | while(node != nullptr) 64 | { 65 | std::cout << node->data << " "; 66 | node = node->next; 67 | } 68 | } 69 | 70 | int count_pairs(int k) 71 | { 72 | Node *p1 = head; 73 | Node *p2 = tail; 74 | int count = 0; 75 | 76 | while (p1 != p2 && p2->next != p1) 77 | { 78 | if ((p1->data + p2->data) < k) 79 | { 80 | p1 = p1->next; 81 | } 82 | else if ((p1->data + p2->data) > k) 83 | { 84 | p2 = p2->prev; 85 | } 86 | else 87 | { 88 | count++; 89 | p1 = p1->next; 90 | p2 = p2->prev; 91 | } 92 | } 93 | return count; 94 | } 95 | }; 96 | 97 | int main(){ 98 | #ifndef FILE_INOUT 99 | 100 | freopen("in.txt", "r", stdin); 101 | 102 | freopen("out.txt", "w", stdout); 103 | 104 | #endif 105 | 106 | DoublyLinkedList l1; 107 | l1.insertFront(-3); 108 | l1.insertBack(0); 109 | l1.insertBack(3); 110 | l1.insertBack(6); 111 | l1.insertBack(14); 112 | l1.insertBack(25); 113 | l1.display(); 114 | std::cout << "\n" << l1.count_pairs(17) << "\n"; 115 | return 0; 116 | } 117 | -------------------------------------------------------------------------------- /Stack/max_min_sum.cpp: -------------------------------------------------------------------------------- 1 | /** Given an array. Find sum of max-min for every subarray **/ 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | void clear_stack(std::stack& st) 9 | { 10 | while (!st.empty()) 11 | { 12 | st.pop(); 13 | } 14 | } 15 | 16 | int min_max_sum(std::vector& arr) 17 | { 18 | int n = arr.size(); 19 | int mod = 1000000007; 20 | std::vector min_val_idx_L(n), min_val_idx_R(n), max_val_idx_L(n), max_val_idx_R(n); 21 | 22 | std::stack index_st; 23 | 24 | for (int i = 0; i < arr.size(); i++) 25 | { 26 | while (!index_st.empty() && arr[index_st.top()] <= arr[i]) 27 | { 28 | index_st.pop(); 29 | } 30 | 31 | if (index_st.empty()) 32 | { 33 | max_val_idx_L[i] = -1; 34 | } 35 | else if (arr[index_st.top()] > arr[i]) 36 | { 37 | max_val_idx_L[i] = index_st.top(); 38 | } 39 | index_st.push(i); 40 | } 41 | 42 | clear_stack(index_st); 43 | 44 | for (int i = 0; i < arr.size(); i++) 45 | { 46 | while (!index_st.empty() && arr[index_st.top()] >= arr[i]) 47 | { 48 | index_st.pop(); 49 | } 50 | 51 | if (index_st.empty()) 52 | { 53 | min_val_idx_L[i] = -1; 54 | } 55 | else if (arr[index_st.top()] < arr[i]) 56 | { 57 | min_val_idx_L[i] = index_st.top(); 58 | } 59 | index_st.push(i); 60 | } 61 | clear_stack(index_st); 62 | 63 | for (int i = arr.size()-1; i >= 0; i--) 64 | { 65 | while (!index_st.empty() && arr[index_st.top()] <= arr[i]) 66 | { 67 | index_st.pop(); 68 | } 69 | 70 | if (index_st.empty()) 71 | { 72 | max_val_idx_R[i] = n; 73 | } 74 | else if (arr[index_st.top()] > arr[i]) 75 | { 76 | max_val_idx_R[i] = index_st.top(); 77 | } 78 | index_st.push(i); 79 | } 80 | 81 | clear_stack(index_st); 82 | 83 | for (int i = arr.size()-1; i >= 0; i--) 84 | { 85 | while (!index_st.empty() && arr[index_st.top()] >= arr[i]) 86 | { 87 | index_st.pop(); 88 | } 89 | 90 | if (index_st.empty()) 91 | { 92 | min_val_idx_R[i] = n; 93 | } 94 | else if (arr[index_st.top()] < arr[i]) 95 | { 96 | min_val_idx_R[i] = index_st.top(); 97 | } 98 | index_st.push(i); 99 | } 100 | 101 | int mx_sum = 0, mn_sum = 0; 102 | 103 | for (int i = 0; i < arr.size(); ++i) 104 | { 105 | int sum = arr[i]; 106 | 107 | sum = (sum * (((max_val_idx_R[i] - i) * (i - max_val_idx_L[i])) % mod)) % mod; 108 | 109 | mx_sum = (mx_sum + sum) % mod; 110 | 111 | sum = arr[i]; 112 | 113 | sum = (sum * (((min_val_idx_R[i] - i) * (i - min_val_idx_L[i])) % mod)) % mod; 114 | 115 | mn_sum = (mn_sum + sum) % mod; 116 | } 117 | 118 | return (mx_sum - mn_sum); 119 | } 120 | 121 | int main() 122 | { 123 | #ifndef FILE_INOUT 124 | 125 | freopen("in.txt", "r", stdin); 126 | 127 | freopen("out.txt", "w", stdout); 128 | 129 | #endif 130 | 131 | std::vector arr = {2, 5, 3}; 132 | std::cout << min_max_sum(arr); 133 | 134 | return 0; 135 | } 136 | -------------------------------------------------------------------------------- /Linked_List/singly_ll.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | template 4 | class LinkedList 5 | { 6 | struct Node 7 | { 8 | T data; 9 | Node * next; 10 | Node(T val): data(val), next(nullptr){} 11 | }; 12 | Node *head; 13 | 14 | public: 15 | LinkedList() : head(nullptr){} 16 | LinkedList(const LinkedList & ll) = delete; 17 | LinkedList& operator=(LinkedList const&) = delete; 18 | ~LinkedList(); 19 | void insert(T); 20 | void display(std::ostream& out = std::cout) const 21 | { 22 | Node *node = head; 23 | while(node != nullptr) 24 | { 25 | out << node->data << " "; 26 | node = node->next; 27 | } 28 | } 29 | 30 | void deleteNode(T); 31 | template 32 | friend std::ostream & operator<<(std::ostream & os, const LinkedList & ll); 33 | 34 | private: 35 | struct Node *search(T n) 36 | { //returns node of the given value 37 | Node *node = head; 38 | while(node != nullptr) 39 | { 40 | if(node->data == n) 41 | return node; 42 | node = node->next; 43 | } 44 | 45 | std::cerr << "No such element in the list \n"; 46 | return nullptr; 47 | } 48 | 49 | }; 50 | 51 | template 52 | std::ostream & operator<<(std::ostream & os, const LinkedList& ll) 53 | { 54 | ll.display(os); 55 | return os; 56 | } 57 | 58 | template 59 | void LinkedList::insert(T data) 60 | { 61 | Node *t = new Node(data); 62 | Node *tmp = head; 63 | if (tmp == nullptr) 64 | { 65 | head = t; 66 | } 67 | else 68 | { 69 | while (tmp->next != nullptr) 70 | { 71 | tmp = tmp->next; 72 | } 73 | tmp->next = t; 74 | } 75 | } 76 | 77 | template 78 | void LinkedList::deleteNode(T data) 79 | { 80 | Node *node=search(data); 81 | Node *tmp = head; 82 | 83 | if(tmp == node) 84 | { 85 | head=tmp->next; 86 | } 87 | else if (node != nullptr) 88 | { 89 | while(node != nullptr) 90 | { 91 | if(tmp->next==node) 92 | { 93 | tmp->next=node->next; 94 | return ; 95 | } 96 | tmp=tmp->next; 97 | } 98 | delete tmp; 99 | } 100 | } 101 | 102 | template 103 | LinkedList::~LinkedList() 104 | { 105 | Node *tmp = nullptr; 106 | while (head) 107 | { 108 | tmp = head; 109 | head = head->next; 110 | delete tmp; 111 | } 112 | head =nullptr; 113 | } 114 | 115 | int main() 116 | { 117 | LinkedList ll1; 118 | ll1.insert(5); 119 | ll1.insert(6); 120 | ll1.insert(7); 121 | ll1.insert(8); 122 | std::cout< ll2; 126 | ll2.insert('a'); 127 | ll2.insert('r'); 128 | ll2.insert('d'); 129 | ll2.insert('y'); 130 | std::cout< 2 | #include 3 | 4 | template 5 | void merge(std::vector& v, int p, int q, int r) 6 | { 7 | int size1 = q-p+1; 8 | int size2 = r-q; 9 | std::vector L(size1); 10 | std::vector R(size2); 11 | 12 | for(int i = 0; i < size1; i++) 13 | { 14 | L[i] = v[p+i]; 15 | } 16 | for(int j = 0; j < size2; j++) 17 | { 18 | R[j]=v[q+j+1]; 19 | } 20 | 21 | int i=0,j=0; 22 | int k; 23 | for(k = p; k <= r && i < size1 && j < size2; k++) 24 | { 25 | if(L[i] <= R[j]) 26 | { 27 | v[k] = L[i]; 28 | i++; 29 | } 30 | else 31 | { 32 | v[k] = R[j]; 33 | j++; 34 | } 35 | } 36 | for(i = i; i < size1; ++i) 37 | { 38 | v[k] = L[i]; 39 | k++; 40 | } 41 | 42 | for(j = j; j < size2; j++) 43 | { 44 | v[k] = R[j]; 45 | k++; 46 | } 47 | } 48 | 49 | template 50 | void merge_sort(std::vector& v, int p, int r) 51 | { 52 | if(p < r) 53 | { 54 | int q = (p+r)/2; 55 | merge_sort(v, p, q); 56 | merge_sort(v, q+1, r); 57 | merge(v, p, q, r); 58 | } 59 | } 60 | 61 | int main() 62 | { 63 | std::vectorvec; 64 | vec.push_back(13); 65 | vec.push_back(5); 66 | vec.push_back(7); 67 | vec.push_back(7); 68 | vec.push_back(4); 69 | vec.push_back(2); 70 | vec.push_back(10); 71 | int sz = vec.size(); 72 | std::cout << "Entered array : "; 73 | for(int n = 0; n < sz; n++) 74 | { 75 | std::cout << vec[n] <<" "; 76 | } 77 | std::cout << "\n"; 78 | std::cout << "Sorted array : "; 79 | merge_sort(vec, 0, sz-1); 80 | for(int n = 0; n < sz; n++) 81 | { 82 | std::cout << vec[n] << " "; 83 | } 84 | std::cout << "\n\n"; 85 | 86 | std::vector c; 87 | c.push_back('d'); 88 | c.push_back('y'); 89 | c.push_back('h'); 90 | c.push_back('l'); 91 | c.push_back('e'); 92 | c.push_back('a'); 93 | int sz1 = c.size(); 94 | std::cout << "Entered array : "; 95 | for(int n = 0; n < sz1; n++) 96 | { 97 | std::cout << c[n] <<" "; 98 | } 99 | std::cout << "\n"; 100 | std::cout << "Sorted array : "; 101 | merge_sort(c, 0, sz1-1); 102 | for(int n = 0; n < sz1; n++) 103 | { 104 | std::cout << c[n] << " "; 105 | } 106 | std::cout << "\n\n"; 107 | 108 | std::vector str; 109 | str.push_back("car"); 110 | str.push_back("dog"); 111 | str.push_back("apple"); 112 | str.push_back("ball"); 113 | str.push_back("tree"); 114 | int sz2 = str.size(); 115 | 116 | std::cout << "Entered array : "; 117 | for(int n = 0; n < sz2; n++) 118 | { 119 | std::cout << str[n] <<" "; 120 | } 121 | std::cout << "\n"; 122 | std::cout << "Sorted array : "; 123 | merge_sort(str, 0, sz2-1); 124 | for(int n = 0; n < sz2; n++) 125 | { 126 | std::cout << str[n] << " "; 127 | } 128 | std::cout << "\n"; 129 | 130 | return 0; 131 | } 132 | -------------------------------------------------------------------------------- /Linked_List/find_middle_node.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | class LinkedList 7 | { 8 | struct Node 9 | { 10 | int data; 11 | Node * next = nullptr; 12 | Node(int value) : data(value), next(nullptr) {} 13 | }; 14 | Node *head; 15 | 16 | public: 17 | LinkedList() : head(nullptr) {} 18 | ~LinkedList() 19 | { 20 | Node *tmp = nullptr; 21 | while (head) 22 | { 23 | tmp = head; 24 | head = head->next; 25 | delete tmp; 26 | } 27 | head = nullptr; 28 | } 29 | 30 | void insert(int); 31 | int find_first_middle_node(); 32 | int find_second_middle_node(); 33 | void printList() const; 34 | Node* find_first_middle_node_(Node* head_) 35 | { 36 | Node* slow_ptr = head_; 37 | Node* fast_ptr = head_; 38 | 39 | while (fast_ptr->next != nullptr 40 | && fast_ptr->next->next != nullptr) 41 | { 42 | fast_ptr = fast_ptr->next->next; 43 | slow_ptr = slow_ptr->next; 44 | } 45 | return slow_ptr; 46 | } 47 | 48 | Node* find_second_middle_node_(Node* head_) 49 | { 50 | Node* slow_ptr = head_; 51 | Node* fast_ptr = head_; 52 | 53 | while (fast_ptr != nullptr 54 | && fast_ptr->next != nullptr) 55 | { 56 | fast_ptr = fast_ptr->next->next; 57 | slow_ptr = slow_ptr->next; 58 | } 59 | return slow_ptr; 60 | } 61 | }; 62 | 63 | void LinkedList::insert(int value) 64 | { 65 | Node *node = new Node(value); 66 | Node *tmp = head; 67 | if (tmp == nullptr) 68 | { 69 | head = node; 70 | } 71 | else 72 | { 73 | while (tmp->next != nullptr) 74 | { 75 | tmp = tmp->next; 76 | } 77 | tmp->next = node; 78 | } 79 | } 80 | 81 | int LinkedList::find_first_middle_node() 82 | { 83 | Node* node = find_first_middle_node_(head); 84 | return node->data; 85 | } 86 | 87 | int LinkedList::find_second_middle_node() 88 | { 89 | Node* node = find_second_middle_node_(head); 90 | return node->data; 91 | } 92 | 93 | void LinkedList::printList() const 94 | { 95 | if (head == nullptr) 96 | { 97 | std::cout << "Empty List \n"; 98 | return; 99 | } 100 | 101 | Node *node = head; 102 | 103 | while (node != nullptr) 104 | { 105 | std::cout << node->data << " "; 106 | node = node->next; 107 | } 108 | 109 | std::cout << "\n"; 110 | } 111 | 112 | int main() 113 | { 114 | #ifndef FILE_INOUT 115 | 116 | freopen("in.txt", "r", stdin); 117 | 118 | freopen("out.txt", "w", stdout); 119 | 120 | #endif 121 | 122 | LinkedList ll1; 123 | ll1.insert(1); 124 | ll1.insert(2); 125 | ll1.insert(3); 126 | ll1.insert(4); 127 | ll1.insert(5); 128 | ll1.insert(6); 129 | std::cout << "Original List : "; 130 | ll1.printList(); 131 | 132 | std::cout << ll1.find_first_middle_node() << " "; 133 | std::cout << ll1.find_second_middle_node() << " "; 134 | //ll1.printList(); 135 | } 136 | -------------------------------------------------------------------------------- /Bellman Ford/C++/bellmanford.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | class Graph 7 | { 8 | 9 | struct Vertex 10 | { 11 | std::size_t id; 12 | int distance = std::numeric_limits::max(); 13 | Vertex(std::size_t id) : id(id) {} 14 | }; 15 | std::vector vertices; 16 | std::map, int> edge_weight; 17 | 18 | public: 19 | Graph(std::size_t); 20 | void add_edge(std::size_t, std::size_t, int); //source, destination, weight 21 | bool bellman_ford(std::size_t); //source 22 | std::ostream& distance_from_source(std::ostream&) const; 23 | 24 | private: 25 | void relax(std::size_t, std::size_t, int); //source, destination, weight 26 | }; 27 | 28 | Graph::Graph(std::size_t size) 29 | { 30 | vertices.reserve(size); 31 | for (int i = 0; i < size; i++) 32 | { 33 | vertices.push_back(Vertex(i)); 34 | } 35 | } 36 | 37 | void Graph::add_edge(std::size_t src, std::size_t dest, int weight) 38 | { 39 | if (src == dest) 40 | throw std::logic_error("Source and destination vertices are same"); 41 | 42 | if (src < 0 || vertices.size() <= src) 43 | throw std::out_of_range("Enter correct source vertex"); 44 | 45 | if (dest < 0 || vertices.size() <= dest) 46 | throw std::out_of_range("Enter correct destination vertex"); 47 | 48 | const auto inserted = edge_weight.insert(std::make_pair( 49 | std::make_pair(src, dest), weight )); 50 | if (!inserted.second) 51 | throw std::logic_error("Existing edge"); 52 | } 53 | 54 | void Graph::relax(std::size_t src, std::size_t dest, int weight) 55 | { 56 | if (vertices[dest].distance > (vertices[src].distance + weight)) 57 | { 58 | vertices[dest].distance = (vertices[src].distance + weight); 59 | } 60 | } 61 | 62 | bool Graph::bellman_ford(std::size_t src) 63 | { 64 | //initialize distance of source 65 | vertices[src].distance = 0; 66 | 67 | for (int i = 0; i < vertices.size() - 1; i++) 68 | { 69 | for (auto it = edge_weight.begin(); it != edge_weight.end(); it++) 70 | { 71 | relax(it->first.first, it->first.second, it->second); 72 | } 73 | } 74 | 75 | for (auto it = edge_weight.begin(); it != edge_weight.end(); it++) 76 | { 77 | if (vertices[it->first.second].distance 78 | > (vertices[it->first.first].distance + it->second)) 79 | return false; 80 | } 81 | return true; 82 | } 83 | 84 | std::ostream& Graph::distance_from_source(std::ostream& os) const 85 | { 86 | os << "Vertex\t\tDistance from Source\n"; 87 | for (int i = 0; i < vertices.size(); i++) 88 | { 89 | os << vertices[i].id <<"\t\t" << vertices[i].distance <<"\n"; 90 | } 91 | } 92 | 93 | 94 | int main() 95 | { 96 | Graph grp(5); 97 | grp.add_edge(0, 1, 6); 98 | grp.add_edge(0, 2, 7); 99 | grp.add_edge(1, 3, 5); 100 | grp.add_edge(1, 4, -4); 101 | grp.add_edge(1, 2, 8); 102 | grp.add_edge(2, 3, -3); 103 | grp.add_edge(2, 4, 9); 104 | grp.add_edge(3, 1, -2); 105 | grp.add_edge(4, 0, 2); 106 | grp.add_edge(4, 3, 7); 107 | 108 | bool res = grp.bellman_ford(0); 109 | if (res == true) 110 | std::cout << "Graph contains no negative cycle \n"; 111 | else 112 | std::cout << "Graph conatins negative cycle \n"; 113 | 114 | grp.distance_from_source(std::cout); 115 | } 116 | -------------------------------------------------------------------------------- /Linked_List/doublylinkedlist.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | template 4 | class DoublyLinkedList 5 | { 6 | struct Node 7 | { 8 | T data; 9 | Node* next; 10 | Node* prev; 11 | Node(T val): data(val), next(nullptr), prev(nullptr) {} 12 | }; 13 | Node *head, *tail; 14 | 15 | public: 16 | DoublyLinkedList(): head(nullptr), tail(nullptr) {} 17 | 18 | ~DoublyLinkedList() 19 | { 20 | Node *tmp = nullptr; 21 | while (head) 22 | { 23 | tmp = head; 24 | head = head->next; 25 | delete tmp; 26 | } 27 | head = nullptr; 28 | } 29 | 30 | DoublyLinkedList(const DoublyLinkedList & dll) = delete; 31 | DoublyLinkedList& operator=(DoublyLinkedList const&) = delete; 32 | 33 | void insertFront(T val) 34 | { 35 | Node *node = new Node(val); 36 | Node *tmp = head; 37 | if (head == nullptr) 38 | { 39 | head = node; 40 | tail = node; 41 | } 42 | else 43 | { 44 | node->next = head; 45 | head = node; 46 | node->next->prev = node; 47 | } 48 | } 49 | 50 | void insertBack(T val) 51 | { 52 | Node *node = new Node(val); 53 | if(tail->next == nullptr) 54 | { 55 | tail->next = node; 56 | node->prev = tail; 57 | tail = node; 58 | } 59 | } 60 | 61 | 62 | void deleteVal(T val) 63 | { 64 | Node* find = findVal(val); 65 | Node *tmp = head; 66 | 67 | if(tmp == find) 68 | { 69 | head = tmp->next; 70 | } 71 | else 72 | { 73 | while(find != nullptr) 74 | { 75 | if(tmp->next == find) 76 | { 77 | tmp->next = find->next; 78 | find->next->prev = tmp; 79 | delete find; 80 | return; 81 | } 82 | tmp = tmp->next; 83 | } 84 | } 85 | } 86 | 87 | template 88 | friend std::ostream & operator<<(std::ostream & os, const DoublyLinkedList & dll){ 89 | dll.display(os); 90 | return os; 91 | } 92 | 93 | private: 94 | 95 | Node *findVal(T n) //returns node of the given number 96 | { 97 | Node *node = head; 98 | while(node != nullptr) 99 | { 100 | if(node->data == n) 101 | return node; 102 | 103 | node = node->next; 104 | } 105 | std::cerr << "No such element in the list \n"; 106 | return nullptr; 107 | } 108 | 109 | void display(std::ostream& out = std::cout) const 110 | { 111 | Node *node = head; 112 | while(node != nullptr) 113 | { 114 | out << node->data << " "; 115 | node = node->next; 116 | } 117 | } 118 | }; 119 | 120 | int main(){ 121 | DoublyLinkedList l1; 122 | l1.insertFront(3); 123 | l1.insertBack(5); 124 | l1.insertBack(12); 125 | l1.insertFront(6); 126 | l1.insertBack(88); 127 | std::cout< 2 | #include 3 | #include 4 | 5 | class LinkedList 6 | { 7 | struct Node 8 | { 9 | int data; 10 | Node * next = nullptr; 11 | Node(int value) : data(std::move(value)), next(nullptr) {} 12 | }; 13 | Node *head; 14 | 15 | public: 16 | LinkedList() : head(nullptr) {} 17 | ~LinkedList() 18 | { 19 | Node *tmp = nullptr; 20 | while (head) 21 | { 22 | tmp = head; 23 | head = head->next; 24 | delete tmp; 25 | } 26 | head = nullptr; 27 | } 28 | 29 | void insert(int); 30 | void exchangeEvenOdd(); 31 | void printList() const; 32 | 33 | private: 34 | static void advance(Node*& node) 35 | { 36 | assert (node != nullptr); 37 | node = node->next; 38 | } 39 | 40 | Node* getLastNode() 41 | { 42 | Node *node = head; 43 | while (node->next != nullptr) 44 | node = node->next; 45 | 46 | return node; 47 | } 48 | 49 | bool isOdd(int num) 50 | { 51 | if (num % 2 != 0) 52 | return true; 53 | else 54 | return false; 55 | } 56 | }; 57 | 58 | void LinkedList::insert(int value) 59 | { 60 | Node *node = new Node(std::move(value)); 61 | Node *tmp = head; 62 | if (tmp == nullptr) 63 | { 64 | head = node; 65 | } 66 | else 67 | { 68 | tmp = getLastNode(); 69 | tmp->next = node; 70 | } 71 | } 72 | 73 | void LinkedList::exchangeEvenOdd() 74 | { 75 | Node *node = nullptr; 76 | Node *lastNodeToTest = getLastNode(); 77 | Node *tail = lastNodeToTest; 78 | 79 | while (isOdd(head->data) == true) 80 | { 81 | node = head; 82 | advance(head); 83 | tail->next = node; 84 | advance(tail); 85 | } 86 | 87 | Node *tmp = head; 88 | Node *curr = head; 89 | 90 | while (tmp->next != lastNodeToTest) 91 | { 92 | if (isOdd(curr->next->data) == true) 93 | { 94 | node = curr->next; 95 | curr->next = node->next; 96 | tail->next = node; 97 | advance(tail); 98 | } 99 | else 100 | { 101 | //advance "curr" and "tmp" only when next node to it is even 102 | advance(curr); 103 | advance(tmp); 104 | } 105 | } 106 | 107 | if (isOdd(curr->next->data) == true && tmp->next == lastNodeToTest) 108 | { 109 | node = lastNodeToTest; 110 | curr->next = lastNodeToTest->next; 111 | tail->next = lastNodeToTest; 112 | advance(tail); 113 | } 114 | tail->next = nullptr; 115 | lastNodeToTest = nullptr; 116 | node = nullptr; 117 | } 118 | 119 | void LinkedList::printList() const 120 | { 121 | if (head == nullptr) 122 | { 123 | std::cout << "Empty List \n"; 124 | return; 125 | } 126 | 127 | Node *node = head; 128 | 129 | while (node != nullptr) 130 | { 131 | std::cout << node->data << " "; 132 | advance(node); 133 | } 134 | 135 | std::cout << "\n"; 136 | } 137 | 138 | int main() 139 | { 140 | LinkedList ll1; 141 | ll1.insert(1); 142 | ll1.insert(2); 143 | ll1.insert(3); 144 | ll1.insert(4); 145 | ll1.insert(5); 146 | ll1.insert(6); 147 | ll1.insert(7); 148 | std::cout << "Original List : "; 149 | ll1.printList(); 150 | 151 | ll1.exchangeEvenOdd(); 152 | std::cout << "New List : "; 153 | ll1.printList(); 154 | } 155 | -------------------------------------------------------------------------------- /Linked_List/linkedlistwithloop.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | class LinkedList 6 | { 7 | struct Node 8 | { 9 | T data; 10 | Node * next; 11 | Node(T value) : data(std::move(value)), next(nullptr) {} 12 | }; 13 | Node *head; 14 | 15 | public: 16 | LinkedList() : head(nullptr) {} 17 | LinkedList(const LinkedList& ll) = delete; //copy constructor 18 | LinkedList& operator=(const LinkedList& ll) = delete; //copy assignment 19 | ~LinkedList(); 20 | void insert(T); 21 | void createLoop(int); 22 | int lengthOfLoop(); 23 | Node* doesLoopExist() 24 | { 25 | Node *slowPtr = head; 26 | Node *fastPtr = head; 27 | 28 | while(slowPtr && fastPtr && fastPtr->next) 29 | { 30 | slowPtr = slowPtr->next; 31 | fastPtr = fastPtr->next->next; 32 | 33 | if(slowPtr == fastPtr) 34 | { 35 | return slowPtr; 36 | } 37 | } 38 | return nullptr; 39 | } 40 | }; 41 | 42 | template 43 | void LinkedList::insert(T data) 44 | { 45 | Node *node = new Node(std::move(data)); 46 | Node *tmp = head; 47 | if(tmp == nullptr) 48 | { 49 | head = node; 50 | } 51 | else 52 | { 53 | while(tmp->next != nullptr) 54 | { 55 | tmp = tmp->next; 56 | } 57 | tmp->next = node; 58 | } 59 | } 60 | 61 | template 62 | void LinkedList::createLoop(int n) 63 | { 64 | Node *tmp = head; 65 | Node *tail = head; 66 | for(int i = 0; i < n-1; i++) 67 | { 68 | tmp = tmp->next; 69 | } 70 | 71 | while(tail->next != nullptr) 72 | { 73 | tail = tail->next; 74 | } 75 | tail->next = tmp; 76 | } 77 | 78 | template 79 | int LinkedList::lengthOfLoop() 80 | { 81 | int count = 0; 82 | bool loopExist = false; 83 | Node *slowPtr = nullptr, *fastPtr = nullptr; 84 | 85 | slowPtr = doesLoopExist(); 86 | fastPtr = slowPtr; 87 | if(slowPtr != nullptr) 88 | { 89 | loopExist = true; 90 | } 91 | else 92 | { 93 | return 0; 94 | } 95 | if(loopExist) 96 | { 97 | fastPtr = fastPtr->next; 98 | count++; 99 | while(slowPtr != fastPtr) 100 | { 101 | fastPtr = fastPtr->next; 102 | count++; 103 | } 104 | return count; 105 | } 106 | return 0; 107 | } 108 | 109 | template 110 | LinkedList::~LinkedList() 111 | { 112 | Node *tmp = nullptr; 113 | while(head) 114 | { 115 | tmp = head; 116 | head = head->next; 117 | delete tmp; 118 | } 119 | head = nullptr; 120 | } 121 | 122 | int main() 123 | { 124 | LinkedList ll1; 125 | ll1.insert('p'); 126 | ll1.insert('r'); 127 | ll1.insert('o'); 128 | ll1.insert('g'); 129 | ll1.insert('r'); 130 | ll1.insert('a'); 131 | ll1.insert('m'); 132 | ll1.insert('m'); 133 | ll1.insert('e'); 134 | ll1.insert('r'); 135 | 136 | int nodeNumber = 5; 137 | //Node number starts from 1 138 | 139 | ll1.createLoop(nodeNumber); 140 | bool result = ll1.doesLoopExist(); 141 | if(result == true) 142 | { 143 | std::cout <<"Loop exist in the Linked List\n"; 144 | } 145 | else 146 | { 147 | std::cout <<"Loop does not exist in the Linked List\n"; 148 | } 149 | 150 | int len = ll1.lengthOfLoop(); 151 | std::cout << "Length of Loop is " << len <<"\n"; 152 | 153 | exit(0); 154 | } 155 | --------------------------------------------------------------------------------