refactor: moved to github actions, updated docs

Author: Nejc

.github/workflows/node.js.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [master, beta, next, develop]
+  pull_request:
+    branches: [master, beta, next, develop]
+
+jobs:
+  test:
+    name: Running tests...
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Installing
+      - run: npm install
+      - name: Test
+      - run: npm run validate
+
+      - name: Building docs
+      - run: npm run docz:build
+      - name: Deploy 🚀
+        uses: JamesIves/github-pages-deploy-action@3.5.9
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          BRANCH: gh-pages
+          FOLDER: .docz/dist

README.md

@@ -58,6 +58,11 @@ $ npm run start
 
 ```
 
+### Issues
+
+Sometimes npm has some issues with running docs. Try using yarn instead for installing the
+deps and running tasks.
+
 ## Docs & Examples
 
 Each algorithm is described on the docs website.

package.json

@@ -38,7 +38,7 @@
     "test:build": "jest --coverage --colors --silent && jest-coverage-badges",
     "test:watch": "jest --watch",
     "docz:clean": "rimraf .docz && docz clean",
-    "docz:dev": "npm run docz:clean && docz dev",
+    "docz:dev": "docz dev",
     "docz:build": "npm run docz:clean && docz build",
     "start": "npm run docz:dev",
     "validate": "npm run format && npm run lint && npm run test:build",

src/docs/Algorithms/Graph/FloydWarshall.mdx

@@ -6,17 +6,15 @@ menu: Graph
 
 # Floyd warshall
 
-Floyd–Warshall algorithm (also known as Floyd's algorithm, the Roy–Warshall
-algorithm, the Roy–Floyd algorithm, or the WFI algorithm) is an algorithm for
-finding shortest paths in a weighted graph with positive or negative edge
-weights (but with no negative cycles). A single execution of the algorithm will
-find the lengths (summed weights) of shortest paths between all pairs of
-vertices. Although it does not return details of the paths themselves, it is
-possible to reconstruct the paths with simple modifications to the algorithm.
-Versions of the algorithm can also be used for finding the transitive closure of
-a relation {\displaystyle R}R, or (in connection with the Schulze voting system)
-widest paths between all pairs of vertices in a weighted graph. [Source:
-Wikipedia]
+Floyd–Warshall algorithm (also known as Floyd's algorithm, the Roy–Warshall algorithm, the
+Roy–Floyd algorithm, or the WFI algorithm) is an algorithm for finding shortest paths in a
+weighted graph with positive or negative edge weights (but with no negative cycles). A
+single execution of the algorithm will find the lengths (summed weights) of shortest paths
+between all pairs of vertices. Although it does not return details of the paths
+themselves, it is possible to reconstruct the paths with simple modifications to the
+algorithm. Versions of the algorithm can also be used for finding the transitive closure
+of a relation R, or (in connection with the Schulze voting system) widest paths between
+all pairs of vertices in a weighted graph. [Source: Wikipedia]
 
 ![Floyd warshall](https://upload.wikimedia.org/wikipedia/commons/thumb/2/2e/Floyd-Warshall_example.svg/2880px-Floyd-Warshall_example.svg.png)
 

src/docs/Algorithms/Other/KnapsackProblem.mdx

@@ -1,6 +1,6 @@
 ---
 name: Knapsack problem
-route: /algorithms/graph/knapsack-problem
+route: /algorithms/other/knapsack-problem
 menu: Other
 ---
 

src/docs/Algorithms/Overview.mdx

@@ -125,8 +125,9 @@ typically to solve a class of problems or to perform a computation. (Source: Wik
   algorithm</Link>
 - `A` <Link className="link" to="/algorithms/graph/a-star-search-algorithm">A\* search
   algorithm</Link>
+  [[Code](https://github.com/nejcm/js-algorithms/blob/master/src/algorithms/graph/a-star-search-algorithm/index.ts)]
 
-**Other**
+**Math**
 
 - `B` <Link className="link" to="/algorithms/math/combinations">Combinations</Link>
   - With repetitions
@@ -140,7 +141,12 @@ typically to solve a class of problems or to perform a computation. (Source: Wik
     [[Code](https://github.com/nejcm/js-algorithms/blob/master/src/algorithms/math/permutations/withoutRepetitions.ts)]
 - `B` <Link className="link" to="/algorithms/math/factorial">Factorial</Link>
   [[Code](https://github.com/nejcm/js-algorithms/blob/master/src/algorithms/math/factorial/index.ts)]
-- Knapsack problem
+
+**Other**
+
+- `A` <Link className="link" to="/algorithms/other/knapsack-problem">Knapsack
+  problem</Link>
+  [[Code](https://github.com/nejcm/js-algorithms/blob/master/src/algorithms/other/factorial/index.ts)]
 - Hanoi tower
 - Knight tour
 - N-queens

src/docs/Algorithms/Searching/JumpSearch.mdx

@@ -6,15 +6,14 @@ menu: Searching
 
 # Jump search
 
-Like Binary Search, Jump Search is a searching algorithm for sorted arrays. The
-basic idea is to check fewer elements (than linear search) by jumping ahead by
-fixed steps or skipping some elements in place of searching all elements.
-
-For example, suppose we have an array arr[] of size n and block (to be jumped)
-size m. Then we search at the indexes arr[0], arr[m], arr[2m]…..arr[km] and so
-on. Once we find the interval (arr[km] < x < arr[(k+1)m]), we perform a linear
-search operation from the index km to find the element x. (Source:
-Geeksforgeeks)
+Like Binary Search, Jump Search is a searching algorithm for sorted arrays. The basic idea
+is to check fewer elements (than linear search) by jumping ahead by fixed steps or
+skipping some elements in place of searching all elements.
+
+For example, suppose we have an array arr[] of size n and block (to be jumped) size m.
+Then we search at the indexes arr[0], arr[m], arr[2m]…..arr[km] and so on. Once we find
+the interval (arr[km] < x < arr[(k+1)m]), we perform a linear search operation from the
+index km to find the element x. (Source: Geeksforgeeks)
 
 ![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/8/83/Jump_Search_Depiction.svg)