├── .eslintrc.cjs ├── .gitignore ├── LICENSE ├── README.md ├── docs ├── assets │ ├── bg-city-night-Hn7IgFgp.webp │ ├── bg-cotton-orb-COQ-b5QR.webp │ ├── firacode-DmifnrmV.woff2 │ ├── index-CCPfFMQM.js │ ├── index-DqUlzqnG.css │ └── silkscreen-DLtPLOcD.woff2 ├── favicon │ ├── android-chrome-192x192.png │ ├── android-chrome-512x512.png │ ├── apple-touch-icon.png │ ├── favicon-16x16.png │ ├── favicon-32x32.png │ ├── favicon.ico │ └── site.webmanifest ├── index.html └── robots.txt ├── index.html ├── package-lock.json ├── package.json ├── public ├── favicon │ ├── android-chrome-192x192.png │ ├── android-chrome-512x512.png │ ├── apple-touch-icon.png │ ├── favicon-16x16.png │ ├── favicon-32x32.png │ ├── favicon.ico │ └── site.webmanifest └── robots.txt ├── src ├── code │ ├── cpp │ │ ├── array │ │ │ ├── prefix_sum.cpp │ │ │ ├── sliding_window.cpp │ │ │ ├── string_building.cpp │ │ │ ├── two_pointers_one_input.cpp │ │ │ └── two_pointers_two_inputs.cpp │ │ ├── backtracking │ │ │ └── backtracking.cpp │ │ ├── binary_search │ │ │ ├── binary_search.cpp │ │ │ ├── duplicate_elements_left_insertion.cpp │ │ │ ├── duplicate_elements_right_insertion.cpp │ │ │ ├── greedy_maximum.cpp │ │ │ └── greedy_minimum.cpp │ │ ├── binary_tree │ │ │ ├── bfs.cpp │ │ │ ├── dfs_iterative.cpp │ │ │ └── dfs_recursive.cpp │ │ ├── bit_manipulation │ │ │ ├── check_power_of_two.cpp │ │ │ ├── clear_kth_bit.cpp │ │ │ ├── count_set_bits.cpp │ │ │ ├── divide_power_of_two.cpp │ │ │ ├── get_rightmost_bit.cpp │ │ │ ├── multiply_power_of_two.cpp │ │ │ ├── set_kth_bit.cpp │ │ │ ├── swap_variables.cpp │ │ │ ├── test_kth_bit.cpp │ │ │ └── toggle_kth_bit.cpp │ │ ├── data_structures │ │ │ ├── array.cpp │ │ │ ├── binary_search_tree.cpp │ │ │ ├── binary_tree.cpp │ │ │ ├── doubly_linked_list.cpp │ │ │ ├── graph.cpp │ │ │ ├── hash_map.cpp │ │ │ ├── linked_list.cpp │ │ │ ├── trie.cpp │ │ │ ├── union_find.cpp │ │ │ └── union_find_optimized.cpp │ │ ├── dynamic_programming │ │ │ ├── bottom_up.cpp │ │ │ ├── kadane.cpp │ │ │ └── top_down.cpp │ │ ├── graph │ │ │ ├── bellman_ford.cpp │ │ │ ├── bfs.cpp │ │ │ ├── dfs_iterative.cpp │ │ │ ├── dfs_recursive.cpp │ │ │ ├── dijkstra.cpp │ │ │ ├── kahn.cpp │ │ │ ├── kruskal.cpp │ │ │ └── prim.cpp │ │ ├── hash_map │ │ │ ├── find_number_of_subarrays.cpp │ │ │ └── sliding_window.cpp │ │ ├── heap │ │ │ └── find_top_k_elements.cpp │ │ ├── linked_list │ │ │ ├── fast_and_slow_pointer.cpp │ │ │ └── reverse_linked_list.cpp │ │ ├── matrix │ │ │ ├── create_copy.cpp │ │ │ ├── diagonals.cpp │ │ │ └── rotate_transpose.cpp │ │ ├── sorting_algorithms │ │ │ ├── bogo_sort.cpp │ │ │ ├── bubble_sort.cpp │ │ │ ├── bucket_sort.cpp │ │ │ ├── counting_sort.cpp │ │ │ ├── cube_sort.cpp │ │ │ ├── heap_sort.cpp │ │ │ ├── insertion_sort.cpp │ │ │ ├── merge_sort.cpp │ │ │ ├── pancake_sort.cpp │ │ │ ├── quick_sort.cpp │ │ │ ├── radix_sort.cpp │ │ │ ├── selection_sort.cpp │ │ │ ├── shell_sort.cpp │ │ │ ├── sleep_sort.cpp │ │ │ └── tim_sort.cpp │ │ └── stack │ │ │ ├── monotonic_decreasing.cpp │ │ │ └── monotonic_increasing.cpp │ ├── java │ │ ├── array │ │ │ ├── prefix_sum.java │ │ │ ├── sliding_window.java │ │ │ ├── string_building.java │ │ │ ├── two_pointers_one_input.java │ │ │ └── two_pointers_two_inputs.java │ │ ├── backtracking │ │ │ └── backtracking.java │ │ ├── binary_search │ │ │ ├── binary_search.java │ │ │ ├── duplicate_elements_left_insertion.java │ │ │ ├── duplicate_elements_right_insertion.java │ │ │ ├── greedy_maximum.java │ │ │ └── greedy_minimum.java │ │ ├── binary_tree │ │ │ ├── bfs.java │ │ │ ├── dfs_iterative.java │ │ │ └── dfs_recursive.java │ │ ├── bit_manipulation │ │ │ ├── check_power_of_two.java │ │ │ ├── clear_kth_bit.java │ │ │ ├── count_set_bits.java │ │ │ ├── divide_power_of_two.java │ │ │ ├── get_rightmost_bit.java │ │ │ ├── multiply_power_of_two.java │ │ │ ├── set_kth_bit.java │ │ │ ├── swap_variables.java │ │ │ ├── test_kth_bit.java │ │ │ └── toggle_kth_bit.java │ │ ├── data_structures │ │ │ ├── array.java │ │ │ ├── binary_search_tree.java │ │ │ ├── binary_tree.java │ │ │ ├── doubly_linked_list.java │ │ │ ├── graph.java │ │ │ ├── hash_map.java │ │ │ ├── linked_list.java │ │ │ ├── trie.java │ │ │ ├── union_find.java │ │ │ └── union_find_optimized.java │ │ ├── dynamic_programming │ │ │ ├── bottom_up.java │ │ │ ├── kadane.java │ │ │ └── top_down.java │ │ ├── graph │ │ │ ├── bellman_ford.java │ │ │ ├── bfs.java │ │ │ ├── dfs_iterative.java │ │ │ ├── dfs_recursive.java │ │ │ ├── dijkstra.java │ │ │ ├── kahn.java │ │ │ ├── kruskal.java │ │ │ └── prim.java │ │ ├── hash_map │ │ │ ├── find_number_of_subarrays.java │ │ │ └── sliding_window.java │ │ ├── heap │ │ │ └── find_top_k_elements.java │ │ ├── linked_list │ │ │ ├── fast_and_slow_pointer.java │ │ │ └── reverse_linked_list.java │ │ ├── matrix │ │ │ ├── create_copy.java │ │ │ ├── diagonals.java │ │ │ └── rotate_transpose.java │ │ ├── sorting_algorithms │ │ │ ├── bogo_sort.java │ │ │ ├── bubble_sort.java │ │ │ ├── bucket_sort.java │ │ │ ├── counting_sort.java │ │ │ ├── cube_sort.java │ │ │ ├── heap_sort.java │ │ │ ├── insertion_sort.java │ │ │ ├── merge_sort.java │ │ │ ├── pancake_sort.java │ │ │ ├── quick_sort.java │ │ │ ├── radix_sort.java │ │ │ ├── selection_sort.java │ │ │ ├── shell_sort.java │ │ │ ├── sleep_sort.java │ │ │ └── tim_sort.java │ │ └── stack │ │ │ ├── monotonic_decreasing.java │ │ │ └── monotonic_increasing.java │ ├── javascript │ │ ├── array │ │ │ ├── prefix_sum.js │ │ │ ├── sliding_window.js │ │ │ ├── string_building.js │ │ │ ├── two_pointers_one_input.js │ │ │ └── two_pointers_two_inputs.js │ │ ├── backtracking │ │ │ └── backtracking.js │ │ ├── binary_search │ │ │ ├── binary_search.js │ │ │ ├── duplicate_elements_left_insertion.js │ │ │ ├── duplicate_elements_right_insertion.js │ │ │ ├── greedy_maximum.js │ │ │ └── greedy_minimum.js │ │ ├── binary_tree │ │ │ ├── bfs.js │ │ │ ├── dfs_iterative.js │ │ │ └── dfs_recursive.js │ │ ├── bit_manipulation │ │ │ ├── check_power_of_two.js │ │ │ ├── clear_kth_bit.js │ │ │ ├── count_set_bits.js │ │ │ ├── divide_power_of_two.js │ │ │ ├── get_rightmost_bit.js │ │ │ ├── multiply_power_of_two.js │ │ │ ├── set_kth_bit.js │ │ │ ├── swap_variables.js │ │ │ ├── test_kth_bit.js │ │ │ └── toggle_kth_bit.js │ │ ├── data_structures │ │ │ ├── array.js │ │ │ ├── binary_search_tree.js │ │ │ ├── binary_tree.js │ │ │ ├── doubly_linked_list.js │ │ │ ├── graph.js │ │ │ ├── hash_map.js │ │ │ ├── linked_list.js │ │ │ ├── trie.js │ │ │ ├── union_find.js │ │ │ └── union_find_optimized.js │ │ ├── dynamic_programming │ │ │ ├── bottom_up.js │ │ │ ├── kadane.js │ │ │ └── top_down.js │ │ ├── graph │ │ │ ├── bellman_ford.js │ │ │ ├── bfs.js │ │ │ ├── dfs_iterative.js │ │ │ ├── dfs_recursive.js │ │ │ ├── dijkstra.js │ │ │ ├── kahn.js │ │ │ ├── kruskal.js │ │ │ └── prim.js │ │ ├── hash_map │ │ │ ├── find_number_of_subarrays.js │ │ │ └── sliding_window.js │ │ ├── heap │ │ │ └── find_top_k_elements.js │ │ ├── linked_list │ │ │ ├── fast_and_slow_pointer.js │ │ │ └── reverse_linked_list.js │ │ ├── matrix │ │ │ ├── create_copy.js │ │ │ ├── diagonals.js │ │ │ └── rotate_transpose.js │ │ ├── sorting_algorithms │ │ │ ├── bogo_sort.js │ │ │ ├── bubble_sort.js │ │ │ ├── bucket_sort.js │ │ │ ├── counting_sort.js │ │ │ ├── cube_sort.js │ │ │ ├── heap_sort.js │ │ │ ├── insertion_sort.js │ │ │ ├── merge_sort.js │ │ │ ├── pancake_sort.js │ │ │ ├── quick_sort.js │ │ │ ├── radix_sort.js │ │ │ ├── selection_sort.js │ │ │ ├── shell_sort.js │ │ │ ├── sleep_sort.js │ │ │ └── tim_sort.js │ │ └── stack │ │ │ ├── monotonic_decreasing.js │ │ │ └── monotonic_increasing.js │ └── python │ │ ├── array │ │ ├── prefix_sum.py │ │ ├── sliding_window.py │ │ ├── string_building.py │ │ ├── two_pointers_one_input.py │ │ └── two_pointers_two_inputs.py │ │ ├── backtracking │ │ └── backtracking.py │ │ ├── binary_search │ │ ├── binary_search.py │ │ ├── duplicate_elements_left_insertion.py │ │ ├── duplicate_elements_right_insertion.py │ │ ├── greedy_maximum.py │ │ └── greedy_minimum.py │ │ ├── binary_tree │ │ ├── bfs.py │ │ ├── dfs_iterative.py │ │ └── dfs_recursive.py │ │ ├── bit_manipulation │ │ ├── check_power_of_two.py │ │ ├── clear_kth_bit.py │ │ ├── count_set_bits.py │ │ ├── divide_power_of_two.py │ │ ├── get_rightmost_bit.py │ │ ├── multiply_power_of_two.py │ │ ├── set_kth_bit.py │ │ ├── swap_variables.py │ │ ├── test_kth_bit.py │ │ └── toggle_kth_bit.py │ │ ├── data_structures │ │ ├── array.py │ │ ├── binary_search_tree.py │ │ ├── binary_tree.py │ │ ├── doubly_linked_list.py │ │ ├── graph.py │ │ ├── hash_map.py │ │ ├── linked_list.py │ │ ├── trie.py │ │ ├── union_find.py │ │ └── union_find_optimized.py │ │ ├── dynamic_programming │ │ ├── bottom_up.py │ │ ├── kadane.py │ │ └── top_down.py │ │ ├── graph │ │ ├── bellman_ford.py │ │ ├── bfs.py │ │ ├── dfs_iterative.py │ │ ├── dfs_recursive.py │ │ ├── dijkstra.py │ │ ├── kahn.py │ │ ├── kruskal.py │ │ └── prim.py │ │ ├── hash_map │ │ ├── find_number_of_subarrays.py │ │ └── sliding_window.py │ │ ├── heap │ │ └── find_top_k_elements.py │ │ ├── linked_list │ │ ├── fast_and_slow_pointer.py │ │ └── reverse_linked_list.py │ │ ├── matrix │ │ ├── create_copy.py │ │ ├── diagonals.py │ │ └── rotate_transpose.py │ │ ├── sorting_algorithms │ │ ├── bogo_sort.py │ │ ├── bubble_sort.py │ │ ├── bucket_sort.py │ │ ├── counting_sort.py │ │ ├── cube_sort.py │ │ ├── heap_sort.py │ │ ├── insertion_sort.py │ │ ├── merge_sort.py │ │ ├── pancake_sort.py │ │ ├── quick_sort.py │ │ ├── radix_sort.py │ │ ├── selection_sort.py │ │ ├── shell_sort.py │ │ ├── sleep_sort.py │ │ └── tim_sort.py │ │ └── stack │ │ ├── monotonic_decreasing.py │ │ └── monotonic_increasing.py ├── components │ ├── Accordion │ │ ├── accordion.module.sass │ │ └── index.tsx │ ├── App │ │ └── index.tsx │ ├── Appbar │ │ └── index.tsx │ ├── Background │ │ ├── background.module.sass │ │ └── index.tsx │ ├── Brand │ │ ├── brand.module.sass │ │ └── index.tsx │ ├── Code │ │ ├── code.module.sass │ │ ├── index.tsx │ │ └── python.tsx │ ├── Content │ │ ├── content.module.sass │ │ └── index.tsx │ ├── CopyButton │ │ ├── copybutton.module.sass │ │ └── index.tsx │ ├── Language │ │ └── context.tsx │ ├── LinkWithTooltip │ │ ├── index.tsx │ │ └── linkwithtooltip.module.sass │ ├── Sidebar │ │ ├── SidebarLinks.tsx │ │ ├── context.tsx │ │ ├── index.tsx │ │ └── sidebar.module.sass │ ├── Tabs │ │ ├── index.tsx │ │ └── tabs.module.sass │ ├── ThemeSwitch │ │ ├── index.tsx │ │ └── themeswitch.module.sass │ ├── Tooltip │ │ ├── index.tsx │ │ └── tooltip.module.sass │ └── Topbar │ │ ├── index.tsx │ │ └── topbar.module.sass ├── fonts │ ├── firacode.woff2 │ ├── neometric.woff2 │ └── silkscreen.woff2 ├── hooks │ ├── useClickOutside.tsx │ ├── useScrollDistance.tsx │ ├── useScrollTo.tsx │ └── useTheme.tsx ├── icons │ ├── Check.tsx │ ├── Chevron.tsx │ ├── Copy.tsx │ ├── Cpp.tsx │ ├── Download.tsx │ ├── File.tsx │ ├── Github.tsx │ ├── GithubLight.tsx │ ├── Java.tsx │ ├── Javascript.tsx │ └── Python.tsx ├── images │ ├── banner.webp │ ├── bg-city-day.webp │ ├── bg-city-night-2.webp │ ├── bg-city-night-3.webp │ ├── bg-city-night.webp │ └── bg-cotton-orb.webp ├── main.tsx ├── sections │ ├── Array │ │ └── index.tsx │ ├── Backtracking │ │ └── index.tsx │ ├── BigO │ │ ├── Chart.tsx │ │ ├── DataStructureOperationsTable.tsx │ │ ├── SortingAlgorithmsTable.tsx │ │ ├── bigo.module.sass │ │ └── index.tsx │ ├── BinarySearch │ │ └── index.tsx │ ├── BinaryTree │ │ └── index.tsx │ ├── BitManipulation │ │ └── index.tsx │ ├── DataStructures │ │ └── index.tsx │ ├── DynamicProgramming │ │ └── index.tsx │ ├── Graph │ │ └── index.tsx │ ├── HashMap │ │ └── index.tsx │ ├── Heap │ │ └── index.tsx │ ├── LinkedList │ │ └── index.tsx │ ├── Matrix │ │ └── index.tsx │ ├── SortingAlgorithms │ │ └── index.tsx │ ├── Stack │ │ └── index.tsx │ └── section.module.sass ├── styles │ ├── buttons.sass │ ├── colors.sass │ ├── document.sass │ ├── hljstheme.sass │ ├── styles.d.ts │ ├── styles.sass │ ├── table.sass │ ├── themes.sass │ └── typography.sass └── utils │ └── clsx.tsx ├── tsconfig.json └── vite.config.ts /.eslintrc.cjs: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | root: true, 3 | env: { browser: true, es2020: true }, 4 | extends: [ 5 | 'eslint:recommended', 6 | 'plugin:react/recommended', 7 | 'plugin:react/jsx-runtime', 8 | 'plugin:react-hooks/recommended', 9 | ], 10 | ignorePatterns: ['dist', '.eslintrc.cjs'], 11 | parserOptions: { ecmaVersion: 'latest', sourceType: 'module' }, 12 | settings: { react: { version: '18.2' } }, 13 | plugins: ['react-refresh'], 14 | rules: { 15 | 'react-refresh/only-export-components': [ 16 | 'warn', 17 | { allowConstantExport: true }, 18 | ], 19 | }, 20 | } 21 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Logs 2 | logs 3 | *.log 4 | npm-debug.log* 5 | yarn-debug.log* 6 | yarn-error.log* 7 | pnpm-debug.log* 8 | lerna-debug.log* 9 | 10 | node_modules 11 | dist 12 | dist-ssr 13 | *.local 14 | 15 | # Editor directories and files 16 | .vscode/* 17 | !.vscode/extensions.json 18 | .idea 19 | .DS_Store 20 | *.suo 21 | *.ntvs* 22 | *.njsproj 23 | *.sln 24 | *.sw? 25 | 26 | # Environment 27 | .env 28 | .env.local 29 | .env.development.local 30 | .env.test.local 31 | .env.production.local 32 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |

2 | leetcode cheatsheet banner 3 |

