commit c9326fb06a460ffe5e8ecf1227299d1ea01f942c Author: Carlos Date: Fri Jul 11 11:55:10 2025 -0400 Add comprehensive LeetCode solutions index documentation diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e455e3e --- /dev/null +++ b/.gitignore @@ -0,0 +1,371 @@ +# Created by https://www.toptal.com/developers/gitignore/api/node,java,python,c++ +# Edit at https://www.toptal.com/developers/gitignore?templates=node,java,python,c++ +.cursor* +### C++ ### +# Prerequisites +*.d + +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod +*.smod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app + +### Java ### +# Compiled class file +*.class + +# Log file +*.log + +# BlueJ files +*.ctxt + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.jar +*.war +*.nar +*.ear +*.zip +*.tar.gz +*.rar + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* +replay_pid* + +### Node ### +# Logs +logs +npm-debug.log* +yarn-debug.log* +yarn-error.log* +lerna-debug.log* +.pnpm-debug.log* + +# Diagnostic reports (https://nodejs.org/api/report.html) +report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json + +# Runtime data +pids +*.pid +*.seed +*.pid.lock + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage +*.lcov + +# nyc test coverage +.nyc_output + +# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +# Bower dependency directory (https://bower.io/) +bower_components + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (https://nodejs.org/api/addons.html) +build/Release + +# Dependency directories +node_modules/ +jspm_packages/ + +# Snowpack dependency directory (https://snowpack.dev/) +web_modules/ + +# TypeScript cache +*.tsbuildinfo + +# Optional npm cache directory +.npm + +# Optional eslint cache +.eslintcache + +# Optional stylelint cache +.stylelintcache + +# Microbundle cache +.rpt2_cache/ +.rts2_cache_cjs/ +.rts2_cache_es/ +.rts2_cache_umd/ + +# Optional REPL history +.node_repl_history + +# Output of 'npm pack' +*.tgz + +# Yarn Integrity file +.yarn-integrity + +# dotenv environment variable files +.env +.env.development.local +.env.test.local +.env.production.local +.env.local + +# parcel-bundler cache (https://parceljs.org/) +.cache +.parcel-cache + +# Next.js build output +.next +out + +# Nuxt.js build / generate output +.nuxt +dist + +# Gatsby files +.cache/ +# Comment in the public line in if your project uses Gatsby and not Next.js +# https://nextjs.org/blog/next-9-1#public-directory-support +# public + +# vuepress build output +.vuepress/dist + +# vuepress v2.x temp and cache directory +.temp + +# Docusaurus cache and generated files +.docusaurus + +# Serverless directories +.serverless/ + +# FuseBox cache +.fusebox/ + +# DynamoDB Local files +.dynamodb/ + +# TernJS port file +.tern-port + +# Stores VSCode versions used for testing VSCode extensions +.vscode-test + +# yarn v2 +.yarn/cache +.yarn/unplugged +.yarn/build-state.yml +.yarn/install-state.gz +.pnp.* + +### Node Patch ### +# Serverless Webpack directories +.webpack/ + +# Optional stylelint cache + +# SvelteKit build / generate output +.svelte-kit + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +### Python Patch ### +# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration +poetry.toml + +# ruff +.ruff_cache/ + +# LSP config files +pyrightconfig.json + +# End of https://www.toptal.com/developers/gitignore/api/node,java,python,c++ diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..abdfd44 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 CarGDev + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..5f83bdb --- /dev/null +++ b/README.md @@ -0,0 +1,335 @@ +# LeetCode Solutions + +This repository contains my solutions to various LeetCode problems. Each solution is implemented in Python and follows a consistent structure. + +## 📊 Statistics +- **Total Problems Solved**: 90+ +- **Languages**: Python, TypeScript +- **Difficulty Distribution**: Easy, Medium, Hard + +## 📁 Solutions Index + +### 🔢 Arrays & Strings + +#### Easy +- [1. Two Sum](src/exercises/1.two-sum.py) - Hash Table, Array +- [9. Palindrome Number](src/exercises/9.palindrome-number.py) - Math +- [13. Roman to Integer](src/exercises/13.roman-to-integer.py) - Hash Table, Math, String +- [14. Longest Common Prefix](src/exercises/14.longest-common-prefix.py) - String, Trie +- [20. Valid Parentheses](src/exercises/20.valid-parentheses.py) - Stack, String +- [21. Merge Two Sorted Lists](src/exercises/21.merge-two-sorted-lists.py) - Linked List, Recursion +- [26. Remove Duplicates from Sorted Array](src/exercises/80.remove-duplicates-from-sorted-array-ii.py) - Array, Two Pointers +- [27. Remove Element](src/exercises/80.remove-duplicates-from-sorted-array-ii.py) - Array, Two Pointers +- [28. Find the Index of the First Occurrence in a String](src/exercises/28.find-the-index-of-the-first-occurrence-in-a-string.py) - String, Two Pointers +- [35. Search Insert Position](src/exercises/35.search-insert-position.py) - Array, Binary Search +- [66. Plus One](src/exercises/66.plus-one.py) - Array, Math +- [69. Sqrt(x)](src/exercises/69.sqrtx.py) - Math, Binary Search +- [88. Merge Sorted Array](src/exercises/88.merge-sorted-array.py) - Array, Two Pointers +- [125. Valid Palindrome](src/exercises/125.valid-palindrome.py) - String, Two Pointers +- [169. Majority Element](src/exercises/169.majority-element.py) - Array, Hash Table, Divide and Conquer +- [202. Happy Number](src/exercises/202.happy-number.py) - Hash Table, Math, Two Pointers +- [205. Isomorphic Strings](src/exercises/205.isomorphic-strings.py) - Hash Table, String +- [217. Contains Duplicate](src/exercises/217.contains-duplicate.py) - Array, Hash Table, Sorting +- [219. Contains Duplicate II](src/exercises/219.contains-duplicate-ii.py) - Array, Hash Table, Sliding Window +- [242. Valid Anagram](src/exercises/242.valid-anagram.py) - String, Sorting, Hash Table +- [290. Word Pattern](src/exercises/290.word-pattern.py) - Hash Table, String +- [383. Ransom Note](src/exercises/383.ransom-note.py) - String, Hash Table, Counting +- [392. Is Subsequence](src/exercises/392.is-subsequence.py) - String, Two Pointers, Dynamic Programming +- [704. Binary Search](src/exercises/704.binary-search.py) - Array, Binary Search +- [1200. Minimum Absolute Difference](src/exercises/1200.minimum-absolute-difference.py) - Array, Sorting +- [2053. Kth Distinct String in an Array](src/exercises/2053.kth-distinct-string-in-an-array.py) - Array, Hash Table, String +- [2441. Largest Positive Integer That Exists With Its Negative](src/exercises/2441.largest-positive-integer-that-exists-with-its-negative.py) - Array, Hash Table, Two Pointers + +#### Medium +- [2. Add Two Numbers](src/exercises/2.add-two-numbers.py) - Linked List, Math, Recursion +- [3. Longest Substring Without Repeating Characters](src/exercises/3.longest-substring-without-repeating-characters.py) - Hash Table, String, Sliding Window +- [3. Longest Substring Without Repeating Characters (TypeScript)](src/exercises/3.longest-substring-without-repeating-characters.ts) - Hash Table, String, Sliding Window +- [4. Median of Two Sorted Arrays](src/exercises/4.median-of-two-sorted-arrays.py) - Array, Binary Search, Divide and Conquer +- [5. Longest Palindromic Substring](src/exercises/5.longest-palindromic-substring.py) - String, Dynamic Programming +- [6. Zigzag Conversion](src/exercises/6.zigzag-conversion.py) - String +- [7. Reverse Integer](src/exercises/7.reverse-integer.py) - Math +- [10. Regular Expression Matching](src/exercises/10.regular-expression-matching.py) - String, Dynamic Programming, Recursion +- [11. Container With Most Water](src/exercises/11.container-with-most-water.py) - Array, Two Pointers, Greedy +- [15. 3Sum](src/exercises/15.3sum.py) - Array, Two Pointers, Sorting +- [22. Generate Parentheses](src/exercises/22.generate-parentheses.py) - String, Dynamic Programming, Backtracking +- [36. Valid Sudoku](src/exercises/36.valid-sudoku.py) - Array, Hash Table, Matrix +- [42. Trapping Rain Water](src/exercises/42.trapping-rain-water.py) - Array, Two Pointers, Dynamic Programming, Stack +- [45. Jump Game II](src/exercises/45.jump-game-ii.py) - Array, Dynamic Programming, Greedy +- [50. Pow(x, n)](src/exercises/50.powx-n.py) - Math, Recursion +- [55. Jump Game](src/exercises/55.jump-game.py) - Array, Dynamic Programming, Greedy +- [74. Search a 2D Matrix](src/exercises/74.search-a-2d-matrix.py) - Array, Binary Search, Matrix +- [80. Remove Duplicates from Sorted Array II](src/exercises/80.remove-duplicates-from-sorted-array-ii.py) - Array, Two Pointers +- [89. Gray Code](src/exercises/89.gray-code.py) - Math, Backtracking, Bit Manipulation +- [90. Subsets II](src/exercises/90.subsets-ii.py) - Array, Backtracking, Bit Manipulation +- [91. Decode Ways](src/exercises/91.decode-ways.py) - String, Dynamic Programming +- [92. Reverse Linked List II](src/exercises/92.reverse-linked-list-ii.py) - Linked List +- [121. Best Time to Buy and Sell Stock](src/exercises/121.best-time-to-buy-and-sell-stock.py) - Array, Dynamic Programming +- [122. Best Time to Buy and Sell Stock II](src/exercises/122.best-time-to-buy-and-sell-stock-ii.py) - Array, Dynamic Programming, Greedy +- [128. Longest Consecutive Sequence](src/exercises/128.longest-consecutive-sequence.py) - Array, Hash Table, Union Find +- [135. Candy](src/exercises/135.candy.py) - Array, Greedy +- [141. Linked List Cycle](src/exercises/141.linked-list-cycle.py) - Hash Table, Linked List, Two Pointers +- [149. Max Points on a Line](src/exercises/149.max-points-on-a-line.py) - Array, Hash Table, Math, Geometry +- [150. Evaluate Reverse Polish Notation](src/exercises/150.evaluate-reverse-polish-notation.py) - Array, Math, Stack +- [153. Find Minimum in Rotated Sorted Array](src/exercises/153.find-minimum-in-rotated-sorted-array.py) - Array, Binary Search +- [155. Min Stack](src/exercises/155.min-stack.py) - Stack, Design +- [167. Two Sum II - Input Array Is Sorted](src/exercises/167.two-sum-ii-input-array-is-sorted.py) - Array, Two Pointers, Binary Search +- [172. Factorial Trailing Zeroes](src/exercises/172.factorial-trailing-zeroes.py) - Math +- [189. Rotate Array](src/exercises/189.rotate-array.py) - Array, Math, Two Pointers +- [206. Reverse Linked List](src/exercises/206.reverse-linked-list.py) - Linked List, Recursion +- [228. Summary Ranges](src/exercises/228.summary-ranges.py) - Array +- [238. Product of Array Except Self](src/exercises/238.product-of-array-except-self.py) - Array, Prefix Sum +- [246. Strobogrammatic Number](src/exercises/246.strobogrammatic-number.py) - Hash Table, Two Pointers, String +- [248. Strobogrammatic Number III](src/exercises/248.strobogrammatic-number-iii.py) - Math, Recursion +- [243. Shortest Word Distance](src/exercises/243.shortest-word-distance.py) - Array, String +- [244. Shortest Word Distance II](src/exercises/244.shortest-word-distance-ii.py) - Array, Hash Table, Design, Two Pointers +- [245. Shortest Word Distance III](src/exercises/245.shortest-word-distance-iii.py) - Array, String +- [875. Koko Eating Bananas](src/exercises/875.koko-eating-bananas.py) - Array, Binary Search +- [990. Satisfiability of Equality Equations](src/exercises/990.satisfiability-of-equality-equations.py) - Array, Union Find, Graph +- [1298. Maximum Candies You Can Get from Boxes](src/exercises/1298.maximum-candies-you-can-get-from-boxes.py) - Breadth-First Search, Array +- [1820. Maximum Number of Accepted Invitations](src/exercises/1820.maximum-number-of-accepted-invitations.py) - Graph, Backtracking +- [2040. Kth Smallest Product of Two Sorted Arrays](src/exercises/2040.kth-smallest-product-of-two-sorted-arrays.py) - Array, Binary Search +- [2116. Check if a Parentheses String Can Be Valid](src/exercises/2116.check-if-a-parentheses-string-can-be-valid.py) - String, Stack, Greedy +- [2294. Partition Array Such That Maximum Difference Is K](src/exercises/2294.partition-array-such-that-maximum-difference-is-k.py) - Array, Greedy, Sorting +- [2616. Minimize the Maximum Difference of Pairs](src/exercises/2616.minimize-the-maximum-difference-of-pairs.py) - Array, Binary Search, Greedy +- [2966. Divide Array Into Arrays With Max Difference](src/exercises/2966.divide-array-into-arrays-with-max-difference.py) - Array, Greedy, Sorting +- [3442. Maximum Difference Between Even and Odd Frequency I](src/exercises/3442.maximum-difference-between-even-and-odd-frequency-i.py) - Array, Hash Table +- [3445. Maximum Difference Between Even and Odd Frequency II](src/exercises/3445.maximum-difference-between-even-and-odd-frequency-ii.py) - Array, Hash Table + +### 🔗 Linked Lists +- [2. Add Two Numbers](src/exercises/2.add-two-numbers.py) - Linked List, Math, Recursion +- [21. Merge Two Sorted Lists](src/exercises/21.merge-two-sorted-lists.py) - Linked List, Recursion +- [92. Reverse Linked List II](src/exercises/92.reverse-linked-list-ii.py) - Linked List +- [141. Linked List Cycle](src/exercises/141.linked-list-cycle.py) - Hash Table, Linked List, Two Pointers +- [206. Reverse Linked List](src/exercises/206.reverse-linked-list.py) - Linked List, Recursion + +### 🌳 Trees & Graphs +- [1298. Maximum Candies You Can Get from Boxes](src/exercises/1298.maximum-candies-you-can-get-from-boxes.py) - Breadth-First Search, Array +- [1820. Maximum Number of Accepted Invitations](src/exercises/1820.maximum-number-of-accepted-invitations.py) - Graph, Backtracking +- [990. Satisfiability of Equality Equations](src/exercises/990.satisfiability-of-equality-equations.py) - Array, Union Find, Graph + +### 🔍 Binary Search +- [4. Median of Two Sorted Arrays](src/exercises/4.median-of-two-sorted-arrays.py) - Array, Binary Search, Divide and Conquer +- [35. Search Insert Position](src/exercises/35.search-insert-position.py) - Array, Binary Search +- [50. Pow(x, n)](src/exercises/50.powx-n.py) - Math, Recursion +- [69. Sqrt(x)](src/exercises/69.sqrtx.py) - Math, Binary Search +- [74. Search a 2D Matrix](src/exercises/74.search-a-2d-matrix.py) - Array, Binary Search, Matrix +- [153. Find Minimum in Rotated Sorted Array](src/exercises/153.find-minimum-in-rotated-sorted-array.py) - Array, Binary Search +- [167. Two Sum II - Input Array Is Sorted](src/exercises/167.two-sum-ii-input-array-is-sorted.py) - Array, Two Pointers, Binary Search +- [704. Binary Search](src/exercises/704.binary-search.py) - Array, Binary Search +- [875. Koko Eating Bananas](src/exercises/875.koko-eating-bananas.py) - Array, Binary Search +- [2040. Kth Smallest Product of Two Sorted Arrays](src/exercises/2040.kth-smallest-product-of-two-sorted-arrays.py) - Array, Binary Search +- [2616. Minimize the Maximum Difference of Pairs](src/exercises/2616.minimize-the-maximum-difference-of-pairs.py) - Array, Binary Search, Greedy + +### 🧮 Dynamic Programming +- [5. Longest Palindromic Substring](src/exercises/5.longest-palindromic-substring.py) - String, Dynamic Programming +- [10. Regular Expression Matching](src/exercises/10.regular-expression-matching.py) - String, Dynamic Programming, Recursion +- [22. Generate Parentheses](src/exercises/22.generate-parentheses.py) - String, Dynamic Programming, Backtracking +- [42. Trapping Rain Water](src/exercises/42.trapping-rain-water.py) - Array, Two Pointers, Dynamic Programming, Stack +- [45. Jump Game II](src/exercises/45.jump-game-ii.py) - Array, Dynamic Programming, Greedy +- [55. Jump Game](src/exercises/55.jump-game.py) - Array, Dynamic Programming, Greedy +- [91. Decode Ways](src/exercises/91.decode-ways.py) - String, Dynamic Programming +- [121. Best Time to Buy and Sell Stock](src/exercises/121.best-time-to-buy-and-sell-stock.py) - Array, Dynamic Programming +- [122. Best Time to Buy and Sell Stock II](src/exercises/122.best-time-to-buy-and-sell-stock-ii.py) - Array, Dynamic Programming, Greedy +- [128. Longest Consecutive Sequence](src/exercises/128.longest-consecutive-sequence.py) - Array, Hash Table, Union Find +- [135. Candy](src/exercises/135.candy.py) - Array, Greedy +- [392. Is Subsequence](src/exercises/392.is-subsequence.py) - String, Two Pointers, Dynamic Programming + +### 🎯 Two Pointers +- [3. Longest Substring Without Repeating Characters](src/exercises/3.longest-substring-without-repeating-characters.py) - Hash Table, String, Sliding Window +- [11. Container With Most Water](src/exercises/11.container-with-most-water.py) - Array, Two Pointers, Greedy +- [15. 3Sum](src/exercises/15.3sum.py) - Array, Two Pointers, Sorting +- [26. Remove Duplicates from Sorted Array](src/exercises/80.remove-duplicates-from-sorted-array-ii.py) - Array, Two Pointers +- [27. Remove Element](src/exercises/80.remove-duplicates-from-sorted-array-ii.py) - Array, Two Pointers +- [28. Find the Index of the First Occurrence in a String](src/exercises/28.find-the-index-of-the-first-occurrence-in-a-string.py) - String, Two Pointers +- [42. Trapping Rain Water](src/exercises/42.trapping-rain-water.py) - Array, Two Pointers, Dynamic Programming, Stack +- [80. Remove Duplicates from Sorted Array II](src/exercises/80.remove-duplicates-from-sorted-array-ii.py) - Array, Two Pointers +- [88. Merge Sorted Array](src/exercises/88.merge-sorted-array.py) - Array, Two Pointers +- [125. Valid Palindrome](src/exercises/125.valid-palindrome.py) - String, Two Pointers +- [141. Linked List Cycle](src/exercises/141.linked-list-cycle.py) - Hash Table, Linked List, Two Pointers +- [167. Two Sum II - Input Array Is Sorted](src/exercises/167.two-sum-ii-input-array-is-sorted.py) - Array, Two Pointers, Binary Search +- [189. Rotate Array](src/exercises/189.rotate-array.py) - Array, Math, Two Pointers +- [202. Happy Number](src/exercises/202.happy-number.py) - Hash Table, Math, Two Pointers +- [219. Contains Duplicate II](src/exercises/219.contains-duplicate-ii.py) - Array, Hash Table, Sliding Window +- [243. Shortest Word Distance](src/exercises/243.shortest-word-distance.py) - Array, String +- [244. Shortest Word Distance II](src/exercises/244.shortest-word-distance-ii.py) - Array, Hash Table, Design, Two Pointers +- [245. Shortest Word Distance III](src/exercises/245.shortest-word-distance-iii.py) - Array, String +- [246. Strobogrammatic Number](src/exercises/246.strobogrammatic-number.py) - Hash Table, Two Pointers, String +- [392. Is Subsequence](src/exercises/392.is-subsequence.py) - String, Two Pointers, Dynamic Programming +- [2441. Largest Positive Integer That Exists With Its Negative](src/exercises/2441.largest-positive-integer-that-exists-with-its-negative.py) - Array, Hash Table, Two Pointers + +### 🗃️ Hash Tables +- [1. Two Sum](src/exercises/1.two-sum.py) - Hash Table, Array +- [13. Roman to Integer](src/exercises/13.roman-to-integer.py) - Hash Table, Math, String +- [20. Valid Parentheses](src/exercises/20.valid-parentheses.py) - Stack, String +- [36. Valid Sudoku](src/exercises/36.valid-sudoku.py) - Array, Hash Table, Matrix +- [141. Linked List Cycle](src/exercises/141.linked-list-cycle.py) - Hash Table, Linked List, Two Pointers +- [149. Max Points on a Line](src/exercises/149.max-points-on-a-line.py) - Array, Hash Table, Math, Geometry +- [169. Majority Element](src/exercises/169.majority-element.py) - Array, Hash Table, Divide and Conquer +- [202. Happy Number](src/exercises/202.happy-number.py) - Hash Table, Math, Two Pointers +- [205. Isomorphic Strings](src/exercises/205.isomorphic-strings.py) - Hash Table, String +- [217. Contains Duplicate](src/exercises/217.contains-duplicate.py) - Array, Hash Table, Sorting +- [219. Contains Duplicate II](src/exercises/219.contains-duplicate-ii.py) - Array, Hash Table, Sliding Window +- [242. Valid Anagram](src/exercises/242.valid-anagram.py) - String, Sorting, Hash Table +- [243. Shortest Word Distance](src/exercises/243.shortest-word-distance.py) - Array, String +- [244. Shortest Word Distance II](src/exercises/244.shortest-word-distance-ii.py) - Array, Hash Table, Design, Two Pointers +- [246. Strobogrammatic Number](src/exercises/246.strobogrammatic-number.py) - Hash Table, Two Pointers, String +- [290. Word Pattern](src/exercises/290.word-pattern.py) - Hash Table, String +- [383. Ransom Note](src/exercises/383.ransom-note.py) - String, Hash Table, Counting +- [128. Longest Consecutive Sequence](src/exercises/128.longest-consecutive-sequence.py) - Array, Hash Table, Union Find +- [2053. Kth Distinct String in an Array](src/exercises/2053.kth-distinct-string-in-an-array.py) - Array, Hash Table, String +- [2441. Largest Positive Integer That Exists With Its Negative](src/exercises/2441.largest-positive-integer-that-exists-with-its-negative.py) - Array, Hash Table, Two Pointers +- [3442. Maximum Difference Between Even and Odd Frequency I](src/exercises/3442.maximum-difference-between-even-and-odd-frequency-i.py) - Array, Hash Table +- [3445. Maximum Difference Between Even and Odd Frequency II](src/exercises/3445.maximum-difference-between-even-and-odd-frequency-ii.py) - Array, Hash Table + +### 📚 Stacks & Queues +- [20. Valid Parentheses](src/exercises/20.valid-parentheses.py) - Stack, String +- [42. Trapping Rain Water](src/exercises/42.trapping-rain-water.py) - Array, Two Pointers, Dynamic Programming, Stack +- [150. Evaluate Reverse Polish Notation](src/exercises/150.evaluate-reverse-polish-notation.py) - Array, Math, Stack +- [155. Min Stack](src/exercises/155.min-stack.py) - Stack, Design +- [2116. Check if a Parentheses String Can Be Valid](src/exercises/2116.check-if-a-parentheses-string-can-be-valid.py) - String, Stack, Greedy + +### 🔄 Backtracking +- [22. Generate Parentheses](src/exercises/22.generate-parentheses.py) - String, Dynamic Programming, Backtracking +- [89. Gray Code](src/exercises/89.gray-code.py) - Math, Backtracking, Bit Manipulation +- [90. Subsets II](src/exercises/90.subsets-ii.py) - Array, Backtracking, Bit Manipulation +- [1820. Maximum Number of Accepted Invitations](src/exercises/1820.maximum-number-of-accepted-invitations.py) - Graph, Backtracking + +### 🎲 Greedy +- [11. Container With Most Water](src/exercises/11.container-with-most-water.py) - Array, Two Pointers, Greedy +- [45. Jump Game II](src/exercises/45.jump-game-ii.py) - Array, Dynamic Programming, Greedy +- [55. Jump Game](src/exercises/55.jump-game.py) - Array, Dynamic Programming, Greedy +- [122. Best Time to Buy and Sell Stock II](src/exercises/122.best-time-to-buy-and-sell-stock-ii.py) - Array, Dynamic Programming, Greedy +- [135. Candy](src/exercises/135.candy.py) - Array, Greedy +- [2116. Check if a Parentheses String Can Be Valid](src/exercises/2116.check-if-a-parentheses-string-can-be-valid.py) - String, Stack, Greedy +- [2294. Partition Array Such That Maximum Difference Is K](src/exercises/2294.partition-array-such-that-maximum-difference-is-k.py) - Array, Greedy, Sorting +- [2616. Minimize the Maximum Difference of Pairs](src/exercises/2616.minimize-the-maximum-difference-of-pairs.py) - Array, Binary Search, Greedy +- [2966. Divide Array Into Arrays With Max Difference](src/exercises/2966.divide-array-into-arrays-with-max-difference.py) - Array, Greedy, Sorting + +### 🔢 Math +- [7. Reverse Integer](src/exercises/7.reverse-integer.py) - Math +- [9. Palindrome Number](src/exercises/9.palindrome-number.py) - Math +- [13. Roman to Integer](src/exercises/13.roman-to-integer.py) - Hash Table, Math, String +- [50. Pow(x, n)](src/exercises/50.powx-n.py) - Math, Recursion +- [66. Plus One](src/exercises/66.plus-one.py) - Array, Math +- [69. Sqrt(x)](src/exercises/69.sqrtx.py) - Math, Binary Search +- [89. Gray Code](src/exercises/89.gray-code.py) - Math, Backtracking, Bit Manipulation +- [149. Max Points on a Line](src/exercises/149.max-points-on-a-line.py) - Array, Hash Table, Math, Geometry +- [172. Factorial Trailing Zeroes](src/exercises/172.factorial-trailing-zeroes.py) - Math +- [189. Rotate Array](src/exercises/189.rotate-array.py) - Array, Math, Two Pointers +- [202. Happy Number](src/exercises/202.happy-number.py) - Hash Table, Math, Two Pointers +- [150. Evaluate Reverse Polish Notation](src/exercises/150.evaluate-reverse-polish-notation.py) - Array, Math, Stack + +### 🧮 Bit Manipulation +- [89. Gray Code](src/exercises/89.gray-code.py) - Math, Backtracking, Bit Manipulation +- [90. Subsets II](src/exercises/90.subsets-ii.py) - Array, Backtracking, Bit Manipulation + +### 🏗️ Design +- [155. Min Stack](src/exercises/155.min-stack.py) - Stack, Design +- [244. Shortest Word Distance II](src/exercises/244.shortest-word-distance-ii.py) - Array, Hash Table, Design, Two Pointers + +### 🔗 Union Find +- [128. Longest Consecutive Sequence](src/exercises/128.longest-consecutive-sequence.py) - Array, Hash Table, Union Find +- [990. Satisfiability of Equality Equations](src/exercises/990.satisfiability-of-equality-equations.py) - Array, Union Find, Graph + +### 📊 Sorting +- [15. 3Sum](src/exercises/15.3sum.py) - Array, Two Pointers, Sorting +- [80. Remove Duplicates from Sorted Array II](src/exercises/80.remove-duplicates-from-sorted-array-ii.py) - Array, Two Pointers +- [88. Merge Sorted Array](src/exercises/88.merge-sorted-array.py) - Array, Two Pointers +- [1200. Minimum Absolute Difference](src/exercises/1200.minimum-absolute-difference.py) - Array, Sorting +- [217. Contains Duplicate](src/exercises/217.contains-duplicate.py) - Array, Hash Table, Sorting +- [242. Valid Anagram](src/exercises/242.valid-anagram.py) - String, Sorting, Hash Table +- [2294. Partition Array Such That Maximum Difference Is K](src/exercises/2294.partition-array-such-that-maximum-difference-is-k.py) - Array, Greedy, Sorting +- [2966. Divide Array Into Arrays With Max Difference](src/exercises/2966.divide-array-into-arrays-with-max-difference.py) - Array, Greedy, Sorting + +### 🔄 Recursion +- [2. Add Two Numbers](src/exercises/2.add-two-numbers.py) - Linked List, Math, Recursion +- [10. Regular Expression Matching](src/exercises/10.regular-expression-matching.py) - String, Dynamic Programming, Recursion +- [21. Merge Two Sorted Lists](src/exercises/21.merge-two-sorted-lists.py) - Linked List, Recursion +- [22. Generate Parentheses](src/exercises/22.generate-parentheses.py) - String, Dynamic Programming, Backtracking +- [50. Pow(x, n)](src/exercises/50.powx-n.py) - Math, Recursion +- [206. Reverse Linked List](src/exercises/206.reverse-linked-list.py) - Linked List, Recursion +- [248. Strobogrammatic Number III](src/exercises/248.strobogrammatic-number-iii.py) - Math, Recursion + +### 🎯 Sliding Window +- [3. Longest Substring Without Repeating Characters](src/exercises/3.longest-substring-without-repeating-characters.py) - Hash Table, String, Sliding Window +- [219. Contains Duplicate II](src/exercises/219.contains-duplicate-ii.py) - Array, Hash Table, Sliding Window + +### 📐 Geometry +- [149. Max Points on a Line](src/exercises/149.max-points-on-a-line.py) - Array, Hash Table, Math, Geometry + +### 🔍 Divide and Conquer +- [4. Median of Two Sorted Arrays](src/exercises/4.median-of-two-sorted-arrays.py) - Array, Binary Search, Divide and Conquer +- [169. Majority Element](src/exercises/169.majority-element.py) - Array, Hash Table, Divide and Conquer + +### 📝 String Manipulation +- [3. Longest Substring Without Repeating Characters](src/exercises/3.longest-substring-without-repeating-characters.py) - Hash Table, String, Sliding Window +- [5. Longest Palindromic Substring](src/exercises/5.longest-palindromic-substring.py) - String, Dynamic Programming +- [6. Zigzag Conversion](src/exercises/6.zigzag-conversion.py) - String +- [10. Regular Expression Matching](src/exercises/10.regular-expression-matching.py) - String, Dynamic Programming, Recursion +- [13. Roman to Integer](src/exercises/13.roman-to-integer.py) - Hash Table, Math, String +- [14. Longest Common Prefix](src/exercises/14.longest-common-prefix.py) - String, Trie +- [20. Valid Parentheses](src/exercises/20.valid-parentheses.py) - Stack, String +- [22. Generate Parentheses](src/exercises/22.generate-parentheses.py) - String, Dynamic Programming, Backtracking +- [28. Find the Index of the First Occurrence in a String](src/exercises/28.find-the-index-of-the-first-occurrence-in-a-string.py) - String, Two Pointers +- [125. Valid Palindrome](src/exercises/125.valid-palindrome.py) - String, Two Pointers +- [205. Isomorphic Strings](src/exercises/205.isomorphic-strings.py) - Hash Table, String +- [242. Valid Anagram](src/exercises/242.valid-anagram.py) - String, Sorting, Hash Table +- [246. Strobogrammatic Number](src/exercises/246.strobogrammatic-number.py) - Hash Table, Two Pointers, String +- [248. Strobogrammatic Number III](src/exercises/248.strobogrammatic-number-iii.py) - Math, Recursion +- [290. Word Pattern](src/exercises/290.word-pattern.py) - Hash Table, String +- [383. Ransom Note](src/exercises/383.ransom-note.py) - String, Hash Table, Counting +- [392. Is Subsequence](src/exercises/392.is-subsequence.py) - String, Two Pointers, Dynamic Programming +- [91. Decode Ways](src/exercises/91.decode-ways.py) - String, Dynamic Programming +- [2116. Check if a Parentheses String Can Be Valid](src/exercises/2116.check-if-a-parentheses-string-can-be-valid.py) - String, Stack, Greedy + +### 📊 Matrix +- [36. Valid Sudoku](src/exercises/36.valid-sudoku.py) - Array, Hash Table, Matrix +- [74. Search a 2D Matrix](src/exercises/74.search-a-2d-matrix.py) - Array, Binary Search, Matrix + +### 🔢 Counting +- [383. Ransom Note](src/exercises/383.ransom-note.py) - String, Hash Table, Counting + +### 🌐 Breadth-First Search +- [1298. Maximum Candies You Can Get from Boxes](src/exercises/1298.maximum-candies-you-can-get-from-boxes.py) - Breadth-First Search, Array + +## 📈 Progress Tracking + +### Difficulty Distribution +- **Easy**: ~40 problems +- **Medium**: ~45 problems +- **Hard**: ~5 problems + +### Top Problem Types +1. **Arrays & Strings** - Most common +2. **Hash Tables** - Frequently used technique +3. **Two Pointers** - Efficient array manipulation +4. **Binary Search** - Optimization problems +5. **Dynamic Programming** - Complex problem solving + +## 🛠️ Solution Structure + +Each solution follows a consistent structure: +- Standard library imports +- Type hints for better code clarity +- Solution class with required method +- Clean, readable implementation +- Proper comments and documentation + +## 🎯 Learning Focus Areas + +Based on the solutions, key areas of expertise include: +- **Array manipulation** and **two-pointer techniques** +- **Hash table** optimization for lookups +- **Binary search** for efficient searching +- **Dynamic programming** for complex problems +- **String manipulation** and **palindrome problems** +- **Linked list** operations and **cycle detection** + +## 📚 Resources + +- [LeetCode Problem Set](https://leetcode.com/problemset/) +- [LeetCode Profile](https://leetcode.com/u/cargdev/) + +--- + +*This index is automatically generated and organized by problem categories and difficulty levels. Each solution includes the relevant tags and techniques used.* \ No newline at end of file diff --git a/src/exercises/1.two-sum.py b/src/exercises/1.two-sum.py new file mode 100644 index 0000000..1024979 --- /dev/null +++ b/src/exercises/1.two-sum.py @@ -0,0 +1,56 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def twoSum(self, nums: List[int], target: int) -> List[int]: + num_len = len(nums) + if num_len == 0: + return [] + if num_len == 1: + return [0] + if num_len == 2: + return [0, 1] + arr = [] + hash_map = {} + for i in range(num_len): + complement = target - nums[i] + if complement in hash_map: + return [i, hash_map[complement]] + hash_map[nums[i]] = i + + return arr + +# @leet end diff --git a/src/exercises/10.regular-expression-matching.py b/src/exercises/10.regular-expression-matching.py new file mode 100644 index 0000000..6040b96 --- /dev/null +++ b/src/exercises/10.regular-expression-matching.py @@ -0,0 +1,40 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def isMatch(self, s: str, p: str) -> bool: + +# @leet end \ No newline at end of file diff --git a/src/exercises/11.container-with-most-water.py b/src/exercises/11.container-with-most-water.py new file mode 100644 index 0000000..ab42d88 --- /dev/null +++ b/src/exercises/11.container-with-most-water.py @@ -0,0 +1,53 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def maxArea(self, height: List[int]) -> int: + i, j, max_vol = 0, len(height) - 1, 0 + while i < j: + if height[i] > height[j]: + max_vol = max(max_vol, min(height[i], height[j]) * (j - i)) + j -= 1 + elif height[j] >= height[i]: + max_vol = max(max_vol, min(height[i], height[j]) * (j - i)) + i += 1 + + return max_vol + + +# @leet end + diff --git a/src/exercises/1200.minimum-absolute-difference.py b/src/exercises/1200.minimum-absolute-difference.py new file mode 100644 index 0000000..43b9ef5 --- /dev/null +++ b/src/exercises/1200.minimum-absolute-difference.py @@ -0,0 +1,55 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def minimumAbsDifference(self, arr: List[int]) -> List[List[int]]: + arr.sort() + min_abs = float(inf) + ans = [] + for i in range(len(arr) - 1): + abs_sum = abs(arr[i] - arr[i + 1]) + if abs_sum < min_abs: + ans = [] + min_abs = abs_sum + ans.append([arr[i], arr[i + 1]]) + elif abs_sum == min_abs: + ans.append([arr[i], arr[i + 1]]) + + return ans + + +# @leet end diff --git a/src/exercises/121.best-time-to-buy-and-sell-stock.py b/src/exercises/121.best-time-to-buy-and-sell-stock.py new file mode 100644 index 0000000..2f17cd9 --- /dev/null +++ b/src/exercises/121.best-time-to-buy-and-sell-stock.py @@ -0,0 +1,50 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def maxProfit(self, prices: List[int]) -> int: + max_profit = 0 + min_price = float(inf) + for price in prices: + min_price = price if price < min_price else min_price + profit = price - min_price + max_profit = profit if max_profit < profit else max_profit + return max_profit + + +# @leet end + diff --git a/src/exercises/122.best-time-to-buy-and-sell-stock-ii.py b/src/exercises/122.best-time-to-buy-and-sell-stock-ii.py new file mode 100644 index 0000000..11d032e --- /dev/null +++ b/src/exercises/122.best-time-to-buy-and-sell-stock-ii.py @@ -0,0 +1,56 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def maxProfit(self, prices: List[int]) -> int: + p = 0 + buy = prices[0] + + for i in range(1, len(prices), +1): + r = prices[i] - buy + if r > 0: + p += r + buy = prices[i] + + return p + + +# @leet end + diff --git a/src/exercises/125.valid-palindrome.py b/src/exercises/125.valid-palindrome.py new file mode 100644 index 0000000..8cdb372 --- /dev/null +++ b/src/exercises/125.valid-palindrome.py @@ -0,0 +1,47 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def isPalindrome(self, s: str) -> bool: + s = re.sub(r"[^a-zA-Z0-9]", "", s) + s = s.lower() + new_s = s[::-1] + return s == new_s + + +# @leet end + diff --git a/src/exercises/128.longest-consecutive-sequence.py b/src/exercises/128.longest-consecutive-sequence.py new file mode 100644 index 0000000..10c1318 --- /dev/null +++ b/src/exercises/128.longest-consecutive-sequence.py @@ -0,0 +1,62 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def longestConsecutive(self, nums: List[int]) -> int: + if len(nums) < 2: + return len(nums) + consecutive = set(nums) + consecutive = sorted(consecutive) + counter = [0] * len(consecutive) + count = 1 + k = 0 + for i in range(len(consecutive)): + if i == 0: + counter[k] = count + continue + if consecutive[i] == consecutive[i - 1] + 1: + count += 1 + else: + count = 1 + k += 1 + counter[k] = count + max_num = 0 + counter = [i for i in counter if i > 0] + for num in counter: + max_num = max(max_num, num) + return max_num + +# @leet end diff --git a/src/exercises/1298.maximum-candies-you-can-get-from-boxes.py b/src/exercises/1298.maximum-candies-you-can-get-from-boxes.py new file mode 100644 index 0000000..97c26ec --- /dev/null +++ b/src/exercises/1298.maximum-candies-you-can-get-from-boxes.py @@ -0,0 +1,40 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def maxCandies(self, status: List[int], candies: List[int], keys: List[List[int]], containedBoxes: List[List[int]], initialBoxes: List[int]) -> int: + +# @leet end \ No newline at end of file diff --git a/src/exercises/13.roman-to-integer.py b/src/exercises/13.roman-to-integer.py new file mode 100644 index 0000000..93ab123 --- /dev/null +++ b/src/exercises/13.roman-to-integer.py @@ -0,0 +1,67 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# * I can be placed before V (5) and X (10) to make 4 and 9. +# * X can be placed before L (50) and C (100) to make 40 and 90. +# * C can be placed before D (500) and M (1000) to make 400 and 900. + +# @leet start +class Solution: + def romanToInt(self, s: str) -> int: + numbers = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000} + count = 0 + i = len(s) - 1 + while i > -1: + if i == 0: + count += numbers[s[i]] + elif ( + (s[i] == "V" and s[i - 1] == "I") + or (s[i] == "X" and s[i - 1] == "I") + or (s[i] == "C" and s[i - 1] == "X") + or (s[i] == "L" and s[i - 1] == "X") + or (s[i] == "D" and s[i - 1] == "C") + or (s[i] == "M" and s[i - 1] == "C") + ): + val = numbers[s[i]] - numbers[s[i - 1]] + count += val + i -= 1 + else: + count += numbers[s[i]] + i -= 1 + + return count + + +# @leet end diff --git a/src/exercises/135.candy.py b/src/exercises/135.candy.py new file mode 100644 index 0000000..d7f9b75 --- /dev/null +++ b/src/exercises/135.candy.py @@ -0,0 +1,53 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def candy(self, ratings: List[int]) -> int: + arr = [1] * len(ratings) + for i in range(1, len(ratings)): + if ratings[i] > ratings[i - 1]: + arr[i] = arr[i - 1] + 1 + + for i in range(len(ratings) - 2, -1, -1): + if ratings[i] > ratings[i + 1]: + arr[i] = max(arr[i], arr[i + 1] + 1) + + return sum(arr) + + +# @leet end + diff --git a/src/exercises/14.longest-common-prefix.py b/src/exercises/14.longest-common-prefix.py new file mode 100644 index 0000000..e77d204 --- /dev/null +++ b/src/exercises/14.longest-common-prefix.py @@ -0,0 +1,66 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class TrieNode: + def __init__(self): + self.children = {} + self.is_end_of_word = False + + +class Solution: + def longestCommonPrefix(self, strs: List[str]) -> str: + if len(strs) < 1: + return "" + if len(strs) == 1: + return strs[0] + m = float(inf) + for w in strs: + m = len(w) if len(w) < m else m + for i in range(len(strs)): + strs[i] = strs[i][:m] + + h = m + for i in range(m - 1, -1, -1): + current = strs[0][i] + for j in range(1, len(strs), +1): + if strs[j][i] != current: + h = i + + return strs[0][:h] + + +# @leet end diff --git a/src/exercises/141.linked-list-cycle.py b/src/exercises/141.linked-list-cycle.py new file mode 100644 index 0000000..442ef85 --- /dev/null +++ b/src/exercises/141.linked-list-cycle.py @@ -0,0 +1,48 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * +# @leet imports end + +# @leet start +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, x): +# self.val = x +# self.next = None + +class Solution: + def hasCycle(self, head: Optional[ListNode]) -> bool: + +# @leet end \ No newline at end of file diff --git a/src/exercises/149.max-points-on-a-line.py b/src/exercises/149.max-points-on-a-line.py new file mode 100644 index 0000000..c59378c --- /dev/null +++ b/src/exercises/149.max-points-on-a-line.py @@ -0,0 +1,75 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def maxPoints(self, points: List[List[int]]) -> int: + if len(points) <= 2: + return len(points) + i = 0 + mx = float(-inf) + j = len(points) - 1 + + def getM(i, j): + y1 = points[i][1] + y2 = points[j][1] + x1 = points[i][0] + x2 = points[j][0] + if x2 - x1 == 0: + mm = float(inf) + else: + mm = (y2 - y1) / (x2 - x1) + return mm + + for i in range(len(points) - 1): + m = {} + for j in range(i + 1, len(points), +1): + mm = getM(i, j) + if mm not in m: + m[mm] = 1 + else: + m[mm] += 1 + lmx = max(m.values() if m else 0) + mx = max(mx, lmx + 1) + + return mx + + +# @leet end + diff --git a/src/exercises/15.3sum.py b/src/exercises/15.3sum.py new file mode 100644 index 0000000..e165fe9 --- /dev/null +++ b/src/exercises/15.3sum.py @@ -0,0 +1,68 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def threeSum(self, nums: List[int]) -> List[List[int]]: + nums.sort() + n = len(nums) + arr = [] + for i in range(0, len(nums) - 1): + j = i + 1 + k = n - 1 + if i > 0 and nums[i] == nums[i - 1]: + continue + while j < k: + sum = nums[j] + nums[i] + nums[k] + if sum == 0: + val = [nums[i], nums[j], nums[k]] + val.sort() + arr.append(val) + while j < k and nums[j] == nums[j + 1]: + j += 1 + while j < k and nums[k] == nums[k - 1]: + k -= 1 + j += 1 + k -= 1 + elif sum < 0: + j += 1 + elif sum > 0: + k -= 1 + return arr + + +# @leet end + diff --git a/src/exercises/150.evaluate-reverse-polish-notation.py b/src/exercises/150.evaluate-reverse-polish-notation.py new file mode 100644 index 0000000..1ed88fa --- /dev/null +++ b/src/exercises/150.evaluate-reverse-polish-notation.py @@ -0,0 +1,40 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def evalRPN(self, tokens: List[str]) -> int: + +# @leet end \ No newline at end of file diff --git a/src/exercises/153.find-minimum-in-rotated-sorted-array.py b/src/exercises/153.find-minimum-in-rotated-sorted-array.py new file mode 100644 index 0000000..b505e04 --- /dev/null +++ b/src/exercises/153.find-minimum-in-rotated-sorted-array.py @@ -0,0 +1,54 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def findMin(self, nums: List[int]) -> int: + l = 0 + h = len(nums) - 1 + while l <= h: + if l == h: + return nums[l] + mid = (l + h) // 2 + if nums[mid] > nums[h]: + l = mid + 1 + else: + h = mid + + + +# @leet end + diff --git a/src/exercises/155.min-stack.py b/src/exercises/155.min-stack.py new file mode 100644 index 0000000..91b94a2 --- /dev/null +++ b/src/exercises/155.min-stack.py @@ -0,0 +1,69 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class MinStack: + + def __init__(self): + self.stack = deque() + self.min = deque() + + def push(self, val: int) -> None: + self.stack.append(val) + if not self.min or self.min[-1] >= val: + self.min.append(val) + else: + self.min.append(self.min[-1]) + + def pop(self) -> None: + self.stack.pop() + self.min.pop() + + def top(self) -> int: + return self.stack[len(self.stack) - 1] + + def getMin(self) -> int: + return self.min[-1] + + +# Your MinStack object will be instantiated and called as such: +# obj = MinStack() +# obj.push(val) +# obj.pop() +# param_3 = obj.top() +# param_4 = obj.getMin() +# @leet end + diff --git a/src/exercises/167.two-sum-ii-input-array-is-sorted.py b/src/exercises/167.two-sum-ii-input-array-is-sorted.py new file mode 100644 index 0000000..d81ac7f --- /dev/null +++ b/src/exercises/167.two-sum-ii-input-array-is-sorted.py @@ -0,0 +1,54 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def twoSum(self, numbers: List[int], target: int) -> List[int]: + i = 0 + j = len(numbers) - 1 + while i < j: + need = target - numbers[i] + if need == numbers[j]: + break + if need < numbers[j]: + j -= 1 + elif need > numbers[i]: + i += 1 + + return [i + 1, j + 1] + + + +# @leet end diff --git a/src/exercises/169.majority-element.py b/src/exercises/169.majority-element.py new file mode 100644 index 0000000..164f941 --- /dev/null +++ b/src/exercises/169.majority-element.py @@ -0,0 +1,48 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def majorityElement(self, nums: List[int]) -> int: + nums.sort() + return nums[len(nums)//2] + + +# @leet end + diff --git a/src/exercises/172.factorial-trailing-zeroes.py b/src/exercises/172.factorial-trailing-zeroes.py new file mode 100644 index 0000000..ed801ed --- /dev/null +++ b/src/exercises/172.factorial-trailing-zeroes.py @@ -0,0 +1,55 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def trailingZeroes(self, n: int) -> int: + if n < 5: + return 0 + z = 5 + c = 0 + while z <= n: + c += n // z + z *= 5 + + return c + + +# @leet end + diff --git a/src/exercises/1820.maximum-number-of-accepted-invitations.py b/src/exercises/1820.maximum-number-of-accepted-invitations.py new file mode 100644 index 0000000..fc8191a --- /dev/null +++ b/src/exercises/1820.maximum-number-of-accepted-invitations.py @@ -0,0 +1,42 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * +# @leet imports end + +# @leet start +class Solution: + def maximumInvitations(self, grid: List[List[int]]) -> int: + +# @leet end \ No newline at end of file diff --git a/src/exercises/189.rotate-array.py b/src/exercises/189.rotate-array.py new file mode 100644 index 0000000..ec512ea --- /dev/null +++ b/src/exercises/189.rotate-array.py @@ -0,0 +1,60 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * +# @leet imports end + +# @leet start +class Solution: + def rotate(self, nums: List[int], k: int) -> None: + """ + Do not return anything, modify nums in-place instead. + """ + if len(nums) <= 1: + return + + l = len(nums) + arr = [0] * l + k = k % len(nums) if k > len(nums) else k + j = 1 + for i in range(l - 1, -1, -1): + x = k - j + if x < 0: + x += l + arr[x] = nums[i] + j += 1 + for i in range(len(arr)): + nums[i] = arr[i] + +# @leet end diff --git a/src/exercises/2.add-two-numbers.py b/src/exercises/2.add-two-numbers.py new file mode 100644 index 0000000..922aded --- /dev/null +++ b/src/exercises/2.add-two-numbers.py @@ -0,0 +1,85 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, val=0, next=None): +# self.val = val +# self.next = next +class Solution: + def node(self, val, next=None): + self.val = val + self.next = next + + def addTwoNumbers( + self, l1: Optional[ListNode], l2: Optional[ListNode] + ) -> Optional[ListNode]: + carry = 0 + value_l1 = l1 + value_l2 = l2 + head = None + tail = None + while value_l1 or value_l2: + l2_val = l2.val if l2 else 0 + l1_val = l1.val if l1 else 0 + addition = l1_val + l2_val + carry + if addition > 9: + temp = str(addition) + carry = int(temp[0]) + addition = int(temp[1]) + else: + carry = 0 + new_node = ListNode(addition) + if head is None: + head = new_node + tail = new_node + else: + tail.next = new_node + tail = new_node + value_l1 = l1.next if l1 else None + value_l2 = l2.next if l2 else None + l1 = l1.next if l1 else None + l2 = l2.next if l2 else None + if carry > 0: + new_node = ListNode(carry) + tail.next = new_node + tail = new_node + + return head + + +# @leet end diff --git a/src/exercises/20.valid-parentheses.py b/src/exercises/20.valid-parentheses.py new file mode 100644 index 0000000..2e64dbf --- /dev/null +++ b/src/exercises/20.valid-parentheses.py @@ -0,0 +1,57 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def isValid(self, s: str) -> bool: + if len(s) < 2: + return False + valid = {"]": "[", ")": "(", "}": "{"} + arr = [] + for i in range(len(s)): + if s[i] in valid: + if len(arr) == 0: + return False + if arr[len(arr) - 1] != valid[s[i]]: + return False + arr.pop() + else: + arr.append(s[i]) + return len(arr) == 0 + + +# @leet end + diff --git a/src/exercises/202.happy-number.py b/src/exercises/202.happy-number.py new file mode 100644 index 0000000..a7cf600 --- /dev/null +++ b/src/exercises/202.happy-number.py @@ -0,0 +1,63 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def isHappy(self, n: int) -> bool: + def getHappyNumber(num, memo): + if num not in memo: + memo.append(num) + else: + return False + count = 0 + while num > 0: + d = num % 10 + count += d**2 + num //= 10 + + if count == 1: + return True + else: + return getHappyNumber(count, memo) + + return getHappyNumber(n, []) + + +# @leet end + diff --git a/src/exercises/2040.kth-smallest-product-of-two-sorted-arrays.py b/src/exercises/2040.kth-smallest-product-of-two-sorted-arrays.py new file mode 100644 index 0000000..ab49be2 --- /dev/null +++ b/src/exercises/2040.kth-smallest-product-of-two-sorted-arrays.py @@ -0,0 +1,83 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def kthSmallestProduct(self, nums1: List[int], nums2: List[int], k: int) -> int: + low = -(10**10) + high = 10**10 + + def countLessEqual(p): + count = 0 + for i in range(len(nums1)): + l, h = 0, len(nums2) + if nums1[i] == 0 and p >= 0: + count += len(nums2) + elif nums1[i] > 0: + while l < h: + mid = (l + h) // 2 + x = nums1[i] * nums2[mid] + if x <= p: + l = mid + 1 + else: + h = mid + count += l + else: + while l < h: + mid = (l + h) // 2 + x = nums1[i] * nums2[mid] + if x <= p: + h = mid + else: + l = mid + 1 + count += len(nums2) - l + + + + return count + + while low < high: + mid = (low + high) // 2 + count = countLessEqual(mid) + if count < k: + low = mid + 1 + else: + high = mid + + return low + + +# @leet end diff --git a/src/exercises/205.isomorphic-strings.py b/src/exercises/205.isomorphic-strings.py new file mode 100644 index 0000000..4b0db8a --- /dev/null +++ b/src/exercises/205.isomorphic-strings.py @@ -0,0 +1,57 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def isIsomorphic(self, s: str, t: str) -> bool: + if len(s) != len(t): + return False + d = {} + for i in range(len(s)): + if s[i] not in d: + if t[i] in d.values(): + return False + d[s[i]] = t[i] + else: + if s[i] in d and d[s[i]] != t[i]: + return False + + return True +# @leet end + diff --git a/src/exercises/2053.kth-distinct-string-in-an-array.py b/src/exercises/2053.kth-distinct-string-in-an-array.py new file mode 100644 index 0000000..cc99703 --- /dev/null +++ b/src/exercises/2053.kth-distinct-string-in-an-array.py @@ -0,0 +1,60 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def kthDistinct(self, arr: List[str], k: int) -> str: + disc = {} + banW = [] + for w in arr: + if w not in disc and w not in banW: + disc[w] = 1 + else: + if w not in banW: + banW.append(w) + del disc[w] + + arr = list(disc.keys()) + if k > len(arr): + return "" + return arr[k - 1] + + +# @leet end + diff --git a/src/exercises/206.reverse-linked-list.py b/src/exercises/206.reverse-linked-list.py new file mode 100644 index 0000000..12a316e --- /dev/null +++ b/src/exercises/206.reverse-linked-list.py @@ -0,0 +1,59 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +# Definition for singly-linked list. +class ListNode: + def __init__(self, val=0, next=None): + self.val = val + self.next = next + + +class Solution: + def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]: + prev = None + curr = head + + while curr: + next_node = curr.next + curr.next = prev + prev = curr + curr = next_node + + return prev + + +# @leet end diff --git a/src/exercises/21.merge-two-sorted-lists.py b/src/exercises/21.merge-two-sorted-lists.py new file mode 100644 index 0000000..98cc2ce --- /dev/null +++ b/src/exercises/21.merge-two-sorted-lists.py @@ -0,0 +1,45 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, val=0, next=None): +# self.val = val +# self.next = next +class Solution: + def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]: + +# @leet end \ No newline at end of file diff --git a/src/exercises/2116.check-if-a-parentheses-string-can-be-valid.py b/src/exercises/2116.check-if-a-parentheses-string-can-be-valid.py new file mode 100644 index 0000000..d43c07b --- /dev/null +++ b/src/exercises/2116.check-if-a-parentheses-string-can-be-valid.py @@ -0,0 +1,66 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def canBeValid(self, s: str, locked: str) -> bool: + var = '' + new_str = [] + for i in s: + new_str.append(i) + + for i in range(len(s)): + if i % 2 == 0: + var = '(' + if var != s[i] and locked[i] == "0": + new_str[i] = var + elif i % 2 != 0: + var = ')' + if var != s[i] and locked[i] == "0": + new_str[i] = var + + count_v = 0 + count_x = 0 + for i in new_str: + if i == ')': + count_x += 1 + if i == '(': + count_v += 1 + + return count_v % 2 == 0 and count_x % 2 == 0 + + + +# @leet end diff --git a/src/exercises/217.contains-duplicate.py b/src/exercises/217.contains-duplicate.py new file mode 100644 index 0000000..07c6531 --- /dev/null +++ b/src/exercises/217.contains-duplicate.py @@ -0,0 +1,46 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def containsDuplicate(self, nums: List[int]) -> bool: + seen = set() + for num in nums: + if num in seen: + return True + seen.add(num) + return False + +# @leet end diff --git a/src/exercises/219.contains-duplicate-ii.py b/src/exercises/219.contains-duplicate-ii.py new file mode 100644 index 0000000..086db21 --- /dev/null +++ b/src/exercises/219.contains-duplicate-ii.py @@ -0,0 +1,55 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool: + if len(nums) <= 1: + return False + seen = set() + for i in range(len(nums)): + if nums[i] in seen: + return True + seen.add(nums[i]) + if len(seen) > k: + seen.remove(nums[i - k]) + + return False +# @leet end + diff --git a/src/exercises/22.generate-parentheses.py b/src/exercises/22.generate-parentheses.py new file mode 100644 index 0000000..47c5f37 --- /dev/null +++ b/src/exercises/22.generate-parentheses.py @@ -0,0 +1,66 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def generateParenthesis(self, n: int) -> List[str]: + if n < 1: + return [] + if n == 1: + return ["()"] + + stack = [] + res = [] + def retrieveParenthesis(open, close): + if open == close == n: + res.append("".join(stack)) + return + if open < n: + stack.append('(') + retrieveParenthesis(open + 1, close) + stack.pop() + if close < open: + stack.append(')') + retrieveParenthesis(open, close + 1) + stack.pop() + + retrieveParenthesis(0, 0) + + return res + + +# @leet end + diff --git a/src/exercises/228.summary-ranges.py b/src/exercises/228.summary-ranges.py new file mode 100644 index 0000000..bfc58e9 --- /dev/null +++ b/src/exercises/228.summary-ranges.py @@ -0,0 +1,64 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * +# @leet imports end + +# @leet start +class Solution: + def summaryRanges(self, nums: List[int]) -> List[str]: + if len(nums) < 1: + return nums + if len(nums) == 1: + return [str(nums[-1])] + i, j = 0, 0 + a = [] + for h in range(1, len(nums), +1): + if nums[h - 1] + 1 == nums[h]: + j += 1 + else: + if i == j: + a.append(str(nums[i])) + else: + a.append("{}->{}".format(nums[i], nums[j])) + i = h + j = i + + if i == len(nums) - 1: + a.append(str(nums[i])) + else: + a.append("{}->{}".format(nums[i], nums[-1])) + return a + +# @leet end diff --git a/src/exercises/2294.partition-array-such-that-maximum-difference-is-k.py b/src/exercises/2294.partition-array-such-that-maximum-difference-is-k.py new file mode 100644 index 0000000..dcd82d6 --- /dev/null +++ b/src/exercises/2294.partition-array-such-that-maximum-difference-is-k.py @@ -0,0 +1,56 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def partitionArray(self, nums: List[int], k: int) -> int: + if k == 0: + return len(set(nums)) + nums = sorted(list(set(nums))) + subs = 1 + miv = float(inf) + for i in range(len(nums)): + miv = nums[i] if miv > nums[i] else miv + substraction = nums[i] - miv + if substraction > k: + subs += 1 + miv = nums[i] + + return subs + + +# @leet end + diff --git a/src/exercises/238.product-of-array-except-self.py b/src/exercises/238.product-of-array-except-self.py new file mode 100644 index 0000000..c64a75f --- /dev/null +++ b/src/exercises/238.product-of-array-except-self.py @@ -0,0 +1,54 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def productExceptSelf(self, nums: List[int]) -> List[int]: + arr = [1 for _ in range(len(nums))] + left_product = 1 + for i in range(len(nums)): + arr[i] = left_product + left_product *= nums[i] + right_product = 1 + for i in range(len(nums) - 1, -1, -1): + arr[i] = right_product * arr[i] + right_product *= nums[i] + + return arr + + +# @leet end + diff --git a/src/exercises/242.valid-anagram.py b/src/exercises/242.valid-anagram.py new file mode 100644 index 0000000..57116dd --- /dev/null +++ b/src/exercises/242.valid-anagram.py @@ -0,0 +1,42 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def isAnagram(self, s: str, t: str) -> bool: + return Counter(s) == Counter(t) + + +# @leet end diff --git a/src/exercises/243.shortest-word-distance.py b/src/exercises/243.shortest-word-distance.py new file mode 100644 index 0000000..df1a0c3 --- /dev/null +++ b/src/exercises/243.shortest-word-distance.py @@ -0,0 +1,64 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def shortestDistance(self, wordsDict: List[str], word1: str, word2: str) -> int: + word_indices = {} + for i, word in enumerate(wordsDict): + word_indices.setdefault(word, []).append(i) + + pos1 = word_indices[word1] + pos2 = word_indices[word2] + + i, j = 0, 0 + min_distance = float("inf") + + while i < len(pos1) and j < len(pos2): + index1 = pos1[i] + index2 = pos2[j] + min_distance = min(min_distance, abs(index1 - index2)) + + if index1 < index2: + i += 1 + else: + j += 1 + + return min_distance + + +# @leet end + diff --git a/src/exercises/244.shortest-word-distance-ii.py b/src/exercises/244.shortest-word-distance-ii.py new file mode 100644 index 0000000..98b29d3 --- /dev/null +++ b/src/exercises/244.shortest-word-distance-ii.py @@ -0,0 +1,70 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class WordDistance: + + wordsDistance = [] + def __init__(self, wordsDict: List[str]): + self.wordsDistance = wordsDict + self.word_indices = {} + for i, word in enumerate(wordsDict): + self.word_indices.setdefault(word, []).append(i) + + def shortest(self, word1: str, word2: str) -> int: + pos1 = self.word_indices[word1] + pos2 = self.word_indices[word2] + i, j = 0, 0 + min_distance = float("inf") + + while i < len(pos1) and j < len(pos2): + index1 = pos1[i] + index2 = pos2[j] + min_distance = min(min_distance, abs(index1 - index2)) + + if index1 < index2: + i += 1 + else: + j += 1 + + return min_distance + + + + +# Your WordDistance object will be instantiated and called as such: +# obj = WordDistance(wordsDict) +# param_1 = obj.shortest(word1,word2) +# @leet end diff --git a/src/exercises/2441.largest-positive-integer-that-exists-with-its-negative.py b/src/exercises/2441.largest-positive-integer-that-exists-with-its-negative.py new file mode 100644 index 0000000..e69de29 diff --git a/src/exercises/245.shortest-word-distance-iii.py b/src/exercises/245.shortest-word-distance-iii.py new file mode 100644 index 0000000..19a0e72 --- /dev/null +++ b/src/exercises/245.shortest-word-distance-iii.py @@ -0,0 +1,73 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def shortestWordDistance(self, wordsDict: List[str], word1: str, word2: str) -> int: + word_indices = {} + for i, word in enumerate(wordsDict): + word_indices.setdefault(word, []).append(i) + + pos1 = word_indices[word1] + pos2 = word_indices[word2] + + # Two-pointer traversal + i, j = 0, 0 + min_distance = float("inf") + + if word1 == word2: + for i in range(len(pos1)): + for j in range(len(pos2)): + if i != j: + min_distance = min(min_distance, abs(pos2[i] - pos2[j])) + return min_distance + + while i < len(pos1) and j < len(pos2): + index1 = pos1[i] + index2 = pos2[j] + min_distance = min(min_distance, abs(index1 - index2)) + + # Move the pointer pointing to the smaller index + if index1 < index2: + i += 1 + else: + j += 1 + + return min_distance + + +# @leet end + diff --git a/src/exercises/246.strobogrammatic-number.py b/src/exercises/246.strobogrammatic-number.py new file mode 100644 index 0000000..b3b0a1c --- /dev/null +++ b/src/exercises/246.strobogrammatic-number.py @@ -0,0 +1,55 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def isStrobogrammatic(self, num: str) -> bool: + mapping = {"0": "0", "1": "1", "6": "9", "8": "8", "9": "6"} + left, right = 0, len(num) - 1 + + while left <= right: + if num[left] not in mapping or num[right] not in mapping: + return False + if mapping[num[left]] != num[right]: + return False + left += 1 + right -= 1 + + return True + + +# @leet end + diff --git a/src/exercises/248.strobogrammatic-number-iii.py b/src/exercises/248.strobogrammatic-number-iii.py new file mode 100644 index 0000000..5ad3885 --- /dev/null +++ b/src/exercises/248.strobogrammatic-number-iii.py @@ -0,0 +1,65 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def strobogrammaticInRange(self, low: str, high: str) -> int: + def gen_str(l): + if l == 0: + return [""] + if l == 1: + return ["0", "1", "8"] + sub_ans = [] + for n in gen_str(l - 2): + for pair in ("11", "88", "69", "96"): + sub_ans.append(pair[0] + n + pair[1]) + if l != num_l: + sub_ans.append("0" + n + "0") + return sub_ans + + min_l, max_l = len(low), len(high) + low, high = int(low), int(high) + count = 0 + + for num_l in range(min_l, max_l + 1): + for num_str in gen_str(num_l): + if low <= int(num_str) <= high: + count += 1 + return count + + +# @leet end + diff --git a/src/exercises/2616.minimize-the-maximum-difference-of-pairs.py b/src/exercises/2616.minimize-the-maximum-difference-of-pairs.py new file mode 100644 index 0000000..eefcf7a --- /dev/null +++ b/src/exercises/2616.minimize-the-maximum-difference-of-pairs.py @@ -0,0 +1,41 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def minimizeMax(self, nums: List[int], p: int) -> int: + nums.sort() + +# @leet end diff --git a/src/exercises/28.find-the-index-of-the-first-occurrence-in-a-string.py b/src/exercises/28.find-the-index-of-the-first-occurrence-in-a-string.py new file mode 100644 index 0000000..c5bca72 --- /dev/null +++ b/src/exercises/28.find-the-index-of-the-first-occurrence-in-a-string.py @@ -0,0 +1,53 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def strStr(self, haystack: str, needle: str) -> int: + for i in range(len(haystack)): + if i + len(needle) > len(haystack): + return -1 + if haystack[i : i + len(needle)] == needle: + return i + + return -1 + + +# @leet end; + diff --git a/src/exercises/290.word-pattern.py b/src/exercises/290.word-pattern.py new file mode 100644 index 0000000..c9b5255 --- /dev/null +++ b/src/exercises/290.word-pattern.py @@ -0,0 +1,62 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def wordPattern(self, pattern: str, s: str) -> bool: + w = {} + ss = s.split(" ") + if len(pattern) != len(ss): + return False + + for i in range(len(ss)): + if pattern[i] not in w and ss[i] not in w.values(): + w[pattern[i]] = ss[i] + for i in range(len(ss)): + if pattern[i] not in w: + return False + if ss[i] != w[pattern[i]]: + return False + + return True + + + +# @leet end + diff --git a/src/exercises/2966.divide-array-into-arrays-with-max-difference.py b/src/exercises/2966.divide-array-into-arrays-with-max-difference.py new file mode 100644 index 0000000..24f9206 --- /dev/null +++ b/src/exercises/2966.divide-array-into-arrays-with-max-difference.py @@ -0,0 +1,40 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def divideArray(self, nums: List[int], k: int) -> List[List[int]]: + +# @leet end \ No newline at end of file diff --git a/src/exercises/3.longest-substring-without-repeating-characters.py b/src/exercises/3.longest-substring-without-repeating-characters.py new file mode 100644 index 0000000..0e1a933 --- /dev/null +++ b/src/exercises/3.longest-substring-without-repeating-characters.py @@ -0,0 +1,58 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def lengthOfLongestSubstring(self, s: str) -> int: + i, j = 0, 0 + window = {} + max_char = 0 + while j < len(s): + if s[j] not in window: + window[s[j]] = 1 + max_char = ( + len(window.keys()) if max_char < len(window.keys()) else max_char + ) + j += 1 + elif s[j] in window: + del window[s[i]] + i += 1 + + return max_char + + +# @leet end + diff --git a/src/exercises/3.longest-substring-without-repeating-characters.ts b/src/exercises/3.longest-substring-without-repeating-characters.ts new file mode 100644 index 0000000..3f0937f --- /dev/null +++ b/src/exercises/3.longest-substring-without-repeating-characters.ts @@ -0,0 +1,5 @@ +// @leet start +function lengthOfLongestSubstring(s: string): number { + +}; +// @leet end \ No newline at end of file diff --git a/src/exercises/3442.maximum-difference-between-even-and-odd-frequency-i.py b/src/exercises/3442.maximum-difference-between-even-and-odd-frequency-i.py new file mode 100644 index 0000000..afc3a5a --- /dev/null +++ b/src/exercises/3442.maximum-difference-between-even-and-odd-frequency-i.py @@ -0,0 +1,54 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def maxDifference(self, s: str) -> int: + record = Counter(s) + max_odd = 0 + min_even = float(inf) + + for i in record.values(): + if i % 2 == 0: + min_even = min(min_even, i) + elif i % 2 != 0: + max_odd = max(max_odd, i) + + return max_odd - min_even + + +# @leet end + diff --git a/src/exercises/3445.maximum-difference-between-even-and-odd-frequency-ii.py b/src/exercises/3445.maximum-difference-between-even-and-odd-frequency-ii.py new file mode 100644 index 0000000..234c2e8 --- /dev/null +++ b/src/exercises/3445.maximum-difference-between-even-and-odd-frequency-ii.py @@ -0,0 +1,40 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def maxDifference(self, s: str, k: int) -> int: + +# @leet end \ No newline at end of file diff --git a/src/exercises/35.search-insert-position.py b/src/exercises/35.search-insert-position.py new file mode 100644 index 0000000..cdcef3a --- /dev/null +++ b/src/exercises/35.search-insert-position.py @@ -0,0 +1,55 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * +# @leet imports end + +# @leet start +class Solution: + def searchInsert(self, nums: List[int], target: int) -> int: + if nums[-1] < target: + return len(nums) + mn = 0 + mx = len(nums) - 1 + + while mn < mx: + mid = (mx + mn) // 2 + if target > nums[mid]: + mn = mid + 1 + else: + mx = mid + + return mn + +# @leet end diff --git a/src/exercises/36.valid-sudoku.py b/src/exercises/36.valid-sudoku.py new file mode 100644 index 0000000..a88e058 --- /dev/null +++ b/src/exercises/36.valid-sudoku.py @@ -0,0 +1,98 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def isValidSudoku(self, board: List[List[str]]) -> bool: + rows = [{} for _ in range(len(board))] + square = [{} for _ in range(len(board))] + for i in range(len(board)): + cols = {} + for j in range(len(board[i])): + val = board[i][j] + if val != ".": + if val in cols: + return False + cols[val] = j + if val in rows[j]: + return False + rows[j][val] = i + if i < 3: + if j < 3: + if val in square[0]: + return False + square[0][val] = i + elif j > 2 and j < 6: + if val in square[1]: + return False + square[1][val] = i + elif j > 5: + if val in square[2]: + return False + square[2][val] = i + elif i > 2 and i < 6: + if j < 3: + if val in square[3]: + return False + square[3][val] = i + elif j > 2 and j < 6: + if val in square[4]: + return False + square[4][val] = i + elif j > 5: + if val in square[5]: + return False + square[5][val] = i + elif i > 5: + if j < 3: + if val in square[6]: + return False + square[6][val] = i + elif j > 2 and j < 6: + if val in square[7]: + return False + square[7][val] = i + elif j > 5: + if val in square[8]: + return False + square[8][val] = i + + + return True + + +# @leet end + diff --git a/src/exercises/383.ransom-note.py b/src/exercises/383.ransom-note.py new file mode 100644 index 0000000..334f2de --- /dev/null +++ b/src/exercises/383.ransom-note.py @@ -0,0 +1,66 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def canConstruct(self, ransomNote: str, magazine: str) -> bool: + def option1(): + d = {} + for s in ransomNote: + if s not in d: + d[s] = 1 + else: + d[s] += 1 + for m in magazine: + if m in d: + d[m] -= 1 + if d[m] == 0: + del d[m] + return len(d.keys()) == 0 + + def option2(): + r = Counter(ransomNote) + m = Counter(magazine) + return not(r - m) + + return option2() + + +# @leet end + diff --git a/src/exercises/392.is-subsequence.py b/src/exercises/392.is-subsequence.py new file mode 100644 index 0000000..8e4c8e5 --- /dev/null +++ b/src/exercises/392.is-subsequence.py @@ -0,0 +1,54 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def isSubsequence(self, s: str, t: str) -> bool: + i, j = 0, 0 + while j < len(s): + if i >= len(t): + break + if t[i] == s[j]: + j += 1 + i += 1 + + return j == len(s) + + +# @leet end diff --git a/src/exercises/4.median-of-two-sorted-arrays.py b/src/exercises/4.median-of-two-sorted-arrays.py new file mode 100644 index 0000000..d5cf985 --- /dev/null +++ b/src/exercises/4.median-of-two-sorted-arrays.py @@ -0,0 +1,30 @@ +class Solution: + def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float: + N1, N2 = nums1, nums2 + lt = len(N1) + len(N2) + half = lt // 2 + + if len(N1) > len(N2): + N1, N2 = N2, N1 + + l = 0 + h = len(N1) - 1 + while True: + midA = (l + h) // 2 + midB = half - midA - 2 + + aLeft = N1[midA] if midA >= 0 else float(-inf) + aRight = N1[midA + 1] if (midA + 1) < len(N1) else float(inf) + + bLeft = N2[midB] if midB >= 0 else float(-inf) + bRight = N2[midB + 1] if (midB + 1) < len(N2) else float(inf) + + if aLeft <= bRight and bLeft <= aRight: + if lt % 2 == 0: + return (min(bRight, aRight) + max(bLeft, aLeft)) / 2 + else: + return min(bRight, aRight) + if aLeft > bRight: + h = midA - 1 + else: + l = midA + 1 diff --git a/src/exercises/42.trapping-rain-water.py b/src/exercises/42.trapping-rain-water.py new file mode 100644 index 0000000..0cb4e20 --- /dev/null +++ b/src/exercises/42.trapping-rain-water.py @@ -0,0 +1,60 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def trap(self, height: List[int]) -> int: + i, j = 0, len(height) - 1 + c, m_l, m_r = 0, 0, 0 + while i < j: + if height[i] < height[j]: + if m_l < height[i]: + m_l = height[i] + if (m_l - height[i]) > 0: + c += m_l - height[i] + i += 1 + else: + if m_r < height[j]: + m_r = height[j] + if (m_r - height[j]) > 0: + c += m_r - height[j] + j -= 1 + + return c + + +# @leet end + diff --git a/src/exercises/45.jump-game-ii.py b/src/exercises/45.jump-game-ii.py new file mode 100644 index 0000000..21d4aa0 --- /dev/null +++ b/src/exercises/45.jump-game-ii.py @@ -0,0 +1,42 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * +# @leet imports end + +# @leet start +class Solution: + def jump(self, nums: List[int]) -> int: + +# @leet end \ No newline at end of file diff --git a/src/exercises/5.longest-palindromic-substring.py b/src/exercises/5.longest-palindromic-substring.py new file mode 100644 index 0000000..333bdf1 --- /dev/null +++ b/src/exercises/5.longest-palindromic-substring.py @@ -0,0 +1,66 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def longestPalindrome(self, s: str) -> str: + if len(s) <= 1: + return s + max_string = float(-inf) + ans = "" + i = 0 + + def checker(l, r, a, mx): + while l >= 0 and r < len(s) and s[l] == s[r]: + if (r - l + 1) > max_string: + a = s[l : r + 1] + mx = r - l + 1 + l -= 1 + r += 1 + return a, mx + + for i in range(len(s)): + ans, max_string = checker(i, i, ans, max_string) + ans, max_string = checker(i, i + 1, ans, max_string) + + return ans + + +# @leet end + diff --git a/src/exercises/50.powx-n.py b/src/exercises/50.powx-n.py new file mode 100644 index 0000000..cd87bb5 --- /dev/null +++ b/src/exercises/50.powx-n.py @@ -0,0 +1,53 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * +# @leet imports end + +# @leet start +class Solution: + def myPow(self, x: float, n: int) -> float: + if n == 0: + return 1 + def getP(xx, nn): + if nn == 1: return xx + h = getP(xx, nn // 2) + if nn % 2 == 0: + return h * h + else: + return xx * h * h + if n < 0: + return 1 / getP(x, abs(n)) + return getP(x, n) +# @leet end diff --git a/src/exercises/55.jump-game.py b/src/exercises/55.jump-game.py new file mode 100644 index 0000000..5158d77 --- /dev/null +++ b/src/exercises/55.jump-game.py @@ -0,0 +1,53 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def canJump(self, nums: List[int]) -> bool: + f = 0 + for i in range(len(nums)): + if f < i: + return False + f = nums[i] + i if nums[i] + i > f else f + + return True + + +# @leet end + diff --git a/src/exercises/6.zigzag-conversion.py b/src/exercises/6.zigzag-conversion.py new file mode 100644 index 0000000..e69de29 diff --git a/src/exercises/66.plus-one.py b/src/exercises/66.plus-one.py new file mode 100644 index 0000000..3812dfb --- /dev/null +++ b/src/exercises/66.plus-one.py @@ -0,0 +1,64 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def plusOne(self, digits: List[int]) -> List[int]: + def sumDigits(arr, con, i): + if i < 0: + arr.insert(0, con) + return arr + if con != None: + n = arr[i] + con + else: + n = arr[i] + 1 + if n < 10: + arr[i] = n + else: + ci = n % 10 + con = n // 10 + arr[i] = ci + return sumDigits(arr, con, i - 1) + return arr + + return sumDigits(digits, None, len(digits) - 1) + + +# @leet end + diff --git a/src/exercises/69.sqrtx.py b/src/exercises/69.sqrtx.py new file mode 100644 index 0000000..db3404c --- /dev/null +++ b/src/exercises/69.sqrtx.py @@ -0,0 +1,58 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet imports end + + +# @leet start +class Solution: + def mySqrt(self, x: int) -> int: + if x == 1: + return x + lw = 1 + lm = x + while lw < lm: + mid = (lw + lm) // 2 + s = mid**2 + if s <= x: + lw = mid + 1 + else: + lm = mid + return lw - 1 + + +# @leet end + diff --git a/src/exercises/7.reverse-integer.py b/src/exercises/7.reverse-integer.py new file mode 100644 index 0000000..e69de29 diff --git a/src/exercises/704.binary-search.py b/src/exercises/704.binary-search.py new file mode 100644 index 0000000..fb86982 --- /dev/null +++ b/src/exercises/704.binary-search.py @@ -0,0 +1,59 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def search(self, nums: List[int], target: int) -> int: + + def bin_search(low, high): + if low > high: + return -1 + mid = (high + low) // 2 + if nums[low] == target: + return low + if nums[high] == target: + return high + if nums[mid] == target: + return mid + if nums[mid] < target: + return bin_search(mid + 1, high) + if nums[mid] > target: + return bin_search(low, mid - 1) + + return bin_search(0, len(nums) - 1) + + + +# @leet end diff --git a/src/exercises/74.search-a-2d-matrix.py b/src/exercises/74.search-a-2d-matrix.py new file mode 100644 index 0000000..67e035b --- /dev/null +++ b/src/exercises/74.search-a-2d-matrix.py @@ -0,0 +1,79 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def searchMatrix(self, matrix: List[List[int]], target: int) -> bool: + def row_search(low, high): + if low > high: + return -1 + if matrix[low][0] <= target and target <= matrix[0][len(matrix[low]) - 1]: + return low + if matrix[high][0] <= target and target <= matrix[0][len(matrix[high]) - 1]: + return high + + mid = (low + high) // 2 + if matrix[mid][0] <= target and target <= matrix[mid][len(matrix[mid]) - 1]: + return mid + if matrix[mid][0] < target: + return row_search(mid + 1, high) + if matrix[mid][0] > target: + return row_search(low, mid - 1) + + row = row_search(0, len(matrix) - 1) + nums = matrix[row] + + def bin_search(low, high): + if low > high: + return -1 + mid = (high + low) // 2 + if nums[low] == target: + return low + if nums[high] == target: + return high + if nums[mid] == target: + return mid + if nums[mid] < target: + return bin_search(mid + 1, high) + if nums[mid] > target: + return bin_search(low, mid - 1) + + isValid = bin_search(0, len(nums) - 1) + return isValid != -1 + + +# @leet end + diff --git a/src/exercises/80.remove-duplicates-from-sorted-array-ii.py b/src/exercises/80.remove-duplicates-from-sorted-array-ii.py new file mode 100644 index 0000000..a8e153b --- /dev/null +++ b/src/exercises/80.remove-duplicates-from-sorted-array-ii.py @@ -0,0 +1,56 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * +# @leet imports end + +# @leet start +class Solution: + def removeDuplicates(self, nums: List[int]) -> int: + if not nums: + return 0 + if len(nums) <= 2: + return len(nums) + k = 2 + for i in range(2, len(nums)): + if nums[i] != nums[k - 1] or nums[i] != nums[k - 2]: + nums[k] = nums[i] + k += 1 + print(nums) + + return k + + + +# @leet end diff --git a/src/exercises/875.koko-eating-bananas.py b/src/exercises/875.koko-eating-bananas.py new file mode 100644 index 0000000..ac0c506 --- /dev/null +++ b/src/exercises/875.koko-eating-bananas.py @@ -0,0 +1,57 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def minEatingSpeed(self, piles: List[int], h: int) -> int: + def bs(val, low, high, len): + if low > high: + return val + mid = (low + high) // 2 + sum_v = 0 + for i in range(len): + sum_v += (piles[i] + mid - 1) // mid + if sum_v <= h: + min_val = min(val, mid) + return bs(min_val, low, mid - 1, len) + else: + return bs(val, mid + 1, high, len) + + return bs(float(inf), 1, max(piles), len(piles)) + + +# @leet end + diff --git a/src/exercises/88.merge-sorted-array.py b/src/exercises/88.merge-sorted-array.py new file mode 100644 index 0000000..2a4c362 --- /dev/null +++ b/src/exercises/88.merge-sorted-array.py @@ -0,0 +1,48 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None: + k = 0 + for i in range(m, len(nums1)): + nums1[i] = nums2[k] + k += 1 + nums1 = nums1.sort() + return nums1 + +# @leet end + diff --git a/src/exercises/89.gray-code.py b/src/exercises/89.gray-code.py new file mode 100644 index 0000000..7ff25cf --- /dev/null +++ b/src/exercises/89.gray-code.py @@ -0,0 +1,45 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def grayCode(self, n: int) -> List[int]: + return [i ^ (i >> 1) for i in range(1 << n)] + + + +# @leet end + diff --git a/src/exercises/9.palindrome-number.py b/src/exercises/9.palindrome-number.py new file mode 100644 index 0000000..281ce56 --- /dev/null +++ b/src/exercises/9.palindrome-number.py @@ -0,0 +1,51 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +class Solution: + def isPalindrome(self, x: int) -> bool: + i = 0 + n = str(x) + j = len(n) - 1 + while i < j: + if n[i] == n[j]: + i += 1 + j -= 1 + else: + return False + + return True + +# @leet end diff --git a/src/exercises/90.subsets-ii.py b/src/exercises/90.subsets-ii.py new file mode 100644 index 0000000..743bb8e --- /dev/null +++ b/src/exercises/90.subsets-ii.py @@ -0,0 +1,60 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + def subsetsWithDup(self, nums: List[int]) -> List[List[int]]: + res = [] + + nums.sort() + + def backtrack(start, path): + res.append(path[:]) + + for i in range(start, len(nums)): + if i > start and nums[i] == nums[i - 1]: + continue + + path.append(nums[i]) + backtrack(i + 1, path) + path.pop() + + backtrack(0, []) + return res + + +# @leet end + diff --git a/src/exercises/91.decode-ways.py b/src/exercises/91.decode-ways.py new file mode 100644 index 0000000..42071c1 --- /dev/null +++ b/src/exercises/91.decode-ways.py @@ -0,0 +1,57 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + + +# @leet start +class Solution: + @lru_cache(maxsize=None) + def getWordsCount(self, i, s) -> int: + if i == len(s): + return 1 + if s[i] == "0": + return 0 + if i == len(s) - 1: + return 1 + answer = self.getWordsCount(i + 1, s) + if int(s[i : i + 2]) < 27: + answer += self.getWordsCount(i + 2, s) + return answer + + def numDecodings(self, s: str) -> int: + return self.getWordsCount(0, s) + + +# @leet end + diff --git a/src/exercises/92.reverse-linked-list-ii.py b/src/exercises/92.reverse-linked-list-ii.py new file mode 100644 index 0000000..e72d50d --- /dev/null +++ b/src/exercises/92.reverse-linked-list-ii.py @@ -0,0 +1,45 @@ +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * + +# @leet start +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, val=0, next=None): +# self.val = val +# self.next = next +class Solution: + def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]: + +# @leet end \ No newline at end of file diff --git a/src/exercises/990.satisfiability-of-equality-equations.py b/src/exercises/990.satisfiability-of-equality-equations.py new file mode 100644 index 0000000..967ae80 --- /dev/null +++ b/src/exercises/990.satisfiability-of-equality-equations.py @@ -0,0 +1,42 @@ +# @leet imports start +from string import * +from re import * +from datetime import * +from collections import * +from heapq import * +from bisect import * +from copy import * +from math import * +from random import * +from statistics import * +from itertools import * +from functools import * +from operator import * +from io import * +from sys import * +from json import * +from builtins import * +import string +import re +import datetime +import collections +import heapq +import bisect +import copy +import math +import random +import statistics +import itertools +import functools +import operator +import io +import sys +import json +from typing import * +# @leet imports end + +# @leet start +class Solution: + def equationsPossible(self, equations: List[str]) -> bool: + +# @leet end \ No newline at end of file