Merge branch 'master' into add-trapping-water

Author: kgolder92

.prettierrc

@@ -0,0 +1,15 @@
+{
+  "arrowParens": "always",
+  "bracketSpacing": true,
+  "endOfLine": "lf",
+  "insertPragma": false,
+  "printWidth": 80,
+  "proseWrap": "preserve",
+  "quoteProps": "as-needed",
+  "requirePragma": false,
+  "semi": false,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "none",
+  "useTabs": false
+}

back-tracking/KnightTour.js renamed to Backtracking/KnightTour.js

@@ -0,0 +1,21 @@
+/**
+ * Transcipher a ROT13 cipher
+ * @param  {String} text - string to be encrypted
+ * @return {String} - decrypted string
+ */
+const transcipher = (text) => {
+  const originalCharacterList = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+  const toBeMappedCharaterList = 'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm'
+  const index = x => originalCharacterList.indexOf(x)
+  const replace = x => index(x) > -1 ? toBeMappedCharaterList[index(x)] : x
+  return text.split('').map(replace).join('')
+}
+
+(() => {
+  const messageToBeEncrypted = 'The quick brown fox jumps over the lazy dog'
+  console.log(`Original Text = "${messageToBeEncrypted}"`)
+  const rot13CipheredText = transcipher(messageToBeEncrypted)
+  console.log(`Ciphered Text = "${rot13CipheredText}"`)
+  const rot13DecipheredText = transcipher(rot13CipheredText)
+  console.log(`Deciphered Text = "${rot13DecipheredText}"`)
+})()

back-tracking/NQueen.js renamed to Backtracking/NQueen.js

