diff --git a/Conversions/RailwayTimeConversion.js b/Conversions/RailwayTimeConversion.js
index 15f837b0da..b499023223 100644
--- a/Conversions/RailwayTimeConversion.js
+++ b/Conversions/RailwayTimeConversion.js
@@ -24,8 +24,8 @@ const RailwayTimeConversion = (timeString) => {
const [hour, minute, secondWithShift] = timeString.split(':')
// split second and shift value.
const [second, shift] = [
- secondWithShift.substr(0, 2),
- secondWithShift.substr(2)
+ secondWithShift.substring(0, 2),
+ secondWithShift.substring(2)
]
// convert shifted time to not-shift time(Railway time) by using the above explanation.
if (shift === 'PM') {
diff --git a/Data-Structures/Array/Reverse.js b/Data-Structures/Array/Reverse.js
index 79a789c017..ca08f35f8a 100644
--- a/Data-Structures/Array/Reverse.js
+++ b/Data-Structures/Array/Reverse.js
@@ -7,11 +7,9 @@
const Reverse = (arr) => {
// limit specifies the amount of Reverse actions
- for (let i = 0, j = arr.length - 1; i < arr.length / 2; i++, j--) {
- const temp = arr[i]
- arr[i] = arr[j]
- arr[j] = temp
- }
+ for (let i = 0, j = arr.length - 1; i < arr.length / 2; i++, j--)
+ [arr[i], arr[j]] = [arr[j], arr[i]]
+
return arr
}
export { Reverse }
diff --git a/Data-Structures/Stack/Stack.js b/Data-Structures/Stack/Stack.js
index d3001e8020..d8531fdebf 100644
--- a/Data-Structures/Stack/Stack.js
+++ b/Data-Structures/Stack/Stack.js
@@ -8,8 +8,8 @@
// Functions: push, pop, peek, view, length
// Creates a stack constructor
-const Stack = (function () {
- function Stack() {
+class Stack {
+ constructor() {
// The top of the Stack
this.top = 0
// The array representation of the stack
@@ -17,13 +17,13 @@ const Stack = (function () {
}
// Adds a value onto the end of the stack
- Stack.prototype.push = function (value) {
+ push(value) {
this.stack[this.top] = value
this.top++
}
// Removes and returns the value at the end of the stack
- Stack.prototype.pop = function () {
+ pop() {
if (this.top === 0) {
return 'Stack is Empty'
}
@@ -35,23 +35,21 @@ const Stack = (function () {
}
// Returns the size of the stack
- Stack.prototype.size = function () {
+ size() {
return this.top
}
// Returns the value at the end of the stack
- Stack.prototype.peek = function () {
+ peek() {
return this.stack[this.top - 1]
}
// To see all the elements in the stack
- Stack.prototype.view = function (output = (value) => console.log(value)) {
+ view(output = (value) => console.log(value)) {
for (let i = 0; i < this.top; i++) {
output(this.stack[i])
}
}
-
- return Stack
-})()
+}
export { Stack }
diff --git a/Data-Structures/Tree/AVLTree.js b/Data-Structures/Tree/AVLTree.js
index e5abbf3e55..dd673a9330 100644
--- a/Data-Structures/Tree/AVLTree.js
+++ b/Data-Structures/Tree/AVLTree.js
@@ -31,8 +31,8 @@ let utils
* @argument comp - A function used by AVL Tree For Comparison
* If no argument is sent it uses utils.comparator
*/
-const AVLTree = (function () {
- function _avl(comp) {
+class AVLTree {
+ constructor(comp) {
/** @public comparator function */
this._comp = undefined
this._comp = comp !== undefined ? comp : utils.comparator()
@@ -43,162 +43,6 @@ const AVLTree = (function () {
this.size = 0
}
- // creates new Node Object
- const Node = function (val) {
- this._val = val
- this._left = null
- this._right = null
- this._height = 1
- }
-
- // get height of a node
- const getHeight = function (node) {
- if (node == null) {
- return 0
- }
- return node._height
- }
-
- // height difference or balance factor of a node
- const getHeightDifference = function (node) {
- return node == null ? 0 : getHeight(node._left) - getHeight(node._right)
- }
-
- // update height of a node based on children's heights
- const updateHeight = function (node) {
- if (node == null) {
- return
- }
- node._height = Math.max(getHeight(node._left), getHeight(node._right)) + 1
- }
-
- // Helper: To check if the balanceFactor is valid
- const isValidBalanceFactor = (balanceFactor) =>
- [0, 1, -1].includes(balanceFactor)
-
- // rotations of AVL Tree
- const leftRotate = function (node) {
- const temp = node._right
- node._right = temp._left
- temp._left = node
- updateHeight(node)
- updateHeight(temp)
- return temp
- }
- const rightRotate = function (node) {
- const temp = node._left
- node._left = temp._right
- temp._right = node
- updateHeight(node)
- updateHeight(temp)
- return temp
- }
-
- // check if tree is balanced else balance it for insertion
- const insertBalance = function (node, _val, balanceFactor, tree) {
- if (balanceFactor > 1 && tree._comp(_val, node._left._val) < 0) {
- return rightRotate(node) // Left Left Case
- }
- if (balanceFactor < 1 && tree._comp(_val, node._right._val) > 0) {
- return leftRotate(node) // Right Right Case
- }
- if (balanceFactor > 1 && tree._comp(_val, node._left._val) > 0) {
- node._left = leftRotate(node._left) // Left Right Case
- return rightRotate(node)
- }
- node._right = rightRotate(node._right)
- return leftRotate(node)
- }
-
- // check if tree is balanced after deletion
- const delBalance = function (node) {
- const balanceFactor1 = getHeightDifference(node)
- if (isValidBalanceFactor(balanceFactor1)) {
- return node
- }
- if (balanceFactor1 > 1) {
- if (getHeightDifference(node._left) >= 0) {
- return rightRotate(node) // Left Left
- }
- node._left = leftRotate(node._left)
- return rightRotate(node) // Left Right
- }
- if (getHeightDifference(node._right) > 0) {
- node._right = rightRotate(node._right)
- return leftRotate(node) // Right Left
- }
- return leftRotate(node) // Right Right
- }
-
- // implement avl tree insertion
- const insert = function (root, val, tree) {
- if (root == null) {
- tree.size++
- return new Node(val)
- }
- if (tree._comp(root._val, val) < 0) {
- root._right = insert(root._right, val, tree)
- } else if (tree._comp(root._val, val) > 0) {
- root._left = insert(root._left, val, tree)
- } else {
- return root
- }
- updateHeight(root)
- const balanceFactor = getHeightDifference(root)
- return isValidBalanceFactor(balanceFactor)
- ? root
- : insertBalance(root, val, balanceFactor, tree)
- }
-
- // delete am element
- const deleteElement = function (root, _val, tree) {
- if (root == null) {
- return root
- }
- if (tree._comp(root._val, _val) === 0) {
- // key found case
- if (root._left === null && root._right === null) {
- root = null
- tree.size--
- } else if (root._left === null) {
- root = root._right
- tree.size--
- } else if (root._right === null) {
- root = root._left
- tree.size--
- } else {
- let temp = root._right
- while (temp._left != null) {
- temp = temp._left
- }
- root._val = temp._val
- root._right = deleteElement(root._right, temp._val, tree)
- }
- } else {
- if (tree._comp(root._val, _val) < 0) {
- root._right = deleteElement(root._right, _val, tree)
- } else {
- root._left = deleteElement(root._left, _val, tree)
- }
- }
- updateHeight(root)
- root = delBalance(root)
- return root
- }
- // search tree for a element
- const searchAVLTree = function (root, val, tree) {
- if (root == null) {
- return null
- }
- if (tree._comp(root._val, val) === 0) {
- return root
- }
- if (tree._comp(root._val, val) < 0) {
- return searchAVLTree(root._right, val, tree)
- }
- return searchAVLTree(root._left, val, tree)
- }
-
/* Public Functions */
/**
* For Adding Elements to AVL Tree
@@ -207,20 +51,22 @@ const AVLTree = (function () {
* if a element exists it return false
* @returns {Boolean} element added or not
*/
- _avl.prototype.add = function (_val) {
+ add(_val) {
const prevSize = this.size
this.root = insert(this.root, _val, this)
return this.size !== prevSize
}
+
/**
* TO check is a particular element exists or not
* @param {any} _val
* @returns {Boolean} exists or not
*/
- _avl.prototype.find = function (_val) {
+ find(_val) {
const temp = searchAVLTree(this.root, _val, this)
return temp != null
}
+
/**
*
* @param {any} _val
@@ -228,13 +74,170 @@ const AVLTree = (function () {
* in that case it return false
* @returns {Boolean} if element was found and deleted
*/
- _avl.prototype.remove = function (_val) {
+ remove(_val) {
const prevSize = this.size
this.root = deleteElement(this.root, _val, this)
return prevSize !== this.size
}
- return _avl
-})()
+}
+
+// creates new Node Object
+class Node {
+ constructor(val) {
+ this._val = val
+ this._left = null
+ this._right = null
+ this._height = 1
+ }
+}
+
+// get height of a node
+const getHeight = function (node) {
+ if (node == null) {
+ return 0
+ }
+ return node._height
+}
+
+// height difference or balance factor of a node
+const getHeightDifference = function (node) {
+ return node == null ? 0 : getHeight(node._left) - getHeight(node._right)
+}
+
+// update height of a node based on children's heights
+const updateHeight = function (node) {
+ if (node == null) {
+ return
+ }
+ node._height = Math.max(getHeight(node._left), getHeight(node._right)) + 1
+}
+
+// Helper: To check if the balanceFactor is valid
+const isValidBalanceFactor = (balanceFactor) =>
+ [0, 1, -1].includes(balanceFactor)
+
+// rotations of AVL Tree
+const leftRotate = function (node) {
+ const temp = node._right
+ node._right = temp._left
+ temp._left = node
+ updateHeight(node)
+ updateHeight(temp)
+ return temp
+}
+const rightRotate = function (node) {
+ const temp = node._left
+ node._left = temp._right
+ temp._right = node
+ updateHeight(node)
+ updateHeight(temp)
+ return temp
+}
+
+// check if tree is balanced else balance it for insertion
+const insertBalance = function (node, _val, balanceFactor, tree) {
+ if (balanceFactor > 1 && tree._comp(_val, node._left._val) < 0) {
+ return rightRotate(node) // Left Left Case
+ }
+ if (balanceFactor < 1 && tree._comp(_val, node._right._val) > 0) {
+ return leftRotate(node) // Right Right Case
+ }
+ if (balanceFactor > 1 && tree._comp(_val, node._left._val) > 0) {
+ node._left = leftRotate(node._left) // Left Right Case
+ return rightRotate(node)
+ }
+ node._right = rightRotate(node._right)
+ return leftRotate(node)
+}
+
+// check if tree is balanced after deletion
+const delBalance = function (node) {
+ const balanceFactor1 = getHeightDifference(node)
+ if (isValidBalanceFactor(balanceFactor1)) {
+ return node
+ }
+ if (balanceFactor1 > 1) {
+ if (getHeightDifference(node._left) >= 0) {
+ return rightRotate(node) // Left Left
+ }
+ node._left = leftRotate(node._left)
+ return rightRotate(node) // Left Right
+ }
+ if (getHeightDifference(node._right) > 0) {
+ node._right = rightRotate(node._right)
+ return leftRotate(node) // Right Left
+ }
+ return leftRotate(node) // Right Right
+}
+
+// implement avl tree insertion
+const insert = function (root, val, tree) {
+ if (root == null) {
+ tree.size++
+ return new Node(val)
+ }
+ if (tree._comp(root._val, val) < 0) {
+ root._right = insert(root._right, val, tree)
+ } else if (tree._comp(root._val, val) > 0) {
+ root._left = insert(root._left, val, tree)
+ } else {
+ return root
+ }
+ updateHeight(root)
+ const balanceFactor = getHeightDifference(root)
+ return isValidBalanceFactor(balanceFactor)
+ ? root
+ : insertBalance(root, val, balanceFactor, tree)
+}
+
+// delete am element
+const deleteElement = function (root, _val, tree) {
+ if (root == null) {
+ return root
+ }
+ if (tree._comp(root._val, _val) === 0) {
+ // key found case
+ if (root._left === null && root._right === null) {
+ root = null
+ tree.size--
+ } else if (root._left === null) {
+ root = root._right
+ tree.size--
+ } else if (root._right === null) {
+ root = root._left
+ tree.size--
+ } else {
+ let temp = root._right
+ while (temp._left != null) {
+ temp = temp._left
+ }
+ root._val = temp._val
+ root._right = deleteElement(root._right, temp._val, tree)
+ }
+ } else {
+ if (tree._comp(root._val, _val) < 0) {
+ root._right = deleteElement(root._right, _val, tree)
+ } else {
+ root._left = deleteElement(root._left, _val, tree)
+ }
+ }
+ updateHeight(root)
+ root = delBalance(root)
+ return root
+}
+// search tree for a element
+const searchAVLTree = function (root, val, tree) {
+ if (root == null) {
+ return null
+ }
+ if (tree._comp(root._val, val) === 0) {
+ return root
+ }
+ if (tree._comp(root._val, val) < 0) {
+ return searchAVLTree(root._right, val, tree)
+ }
+ return searchAVLTree(root._left, val, tree)
+}
/**
* A Code for Testing the AVLTree
diff --git a/Data-Structures/Tree/BinarySearchTree.js b/Data-Structures/Tree/BinarySearchTree.js
index c86a2995c0..abbcc3fb62 100644
--- a/Data-Structures/Tree/BinarySearchTree.js
+++ b/Data-Structures/Tree/BinarySearchTree.js
@@ -13,77 +13,79 @@
// class Node
const Node = (function Node() {
// Node in the tree
- function Node(val) {
- this.value = val
- this.left = null
- this.right = null
- }
-
- // Search the tree for a value
- Node.prototype.search = function (val) {
- if (this.value === val) {
- return this
- } else if (val < this.value && this.left !== null) {
- return this.left.search(val)
- } else if (val > this.value && this.right !== null) {
- return this.right.search(val)
+ class Node {
+ constructor(val) {
+ this.value = val
+ this.left = null
+ this.right = null
}
- return null
- }
- // Visit a node
- Node.prototype.visit = function (output = (value) => console.log(value)) {
- // Recursively go left
- if (this.left !== null) {
- this.left.visit()
- }
- // Print out value
- output(this.value)
- // Recursively go right
- if (this.right !== null) {
- this.right.visit()
+ // Search the tree for a value
+ search(val) {
+ if (this.value === val) {
+ return this
+ } else if (val < this.value && this.left !== null) {
+ return this.left.search(val)
+ } else if (val > this.value && this.right !== null) {
+ return this.right.search(val)
+ }
+ return null
}
- }
- // Add a node
- Node.prototype.addNode = function (n) {
- if (n.value < this.value) {
- if (this.left === null) {
- this.left = n
- } else {
- this.left.addNode(n)
+ // Visit a node
+ visit(output = (value) => console.log(value)) {
+ // Recursively go left
+ if (this.left !== null) {
+ this.left.visit()
}
- } else if (n.value > this.value) {
- if (this.right === null) {
- this.right = n
- } else {
- this.right.addNode(n)
+ // Print out value
+ output(this.value)
+ // Recursively go right
+ if (this.right !== null) {
+ this.right.visit()
}
}
- }
- // remove a node
- Node.prototype.removeNode = function (val) {
- if (val === this.value) {
- if (!this.left && !this.right) {
- return null
- } else {
- if (this.left) {
- const leftMax = maxVal(this.left)
- this.value = leftMax
- this.left = this.left.removeNode(leftMax)
+ // Add a node
+ addNode(n) {
+ if (n.value < this.value) {
+ if (this.left === null) {
+ this.left = n
} else {
- const rightMin = minVal(this.right)
- this.value = rightMin
- this.right = this.right.removeNode(rightMin)
+ this.left.addNode(n)
+ }
+ } else if (n.value > this.value) {
+ if (this.right === null) {
+ this.right = n
+ } else {
+ this.right.addNode(n)
}
}
- } else if (val < this.value) {
- this.left = this.left && this.left.removeNode(val)
- } else if (val > this.value) {
- this.right = this.right && this.right.removeNode(val)
}
- return this
+
+ // remove a node
+ removeNode(val) {
+ if (val === this.value) {
+ if (!this.left && !this.right) {
+ return null
+ } else {
+ if (this.left) {
+ const leftMax = maxVal(this.left)
+ this.value = leftMax
+ this.left = this.left.removeNode(leftMax)
+ } else {
+ const rightMin = minVal(this.right)
+ this.value = rightMin
+ this.right = this.right.removeNode(rightMin)
+ }
+ }
+ } else if (val < this.value) {
+ this.left = this.left && this.left.removeNode(val)
+ } else if (val > this.value) {
+ this.right = this.right && this.right.removeNode(val)
+ }
+ return this
+ }
}
// find maximum value in the tree
@@ -107,44 +109,46 @@ const Node = (function Node() {
// class Tree
const Tree = (function () {
- function Tree() {
- // Just store the root
- this.root = null
- }
+ class Tree {
+ constructor() {
+ // Just store the root
+ this.root = null
+ }
- // Inorder traversal
- Tree.prototype.traverse = function () {
- if (!this.root) {
- // No nodes are there in the tree till now
- return
+ // Inorder traversal
+ traverse() {
+ if (!this.root) {
+ // No nodes are there in the tree till now
+ return
+ }
+ this.root.visit()
}
- this.root.visit()
- }
- // Start by searching the root
- Tree.prototype.search = function (val) {
- const found = this.root.search(val)
- if (found !== null) {
- return found.value
+ // Start by searching the root
+ search(val) {
+ const found = this.root.search(val)
+ if (found !== null) {
+ return found.value
+ }
+ // not found
+ return null
}
- // not found
- return null
- }
- // Add a new value to the tree
- Tree.prototype.addValue = function (val) {
- const n = new Node(val)
- if (this.root === null) {
- this.root = n
- } else {
- this.root.addNode(n)
+ // Add a new value to the tree
+ addValue(val) {
+ const n = new Node(val)
+ if (this.root === null) {
+ this.root = n
+ } else {
+ this.root.addNode(n)
+ }
}
- }
- // remove a value from the tree
- Tree.prototype.removeValue = function (val) {
- // remove something if root exists
- this.root = this.root && this.root.removeNode(val)
+ // remove a value from the tree
+ removeValue(val) {
+ // remove something if root exists
+ this.root = this.root && this.root.removeNode(val)
+ }
}
// returns the constructor
diff --git a/Data-Structures/Tree/Trie.js b/Data-Structures/Tree/Trie.js
index ea59e53846..0d4018f74f 100644
--- a/Data-Structures/Tree/Trie.js
+++ b/Data-Structures/Tree/Trie.js
@@ -1,129 +1,132 @@
-const TrieNode = function TrieNode(key, parent) {
- this.key = key
- this.count = 0
- this.children = Object.create(null)
- if (parent === undefined) {
- this.parent = null
- } else {
- this.parent = parent
+class TrieNode {
+ constructor(key, parent) {
+ this.key = key
+ this.count = 0
+ this.children = Object.create(null)
+ if (parent === undefined) {
+ this.parent = null
+ } else {
+ this.parent = parent
+ }
}
}
-function Trie() {
- // create only root with null key and parent
- this.root = new TrieNode(null, null)
-}
+class Trie {
+ constructor() {
+ // create only root with null key and parent
+ this.root = new TrieNode(null, null)
+ }
-// Recursively finds the occurrence of all words in a given node
-Trie.findAllWords = function (root, word, output) {
- if (root === null) return
- if (root.count > 0) {
- if (typeof output === 'object') {
- output.push({ word, count: root.count })
+ // Recursively finds the occurrence of all words in a given node
+ static findAllWords(root, word, output) {
+ if (root === null) return
+ if (root.count > 0) {
+ if (typeof output === 'object') {
+ output.push({ word, count: root.count })
+ }
+ }
+ let key
+ for (key in root.children) {
+ word += key
+ this.findAllWords(root.children[key], word, output)
+ word = word.slice(0, -1)
}
}
- let key
- for (key in root.children) {
- word += key
- this.findAllWords(root.children[key], word, output)
- word = word.slice(0, -1)
- }
-}
-Trie.prototype.insert = function (word) {
- if (typeof word !== 'string') return
- if (word === '') {
- this.root.count += 1
- return
- }
- let node = this.root
- const len = word.length
- let i
- for (i = 0; i < len; i++) {
- if (node.children[word.charAt(i)] === undefined) {
- node.children[word.charAt(i)] = new TrieNode(word.charAt(i), node)
+ insert(word) {
+ if (typeof word !== 'string') return
+ if (word === '') {
+ this.root.count += 1
+ return
+ }
+ let node = this.root
+ const len = word.length
+ let i
+ for (i = 0; i < len; i++) {
+ if (node.children[word.charAt(i)] === undefined) {
+ node.children[word.charAt(i)] = new TrieNode(word.charAt(i), node)
+ }
+ node = node.children[word.charAt(i)]
}
- node = node.children[word.charAt(i)]
+ node.count += 1
}
- node.count += 1
-}
-Trie.prototype.findPrefix = function (word) {
- if (typeof word !== 'string') return null
- let node = this.root
- const len = word.length
- let i
- // After end of this loop node will be at desired prefix
- for (i = 0; i < len; i++) {
- if (node.children[word.charAt(i)] === undefined) return null // No such prefix exists
- node = node.children[word.charAt(i)]
+ findPrefix(word) {
+ if (typeof word !== 'string') return null
+ let node = this.root
+ const len = word.length
+ let i
+ // After end of this loop node will be at desired prefix
+ for (i = 0; i < len; i++) {
+ if (node.children[word.charAt(i)] === undefined) return null // No such prefix exists
+ node = node.children[word.charAt(i)]
+ }
+ return node
}
- return node
-}
-Trie.prototype.remove = function (word, count) {
- if (typeof word !== 'string') return
- if (typeof count !== 'number') count = 1
- else if (count <= 0) return
+ remove(word, count) {
+ if (typeof word !== 'string') return
+ if (typeof count !== 'number') count = 1
+ else if (count <= 0) return
- // for empty string just delete count of root
- if (word === '') {
- if (this.root.count >= count) this.root.count -= count
- else this.root.count = 0
- return
- }
+ // for empty string just delete count of root
+ if (word === '') {
+ if (this.root.count >= count) this.root.count -= count
+ else this.root.count = 0
+ return
+ }
- let child = this.root
- const len = word.length
- let i, key
- // child: node which is to be deleted
- for (i = 0; i < len; i++) {
- key = word.charAt(i)
- if (child.children[key] === undefined) return
- child = child.children[key]
- }
+ let child = this.root
+ const len = word.length
+ let i, key
+ // child: node which is to be deleted
+ for (i = 0; i < len; i++) {
+ key = word.charAt(i)
+ if (child.children[key] === undefined) return
+ child = child.children[key]
+ }
- // Delete no of occurrences specified
- if (child.count >= count) child.count -= count
- else child.count = 0
+ // Delete no of occurrences specified
+ if (child.count >= count) child.count -= count
+ else child.count = 0
- // If some occurrences are left we don't delete it or else
- // if the object forms some other objects prefix we don't delete it
- // For checking an empty object
- // https://stackoverflow.com/questions/679915/how-do-i-test-for-an-empty-javascript-object
- if (
- child.count <= 0 &&
- Object.keys(child.children).length &&
- child.children.constructor === Object
- ) {
- child.parent.children[child.key] = undefined
+ // If some occurrences are left we don't delete it or else
+ // if the object forms some other objects prefix we don't delete it
+ // For checking an empty object
+ // https://stackoverflow.com/questions/679915/how-do-i-test-for-an-empty-javascript-object
+ if (
+ child.count <= 0 &&
+ Object.keys(child.children).length &&
+ child.children.constructor === Object
+ ) {
+ child.parent.children[child.key] = undefined
+ }
}
-}
-Trie.prototype.findAllWords = function (prefix) {
- const output = []
- // find the node with provided prefix
- const node = this.findPrefix(prefix)
- // No such prefix exists
- if (node === null) return output
- Trie.findAllWords(node, prefix, output)
- return output
-}
-
-Trie.prototype.contains = function (word) {
- // find the node with given prefix
- const node = this.findPrefix(word)
- // No such word exists
+ findAllWords(prefix) {
+ const output = []
+ // find the node with provided prefix
+ const node = this.findPrefix(prefix)
+ // No such prefix exists
+ if (node === null) return output
+ Trie.findAllWords(node, prefix, output)
+ return output
+ }
- return node !== null && node.count !== 0
-}
+ contains(word) {
+ // find the node with given prefix
+ const node = this.findPrefix(word)
+ // No such word exists
+ return node !== null && node.count !== 0
+ }
-Trie.prototype.findOccurrences = function (word) {
- // find the node with given prefix
- const node = this.findPrefix(word)
- // No such word exists
- if (node === null) return 0
- return node.count
+ findOccurrences(word) {
+ // find the node with given prefix
+ const node = this.findPrefix(word)
+ // No such word exists
+ if (node === null) return 0
+ return node.count
+ }
}
export { Trie }
diff --git a/Dynamic-Programming/NumberOfSubsetEqualToGivenSum.js b/Dynamic-Programming/NumberOfSubsetEqualToGivenSum.js
index dee12f8de9..48905c39e2 100644
--- a/Dynamic-Programming/NumberOfSubsetEqualToGivenSum.js
+++ b/Dynamic-Programming/NumberOfSubsetEqualToGivenSum.js
@@ -4,7 +4,7 @@ determine the total number of the subset with sum
equal to the given sum.
*/
/*
- Given solution is O(n*sum) Time complexity and O(sum) Space complexity
+ Given solution is O(n*sum) Time complexity and O(sum) Space complexity
*/
function NumberOfSubsetSum(array, sum) {
const dp = [] // create an dp array where dp[i] denote number of subset with sum equal to i
diff --git a/Project-Euler/Problem004.js b/Project-Euler/Problem004.js
index 34fa87471d..7c85dfdb85 100644
--- a/Project-Euler/Problem004.js
+++ b/Project-Euler/Problem004.js
@@ -1,6 +1,6 @@
// https://projecteuler.net/problem=4
/* A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.
- Find the largest palindrome made from the product of two 3-digit numbers.
+ Find the largest palindrome made from the product of two 3-digit numbers.
*/
export const largestPalindromic = (digits) => {
let i
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy