initial commit, excercises 238, 334 and 1071 completed

Author: BlackBeast593

.gitignore

@@ -0,0 +1,2 @@
+.vscode
+node_modules

1071-greatest-common-divisor-of-strings/README.md

@@ -0,0 +1,15 @@
+# 345. Reverse Vowels of a String
+
+Given a string `s`, reverse only all the vowels in the string and return it.
+
+The vowels are `'a'`, `'e'`, `'i'`, `'o'`, and `'u'`, and they can appear in both lower and upper cases, more than once.
+
+## Example 1:
+
+- Input: `s = "hello"`
+- Output: `"holle"`
+
+## Example 2:
+
+- Input: `s = "leetcode"`
+- Output: `"leotcede"`

1071-greatest-common-divisor-of-strings/index.js

@@ -0,0 +1,68 @@
+const assert = require('assert')
+const { benchmark } = require('..//utils/index')
+/**
+ * @param {string} s
+ * @return {string}
+ */
+// This function will traverse the string from the left until a vowel appears
+// Then swap with the vowel at the right
+var reverseVowels = function(s) {
+    let i = 0
+    let j = s.length - 1
+    const reverse = Array(s.length).fill()
+    while (i <= j){
+        if (!isVowel(s[i])) {
+            reverse[i] = s[i]
+            i++
+            continue
+        }
+        while (j >= i) {
+            if (!isVowel(s[j])) {
+                reverse[j] = s[j]
+                j--
+                continue
+            }
+
+            reverse[i] = s[j]
+            reverse[j] = s[i]
+            j--
+            // break this  while loop to continue from the left
+            break
+        }
+        i++
+    }
+
+    return reverse.join('')
+}
+
+var reverseVowels2 = function(s) {
+    const vowels = Array.from(s).filter(isVowel)
+    const rev = []
+    for (let i = 0; i < s.length; i++) {
+        if (!isVowel(s[i])) {
+            rev[i] = s[i]
+            continue
+        }
+        rev[i] = vowels[vowels.length - 1]
+        vowels.pop()
+    }
+    return rev.join('')
+}
+
+function isVowel(a) {
+    return ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'].includes(a)
+} 
+
+// Test `reverseVowels`
+assert.strictEqual(reverseVowels('hello'), 'holle')
+assert.strictEqual(reverseVowels('leetcode'), 'leotcede')
+assert.strictEqual(reverseVowels('a.'), 'a.')
+assert.strictEqual(reverseVowels('aA'), 'Aa')
+benchmark(reverseVowels, 'leetcode')
+
+// Test `reverseVowels2`
+assert.strictEqual(reverseVowels2('hello'), 'holle')
+assert.strictEqual(reverseVowels2('leetcode'), 'leotcede')
+assert.strictEqual(reverseVowels2('a.'), 'a.')
+assert.strictEqual(reverseVowels2('aA'), 'Aa')
+benchmark(reverseVowels2, 'leetcode')

1071-greatest-common-divisor-of-strings/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "1071-greatest-common-divisor-of-strings",
+  "version": "1.0.0",
+  "description": "Given a string `s`, reverse only all the vowels in the string and return it.",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}

238-product-array-except-self/README.md

@@ -0,0 +1,26 @@
+# 238. Product of Array Except Self
+
+## Problem Description
+Given an integer array `nums`, return an array `answer` such that `answer[i]` is equal to the product of all the elements of `nums` except `nums[i]`.
+
+The product of any prefix or suffix of `nums` is guaranteed to fit in a 32-bit integer.
+
+You must write an algorithm that runs in O(n) time and without using the division operation.
+
+## Examples
+
+### Example 1:
+Input: `nums` = [1,2,3,4]
+Output: [24,12,8,6]
+
+### Example 2:
+Input: `nums` = [-1,1,0,-3,3]
+Output: [0,0,9,0,0]
+
+## Constraints
+- 2 <= `nums.length` <= 105
+- -30 <= `nums[i]` <= 30
+The product of any prefix or suffix of `nums` is guaranteed to fit in a 32-bit integer.
+
+## Follow up
+Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)

238-product-array-except-self/index.js