@@ -1,11 +1,14 @@
-function binaryToDeicmal (binaryNumber) {
+const binaryToDecimal = (binaryString) => {
   let decimalNumber = 0
-  const binaryDigits = binaryNumber.split('').reverse() // Splits the binary number into reversed single digits
+  const binaryDigits = binaryString.split('').reverse() // Splits the binary number into reversed single digits
   binaryDigits.forEach((binaryDigit, index) => {
     decimalNumber += binaryDigit * (Math.pow(2, index)) // Summation of all the decimal converted digits
   })
-  console.log(`Decimal of ${binaryNumber} is ${decimalNumber}`)
+  console.log(`Decimal of ${binaryString} is ${decimalNumber}`)
+  return decimalNumber
 }
 
-binaryToDeicmal('111001')
-binaryToDeicmal('101')
+(() => {
+  binaryToDecimal('111001')
+  binaryToDecimal('101')
+})()

back-tracking/Sudoku.js renamed to Backtracking/Sudoku.js

@@ -1,7 +1,7 @@
 function hexStringToRGB (hexString) {
-  var r = (hexString.substring(1, 3)).toUpperCase()
-  var g = hexString.substring(3, 5).toUpperCase()
-  var b = hexString.substring(5, 7).toUpperCase()
+  var r = hexString.substring(0, 2)
+  var g = hexString.substring(2, 4)
+  var b = hexString.substring(4, 6)
 
   r = parseInt(r, 16)
   g = parseInt(g, 16)
@@ -11,4 +11,4 @@ function hexStringToRGB (hexString) {
   return obj
 }
 
-console.log(hexStringToRGB('javascript rock !!'))
+console.log(hexStringToRGB('ffffff'))

Ciphers/ROT13.js

@@ -0,0 +1,16 @@
+function RGBToHex (r, g, b) {
+  if (
+    typeof r !== 'number' ||
+    typeof g !== 'number' ||
+    typeof b !== 'number'
+  ) {
+    throw new TypeError('argument is not a Number')
+  }
+
+  const toHex = n => (n || '0').toString(16).padStart(2, '0')
+
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`
+}
+
+console.log(RGBToHex(255, 255, 255) === '#ffffff')
+console.log(RGBToHex(255, 99, 71) === '#ff6347')

Conversions/BinaryToDecimal.js

@@ -0,0 +1,32 @@
+/**
+ * A LinkedList based solution for Detect a Cycle in a list
+ * https://en.wikipedia.org/wiki/Cycle_detection
+ */
+
+function main () {
+  /*
+  Problem Statement:
+  Given head, the head of a linked list, determine if the linked list has a cycle in it.
+
+  Note:
+  * While Solving the problem in given link below, don't use main() function.
+  * Just use only the code inside main() function.
+  * The purpose of using main() function here is to aviod global variables.
+
+  Link for the Problem: https://leetcode.com/problems/linked-list-cycle/
+  */
+  const head = '' // Reference to head is given in the problem. So please ignore this line
+  let fast = head
+  let slow = head
+
+  while (fast != null && fast.next != null && slow != null) {
+    fast = fast.next.next
+    slow = slow.next
+    if (fast === slow) {
+      return true
+    }
+  }
+  return false
+}
+
+main()

Conversions/HexToRGB.js

@@ -0,0 +1,45 @@
+/**
+ * A LinkedList based solution for Rotating a List to the right by k places
+ */
+
+function main () {
+  /*
+  Problem Statement:
+  Given a linked list, rotate the list to the right by k places, where k is non-negative.
+
+  Note:
+  * While Solving the problem in given link below, don't use main() function.
+  * Just use only the code inside main() function.
+  * The purpose of using main() function here is to aviod global variables.
+
+  Link for the Problem: https://leetcode.com/problems/rotate-list/
+  */
+  // Reference to both head and k is given in the problem. So please ignore below two lines
+  let head = ''
+  let k = ''
+  let i = 0
+  let current = head
+  while (current) {
+    i++
+    current = current.next
+  }
+  k %= i
+  current = head
+  let prev = null
+  while (k--) {
+    if (!current || !current.next) {
+      return current
+    } else {
+      while (current.next) {
+        prev = current
+        current = current.next
+      }
+      prev.next = current.next
+      current.next = head
+      head = current
+    }
+  }
+  return head
+}
+
+main()

Conversions/RGBToHex.js

@@ -0,0 +1,97 @@
+class Node {
+  constructor (data, next = null) {
+    this.data = data
+    this.next = next
+  }
+}
+
+class SinglyCircularLinkedList {
+  constructor () {
+    this.head = null
+    this.size = 0
+  }
+
+  insert (data) {
+    const node = new Node(data)
+
+    if (!this.head) {
+      node.next = node
+      this.head = node
+      this.size++
+    } else {
+      node.next = this.head
+
+      let current = this.head
+
+      while (current.next.data !== this.head.data) {
+        current = current.next
+      }
+
+      current.next = node
+      this.size++
+    }
+  }
+
+  insertAt (index, data) {
+    const node = new Node(data)
+
+    if (index < 0 || index > this.size) return
+
+    if (index === 0) {
+      this.head = node
+      this.size = 1
+      return
+    }
+
+    let previous
+    let count = 0
+    let current = this.head
+
+    while (count < index) {
+      previous = current
+      current = current.next
+      count++
+    }
+
+    node.next = current
+    previous.next = node
+    this.size++
+  }
+
+  remove () {
+    if (!this.head) return
+
+    let prev
+    let current = this.head
+
+    while (current.next !== this.head) {
+      prev = current
+      current = current.next
+    }
+
+    prev.next = this.head
+    this.size--
+  }
+
+  printData () {
+    let count = 0
+    let current = this.head
+
+    while (current !== null && count !== this.size) {
+      console.log(current.data + '\n')
+      current = current.next
+      count++
+    }
+  }
+}
+
+const ll = new SinglyCircularLinkedList()
+
+ll.insert(10)
+ll.insert(20)
+ll.insert(30)
+ll.insert(40)
+ll.insert(50)
+ll.insertAt(5, 60)
+ll.remove(5)
+ll.printData()

DIRECTORY.md

@@ -0,0 +1,26 @@
+/*
+ * You are climbing a stair case. It takes n steps to reach to the top.
+ * Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+*/
+
+const climbStairs = (n) => {
+  let prev = 0
+  let cur = 1
+  let temp
+
+  for (let i = 0; i < n; i++) {
+    temp = prev
+    prev = cur
+    cur += temp
+  }
+  return cur
+}
+
+const main = () => {
+  const number = 5
+
+  console.log('Number of ways to climb ' + number + ' stairs in ' + climbStairs(5))
+}
+
+// testing
+main()

Data-Structures/Linked-List/CycleDetection.js

@@ -0,0 +1,61 @@
+/*
+Wikipedia -> https://en.wikipedia.org/wiki/Edit_distance
+
+Q. -> Given two strings `word1` and `word2`. You can perform these operations on any of the string to make both strings similar.
+    - Insert
+    - Remove
+    - Replace
+Find the minimum operation cost required to make both same. Each operation cost is 1.
+
+Algorithm details ->
+time complexity - O(n*m)
+space complexity - O(n*m)
+*/
+
+const minimumEditDistance = (word1, word2) => {
+  const n = word1.length
+  const m = word2.length
+  const dp = new Array(m + 1).fill(0).map(item => [])
+
+  /*
+    fill dp matrix with default values -
+        - first row is filled considering no elements in word2.
+        - first column filled considering no elements in word1.
+    */
+
+  for (let i = 0; i < n + 1; i++) {
+    dp[0][i] = i
+  }
+
+  for (let i = 0; i < m + 1; i++) {
+    dp[i][0] = i
+  }
+
+  /*
+        indexing is 1 based for dp matrix as we defined some known values at first row and first column/
+    */
+
+  for (let i = 1; i < m + 1; i++) {
+    for (let j = 1; j < n + 1; j++) {
+      const letter1 = word1[j - 1]
+      const letter2 = word2[i - 1]
+
+      if (letter1 === letter2) {
+        dp[i][j] = dp[i - 1][j - 1]
+      } else {
+        dp[i][j] = Math.min(dp[i - 1][j], dp[i - 1][j - 1], dp[i][j - 1]) + 1
+      }
+    }
+  }
+
+  return dp[m][n]
+}
+
+const main = () => {
+  console.log(minimumEditDistance('horse', 'ros'))
+  console.log(minimumEditDistance('cat', 'cut'))
+  console.log(minimumEditDistance('', 'abc'))
+  console.log(minimumEditDistance('google', 'glgool'))
+}
+
+main()

Data-Structures/Linked-List/RotateListRight.js

@@ -0,0 +1,18 @@
+//  https://en.wikipedia.org/wiki/Fibonacci_number
+
+const fibonacci = (N) => {
+  // creating array to store values
+  const memo = new Array(N + 1)
+  memo[0] = 0
+  memo[1] = 1
+  for (let i = 2; i <= N; i++) {
+    memo[i] = memo[i - 1] + memo[i - 2]
+  }
+  return memo[N]
+}
+
+// testing
+(() => {
+  const number = 5
+  console.log(number + 'th Fibonacci number is ' + fibonacci(number))
+})()