algorithm/javascript-algorithms
1
0
Fork 0
mirror of https://github.com/trekhleb/javascript-algorithms.git synced 2025-07-06 17:44:08 +08:00
Code Issues Packages Projects Releases Wiki Activity

"Italiano" is "italian" in italian :)

Browse Source
This commit is contained in:
Gianfranco P
2024-12-20 19:35:01 +00:00
committed by Oleksii Trekhleb
parent ae869ef3fa
commit 49e0814c43
1 changed files with 11 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
README.md
View File

@ -31,7 +31,7 @@ _Read this in other languages:_
[_Português_](README.pt-BR.md), [_Português_](README.pt-BR.md),
[_Русский_](README.ru-RU.md), [_Русский_](README.ru-RU.md),
[_Türkçe_](README.tr-TR.md), [_Türkçe_](README.tr-TR.md),
[_Italiana_](README.it-IT.md), [_Italiano_](README.it-IT.md),
[_Bahasa Indonesia_](README.id-ID.md), [_Bahasa Indonesia_](README.id-ID.md),
[_Українська_](README.uk-UA.md), [_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md), [_Arabic_](README.ar-AR.md),
@ -199,7 +199,7 @@ algorithm is an abstraction higher than a computer program.
* **Brute Force** - look at all the possibilities and selects the best solution * **Brute Force** - look at all the possibilities and selects the best solution
* `B` [Linear Search](src/algorithms/search/linear-search) * `B` [Linear Search](src/algorithms/search/linear-search)
* `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem * `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
* `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach the top
* `A` [Maximum Subarray](src/algorithms/sets/maximum-subarray) * `A` [Maximum Subarray](src/algorithms/sets/maximum-subarray)
* `A` [Travelling Salesman Problem](src/algorithms/graph/travelling-salesman) - shortest possible route that visits each city and returns to the origin city * `A` [Travelling Salesman Problem](src/algorithms/graph/travelling-salesman) - shortest possible route that visits each city and returns to the origin city
* `A` [Discrete Fourier Transform](src/algorithms/math/fourier-transform) - decompose a function of time (a signal) into the frequencies that make it up * `A` [Discrete Fourier Transform](src/algorithms/math/fourier-transform) - decompose a function of time (a signal) into the frequencies that make it up
@ -230,7 +230,7 @@ algorithm is an abstraction higher than a computer program.
* `B` [Jump Game](src/algorithms/uncategorized/jump-game) * `B` [Jump Game](src/algorithms/uncategorized/jump-game)
* `B` [Unique Paths](src/algorithms/uncategorized/unique-paths) * `B` [Unique Paths](src/algorithms/uncategorized/unique-paths)
* `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem * `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
* `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach the top
* `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - content-aware image resizing algorithm * `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - content-aware image resizing algorithm
* `A` [Levenshtein Distance](src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences * `A` [Levenshtein Distance](src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
* `A` [Longest Common Subsequence](src/algorithms/sets/longest-common-subsequence) (LCS) * `A` [Longest Common Subsequence](src/algorithms/sets/longest-common-subsequence) (LCS)
@ -243,9 +243,9 @@ algorithm is an abstraction higher than a computer program.
* `A` [Bellman-Ford Algorithm](src/algorithms/graph/bellman-ford) - finding the shortest path to all graph vertices * `A` [Bellman-Ford Algorithm](src/algorithms/graph/bellman-ford) - finding the shortest path to all graph vertices
* `A` [Floyd-Warshall Algorithm](src/algorithms/graph/floyd-warshall) - find the shortest paths between all pairs of vertices * `A` [Floyd-Warshall Algorithm](src/algorithms/graph/floyd-warshall) - find the shortest paths between all pairs of vertices
* `A` [Regular Expression Matching](src/algorithms/string/regular-expression-matching) * `A` [Regular Expression Matching](src/algorithms/string/regular-expression-matching)
* **Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generate next solution you test * **Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generate the next solution, you test
if it satisfies all conditions, and only then continue generating subsequent solutions. Otherwise, backtrack, and go on a if it satisfies all conditions and only then continue generating subsequent solutions. Otherwise, backtrack and go on a
different path of finding a solution. Normally the DFS traversal of state-space is being used. different path to finding a solution. Normally the DFS traversal of state-space is being used.
* `B` [Jump Game](src/algorithms/uncategorized/jump-game) * `B` [Jump Game](src/algorithms/uncategorized/jump-game)
* `B` [Unique Paths](src/algorithms/uncategorized/unique-paths) * `B` [Unique Paths](src/algorithms/uncategorized/unique-paths)
* `B` [Power Set](src/algorithms/sets/power-set) - all subsets of a set * `B` [Power Set](src/algorithms/sets/power-set) - all subsets of a set
@ -255,8 +255,8 @@ different path of finding a solution. Normally the DFS traversal of state-space
* `A` [Combination Sum](src/algorithms/sets/combination-sum) - find all combinations that form specific sum * `A` [Combination Sum](src/algorithms/sets/combination-sum) - find all combinations that form specific sum
* **Branch & Bound** - remember the lowest-cost solution found at each stage of the backtracking * **Branch & Bound** - remember the lowest-cost solution found at each stage of the backtracking
search, and use the cost of the lowest-cost solution found so far as a lower bound on the cost of search, and use the cost of the lowest-cost solution found so far as a lower bound on the cost of
a least-cost solution to the problem, in order to discard partial solutions with costs larger than the a least-cost solution to the problem in order to discard partial solutions with costs larger than the
lowest-cost solution found so far. Normally BFS traversal in combination with DFS traversal of state-space lowest-cost solution found so far. Normally, BFS traversal in combination with DFS traversal of state-space
tree is being used. tree is being used.
## How to use this repository ## How to use this repository
@ -296,14 +296,14 @@ rm -rf ./node_modules
npm i npm i
``` ```
Also make sure that you're using a correct Node version (`>=16`). If you're using [nvm](https://github.com/nvm-sh/nvm) for Node version management you may run `nvm use` from the root folder of the project and the correct version will be picked up. Also, make sure that you're using the correct Node version (`>=16`). If you're using [nvm](https://github.com/nvm-sh/nvm) for Node version management you may run `nvm use` from the root folder of the project and the correct version will be picked up.
**Playground** **Playground**
You may play with data-structures and algorithms in `./src/playground/playground.js` file and write You may play with data-structures and algorithms in `./src/playground/playground.js` file and write
tests for it in `./src/playground/__test__/playground.test.js`. tests for it in `./src/playground/__test__/playground.test.js`.
Then just simply run the following command to test if your playground code works as expected: Then just, simply run the following command to test if your playground code works as expected:
``` ```
npm test -- 'playground' npm test -- 'playground'
@ -319,7 +319,7 @@ npm test -- 'playground'
### Big O Notation ### Big O Notation
*Big O notation* is used to classify algorithms according to how their running time or space requirements grow as the input size grows. *Big O notation* is used to classify algorithms according to how their running time or space requirements grow as the input size grows.
On the chart below you may find most common orders of growth of algorithms specified in Big O notation. On the chart below, you may find the most common orders of growth of algorithms specified in Big O notation.
![Big O graphs](./assets/big-o-graph.png) ![Big O graphs](./assets/big-o-graph.png)