@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function(nums) {
+    const n = nums.length;
+    const result = new Array(n).fill(1);
+
+    let leftProduct = 1;
+    let rightProduct = 1;
+
+    for (let i = 0; i < n; i++) {
+        result[i] *= leftProduct;
+        leftProduct *= nums[i];
+    }
+
+    for (let i = n - 1; i >= 0; i--) {
+        result[i] *= rightProduct;
+        rightProduct *= nums[i];
+    }
+
+    return result;
+};
+
+productExceptSelf([1,2,3,4])
+// Output: [24,12,8,6]

238-product-array-except-self/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "238-product-array-except-self",
+  "version": "1.0.0",
+  "description": "## Problem Description Given an integer array `nums`, return an array `answer` such that `answer[i]` is equal to the product of all the elements of `nums` except `nums[i]`.",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "debug": "node --inspect-brk index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}

334-increasing-triplet-sequence/REAME.md

@@ -0,0 +1,24 @@
+# 334. Increasing Triplet Subsequence
+Given an integer array `nums`, return `true` if there exists a triple of indices `(i, j, k)` such
+that `i < j < k` and `nums[i] < nums[j] < nums[k]`. If no such indices exist, return `false`.
+
+## Examples
+
+### Example 1:
+Input: `nums` = [1,2,3,4,5]
+Output: `true`
+Explanation: Any triplet where `i < j < k` is valid.
+
+### Example 2:
+Input: `nums` = [5,4,3,2,1]
+Output: `false`
+Explanation: No triplet exists.
+
+### Example 3:
+Input: `nums` = [2,1,5,0,4,6]
+Output: `true`
+Explanation: The triplet `(3, 4, 5)` is valid because `nums[3] == 0 < nums[4] == 4 < nums[5] == 6`.
+
+## Constraints
+- 1 <= `nums.length` <= 5 * 10^5
+- -2^31 <= `nums[i]` <= 2^31 - 1

334-increasing-triplet-sequence/index.js

@@ -0,0 +1,33 @@
+/**
+ * 
+ * @param {*} nums 
+ * @returns 
+ */
+var increasingTriplet = function(nums) {
+    let i = null // The first smaller number
+    let j = null // The second smaller number
+
+    for (const num of nums) {
+        // Look for the first smaller `num`
+        if (i === null || num <= i) {
+            // If we found it assign it to `i`
+            i = num
+            continue
+        }
+
+        // At this point is waranteed that i exists and the current `num`
+        // is greater than `i`
+        if (j === null || num <= j) {
+            j = num
+            continue
+        }
+
+        // At thhis point is waranteed that `i` and `j` exist and
+        // num > j > i, so we had found a triplet
+        return true
+    }
+
+    return false
+}
+
+module.exports = increasingTriplet

334-increasing-triplet-sequence/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "334-increasing-triplet-sequence",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "debug": "node --inspect-brk index.js",
+    "test": "node test.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}

334-increasing-triplet-sequence/test.js

@@ -0,0 +1,7 @@
+const assert = require('assert')
+const increasingTriplet = require('./index')
+
+assert.strict.equal(increasingTriplet([1,2,3,4,5]), true)
+assert.strict.equal(increasingTriplet([5,4,3,2,1]), false)
+assert.strict.equal(increasingTriplet([2,1,5,0,4,6]), true)
+assert.strict.equal(increasingTriplet([20,100,10,12,5,13]), true)

utils/index.js

@@ -0,0 +1,24 @@
+/**
+ * 
+ * @param {*} f 
+ * @param  {...any} params 
+ * @returns 
+ */
+function benchmark(f, ...params) {
+    const initialCpuUsage = totalCpuUseInSeconds()
+    f(...params)
+    const finalCpuUsage = totalCpuUseInSeconds()
+    const stats = {
+        function: f.name,
+        params: Array.from(...params).join(''),
+        cpuUsageInSeconds: finalCpuUsage - initialCpuUsage
+    }
+    console.table(stats)
+    return stats
+}
+
+function totalCpuUseInSeconds() {
+    return (process.cpuUsage().user + process.cpuUsage().system)/1000000
+}
+
+module.exports = { benchmark }

utils/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "utils",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}