Add: Exercise 1207. Unique Number of Occurrences

Author: BlackBeast593

1657-determine-if-two-strings-are-close/README.md

@@ -0,0 +1,38 @@
+# 1657. Determine if Two Strings Are Close
+Two strings are considered close if you can attain one from the other using the following
+operations:
+
+**Operation 1**: Swap any two existing characters.
+For example, `abcde` -> `aecdb`
+
+**Operation 2**: Transform every occurrence of one existing character into another existing character, and do the same with the other character.
+For example, `aacabb` -> `bbcbaa` (all a's turn into b's, and all b's turn into a's)
+You can use the operations on either string as many times as necessary.
+
+Given two strings, `word1` and `word2`, return `true` if `word1` and `word2` are close, and `false` otherwise.
+
+## Examples
+
+### Example 1:
+Input: `word1` = "abc", `word2` = "bca"  
+Output: `true`  
+Explanation: You can attain `word2` from `word1` in 2 operations.  
+Apply Operation 1: "abc" -> "acb"  
+Apply Operation 1: "acb" -> "bca"
+
+### Example 2:
+Input: `word1` = "a", `word2` = "aa"  
+Output: `false`  
+Explanation: It is impossible to attain `word2` from `word1`, or vice versa, in any number of operations.
+
+### Example 3:
+Input: `word1` = "cabbba", `word2` = "abbccc"  
+Output: `true`  
+Explanation: You can attain `word2` from `word1` in 3 operations.  
+Apply Operation 1: "cabbba" -> "caabbb"  
+Apply Operation 2: "caabbb" -> "baaccc"  
+Apply Operation 2: "baaccc" -> "abbccc"
+
+## Constraints
+- 1 <= `word1.length`, `word2.length` <= 10^5
+- `word1` and `word2` contain only lowercase English letters.

1657-determine-if-two-strings-are-close/index.js

@@ -0,0 +1,61 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {boolean}
+ */
+var closeStrings = function(word1, word2) {
+    // Edge case: different lengths
+    if (word1.length !== word2.length) {
+        return false
+    }
+
+    // Obtain letter maps and sets
+    const word1FreqMap = {}
+    const word2FreqMap = {}
+    const word1LetterSet = new Set()
+    const word2LetterSet = new Set()
+    let word1Freqs = []
+    let word2Freqs = []
+
+    for (let i = 0; i < word1.length; i++) {
+        word1FreqMap.hasOwnProperty(word1[i]) ? word1FreqMap[word1[i]]++ : word1FreqMap[word1[i]] = 1
+        word2FreqMap.hasOwnProperty(word2[i]) ? word2FreqMap[word2[i]]++ : word2FreqMap[word2[i]] = 1
+    }
+
+    // Let's create the sets
+    for (const key in word1FreqMap) {
+        word1LetterSet.add(key)
+        word1Freqs.push(word1FreqMap[key])
+    }
+    for (const key in word2FreqMap) {
+        word2LetterSet.add(key)
+        word2Freqs.push(word2FreqMap[key])
+    }
+
+    // Let's compare sizes
+    if (word1LetterSet.size !== word2LetterSet.size) {
+        return false
+    }
+
+    // Let's iterate and compare letters and frequencies
+    word1LetterSet.forEach((letter) => {
+        if (!word2LetterSet.has(letter)) return false
+        word2LetterSet.delete(letter)
+    })
+
+    if (word2LetterSet.size !== 0) return false
+
+    word1Freqs = word1Freqs.sort()
+    word2Freqs = word2Freqs.sort()
+
+    // There should be the same frequencies in order of two strings to be close
+    for (let i = 0; i < word1Freqs.length; i++) {
+        if (word1Freqs[i] !== word2Freqs[i]) return false
+    }
+
+    return true
+};
+
+var output = closeStrings('abbzzca', 'babzzcz')
+
+module.exports = closeStrings

1657-determine-if-two-strings-are-close/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "1657-determine-if-two-strings-are-close",
+  "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"
+}

1657-determine-if-two-strings-are-close/test.js

@@ -0,0 +1,29 @@
+const assert = require('assert')
+const closeStrings = require('./index')
+
+const tests = [
+    {
+        word1: 'abc',
+        word2: 'bca',
+        expectedOutput: true
+    },
+    {
+        word1: 'a',
+        word2: 'aa',
+        expectedOutput: false
+    },
+    {
+        word1: 'cabbba',
+        word2: 'abbccc',
+        expectedOutput: true
+    },
+    {
+        word1: 'abbzzca',
+        word2: 'babzzcz',
+        expectedOutput: false
+    },
+]
+
+for (const t of tests) {
+    assert.strictEqual(closeStrings(t.word1, t.word2), t.expectedOutput)
+}