4 | 5 | - big o time/space complexities 6 | - code templates 7 | - data structure implementations 8 | - sorting algorithms 9 | 10 | ## License 11 | This project is released under the GNU GPL License - see the [LICENSE](LICENSE) file for details 12 | -------------------------------------------------------------------------------- /docs/assets/bg-city-night-Hn7IgFgp.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/docs/assets/bg-city-night-Hn7IgFgp.webp -------------------------------------------------------------------------------- /docs/assets/bg-cotton-orb-COQ-b5QR.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/docs/assets/bg-cotton-orb-COQ-b5QR.webp -------------------------------------------------------------------------------- /docs/assets/firacode-DmifnrmV.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/docs/assets/firacode-DmifnrmV.woff2 -------------------------------------------------------------------------------- /docs/assets/silkscreen-DLtPLOcD.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/docs/assets/silkscreen-DLtPLOcD.woff2 -------------------------------------------------------------------------------- /docs/favicon/android-chrome-192x192.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/docs/favicon/android-chrome-192x192.png -------------------------------------------------------------------------------- /docs/favicon/android-chrome-512x512.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/docs/favicon/android-chrome-512x512.png -------------------------------------------------------------------------------- /docs/favicon/apple-touch-icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/docs/favicon/apple-touch-icon.png -------------------------------------------------------------------------------- /docs/favicon/favicon-16x16.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/docs/favicon/favicon-16x16.png -------------------------------------------------------------------------------- /docs/favicon/favicon-32x32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/docs/favicon/favicon-32x32.png -------------------------------------------------------------------------------- /docs/favicon/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/docs/favicon/favicon.ico -------------------------------------------------------------------------------- /docs/favicon/site.webmanifest: -------------------------------------------------------------------------------- 1 | {"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"} -------------------------------------------------------------------------------- /docs/robots.txt: -------------------------------------------------------------------------------- 1 | # https://www.robotstxt.org/robotstxt.html 2 | User-agent: * 3 | Disallow: 4 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "leetcode-cheatsheet", 3 | "private": true, 4 | "version": "1.0.0", 5 | "type": "module", 6 | "scripts": { 7 | "dev": "vite", 8 | "build": "vite build", 9 | "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0", 10 | "preview": "vite preview" 11 | }, 12 | "dependencies": { 13 | "highlight.js": "^11.9.0", 14 | "react": "^18.2.0", 15 | "react-animate-height": "^3.2.3", 16 | "react-dom": "^18.2.0", 17 | "react-responsive": "^9.0.2" 18 | }, 19 | "devDependencies": { 20 | "@types/node": "^20.11.17", 21 | "@types/react": "^18.2.55", 22 | "@types/react-dom": "^18.2.19", 23 | "@vitejs/plugin-react-swc": "^3.5.0", 24 | "eslint": "^8.55.0", 25 | "eslint-plugin-react": "^7.33.2", 26 | "eslint-plugin-react-hooks": "^4.6.0", 27 | "eslint-plugin-react-refresh": "^0.4.5", 28 | "sass": "^1.70.0", 29 | "typescript": "^5.3.3", 30 | "vite": "^5.0.8" 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /public/favicon/android-chrome-192x192.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/public/favicon/android-chrome-192x192.png -------------------------------------------------------------------------------- /public/favicon/android-chrome-512x512.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/public/favicon/android-chrome-512x512.png -------------------------------------------------------------------------------- /public/favicon/apple-touch-icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/public/favicon/apple-touch-icon.png -------------------------------------------------------------------------------- /public/favicon/favicon-16x16.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/public/favicon/favicon-16x16.png -------------------------------------------------------------------------------- /public/favicon/favicon-32x32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/public/favicon/favicon-32x32.png -------------------------------------------------------------------------------- /public/favicon/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/public/favicon/favicon.ico -------------------------------------------------------------------------------- /public/favicon/site.webmanifest: -------------------------------------------------------------------------------- 1 | {"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"} -------------------------------------------------------------------------------- /public/robots.txt: -------------------------------------------------------------------------------- 1 | # https://www.robotstxt.org/robotstxt.html 2 | User-agent: * 3 | Disallow: 4 | -------------------------------------------------------------------------------- /src/code/cpp/array/prefix_sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | vector fn(vector& arr) { 8 | int n = arr.size(); 9 | vector prefix; 10 | prefix.push_back(arr[0]); 11 | 12 | for (int i = 1; i < n; ++i) { 13 | prefix.push_back(prefix.back() + arr[i]); 14 | } 15 | 16 | return prefix; 17 | } 18 | -------------------------------------------------------------------------------- /src/code/cpp/array/sliding_window.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int fn(vector& arr) { 7 | int n = arr.size(); 8 | int window = 0; 9 | int left = 0; 10 | int ans = 0; 11 | 12 | for (int right = 0; right < n; right++) { 13 | // TODO: add arr[right] to window 14 | 15 | while (WINDOW_CONDITION_BROKEN) { 16 | // TODO: remove arr[left] from window 17 | left++; 18 | } 19 | 20 | // TODO: update ans 21 | } 22 | 23 | return ans; 24 | } 25 | -------------------------------------------------------------------------------- /src/code/cpp/array/string_building.cpp: -------------------------------------------------------------------------------- 1 | string fn(vector& arr) { 2 | return string(arr.begin(), arr.end()) 3 | } 4 | -------------------------------------------------------------------------------- /src/code/cpp/array/two_pointers_one_input.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int fn(vector& arr) { 7 | int ans = 0; 8 | int left = 0; 9 | int right = arr.size() - 1; 10 | 11 | while (left < right) { 12 | // TODO: logic with left and right 13 | if (CONDITION) { 14 | left++; 15 | } else { 16 | right--; 17 | } 18 | } 19 | 20 | return ans; 21 | } 22 | -------------------------------------------------------------------------------- /src/code/cpp/array/two_pointers_two_inputs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int fn(vector& arr1, vector& arr2) { 7 | int i = 0; 8 | int j = 0; 9 | int ans = 0; 10 | 11 | while (i < arr1.size() && j < arr2.size()) { 12 | // TODO: logic 13 | if (CONDITION) { 14 | i++; 15 | } else { 16 | j++; 17 | } 18 | } 19 | 20 | while (i < arr1.size()) { 21 | // TODO: logic 22 | i++; 23 | } 24 | 25 | while (j < arr2.size()) { 26 | // TODO: logic 27 | j++; 28 | } 29 | 30 | return ans; 31 | } 32 | -------------------------------------------------------------------------------- /src/code/cpp/backtracking/backtracking.cpp: -------------------------------------------------------------------------------- 1 | int backtrack(STATE curr, OTHER_ARGUMENTS...) { 2 | if (BASE_CASE) { 3 | // TODO: modify answer 4 | return 0; 5 | } 6 | 7 | int ans = 0; 8 | 9 | for (ITERATE_OVER_INPUT) { 10 | // TODO: modify current state 11 | ans += backtrack(curr, OTHER_ARGUMENTS...); 12 | // TODO: undo modification of current state 13 | } 14 | 15 | return ans; 16 | } 17 | -------------------------------------------------------------------------------- /src/code/cpp/binary_search/binary_search.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int fn(vector& arr, int target) { 7 | int left = 0; 8 | int right = arr.size() - 1; 9 | 10 | while (left <= right) { 11 | int mid = left + (right - left) / 2; 12 | 13 | if (arr[mid] == target) { 14 | // TODO: logic 15 | return mid; 16 | } 17 | if (arr[mid] > target) { 18 | right = mid - 1; 19 | } else { 20 | left = mid + 1; 21 | } 22 | } 23 | 24 | return left; 25 | } 26 | -------------------------------------------------------------------------------- /src/code/cpp/binary_search/duplicate_elements_left_insertion.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int fn(vector& arr, int target) { 7 | int left = 0; 8 | int right = arr.size(); 9 | 10 | while (left < right) { 11 | int mid = left + (right - left) / 2; 12 | 13 | if (arr[mid] >= target) { 14 | right = mid; 15 | } else { 16 | left = mid + 1; 17 | } 18 | } 19 | 20 | return left; 21 | } 22 | -------------------------------------------------------------------------------- /src/code/cpp/binary_search/duplicate_elements_right_insertion.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int fn(vector& arr, int target) { 7 | int left = 0; 8 | int right = arr.size(); 9 | 10 | while (left < right) { 11 | int mid = left + (right - left) / 2; 12 | 13 | if (arr[mid] > target) { 14 | right = mid; 15 | } else { 16 | left = mid + 1; 17 | } 18 | } 19 | 20 | return left; 21 | } 22 | -------------------------------------------------------------------------------- /src/code/cpp/binary_search/greedy_maximum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | bool check(int x) { 7 | return BOOLEAN; 8 | } 9 | 10 | int fn(vector& arr) { 11 | int left = MINIMUM_POSSIBLE_ANSWER; 12 | int right = MAXIMUM_POSSIBLE_ANSWER; 13 | 14 | while (left <= right) { 15 | int mid = left + (right - left) / 2; 16 | 17 | if (check(mid)) { 18 | left = mid + 1; 19 | } else { 20 | right = mid - 1; 21 | } 22 | } 23 | 24 | return right; 25 | } 26 | -------------------------------------------------------------------------------- /src/code/cpp/binary_search/greedy_minimum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | bool check(int x) { 7 | return BOOLEAN; 8 | } 9 | 10 | int fn(vector& arr) { 11 | int left = MINIMUM_POSSIBLE_ANSWER; 12 | int right = MAXIMUM_POSSIBLE_ANSWER; 13 | 14 | while (left <= right) { 15 | int mid = left + (right - left) / 2; 16 | 17 | if (check(mid)) { 18 | right = mid - 1; 19 | } else { 20 | left = mid + 1; 21 | } 22 | } 23 | 24 | return left; 25 | } 26 | -------------------------------------------------------------------------------- /src/code/cpp/binary_tree/bfs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int fn(TreeNode* root) { 7 | queue que; 8 | que.push(root); 9 | int ans = 0; 10 | 11 | while (!que.empty()) { 12 | int currentLength = que.size(); 13 | // TODO: logic for current level 14 | 15 | for (int i = 0; i < currentLength; i++) { 16 | TreeNode* node = que.front(); 17 | que.pop(); 18 | // TODO: logic 19 | if (node->left != nullptr) { 20 | que.push(node->left); 21 | } 22 | if (node->right != nullptr) { 23 | que.push(node->right); 24 | } 25 | } 26 | } 27 | 28 | return ans; 29 | } 30 | -------------------------------------------------------------------------------- /src/code/cpp/binary_tree/dfs_iterative.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int dfs(TreeNode* root) { 7 | stack stack; 8 | stack.push(root); 9 | int ans = 0; 10 | 11 | while (!stack.empty()) { 12 | TreeNode* node = stack.top(); 13 | stack.pop(); 14 | // TODO: logic 15 | if (node->left) { 16 | stack.push(node->left); 17 | } 18 | if (node->right) { 19 | stack.push(node->right); 20 | } 21 | } 22 | 23 | return ans; 24 | } 25 | -------------------------------------------------------------------------------- /src/code/cpp/binary_tree/dfs_recursive.cpp: -------------------------------------------------------------------------------- 1 | int dfs(TreeNode* root) { 2 | if (root == nullptr) { 3 | return 0; 4 | } 5 | 6 | int ans = 0; 7 | 8 | // TODO: logic 9 | dfs(root.left); 10 | dfs(root.right); 11 | 12 | return ans; 13 | } 14 | -------------------------------------------------------------------------------- /src/code/cpp/bit_manipulation/check_power_of_two.cpp: -------------------------------------------------------------------------------- 1 | bool is_power_of_two(int num) { 2 | return (num & (num - 1)) == 0; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/cpp/bit_manipulation/clear_kth_bit.cpp: -------------------------------------------------------------------------------- 1 | int clear_kth_bit(int num, int k) { 2 | return num & ~(1 << k); 3 | } 4 | -------------------------------------------------------------------------------- /src/code/cpp/bit_manipulation/count_set_bits.cpp: -------------------------------------------------------------------------------- 1 | int count_set_bits(int num) { 2 | int count = 0; 3 | 4 | while (num) { 5 | count += num & 1; 6 | num >>= 1; 7 | } 8 | 9 | return count; 10 | } 11 | -------------------------------------------------------------------------------- /src/code/cpp/bit_manipulation/divide_power_of_two.cpp: -------------------------------------------------------------------------------- 1 | int divide_by_power_of_two(int num, int k) { 2 | return num >> k; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/cpp/bit_manipulation/get_rightmost_bit.cpp: -------------------------------------------------------------------------------- 1 | int get_rightmost_set_bit(int num) { 2 | return num & -num; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/cpp/bit_manipulation/multiply_power_of_two.cpp: -------------------------------------------------------------------------------- 1 | int multiply_by_power_of_two(int num, int k) { 2 | return num << k; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/cpp/bit_manipulation/set_kth_bit.cpp: -------------------------------------------------------------------------------- 1 | int set_kth_bit(int num, int k) { 2 | return num | (1 << k); 3 | } 4 | -------------------------------------------------------------------------------- /src/code/cpp/bit_manipulation/swap_variables.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | tuple swap_variables(int num1, int num2) { 7 | num1 ^= num2; 8 | num2 ^= num1; 9 | num1 ^= num2; 10 | return std::make_tuple(num1, num2); 11 | } 12 | -------------------------------------------------------------------------------- /src/code/cpp/bit_manipulation/test_kth_bit.cpp: -------------------------------------------------------------------------------- 1 | bool test_kth_bit(int num, int k) { 2 | return (num & (1 << k)) != 0; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/cpp/bit_manipulation/toggle_kth_bit.cpp: -------------------------------------------------------------------------------- 1 | int toggle_kth_bit(int num, int k) { 2 | return num ^ (1 << k); 3 | } 4 | -------------------------------------------------------------------------------- /src/code/cpp/data_structures/array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | template 8 | class Array { 9 | private: 10 | T* data; 11 | size_t size; 12 | 13 | public: 14 | Array(size_t size) : size(size) { 15 | data = new T[size]; 16 | } 17 | 18 | ~Array() { 19 | delete[] data; 20 | } 21 | 22 | T& operator[](size_t index) { 23 | if (index >= size) { 24 | throw std::out_of_range("Index out of range"); 25 | } 26 | return data[index]; 27 | } 28 | 29 | const T& operator[](size_t index) const { 30 | if (index >= size) { 31 | throw out_of_range("Index out of range"); 32 | } 33 | return data[index]; 34 | } 35 | 36 | size_t len() const { 37 | return size; 38 | } 39 | 40 | friend ostream& operator<<(ostream& os, const Array& arr) { 41 | os << "["; 42 | for (size_t i = 0; i < arr.size; ++i) { 43 | os << arr.data[i]; 44 | if (i < arr.size - 1) { 45 | os << ", "; 46 | } 47 | } 48 | os << "]"; 49 | return os; 50 | } 51 | }; 52 | -------------------------------------------------------------------------------- /src/code/cpp/data_structures/binary_tree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | 8 | template 9 | class BinaryTree { 10 | private: 11 | shared_ptr> root; 12 | 13 | public: 14 | BinaryTree() : root(nullptr) {} 15 | 16 | void insert(const T& data) { 17 | root = insertNode(root, data); 18 | } 19 | 20 | shared_ptr> insertNode(shared_ptr> node, const T& data) { 21 | if (!node) { 22 | return make_shared>(data); 23 | } 24 | 25 | if (!node->left) { 26 | node->left = make_shared>(data); 27 | } else if (!node->right) { 28 | node->right = make_shared>(data); 29 | } else { 30 | node->left = insertNode(node->left, data); 31 | } 32 | 33 | return node; 34 | } 35 | 36 | string printTree() const { 37 | return root ? printNode(root, "", true) : "Empty tree"; 38 | } 39 | 40 | string printNode(const shared_ptr>& node, const string& prefix, bool isLeft) const { 41 | string result; 42 | if (node) { 43 | result += printNode(node->right, prefix + (isLeft ? "│ " : " "), false); 44 | result += prefix + (isLeft ? "└── " : "┌── ") + to_string(node->data) + "\n"; 45 | result += printNode(node->left, prefix + (isLeft ? " " : "│ "), true); 46 | } 47 | return result; 48 | } 49 | }; 50 | -------------------------------------------------------------------------------- /src/code/cpp/data_structures/graph.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | 9 | class Graph { 10 | private: 11 | unordered_map> graph; 12 | 13 | public: 14 | Graph() {} 15 | 16 | void addVertex(const string& vertex) { 17 | if (graph.find(vertex) == graph.end()) { 18 | graph[vertex] = {}; 19 | } 20 | } 21 | 22 | void addEdge(const string& a, const string& b) { 23 | addVertex(a); 24 | addVertex(b); 25 | graph[a].push_back(b); 26 | graph[b].push_back(a); 27 | } 28 | 29 | vector getNeighbors(const string& vertex) { 30 | return graph[vertex]; 31 | } 32 | 33 | string toString() { 34 | string output; 35 | 36 | for (const auto& [vertex, neighbors] : graph) { 37 | output += vertex + " - "; 38 | 39 | for (const auto& neighbor : neighbors) { 40 | output += neighbor + " - "; 41 | } 42 | 43 | output.pop_back(); 44 | output.pop_back(); 45 | output += "\n"; 46 | } 47 | 48 | return output; 49 | } 50 | }; 51 | -------------------------------------------------------------------------------- /src/code/cpp/data_structures/hash_map.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | template 8 | class HashMap { 9 | private: 10 | const size_t size = 100000; 11 | vector> buckets[size]; 12 | 13 | size_t hash(const KeyType& key) { 14 | return hash{}(key) % size; 15 | } 16 | 17 | public: 18 | HashMap() {} 19 | 20 | void setItem(const KeyType& key, const ValueType& value) { 21 | size_t index = hash(key); 22 | 23 | for (auto& pair : buckets[index]) { 24 | if (pair.first == key) { 25 | pair.second = value; 26 | return; 27 | } 28 | } 29 | 30 | buckets[index].emplace_back(key, value); 31 | } 32 | 33 | ValueType& getItem(const KeyType& key) { 34 | size_t index = hash(key); 35 | 36 | for (auto& pair : buckets[index]) { 37 | if (pair.first == key) { 38 | return pair.second; 39 | } 40 | } 41 | 42 | throw out_of_range("Key not found"); 43 | } 44 | 45 | void delItem(const KeyType& key) { 46 | size_t index = hash(key); 47 | 48 | for (auto it = buckets[index].begin(); it != buckets[index].end(); ++it) { 49 | if (it->first == key) { 50 | buckets[index].erase(it); 51 | return; 52 | } 53 | } 54 | } 55 | }; 56 | -------------------------------------------------------------------------------- /src/code/cpp/data_structures/union_find.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | 8 | class UnionFind { 9 | private: 10 | vector root; 11 | 12 | public: 13 | UnionFind(int n) : root(n) { 14 | for (int i = 0; i < n; ++i) { 15 | root[i] = i; 16 | } 17 | } 18 | 19 | int find(int a) { 20 | return a == root[a] ? a : root[a] = find(root[a]); 21 | } 22 | 23 | void unionSets(int a, int b) { 24 | root[find(a)] = find(b); 25 | } 26 | 27 | bool connected(int a, int b) { 28 | return find(a) == find(b); 29 | } 30 | 31 | string toString() { 32 | int n = root.size(); 33 | vector> components(n); 34 | 35 | for (int i = 0; i < n; ++i) { 36 | components[find(i)].push_back(i); 37 | } 38 | 39 | string result; 40 | 41 | for (const auto& component : components) { 42 | if (!component.empty()) { 43 | for (int node : component) { 44 | result += "(" + to_string(node) + ") - "; 45 | } 46 | result.pop_back(); 47 | result.pop_back(); 48 | result += "\n"; 49 | } 50 | } 51 | 52 | return result; 53 | } 54 | }; 55 | -------------------------------------------------------------------------------- /src/code/cpp/dynamic_programming/bottom_up.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | int fn(int arr[], int size) { 8 | if (BASE_CASE) { 9 | return 0; 10 | } 11 | 12 | vector dp(STATE_FOR_WHOLE_INPUT + 1, BASE_CASE); 13 | 14 | for (int state = SMALLEST_SUBPROBLEM; state <= STATE_FOR_WHOLE_INPUT; ++state) { 15 | if (BASE_CASE) { 16 | dp[state] = BASE_CASE; 17 | } else { 18 | dp[state] = RECURRENCE_RELATION(state); 19 | } 20 | } 21 | 22 | return dp[STATE_FOR_WHOLE_INPUT]; 23 | } 24 | -------------------------------------------------------------------------------- /src/code/cpp/dynamic_programming/kadane.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | int kadane(vector& arr) { 8 | int curr_sub = arr[0]; 9 | int max_sub = arr[0]; 10 | 11 | for (size_t i = 1; i < arr.size(); ++i) { 12 | curr_sub = max(curr_sub + arr[i], arr[i]); 13 | max_sub = max(max_sub, curr_sub); 14 | } 15 | 16 | return max_sub; 17 | } 18 | -------------------------------------------------------------------------------- /src/code/cpp/dynamic_programming/top_down.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | unordered_map memo; 7 | 8 | int fn(vector& arr) { 9 | return dp(STATE_FOR_WHOLE_INPUT, arr); 10 | } 11 | 12 | int dp(STATE, vector& arr) { 13 | if (BASE_CASE) { 14 | return 0; 15 | } 16 | 17 | if (memo.find(STATE) != memo.end()) { 18 | return memo[STATE]; 19 | } 20 | 21 | int ans = RECURRENCE_RELATION(STATE); 22 | memo[STATE] = ans; 23 | return ans; 24 | } 25 | -------------------------------------------------------------------------------- /src/code/cpp/graph/bellman_ford.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | 8 | vector bellman_ford(int n, vector, int>>& edges, int source) { 9 | vector distances(n, numeric_limits::max()); 10 | distances[source] = 0; 11 | 12 | for (int i = 0; i < n - 1; ++i) { 13 | for (const auto& edge : edges) { 14 | int u = edge.first.first; 15 | int v = edge.first.second; 16 | int w = edge.second; 17 | 18 | if (distances[u] != numeric_limits::max() && distances[u] + w < distances[v]) { 19 | distances[v] = distances[u] + w; 20 | } 21 | } 22 | } 23 | 24 | for (const auto& edge : edges) { 25 | int u = edge.first.first; 26 | int v = edge.first.second; 27 | int w = edge.second; 28 | 29 | if (distances[u] != numeric_limits::max() && distances[u] + w < distances[v]) { 30 | return vector(); 31 | } 32 | } 33 | 34 | return distances; 35 | } 36 | -------------------------------------------------------------------------------- /src/code/cpp/graph/bfs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | 8 | int fn(vector>& graph) { 9 | queue que; 10 | unordered_set seen; 11 | que.push(START_NODE); 12 | seen.insert(START_NODE); 13 | int ans = 0; 14 | 15 | while (!que.empty()) { 16 | int node = que.front(); 17 | que.pop(); 18 | // TODO: logic 19 | for (int neighbor: graph[node]) { 20 | if (seen.find(neighbor) == seen.end()) { 21 | seen.insert(neighbor); 22 | que.push(neighbor); 23 | } 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/code/cpp/graph/dfs_iterative.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | 8 | int fn(vector>& graph) { 9 | stack stack; 10 | unordered_set seen; 11 | stack.push(START_NODE); 12 | seen.insert(START_NODE); 13 | int ans = 0; 14 | 15 | while (!stack.empty()) { 16 | int node = stack.top(); 17 | stack.pop(); 18 | // TODO: logic 19 | for (int neighbor: graph[node]) { 20 | if (seen.find(neighbor) == seen.end()) { 21 | seen.insert(neighbor); 22 | stack.push(neighbor); 23 | } 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/code/cpp/graph/dfs_recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | unordered_set seen; 8 | 9 | int fn(vector>& graph) { 10 | seen.insert(START_NODE); 11 | return dfs(START_NODE, graph); 12 | } 13 | 14 | int dfs(int node, vector>& graph) { 15 | int ans = 0; 16 | // TODO: logic 17 | for (int neighbor: graph[node]) { 18 | if (seen.find(neighbor) == seen.end()) { 19 | seen.insert(neighbor); 20 | ans += dfs(neighbor, graph); 21 | } 22 | } 23 | 24 | return ans; 25 | } 26 | -------------------------------------------------------------------------------- /src/code/cpp/graph/dijkstra.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | 9 | vector dijkstra(vector>>& graph, int source) { 10 | int n = graph.size(); 11 | vector distances(n, INT_MAX); 12 | distances[source] = 0; 13 | 14 | priority_queue, vector>, greater>> heap; 15 | heap.push({0, source}); 16 | 17 | while (!heap.empty()) { 18 | int currDist = heap.top().first; 19 | int node = heap.top().second; 20 | heap.pop(); 21 | 22 | if (currDist > distances[node]) { 23 | continue; 24 | } 25 | 26 | for (pair edge : graph[node]) { 27 | int neighbor = edge.first; 28 | int weight = edge.second; 29 | int dist = currDist + weight; 30 | 31 | if (dist < distances[neighbor]) { 32 | distances[neighbor] = dist; 33 | heap.push({dist, neighbor}); 34 | } 35 | } 36 | } 37 | 38 | return distances; 39 | } 40 | -------------------------------------------------------------------------------- /src/code/cpp/graph/kahn.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | 8 | vector kahn_topological_sort(unordered_map>& graph) { 9 | vector result; 10 | unordered_map indegree; 11 | 12 | for (auto& [node, neighbors] : graph) { 13 | for (int neighbor : neighbors) { 14 | indegree[neighbor]++; 15 | } 16 | } 17 | 18 | queue que; 19 | 20 | for (auto& [node, _] : graph) { 21 | if (indegree[node] == 0) { 22 | que.push(node); 23 | } 24 | } 25 | 26 | while (!que.empty()) { 27 | int node = que.front(); 28 | que.pop(); 29 | result.push_back(node); 30 | 31 | for (int neighbor : graph[node]) { 32 | indegree[neighbor]--; 33 | if (indegree[neighbor] == 0) { 34 | que.push(neighbor); 35 | } 36 | } 37 | } 38 | 39 | return (result.size() == graph.size()) ? result : vector(); 40 | } 41 | -------------------------------------------------------------------------------- /src/code/cpp/graph/kruskal.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | vector> kruskal_mst(int n, vector>& edges) { 8 | vector> mst; 9 | UnionFind uf(n); 10 | sort(edges.begin(), edges.end()); 11 | 12 | for (auto& [w, u, v] : edges) { 13 | if (!uf.connected(u, v)) { 14 | uf.unionNodes(u, v); 15 | mst.emplace_back(w, u, v); 16 | } 17 | } 18 | 19 | return mst; 20 | } 21 | -------------------------------------------------------------------------------- /src/code/cpp/graph/prim.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | 8 | vector> prim_mst(int n, vector>& edges) { 9 | vector> mst; 10 | UnionFind uf(n); 11 | make_heap(edges.begin(), edges.end()); 12 | 13 | while (!edges.empty()) { 14 | auto [w, u, v] = edges.front(); 15 | pop_heap(edges.begin(), edges.end()); 16 | edges.pop_back(); 17 | 18 | if (!uf.connected(u, v)) { 19 | uf.unionNodes(u, v); 20 | mst.emplace_back(w, u, v); 21 | } 22 | } 23 | 24 | return mst; 25 | } 26 | -------------------------------------------------------------------------------- /src/code/cpp/hash_map/find_number_of_subarrays.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | int fn(vector& arr, int k) { 8 | unordered_map counts; 9 | counts[0] = 1; 10 | int ans = 0; 11 | int curr = 0; 12 | 13 | for (int num : arr) { 14 | // TODO: logic to change curr 15 | ans += counts[curr - k]; 16 | counts[curr]++; 17 | } 18 | 19 | return ans; 20 | } 21 | -------------------------------------------------------------------------------- /src/code/cpp/hash_map/sliding_window.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | int fn(vector& arr) { 8 | unordered_set window; 9 | int ans = 0; 10 | int left = 0; 11 | 12 | for (int right = 0; right < arr.size(); right++) { 13 | // TODO: add arr[right] to window 14 | 15 | while (WINDOW_CONDITION_BROKEN) { 16 | // TODO: remove arr[left] from window 17 | left++; 18 | } 19 | 20 | // TODO: update ans 21 | } 22 | 23 | return ans; 24 | } 25 | -------------------------------------------------------------------------------- /src/code/cpp/heap/find_top_k_elements.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | vector fn(vector& arr, int k) { 8 | priority_queue, greater> min_heap; 9 | vector result; 10 | 11 | for (int num : arr) { 12 | // TODO: logic to push onto heap according to problem's criteria 13 | min_heap.push(num); 14 | 15 | if (min_heap.size() > k) { 16 | min_heap.pop(); 17 | } 18 | } 19 | 20 | while (!min_heap.empty()) { 21 | result.push_back(min_heap.top()); 22 | min_heap.pop(); 23 | } 24 | 25 | return result; 26 | } 27 | -------------------------------------------------------------------------------- /src/code/cpp/linked_list/fast_and_slow_pointer.cpp: -------------------------------------------------------------------------------- 1 | int fn(ListNode* head) { 2 | ListNode* slow = head; 3 | ListNode* fast = head; 4 | int ans = 0; 5 | 6 | while (fast && fast->next) { 7 | // TODO: logic 8 | slow = slow->next; 9 | fast = fast->next->next; 10 | } 11 | 12 | return ans; 13 | } 14 | -------------------------------------------------------------------------------- /src/code/cpp/linked_list/reverse_linked_list.cpp: -------------------------------------------------------------------------------- 1 | ListNode* fn(ListNode* head) { 2 | ListNode* prev = nullptr; 3 | ListNode* curr = head; 4 | 5 | while (curr) { 6 | ListNode* nxt = curr->next; 7 | curr->next = prev; 8 | prev = curr; 9 | curr = nxt; 10 | } 11 | 12 | return prev; 13 | } 14 | -------------------------------------------------------------------------------- /src/code/cpp/matrix/create_copy.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | void fn(vector>& matrix) { 7 | int r = matrix.size(); 8 | int c = matrix[0].size(); 9 | 10 | vector> create_matrix(r, vector(c, 0)); 11 | vector> copy_matrix(matrix); 12 | } 13 | -------------------------------------------------------------------------------- /src/code/cpp/matrix/diagonals.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | void fn(vector>& matrix) { 7 | int r = matrix.size(); 8 | int c = matrix[0].size(); 9 | 10 | vector main_diagonal; 11 | vector anti_diagonal; 12 | 13 | for (int i = 0; i < min(r, c); ++i) { 14 | main_diagonal.push_back(matrix[i][i]); 15 | anti_diagonal.push_back(matrix[i][c - i - 1]); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/code/cpp/matrix/rotate_transpose.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | void fn(vector>& matrix) { 7 | int r = matrix.size(); 8 | int c = matrix[0].size(); 9 | vector> transpose(c, vector(r)); 10 | vector> rotate_left(c, vector(r)); 11 | vector> rotate_right(c, vector(r)); 12 | 13 | for (int i = 0; i < r; ++i) { 14 | for (int j = 0; j < c; ++j) { 15 | transpose[j][i] = matrix[i][j]; 16 | } 17 | } 18 | 19 | for (int i = 0; i < c; ++i) { 20 | for (int j = 0; j < r; ++j) { 21 | rotate_left[i][j] = transpose[c - i - 1][j]; 22 | } 23 | } 24 | 25 | for (int i = 0; i < c; ++i) { 26 | for (int j = 0; j < r; ++j) { 27 | rotate_right[i][j] = transpose[i][r - j - 1]; 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/bogo_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | 8 | void BogoSort(vector& arr) { 9 | vector target = arr; 10 | sort(target.begin(), target.end()); 11 | 12 | random_device rd; 13 | mt19937 g(rd()); 14 | 15 | while (!is_sorted(arr.begin(), arr.end())) { 16 | shuffle(arr.begin(), arr.end(), g); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/bubble_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | void BubbleSort(vector& arr) { 7 | int n = arr.size(); 8 | 9 | for (int i = 0; i < n; ++i) { 10 | bool swapped = false; 11 | 12 | for (int j = 0; j < n - i - 1; ++j) { 13 | if (arr[j] > arr[j + 1]) { 14 | std::swap(arr[j], arr[j + 1]); 15 | swapped = true; 16 | } 17 | } 18 | 19 | if (!swapped) { 20 | break; 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/bucket_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | vector BucketSort(vector& arr) { 8 | int num_buckets = 10; 9 | int min_num = *min_element(arr.begin(), arr.end()); 10 | int max_num = *max_element(arr.begin(), arr.end()); 11 | double bucket_size = static_cast(max_num - min_num) / num_buckets; 12 | vector> buckets(num_buckets); 13 | vector result; 14 | 15 | for (int num : arr) { 16 | int index = min(static_cast((num - min_num) / bucket_size), num_buckets - 1); 17 | buckets[index].push_back(num); 18 | } 19 | 20 | for (auto& bucket : buckets) { 21 | sort(bucket.begin(), bucket.end()); 22 | result.insert(result.end(), bucket.begin(), bucket.end()); 23 | } 24 | 25 | return result; 26 | } 27 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/counting_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | vector CountingSort(vector& arr) { 8 | int max_num = *max_element(arr.begin(), arr.end()); 9 | int min_num = *min_element(arr.begin(), arr.end()); 10 | int count_range = max_num - min_num + 1; 11 | vector count(count_range, 0); 12 | vector output(arr.size(), 0); 13 | 14 | for (int num : arr) { 15 | count[num - min_num]++; 16 | } 17 | 18 | for (int i = 1; i < count_range; ++i) { 19 | count[i] += count[i - 1]; 20 | } 21 | 22 | for (int i = arr.size() - 1; i >= 0; --i) { 23 | output[count[arr[i] - min_num] - 1] = arr[i]; 24 | count[arr[i] - min_num]--; 25 | } 26 | 27 | return output; 28 | } 29 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/cube_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | 8 | void CubeSort(vector& arr, int processors) { 9 | int n = arr.size(); 10 | vector> subarrays; 11 | int subarray_size = n / processors; 12 | 13 | for (int i = 0; i < processors; ++i) { 14 | vector subarray(arr.begin() + i * subarray_size, arr.begin() + (i + 1) * subarray_size); 15 | sort(subarray.begin(), subarray.end()); 16 | subarrays.push_back(subarray); 17 | } 18 | 19 | for (int dimension = 0; dimension < log2(processors); ++dimension) { 20 | for (int i = 0; i < processors; ++i) { 21 | int partner = i ^ (1 << dimension); 22 | vector merged; 23 | if (i < partner) { 24 | merged = subarrays[i]; 25 | merged.insert(merged.end(), subarrays[partner].begin(), subarrays[partner].end()); 26 | } else { 27 | merged = subarrays[partner]; 28 | merged.insert(merged.end(), subarrays[i].begin(), subarrays[i].end()); 29 | } 30 | sort(merged.begin(), merged.end()); 31 | subarrays[i].assign(merged.begin(), merged.begin() + subarray_size); 32 | subarrays[partner].assign(merged.begin() + subarray_size, merged.end()); 33 | } 34 | } 35 | 36 | arr.clear(); 37 | for (auto& subarray : subarrays) { 38 | arr.insert(arr.end(), subarray.begin(), subarray.end()); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/heap_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | void Heapify(vector& arr, int n, int i) { 7 | int largest = i; 8 | int left = 2 * i + 1; 9 | int right = 2 * i + 2; 10 | 11 | if (left < n && arr[left] > arr[largest]) { 12 | largest = left; 13 | } 14 | if (right < n && arr[right] > arr[largest]) { 15 | largest = right; 16 | } 17 | if (largest != i) { 18 | swap(arr[i], arr[largest]); 19 | Heapify(arr, n, largest); 20 | } 21 | } 22 | 23 | void HeapSort(vector& arr) { 24 | int n = arr.size(); 25 | 26 | for (int i = n / 2 - 1; i >= 0; --i) { 27 | Heapify(arr, n, i); 28 | } 29 | for (int i = n - 1; i > 0; --i) { 30 | swap(arr[0], arr[i]); 31 | Heapify(arr, i, 0); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/insertion_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | void InsertionSort(vector& arr) { 7 | int n = arr.size(); 8 | 9 | for (int i = 1; i < n; ++i) { 10 | int key = arr[i]; 11 | int j = i - 1; 12 | 13 | while (j >= 0 && key < arr[j]) { 14 | arr[j + 1] = arr[j]; 15 | --j; 16 | } 17 | 18 | arr[j + 1] = key; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/merge_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | vector Merge(vector& left, vector& right) { 7 | vector output; 8 | 9 | while (!left.empty() && !right.empty()) { 10 | int min_num = (left[0] <= right[0]) ? left[0] : right[0]; 11 | output.push_back(min_num); 12 | 13 | if (left[0] <= right[0]) { 14 | left.erase(left.begin()); 15 | } else { 16 | right.erase(right.begin()); 17 | } 18 | } 19 | 20 | output.insert(output.end(), left.begin(), left.end()); 21 | output.insert(output.end(), right.begin(), right.end()); 22 | 23 | return output; 24 | } 25 | 26 | vector MergeSort(vector& arr) { 27 | int n = arr.size(); 28 | 29 | if (n <= 1) { 30 | return arr; 31 | } 32 | 33 | int mid = n / 2; 34 | vector left(arr.begin(), arr.begin() + mid); 35 | vector right(arr.begin() + mid, arr.end()); 36 | 37 | left = MergeSort(left); 38 | right = MergeSort(right); 39 | 40 | return Merge(left, right); 41 | } 42 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/pancake_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int FindMaxIndex(vector& arr, int n) { 7 | int max_idx = 0; 8 | 9 | for (int i = 0; i < n; ++i) { 10 | if (arr[i] > arr[max_idx]) { 11 | max_idx = i; 12 | } 13 | } 14 | 15 | return max_idx; 16 | } 17 | 18 | void Flip(vector& arr, int i) { 19 | int left = 0; 20 | 21 | while (left < i) { 22 | swap(arr[left], arr[i]); 23 | left++; 24 | i--; 25 | } 26 | } 27 | 28 | void PancakeSort(vector& arr) { 29 | int n = arr.size(); 30 | 31 | for (int size = n; size >= 2; --size) { 32 | int max_idx = FindMaxIndex(arr, size); 33 | 34 | if (max_idx != size - 1) { 35 | Flip(arr, max_idx); 36 | Flip(arr, size - 1); 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/quick_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | vector QuickSort(vector& arr) { 7 | int n = arr.size(); 8 | 9 | if (n <= 1) { 10 | return arr; 11 | } 12 | 13 | int pivot = arr[n / 2]; 14 | vector left, right; 15 | 16 | for (int x : arr) { 17 | if (x < pivot) { 18 | left.push_back(x); 19 | } else if (x > pivot) { 20 | right.push_back(x); 21 | } 22 | } 23 | 24 | left = QuickSort(left); 25 | right = QuickSort(right); 26 | 27 | left.push_back(pivot); 28 | left.insert(left.end(), right.begin(), right.end()); 29 | 30 | return left; 31 | } 32 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/radix_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | void CountingSort(vector& arr, int exp) { 7 | int n = arr.size(); 8 | vector output(n, 0); 9 | vector count(10, 0); 10 | 11 | for (int i = 0; i < n; ++i) { 12 | int idx = arr[i] / exp % 10; 13 | count[idx]++; 14 | } 15 | 16 | for (int i = 1; i < 10; ++i) { 17 | count[i] += count[i - 1]; 18 | } 19 | 20 | for (int i = n - 1; i >= 0; --i) { 21 | int idx = arr[i] / exp % 10; 22 | output[count[idx] - 1] = arr[i]; 23 | count[idx]--; 24 | } 25 | 26 | for (int i = 0; i < n; ++i) { 27 | arr[i] = output[i]; 28 | } 29 | } 30 | 31 | void RadixSort(vector& arr) { 32 | int max_val = *max_element(arr.begin(), arr.end()); 33 | int exp = 1; 34 | 35 | while (max_val / exp > 0) { 36 | CountingSort(arr, exp); 37 | exp *= 10; 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/selection_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | void SelectionSort(vector& arr) { 7 | int n = arr.size(); 8 | 9 | for (int i = 0; i < n; ++i) { 10 | int min_i = i; 11 | 12 | for (int j = i + 1; j < n; ++j) { 13 | if (arr[j] < arr[min_i]) { 14 | min_i = j; 15 | } 16 | } 17 | 18 | if (min_i != i) { 19 | swap(arr[i], arr[min_i]); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/shell_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | void ShellSort(vector& arr) { 7 | int n = arr.size(); 8 | vector gaps = {701, 301, 132, 57, 23, 10, 4, 1}; 9 | 10 | for (int gap : gaps) { 11 | for (int i = gap; i < n; ++i) { 12 | int tmp = arr[i]; 13 | int j = i; 14 | 15 | while (j >= gap && arr[j - gap] > tmp) { 16 | arr[j] = arr[j - gap]; 17 | j -= gap; 18 | } 19 | 20 | if (j != i) { 21 | arr[j] = tmp; 22 | } 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/code/cpp/sorting_algorithms/sleep_sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | 8 | void Snorlax(double num, vector& arr) { 9 | this_thread::sleep_for(chrono::milliseconds(static_cast(num))); 10 | arr.push_back(num); 11 | } 12 | 13 | vector SleepSort(vector& arr) { 14 | vector sorted_arr; 15 | vector threads; 16 | 17 | for (double num : arr) { 18 | threads.emplace_back(Snorlax, num, ref(sorted_arr)); 19 | } 20 | 21 | for (thread& t : threads) { 22 | t.join(); 23 | } 24 | 25 | return sorted_arr; 26 | } 27 | -------------------------------------------------------------------------------- /src/code/cpp/stack/monotonic_decreasing.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | int fn(vector& arr) { 8 | stack stack; 9 | int ans = 0; 10 | 11 | for (int num : arr) { 12 | while (!stack.empty() && stack.top() < num) { 13 | // TODO: logic 14 | stack.pop(); 15 | } 16 | stack.push(num); 17 | } 18 | 19 | return ans; 20 | } 21 | -------------------------------------------------------------------------------- /src/code/cpp/stack/monotonic_increasing.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | int fn(vector& arr) { 8 | stack stack; 9 | int ans = 0; 10 | 11 | for (int num : arr) { 12 | while (!stack.empty() && stack.top() > num) { 13 | // TODO: logic 14 | stack.pop(); 15 | } 16 | stack.push(num); 17 | } 18 | 19 | return ans; 20 | } 21 | -------------------------------------------------------------------------------- /src/code/java/array/prefix_sum.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | 5 | public int[] fn(int[] arr) { 6 | int n = arr.length; 7 | int[] prefix = new int[n]; 8 | prefix[0] = arr[0]; 9 | 10 | for (int i = 1; i < n; i++) { 11 | prefix[i] = prefix[i - 1] + arr[i]; 12 | } 13 | 14 | return prefix; 15 | } 16 | -------------------------------------------------------------------------------- /src/code/java/array/sliding_window.java: -------------------------------------------------------------------------------- 1 | public int fn(int[] arr) { 2 | int n = arr.length; 3 | int window = 0; 4 | int left = 0; 5 | int ans = 0; 6 | 7 | for (int right = 0; right < arr.length; right++) { 8 | // TODO: add arr[right] to window 9 | 10 | while (WINDOW_CONDITION_BROKEN) { 11 | // TODO: remove arr[left] from window 12 | left++; 13 | } 14 | 15 | // TODO: update ans 16 | } 17 | 18 | return ans; 19 | } 20 | -------------------------------------------------------------------------------- /src/code/java/array/string_building.java: -------------------------------------------------------------------------------- 1 | public String fn(char[] strs) { 2 | StringBuilder sb = new StringBuilder(); 3 | 4 | for (char c: strs) { 5 | sb.append(c); 6 | } 7 | 8 | return sb.toString(); 9 | } 10 | -------------------------------------------------------------------------------- /src/code/java/array/two_pointers_one_input.java: -------------------------------------------------------------------------------- 1 | public int fn(int[] arr) { 2 | int ans = 0; 3 | int left = 0; 4 | int right = arr.length - 1; 5 | 6 | while (left < right) { 7 | // TODO: logic with left and right 8 | if (CONDITION) { 9 | left++; 10 | } else { 11 | right--; 12 | } 13 | } 14 | 15 | return ans; 16 | } 17 | -------------------------------------------------------------------------------- /src/code/java/array/two_pointers_two_inputs.java: -------------------------------------------------------------------------------- 1 | public int fn(int[] arr1, int[] arr2) { 2 | int i = 0; 3 | int j = 0; 4 | int ans = 0; 5 | 6 | while (i < arr1.length && j < arr2.length) { 7 | // TODO: logic 8 | if (CONDITION) { 9 | i++; 10 | } else { 11 | j++; 12 | } 13 | } 14 | 15 | while (i < arr1.length) { 16 | // TODO: logic 17 | i++; 18 | } 19 | 20 | while (j < arr2.length) { 21 | // TODO: logic 22 | j++; 23 | } 24 | 25 | return ans; 26 | } 27 | -------------------------------------------------------------------------------- /src/code/java/backtracking/backtracking.java: -------------------------------------------------------------------------------- 1 | public int backtrack(STATE curr, OTHER_ARGUMENTS...) { 2 | if (BASE_CASE) { 3 | // TODO: modify answer 4 | return 0; 5 | } 6 | 7 | int ans = 0; 8 | 9 | for (ITERATE_OVER_INPUT) { 10 | // TODO: modify current state 11 | ans += backtrack(curr, OTHER_ARGUMENTS...); 12 | // TODO: undo modification of current state 13 | } 14 | 15 | return ans; 16 | } 17 | -------------------------------------------------------------------------------- /src/code/java/binary_search/binary_search.java: -------------------------------------------------------------------------------- 1 | public int fn(int[] arr, int target) { 2 | int left = 0; 3 | int right = arr.length - 1; 4 | 5 | while (left <= right) { 6 | int mid = left + (right - left) / 2; 7 | 8 | if (arr[mid] == target) { 9 | // TODO: logic 10 | return mid; 11 | } 12 | if (arr[mid] > target) { 13 | right = mid - 1; 14 | } else { 15 | left = mid + 1; 16 | } 17 | } 18 | 19 | return left; 20 | } 21 | -------------------------------------------------------------------------------- /src/code/java/binary_search/duplicate_elements_left_insertion.java: -------------------------------------------------------------------------------- 1 | public int fn(int[] arr, int target) { 2 | int left = 0; 3 | int right = arr.length; 4 | 5 | while (left < right) { 6 | int mid = left + (right - left) / 2; 7 | 8 | if (arr[mid] >= target) { 9 | right = mid; 10 | } else { 11 | left = mid + 1; 12 | } 13 | } 14 | 15 | return left; 16 | } 17 | -------------------------------------------------------------------------------- /src/code/java/binary_search/duplicate_elements_right_insertion.java: -------------------------------------------------------------------------------- 1 | public int fn(int[] arr, int target) { 2 | int left = 0; 3 | int right = arr.length; 4 | 5 | while (left < right) { 6 | int mid = left + (right - left) / 2; 7 | 8 | if (arr[mid] > target) { 9 | right = mid; 10 | } else { 11 | left = mid + 1; 12 | } 13 | } 14 | 15 | return left; 16 | } 17 | -------------------------------------------------------------------------------- /src/code/java/binary_search/greedy_maximum.java: -------------------------------------------------------------------------------- 1 | public int fn(int[] arr) { 2 | int left = MINIMUM_POSSIBLE_ANSWER; 3 | int right = MAXIMUM_POSSIBLE_ANSWER; 4 | 5 | while (left <= right) { 6 | int mid = left + (right - left) / 2; 7 | 8 | if (check(mid)) { 9 | left = mid + 1; 10 | } else { 11 | right = mid - 1; 12 | } 13 | } 14 | 15 | return right; 16 | } 17 | 18 | public boolean check(int x) { 19 | return BOOLEAN 20 | } 21 | -------------------------------------------------------------------------------- /src/code/java/binary_search/greedy_minimum.java: -------------------------------------------------------------------------------- 1 | public int fn(int[] arr) { 2 | int left = MINIMUM_POSSIBLE_ANSWER; 3 | int right = MAXIMUM_POSSIBLE_ANSWER; 4 | 5 | while (left <= right) { 6 | int mid = left + (right - left) / 2; 7 | 8 | if (check(mid)) { 9 | right = mid - 1; 10 | } else { 11 | left = mid + 1; 12 | } 13 | } 14 | 15 | return left; 16 | } 17 | 18 | public boolean check(int x) { 19 | return BOOLEAN 20 | } 21 | -------------------------------------------------------------------------------- /src/code/java/binary_tree/bfs.java: -------------------------------------------------------------------------------- 1 | import java.util.LinkedList; 2 | import java.util.Queue; 3 | 4 | 5 | public int fn(TreeNode root) { 6 | Queue que = new LinkedList<>(); 7 | que.add(root); 8 | int ans = 0; 9 | 10 | while (!que.isEmpty()) { 11 | int currentLength = que.size(); 12 | // TODO: logic for current level 13 | for (int i = 0; i < currentLength; i++) { 14 | TreeNode node = que.remove(); 15 | // TODO: logic 16 | if (node.left != null) { 17 | que.add(node.left); 18 | } 19 | if (node.right != null) { 20 | que.add(node.right); 21 | } 22 | } 23 | } 24 | 25 | return ans; 26 | } 27 | -------------------------------------------------------------------------------- /src/code/java/binary_tree/dfs_iterative.java: -------------------------------------------------------------------------------- 1 | import java.util.Stack; 2 | 3 | 4 | public int dfs(TreeNode root) { 5 | Stack stack = new Stack<>(); 6 | stack.push(root); 7 | int ans = 0; 8 | 9 | while (!stack.isEmpty()) { 10 | TreeNode node = stack.pop(); 11 | // TODO: logic 12 | if (node.left != null) { 13 | stack.push(node.left); 14 | } 15 | if (node.right != null) { 16 | stack.push(node.right); 17 | } 18 | } 19 | 20 | return ans; 21 | } 22 | -------------------------------------------------------------------------------- /src/code/java/binary_tree/dfs_recursive.java: -------------------------------------------------------------------------------- 1 | public int dfs(TreeNode root) { 2 | if (root == null) { 3 | return 0; 4 | } 5 | 6 | int ans = 0; 7 | 8 | // TODO: logic 9 | ans += dfs(root.left); 10 | ans += dfs(root.right); 11 | 12 | return ans; 13 | } 14 | -------------------------------------------------------------------------------- /src/code/java/bit_manipulation/check_power_of_two.java: -------------------------------------------------------------------------------- 1 | public boolean isPowerOfTwo(int num) { 2 | return (num & (num - 1)) == 0; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/java/bit_manipulation/clear_kth_bit.java: -------------------------------------------------------------------------------- 1 | public int clearKthBit(int num, int k) { 2 | return num & ~(1 << k); 3 | } 4 | -------------------------------------------------------------------------------- /src/code/java/bit_manipulation/count_set_bits.java: -------------------------------------------------------------------------------- 1 | public int countSetBits(int num) { 2 | int count = 0; 3 | 4 | while (num > 0) { 5 | count += num & 1; 6 | num >>= 1; 7 | } 8 | 9 | return count; 10 | } 11 | -------------------------------------------------------------------------------- /src/code/java/bit_manipulation/divide_power_of_two.java: -------------------------------------------------------------------------------- 1 | public int divideByPowerOfTwo(int num, int k) { 2 | return num >> k; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/java/bit_manipulation/get_rightmost_bit.java: -------------------------------------------------------------------------------- 1 | public int getRightmostSetBit(int num) { 2 | return num & -num; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/java/bit_manipulation/multiply_power_of_two.java: -------------------------------------------------------------------------------- 1 | public int multiplyByPowerOfTwo(int num, int k) { 2 | return num << k; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/java/bit_manipulation/set_kth_bit.java: -------------------------------------------------------------------------------- 1 | public int setKthBit(int num, int k) { 2 | return num | (1 << k); 3 | } 4 | -------------------------------------------------------------------------------- /src/code/java/bit_manipulation/swap_variables.java: -------------------------------------------------------------------------------- 1 | public int[] swapVariables(int num1, int num2) { 2 | num1 ^= num2; 3 | num2 ^= num1; 4 | num1 ^= num2; 5 | return new int[] { num1, num2 }; 6 | } 7 | -------------------------------------------------------------------------------- /src/code/java/bit_manipulation/test_kth_bit.java: -------------------------------------------------------------------------------- 1 | public boolean testKthBit(int num, int k) { 2 | return (num & (1 << k)) != 0; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/java/bit_manipulation/toggle_kth_bit.java: -------------------------------------------------------------------------------- 1 | public int toggleKthBit(int num, int k) { 2 | return num ^ (1 << k); 3 | } 4 | -------------------------------------------------------------------------------- /src/code/java/data_structures/array.java: -------------------------------------------------------------------------------- 1 | public class Array { 2 | private int size; 3 | private T[] data; 4 | 5 | @SuppressWarnings("unchecked") 6 | public Array(int size) { 7 | this.size = size; 8 | this.data = (T[]) new Object[size]; 9 | } 10 | 11 | public T get(int index) { 12 | if (index < 0 || index >= size) { 13 | throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); 14 | } 15 | return data[index]; 16 | } 17 | 18 | public void set(int index, T value) { 19 | if (index < 0 || index >= size) { 20 | throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); 21 | } 22 | data[index] = value; 23 | } 24 | 25 | public int size() { 26 | return size; 27 | } 28 | 29 | @Override 30 | public String toString() { 31 | StringBuilder sb = new StringBuilder("["); 32 | 33 | for (int i = 0; i < size; i++) { 34 | sb.append(data[i]); 35 | if (i < size - 1) { 36 | sb.append(", "); 37 | } 38 | } 39 | 40 | sb.append("]"); 41 | return sb.toString(); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/code/java/data_structures/binary_tree.java: -------------------------------------------------------------------------------- 1 | public class TreeNode { 2 | T data; 3 | TreeNode left; 4 | TreeNode right; 5 | 6 | public TreeNode(T data) { 7 | this.data = data; 8 | left = null; 9 | right = null; 10 | } 11 | } 12 | 13 | public class BinaryTree { 14 | TreeNode root; 15 | 16 | public BinaryTree() { 17 | root = null; 18 | } 19 | 20 | public void insert(T data) { 21 | root = insertNode(root, data); 22 | } 23 | 24 | private TreeNode insertNode(TreeNode node, T data) { 25 | if (node == null) { 26 | return new TreeNode<>(data); 27 | } 28 | 29 | if (node.left == null) { 30 | node.left = new TreeNode<>(data); 31 | } else if (node.right == null) { 32 | node.right = new TreeNode<>(data); 33 | } else { 34 | node.left = insertNode(node.left, data); 35 | } 36 | 37 | return node; 38 | } 39 | 40 | @Override 41 | public String toString() { 42 | return root == null ? "Empty tree" : printTree(root, "", true); 43 | } 44 | 45 | private String printTree(TreeNode node, String prefix, boolean isLeft) { 46 | if (node == null) { 47 | return ""; 48 | } 49 | 50 | StringBuilder sb = new StringBuilder(); 51 | sb.append(printTree(node.right, prefix + (isLeft ? "│ " : " "), false)); 52 | sb.append(prefix).append(isLeft ? "└── " : "┌── ").append(node.data).append("\n"); 53 | sb.append(printTree(node.left, prefix + (isLeft ? " " : "│ "), true)); 54 | 55 | return sb.toString(); 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/code/java/data_structures/graph.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.HashMap; 3 | import java.util.List; 4 | import java.util.Map; 5 | 6 | 7 | public class Graph { 8 | Map> graph; 9 | 10 | public Graph() { 11 | graph = new HashMap<>(); 12 | } 13 | 14 | public void addVertex(String vertex) { 15 | if (!graph.containsKey(vertex)) { 16 | graph.put(vertex, new ArrayList<>()); 17 | } 18 | } 19 | 20 | public void addEdge(String a, String b) { 21 | addVertex(a); 22 | addVertex(b); 23 | graph.get(a).add(b); 24 | graph.get(b).add(a); 25 | } 26 | 27 | public List getNeighbors(String vertex) { 28 | return graph.getOrDefault(vertex, new ArrayList<>()); 29 | } 30 | 31 | @Override 32 | public String toString() { 33 | StringBuilder output = new StringBuilder(); 34 | 35 | for (Map.Entry> entry : graph.entrySet()) { 36 | output.append(entry.getKey()).append(" - ").append(String.join(" - ", entry.getValue())).append("\n"); 37 | } 38 | 39 | return output.toString(); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/code/java/data_structures/hash_map.java: -------------------------------------------------------------------------------- 1 | public class HashMap { 2 | private int size; 3 | private Object[] bucket; 4 | 5 | public HashMap() { 6 | size = 100000; 7 | bucket = new Object[size]; 8 | } 9 | 10 | private int hash(int key) { 11 | return key % size; 12 | } 13 | 14 | public void put(int key, Object value) { 15 | bucket[hash(key)] = value; 16 | } 17 | 18 | public Object get(int key) { 19 | return bucket[hash(key)]; 20 | } 21 | 22 | public void remove(int key) { 23 | bucket[hash(key)] = null; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/code/java/data_structures/union_find.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.HashMap; 3 | import java.util.List; 4 | import java.util.Map; 5 | 6 | 7 | public class UnionFind { 8 | private int[] root; 9 | 10 | public UnionFind(int n) { 11 | this.root = new int[n]; 12 | for (int i = 0; i < n; i++) { 13 | this.root[i] = i; 14 | } 15 | } 16 | 17 | public int find(int a) { 18 | if (a == root[a]) { 19 | return a; 20 | } 21 | return root[a] = find(root[a]); 22 | } 23 | 24 | public void union(int a, int b) { 25 | root[find(a)] = find(b); 26 | } 27 | 28 | public boolean connected(int a, int b) { 29 | return find(a) == find(b); 30 | } 31 | 32 | @Override 33 | public String toString() { 34 | int n = root.length; 35 | List> components = new ArrayList<>(); 36 | Map> componentMap = new HashMap<>(); 37 | 38 | for (int i = 0; i < n; i++) { 39 | int root = find(i); 40 | 41 | if (!componentMap.containsKey(root)) { 42 | componentMap.put(root, new ArrayList<>()); 43 | } 44 | 45 | componentMap.get(root).add(i); 46 | } 47 | 48 | StringBuilder sb = new StringBuilder(); 49 | 50 | for (List component : componentMap.values()) { 51 | sb.append(" - ").append(component); 52 | } 53 | 54 | return sb.toString(); 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/code/java/dynamic_programming/bottom_up.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | 4 | public int fn(int[] arr) { 5 | if (BASE_CASE) { 6 | return 0; 7 | } 8 | 9 | int[] dp = new int[STATE_FOR_WHOLE_INPUT + 1]; 10 | Arrays.fill(dp, BASE_CASE); 11 | 12 | for (int STATE = SMALLEST_SUBPROBLEM; STATE <= STATE_FOR_WHOLE_INPUT; STATE++) { 13 | if (BASE_CASE) { 14 | dp[STATE] = BASE_CASE; 15 | } else { 16 | dp[STATE] = RECURRENCE_RELATION(STATE); 17 | } 18 | } 19 | 20 | return dp[STATE_FOR_WHOLE_INPUT]; 21 | } 22 | -------------------------------------------------------------------------------- /src/code/java/dynamic_programming/kadane.java: -------------------------------------------------------------------------------- 1 | public int kadane(int[] arr) { 2 | int currSub = arr[0]; 3 | int maxSub = arr[0]; 4 | 5 | for (int i = 1; i < arr.length; i++) { 6 | currSub = Math.max(currSub + arr[i], arr[i]); 7 | maxSub = Math.max(maxSub, currSub); 8 | } 9 | 10 | return maxSub; 11 | } 12 | -------------------------------------------------------------------------------- /src/code/java/dynamic_programming/top_down.java: -------------------------------------------------------------------------------- 1 | import java.util.HashMap; 2 | import java.util.Map; 3 | 4 | 5 | Map memo = new HashMap<>(); 6 | 7 | public int fn(int[] arr) { 8 | return dp(STATE_FOR_WHOLE_INPUT, arr); 9 | } 10 | 11 | public int dp(STATE, int[] arr) { 12 | if (BASE_CASE) { 13 | return 0; 14 | } 15 | 16 | if (memo.contains(STATE)) { 17 | return memo.get(STATE); 18 | } 19 | 20 | int ans = RECURRENCE_RELATION(STATE); 21 | memo.put(STATE, ans); 22 | return ans; 23 | } 24 | -------------------------------------------------------------------------------- /src/code/java/graph/bellman_ford.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | import java.util.List; 3 | 4 | 5 | public int[] bellmanFord(int n, List edges, int source) { 6 | int[] distances = new int[n]; 7 | Arrays.fill(distances, Integer.MAX_VALUE); 8 | distances[source] = 0; 9 | 10 | for (int i = 0; i < n - 1; i++) { 11 | for (int[] edge : edges) { 12 | int u = edge[0]; 13 | int v = edge[1]; 14 | int w = edge[2]; 15 | 16 | if (distances[u] != Integer.MAX_VALUE && distances[u] + w < distances[v]) { 17 | distances[v] = distances[u] + w; 18 | } 19 | } 20 | } 21 | 22 | for (int[] edge : edges) { 23 | int u = edge[0]; 24 | int v = edge[1]; 25 | int w = edge[2]; 26 | 27 | if (distances[u] != Integer.MAX_VALUE && distances[u] + w < distances[v]) { 28 | return new int[]{}; 29 | } 30 | } 31 | 32 | return distances; 33 | } 34 | -------------------------------------------------------------------------------- /src/code/java/graph/bfs.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.HashSet; 3 | import java.util.LinkedList; 4 | import java.util.List; 5 | import java.util.Map; 6 | import java.util.Queue; 7 | import java.util.Set; 8 | 9 | 10 | public int fn(int[][] graph) { 11 | Queue que = new LinkedList<>(); 12 | Set seen = new HashSet<>(); 13 | que.offer(START_NODE); 14 | seen.add(START_NODE); 15 | int ans = 0; 16 | 17 | while (!que.isEmpty()) { 18 | int node = que.remove(); 19 | // TODO: Logic 20 | for (int neighbor: graph[node]) { 21 | if (!seen.contains(neighbor)) { 22 | seen.add(neighbor); 23 | que.add(neighbor); 24 | } 25 | } 26 | } 27 | 28 | return ans; 29 | } 30 | -------------------------------------------------------------------------------- /src/code/java/graph/dfs_iterative.java: -------------------------------------------------------------------------------- 1 | import java.util.Stack; 2 | import java.util.HashSet; 3 | import java.util.Set; 4 | 5 | 6 | public int fn(int[][] graph) { 7 | Stack stack = new Stack<>(); 8 | Set seen = new HashSet<>(); 9 | stack.push(START_NODE); 10 | seen.add(START_NODE); 11 | int ans = 0; 12 | 13 | while (!stack.empty()) { 14 | int node = stack.pop(); 15 | // TODO: logic 16 | for (int neighbor: graph[node]) { 17 | if (!seen.contains(neighbor)) { 18 | seen.add(neighbor); 19 | stack.push(neighbor); 20 | } 21 | } 22 | } 23 | 24 | return ans; 25 | } 26 | -------------------------------------------------------------------------------- /src/code/java/graph/dfs_recursive.java: -------------------------------------------------------------------------------- 1 | import java.util.HashSet; 2 | import java.util.Set; 3 | 4 | 5 | Set seen = new HashSet<>(); 6 | 7 | public int fn(int[][] graph) { 8 | seen.add(START_NODE); 9 | return dfs(START_NODE, graph); 10 | } 11 | 12 | public int dfs(int node, int[][] graph) { 13 | int ans = 0; 14 | // TODO: logic 15 | for (int neighbor: graph[node]) { 16 | if (!seen.contains(neighbor)) { 17 | seen.add(neighbor); 18 | ans += dfs(neighbor, graph); 19 | } 20 | } 21 | 22 | return ans; 23 | } 24 | -------------------------------------------------------------------------------- /src/code/java/graph/dijkstra.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | import java.util.Comparator; 3 | import java.util.PriorityQueue; 4 | import java.util.Queue; 5 | import java.util.List; 6 | 7 | 8 | public int[] dijkstras(List> graph, int source) { 9 | int n = graph.size(); 10 | int[] distances = new int[n]; 11 | Arrays.fill(distances, Integer.MAX_VALUE); 12 | distances[source] = 0; 13 | 14 | PriorityQueue pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1])); 15 | pq.offer(new int[]{source, 0}); 16 | 17 | while (!pq.isEmpty()) { 18 | int[] curr = pq.poll(); 19 | int node = curr[0]; 20 | int dist = curr[1]; 21 | 22 | if (dist > distances[node]) { 23 | continue; 24 | } 25 | 26 | for (int[] edge : graph.get(node)) { 27 | int neighbor = edge[0]; 28 | int weight = edge[1]; 29 | int newDist = dist + weight; 30 | 31 | if (newDist < distances[neighbor]) { 32 | distances[neighbor] = newDist; 33 | pq.offer(new int[]{neighbor, newDist}); 34 | } 35 | } 36 | } 37 | 38 | return distances; 39 | } 40 | -------------------------------------------------------------------------------- /src/code/java/graph/kahn.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.HashMap; 3 | import java.util.LinkedList; 4 | import java.util.List; 5 | import java.util.Map; 6 | import java.util.Queue; 7 | 8 | 9 | public static List kahnTopologicalSort(Map> graph) { 10 | List result = new ArrayList<>(); 11 | Map indegree = new HashMap<>(); 12 | Queue que = new LinkedList<>(); 13 | 14 | for (List vertices : graph.values()) { 15 | for (int v : vertices) { 16 | indegree.put(v, indegree.getOrDefault(v, 0) + 1); 17 | } 18 | } 19 | 20 | for (Integer node : graph.keySet()) { 21 | if (!indegree.containsKey(node)) { 22 | que.offer(node); 23 | } 24 | } 25 | 26 | while (!que.isEmpty()) { 27 | int node = que.poll(); 28 | result.add(node); 29 | 30 | if (graph.containsKey(node)) { 31 | for (int neighbor : graph.get(node)) { 32 | indegree.put(neighbor, indegree.get(neighbor) - 1); 33 | 34 | if (indegree.get(neighbor) == 0) { 35 | que.offer(neighbor); 36 | } 37 | } 38 | } 39 | } 40 | 41 | if (result.size() != graph.size()) { 42 | return new ArrayList<>(); 43 | } 44 | 45 | return result; 46 | } 47 | -------------------------------------------------------------------------------- /src/code/java/graph/kruskal.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Collections; 3 | import java.util.List; 4 | 5 | 6 | public List kruskalMST(int n, List edges) { 7 | List mst = new ArrayList<>(); 8 | UnionFind uf = new UnionFind(n); 9 | Collections.sort(edges, (a, b) -> Integer.compare(a[0], b[0])); 10 | 11 | for (int[] edge : edges) { 12 | int weight = edge[0]; 13 | int u = edge[1]; 14 | int v = edge[2]; 15 | 16 | if (!uf.connected(u, v)) { 17 | uf.union(u, v); 18 | mst.add(edge); 19 | } 20 | } 21 | 22 | return mst; 23 | } 24 | -------------------------------------------------------------------------------- /src/code/java/graph/prim.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Comparator; 3 | import java.util.List; 4 | import java.util.PriorityQueue; 5 | 6 | 7 | public List primMST(int n, List edges) { 8 | List mst = new ArrayList<>(); 9 | UnionFind uf = new UnionFind(n); 10 | PriorityQueue pq = new PriorityQueue<>(Comparator.comparingInt(edge -> edge[0])); 11 | 12 | for (int[] edge : edges) { 13 | pq.offer(edge); 14 | } 15 | 16 | while (!pq.isEmpty()) { 17 | int[] edge = pq.poll(); 18 | int w = edge[0]; 19 | int u = edge[1]; 20 | int v = edge[2]; 21 | 22 | if (!uf.connected(u, v)) { 23 | uf.union(u, v); 24 | mst.add(edge); 25 | } 26 | } 27 | 28 | return mst; 29 | } 30 | -------------------------------------------------------------------------------- /src/code/java/hash_map/find_number_of_subarrays.java: -------------------------------------------------------------------------------- 1 | import java.util.HashMap; 2 | import java.util.Map; 3 | 4 | 5 | public int fn(int[] arr, int k) { 6 | Map counts = new HashMap<>(); 7 | counts.put(0, 1); 8 | int ans = 0; 9 | int curr = 0; 10 | 11 | for (int num: arr) { 12 | // TODO: logic to change curr 13 | ans += counts.getOrDefault(curr - k, 0); 14 | counts.put(curr, counts.getOrDefault(curr, 0) + 1); 15 | } 16 | 17 | return ans; 18 | } 19 | -------------------------------------------------------------------------------- /src/code/java/hash_map/sliding_window.java: -------------------------------------------------------------------------------- 1 | import java.util.HashSet; 2 | import java.util.Set; 3 | 4 | 5 | public int fn(int[] arr) { 6 | Set window = new HashSet<>(); 7 | int ans = 0; 8 | int left = 0; 9 | 10 | for (int right = 0; right < arr.length; right++) { 11 | // TODO: add arr[right] to window 12 | 13 | while (WINDOW_CONDITION_BROKEN) { 14 | // TODO: remove arr[left] from window 15 | left++; 16 | } 17 | 18 | // TODO: update ans 19 | } 20 | 21 | return ans; 22 | } 23 | -------------------------------------------------------------------------------- /src/code/java/heap/find_top_k_elements.java: -------------------------------------------------------------------------------- 1 | import java.util.PriorityQueue; 2 | 3 | 4 | public int[] fn(int[] arr, int k) { 5 | PriorityQueue heap = new PriorityQueue<>(CRITERIA); 6 | 7 | for (int num: arr) { 8 | // TODO: logic to push onto heap according to problem's criteria 9 | heap.add(num); 10 | 11 | if (heap.size() > k) { 12 | heap.remove(); 13 | } 14 | } 15 | 16 | int[] ans = new int[k]; 17 | 18 | for (int i = 0; i < k; i++) { 19 | ans[i] = heap.remove(); 20 | } 21 | 22 | return ans; 23 | } 24 | -------------------------------------------------------------------------------- /src/code/java/linked_list/fast_and_slow_pointer.java: -------------------------------------------------------------------------------- 1 | public int fn(ListNode head) { 2 | ListNode slow = head; 3 | ListNode fast = head; 4 | int ans = 0; 5 | 6 | while (fast != null && fast.next != null) { 7 | // TODO: logic 8 | slow = slow.next; 9 | fast = fast.next.next; 10 | } 11 | 12 | return ans; 13 | } 14 | -------------------------------------------------------------------------------- /src/code/java/linked_list/reverse_linked_list.java: -------------------------------------------------------------------------------- 1 | public ListNode fn(ListNode head) { 2 | ListNode curr = head; 3 | ListNode prev = null; 4 | 5 | while (curr != null) { 6 | ListNode nextNode = curr.next; 7 | curr.next = prev; 8 | prev = curr; 9 | curr = nextNode; 10 | } 11 | 12 | return prev; 13 | } 14 | -------------------------------------------------------------------------------- /src/code/java/matrix/create_copy.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | 5 | public void fn(List> matrix) { 6 | List> createMatrix = new ArrayList<>(); 7 | List> copyMatrix = new ArrayList<>(); 8 | int r = matrix.size(); 9 | int c = matrix.get(0).size(); 10 | 11 | for (int i = 0; i < r; i++) { 12 | List row = new ArrayList<>(); 13 | 14 | for (int j = 0; j < c; j++) { 15 | row.add(0); 16 | } 17 | 18 | createMatrix.add(row); 19 | } 20 | 21 | for (List row : matrix) { 22 | copyMatrix.add(new ArrayList<>(row)); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/code/java/matrix/diagonals.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | 5 | public void fn(List> matrix) { 6 | List mainDiagonal = new ArrayList<>(); 7 | List antiDiagonal = new ArrayList<>(); 8 | int r = matrix.size(); 9 | int c = matrix.get(0).size(); 10 | 11 | for (int i = 0; i < Math.min(r, c); i++) { 12 | mainDiagonal.add(matrix.get(i).get(i)); 13 | } 14 | 15 | for (int i = 0; i < Math.min(r, c); i++) { 16 | antiDiagonal.add(matrix.get(i).get(c - 1 - i)); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/code/java/matrix/rotate_transpose.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | 5 | public static void fn(List> matrix) { 6 | List> transpose = new ArrayList<>(); 7 | List> rotateLeft = new ArrayList<>(); 8 | List> rotateRight = new ArrayList<>(); 9 | int r = matrix.size(); 10 | int c = matrix.get(0).size(); 11 | 12 | for (int j = 0; j < c; j++) { 13 | List newRow = new ArrayList<>(); 14 | 15 | for (int i = 0; i < r; i++) { 16 | newRow.add(matrix.get(i).get(j)); 17 | } 18 | 19 | transpose.add(newRow); 20 | } 21 | 22 | for (int i = transpose.size() - 1; i >= 0; i--) { 23 | rotateLeft.add(transpose.get(i)); 24 | } 25 | 26 | for (List row : transpose) { 27 | List newRow = new ArrayList<>(); 28 | 29 | for (int i = row.size() - 1; i >= 0; i--) { 30 | newRow.add(row.get(i)); 31 | } 32 | 33 | rotateRight.add(newRow); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/bogo_sort.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | import java.util.Random; 3 | 4 | 5 | public static void bogoSort(int[] arr) { 6 | int[] target = Arrays.copyOf(arr, arr.length); 7 | Arrays.sort(target); 8 | 9 | while (!Arrays.equals(arr, target)) { 10 | shuffleArray(arr); 11 | } 12 | } 13 | 14 | public static void shuffleArray(int[] arr) { 15 | Random rnd = new Random(); 16 | 17 | for (int i = arr.length - 1; i > 0; i--) { 18 | int index = rnd.nextInt(i + 1); 19 | int temp = arr[index]; 20 | arr[index] = arr[i]; 21 | arr[i] = temp; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/bubble_sort.java: -------------------------------------------------------------------------------- 1 | public static void bubbleSort(int[] arr) { 2 | int n = arr.length; 3 | 4 | for (int i = 0; i < n; i++) { 5 | boolean swapped = false; 6 | 7 | for (int j = 0; j < n - i - 1; j++) { 8 | if (arr[j] > arr[j + 1]) { 9 | int temp = arr[j]; 10 | arr[j] = arr[j + 1]; 11 | arr[j + 1] = temp; 12 | swapped = true; 13 | } 14 | } 15 | 16 | if (!swapped) { 17 | break; 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/bucket_sort.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Arrays; 3 | import java.util.Collections; 4 | import java.util.List; 5 | 6 | 7 | public static int[] bucketSort(int[] arr) { 8 | int numBuckets = 10; 9 | int index; 10 | int[] result = new int[arr.length]; 11 | int minNum = Arrays.stream(arr).min().getAsInt(); 12 | int maxNum = Arrays.stream(arr).max().getAsInt(); 13 | double bucketSize = (double) (maxNum - minNum) / numBuckets; 14 | List> buckets = new ArrayList<>(numBuckets); 15 | 16 | for (int i = 0; i < numBuckets; i++) { 17 | buckets.add(new ArrayList<>()); 18 | } 19 | 20 | for (int num : arr) { 21 | index = Math.min((int) ((num - minNum) / bucketSize), numBuckets - 1); 22 | buckets.get(index).add(num); 23 | } 24 | 25 | index = 0; 26 | 27 | for (List bucket : buckets) { 28 | Collections.sort(bucket); 29 | 30 | for (int num : bucket) { 31 | result[index++] = num; 32 | } 33 | } 34 | 35 | return result; 36 | } 37 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/counting_sort.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | 4 | public static int[] countingSort(int[] arr) { 5 | int maxNum = Arrays.stream(arr).max().orElse(Integer.MIN_VALUE); 6 | int minNum = Arrays.stream(arr).min().orElse(Integer.MAX_VALUE); 7 | int countRange = maxNum - minNum + 1; 8 | int[] count = new int[countRange]; 9 | int[] output = new int[arr.length]; 10 | 11 | for (int num : arr) { 12 | count[num - minNum]++; 13 | } 14 | 15 | for (int i = 1; i < countRange; i++) { 16 | count[i] += count[i - 1]; 17 | } 18 | 19 | for (int i = arr.length - 1; i >= 0; i--) { 20 | output[count[arr[i] - minNum] - 1] = arr[i]; 21 | count[arr[i] - minNum]--; 22 | } 23 | 24 | return output; 25 | } 26 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/heap_sort.java: -------------------------------------------------------------------------------- 1 | public static int[] heapSort(int[] arr) { 2 | int n = arr.length; 3 | 4 | for (int i = n / 2 - 1; i >= 0; i--) { 5 | heapify(arr, n, i); 6 | } 7 | 8 | for (int i = n - 1; i > 0; i--) { 9 | int temp = arr[0]; 10 | arr[0] = arr[i]; 11 | arr[i] = temp; 12 | 13 | heapify(arr, i, 0); 14 | } 15 | 16 | return arr; 17 | } 18 | 19 | public static void heapify(int[] arr, int n, int i) { 20 | int largest = i; 21 | int left = 2 * i + 1; 22 | int right = 2 * i + 2; 23 | 24 | if (left < n && arr[left] > arr[largest]) { 25 | largest = left; 26 | } 27 | if (right < n && arr[right] > arr[largest]) { 28 | largest = right; 29 | } 30 | if (largest != i) { 31 | int temp = arr[i]; 32 | arr[i] = arr[largest]; 33 | arr[largest] = temp; 34 | 35 | heapify(arr, n, largest); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/insertion_sort.java: -------------------------------------------------------------------------------- 1 | public static void insertionSort(int[] arr) { 2 | int n = arr.length; 3 | 4 | for (int i = 1; i < n; i++) { 5 | int key = arr[i]; 6 | int j = i - 1; 7 | 8 | while (j >= 0 && key < arr[j]) { 9 | arr[j + 1] = arr[j]; 10 | j--; 11 | } 12 | 13 | arr[j + 1] = key; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/merge_sort.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | 4 | public static int[] mergeSort(int[] arr) { 5 | int n = arr.length; 6 | 7 | if (n <= 1) { 8 | return arr; 9 | } 10 | 11 | int mid = n / 2; 12 | int[] left = Arrays.copyOfRange(arr, 0, mid); 13 | int[] right = Arrays.copyOfRange(arr, mid, n); 14 | 15 | left = mergeSort(left); 16 | right = mergeSort(right); 17 | 18 | return merge(left, right); 19 | } 20 | 21 | public static int[] merge(int[] left, int[] right) { 22 | int[] output = new int[left.length + right.length]; 23 | int i = 0, j = 0, k = 0; 24 | 25 | while (i < left.length && j < right.length) { 26 | if (left[i] <= right[j]) { 27 | output[k++] = left[i++]; 28 | } else { 29 | output[k++] = right[j++]; 30 | } 31 | } 32 | 33 | while (i < left.length) { 34 | output[k++] = left[i++]; 35 | } 36 | 37 | while (j < right.length) { 38 | output[k++] = right[j++]; 39 | } 40 | 41 | return output; 42 | } 43 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/pancake_sort.java: -------------------------------------------------------------------------------- 1 | public static void pancakeSort(int[] arr) { 2 | int n = arr.length; 3 | 4 | for (int size = n; size >= 2; size--) { 5 | int maxIdx = findMaxIndex(arr, size); 6 | 7 | if (maxIdx != size - 1) { 8 | flip(arr, maxIdx); 9 | flip(arr, size - 1); 10 | } 11 | } 12 | } 13 | 14 | public static void flip(int[] arr, int i) { 15 | int left = 0; 16 | 17 | while (left < i) { 18 | int temp = arr[left]; 19 | arr[left] = arr[i]; 20 | arr[i] = temp; 21 | left++; 22 | i--; 23 | } 24 | } 25 | 26 | public static int findMaxIndex(int[] arr, int n) { 27 | int maxIdx = 0; 28 | 29 | for (int i = 0; i < n; i++) { 30 | if (arr[i] > arr[maxIdx]) { 31 | maxIdx = i; 32 | } 33 | } 34 | 35 | return maxIdx; 36 | } 37 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/quick_sort.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | 5 | public static int[] quickSort(int[] arr) { 6 | int n = arr.length; 7 | 8 | if (n <= 1) { 9 | return arr; 10 | } 11 | 12 | int pivot = arr[n / 2]; 13 | List left = new ArrayList<>(); 14 | List right = new ArrayList<>(); 15 | 16 | for (int x : arr) { 17 | if (x < pivot) { 18 | left.add(x); 19 | } else if (x > pivot) { 20 | right.add(x); 21 | } 22 | } 23 | 24 | int[] sortedLeft = quickSort(left.stream().mapToInt(i -> i).toArray()); 25 | int[] sortedRight = quickSort(right.stream().mapToInt(i -> i).toArray()); 26 | int[] result = new int[n]; 27 | 28 | System.arraycopy(sortedLeft, 0, result, 0, sortedLeft.length); 29 | result[sortedLeft.length] = pivot; 30 | System.arraycopy(sortedRight, 0, result, sortedLeft.length + 1, sortedRight.length); 31 | 32 | return result; 33 | } 34 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/radix_sort.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | 4 | public static void radixSort(int[] arr) { 5 | int maxVal = Arrays.stream(arr).max().getAsInt(); 6 | int exp = 1; 7 | 8 | while (maxVal / exp > 0) { 9 | countingSort(arr, exp); 10 | exp *= 10; 11 | } 12 | } 13 | 14 | public static void countingSort(int[] arr, int exp) { 15 | int n = arr.length; 16 | int[] output = new int[n]; 17 | int[] count = new int[10]; 18 | 19 | for (int i = 0; i < n; i++) { 20 | int idx = arr[i] / exp; 21 | count[idx % 10]++; 22 | } 23 | 24 | for (int i = 1; i < 10; i++) { 25 | count[i] += count[i - 1]; 26 | } 27 | 28 | for (int i = n - 1; i >= 0; i--) { 29 | int idx = arr[i] / exp; 30 | output[count[idx % 10] - 1] = arr[i]; 31 | count[idx % 10]--; 32 | } 33 | 34 | System.arraycopy(output, 0, arr, 0, n); 35 | } 36 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/selection_sort.java: -------------------------------------------------------------------------------- 1 | public static void selectionSort(int[] arr) { 2 | int n = arr.length; 3 | 4 | for (int i = 0; i < n; i++) { 5 | int minIdx = i; 6 | 7 | for (int j = i + 1; j < n; j++) { 8 | if (arr[j] < arr[minIdx]) { 9 | minIdx = j; 10 | } 11 | } 12 | 13 | if (minIdx != i) { 14 | int temp = arr[i]; 15 | arr[i] = arr[minIdx]; 16 | arr[minIdx] = temp; 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/shell_sort.java: -------------------------------------------------------------------------------- 1 | public static void shellSort(int[] arr) { 2 | int n = arr.length; 3 | int[] gaps = {701, 301, 132, 57, 23, 10, 4, 1}; 4 | 5 | for (int gap : gaps) { 6 | for (int i = gap; i < n; i++) { 7 | int tmp = arr[i]; 8 | int j = i; 9 | 10 | while (j >= gap && arr[j - gap] > tmp) { 11 | arr[j] = arr[j - gap]; 12 | j -= gap; 13 | } 14 | 15 | if (j != i) { 16 | arr[j] = tmp; 17 | } 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/code/java/sorting_algorithms/sleep_sort.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | 5 | public static int[] sleepSort(int[] arr) { 6 | List sortedArr = new ArrayList<>(); 7 | List threads = new ArrayList<>(); 8 | 9 | for (int num : arr) { 10 | Thread thread = new Thread(() -> snorlax(num, sortedArr)); 11 | threads.add(thread); 12 | } 13 | 14 | for (Thread thread : threads) { 15 | thread.start(); 16 | } 17 | 18 | for (Thread thread : threads) { 19 | try { 20 | thread.join(); 21 | } catch (InterruptedException e) { 22 | e.printStackTrace(); 23 | } 24 | } 25 | 26 | return sortedArr.stream().mapToInt(i -> i).toArray(); 27 | } 28 | 29 | public static void snorlax(int num, List arr) { 30 | try { 31 | Thread.sleep(num); 32 | } catch (InterruptedException e) { 33 | e.printStackTrace(); 34 | } 35 | arr.add(num); 36 | } 37 | -------------------------------------------------------------------------------- /src/code/java/stack/monotonic_decreasing.java: -------------------------------------------------------------------------------- 1 | import java.util.Stack; 2 | 3 | 4 | public int fn(int[] arr) { 5 | Stack stack = new Stack<>(); 6 | int ans = 0; 7 | 8 | for (int num : arr) { 9 | while (!stack.isEmpty() && stack.peek() < num) { 10 | // TODO: logic 11 | stack.pop(); 12 | } 13 | stack.push(num); 14 | } 15 | 16 | return ans; 17 | } 18 | -------------------------------------------------------------------------------- /src/code/java/stack/monotonic_increasing.java: -------------------------------------------------------------------------------- 1 | import java.util.Stack; 2 | 3 | 4 | public int fn(int[] arr) { 5 | Stack stack = new Stack<>(); 6 | int ans = 0; 7 | 8 | for (int num : arr) { 9 | while (!stack.isEmpty() && stack.peek() > num) { 10 | // TODO: logic 11 | stack.pop(); 12 | } 13 | stack.push(num); 14 | } 15 | 16 | return ans; 17 | } 18 | -------------------------------------------------------------------------------- /src/code/javascript/array/prefix_sum.js: -------------------------------------------------------------------------------- 1 | const fn = (arr) => { 2 | let prefix = [arr[0]] 3 | 4 | for (let i = 1; i < arr.length; i++) { 5 | prefix.push(prefix[prefix.length - 1] + arr[i]) 6 | } 7 | 8 | return prefix 9 | } 10 | -------------------------------------------------------------------------------- /src/code/javascript/array/sliding_window.js: -------------------------------------------------------------------------------- 1 | const fn = (arr) => { 2 | let window = 0 3 | let ans = 0 4 | let left = 0 5 | 6 | for (let right = 0; right < arr.length; right++) { 7 | // TODO: add arr[right] to window 8 | 9 | while (WINDOW_CONDITION_BROKEN) { 10 | // TODO: remove arr[left] from window 11 | left++ 12 | } 13 | 14 | // TODO: update ans 15 | } 16 | 17 | return ans 18 | } 19 | -------------------------------------------------------------------------------- /src/code/javascript/array/string_building.js: -------------------------------------------------------------------------------- 1 | const fn = (arr) => { 2 | let ans = [] 3 | 4 | for (const c of arr) { 5 | ans.push(c) 6 | } 7 | 8 | return ans.join('') 9 | } 10 | 11 | const fn = (arr) => { 12 | let ans = '' 13 | 14 | for (const c of arr) { 15 | ans += c 16 | } 17 | 18 | return ans 19 | } 20 | -------------------------------------------------------------------------------- /src/code/javascript/array/two_pointers_one_input.js: -------------------------------------------------------------------------------- 1 | const fn = (arr) => { 2 | let ans = 0 3 | let left = 0 4 | let right = arr.length - 1 5 | 6 | while (left < right) { 7 | // TODO: logic with left and right 8 | if (CONDITION) { 9 | left++ 10 | } else { 11 | right-- 12 | } 13 | } 14 | 15 | return ans 16 | } 17 | -------------------------------------------------------------------------------- /src/code/javascript/array/two_pointers_two_inputs.js: -------------------------------------------------------------------------------- 1 | let fn = (arr1, arr2) => { 2 | let ans = 0 3 | let i = 0 4 | let j = 0 5 | 6 | while (i < arr1.length && j < arr2.length) { 7 | // TODO: logic 8 | if (CONDITION) { 9 | i++ 10 | } else { 11 | j++ 12 | } 13 | } 14 | 15 | while (i < arr1.length) { 16 | // TODO: logic 17 | i++ 18 | } 19 | 20 | while (j < arr2.length) { 21 | // TODO: logic 22 | j++ 23 | } 24 | 25 | return ans 26 | } 27 | -------------------------------------------------------------------------------- /src/code/javascript/backtracking/backtracking.js: -------------------------------------------------------------------------------- 1 | const backtrack = (curr, OTHER_ARGUMENTS...) => { 2 | if (BASE_CASE) { 3 | // TODO: modify answer 4 | return 5 | } 6 | 7 | let ans = 0 8 | 9 | for (ITERATE_OVER_INPUT) { 10 | // TODO: modify current state 11 | ans += backtrack(curr, OTHER_ARGUMENTS...) 12 | // TODO: undo modification of current state 13 | } 14 | 15 | return ans 16 | } 17 | -------------------------------------------------------------------------------- /src/code/javascript/binary_search/binary_search.js: -------------------------------------------------------------------------------- 1 | const fn = (arr, target) => { 2 | let left = 0 3 | let right = arr.length - 1 4 | 5 | while (left <= right) { 6 | let mid = Math.floor((left + right) / 2) 7 | 8 | if (arr[mid] == target) { 9 | // TODO: logic 10 | return 11 | } 12 | 13 | if (arr[mid] > target) { 14 | right = mid - 1 15 | } else { 16 | left = mid + 1 17 | } 18 | } 19 | 20 | return left 21 | } 22 | -------------------------------------------------------------------------------- /src/code/javascript/binary_search/duplicate_elements_left_insertion.js: -------------------------------------------------------------------------------- 1 | const fn = (arr, target) => { 2 | let left = 0 3 | let right = arr.length 4 | 5 | while (left < right) { 6 | let mid = Math.floor((left + right) / 2) 7 | 8 | if (arr[mid] >= target) { 9 | right = mid 10 | } else { 11 | left = mid + 1 12 | } 13 | } 14 | 15 | return left 16 | } 17 | -------------------------------------------------------------------------------- /src/code/javascript/binary_search/duplicate_elements_right_insertion.js: -------------------------------------------------------------------------------- 1 | const fn = (arr, target) => { 2 | let left = 0 3 | let right = arr.length 4 | 5 | while (left < right) { 6 | let mid = Math.floor((left + right) / 2) 7 | 8 | if (arr[mid] > target) { 9 | right = mid 10 | } else { 11 | left = mid + 1 12 | } 13 | } 14 | 15 | return left 16 | } 17 | -------------------------------------------------------------------------------- /src/code/javascript/binary_search/greedy_maximum.js: -------------------------------------------------------------------------------- 1 | const fn = (arr) => { 2 | const check = (x) => { 3 | return BOOLEAN 4 | } 5 | 6 | let left = MINIMUM_POSSIBLE_ANSWER 7 | let right = MAXMIMUM_POSSIBLE_ANSWER 8 | 9 | while (left <= right) { 10 | let mid = Math.floor((left + right) / 2) 11 | 12 | if (check(mid)) { 13 | left = mid + 1 14 | } else { 15 | right = mid - 1 16 | } 17 | } 18 | 19 | return right 20 | } 21 | -------------------------------------------------------------------------------- /src/code/javascript/binary_search/greedy_minimum.js: -------------------------------------------------------------------------------- 1 | const fn = (arr) => { 2 | const check = (x) => { 3 | return BOOLEAN 4 | } 5 | 6 | let left = MINIMUM_POSSIBLE_ANSWER 7 | let right = MAXMIMUM_POSSIBLE_ANSWER 8 | 9 | while (left <= right) { 10 | let mid = Math.floor((left + right) / 2) 11 | 12 | if (check(mid)) { 13 | right = mid - 1 14 | } else { 15 | left = mid + 1 16 | } 17 | } 18 | 19 | return left 20 | } 21 | -------------------------------------------------------------------------------- /src/code/javascript/binary_tree/bfs.js: -------------------------------------------------------------------------------- 1 | const fn = (root) => { 2 | let que = [root] 3 | let ans = 0 4 | 5 | while (que.length) { 6 | let currentLength = que.length 7 | let nextQue = [] 8 | // TODO: logic for current level 9 | 10 | for (let i = 0; i < currentLength; i++) { 11 | let node = que[i] 12 | // TODO: logic 13 | if (node.left) { 14 | nextQue.push(node.left) 15 | } 16 | if (node.right) { 17 | nextQue.push(node.right) 18 | } 19 | } 20 | 21 | que = nextQue 22 | } 23 | 24 | return ans 25 | } 26 | -------------------------------------------------------------------------------- /src/code/javascript/binary_tree/dfs_iterative.js: -------------------------------------------------------------------------------- 1 | const dfs = (root) => { 2 | let stack = [root] 3 | let ans = 0 4 | 5 | while (stack.length) { 6 | let node = stack.pop() 7 | // TODO: logic 8 | if (node.left) { 9 | stack.push(node.left) 10 | } 11 | if (node.right) { 12 | stack.push(node.right) 13 | } 14 | } 15 | 16 | return ans 17 | } 18 | -------------------------------------------------------------------------------- /src/code/javascript/binary_tree/dfs_recursive.js: -------------------------------------------------------------------------------- 1 | const dfs = (root) => { 2 | if (!root) { 3 | return 4 | } 5 | 6 | let ans = 0 7 | 8 | // TODO: logic 9 | dfs(root.left) 10 | dfs(root.right) 11 | 12 | return ans 13 | } 14 | -------------------------------------------------------------------------------- /src/code/javascript/bit_manipulation/check_power_of_two.js: -------------------------------------------------------------------------------- 1 | const isPowerOfTwo = (num) => { 2 | return (num & (num - 1)) === 0 3 | } 4 | -------------------------------------------------------------------------------- /src/code/javascript/bit_manipulation/clear_kth_bit.js: -------------------------------------------------------------------------------- 1 | const clearKthBit = (num, k) => { 2 | return num & ~(1 << k) 3 | } 4 | -------------------------------------------------------------------------------- /src/code/javascript/bit_manipulation/count_set_bits.js: -------------------------------------------------------------------------------- 1 | const countSetBits = (num) => { 2 | return num.toString(2).split('1').length - 1 3 | } 4 | -------------------------------------------------------------------------------- /src/code/javascript/bit_manipulation/divide_power_of_two.js: -------------------------------------------------------------------------------- 1 | const divideByPowerOfTwo = (num, k) => { 2 | return num >> k; 3 | } 4 | -------------------------------------------------------------------------------- /src/code/javascript/bit_manipulation/get_rightmost_bit.js: -------------------------------------------------------------------------------- 1 | const getRightmostSetBit = (num) => { 2 | return num & -num 3 | } 4 | -------------------------------------------------------------------------------- /src/code/javascript/bit_manipulation/multiply_power_of_two.js: -------------------------------------------------------------------------------- 1 | const multiplyByPowerOfTwo = (num, k) => { 2 | return num << k 3 | } 4 | -------------------------------------------------------------------------------- /src/code/javascript/bit_manipulation/set_kth_bit.js: -------------------------------------------------------------------------------- 1 | const setKthBit = (num, k) => { 2 | return num | (1 << k) 3 | } 4 | -------------------------------------------------------------------------------- /src/code/javascript/bit_manipulation/swap_variables.js: -------------------------------------------------------------------------------- 1 | const swapVariables = (num1, num2) => { 2 | num1 ^= num2 3 | num2 ^= num1 4 | num1 ^= num2 5 | return [num1, num2] 6 | } 7 | -------------------------------------------------------------------------------- /src/code/javascript/bit_manipulation/test_kth_bit.js: -------------------------------------------------------------------------------- 1 | const testKthBit = (num, k) => { 2 | return num & (1 << k) !== 0 3 | } 4 | -------------------------------------------------------------------------------- /src/code/javascript/bit_manipulation/toggle_kth_bit.js: -------------------------------------------------------------------------------- 1 | const toggleKthBit = (num, k) => { 2 | return num ^ (1 << k) 3 | } 4 | -------------------------------------------------------------------------------- /src/code/javascript/data_structures/array.js: -------------------------------------------------------------------------------- 1 | class Array { 2 | constructor(size) { 3 | this.size = size 4 | this.data = new Array(size).fill(null) 5 | } 6 | 7 | getItem(index) { 8 | return this.data[index] 9 | } 10 | 11 | setItem(index, value) { 12 | this.data[index] = value 13 | } 14 | 15 | get length() { 16 | return this.data.length 17 | } 18 | 19 | toString() { 20 | return this.data.toString() 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/code/javascript/data_structures/binary_search_tree.js: -------------------------------------------------------------------------------- 1 | class TreeNode { 2 | constructor(data) { 3 | this.data = data 4 | this.left = null 5 | this.right = null 6 | } 7 | } 8 | 9 | class BinarySearchTree { 10 | constructor() { 11 | this.root = null 12 | } 13 | 14 | insert(data) { 15 | if (!this.root) { 16 | this.root = new TreeNode(data) 17 | } else { 18 | this._insertNode(this.root, data) 19 | } 20 | } 21 | 22 | _insertNode(node, data) { 23 | if (data < node.data) { 24 | if (!node.left) { 25 | node.left = new TreeNode(data) 26 | } else { 27 | this._insertNode(node.left, data) 28 | } 29 | } else { 30 | if (!node.right) { 31 | node.right = new TreeNode(data) 32 | } else { 33 | this._insertNode(node.right, data) 34 | } 35 | } 36 | } 37 | 38 | toString() { 39 | return this.root ? this._printTree(this.root, '', true) : 'Empty tree' 40 | } 41 | 42 | _printTree(node, prefix, isLeft) { 43 | if (!node) { 44 | return '' 45 | } 46 | 47 | let result = '' 48 | result += this._printTree(node.right, prefix + (isLeft ? '│ ' : ' '), false) 49 | result += prefix + (isLeft ? '└── ' : '┌── ') + node.data + '\n' 50 | result += this._printTree(node.left, prefix + (isLeft ? ' ' : '│ '), true) 51 | 52 | return result 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /src/code/javascript/data_structures/binary_tree.js: -------------------------------------------------------------------------------- 1 | class TreeNode { 2 | constructor(data) { 3 | this.data = data 4 | this.left = null 5 | this.right = null 6 | } 7 | } 8 | 9 | class BinaryTree { 10 | constructor() { 11 | this.root = null 12 | } 13 | 14 | insert(data) { 15 | if (!this.root) { 16 | this.root = new TreeNode(data) 17 | } else { 18 | this.insertNode(this.root, data) 19 | } 20 | } 21 | 22 | insertNode(node, data) { 23 | if (!node) { 24 | return new TreeNode(data) 25 | } 26 | 27 | if (!node.left) { 28 | node.left = new TreeNode(data) 29 | } else if (!node.right) { 30 | node.right = new TreeNode(data) 31 | } else { 32 | node.left = this.insertNode(node.left, data) 33 | } 34 | 35 | return node 36 | } 37 | 38 | toString() { 39 | return this.root ? this.printTree(this.root, '', true) : 'Empty tree' 40 | } 41 | 42 | printTree(node, prefix, isLeft) { 43 | if (!node) { 44 | return '' 45 | } 46 | 47 | let result = '' 48 | result += this.printTree(node.right, prefix + (isLeft ? '│ ' : ' '), false) 49 | result += prefix + (isLeft ? '└── ' : '┌── ') + node.data + '\n' 50 | result += this.printTree(node.left, prefix + (isLeft ? ' ' : '│ '), true) 51 | 52 | return result 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /src/code/javascript/data_structures/graph.js: -------------------------------------------------------------------------------- 1 | class Graph { 2 | constructor() { 3 | this.graph = {} 4 | } 5 | 6 | addVertex(vertex) { 7 | if (!(vertex in this.graph)) { 8 | this.graph[vertex] = [] 9 | } 10 | } 11 | 12 | addEdge(a, b) { 13 | this.addVertex(a) 14 | this.addVertex(b) 15 | this.graph[a].push(b) 16 | this.graph[b].push(a) 17 | } 18 | 19 | getNeighbors(vertex) { 20 | return this.graph[vertex] || [] 21 | } 22 | 23 | toString() { 24 | let output = '' 25 | 26 | for (const [vertex, neighbors] of Object.entries(this.graph)) { 27 | output += `${vertex} - ${neighbors.join(' - ')}\n` 28 | } 29 | 30 | return output 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/code/javascript/data_structures/hash_map.js: -------------------------------------------------------------------------------- 1 | class HashMap { 2 | constructor() { 3 | this.size = 100000 4 | this.bucket = new Array(this.size).fill(null) 5 | } 6 | 7 | _hash(key) { 8 | return key % this.size 9 | } 10 | 11 | setItem(key, value) { 12 | this.bucket[this._hash(key)] = value 13 | } 14 | 15 | getItem(key) { 16 | return this.bucket[this._hash(key)] 17 | } 18 | 19 | deleteItem(key) { 20 | this.bucket[this._hash(key)] = null 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/code/javascript/data_structures/union_find.js: -------------------------------------------------------------------------------- 1 | class UnionFind { 2 | constructor(n) { 3 | this.root = [...Array(n).keys()] 4 | } 5 | 6 | find(a) { 7 | return a === this.root[a] ? a : this.find(this.root[a]) 8 | } 9 | 10 | union(a, b) { 11 | this.root[this.find(a)] = this.find(b) 12 | } 13 | 14 | connected(a, b) { 15 | return this.find(a) === this.find(b) 16 | } 17 | 18 | toString() { 19 | const n = this.root.length 20 | const lines = [] 21 | const components = {} 22 | 23 | for (let i = 0; i < n; i++) { 24 | const root = this.find(i) 25 | 26 | if (!(root in components)) { 27 | components[root] = [] 28 | } 29 | 30 | components[root].push(i) 31 | } 32 | 33 | for (const component of Object.values(components)) { 34 | lines.push(`(${component.join(' - ')})`) 35 | } 36 | 37 | return lines.join('\n') 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/code/javascript/data_structures/union_find_optimized.js: -------------------------------------------------------------------------------- 1 | class UnionFind { 2 | constructor(n) { 3 | this.root = [...Array(n).keys()] 4 | this.rank = Array(n).fill(1) 5 | } 6 | 7 | find(a) { 8 | return a === this.root[a] ? a : this.find(this.root[a]) 9 | } 10 | 11 | union(a, b) { 12 | const rootA = this.find(a) 13 | const rootB = this.find(b) 14 | 15 | if (rootA !== rootB) { 16 | if (this.rank[rootA] < this.rank[rootB]) { 17 | this.root[rootA] = rootB 18 | } else if (this.rank[rootA] > this.rank[rootB]) { 19 | this.root[rootB] = rootA 20 | } else { 21 | this.root[rootB] = rootA 22 | this.rank[rootA]++ 23 | } 24 | } 25 | } 26 | 27 | connected(a, b) { 28 | return this.find(a) === this.find(b) 29 | } 30 | 31 | toString() { 32 | const n = this.root.length 33 | const lines = [] 34 | const components = {} 35 | 36 | for (let i = 0; i < n; i++) { 37 | const root = this.find(i) 38 | 39 | if (!(root in components)) { 40 | components[root] = [] 41 | } 42 | 43 | components[root].push(i) 44 | } 45 | 46 | for (const component of Object.values(components)) { 47 | lines.push(component.map(node => `(${node})`).join(' - ')) 48 | } 49 | 50 | return lines.join('\n') 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /src/code/javascript/dynamic_programming/bottom_up.js: -------------------------------------------------------------------------------- 1 | const fn = (arr) => { 2 | const dp = new Array(STATE_FOR_WHOLE_INPUT + 1).fill(BASE_CASE) 3 | 4 | for (let state = SMALLEST_SUBPROBLEM; state <= STATE_FOR_WHOLE_INPUT; state++) { 5 | if (BASE_CASE) { 6 | dp[state] = BASE_CASE 7 | } else { 8 | dp[state] = RECURRENCE_RELATION(state) 9 | } 10 | } 11 | 12 | return dp[STATE_FOR_WHOLE_INPUT] 13 | } 14 | -------------------------------------------------------------------------------- /src/code/javascript/dynamic_programming/kadane.js: -------------------------------------------------------------------------------- 1 | const kadane = (arr) => { 2 | let currSub = arr[0] 3 | let maxSub = arr[0] 4 | 5 | for (let i = 1; i < arr.length; i++) { 6 | currSub = Math.max(currSub + arr[i], arr[i]) 7 | maxSub = Math.max(maxSub, currSub) 8 | } 9 | 10 | return maxSub 11 | } 12 | -------------------------------------------------------------------------------- /src/code/javascript/dynamic_programming/top_down.js: -------------------------------------------------------------------------------- 1 | const fn = (arr) => { 2 | const dp = (STATE) => { 3 | if (BASE_CASE) { 4 | return 0 5 | } 6 | 7 | if (memo[STATE] != -1) { 8 | return memo[STATE] 9 | } 10 | 11 | let ans = RECURRENCE_RELATION(STATE) 12 | memo[STATE] = ans 13 | 14 | return ans 15 | } 16 | 17 | let memo = ARRAY_SIZED_ACCORDING_TO_STATE 18 | 19 | return dp(STATE_FOR_WHOLE_INPUT) 20 | } 21 | -------------------------------------------------------------------------------- /src/code/javascript/graph/bellman_ford.js: -------------------------------------------------------------------------------- 1 | const bellmanFord = (n, edges, source) => { 2 | let distances = new Array(n).fill(Infinity) 3 | distances[source] = 0 4 | 5 | for (let i = 0; i < n - 1; i++) { 6 | for (let j = 0; j < edges.length; j++) { 7 | let [u, v, w] = edges[j] 8 | 9 | if (distances[u] !== Infinity && distances[u] + w < distances[v]) { 10 | distances[v] = distances[u] + w 11 | } 12 | } 13 | } 14 | 15 | for (let i = 0; i < edges.length; i++) { 16 | let [u, v, w] = edges[i] 17 | 18 | if (distances[u] !== Infinity && distances[u] + w < distances[v]) { 19 | return [] 20 | } 21 | } 22 | 23 | return distances 24 | } 25 | -------------------------------------------------------------------------------- /src/code/javascript/graph/bfs.js: -------------------------------------------------------------------------------- 1 | const fn = (graph) => { 2 | let que = [START_NODE] 3 | let seen = new Set([START_NODE]) 4 | let ans = 0 5 | 6 | while (que.length) { 7 | let currentLength = que.length 8 | let nextQue = [] 9 | 10 | for (let i = 0; i < currentLength; i++) { 11 | let node = que[i] 12 | // TODO: logic 13 | for (const neighbor of graph[node]) { 14 | if (!seen.has(neighbor)) { 15 | seen.add(neighbor) 16 | nextQue.push(neighbor) 17 | } 18 | } 19 | } 20 | 21 | que = nextQue 22 | } 23 | 24 | return ans 25 | } 26 | -------------------------------------------------------------------------------- /src/code/javascript/graph/dfs_iterative.js: -------------------------------------------------------------------------------- 1 | const fn = (graph) => { 2 | let stack = [START_NODE] 3 | let seen = new Set([START_NODE]) 4 | let ans = 0 5 | 6 | while (stack.length) { 7 | let node = stack.pop() 8 | // TODO: logic 9 | for (const neighbor of graph[node]) { 10 | if (!seen.has(neighbor)) { 11 | seen.add(neighbor) 12 | stack.push(neighbor) 13 | } 14 | } 15 | } 16 | 17 | return ans 18 | } 19 | -------------------------------------------------------------------------------- /src/code/javascript/graph/dfs_recursive.js: -------------------------------------------------------------------------------- 1 | const fn = (graph) => { 2 | const dfs = (node) => { 3 | let ans = 0 4 | // TODO: logic 5 | for (const neighbor of graph[node]) { 6 | if (!seen.has(neighbor)) { 7 | seen.add(neighbor) 8 | ans += dfs(neighbor) 9 | } 10 | } 11 | 12 | return ans 13 | } 14 | 15 | let seen = new Set([START_NODE]) 16 | 17 | return dfs(START_NODE) 18 | } 19 | -------------------------------------------------------------------------------- /src/code/javascript/graph/dijkstra.js: -------------------------------------------------------------------------------- 1 | /* 2 | JavaScript lacks built-in support for heaps. 3 | Try using a language that doesn't hate you, like Python. 4 | */ 5 | -------------------------------------------------------------------------------- /src/code/javascript/graph/kahn.js: -------------------------------------------------------------------------------- 1 | const kahnTopologicalSort = (graph) => { 2 | const result = [] 3 | const queue = [] 4 | const indegree = new Map() 5 | 6 | for (let nodes of Object.values(graph)) { 7 | for (let node of nodes) { 8 | if (indegree.has(node)) { 9 | indegree.set(node, indegree.get(node) + 1) 10 | } else { 11 | indegree.set(node, 1) 12 | } 13 | } 14 | } 15 | 16 | for (let node of Object.keys(graph)) { 17 | if (!indegree.has(node)) { 18 | queue.push(node) 19 | } 20 | } 21 | 22 | while (queue.length > 0) { 23 | const node = queue.shift() 24 | result.push(node) 25 | 26 | if (graph[node]) { 27 | for (let neighbor of graph[node]) { 28 | indegree.set(neighbor, indegree.get(neighbor) - 1) 29 | 30 | if (indegree.get(neighbor) === 0) { 31 | queue.push(neighbor) 32 | } 33 | } 34 | } 35 | } 36 | 37 | return result.length === Object.keys(graph).length ? result : [] 38 | } 39 | -------------------------------------------------------------------------------- /src/code/javascript/graph/kruskal.js: -------------------------------------------------------------------------------- 1 | const kruskalMst = (n, edges) => { 2 | let mst = [] 3 | let uf = new UnionFind(n) 4 | 5 | edges.sort((a, b) => a[0] - b[0]) 6 | 7 | for (let i = 0; i < edges.length; i++) { 8 | let [w, u, v] = edges[i] 9 | 10 | if (!uf.connected(u, v)) { 11 | uf.union(u, v) 12 | mst.push([w, u, v]) 13 | } 14 | } 15 | 16 | return mst 17 | } 18 | -------------------------------------------------------------------------------- /src/code/javascript/graph/prim.js: -------------------------------------------------------------------------------- 1 | /* 2 | JavaScript lacks built-in support for heaps. 3 | Try using a language that doesn't hate you, like Python. 4 | */ 5 | -------------------------------------------------------------------------------- /src/code/javascript/hash_map/find_number_of_subarrays.js: -------------------------------------------------------------------------------- 1 | const fn = (arr, k) => { 2 | let counts = new Map() 3 | counts.set(0, 1) 4 | let ans = 0 5 | let curr = 0 6 | 7 | for (const num of arr) { 8 | // TODO: logic to change curr 9 | ans += counts.get(curr - k) || 0 10 | counts.set(curr, (counts.get(curr) || 0) + 1) 11 | } 12 | 13 | return ans 14 | } 15 | -------------------------------------------------------------------------------- /src/code/javascript/hash_map/sliding_window.js: -------------------------------------------------------------------------------- 1 | function fn(arr) { 2 | let window = new Set() 3 | let ans = 0 4 | let left = 0 5 | 6 | for (let right = 0; right < arr.length; right++) { 7 | // TODO: add arr[right] to window 8 | 9 | while (WINDOW_CONDITION_BROKEN) { 10 | // TODO: remove arr[left] from window 11 | left += 1 12 | } 13 | 14 | // TODO: update ans 15 | } 16 | 17 | return ans 18 | } 19 | -------------------------------------------------------------------------------- /src/code/javascript/heap/find_top_k_elements.js: -------------------------------------------------------------------------------- 1 | /* 2 | JavaScript lacks built-in support for heaps. 3 | Try using a language that doesn't hate you, like Python. 4 | */ 5 | -------------------------------------------------------------------------------- /src/code/javascript/linked_list/fast_and_slow_pointer.js: -------------------------------------------------------------------------------- 1 | const fn = (head) => { 2 | let ans = 0 3 | let slow = head 4 | let fast = head 5 | 6 | while (fast && fast.next) { 7 | // TODO: logic 8 | slow = slow.next 9 | fast = fast.next.next 10 | } 11 | 12 | return ans 13 | } 14 | -------------------------------------------------------------------------------- /src/code/javascript/linked_list/reverse_linked_list.js: -------------------------------------------------------------------------------- 1 | const fn = (head) => { 2 | let prev = null 3 | let curr = head 4 | 5 | while (curr) { 6 | let next = curr.next 7 | curr.next = prev 8 | prev = curr 9 | curr = next 10 | } 11 | 12 | return prev 13 | } 14 | -------------------------------------------------------------------------------- /src/code/javascript/matrix/create_copy.js: -------------------------------------------------------------------------------- 1 | const fn = (matrix) => { 2 | const r = matrix.length; 3 | const c = matrix[0].length; 4 | 5 | const createMatrix = Array.from({ length: r }, () => Array(c).fill(0)) 6 | const copyMatrix = matrix.map(row => [...row]) 7 | } 8 | -------------------------------------------------------------------------------- /src/code/javascript/matrix/diagonals.js: -------------------------------------------------------------------------------- 1 | const fn = (matrix) => { 2 | const r = matrix.length 3 | const c = matrix[0].length 4 | 5 | const mainDiagonal = Array.from({ length: Math.min(r, c) }, (_, i) => matrix[i][i]) 6 | const antiDiagonal = Array.from({ length: Math.min(r, c) }, (_, i) => matrix[i][~i]) 7 | } 8 | -------------------------------------------------------------------------------- /src/code/javascript/matrix/rotate_transpose.js: -------------------------------------------------------------------------------- 1 | const fn = (matrix) => { 2 | const r = matrix.length 3 | const c = matrix[0].length 4 | 5 | const transposeTuple = matrix[0].map((_, i) => matrix.map(row => row[i])) 6 | const transpose = transposeTuple.map(row => [...row]) 7 | const rotateLeft = transpose.reverse() 8 | const rotateRight = transpose.map(row => row.reverse()) 9 | } 10 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/bogo_sort.js: -------------------------------------------------------------------------------- 1 | const bogoSort = (arr) => { 2 | const isSorted = (arr) => { 3 | for (let i = 0; i < arr.length - 1; i++) { 4 | if (arr[i] > arr[i + 1]) { 5 | return false 6 | } 7 | } 8 | 9 | return true 10 | } 11 | 12 | const shuffleArray = (arr) => { 13 | for (let i = arr.length - 1; i > 0; i--) { 14 | const j = Math.floor(Math.random() * (i + 1)) 15 | [arr[i], arr[j]] = [arr[j], arr[i]] 16 | } 17 | 18 | return arr 19 | } 20 | 21 | while (!isSorted(arr)) { 22 | arr = shuffleArray(arr) 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/bubble_sort.js: -------------------------------------------------------------------------------- 1 | const bubbleSort = (arr) => { 2 | const n = arr.length 3 | 4 | for (let i = 0; i < n; i++) { 5 | let swapped = false 6 | 7 | for (let j = 0; j < n - i - 1; j++) { 8 | if (arr[j] > arr[j + 1]) { 9 | [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]] 10 | swapped = true 11 | } 12 | } 13 | 14 | if (!swapped) { 15 | break 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/bucket_sort.js: -------------------------------------------------------------------------------- 1 | const bucketSort = (arr) => { 2 | const num_buckets = 10 3 | const min_num = Math.min(...arr) 4 | const max_num = Math.max(...arr) 5 | const bucket_size = (max_num - min_num) / num_buckets 6 | const buckets = Array.from({ length: num_buckets }, () => []) 7 | 8 | for (const num of arr) { 9 | const index = Math.min(Math.floor((num - min_num) / bucket_size), num_buckets - 1) 10 | buckets[index].push(num) 11 | } 12 | 13 | return buckets.flatMap(bucket => bucket.sort((a, b) => a - b)) 14 | } 15 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/counting_sort.js: -------------------------------------------------------------------------------- 1 | const countingSort = (arr) => { 2 | const max_num = Math.max(...arr) 3 | const min_num = Math.min(...arr) 4 | const count_range = max_num - min_num + 1 5 | const count = Array(count_range).fill(0) 6 | const output = Array(arr.length) 7 | 8 | for (const num of arr) { 9 | count[num - min_num]++ 10 | } 11 | 12 | for (let i = 1; i < count_range; i++) { 13 | count[i] += count[i - 1] 14 | } 15 | 16 | for (let i = arr.length - 1; i >= 0; i--) { 17 | output[count[arr[i] - min_num] - 1] = arr[i] 18 | count[arr[i] - min_num]-- 19 | } 20 | 21 | return output 22 | } 23 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/cube_sort.js: -------------------------------------------------------------------------------- 1 | const cubeSort = (arr, processors) => { 2 | const n = arr.length 3 | const subarrays = [] 4 | const subarraySize = Math.floor(n / processors) 5 | 6 | for (let i = 0; i < processors; i++) { 7 | const subarray = arr.slice(i * subarraySize, (i + 1) * subarraySize) 8 | subarray.sort((a, b) => a - b) 9 | subarrays.push(subarray) 10 | } 11 | 12 | for (let dimension = 0; dimension < Math.floor(Math.log2(processors)); dimension++) { 13 | for (let i = 0; i < processors; i++) { 14 | const partner = i ^ (1 << dimension) 15 | if (i < partner) { 16 | const merged = subarrays[i].concat(subarrays[partner]) 17 | merged.sort((a, b) => a - b) 18 | subarrays[i] = merged.slice(0, subarraySize) 19 | subarrays[partner] = merged.slice(subarraySize) 20 | } 21 | } 22 | } 23 | 24 | arr.splice(0, arr.length, ...subarrays.flat()) 25 | } 26 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/heap_sort.js: -------------------------------------------------------------------------------- 1 | const heapSort = (arr) => { 2 | const n = arr.length 3 | 4 | const heapify = (arr, n, i) => { 5 | let largest = i 6 | const left = 2 * i + 1 7 | const right = 2 * i + 2 8 | 9 | if (left < n && arr[left] > arr[largest]) { 10 | largest = left 11 | } 12 | if (right < n && arr[right] > arr[largest]) { 13 | largest = right 14 | } 15 | if (largest !== i) { 16 | [arr[i], arr[largest]] = [arr[largest], arr[i]] 17 | heapify(arr, n, largest) 18 | } 19 | } 20 | 21 | for (let i = Math.floor(n / 2) - 1; i >= 0; i--) { 22 | heapify(arr, n, i) 23 | } 24 | for (let i = n - 1; i > 0; i--) { 25 | [arr[i], arr[0]] = [arr[0], arr[i]] 26 | heapify(arr, i, 0) 27 | } 28 | 29 | return arr 30 | } 31 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/insertion_sort.js: -------------------------------------------------------------------------------- 1 | const insertionSort = (arr) => { 2 | const n = arr.length 3 | 4 | for (let i = 1; i < n; i++) { 5 | let key = arr[i] 6 | let j = i - 1 7 | 8 | while (j >= 0 && key < arr[j]) { 9 | arr[j + 1] = arr[j] 10 | j-- 11 | } 12 | 13 | arr[j + 1] = key 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/merge_sort.js: -------------------------------------------------------------------------------- 1 | const mergeSort = (arr) => { 2 | const n = arr.length 3 | 4 | if (n <= 1) { 5 | return arr 6 | } 7 | 8 | const mid = Math.floor(n / 2) 9 | const left = mergeSort(arr.slice(0, mid)) 10 | const right = mergeSort(arr.slice(mid)) 11 | 12 | return merge(left, right) 13 | } 14 | 15 | const merge = (left, right) => { 16 | const output = [] 17 | 18 | while (left.length && right.length) { 19 | const minNum = left[0] <= right[0] ? left.shift() : right.shift() 20 | output.push(minNum) 21 | } 22 | 23 | output.push(...left) 24 | output.push(...right) 25 | 26 | return output 27 | } 28 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/pancake_sort.js: -------------------------------------------------------------------------------- 1 | const pancakeSort = (arr) => { 2 | const n = arr.length 3 | 4 | for (let size = n; size > 1; size--) { 5 | const maxIdx = findMaxIndex(arr, size) 6 | 7 | if (maxIdx !== size - 1) { 8 | flip(arr, maxIdx) 9 | flip(arr, size - 1) 10 | } 11 | } 12 | } 13 | 14 | const flip = (arr, i) => { 15 | let left = 0 16 | 17 | while (left < i) { 18 | [arr[left], arr[i]] = [arr[i], arr[left]] 19 | left++ 20 | i-- 21 | } 22 | } 23 | 24 | const findMaxIndex = (arr, n) => { 25 | let maxIdx = 0 26 | 27 | for (let i = 0; i < n; i++) { 28 | if (arr[i] > arr[maxIdx]) { 29 | maxIdx = i 30 | } 31 | } 32 | 33 | return maxIdx 34 | } 35 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/quick_sort.js: -------------------------------------------------------------------------------- 1 | const quickSort = (arr) => { 2 | const n = arr.length 3 | 4 | if (n <= 1) { 5 | return arr 6 | } 7 | 8 | const pivot = arr[Math.floor(n / 2)] 9 | const left = arr.filter(x => x < pivot) 10 | const right = arr.filter(x => x > pivot) 11 | 12 | return [...quickSort(left), pivot, ...quickSort(right)] 13 | } 14 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/radix_sort.js: -------------------------------------------------------------------------------- 1 | const radixSort = (arr) => { 2 | const maxVal = Math.max(...arr) 3 | let exp = 1 4 | 5 | while (maxVal / exp > 0) { 6 | countingSort(arr, exp) 7 | exp *= 10 8 | } 9 | } 10 | 11 | const countingSort = (arr, exp) => { 12 | const n = arr.length 13 | const output = new Array(n).fill(0) 14 | const count = new Array(10).fill(0) 15 | 16 | for (let i = 0; i < n; i++) { 17 | const idx = Math.floor(arr[i] / exp) 18 | count[idx % 10] += 1 19 | } 20 | 21 | for (let i = 1; i < 10; i++) { 22 | count[i] += count[i - 1] 23 | } 24 | 25 | let i = n - 1 26 | 27 | while (i >= 0) { 28 | const idx = Math.floor(arr[i] / exp) 29 | output[count[idx % 10] - 1] = arr[i] 30 | count[idx % 10] -= 1 31 | i -= 1 32 | } 33 | 34 | for (let i = 0; i < n; i++) { 35 | arr[i] = output[i] 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/selection_sort.js: -------------------------------------------------------------------------------- 1 | const selectionSort = (arr) => { 2 | const n = arr.length 3 | 4 | for (let i = 0; i < n; i++) { 5 | let minIndex = i 6 | 7 | for (let j = i + 1; j < n; j++) { 8 | if (arr[j] < arr[minIndex]) { 9 | minIndex = j 10 | } 11 | } 12 | 13 | if (minIndex !== i) { 14 | [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]] 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/shell_sort.js: -------------------------------------------------------------------------------- 1 | const shellSort = (arr) => { 2 | const n = arr.length 3 | const gaps = [701, 301, 132, 57, 23, 10, 4, 1] 4 | 5 | for (const gap of gaps) { 6 | for (let i = gap; i < n; i++) { 7 | const tmp = arr[i] 8 | let j = i 9 | 10 | while (j >= gap && arr[j - gap] > tmp) { 11 | arr[j] = arr[j - gap] 12 | j -= gap 13 | } 14 | 15 | if (j !== i) { 16 | arr[j] = tmp 17 | } 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/code/javascript/sorting_algorithms/sleep_sort.js: -------------------------------------------------------------------------------- 1 | const sleepSort = (arr) => { 2 | const sortedArr = [] 3 | const promises = [] 4 | 5 | for (const num of arr) { 6 | promises.push(new Promise((resolve) => setTimeout(() => { 7 | sortedArr.push(num) 8 | resolve() 9 | }, num))) 10 | } 11 | 12 | return Promise.all(promises).then(() => sortedArr) 13 | } 14 | -------------------------------------------------------------------------------- /src/code/javascript/stack/monotonic_decreasing.js: -------------------------------------------------------------------------------- 1 | const fn = (arr) => { 2 | let stack = [] 3 | let ans = 0 4 | 5 | for (const num of arr) { 6 | while (stack.length && stack[stack.length - 1] < num) { 7 | // TODO: logic 8 | stack.pop() 9 | } 10 | 11 | stack.push(num) 12 | } 13 | 14 | return ans 15 | } 16 | -------------------------------------------------------------------------------- /src/code/javascript/stack/monotonic_increasing.js: -------------------------------------------------------------------------------- 1 | const fn = (arr) => { 2 | let stack = [] 3 | let ans = 0 4 | 5 | for (const num of arr) { 6 | while (stack.length && stack[stack.length - 1] > num) { 7 | // TODO: logic 8 | stack.pop() 9 | } 10 | 11 | stack.push(num) 12 | } 13 | 14 | return ans 15 | } 16 | -------------------------------------------------------------------------------- /src/code/python/array/prefix_sum.py: -------------------------------------------------------------------------------- 1 | def fn(arr): 2 | n = len(arr) 3 | prefix = [arr[0]] 4 | 5 | for i in range(1, n): 6 | prefix.append(prefix[-1] + arr[i]) 7 | 8 | return prefix 9 | -------------------------------------------------------------------------------- /src/code/python/array/sliding_window.py: -------------------------------------------------------------------------------- 1 | def fn(arr): 2 | n = len(arr) 3 | window = 0 4 | left = 0 5 | ans = 0 6 | 7 | for right in range(n): 8 | # TODO: add arr[right] to window 9 | 10 | while WINDOW_CONDITION_BROKEN: 11 | # TODO: remove arr[left] from window 12 | left += 1 13 | 14 | # TODO: update ans 15 | 16 | return ans 17 | -------------------------------------------------------------------------------- /src/code/python/array/string_building.py: -------------------------------------------------------------------------------- 1 | def fn(strs: list[str]): 2 | ans = [] 3 | 4 | for char in strs: 5 | ans.append(char) 6 | 7 | return ''.join(ans) 8 | -------------------------------------------------------------------------------- /src/code/python/array/two_pointers_one_input.py: -------------------------------------------------------------------------------- 1 | def fn(arr): 2 | ans = 0 3 | left = 0 4 | right = len(arr) - 1 5 | 6 | while left < right: 7 | # TODO: logic with left and right 8 | if CONDITION: 9 | left += 1 10 | else: 11 | right -= 1 12 | 13 | return ans 14 | -------------------------------------------------------------------------------- /src/code/python/array/two_pointers_two_inputs.py: -------------------------------------------------------------------------------- 1 | def fn(arr1, arr2): 2 | i = 0 3 | j = 0 4 | ans = 0 5 | 6 | while i < len(arr1) and j < len(arr2): 7 | # TODO: logic 8 | if CONDITION: 9 | i += 1 10 | else: 11 | j += 1 12 | 13 | while i < len(arr1): 14 | # TODO: logic 15 | i += 1 16 | 17 | while j < len(arr2): 18 | # TODO: logic 19 | j += 1 20 | 21 | return ans 22 | -------------------------------------------------------------------------------- /src/code/python/backtracking/backtracking.py: -------------------------------------------------------------------------------- 1 | def backtrack(curr, OTHER_ARGUMENTS...): 2 | if (BASE_CASE): 3 | # TODO: modify answer 4 | return 5 | 6 | ans = 0 7 | 8 | for (ITERATE_OVER_INPUT): 9 | # TODO: modify current state 10 | ans += backtrack(curr, OTHER_ARGUMENTS...) 11 | # TODO: undo modification of current state 12 | 13 | return ans 14 | -------------------------------------------------------------------------------- /src/code/python/binary_search/binary_search.py: -------------------------------------------------------------------------------- 1 | def fn(arr, target): 2 | left = 0 3 | right = len(arr) - 1 4 | 5 | while left <= right: 6 | mid = (left + right) // 2 7 | 8 | if arr[mid] == target: 9 | # TODO: logic 10 | return 11 | if arr[mid] > target: 12 | right = mid - 1 13 | else: 14 | left = mid + 1 15 | 16 | return left 17 | -------------------------------------------------------------------------------- /src/code/python/binary_search/duplicate_elements_left_insertion.py: -------------------------------------------------------------------------------- 1 | def fn(arr, target): 2 | left = 0 3 | right = len(arr) 4 | 5 | while left < right: 6 | mid = (left + right) // 2 7 | 8 | if arr[mid] >= target: 9 | right = mid 10 | else: 11 | left = mid + 1 12 | 13 | return left 14 | -------------------------------------------------------------------------------- /src/code/python/binary_search/duplicate_elements_right_insertion.py: -------------------------------------------------------------------------------- 1 | def fn(arr, target): 2 | left = 0 3 | right = len(arr) 4 | 5 | while left < right: 6 | mid = (left + right) // 2 7 | 8 | if arr[mid] > target: 9 | right = mid 10 | else: 11 | left = mid + 1 12 | 13 | return left 14 | -------------------------------------------------------------------------------- /src/code/python/binary_search/greedy_maximum.py: -------------------------------------------------------------------------------- 1 | def fn(arr): 2 | def check(x): 3 | return BOOLEAN 4 | 5 | left = MINIMUM_POSSIBLE_ANSWER 6 | right = MAXIMUM_POSSIBLE_ANSWER 7 | 8 | while left <= right: 9 | mid = (left + right) // 2 10 | 11 | if check(mid): 12 | left = mid + 1 13 | else: 14 | right = mid - 1 15 | 16 | return right 17 | -------------------------------------------------------------------------------- /src/code/python/binary_search/greedy_minimum.py: -------------------------------------------------------------------------------- 1 | def fn(arr): 2 | def check(x): 3 | return BOOLEAN 4 | 5 | left = MINIMUM_POSSIBLE_ANSWER 6 | right = MAXIMUM_POSSIBLE_ANSWER 7 | 8 | while left <= right: 9 | mid = (left + right) // 2 10 | 11 | if check(mid): 12 | right = mid - 1 13 | else: 14 | left = mid + 1 15 | 16 | return left 17 | -------------------------------------------------------------------------------- /src/code/python/binary_tree/bfs.py: -------------------------------------------------------------------------------- 1 | from collections import deque 2 | 3 | 4 | def fn(root): 5 | que = deque([root]) 6 | ans = 0 7 | 8 | while que: 9 | current_length = len(que) 10 | # TODO: logic for current level 11 | for _ in range(current_length): 12 | node = que.popleft() 13 | # TODO: logic 14 | if node.left: 15 | que.append(node.left) 16 | if node.right: 17 | que.append(node.right) 18 | 19 | return ans 20 | -------------------------------------------------------------------------------- /src/code/python/binary_tree/dfs_iterative.py: -------------------------------------------------------------------------------- 1 | def dfs(root): 2 | stack = [root] 3 | ans = 0 4 | 5 | while stack: 6 | node = stack.pop() 7 | # TODO: logic 8 | if node.left: 9 | stack.append(node.left) 10 | if node.right: 11 | stack.append(node.right) 12 | 13 | return ans 14 | -------------------------------------------------------------------------------- /src/code/python/binary_tree/dfs_recursive.py: -------------------------------------------------------------------------------- 1 | def dfs(root): 2 | if not root: 3 | return 4 | 5 | ans = 0 6 | 7 | # TODO: logic 8 | dfs(root.left) 9 | dfs(root.right) 10 | 11 | return ans 12 | -------------------------------------------------------------------------------- /src/code/python/bit_manipulation/check_power_of_two.py: -------------------------------------------------------------------------------- 1 | def is_power_of_two(num: int) -> bool: 2 | return (num & (num - 1)) == 0 3 | -------------------------------------------------------------------------------- /src/code/python/bit_manipulation/clear_kth_bit.py: -------------------------------------------------------------------------------- 1 | def clear_kth_bit(num: int, k: int) -> int: 2 | return num & ~(1 << k) 3 | -------------------------------------------------------------------------------- /src/code/python/bit_manipulation/count_set_bits.py: -------------------------------------------------------------------------------- 1 | def count_set_bits(num: int) -> int: 2 | return bin(num).count('1') 3 | -------------------------------------------------------------------------------- /src/code/python/bit_manipulation/divide_power_of_two.py: -------------------------------------------------------------------------------- 1 | def divide_by_power_of_two(num: int, k: int) -> int: 2 | return num >> k 3 | -------------------------------------------------------------------------------- /src/code/python/bit_manipulation/get_rightmost_bit.py: -------------------------------------------------------------------------------- 1 | def get_rightmost_set_bit(num: int) -> int: 2 | return num & -num 3 | -------------------------------------------------------------------------------- /src/code/python/bit_manipulation/multiply_power_of_two.py: -------------------------------------------------------------------------------- 1 | def multiply_by_power_of_two(num: int, k: int) -> int: 2 | return num << k 3 | -------------------------------------------------------------------------------- /src/code/python/bit_manipulation/set_kth_bit.py: -------------------------------------------------------------------------------- 1 | def set_kth_bit(num: int, k: int) -> int: 2 | return num | (1 << k) 3 | -------------------------------------------------------------------------------- /src/code/python/bit_manipulation/swap_variables.py: -------------------------------------------------------------------------------- 1 | def swap_variables(num1: int, num2: int) -> tuple: 2 | num1 ^= num2 3 | num2 ^= num1 4 | num1 ^= num2 5 | return num1, num2 6 | -------------------------------------------------------------------------------- /src/code/python/bit_manipulation/test_kth_bit.py: -------------------------------------------------------------------------------- 1 | def test_kth_bit(num: int, k: int) -> bool: 2 | return num & (1 << k) != 0 3 | -------------------------------------------------------------------------------- /src/code/python/bit_manipulation/toggle_kth_bit.py: -------------------------------------------------------------------------------- 1 | def toggle_kth_bit(num: int, k: int) -> int: 2 | return num ^ (1 << k) 3 | -------------------------------------------------------------------------------- /src/code/python/data_structures/array.py: -------------------------------------------------------------------------------- 1 | from typing import Any 2 | 3 | 4 | class Array: 5 | def __init__(self, size: int) -> None: 6 | self.size = size 7 | self.data = [None] * size 8 | 9 | def __getitem__(self, index: int) -> Any: 10 | return self.data[index] 11 | 12 | def __setitem__(self, index: int, value: Any) -> None: 13 | self.data[index] = value 14 | 15 | def __len__(self) -> int: 16 | return len(self.data) 17 | 18 | def __repr__(self) -> str: 19 | return repr(self.data) 20 | -------------------------------------------------------------------------------- /src/code/python/data_structures/binary_search_tree.py: -------------------------------------------------------------------------------- 1 | from typing import Any 2 | 3 | 4 | class TreeNode: 5 | def __init__(self, data: Any) -> None: 6 | self.data = data 7 | self.left = None 8 | self.right = None 9 | 10 | 11 | class BinarySearchTree: 12 | def __init__(self) -> None: 13 | self.root = None 14 | 15 | def insert(self, data: Any) -> None: 16 | if not self.root: 17 | self.root = TreeNode(data) 18 | else: 19 | self.insert_node(self.root, data) 20 | 21 | def insert_node(self, node: TreeNode | None, data: Any) -> None: 22 | if data < node.data: 23 | if not node.left: 24 | node.left = TreeNode(data) 25 | else: 26 | self.insert_node(node.left, data) 27 | else: 28 | if not node.right: 29 | node.right = TreeNode(data) 30 | else: 31 | self.insert_node(node.right, data) 32 | 33 | def __repr__(self) -> str: 34 | return 'Empty tree' if not self.root else self._print_tree(self.root, '', True) 35 | 36 | def _print_tree(self, node: TreeNode | None, prefix: str, is_left: bool) -> str: 37 | if node is None: 38 | return '' 39 | 40 | result = '' 41 | result += self._print_tree(node.right, prefix + ('│ ' if is_left else ' '), False) 42 | result += prefix + ('└── ' if is_left else '┌── ') + str(node.data) + '\n' 43 | result += self._print_tree(node.left, prefix + (' ' if is_left else '│ '), True) 44 | 45 | return result 46 | -------------------------------------------------------------------------------- /src/code/python/data_structures/binary_tree.py: -------------------------------------------------------------------------------- 1 | from typing import Any 2 | 3 | 4 | class TreeNode: 5 | def __init__(self, data: Any) -> None: 6 | self.data = data 7 | self.left = None 8 | self.right = None 9 | 10 | 11 | class BinaryTree: 12 | def __init__(self) -> None: 13 | self.root = None 14 | 15 | def insert(self, data: Any) -> None: 16 | if not self.root: 17 | self.root = TreeNode(data) 18 | else: 19 | self.insert_node(self.root, data) 20 | 21 | def insert_node(self, node: TreeNode | None, data: Any) -> TreeNode: 22 | if not node: 23 | return TreeNode(data) 24 | 25 | if not node.left: 26 | node.left = TreeNode(data) 27 | elif not node.right: 28 | node.right = TreeNode(data) 29 | else: 30 | node.left = self.insert_node(node.left, data) 31 | 32 | return node 33 | 34 | def __repr__(self) -> str: 35 | return 'Empty tree' if not self.root else self._print_tree(self.root, '', True) 36 | 37 | def _print_tree(self, node: TreeNode | None, prefix: str, is_left: bool) -> str: 38 | if node is None: 39 | return '' 40 | 41 | result = '' 42 | result += self._print_tree(node.right, prefix + ('│ ' if is_left else ' '), False) 43 | result += prefix + ('└── ' if is_left else '┌── ') + str(node.data) + '\n' 44 | result += self._print_tree(node.left, prefix + (' ' if is_left else '│ '), True) 45 | 46 | return result 47 | -------------------------------------------------------------------------------- /src/code/python/data_structures/graph.py: -------------------------------------------------------------------------------- 1 | class Graph: 2 | def __init__(self) -> None: 3 | self.graph = {} 4 | 5 | def add_vertex(self, vertex: str) -> None: 6 | if vertex not in self.graph: 7 | self.graph[vertex] = [] 8 | 9 | def add_edge(self, a: str, b: str) -> None: 10 | self.add_vertex(a) 11 | self.add_vertex(b) 12 | self.graph[a].append(b) 13 | self.graph[b].append(a) 14 | 15 | def get_neighbors(self, vertex: str) -> list[str]: 16 | return self.graph.get(vertex, []) 17 | 18 | def __repr__(self) -> str: 19 | output = '' 20 | 21 | for vertex, neighbors in self.graph.items(): 22 | output += f'{vertex} - {' - '.join(neighbors)}\n' 23 | 24 | return output 25 | -------------------------------------------------------------------------------- /src/code/python/data_structures/hash_map.py: -------------------------------------------------------------------------------- 1 | from typing import Any 2 | 3 | 4 | class HashMap: 5 | def __init__(self) -> None: 6 | self.size = 100000 7 | self.bucket = [None] * self.size 8 | 9 | def _hash(self, key: int) -> int: 10 | return hash(key) % self.size 11 | 12 | def __setitem__(self, key: int, value: Any) -> None: 13 | self.bucket[self._hash(key)] = value 14 | 15 | def __getitem__(self, key: int) -> Any: 16 | return self.bucket[self._hash(key)] 17 | 18 | def __delitem__(self, key: int) -> None: 19 | self.bucket[self._hash(key)] = None 20 | -------------------------------------------------------------------------------- /src/code/python/data_structures/union_find.py: -------------------------------------------------------------------------------- 1 | class UnionFind: 2 | def __init__(self, n: int) -> None: 3 | self.root = list(range(n)) 4 | 5 | def find(self, a: int) -> int: 6 | return a if a == self.root[a] else self.find(self.root[a]) 7 | 8 | def union(self, a: int, b: int) -> None: 9 | self.root[self.find(a)] = self.find(b) 10 | 11 | def connected(self, a: int, b: int) -> bool: 12 | return self.find(a) == self.find(b) 13 | 14 | def __repr__(self) -> str: 15 | n = len(self.root) 16 | lines = [] 17 | components = {} 18 | 19 | for i in range(n): 20 | root = self.find(i) 21 | 22 | if root not in components: 23 | components[root] = [] 24 | 25 | components[root].append(i) 26 | 27 | for component in components.values(): 28 | lines.append(' - '.join(f'({node})' for node in component)) 29 | 30 | return '\n'.join(lines) 31 | -------------------------------------------------------------------------------- /src/code/python/data_structures/union_find_optimized.py: -------------------------------------------------------------------------------- 1 | class UnionFind: 2 | def __init__(self, n: int) -> None: 3 | self.root = list(range(n)) 4 | self.rank = [1] * n 5 | 6 | def find(self, a: int) -> int: 7 | return a if a == self.root[a] else self.find(self.root[a]) 8 | 9 | def union(self, a: int, b: int) -> None: 10 | root_a = self.find(a) 11 | root_b = self.find(b) 12 | 13 | if root_a != root_b: 14 | if self.rank[root_a] < self.rank[root_b]: 15 | self.root[root_a] = root_b 16 | elif self.rank[root_a] > self.rank[root_b]: 17 | self.root[root_b] = root_a 18 | else: 19 | self.root[root_b] = root_a 20 | self.rank[root_a] += 1 21 | 22 | def connected(self, a: int, b: int) -> bool: 23 | return self.find(a) == self.find(b) 24 | 25 | def __repr__(self) -> str: 26 | n = len(self.root) 27 | lines = [] 28 | components = {} 29 | 30 | for i in range(n): 31 | root = self.find(i) 32 | 33 | if root not in components: 34 | components[root] = [] 35 | 36 | components[root].append(i) 37 | 38 | for component in components.values(): 39 | lines.append(' - '.join(f'({node})' for node in component)) 40 | 41 | return '\n'.join(lines) 42 | -------------------------------------------------------------------------------- /src/code/python/dynamic_programming/bottom_up.py: -------------------------------------------------------------------------------- 1 | def fn(arr): 2 | if BASE_CASE: 3 | return 0 4 | 5 | dp = [BASE_CASE] * (STATE_FOR_WHOLE_INPUT + 1) 6 | 7 | for STATE in range(SMALLEST_SUBPROBLEM, STATE_FOR_WHOLE_INPUT + 1): 8 | if BASE_CASE: 9 | dp[STATE] = BASE_CASE 10 | else: 11 | dp[STATE] = RECURRENCE_RELATION(STATE) 12 | 13 | return dp[STATE_FOR_WHOLE_INPUT] 14 | -------------------------------------------------------------------------------- /src/code/python/dynamic_programming/kadane.py: -------------------------------------------------------------------------------- 1 | def kadane(arr: list[int]) -> int: 2 | curr_sub = max_sub = arr[0] 3 | 4 | for num in arr[1:]: 5 | curr_sub = max(curr_sub + num, num) 6 | max_sub = max(max_sub, curr_sub) 7 | 8 | return max_sub 9 | -------------------------------------------------------------------------------- /src/code/python/dynamic_programming/top_down.py: -------------------------------------------------------------------------------- 1 | def fn(arr): 2 | @cache 3 | def dp(STATE): 4 | if BASE_CASE: 5 | return 0 6 | return RECURRENCE_RELATION(STATE) 7 | 8 | return dp(STATE_FOR_WHOLE_INPUT) 9 | -------------------------------------------------------------------------------- /src/code/python/graph/bellman_ford.py: -------------------------------------------------------------------------------- 1 | def bellman_ford(n: int, edges: list[tuple[int, int, int]], source: int) -> list[int]: 2 | distances = [float('inf')] * n 3 | distances[source] = 0 4 | 5 | for _ in range(n - 1): 6 | for u, v, w in edges: 7 | if distances[u] != float('inf') and distances[u] + w < distances[v]: 8 | distances[v] = distances[u] + w 9 | 10 | for u, v, w in edges: 11 | if distances[u] != float('inf') and distances[u] + w < distances[v]: 12 | return [] 13 | 14 | return distances 15 | -------------------------------------------------------------------------------- /src/code/python/graph/bfs.py: -------------------------------------------------------------------------------- 1 | from collections import deque 2 | 3 | 4 | def fn(graph): 5 | que = deque([START_NODE]) 6 | seen = {START_NODE} 7 | ans = 0 8 | 9 | while que: 10 | node = que.popleft() 11 | # TODO: logic 12 | for neighbor in graph[node]: 13 | if neighbor not in seen: 14 | seen.add(neighbor) 15 | que.append(neighbor) 16 | 17 | return ans 18 | -------------------------------------------------------------------------------- /src/code/python/graph/dfs_iterative.py: -------------------------------------------------------------------------------- 1 | def fn(graph): 2 | stack = [START_NODE] 3 | seen = {START_NODE} 4 | ans = 0 5 | 6 | while stack: 7 | node = stack.pop() 8 | # TODO: logic 9 | for neighbor in graph[node]: 10 | if neighbor not in seen: 11 | seen.add(neighbor) 12 | stack.append(neighbor) 13 | 14 | return ans 15 | -------------------------------------------------------------------------------- /src/code/python/graph/dfs_recursive.py: -------------------------------------------------------------------------------- 1 | def fn(graph): 2 | def dfs(node): 3 | ans = 0 4 | # TODO: logic 5 | for neighbor in graph[node]: 6 | if neighbor not in seen: 7 | seen.add(neighbor) 8 | ans += dfs(neighbor) 9 | 10 | return ans 11 | 12 | seen = {START_NODE} 13 | 14 | return dfs(START_NODE) 15 | -------------------------------------------------------------------------------- /src/code/python/graph/dijkstra.py: -------------------------------------------------------------------------------- 1 | from heapq import heappop, heappush 2 | 3 | 4 | def dijkstras(graph: list[list[tuple[int, int]]], source: int) -> list[int]: 5 | n = len(graph) 6 | distances = [float('inf')] * n 7 | distances[source] = 0 8 | heap = [(0, source)] 9 | 10 | while heap: 11 | curr_dist, node = heappop(heap) 12 | 13 | if curr_dist > distances[node]: 14 | continue 15 | 16 | for neighbor, weight in graph[node]: 17 | dist = curr_dist + weight 18 | 19 | if dist < distances[neighbor]: 20 | distances[neighbor] = dist 21 | heappush(heap, (dist, neighbor)) 22 | 23 | return distances 24 | -------------------------------------------------------------------------------- /src/code/python/graph/kahn.py: -------------------------------------------------------------------------------- 1 | from collections import defaultdict, deque 2 | 3 | 4 | def kahn_topological_sort(graph: dict[int, list[int]]) -> list[int]: 5 | result = [] 6 | indegree = defaultdict(int) 7 | 8 | for vertices in graph.values(): 9 | for v in vertices: 10 | indegree[v] += 1 11 | 12 | que = deque([node for node in graph if not indegree[node]]) 13 | 14 | while que: 15 | node = que.popleft() 16 | result.append(node) 17 | 18 | for neighbor in graph[node]: 19 | indegree[neighbor] -= 1 20 | 21 | if not indegree[neighbor]: 22 | que.append(neighbor) 23 | 24 | return result if len(result) == len(graph) else [] 25 | -------------------------------------------------------------------------------- /src/code/python/graph/kruskal.py: -------------------------------------------------------------------------------- 1 | def kruskal_mst(n: int, edges: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]: 2 | mst = [] 3 | uf = UnionFind(n) 4 | edges.sort() 5 | 6 | for w, u, v in edges: 7 | if not uf.connected(u, v): 8 | uf.union(u, v) 9 | mst.append((w, u, v)) 10 | 11 | return mst 12 | -------------------------------------------------------------------------------- /src/code/python/graph/prim.py: -------------------------------------------------------------------------------- 1 | from heapq import heappop 2 | 3 | 4 | def prim_mst(n: int, edges: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]: 5 | mst = [] 6 | uf = UnionFind(n) 7 | edges.sort() 8 | 9 | while edges: 10 | w, u, v = heappop(edges) 11 | 12 | if not uf.connected(u, v): 13 | uf.union(u, v) 14 | mst.append((w, u, v)) 15 | 16 | return mst 17 | -------------------------------------------------------------------------------- /src/code/python/hash_map/find_number_of_subarrays.py: -------------------------------------------------------------------------------- 1 | from collections import defaultdict 2 | 3 | 4 | def fn(arr, k): 5 | counts = defaultdict(int) 6 | counts[0] = 1 7 | ans = curr = 0 8 | 9 | for num in arr: 10 | # TODO: logic to change curr 11 | ans += counts[curr - k] 12 | counts[curr] += 1 13 | 14 | return ans 15 | -------------------------------------------------------------------------------- /src/code/python/hash_map/sliding_window.py: -------------------------------------------------------------------------------- 1 | def fn(arr): 2 | window = set() 3 | ans = 0 4 | left = 0 5 | 6 | for right, ELEMENT in enumerate(arr): 7 | # TODO: add arr[right] to window 8 | 9 | while WINDOW_CONDITION_BROKEN: 10 | # TODO: remove arr[left] from window 11 | left += 1 12 | 13 | # TODO: update ans 14 | 15 | return ans 16 | -------------------------------------------------------------------------------- /src/code/python/heap/find_top_k_elements.py: -------------------------------------------------------------------------------- 1 | from heapq import heappop, heappush 2 | 3 | 4 | def fn(arr, k): 5 | heap = [] 6 | 7 | for num in arr: 8 | # TODO: logic to push onto heap according to problem's criteria 9 | heappush(heap, (CRITERIA, num)) 10 | 11 | if len(heap) > k: 12 | heappop(heap) 13 | 14 | return [num for num in heap] 15 | -------------------------------------------------------------------------------- /src/code/python/linked_list/fast_and_slow_pointer.py: -------------------------------------------------------------------------------- 1 | def fn(head): 2 | slow = head 3 | fast = head 4 | ans = 0 5 | 6 | while fast and fast.next: 7 | # TODO: logic 8 | slow = slow.next 9 | fast = fast.next.next 10 | 11 | return ans 12 | -------------------------------------------------------------------------------- /src/code/python/linked_list/reverse_linked_list.py: -------------------------------------------------------------------------------- 1 | def fn(head): 2 | prev = None 3 | curr = head 4 | 5 | while curr: 6 | nxt = curr.next 7 | curr.next = prev 8 | prev = curr 9 | curr = nxt 10 | 11 | return prev 12 | -------------------------------------------------------------------------------- /src/code/python/matrix/create_copy.py: -------------------------------------------------------------------------------- 1 | def fn(matrix: list[list[int]]): 2 | r = len(matrix) 3 | c = len(matrix[0]) 4 | 5 | create_matrix = [[0 for _ in range(c)] for _ in range(r)] 6 | copy_matrix = [row[:] for row in matrix] 7 | -------------------------------------------------------------------------------- /src/code/python/matrix/diagonals.py: -------------------------------------------------------------------------------- 1 | def fn(matrix: list[list[int]]): 2 | r = len(matrix) 3 | c = len(matrix[0]) 4 | 5 | main_diagonal = [matrix[i][i] for i in range(min(r, c))] 6 | anti_diagonal = [matrix[i][~i] for i in range(min(r, c))] 7 | -------------------------------------------------------------------------------- /src/code/python/matrix/rotate_transpose.py: -------------------------------------------------------------------------------- 1 | def fn(matrix: list[list[int]]): 2 | r = len(matrix) 3 | c = len(matrix[0]) 4 | 5 | transpose_tuple = zip(*matrix) 6 | transpose = [list(row) for row in transpose_tuple] 7 | rotate_left = transpose[::-1] 8 | rotate_right = [row[::-1] for row in transpose] 9 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/bogo_sort.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | 4 | def bogo_sort(arr: list) -> None: 5 | target = sorted(arr) 6 | 7 | while arr != target: 8 | random.shuffle(arr) 9 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/bubble_sort.py: -------------------------------------------------------------------------------- 1 | def bubble_sort(arr: list) -> None: 2 | n = len(arr) 3 | 4 | for i in range(n): 5 | swapped = False 6 | 7 | for j in range(0, n - i - 1): 8 | if arr[j] > arr[j + 1]: 9 | arr[j], arr[j + 1] = arr[j + 1], arr[j] 10 | swapped = True 11 | 12 | if not swapped: 13 | break 14 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/bucket_sort.py: -------------------------------------------------------------------------------- 1 | def bucket_sort(arr: list) -> list: 2 | num_buckets = 10 3 | min_num = min(arr) 4 | max_num = max(arr) 5 | bucket_size = (max_num - min_num) / num_buckets 6 | buckets = [[] for _ in range(num_buckets)] 7 | 8 | for num in arr: 9 | index = min(int((num - min_num) / bucket_size), num_buckets - 1) 10 | buckets[index].append(num) 11 | 12 | return [num for bucket in buckets for num in sorted(bucket)] 13 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/counting_sort.py: -------------------------------------------------------------------------------- 1 | def counting_sort(arr: list) -> list: 2 | max_num = max(arr) 3 | min_num = min(arr) 4 | count_range = max_num - min_num + 1 5 | count = [0] * count_range 6 | output = [0] * len(arr) 7 | 8 | for num in arr: 9 | count[num - min_num] += 1 10 | 11 | for i in range(1, count_range): 12 | count[i] += count[i - 1] 13 | 14 | for num in arr[::-1]: 15 | output[count[num - min_num] - 1] = num 16 | count[num - min_num] -= 1 17 | 18 | return output 19 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/cube_sort.py: -------------------------------------------------------------------------------- 1 | def cube_sort(arr: list, processors: int) -> None: 2 | n = len(arr) 3 | subarrays = [] 4 | subarray_size = n // processors 5 | 6 | for i in range(processors): 7 | subarray = arr[i * subarray_size : (i + 1) * subarray_size] 8 | subarrays.append(subarray) 9 | 10 | for subarray in subarrays: 11 | subarray.sort() 12 | 13 | for dimension in range(processors.bit_length() - 1): 14 | for i in range(processors): 15 | partner = i ^ (1 << dimension) 16 | if i < partner: 17 | merged = subarrays[i] + subarrays[partner] 18 | else: 19 | merged = subarrays[partner] + subarrays[i] 20 | merged.sort() 21 | subarrays[i] = merged[:subarray_size] 22 | subarrays[partner] = merged[subarray_size:] 23 | 24 | arr[:] = [num for subarray in subarrays for num in subarray] 25 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/heap_sort.py: -------------------------------------------------------------------------------- 1 | def heap_sort(arr: list) -> list: 2 | n = len(arr) 3 | 4 | for i in range(n // 2 - 1, -1, -1): 5 | heapify(arr, n, i) 6 | for i in range(n - 1, 0, -1): 7 | arr[i], arr[0] = arr[0], arr[i] 8 | heapify(arr, i, 0) 9 | 10 | return arr 11 | 12 | def heapify(arr: list, n: int, i: int) -> None: 13 | largest = i 14 | left = 2 * i + 1 15 | right = 2 * i + 2 16 | 17 | if left < n and arr[left] > arr[largest]: 18 | largest = left 19 | if right < n and arr[right] > arr[largest]: 20 | largest = right 21 | if largest != i: 22 | arr[i], arr[largest] = arr[largest], arr[i] 23 | heapify(arr, n, largest) 24 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/insertion_sort.py: -------------------------------------------------------------------------------- 1 | def insertion_sort(arr: list) -> None: 2 | n = len(arr) 3 | 4 | for i in range(1, n): 5 | key = arr[i] 6 | 7 | while i > 0 and key < arr[i - 1]: 8 | arr[i] = arr[i - 1] 9 | i -= 1 10 | 11 | arr[i] = key 12 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/merge_sort.py: -------------------------------------------------------------------------------- 1 | def merge_sort(arr: list) -> list: 2 | n = len(arr) 3 | 4 | if n <= 1: 5 | return arr 6 | 7 | mid = n // 2 8 | left = merge_sort(arr[:mid]) 9 | right = merge_sort(arr[mid:]) 10 | 11 | return merge(left, right) 12 | 13 | def merge(left: list, right: list) -> list: 14 | output = [] 15 | 16 | while left and right: 17 | min_num = left.pop(0) if left[0] <= right[0] else right.pop(0) 18 | output.append(min_num) 19 | 20 | output.extend(left) 21 | output.extend(right) 22 | 23 | return output 24 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/pancake_sort.py: -------------------------------------------------------------------------------- 1 | def pancake_sort(arr: list) -> None: 2 | n = len(arr) 3 | 4 | for size in reversed(range(2, n + 1)): 5 | max_idx = find_max_index(arr, size) 6 | 7 | if max_idx != size - 1: 8 | flip(arr, max_idx) 9 | flip(arr, size - 1) 10 | 11 | def flip(arr: list, i: int) -> None: 12 | left = 0 13 | 14 | while left < i: 15 | arr[left], arr[i] = arr[i], arr[left] 16 | left += 1 17 | i -= 1 18 | 19 | def find_max_index(arr: list, n: int) -> int: 20 | max_idx = 0 21 | 22 | for i in range(n): 23 | if arr[i] > arr[max_idx]: 24 | max_idx = i 25 | 26 | return max_idx 27 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/quick_sort.py: -------------------------------------------------------------------------------- 1 | def quick_sort(arr: list) -> list: 2 | n = len(arr) 3 | 4 | if n <= 1: 5 | return arr 6 | 7 | pivot = arr[n // 2] 8 | left = [x for x in arr if x < pivot] 9 | right = [x for x in arr if x > pivot] 10 | 11 | return quick_sort(left) + [pivot] + quick_sort(right) 12 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/radix_sort.py: -------------------------------------------------------------------------------- 1 | def radix_sort(arr: list) -> None: 2 | max_val = max(arr) 3 | exp = 1 4 | 5 | while max_val // exp > 0: 6 | counting_sort(arr, exp) 7 | exp *= 10 8 | 9 | def counting_sort(arr: list, exp: int) -> None: 10 | n = len(arr) 11 | output = [0] * n 12 | count = [0] * 10 13 | 14 | for i in range(n): 15 | idx = arr[i] // exp 16 | count[idx % 10] += 1 17 | 18 | for i in range(1, 10): 19 | count[i] += count[i - 1] 20 | 21 | i = n - 1 22 | 23 | while i >= 0: 24 | idx = arr[i] // exp 25 | output[count[idx % 10] - 1] = arr[i] 26 | count[idx % 10] -= 1 27 | i -= 1 28 | 29 | for i in range(n): 30 | arr[i] = output[i] 31 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/selection_sort.py: -------------------------------------------------------------------------------- 1 | def selection_sort(arr: list) -> None: 2 | n = len(arr) 3 | 4 | for i in range(n): 5 | min_i = i 6 | 7 | for j in range(i + 1, n): 8 | if arr[j] < arr[min_i]: 9 | min_i = j 10 | 11 | if min_i != i: 12 | arr[i], arr[min_i] = arr[min_i], arr[i] 13 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/shell_sort.py: -------------------------------------------------------------------------------- 1 | def shell_sort(arr: list) -> None: 2 | n = len(arr) 3 | gaps = [701, 301, 132, 57, 23, 10, 4, 1] 4 | 5 | for gap in gaps: 6 | for i in range(gap, n): 7 | tmp = arr[i] 8 | j = i 9 | 10 | while j >= gap and arr[j - gap] > tmp: 11 | arr[j] = arr[j - gap] 12 | j -= gap 13 | 14 | if j != i: 15 | arr[j] = tmp 16 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/sleep_sort.py: -------------------------------------------------------------------------------- 1 | from threading import Thread 2 | from time import sleep 3 | 4 | 5 | def sleep_sort(arr: list ) -> list: 6 | sorted_arr = [] 7 | threads = [] 8 | 9 | for num in arr: 10 | thread = Thread(target=snorlax, args=(num, sorted_arr)) 11 | threads.append(thread) 12 | 13 | for thread in threads: 14 | thread.start( ) 15 | 16 | for thread in threads: 17 | thread.join() 18 | 19 | return sorted_arr 20 | 21 | def snorlax(num: float, arr: list) -> None: 22 | sleep(num / 1000.0) 23 | arr.append(num) 24 | -------------------------------------------------------------------------------- /src/code/python/sorting_algorithms/tim_sort.py: -------------------------------------------------------------------------------- 1 | def tim_sort(arr: list) -> list: 2 | n = len(arr) 3 | min_run = 32 4 | 5 | for start in range(0, n, min_run): 6 | end = min(start + min_run - 1, n - 1) 7 | insertion_sort(arr, start, end) 8 | 9 | size = min_run 10 | 11 | while size < n: 12 | for left in range(0, n, 2 * size): 13 | mid = min(n - 1, left + size - 1) 14 | right = min((left + 2 * size - 1), (n - 1)) 15 | arr[left : right + 1] = merge(arr[left : mid + 1], arr[mid + 1 : right + 1]) 16 | size *= 2 17 | 18 | return arr 19 | 20 | def insertion_sort(arr: list, left: int, right: int) -> None: 21 | for i in range(left + 1, right + 1): 22 | key = arr[i] 23 | 24 | while i > 0 and key < arr[i - 1]: 25 | arr[i] = arr[i - 1] 26 | i -= 1 27 | 28 | arr[i] = key 29 | 30 | def merge_sort(arr: list) -> list: 31 | n = len(arr) 32 | 33 | if n <= 1: 34 | return arr 35 | 36 | mid = n // 2 37 | left = merge_sort(arr[:mid]) 38 | right = merge_sort(arr[mid:]) 39 | 40 | return merge(left, right) 41 | 42 | def merge(left: list, right: list) -> list: 43 | output = [] 44 | 45 | while left and right: 46 | min_num = left.pop(0) if left[0] <= right[0] else right.pop(0) 47 | output.append(min_num) 48 | 49 | output.extend(left) 50 | output.extend(right) 51 | 52 | return output 53 | -------------------------------------------------------------------------------- /src/code/python/stack/monotonic_decreasing.py: -------------------------------------------------------------------------------- 1 | def fn(arr): 2 | stack = [] 3 | ans = 0 4 | 5 | for num in arr: 6 | while stack and stack[-1] < num: 7 | # TODO: logic 8 | stack.pop() 9 | stack.append(num) 10 | 11 | return ans 12 | -------------------------------------------------------------------------------- /src/code/python/stack/monotonic_increasing.py: -------------------------------------------------------------------------------- 1 | def fn(arr): 2 | stack = [] 3 | ans = 0 4 | 5 | for num in arr: 6 | while stack and stack[-1] > num: 7 | # TODO: logic 8 | stack.pop() 9 | stack.append(num) 10 | 11 | return ans 12 | -------------------------------------------------------------------------------- /src/components/Accordion/accordion.module.sass: -------------------------------------------------------------------------------- 1 | .accordion 2 | display: flex 3 | flex-direction: column 4 | 5 | .button 6 | align-self: flex-start 7 | justify-content: space-between 8 | background-color: var(--accordion-button-background-color) 9 | backdrop-filter: var(--glass-backdrop-filter) 10 | border: var(--glass-border) 11 | border-radius: 4px 12 | box-shadow: var(--glass-box-shadow) 13 | font-size: var(--accordion-button-font-size) 14 | padding-left: 16px 15 | padding-right: 4px 16 | width: 100% 17 | 18 | svg 19 | stroke: var(--accordion-button-chevron-color) 20 | transform: rotate(90deg) 21 | transition-property: var(--style-transition-property) 22 | transition-duration: var(--style-transition-duration) 23 | 24 | &.open svg 25 | transform: rotate(0) 26 | 27 | .content 28 | background-color: var(--accordion-content-background-color) 29 | backdrop-filter: var(--glass-backdrop-filter) 30 | border-left: var(--glass-border) 31 | border-right: var(--glass-border) 32 | border-bottom: var(--glass-border) 33 | border-bottom-left-radius: 4px 34 | border-bottom-right-radius: 4px 35 | box-shadow: var(--glass-box-shadow) 36 | display: flex 37 | flex-direction: column 38 | margin-left: 2px 39 | margin-right: 2px 40 | padding: 10px 41 | -------------------------------------------------------------------------------- /src/components/Accordion/index.tsx: -------------------------------------------------------------------------------- 1 | import styles from './accordion.module.sass' 2 | 3 | import { ReactNode, useState } from 'react' 4 | import AnimateHeight from 'react-animate-height' 5 | 6 | import clsx from '@utils/clsx' 7 | import Chevron from '@icons/Chevron' 8 | 9 | 10 | interface AccordionProps { 11 | title: string 12 | children: ReactNode 13 | } 14 | 15 | 16 | export default function Accordion({ title, children }: AccordionProps) { 17 | const [isOpen, setIsOpen] = useState(false) 18 | const height = isOpen ? 'auto' : 0 19 | const buttonClasses = clsx( 20 | styles.button, 21 | isOpen && styles.open 22 | ) 23 | 24 | const handleClick = () => setIsOpen(!isOpen) 25 | 26 | return ( 27 |
28 | 32 | 37 |
{children}
38 | 39 |
40 | ) 41 | } 42 | -------------------------------------------------------------------------------- /src/components/App/index.tsx: -------------------------------------------------------------------------------- 1 | import '@styles/styles.sass' 2 | 3 | import React from 'react' 4 | import { LanguageProvider } from '@components/Language/context' 5 | import { SidebarProvider } from '@components/Sidebar/context' 6 | 7 | import Background from '@components/Background' 8 | import Appbar from '@/components/Appbar' 9 | import Content from '@components/Content' 10 | 11 | export default function App() { 12 | return ( 13 | 14 | 15 | 16 |
17 | 18 | 19 | 20 |
21 | 22 | 23 | 24 | ) 25 | } 26 | -------------------------------------------------------------------------------- /src/components/Appbar/index.tsx: -------------------------------------------------------------------------------- 1 | import { useRef } from 'react' 2 | 3 | import Topbar from '@/components/Topbar' 4 | import Sidebar from '@/components/Sidebar' 5 | 6 | 7 | export default function Appbar() { 8 | const hamburgerButtonRef = useRef(null) 9 | 10 | return ( 11 |
12 | 13 | 14 |
15 | ) 16 | } -------------------------------------------------------------------------------- /src/components/Background/background.module.sass: -------------------------------------------------------------------------------- 1 | .wave 2 | background: linear-gradient(210, rgba(255, 183, 197, 0.5), rgba(255, 240, 245, 0.5), rgba(204, 255, 144, 0.5), rgba(128, 216, 255, 0.5)) 3 | border-radius: 1000% 1000% 0 0 4 | position: fixed 5 | width: 200% 6 | height: 144px 7 | animation: wave 10s -3s linear infinite 8 | transform: translate3d(0, 0, 0) 9 | opacity: 0.7 10 | bottom: 0 11 | left: 0 12 | z-index: -1 13 | 14 | &:nth-of-type(2) 15 | background: linear-gradient(180deg, rgba(255, 183, 197, 0.5), rgba(255, 240, 245, 0.5), rgba(204, 255, 144, 0.5), rgba(128, 216, 255, 0.5)) 16 | bottom: -20px 17 | opacity: 0.7 18 | animation: wave 18s linear reverse infinite 19 | 20 | &:nth-of-type(3) 21 | background: linear-gradient(135deg, rgba(255, 183, 197, 0.5), rgba(255, 240, 245, 0.5), rgba(204, 255, 144, 0.5), rgba(128, 216, 255, 0.5)) 22 | bottom: -40px 23 | opacity: 0.8 24 | animation: wave 20s -1s reverse infinite 25 | 26 | @keyframes gradient 27 | 0% 28 | background-position: 0% 0% 29 | 50% 30 | background-position: 100% 100% 31 | 100% 32 | background-position: 0% 0% 33 | 34 | @keyframes wave 35 | 2% 36 | transform: translateX(1) 37 | 25% 38 | transform: translateX(-25%) 39 | 50% 40 | transform: translateX(-50%) 41 | 75% 42 | transform: translateX(-25%) 43 | 100% 44 | transform: translateX(1) 45 | -------------------------------------------------------------------------------- /src/components/Background/index.tsx: -------------------------------------------------------------------------------- 1 | import styles from './background.module.sass' 2 | 3 | 4 | export default function Background() { 5 | return ( 6 |
7 |
8 |
9 |
10 |
11 | ) 12 | } 13 | -------------------------------------------------------------------------------- /src/components/Brand/index.tsx: -------------------------------------------------------------------------------- 1 | import styles from './brand.module.sass' 2 | 3 | import { useState } from 'react' 4 | 5 | import clsx from '@utils/clsx' 6 | 7 | 8 | export default function Brand() { 9 | const [clickAnimation, setClickAnimation] = useState(styles.rotate) 10 | const [isAnimating, setIsAnimating] = useState(false) 11 | 12 | const animationClasses = [ 13 | styles.bounce, 14 | styles.glowDisappear, 15 | styles.heartBeat, 16 | styles.rubberBand, 17 | styles.rotate 18 | ] 19 | const classes = clsx( 20 | styles.brand, 21 | isAnimating && clickAnimation 22 | ) 23 | 24 | const handleAnimationEnd = () => setIsAnimating(false) 25 | const handleClick = () => { 26 | const randomIndex = Math.floor(Math.random() * animationClasses.length) 27 | const randomChoice = animationClasses[randomIndex] 28 | 29 | setIsAnimating(true) 30 | setClickAnimation(randomChoice) 31 | } 32 | 33 | return ( 34 |
39 | JWL 40 |
41 | ) 42 | } 43 | -------------------------------------------------------------------------------- /src/components/Code/code.module.sass: -------------------------------------------------------------------------------- 1 | .code 2 | border: 0.5px solid var(--code-border-color) 3 | border-radius: 6px 4 | font-size: var(--code-font-size) 5 | line-height: var(--code-line-height) 6 | position: relative 7 | padding-left: 2em 8 | 9 | ::selection 10 | background-color: var(--code-line-hover-color) 11 | 12 | .line 13 | display: block 14 | border-left: 0.5px solid var(--code-line-number-color) 15 | padding-left: 1em 16 | min-height: 1em 17 | 18 | &::before 19 | content: attr(data-line-number) 20 | position: absolute 21 | color: var(--code-line-number-color) 22 | left: -5px 23 | width: 2em 24 | text-align: right 25 | user-select: none 26 | 27 | &:hover, 28 | &[focused] 29 | background-color: var(--code-line-hover-color) 30 | 31 | &::before 32 | color: var(--code-line-number-hover-color) 33 | -------------------------------------------------------------------------------- /src/components/Content/content.module.sass: -------------------------------------------------------------------------------- 1 | .main 2 | display: flex 3 | flex-direction: column 4 | row-gap: 48px 5 | margin-bottom: var(--content-margin-bottom) 6 | margin-left: var(--content-margin-left) 7 | margin-right: var(--content-margin-right) 8 | margin-top: var(--content-margin-top) 9 | transition: margin 300ms ease 10 | 11 | &.sidebarHidden 12 | margin-left: 4px 13 | 14 | @media (max-width: 768px) 15 | margin-left: 4px 16 | -------------------------------------------------------------------------------- /src/components/CopyButton/copybutton.module.sass: -------------------------------------------------------------------------------- 1 | .copyButton 2 | background-color: var(--copy-button-background-color) 3 | border: none 4 | border-bottom: 2px solid var(--tab-button-border-bottom-color) 5 | border-radius: 8px 6 | box-shadow: none 7 | padding-left: var(--button-padding-x) 8 | padding-right: var(--button-padding-x) 9 | padding-top: var(--button-padding-y) 10 | padding-bottom: var(--button-padding-y) 11 | height: 48px 12 | width: 70px 13 | display: inline-flex 14 | align-items: center 15 | justify-content: center 16 | outline: none 17 | 18 | &:hover 19 | background-color: var(--copy-button-hover-background-color) 20 | 21 | &:active 22 | background-color: var(--copy-button-active-background-color) 23 | 24 | .copySvg 25 | height: 100% 26 | width: 100% 27 | opacity: 1 28 | fill: var(--copy-button-svg-fill-color) 29 | 30 | .checkSvg 31 | height: 100% 32 | width: 100% 33 | 34 | .checkSvgPath 35 | stroke: var(--copy-button-svg-fill-color) 36 | stroke-width: 2 37 | fill: none 38 | stroke-linecap: round 39 | stroke-linejoin: round 40 | stroke-dasharray: 16 41 | stroke-dashoffset: 16 42 | animation: draw var(--style-transition-duration) ease-in-out forwards 43 | 44 | .enter 45 | animation: fade-in 150ms forwards 46 | 47 | .exit 48 | animation: fade-out 150ms forwards 49 | 50 | @keyframes fade-in 51 | from 52 | opacity: 0 53 | to 54 | opacity: 1 55 | 56 | @keyframes fade-out 57 | from 58 | opacity: 1 59 | to 60 | opacity: 0 61 | 62 | @keyframes draw 63 | to 64 | stroke-dashoffset: 0 65 | -------------------------------------------------------------------------------- /src/components/Language/context.tsx: -------------------------------------------------------------------------------- 1 | import { 2 | createContext, 3 | useContext, 4 | useState, 5 | ReactNode, 6 | useEffect, 7 | } from 'react' 8 | 9 | 10 | type Language = 'python' | 'javascript' | 'java' | 'cpp' 11 | 12 | interface LanguageContextType { 13 | selectedLanguage: Language 14 | setSelectedLanguage: (language: Language) => void 15 | } 16 | 17 | const LanguageContext = createContext( 18 | undefined 19 | ) 20 | 21 | interface LanguageProviderProps { 22 | children: ReactNode 23 | } 24 | 25 | 26 | export const LanguageProvider = ({ children }: LanguageProviderProps) => { 27 | const initialLanguage: Language = 28 | (localStorage.getItem('selectedLanguage') as Language) || 'python' 29 | 30 | const [selectedLanguage, setSelectedLanguage] = useState(initialLanguage) 31 | 32 | useEffect(() => { 33 | localStorage.setItem('selectedLanguage', selectedLanguage) 34 | }, [selectedLanguage]) 35 | 36 | return ( 37 | 40 | {children} 41 | 42 | ) 43 | } 44 | 45 | export function useLanguage() { 46 | const context = useContext(LanguageContext) 47 | 48 | if (context === undefined) { 49 | throw new Error('useLanguage must be used within a LanguageProvider') 50 | } 51 | 52 | return context as LanguageContextType 53 | } 54 | -------------------------------------------------------------------------------- /src/components/LinkWithTooltip/linkwithtooltip.module.sass: -------------------------------------------------------------------------------- 1 | .linkWrapper 2 | width: 100% 3 | 4 | &:hover 5 | background-color: var(--link-hover-background-color) 6 | border-radius: 4px 7 | 8 | .link[role='button'] 9 | padding-left: 12px 10 | justify-content: flex-start 11 | overflow: hidden 12 | mask: var(--link-overflow-mask) 13 | width: 100% 14 | -------------------------------------------------------------------------------- /src/components/Sidebar/context.tsx: -------------------------------------------------------------------------------- 1 | import { createContext, ReactNode, useContext, useState } from 'react' 2 | 3 | 4 | interface SidebarContextType { 5 | isSidebarOpen: boolean 6 | showSidebar: Function 7 | hideSidebar: Function 8 | toggleSidebar: Function 9 | } 10 | 11 | interface SidebarProviderProps { 12 | children: ReactNode 13 | } 14 | 15 | const SidebarContext = createContext(undefined) 16 | 17 | 18 | export function SidebarProvider ({ children }: SidebarProviderProps) { 19 | const [isSidebarOpen, setIsSidebarOpen] = useState(true) 20 | const showSidebar = () => setIsSidebarOpen(true) 21 | const hideSidebar = () => setIsSidebarOpen(false) 22 | const toggleSidebar = () => setIsSidebarOpen(!isSidebarOpen) 23 | 24 | return ( 25 | 26 | {children} 27 | 28 | ) 29 | } 30 | 31 | export function useSidebar() { 32 | const context = useContext(SidebarContext) 33 | 34 | if (context === undefined) { 35 | throw new Error('useSidebar must be used within SidebarProvider') 36 | } 37 | 38 | return context as SidebarContextType 39 | } 40 | -------------------------------------------------------------------------------- /src/components/Tabs/tabs.module.sass: -------------------------------------------------------------------------------- 1 | .container 2 | background-color: var(--glass-background-color) 3 | backdrop-filter: var(--glass-backdrop-filter) 4 | border: var(--glass-border) 5 | border-radius: var(--glass-border-radius) 6 | box-shadow: var(--glass-box-shadow) 7 | padding: 20px 8 | transition-duration: var(--style-transition-duration) 9 | transition-property: var(--style-transition-property) 10 | 11 | .buttonContainer 12 | display: flex 13 | flex-direction: row 14 | justify-content: space-between 15 | 16 | .tabButtonContainer 17 | display: flex 18 | flex-direction: row 19 | gap: 12px 20 | margin-bottom: 12px 21 | 22 | .tabButton 23 | background-color: rgba(255, 255, 255, 0.6) 24 | border-bottom: 2px solid var(--tab-button-border-bottom-color) 25 | border-radius: 8px 26 | font-size: var(--button-font-size) 27 | padding-left: var(--button-padding-x) 28 | padding-right: var(--button-padding-x) 29 | padding-top: var(--button-padding-y) 30 | padding-bottom: var(--button-padding-y) 31 | transition-duration: var(--style-transition-duration) 32 | transition-property: var(--style-transition-property) 33 | position: relative 34 | height: 48px 35 | width: 70px 36 | 37 | svg 38 | width: 100% 39 | height: 100% 40 | 41 | &:hover 42 | background-color: rgba(248, 248, 248, 0.8) 43 | 44 | &:active 45 | background-color: var(--color-frost-white) 46 | 47 | &[aria-selected='true'] 48 | border-bottom: 2px solid var(--color-azure) 49 | -------------------------------------------------------------------------------- /src/components/ThemeSwitch/index.tsx: -------------------------------------------------------------------------------- 1 | import styles from './themeswitch.module.sass' 2 | 3 | import { useState, useEffect } from 'react' 4 | 5 | 6 | export default function ThemeSwitch() { 7 | const htmlElement = document.documentElement 8 | const [darkMode, setDarkMode] = useState(false) 9 | 10 | const dispatchThemeEvent = () => { 11 | const themeChangeEvent = new Event('themeChange') 12 | htmlElement.dispatchEvent(themeChangeEvent) 13 | } 14 | 15 | const handleThemeChange = () => { 16 | setDarkMode(!darkMode) 17 | htmlElement.setAttribute('data-theme', !darkMode ? 'light' : 'dark') 18 | dispatchThemeEvent() 19 | } 20 | 21 | useEffect(() => { 22 | const theme = htmlElement.getAttribute('data-theme') 23 | setDarkMode(theme === 'light') 24 | dispatchThemeEvent() 25 | }, []) 26 | 27 | return ( 28 |
29 | 37 | 41 |
42 | ) 43 | } 44 | -------------------------------------------------------------------------------- /src/components/Tooltip/tooltip.module.sass: -------------------------------------------------------------------------------- 1 | .tooltip 2 | position: absolute 3 | background-color: rgba(0, 0, 0, 0.7) 4 | backdrop-filter: blur(10px) 5 | border: 1px solid rgba(255, 255, 255, 0.3) 6 | border-radius: 4px 7 | box-shadow: 0 4px 30px rgba(0, 0, 0, 0.1) 8 | color: rgba(255, 255, 255, 0.9) 9 | padding: 6px 10 | z-index: 999 11 | animation: tooltip-enter var(--style-transition-duration) forwards 12 | 13 | &.exit 14 | animation: tooltip-exit var(--style-transition-duration) forwards 15 | 16 | &::after 17 | content: '' 18 | position: absolute 19 | top: 100% 20 | left: 50% 21 | margin-left: -5px 22 | border-color: rgba(0, 0, 0, 0.7) transparent transparent transparent 23 | border-style: solid 24 | border-width: 5px 25 | 26 | .text 27 | text-align: center 28 | 29 | @keyframes tooltip-enter 30 | from 31 | opacity: 0 32 | to 33 | opacity: 1 34 | 35 | @keyframes tooltip-exit 36 | from 37 | opacity: 1 38 | to 39 | opacity: 0 -------------------------------------------------------------------------------- /src/fonts/firacode.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/src/fonts/firacode.woff2 -------------------------------------------------------------------------------- /src/fonts/neometric.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/src/fonts/neometric.woff2 -------------------------------------------------------------------------------- /src/fonts/silkscreen.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/src/fonts/silkscreen.woff2 -------------------------------------------------------------------------------- /src/hooks/useClickOutside.tsx: -------------------------------------------------------------------------------- 1 | import { RefObject, useEffect } from 'react' 2 | 3 | 4 | export function useClickOutside( 5 | refs: RefObject | RefObject[], 6 | handler: VoidFunction 7 | ) { 8 | const handleClick = (event: MouseEvent) => { 9 | const clickedOutside = (ref: RefObject) => ref.current && !ref.current.contains(event.target as Node) 10 | if ((Array.isArray(refs) ? refs.every(clickedOutside) : clickedOutside(refs))) handler() 11 | } 12 | 13 | useEffect(() => { 14 | document.addEventListener('click', handleClick) 15 | 16 | return () => document.removeEventListener('click', handleClick) 17 | }, [refs, handler]) 18 | } 19 | -------------------------------------------------------------------------------- /src/hooks/useScrollDistance.tsx: -------------------------------------------------------------------------------- 1 | import { useEffect, useState } from 'react' 2 | 3 | 4 | export function useScrollDistance(distance: number) { 5 | const [isScrollDistanceReached, setIsScrollDistanceReached] = useState(window.scrollY > distance) 6 | const handleScroll = () => setIsScrollDistanceReached(window.scrollY > distance) 7 | 8 | useEffect(() => { 9 | window.addEventListener('scroll', handleScroll) 10 | 11 | return () => window.removeEventListener('scroll', handleScroll) 12 | }, []) 13 | 14 | return isScrollDistanceReached 15 | } 16 | -------------------------------------------------------------------------------- /src/hooks/useTheme.tsx: -------------------------------------------------------------------------------- 1 | import { useState, useEffect } from 'react' 2 | 3 | 4 | export function useTheme() { 5 | const htmlElement = document.documentElement 6 | const [theme, setTheme] = useState('light') 7 | 8 | const handleThemeChange = () => { 9 | const newTheme = htmlElement.getAttribute('data-theme') ?? 'light' 10 | setTheme(newTheme) 11 | } 12 | 13 | useEffect(() => { 14 | htmlElement.addEventListener('themeChange', handleThemeChange) 15 | 16 | return () => htmlElement.removeEventListener('themeChange', handleThemeChange) 17 | }, [htmlElement]) 18 | 19 | return theme 20 | } 21 | -------------------------------------------------------------------------------- /src/icons/Check.tsx: -------------------------------------------------------------------------------- 1 | export default function SvgCheck() { 2 | return ( 3 | 4 | 5 | 6 | ) 7 | } 8 | -------------------------------------------------------------------------------- /src/icons/Chevron.tsx: -------------------------------------------------------------------------------- 1 | export default function SvgChevron() { 2 | return ( 3 | 13 | 14 | 15 | ) 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/icons/Copy.tsx: -------------------------------------------------------------------------------- 1 | export default function SvgCopy() { 2 | return ( 3 | 4 | 5 | 6 | ) 7 | } 8 | -------------------------------------------------------------------------------- /src/icons/Download.tsx: -------------------------------------------------------------------------------- 1 | export default function SvgDownload() { 2 | return ( 3 | 9 | 10 | 11 | ) 12 | } 13 | -------------------------------------------------------------------------------- /src/icons/File.tsx: -------------------------------------------------------------------------------- 1 | export default function SvgFile() { 2 | return ( 3 | 9 | 10 | 11 | ) 12 | } -------------------------------------------------------------------------------- /src/icons/Javascript.tsx: -------------------------------------------------------------------------------- 1 | export default function SvgJavascript() { 2 | return ( 3 | 4 | 5 | 6 | 7 | ) 8 | } 9 | -------------------------------------------------------------------------------- /src/images/banner.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/src/images/banner.webp -------------------------------------------------------------------------------- /src/images/bg-city-day.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/src/images/bg-city-day.webp -------------------------------------------------------------------------------- /src/images/bg-city-night-2.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/src/images/bg-city-night-2.webp -------------------------------------------------------------------------------- /src/images/bg-city-night-3.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/src/images/bg-city-night-3.webp -------------------------------------------------------------------------------- /src/images/bg-city-night.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/src/images/bg-city-night.webp -------------------------------------------------------------------------------- /src/images/bg-cotton-orb.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jwl-7/leetcode-cheatsheet/5393a421ca33005427cdfb85d674d431c5bfbf23/src/images/bg-cotton-orb.webp -------------------------------------------------------------------------------- /src/main.tsx: -------------------------------------------------------------------------------- 1 | import ReactDOM from 'react-dom/client' 2 | 3 | import App from '@components/App' 4 | 5 | 6 | ReactDOM.createRoot(document.getElementById('root')!).render() 7 | -------------------------------------------------------------------------------- /src/sections/Backtracking/index.tsx: -------------------------------------------------------------------------------- 1 | import styles from '@sections/section.module.sass' 2 | 3 | import Tabs from '@components/Tabs' 4 | 5 | import BacktrackingPY from '@code/python/backtracking/backtracking.py?raw' 6 | import BacktrackingJS from '@code/javascript/backtracking/backtracking.js?raw' 7 | import BacktrackingJAVA from '@code/java/backtracking/backtracking.java?raw' 8 | import BacktrackingCPP from '@code/cpp/backtracking/backtracking.cpp?raw' 9 | 10 | 11 | export default function Backtracking() { 12 | return ( 13 |
14 |

Backtracking

15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 |
23 |
24 | ) 25 | } 26 | -------------------------------------------------------------------------------- /src/sections/BigO/bigo.module.sass: -------------------------------------------------------------------------------- 1 | .container 2 | background-color: var(--glass-background-color) 3 | backdrop-filter: var(--glass-backdrop-filter) 4 | border: var(--glass-border) 5 | border-radius: var(--glass-border-radius) 6 | box-shadow: var(--glass-box-shadow) 7 | font-family: var(--font-family-sans-serif) 8 | padding: 20px 9 | transition-duration: var(--style-transition-duration) 10 | transition-property: var(--style-transition-property) 11 | 12 | .label 13 | dominant-baseline: middle 14 | text-anchor: middle 15 | fill: var(--text-color) 16 | font-size: var(--bigo-chart-label-font-size) 17 | font-style: italic 18 | 19 | .tableWrapper 20 | background-color: var(--table-wrapper-background-color) 21 | backdrop-filter: var(--table-wrapper-backdrop-filter) 22 | border-radius: 12px 23 | border: 1px solid var(--table-wrapper-border-color) 24 | padding: 8px 25 | overflow-x: auto 26 | 27 | .red 28 | background-color: var(--color-red-alpha) 29 | 30 | .oliveGreen 31 | background-color: var(--color-olive-green-alpha) 32 | 33 | .green 34 | background-color: var(--color-green-alpha) 35 | 36 | .orange 37 | background-color: var(--color-orange-alpha) 38 | 39 | .yellow 40 | background-color: var(--color-yellow-alpha) 41 | 42 | .gray 43 | background-color: var(--color-gray-alpha) 44 | -------------------------------------------------------------------------------- /src/sections/BigO/index.tsx: -------------------------------------------------------------------------------- 1 | import styles from '@sections/section.module.sass' 2 | 3 | import Chart from './Chart' 4 | import DataStructureOperationsTable from './DataStructureOperationsTable' 5 | import SortingAlgorithmsTable from './SortingAlgorithmsTable' 6 | 7 | 8 | export default function BigO() { 9 | return ( 10 |
11 |

Big O

12 | 13 | 14 | 15 |
16 | ) 17 | } 18 | -------------------------------------------------------------------------------- /src/sections/Heap/index.tsx: -------------------------------------------------------------------------------- 1 | import styles from '@sections/section.module.sass' 2 | 3 | import Tabs from '@components/Tabs' 4 | 5 | import FindTopKElementsPY from '@code/python/heap/find_top_k_elements.py?raw' 6 | import FindTopKElementsJS from '@code/javascript/heap/find_top_k_elements.js?raw' 7 | import FindTopKElementsJAVA from '@code/java/heap/find_top_k_elements.java?raw' 8 | import FindTopKElementsCPP from '@code/cpp/heap/find_top_k_elements.cpp?raw' 9 | 10 | 11 | export default function Heap() { 12 | return ( 13 |
14 |

Heap

15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 |
23 |
24 | ) 25 | } 26 | -------------------------------------------------------------------------------- /src/sections/section.module.sass: -------------------------------------------------------------------------------- 1 | .container 2 | display: flex 3 | flex-direction: column 4 | row-gap: 48px 5 | 6 | .sectionHeader 7 | align-self: flex-start 8 | flex-grow: 0 9 | background: var(--section-header-background) 10 | backdrop-filter: var(--glass-backdrop-filter) 11 | border: var(--glass-border) 12 | border-radius: var(--glass-border-radius) 13 | box-shadow: var(--glass-box-shadow) 14 | padding: 20px 15 | transition-duration: var(--style-transition-duration) 16 | transition-property: var(--style-transition-property) 17 | -------------------------------------------------------------------------------- /src/styles/buttons.sass: -------------------------------------------------------------------------------- 1 | button, 2 | a[role='button'] 3 | display: inline-flex 4 | align-items: center 5 | justify-content: center 6 | background: transparent 7 | border: none 8 | box-shadow: none 9 | color: inherit 10 | font-family: inherit 11 | cursor: pointer 12 | outline: none 13 | margin: 0 14 | padding: 0 15 | text-decoration: none 16 | transition-duration: var(--style-transition-duration) 17 | transition-property: var(--style-transition-property) 18 | white-space: nowrap 19 | 20 | svg 21 | height: 1em 22 | width: 1em 23 | vertical-align: middle 24 | 25 | a:not([role='button']) 26 | color: inherit 27 | cursor: pointer 28 | text-decoration: none 29 | transition-duration: var(--style-transition-duration) 30 | transition-property: var(--style-transition-property) 31 | 32 | &:hover 33 | color: var(--link-hover-color) 34 | 35 | &:active 36 | color: inherit 37 | -------------------------------------------------------------------------------- /src/styles/document.sass: -------------------------------------------------------------------------------- 1 | *, 2 | *::before, 3 | *::after 4 | box-sizing: border-box 5 | background-repeat: no-repeat 6 | 7 | html 8 | font-family: var(--font-family-monospace) 9 | 10 | body 11 | background-attachment: fixed 12 | background-image: var(--background-image) 13 | background-size: cover 14 | color: var(--text-color) 15 | font-size: var(--font-size) 16 | font-weight: var(--font-weight) 17 | line-height: var(--line-height) 18 | text-rendering: optimizeLegibility 19 | overflow-wrap: break-word 20 | margin: 0 21 | transition-duration: var(--style-transition-duration) 22 | transition-property: var(--style-transition-property) 23 | width: 100% 24 | 25 | section 26 | transition-property: var(--style-transition-property) 27 | transition-duration: var(--style-transition-duration) 28 | 29 | @media (min-width: 768px) 30 | padding-left: var(--gutter-spacing) 31 | padding-right: var(--gutter-spacing) 32 | 33 | @media (max-width: 768px) 34 | padding-left: 0 35 | padding-right: 0 36 | 37 | main 38 | height: 100vh 39 | 40 | pre 41 | margin: 0 42 | 43 | @keyframes gradient 44 | 0% 45 | background-position: 0% 0% 46 | 50% 47 | background-position: 100% 100% 48 | 100% 49 | background-position: 0% 0% 50 | -------------------------------------------------------------------------------- /src/styles/styles.d.ts: -------------------------------------------------------------------------------- 1 | declare module '*.module.sass' { 2 | const styles: { [className: string]: string } 3 | export default styles 4 | } 5 | 6 | /* Breakpoints: 7 | sm: 576px 8 | md: 768px 9 | lg: 992px 10 | xl: 1200px 11 | xxl: 1400px 12 | */ 13 | -------------------------------------------------------------------------------- /src/styles/styles.sass: -------------------------------------------------------------------------------- 1 | @import '@styles/colors' 2 | @import '@styles/themes' 3 | @import '@styles/document' 4 | @import '@styles/typography' 5 | @import '@styles/buttons' 6 | @import '@styles/table' 7 | @import '@styles/hljstheme' 8 | -------------------------------------------------------------------------------- /src/styles/table.sass: -------------------------------------------------------------------------------- 1 | table, th, td, tr 2 | transition-duration: var(--style-transition-duration) 3 | transition-property: var(--style-transition-property) 4 | 5 | table 6 | border-collapse: collapse 7 | font-family: var(--table-font-family) 8 | font-size: var(--table-font-size) 9 | position: relative 10 | width: 100% 11 | 12 | td:not(:first-child) 13 | color: var(--table-cell-text-color) 14 | 15 | th, td 16 | background-clip: padding-box 17 | overflow: hidden 18 | padding: 8px 19 | text-align: center 20 | 21 | &:not(:last-child) 22 | border-right: 4px solid var(--table-border-color) 23 | 24 | tr 25 | &:not(:last-child) 26 | th, td 27 | border-bottom: 4px solid var(--table-border-color) 28 | -------------------------------------------------------------------------------- /src/styles/typography.sass: -------------------------------------------------------------------------------- 1 | @font-face 2 | font-display: swap 3 | font-family: firacode 4 | src: url(@fonts/firacode.woff2) format('woff2') 5 | 6 | @font-face 7 | font-display: swap 8 | font-family: neometric 9 | src: url(@fonts/neometric.woff2) format('woff2') 10 | 11 | @font-face 12 | font-display: swap 13 | font-family: silkscreen 14 | src: url(@fonts/silkscreen.woff2) format('woff2') 15 | 16 | h1, h2, h3 17 | font-weight: var(--header-font-weight) 18 | margin: 0 19 | 20 | h1 21 | font-family: var(--h1-font-family) 22 | font-size: var(--h1-font-size) 23 | 24 | h2 25 | font-size: var(--h2-font-size) 26 | 27 | h3 28 | font-family: var(--h3-font-family) 29 | font-size: var(--h3-font-size) 30 | margin-bottom: 12px 31 | 32 | code 33 | font-family: var(--font-family-monospace) 34 | white-space: pre 35 | -------------------------------------------------------------------------------- /src/utils/clsx.tsx: -------------------------------------------------------------------------------- 1 | export default function clsx(...classes: (string | undefined | null | false)[]): string { 2 | return classes.filter(Boolean).join(' ') 3 | } 4 | -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | // Options 4 | "target": "ES2020", 5 | "useDefineForClassFields": true, 6 | "lib": [ 7 | "ES2020", 8 | "DOM", 9 | "DOM.Iterable" 10 | ], 11 | "allowSyntheticDefaultImports": true, 12 | "composite": true, 13 | "skipLibCheck": true, 14 | "module": "ESNext", 15 | "types": ["node", "vite/client"], 16 | 17 | // Paths 18 | "baseUrl": "./", 19 | "paths": { 20 | "@/*": ["src/*"], 21 | "@code/*": ["src/code/*"], 22 | "@components/*": ["src/components/*"], 23 | "@fonts/*": ["src/fonts/*"], 24 | "@hooks/*": ["src/hooks/*"], 25 | "@icons/*": ["src/icons/*"], 26 | "@images/*": ["src/images/*"], 27 | "@styles/*": ["src/styles/*"], 28 | "@sections/*": ["src/sections/*"], 29 | "@utils/*": ["src/utils/*"] 30 | }, 31 | 32 | // Bundler 33 | "moduleResolution": "bundler", 34 | "allowImportingTsExtensions": true, 35 | "resolveJsonModule": true, 36 | "isolatedModules": true, 37 | "noEmit": true, 38 | "jsx": "react-jsx", 39 | 40 | // Linting 41 | "strict": true, 42 | "noUnusedLocals": true, 43 | "noUnusedParameters": true, 44 | "noFallthroughCasesInSwitch": true 45 | }, 46 | "include": [ 47 | "src", 48 | "@styles/styles.d.ts", 49 | "vite.config.ts" 50 | ] 51 | } -------------------------------------------------------------------------------- /vite.config.ts: -------------------------------------------------------------------------------- 1 | import { defineConfig } from 'vite' 2 | import path from 'path' 3 | import react from '@vitejs/plugin-react-swc' 4 | 5 | 6 | export default defineConfig({ 7 | plugins: [react()], 8 | base: "https://jwl-7.github.io/leetcode-cheatsheet/", 9 | resolve: { 10 | alias: { 11 | '@': path.resolve(__dirname, './src'), 12 | '@code': path.resolve(__dirname, './src/code'), 13 | '@components': path.resolve(__dirname, './src/components'), 14 | '@fonts': path.resolve(__dirname, './src/fonts'), 15 | '@hooks': path.resolve(__dirname, './src/hooks'), 16 | '@images': path.resolve(__dirname, './src/images'), 17 | '@icons': path.resolve(__dirname, './src/icons'), 18 | '@sections': path.resolve(__dirname, './src/sections'), 19 | '@styles': path.resolve(__dirname, './src/styles'), 20 | '@utils': path.resolve(__dirname, './src/utils') 21 | } 22 | }, 23 | build: { 24 | outDir: 'docs', 25 | } 26 | }) 27 | --------------------------------------------------------------------------------