Add: Exercise 443. String Compression

Author: BlackBeast593

443-string-compression/README.md

@@ -0,0 +1,34 @@
+# 443. String Compression
+Given an array of characters `chars`, compress it using the following algorithm:
+
+Begin with an empty string `s`. For each group of consecutive repeating characters in `chars`:
+
+- If the group's length is 1, append the character to `s`.
+- Otherwise, append the character followed by the group's length.
+
+The compressed string `s` should not be returned separately, but instead, be stored in the input character array `chars`. Note that group lengths that are 10 or longer will be split into multiple characters in `chars`.
+
+After you are done modifying the input array, return the new length of the array.
+
+You must write an algorithm that uses only constant extra space.
+
+## Examples
+
+### Example 1:
+Input: `chars` = ["a","a","b","b","c","c","c"]
+Output: Return 6, and the first 6 characters of the input array should be: ["a","2","b","2","c","3"]
+Explanation: The groups are "aa", "bb", and "ccc". This compresses to "a2b2c3".
+
+### Example 2:
+Input: `chars` = ["a"]
+Output: Return 1, and the first character of the input array should be: ["a"]
+Explanation: The only group is "a", which remains uncompressed since it's a single character.
+
+### Example 3:
+Input: `chars` = ["a","b","b","b","b","b","b","b","b","b","b","b","b"]
+Output: Return 4, and the first 4 characters of the input array should be: ["a","b","1","2"].
+Explanation: The groups are "a" and "bbbbbbbbbbbb". This compresses to "ab12".
+
+## Constraints
+- 1 <= `chars.length` <= 2000
+- `chars[i]` is a lowercase English letter, uppercase English letter, digit, or symbol.

443-string-compression/index.js

@@ -0,0 +1,48 @@
+/**
+ * @param {character[]} chars
+ * @return {number}
+ */
+/**
+ * @param {character[]} chars
+ * @return {number}
+ */
+var compress = function(chars) {
+    // Intial conditions
+    const compressed = [chars[0]]
+    let prevChar = chars[0]
+    let charCount = 1
+
+    // Traverse the array, if the current char is the same previous one, add a counter
+    for (let i = 1; i <= chars.length; i++) {
+        if (chars[i] !== prevChar) {
+            // If `charCount` is multicharacter, split it in (i.e. '12' => '1', '2')
+            if (charCount.toString().length > 1) {
+                compressed.pop()
+                compressed.push(...Array.from(charCount.toString()))
+            }
+
+            if (i === chars.length) {
+                break
+            }
+
+            prevChar = chars[i]
+            charCount = 1
+            compressed.push(chars[i])
+            continue
+        }
+
+        charCount += 1
+        if (charCount === 2) {
+            compressed.push(charCount.toString())
+            continue
+        }
+       
+        compressed[compressed.length - 1] = charCount.toString()
+    }
+    
+    // Adds the compressed array at the begginning of the chars array
+    chars.unshift(...compressed)
+    return compressed.length
+};
+
+module.exports = compress

443-string-compression/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "443-string-compression",
+  "version": "1.0.0",
+  "description": "Given an array of characters `chars`, compress it using the following algorithm:",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "debug": "node --inspect-brk index.js",
+    "test": "node test.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}

443-string-compression/test.js

@@ -0,0 +1,25 @@
+const assert = require('assert')
+const compress = require('./index')
+
+const tests = [
+    {
+        chars: ['a','a','b','b','c','c','c'],
+        expectedLength: 6,
+        expectedCompressed: ['a','2','b','2','c','3'],
+    },
+    {
+        chars: ['a'],
+        expectedLength: 1,
+        expectedCompressed: ['a'],
+    },
+    {
+        chars: ['a','b','b','b','b','b','b','b','b','b','b','b','b'],
+        expectedLength: 4,
+        expectedCompressed: ['a','b','1','2'],
+    },
+]
+
+for (const t of tests) {
+    assert.strict.deepEqual(compress(t.chars), t.expectedLength)
+    assert.strict.deepEqual(t.chars.slice(0, t.expectedLength), t.expectedCompressed)
+}