[_Português_](README.pt-BR.md),

[_Русский_](README.ru-RU.md),

[_Türkçe_](README.tr-TR.md),

[_Italiana_](README.it-IT.md),

[_Italiano_](README.it-IT.md),

[_Bahasa Indonesia_](README.id-ID.md),

[_Українська_](README.uk-UA.md),

[_Arabic_](README.ar-AR.md),

***Brute Force** - look at all the possibilities and selects the best solution

*`B`[Linear Search](src/algorithms/search/linear-search)

*`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 reachtothe 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`[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

*`B`[Jump Game](src/algorithms/uncategorized/jump-game)

*`B`[Unique Paths](src/algorithms/uncategorized/unique-paths)

*`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 reachtothe 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

*`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`[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`[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

if it satisfies all conditions, and only then continue generating subsequent solutions. Otherwise, backtrack, and go on a

different pathof finding a solution. Normally the DFS traversal of state-space is being used.

***Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generatethenext solution, you test

if it satisfies all conditions and only then continue generating subsequent solutions. Otherwise, backtrack and go on a

different pathto finding a solution. Normally the DFS traversal of state-space is being used.

*`B`[Jump Game](src/algorithms/uncategorized/jump-game)

*`B`[Unique Paths](src/algorithms/uncategorized/unique-paths)

*`B`[Power Set](src/algorithms/sets/power-set) - all subsets of a set

*`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

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

lowest-cost solution found so far. Normally BFS traversal in combination with DFS traversal of state-space

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

tree is being used.

Also make sure that you're usinga 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 usingthe 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**

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`.

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:

*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.