SYMBOL INDEX (618 symbols across 186 files)

FILE: .github/workflows/UpdateDirectory.js
  function pathPrefix (line 5) | function pathPrefix (i) {
  function printPath (line 10) | function printPath (oldPath, newPath, output) {
  function pathsToMarkdown (line 26) | function pathsToMarkdown (filePaths) {

FILE: Backtracking/AllCombinationsOfSizeK.js
  function generateCombinations (line 1) | function generateCombinations(n, k) {

FILE: Backtracking/KnightTour.js
  class OpenKnightTour (line 3) | class OpenKnightTour {
    method constructor (line 4) | constructor(size) {
    method getMoves (line 10) | getMoves([i, j]) {
    method isComplete (line 29) | isComplete() {
    method solve (line 34) | solve() {
    method solveHelper (line 44) | solveHelper([i, j], curr) {
    method printBoard (line 60) | printBoard(output = (value) => console.log(value)) {

FILE: Backtracking/MColoringProblem.js
  function mColoring (line 8) | function mColoring(graph, m) {

FILE: Backtracking/NQueens.js
  class NQueens (line 1) | class NQueens {
    method constructor (line 2) | constructor(size) {
    method isValid (line 11) | isValid([row, col]) {
    method placeQueen (line 32) | placeQueen(row, col) {
    method removeQueen (line 36) | removeQueen(row, col) {
    method solve (line 40) | solve(col = 0) {
    method printBoard (line 57) | printBoard(output = (value) => console.log(value)) {

FILE: Backtracking/RatInAMaze.js
  function validateGrid (line 24) | function validateGrid(grid) {
  function isSafe (line 40) | function isSafe(grid, x, y) {
  function getPathPart (line 55) | function getPathPart(grid, x, y, solution, path) {
  function getPath (line 96) | function getPath(grid) {
  class RatInAMaze (line 114) | class RatInAMaze {
    method constructor (line 115) | constructor(grid) {

FILE: Backtracking/Sudoku.js
  class Sudoku (line 1) | class Sudoku {
    method constructor (line 3) | constructor(board) {
    method findEmptyCell (line 7) | findEmptyCell() {
    method check (line 17) | check([y, x], value) {
    method solve (line 41) | solve() {
    method getSection (line 59) | getSection(row, [start, end]) {
    method printBoard (line 63) | printBoard(output = (...v) => console.log(...v)) {

FILE: Bit-Manipulation/BinaryCountSetBits.js
  function BinaryCountSetBits (line 10) | function BinaryCountSetBits(a) {

FILE: Bit-Manipulation/GenerateSubSets.js
  function generateSubSets (line 9) | function generateSubSets(inputArray) {

FILE: Bit-Manipulation/GrayCodes.js
  function generateGrayCodes (line 25) | function generateGrayCodes(n) {

FILE: Cache/LFUCache.js
  class CacheNode (line 1) | class CacheNode {
    method constructor (line 2) | constructor(key, value, frequency) {
  class FrequencyMap (line 12) | class FrequencyMap extends Map {
    method refresh (line 25) | refresh(node) {
    method insert (line 40) | insert(node) {
  method [Symbol.species] (line 13) | static get [Symbol.species]() {
  method [Symbol.toStringTag] (line 16) | get [Symbol.toStringTag]() {
  class LFUCache (line 51) | class LFUCache {
    method constructor (line 59) | constructor(capacity) {
    method capacity (line 73) | get capacity() {
    method size (line 81) | get size() {
    method capacity (line 88) | set capacity(newCapacity) {
    method info (line 102) | get info() {
    method leastFrequency (line 112) | get leastFrequency() {
    method #removeCacheNode (line 124) | #removeCacheNode() {
    method has (line 138) | has(key) {
    method get (line 150) | get(key) {
    method set (line 174) | set(key, value, frequency = 1) {
    method parse (line 209) | parse(json) {
    method clear (line 228) | clear() {
    method toString (line 241) | toString(indent) {

FILE: Cache/LRUCache.js
  class LRUCache (line 1) | class LRUCache {
    method constructor (line 9) | constructor(capacity) {
    method info (line 22) | get info() {
    method size (line 31) | get size() {
    method capacity (line 35) | get capacity() {
    method capacity (line 39) | set capacity(newCapacity) {
    method #removeLeastRecentlyUsed (line 58) | #removeLeastRecentlyUsed() {
    method has (line 66) | has(key) {
    method set (line 76) | set(key, value) {
    method get (line 90) | get(key) {
    method parse (line 112) | parse(json) {
    method toString (line 129) | toString(indent) {

FILE: Cellular-Automata/ConwaysGameOfLife.js
  function newGeneration (line 14) | function newGeneration(cells) {

FILE: Cellular-Automata/Elementary.js
  function getNextElementaryGeneration (line 67) | function getNextElementaryGeneration(generation, rule) {

FILE: Ciphers/AffineCipher.js
  function mod (line 16) | function mod(n, m) {
  function inverseMod (line 26) | function inverseMod(a, m) {
  function isCorrectFormat (line 39) | function isCorrectFormat(str, a, b) {
  function findCharIndex (line 60) | function findCharIndex(char) {
  function encrypt (line 72) | function encrypt(str, a, b) {
  function decrypt (line 91) | function decrypt(str, a, b) {

FILE: Ciphers/KeyFinder.js
  function keyFinder (line 6) | function keyFinder(str) {
  function caesarCipherEncodeAndDecodeEngine (line 67) | function caesarCipherEncodeAndDecodeEngine(inStr, numShifted) {

FILE: Ciphers/KeywordShiftedAlphabet.js
  function checkKeywordValidity (line 48) | function checkKeywordValidity(keyword) {
  function getEncryptedAlphabet (line 58) | function getEncryptedAlphabet(keyword) {
  function translate (line 68) | function translate(sourceAlphabet, targetAlphabet, message) {
  function checkInputs (line 81) | function checkInputs(keyword, message) {
  function encrypt (line 91) | function encrypt(keyword, message) {
  function decrypt (line 100) | function decrypt(keyword, message) {

FILE: Ciphers/ROT13.js
  function ROT13 (line 8) | function ROT13(str) {

FILE: Ciphers/VigenereCipher.js
  function isLetter (line 6) | function isLetter(str) {
  function isUpperCase (line 15) | function isUpperCase(character) {
  function encrypt (line 30) | function encrypt(message, key) {
  function decrypt (line 61) | function decrypt(message, key) {

FILE: Compression/RLE.js
  function Compress (line 9) | function Compress(str) {
  function Decompress (line 26) | function Decompress(str) {

FILE: Conversions/ArrayBufferToBase64.js
  function bufferToBase64 (line 8) | function bufferToBase64(binaryData) {

FILE: Conversions/Base64ToArrayBuffer.js
  function base64ToBuffer (line 8) | function base64ToBuffer(b64) {

FILE: Conversions/BinaryToDecimal.js
  function binaryToDecimal (line 1) | function binaryToDecimal(binaryString) {

FILE: Conversions/DecimalToBinary.js
  function decimalToBinary (line 1) | function decimalToBinary(num) {

FILE: Conversions/DecimalToHex.js
  function intToHex (line 1) | function intToHex(num) {
  function decimalToHex (line 19) | function decimalToHex(num) {

FILE: Conversions/DecimalToOctal.js
  function decimalToOctal (line 1) | function decimalToOctal(num) {

FILE: Conversions/DecimalToRoman.js
  function decimalToRoman (line 41) | function decimalToRoman(num) {

FILE: Conversions/HexToDecimal.js
  function hexToInt (line 1) | function hexToInt(hexNum) {
  function hexToDecimal (line 26) | function hexToDecimal(hexNum) {

FILE: Conversions/HexToRGB.js
  function hexStringToRGB (line 1) | function hexStringToRGB(hexString) {

FILE: Conversions/OctToDecimal.js
  function octalToDecimal (line 1) | function octalToDecimal(num) {

FILE: Conversions/RGBToHex.js
  function RGBToHex (line 1) | function RGBToHex(r, g, b) {

FILE: Conversions/RgbHsvConversion.js
  function hsvToRgb (line 19) | function hsvToRgb(hue, saturation, value) {
  function rgbToHsv (line 48) | function rgbToHsv(red, green, blue) {
  function approximatelyEqualHsv (line 84) | function approximatelyEqualHsv(hsv1, hsv2) {
  function getRgbBySection (line 92) | function getRgbBySection(

FILE: Conversions/RomanToDecimal.js
  function romanToDecimal (line 11) | function romanToDecimal(romanNumber) {

FILE: Data-Structures/Array/QuickSelect.js
  function QuickSelect (line 14) | function QuickSelect(items, kth) {
  function RandomizedSelect (line 22) | function RandomizedSelect(items, left, right, i) {
  function RandomizedPartition (line 34) | function RandomizedPartition(items, left, right) {
  function Partition (line 40) | function Partition(items, left, right) {
  function getRandomInt (line 56) | function getRandomInt(min, max) {
  function Swap (line 60) | function Swap(arr, x, y) {

FILE: Data-Structures/Graph/Graph.js
  class Graph (line 1) | class Graph {
    method constructor (line 2) | constructor() {
    method addVertex (line 6) | addVertex(vertex) {
    method containsVertex (line 10) | containsVertex(vertex) {
    method addEdge (line 14) | addEdge(vertex1, vertex2) {
    method printGraph (line 21) | printGraph(output = (value) => console.log(value)) {
    method bfs (line 37) | bfs(source, output = (value) => console.log(value)) {
    method dfs (line 60) | dfs(source, visited = new Set(), output = (value) => console.log(value...

FILE: Data-Structures/Graph/Graph2.js
  class Graph (line 2) | class Graph {
    method constructor (line 5) | constructor(noOfVertices) {
    method addVertex (line 20) | addVertex(v) {
    method addEdge (line 28) | addEdge(v, w) {
    method printGraph (line 39) | printGraph(output = (value) => console.log(value)) {

FILE: Data-Structures/Graph/Graph3.js
  class Graph (line 1) | class Graph {
    method constructor (line 2) | constructor() {
    method addVertex (line 6) | addVertex(vertex) {
    method addEdge (line 10) | addEdge(vertex1, vertex2) {
    method removeEdge (line 15) | removeEdge(vertex1, vertex2) {
    method removeVertex (line 24) | removeVertex(vertex) {
    method DFS (line 34) | DFS(start) {
    method DFSIterative (line 59) | DFSIterative(start) {
    method BFS (line 83) | BFS(start) {

FILE: Data-Structures/Heap/BinaryHeap.js
  class BinaryHeap (line 8) | class BinaryHeap {
    method constructor (line 14) | constructor(comparatorFunction) {
    method insert (line 32) | insert(value) {
    method size (line 41) | size() {
    method empty (line 49) | empty() {
    method #bubbleUp (line 58) | #bubbleUp(currIdx) {
    method #sinkDown (line 76) | #sinkDown(currIdx) {
    method peek (line 101) | peek() {
    method extractTop (line 109) | extractTop() {
    method #swap (line 127) | #swap(index1, index2) {

FILE: Data-Structures/Heap/KeyPriorityQueue.js
  class KeyPriorityQueue (line 25) | class KeyPriorityQueue {
    method constructor (line 27) | constructor() {
    method isEmpty (line 36) | isEmpty() {
    method push (line 45) | push(key, priority) {
    method pop (line 55) | pop() {
    method contains (line 68) | contains(key) {
    method update (line 78) | update(key, priority) {
    method _getPriorityOrInfinite (line 98) | _getPriorityOrInfinite(position) {
    method _shiftUp (line 105) | _shiftUp(position) {
    method _shiftDown (line 121) | _shiftDown(position) {
    method _swap (line 148) | _swap(position1, position2) {

FILE: Data-Structures/Heap/MinPriorityQueue.js
  class MinPriorityQueue (line 13) | class MinPriorityQueue {
    method constructor (line 15) | constructor(c) {
    method insert (line 23) | insert(key) {
    method peek (line 39) | peek() {
    method isEmpty (line 44) | isEmpty() {
    method isFull (line 49) | isFull() {
    method print (line 54) | print(output = (value) => console.log(value)) {
    method heapReverse (line 61) | heapReverse() {
    method sink (line 80) | sink() {
    method delete (line 112) | delete() {

FILE: Data-Structures/Linked-List/AddTwoNumbers.js
  class AddTwoNumbers (line 16) | class AddTwoNumbers {
    method constructor (line 17) | constructor() {
    method solution (line 21) | solution(firstList, secondList) {
    method solutionToArray (line 47) | solutionToArray() {

FILE: Data-Structures/Linked-List/CycleDetection.js
  function detectCycle (line 6) | function detectCycle(head) {

FILE: Data-Structures/Linked-List/CycleDetectionII.js
  function findCycleStart (line 8) | function findCycleStart(head) {
  function cycleLength (line 46) | function cycleLength(head) {

FILE: Data-Structures/Linked-List/DoublyLinkedList.js
  class Node (line 1) | class Node {
    method constructor (line 2) | constructor(element) {
  class DoubleLinkedList (line 9) | class DoubleLinkedList {
    method constructor (line 10) | constructor() {
    method append (line 17) | append(element) {
    method insert (line 33) | insert(position, element) {
    method removeAt (line 77) | removeAt(position) {
    method indexOf (line 117) | indexOf(elm) {
    method isPresent (line 136) | isPresent(elm) {
    method delete (line 141) | delete(elm) {
    method deleteHead (line 146) | deleteHead() {
    method deleteTail (line 151) | deleteTail() {
    method toString (line 156) | toString() {
    method toArray (line 169) | toArray() {
    method isEmpty (line 182) | isEmpty() {
    method size (line 187) | size() {
    method getHead (line 192) | getHead() {
    method getTail (line 197) | getTail() {
    method iterator (line 202) | iterator() {
    method log (line 217) | log() {

FILE: Data-Structures/Linked-List/MergeTwoSortedLinkedLists.js
  function mergeLinkedLists (line 18) | function mergeLinkedLists(list1, list2) {

FILE: Data-Structures/Linked-List/ReverseSinglyLinkedList.js
  class ReverseSinglyLinkedList (line 3) | class ReverseSinglyLinkedList {
    method solution (line 4) | solution(head) {

FILE: Data-Structures/Linked-List/SinglyCircularLinkedList.js
  class SinglyCircularLinkedList (line 4) | class SinglyCircularLinkedList {
    method constructor (line 5) | constructor() {
    method initiateNodeAndIndex (line 18) | initiateNodeAndIndex() {
    method getElementAt (line 23) | getElementAt(index) {
    method addAtFirst (line 35) | addAtFirst(data) {
    method add (line 44) | add(data) {
    method insertAt (line 58) | insertAt(index, data) {
    method indexOf (line 72) | indexOf(data) {
    method remove (line 87) | remove() {
    method removeFirst (line 97) | removeFirst() {
    method removeAt (line 112) | removeAt(index) {
    method removeData (line 125) | removeData(data) {
    method printData (line 132) | printData(output = (value) => console.log(value)) {
    method get (line 143) | get() {
    method clear (line 154) | clear() {

FILE: Data-Structures/Linked-List/SinglyLinkedList.js
  class Node (line 11) | class Node {
    method constructor (line 12) | constructor(data) {
  class LinkedList (line 18) | class LinkedList {
    method constructor (line 19) | constructor(listOfValues) {
    method initiateNodeAndIndex (line 32) | initiateNodeAndIndex() {
    method size (line 37) | size() {
    method head (line 42) | head() {
    method tail (line 47) | tail() {
    method isEmpty (line 52) | isEmpty() {
    method addLast (line 57) | addLast(element) {
    method addFirst (line 71) | addFirst(element) {
    method removeFirst (line 85) | removeFirst() {
    method removeLast (line 102) | removeLast() {
    method remove (line 121) | remove(element) {
    method indexOf (line 147) | indexOf(element) {
    method elementAt (line 161) | elementAt(index) {
    method addAt (line 174) | addAt(index, element) {
    method removeAt (line 199) | removeAt(index) {
    method findMiddle (line 219) | findMiddle() {
    method clean (line 232) | clean() {
    method get (line 239) | get() {
    method rotateListRight (line 250) | rotateListRight(k) {
    method iterator (line 271) | iterator() {
    method log (line 285) | log() {
    method reverse (line 290) | reverse() {

FILE: Data-Structures/Queue/CircularQueue.js
  class CircularQueue (line 6) | class CircularQueue {
    method constructor (line 7) | constructor(maxLength) {
    method enqueue (line 15) | enqueue(value) {
    method dequeue (line 29) | dequeue() {
    method checkEmpty (line 47) | checkEmpty() {
    method checkSingleelement (line 53) | checkSingleelement() {
    method checkOverflow (line 61) | checkOverflow() {
    method display (line 72) | display(output = (value) => console.log(value)) {
    method length (line 79) | length() {
    method peek (line 84) | peek() {

FILE: Data-Structures/Queue/Queue.js
  class Queue (line 9) | class Queue {
    method constructor (line 12) | constructor() {
    method length (line 20) | get length() {
    method enqueue (line 29) | enqueue(data) {
    method dequeue (line 47) | dequeue() {
    method peekFirst (line 69) | peekFirst() {
    method peekLast (line 81) | peekLast() {
    method toArray (line 93) | toArray() {
    method isEmpty (line 109) | isEmpty() {

FILE: Data-Structures/Queue/QueueUsing2Stacks.js
  class Queue (line 4) | class Queue {
    method constructor (line 5) | constructor() {
    method enqueue (line 11) | enqueue(item) {
    method dequeue (line 15) | dequeue() {

FILE: Data-Structures/Stack/EvaluateExpression.js
  function evaluatePostfixExpression (line 8) | function evaluatePostfixExpression(expression) {

FILE: Data-Structures/Stack/Stack.js
  class Stack (line 11) | class Stack {
    method constructor (line 12) | constructor() {
    method push (line 20) | push(value) {
    method pop (line 26) | pop() {
    method size (line 38) | size() {
    method peek (line 43) | peek() {
    method view (line 48) | view(output = (value) => console.log(value)) {

FILE: Data-Structures/Stack/StackES6.js
  class Stack (line 12) | class Stack {
    method constructor (line 13) | constructor() {
    method push (line 19) | push(newValue) {
    method pop (line 25) | pop() {
    method length (line 34) | get length() {
    method isEmpty (line 39) | get isEmpty() {
    method last (line 44) | get last() {
    method isStack (line 52) | static isStack(el) {

FILE: Data-Structures/Tree/AVLTree.js
  function comparator (line 18) | function comparator() {
  class AVLTree (line 34) | class AVLTree {
    method constructor (line 35) | constructor(comp) {
    method add (line 54) | add(_val) {
    method find (line 65) | find(_val) {
    method remove (line 77) | remove(_val) {
  class Node (line 85) | class Node {
    method constructor (line 86) | constructor(val) {

FILE: Data-Structures/Tree/BinarySearchTree.js
  class Node (line 16) | class Node {
    method constructor (line 17) | constructor(val) {
    method search (line 24) | search(val) {
    method visit (line 36) | visit(output = (value) => console.log(value)) {
    method addNode (line 50) | addNode(n) {
    method removeNode (line 67) | removeNode(val) {
  class Tree (line 112) | class Tree {
    method constructor (line 113) | constructor() {
    method traverse (line 119) | traverse(output = (value) => console.log(value)) {
    method search (line 128) | search(val) {
    method addValue (line 141) | addValue(val) {
    method removeValue (line 151) | removeValue(val) {

FILE: Data-Structures/Tree/SegmentTree.js
  class SegmentTree (line 13) | class SegmentTree {
    method constructor (line 16) | constructor(arr) {
    method build (line 31) | build(arr) {
    method update (line 48) | update(index, value) {
    method query (line 68) | query(left, right) {

FILE: Data-Structures/Tree/Trie.js
  class TrieNode (line 1) | class TrieNode {
    method constructor (line 2) | constructor(key, parent) {
  class Trie (line 14) | class Trie {
    method constructor (line 15) | constructor() {
    method findAllWords (line 21) | static findAllWords(root, word, output) {
    method insert (line 36) | insert(word) {
    method findPrefix (line 54) | findPrefix(word) {
    method remove (line 67) | remove(word, count) {
    method findAllWords (line 106) | findAllWords(prefix) {
    method contains (line 116) | contains(word) {
    method findOccurrences (line 123) | findOccurrences(word) {

FILE: Data-Structures/Vectors/Vector2.js
  class Vector2 (line 8) | class Vector2 {
    method constructor (line 9) | constructor(x, y) {
    method equalsExactly (line 20) | equalsExactly(vector) {
    method equalsApproximately (line 31) | equalsApproximately(vector, epsilon) {
    method length (line 43) | length() {
    method normalize (line 52) | normalize() {
    method add (line 66) | add(vector) {
    method subtract (line 78) | subtract(vector) {
    method multiply (line 90) | multiply(scalar) {
    method distance (line 102) | distance(vector) {
    method dotProduct (line 113) | dotProduct(vector) {
    method rotate (line 123) | rotate(angleInRadians) {
    method angleBetween (line 137) | angleBetween(vector) {

FILE: Dynamic-Programming/FindMonthCalendar.js
  class Month (line 8) | class Month {
    method constructor (line 9) | constructor() {
    method printCal (line 17) | printCal(days, startDay, output = (value) => console.log(value)) {
    method parseDate (line 40) | parseDate(date) {
    method isGreater (line 58) | isGreater(startDate, endDate) {
    method getDayDiff (line 71) | getDayDiff(startDate, endDate) {
    method generateMonthCal (line 100) | generateMonthCal(date) {

FILE: Dynamic-Programming/KadaneAlgo.js
  function kadaneAlgo (line 12) | function kadaneAlgo(array) {

FILE: Dynamic-Programming/LevenshteinDistance.js
  function minimum (line 10) | function minimum(a, b, c) {
  function costOfSubstitution (line 20) | function costOfSubstitution(x, y) {
  function calculateLevenshteinDp (line 25) | function calculateLevenshteinDp(x, y) {

FILE: Dynamic-Programming/LongestCommonSubsequence.js
  function longestCommonSubsequence (line 30) | function longestCommonSubsequence(str1, str2) {

FILE: Dynamic-Programming/LongestIncreasingSubsequence.js
  function longestIncreasingSubsequence (line 7) | function longestIncreasingSubsequence(x) {

FILE: Dynamic-Programming/MaxNonAdjacentSum.js
  function maximumNonAdjacentSum (line 1) | function maximumNonAdjacentSum(nums) {

FILE: Dynamic-Programming/MaxProductOfThree.js
  function maxProductOfThree (line 8) | function maxProductOfThree(arrayItems) {

FILE: Dynamic-Programming/NumberOfSubsetEqualToGivenSum.js
  function NumberOfSubsetSum (line 9) | function NumberOfSubsetSum(array, sum) {

FILE: Dynamic-Programming/RodCutting.js
  function rodCut (line 6) | function rodCut(prices, n) {

FILE: Dynamic-Programming/Shuf.js
  function shuf (line 6) | function shuf(datasetSource, sampleSize) {
  function fillBaseSample (line 19) | function fillBaseSample(datasetSource, sampleSize) {
  function randomizeOutputFromDataset (line 61) | function randomizeOutputFromDataset(datasetSource, output) {

FILE: Dynamic-Programming/SieveOfEratosthenes.js
  function sieveOfEratosthenes (line 8) | function sieveOfEratosthenes(n) {

FILE: Dynamic-Programming/Sliding-Window/LongestSubstringWithoutRepeatingCharacters.js
  function LongestSubstringWithoutRepeatingCharacters (line 13) | function LongestSubstringWithoutRepeatingCharacters(s) {

FILE: Dynamic-Programming/Sliding-Window/PermutationinString.js
  function PermutationinString (line 15) | function PermutationinString(s1, s2) {
  function equals (line 38) | function equals(a, b) {
  function SetHash (line 42) | function SetHash() {

FILE: Dynamic-Programming/tests/MaxProductOfThree.test.js
  function completeMaxThree (line 24) | function completeMaxThree(array) {

FILE: Geometry/Circle.js
  class Circle (line 7) | class Circle {
    method constructor (line 8) | constructor(radius) {

FILE: Geometry/Cone.js
  class Cone (line 8) | class Cone {
    method constructor (line 9) | constructor(baseRadius, height) {

FILE: Geometry/ConvexHullGraham.js
  function compare (line 9) | function compare(a, b) {
  function orientation (line 15) | function orientation(a, b, c) {
  function convexHull (line 28) | function convexHull(points) {

FILE: Geometry/Pyramid.js
  class Pyramid (line 8) | class Pyramid {
    method constructor (line 9) | constructor(bsl, height) {

FILE: Geometry/Sphere.js
  class Sphere (line 7) | class Sphere {
    method constructor (line 8) | constructor(radius) {

FILE: Graphs/BellmanFord.js
  function BellmanFord (line 28) | function BellmanFord(graph, V, E, src, dest) {

FILE: Graphs/BinaryLifting.js
  class BinaryLifting (line 12) | class BinaryLifting {
    method constructor (line 13) | constructor(root, tree) {
    method addNode (line 24) | addNode(node) {
    method addEdge (line 29) | addEdge(node1, node2) {
    method dfs (line 41) | dfs(node, parent) {
    method kthAncestor (line 56) | kthAncestor(node, k) {
  function binaryLifting (line 72) | function binaryLifting(root, tree, queries) {

FILE: Graphs/BreadthFirstSearch.js
  function breadthFirstSearch (line 12) | function breadthFirstSearch(graph, startingNode) {

FILE: Graphs/BreadthFirstShortestPath.js
  function breadthFirstShortestPath (line 11) | function breadthFirstShortestPath(graph, startNode, targetNode) {

FILE: Graphs/ConnectedComponents.js
  class GraphUnweightedUndirectedAdjacencyList (line 1) | class GraphUnweightedUndirectedAdjacencyList {
    method constructor (line 3) | constructor() {
    method addNode (line 7) | addNode(node) {
    method addEdge (line 12) | addEdge(node1, node2) {
    method DFSComponent (line 24) | DFSComponent(components, node, visited) {
    method connectedComponents (line 42) | connectedComponents() {

FILE: Graphs/Density.js
  function density (line 6) | function density(numberOfNodes, numberOfEdges, isDirected = false) {

FILE: Graphs/DepthFirstSearchIterative.js
  class GraphUnweightedUndirected (line 1) | class GraphUnweightedUndirected {
    method constructor (line 3) | constructor() {
    method addNode (line 7) | addNode(node) {
    method addEdge (line 12) | addEdge(node1, node2) {
    method DFSIterative (line 24) | DFSIterative(node, value) {

FILE: Graphs/DepthFirstSearchRecursive.js
  class GraphUnweightedUndirected (line 1) | class GraphUnweightedUndirected {
    method constructor (line 3) | constructor() {
    method addNode (line 7) | addNode(node) {
    method addEdge (line 12) | addEdge(node1, node2) {
    method DFSRecursive (line 24) | DFSRecursive(node, value, visited = new Set()) {

FILE: Graphs/Dijkstra.js
  function createGraph (line 9) | function createGraph(V, E) {
  function djikstra (line 23) | function djikstra(graph, V, src) {

FILE: Graphs/DijkstraSmallestPath.js
  function solve (line 2) | function solve(graph, s) {

FILE: Graphs/Kosaraju.js
  class Kosaraju (line 11) | class Kosaraju {
    method constructor (line 12) | constructor(graph) {
    method addNode (line 23) | addNode(node) {
    method addEdge (line 30) | addEdge(node1, node2) {
    method dfsTopoSort (line 42) | dfsTopoSort(node, visited) {
    method topoSort (line 50) | topoSort() {
    method dfsKosaraju (line 59) | dfsKosaraju(node, visited) {
    method kosaraju (line 69) | kosaraju() {
  function kosaraju (line 83) | function kosaraju(graph) {

FILE: Graphs/KruskalMST.js
  class DisjointSetTreeNode (line 1) | class DisjointSetTreeNode {
    method constructor (line 3) | constructor(key) {
  class DisjointSetTree (line 10) | class DisjointSetTree {
    method constructor (line 12) | constructor() {
    method makeSet (line 17) | makeSet(x) {
    method findSet (line 22) | findSet(x) {
    method union (line 30) | union(x, y) {
    method link (line 35) | link(x, y) {
  class GraphWeightedUndirectedAdjacencyList (line 48) | class GraphWeightedUndirectedAdjacencyList {
    method constructor (line 50) | constructor() {
    method addNode (line 55) | addNode(node) {
    method addEdge (line 61) | addEdge(node1, node2, weight) {
    method KruskalMST (line 73) | KruskalMST() {

FILE: Graphs/LCABinaryLifting.js
  class LCABinaryLifting (line 11) | class LCABinaryLifting extends BinaryLifting {
    method constructor (line 12) | constructor(root, tree) {
    method dfsDepth (line 19) | dfsDepth(node, parent) {
    method getLCA (line 29) | getLCA(node1, node2) {
  function lcaBinaryLifting (line 51) | function lcaBinaryLifting(root, tree, queries) {

FILE: Graphs/NodeNeighbors.js
  class Graph (line 3) | class Graph {
    method constructor (line 5) | constructor() {
    method addEdge (line 9) | addEdge(node1, node2) {
    method nodeNeighbors (line 17) | nodeNeighbors(node) {

FILE: Graphs/PrimMST.js
  class GraphWeightedUndirectedAdjacencyList (line 2) | class GraphWeightedUndirectedAdjacencyList {
    method constructor (line 4) | constructor() {
    method addNode (line 8) | addNode(node) {
    method addEdge (line 13) | addEdge(node1, node2, weight) {
    method PrimMST (line 25) | PrimMST(start) {

FILE: Hashes/MD5.js
  function chunkify (line 36) | function chunkify(array, size) {
  function rotateLeft (line 54) | function rotateLeft(bits, turns) {
  function u8ToU32 (line 64) | function u8ToU32(u8Array) {
  function u32ToU8 (line 85) | function u32ToU8(u32Array) {
  function padEnd (line 104) | function padEnd(u8Array, size) {
  function preProcess (line 118) | function preProcess(message) {
  function MD5 (line 153) | function MD5(message) {

FILE: Hashes/SHA1.js
  constant CHAR_SIZE (line 9) | const CHAR_SIZE = 8
  function pad (line 21) | function pad(str, bits) {
  function chunkify (line 39) | function chunkify(str, size) {
  function rotateLeft (line 57) | function rotateLeft(bits, turns) {
  function preProcess (line 67) | function preProcess(message) {
  function SHA1 (line 98) | function SHA1(message) {

FILE: Hashes/SHA256.js
  constant CHAR_SIZE (line 9) | const CHAR_SIZE = 8
  function pad (line 35) | function pad(str, bits) {
  function chunkify (line 53) | function chunkify(str, size) {
  function rotateRight (line 71) | function rotateRight(bits, turns) {
  function preProcess (line 81) | function preProcess(message) {
  function SHA256 (line 112) | function SHA256(message) {

FILE: Hashes/tests/MD5.test.js
  function hexMD5 (line 9) | function hexMD5(message) {

FILE: Maths/AliquotSum.js
  function aliquotSum (line 14) | function aliquotSum(input) {

FILE: Maths/CircularArc.js
  function circularArcLength (line 12) | function circularArcLength(radius, degrees) {
  function circularArcArea (line 24) | function circularArcArea(radius, degrees) {

FILE: Maths/CollatzSequence.js
  function collatz (line 16) | function collatz(n) {

FILE: Maths/DecimalExpansion.js
  function decExp (line 23) | function decExp(a, b, base = 10, exp = [], d = {}, dlen = 0) {

FILE: Maths/EulerMethod.js
  function eulerStep (line 11) | function eulerStep(xCurrent, stepSize, yCurrent, differentialEquation) {
  function eulerFull (line 16) | function eulerFull(

FILE: Maths/ExponentialFunction.js
  function exponentialFunction (line 9) | function exponentialFunction(power, n) {

FILE: Maths/FareyApproximation.js
  function fareyApproximation (line 28) | function fareyApproximation(decimal, repeat = 20) {

FILE: Maths/FindMaxRecursion.js
  function findMaxRecursion (line 17) | function findMaxRecursion(arr, left, right) {

FILE: Maths/FriendlyNumbers.js
  function abundancyIndex (line 26) | function abundancyIndex(number) {
  function sumDivisors (line 30) | function sumDivisors(number) {

FILE: Maths/GetEuclidGCD.js
  function CheckInput (line 1) | function CheckInput(a, b) {
  function GetEuclidGCD (line 13) | function GetEuclidGCD(a, b) {
  function GetEuclidGCDRecursive (line 31) | function GetEuclidGCDRecursive(a, b) {

FILE: Maths/JugglerSequence.js
  function jugglerSequence (line 13) | function jugglerSequence(n) {

FILE: Maths/LucasSeries.js
  function lucas (line 16) | function lucas(index) {

FILE: Maths/Mandelbrot.js
  function getRGBData (line 30) | function getRGBData(
  function blackAndWhiteColorMap (line 83) | function blackAndWhiteColorMap(distance) {
  function colorCodedColorMap (line 95) | function colorCodedColorMap(distance) {
  function getDistance (line 140) | function getDistance(figureX, figureY, maxStep) {

FILE: Maths/MeanAbsoluteDeviation.js
  function meanAbsoluteDeviation (line 9) | function meanAbsoluteDeviation(data) {

FILE: Maths/MidpointIntegration.js
  function integralEvaluation (line 20) | function integralEvaluation(N, a, b, func) {

FILE: Maths/ModularArithmetic.js
  class ModRing (line 10) | class ModRing {
    method constructor (line 11) | constructor(MOD) {

FILE: Maths/Polynomial.js
  class Polynomial (line 11) | class Polynomial {
    method constructor (line 12) | constructor(array) {
    method construct (line 21) | construct() {
    method display (line 44) | display() {
    method evaluate (line 52) | evaluate(value) {

FILE: Maths/ShorsAlgorithm.js
  function ShorsAlgorithm (line 25) | function ShorsAlgorithm(num) {
  function findP (line 64) | function findP(A, B) {
  function isValidP (line 78) | function isValidP(A, B, p) {
  function gcd (line 90) | function gcd(A, B) {

FILE: Maths/SieveOfEratosthenes.js
  function sieveOfEratosthenes (line 13) | function sieveOfEratosthenes(max) {

FILE: Maths/Signum.js
  function signum (line 17) | function signum(input) {

FILE: Maths/SimpsonIntegration.js
  function integralEvaluation (line 24) | function integralEvaluation(N, a, b, func) {

FILE: Maths/SquareRoot.js
  function sqrt (line 9) | function sqrt(num, precision = 4) {

FILE: Maths/SumOfDigits.js
  function sumOfDigitsUsingString (line 12) | function sumOfDigitsUsingString(number) {
  function sumOfDigitsUsingLoop (line 25) | function sumOfDigitsUsingLoop(number) {
  function sumOfDigitsUsingRecursion (line 40) | function sumOfDigitsUsingRecursion(number) {

FILE: Maths/SumOfGeometricProgression.js
  function sumOfGeometricProgression (line 19) | function sumOfGeometricProgression(firstTerm, commonRatio, numOfTerms) {

FILE: Maths/isPalindromeIntegerNumber.js
  function isPalindromeIntegerNumber (line 9) | function isPalindromeIntegerNumber(x) {

FILE: Maths/test/EulerMethod.manual-test.js
  function plotLine (line 3) | function plotLine(label, points, width, height) {
  function exampleEquation1 (line 38) | function exampleEquation1(x, y) {
  function exampleEquation2 (line 43) | function exampleEquation2(x, y) {
  function exampleEquation3 (line 48) | function exampleEquation3(x, y) {

FILE: Maths/test/WhileLoopFactorial.test.js
  function testFactorial (line 3) | function testFactorial(n, expected) {

FILE: Maths/test/ZellersCongruenceAlgorithm.test.js
  function testZeller (line 3) | function testZeller(day, month, year, expected) {

FILE: Project-Euler/Problem002.js
  constant SQ5 (line 2) | const SQ5 = 5 ** 0.5 // Square root of 5
  constant PHI (line 3) | const PHI = (1 + SQ5) / 2 // definition of PHI

FILE: Project-Euler/Problem011.js
  function largestProductInAGrid (line 32) | function largestProductInAGrid(arr) {
  function get (line 53) | function get(arr, y, x) {

FILE: Project-Euler/Problem013.js
  function largeSum (line 5) | function largeSum(bignum) {

FILE: Project-Euler/Problem019.js
  function problem19 (line 21) | function problem19() {

FILE: Project-Euler/Problem021.js
  function problem21 (line 17) | function problem21(n) {

FILE: Project-Euler/Problem023.js
  function sumOfNonAbundantNumbers (line 22) | function sumOfNonAbundantNumbers(n = 28123) {
  function isAbundant (line 54) | function isAbundant(number) {

FILE: Project-Euler/Problem025.js
  function fibonacciIndex (line 31) | function fibonacciIndex(t = 1000) {

FILE: Project-Euler/Problem028.js
  function problem28 (line 20) | function problem28(dim) {

FILE: Project-Euler/Problem035.js
  function problem35 (line 14) | function problem35(n) {

FILE: Project-Euler/Problem044.js
  function problem44 (line 14) | function problem44(k) {
  function isPentagonal (line 40) | function isPentagonal(n) {

FILE: Recursive/FloodFill.js
  function isInside (line 23) | function isInside(rgbData, location) {
  function checkLocation (line 29) | function checkLocation(rgbData, location) {
  function breadthFirstSearch (line 52) | function breadthFirstSearch(
  function depthFirstSearch (line 76) | function depthFirstSearch(
  function breadthFirstFill (line 96) | function breadthFirstFill(
  function depthFirstFill (line 122) | function depthFirstFill(rgbData, location, targetColor, replacementColor) {

FILE: Recursive/KochSnowflake.js
  class Vector2 (line 17) | class Vector2 {
    method constructor (line 18) | constructor(x, y) {
    method add (line 29) | add(vector) {
    method subtract (line 41) | subtract(vector) {
    method multiply (line 53) | multiply(scalar) {
    method rotate (line 65) | rotate(angleInDegrees) {
  function iterate (line 84) | function iterate(initialVectors, steps) {
  function iterationStep (line 102) | function iterationStep(vectors) {

FILE: Recursive/KochSnowflake.manual-test.js
  function getKochSnowflake (line 10) | function getKochSnowflake(canvasWidth = 600, steps = 5) {
  function drawToCanvas (line 40) | function drawToCanvas(vectors, canvasWidth, canvasHeight) {

FILE: Recursive/TowerOfHanoi.js
  function TowerOfHanoi (line 4) | function TowerOfHanoi(n, from, to, aux, output = []) {

FILE: Recursive/test/FloodFill.test.js
  function testBreadthFirst (line 46) | function testBreadthFirst(
  function testDepthFirst (line 66) | function testDepthFirst(
  function generateTestRgbData (line 82) | function generateTestRgbData() {

FILE: Search/BinarySearch.js
  function binarySearchRecursive (line 10) | function binarySearchRecursive(arr, x, low = 0, high = arr.length - 1) {
  function binarySearchIterative (line 31) | function binarySearchIterative(arr, x, low = 0, high = arr.length - 1) {

FILE: Search/ExponentialSearch.js
  function binarySearch (line 12) | function binarySearch(arr, value, floor, ceiling) {
  function exponentialSearch (line 34) | function exponentialSearch(arr, length, value) {

FILE: Search/InterpolationSearch.js
  function interpolationSearch (line 12) | function interpolationSearch(arr, key) {

FILE: Search/LinearSearch.js
  function SearchArray (line 9) | function SearchArray(searchNum, ar, output = (v) => console.log(v)) {
  function Search (line 19) | function Search(theArray, key) {

FILE: Search/QuickSelectSearch.js
  function quickSelectSearch (line 14) | function quickSelectSearch(array, k) {

FILE: Search/RabinKarp.js
  constant BASE (line 16) | const BASE = 256 // The number of characters in the alphabet
  constant MOD (line 17) | const MOD = 997 // A prime number used for the hash function
  function rabinKarpSearch (line 19) | function rabinKarpSearch(text, pattern) {
  function hash (line 56) | function hash(str, length) {

FILE: Search/SlidingWindow.js
  function slidingWindow (line 23) | function slidingWindow(arr, num) {

FILE: Search/StringSearch.js
  function makeTable (line 5) | function makeTable(str) {
  function stringSearch (line 38) | function stringSearch(str, word) {

FILE: Search/TernarySearch.js
  function ternarySearchRecursive (line 14) | function ternarySearchRecursive(arr, key, low = 0, high = arr.length - 1) {
  function ternarySearchIterative (line 50) | function ternarySearchIterative(arr, key, low = 0, high = arr.length - 1) {

FILE: Search/UnionFind.js
  function UnionFind (line 17) | function UnionFind(n, key) {

FILE: Sliding-Windows/LongestSubarrayWithSumAtMost.js
  function longestSubarrayWithSumAtMost (line 8) | function longestSubarrayWithSumAtMost(arr, target) {

FILE: Sliding-Windows/MaxSumSubarrayFixed.js
  function maxSumSubarrayFixed (line 9) | function maxSumSubarrayFixed(arr, k) {

FILE: Sorts/BeadSort.js
  function beadSort (line 11) | function beadSort(sequence) {

FILE: Sorts/BinaryInsertionSort.js
  function binarySearch (line 21) | function binarySearch(array, key, start, end) {
  function binaryInsertionSort (line 51) | function binaryInsertionSort(array) {

FILE: Sorts/BogoSort.js
  function isSorted (line 4) | function isSorted(array) {
  function shuffle (line 17) | function shuffle(array) {
  function bogoSort (line 33) | function bogoSort(items) {

FILE: Sorts/BubbleSort.js
  function bubbleSort (line 19) | function bubbleSort(items) {
  function alternativeBubbleSort (line 46) | function alternativeBubbleSort(arr) {

FILE: Sorts/BucketSort.js
  function bucketSort (line 20) | function bucketSort(list, size) {

FILE: Sorts/CocktailShakerSort.js
  function cocktailShakerSort (line 11) | function cocktailShakerSort(items) {

FILE: Sorts/CombSort.js
  function combSort (line 25) | function combSort(list) {

FILE: Sorts/CycleSort.js
  function cycleSort (line 17) | function cycleSort(list) {

FILE: Sorts/DutchNationalFlagSort.js
  function dutchNationalFlagSort (line 10) | function dutchNationalFlagSort(nums) {

FILE: Sorts/FlashSort.js
  function flashSort (line 9) | function flashSort(arr) {

FILE: Sorts/GnomeSort.js
  function gnomeSort (line 6) | function gnomeSort(items) {

FILE: Sorts/HeapSort.js
  function heapSort (line 36) | function heapSort(items) {

FILE: Sorts/HeapSortV2.js
  function heapRoot (line 5) | function heapRoot(input, i) {
  function swap (line 24) | function swap(input, indexA, indexB) {
  function heapSort (line 28) | function heapSort(input) {

FILE: Sorts/InsertionSort.js
  function insertionSort (line 8) | function insertionSort(unsortedList) {
  function insertionSortAlternativeImplementation (line 41) | function insertionSortAlternativeImplementation(array) {

FILE: Sorts/IntroSort.js
  function introsort (line 18) | function introsort(array, compare) {
  function demo1 (line 250) | function demo1() {
  function demo2 (line 282) | function demo2() {

FILE: Sorts/MergeSort.js
  function merge (line 18) | function merge(list1, list2) {
  function mergeSort (line 40) | function mergeSort(list) {

FILE: Sorts/OddEvenSort.js
  function swap (line 10) | function swap(arr, i, j) {
  function oddEvenSort (line 16) | function oddEvenSort(arr) {

FILE: Sorts/PancakeSort.js
  function flipArray (line 29) | function flipArray(array, startIndex, endIndex) {
  function findMax (line 52) | function findMax(array, startIndex, endIndex) {
  function pancakeSort (line 70) | function pancakeSort(array) {

FILE: Sorts/PigeonHoleSort.js
  function pigeonHoleSort (line 9) | function pigeonHoleSort(arr) {

FILE: Sorts/QuickSort.js
  function quickSort (line 8) | function quickSort(items) {

FILE: Sorts/RadixSort.js
  function radixSort (line 7) | function radixSort(items, RADIX) {

FILE: Sorts/ShellSort.js
  function shellSort (line 6) | function shellSort(items) {

FILE: Sorts/StoogeSort.js
  function stoogeSort (line 7) | function stoogeSort(items, leftEnd, rightEnd) {

FILE: Sorts/SwapSort.js
  function minSwapsToSort (line 11) | function minSwapsToSort(items) {

FILE: Sorts/TopologicalSort.js
  function TopologicalSorter (line 1) | function TopologicalSorter() {

FILE: String/DiceCoefficient.js
  function mapBigrams (line 11) | function mapBigrams(string) {
  function countCommonBigrams (line 23) | function countCommonBigrams(bigrams, string) {
  function diceCoefficient (line 33) | function diceCoefficient(stringA, stringB) {

FILE: String/IsPalindrome.js
  function isPalindromeIterative (line 19) | function isPalindromeIterative(x) {

FILE: String/ReverseString.js
  function ReverseStringIterative (line 4) | function ReverseStringIterative(string) {

FILE: String/ZFunction.js
  function zFunction (line 11) | function zFunction(text) {

FILE: Timing-Functions/IntervalTimer.js
  class IntervalTimer (line 8) | class IntervalTimer {
    method constructor (line 15) | constructor(interval = 10, callBack = () => {}) {
    method startTimer (line 29) | startTimer() {
    method resetTimer (line 37) | resetTimer() {
    method getElapsedTime (line 46) | getElapsedTime(offset = 0) {
    method getRunTime (line 55) | getRunTime() {

FILE: Timing-Functions/ParseDate.js
  function checkDate (line 3) | function checkDate(date) {
  function parseDate (line 9) | function parseDate(dateString) {

FILE: Trees/BreadthFirstTreeTraversal.js
  class Node (line 6) | class Node {
    method constructor (line 7) | constructor(data) {
  class BinaryTree (line 14) | class BinaryTree {
    method constructor (line 15) | constructor() {
    method breadthFirstIterative (line 19) | breadthFirstIterative() {
    method breadthFirstRecursive (line 37) | breadthFirstRecursive() {
    method getHeight (line 47) | getHeight(node) {
    method traverseLevel (line 56) | traverseLevel(node, levelRemaining, traversal) {

FILE: Trees/DepthFirstSearch.js
  function traverseDFS (line 8) | function traverseDFS(tree, rootValue) {
  function searchDFS (line 27) | function searchDFS(tree, value) {

FILE: Trees/FenwickTree.js
  class FenwickTree (line 7) | class FenwickTree {
    method constructor (line 8) | constructor(feneickArray, array, n) {
    method update (line 17) | update(feneickArray, n, index, value) {
    method getPrefixSum (line 25) | getPrefixSum(feneickArray, index) {