String Compression

                                            
class Solution {
public:
    int compress(vector<char>& chars) {
        int n = chars.size();
        int i = 0, j = 0;
        while (i < n) {
            int count = 0;
            char current_char = chars[i];
            while (i < n && chars[i] == current_char) {
                i++;
                count++;
            }
            chars[j++] = current_char;
            if (count > 1) {
                string count_str = to_string(count);
                for (char c : count_str) {
                    chars[j++] = c;
                }
            }
        }
        return j;
    }
};

                                            
class Solution {
    public int compress(char[] chars) {
        if(chars == null || chars.length == 0) {
            return 0;
        }
        
        int index = 0;
        int count = 1;
        
        for(int i = 1; i <= chars.length; i++) {
            if(i < chars.length && chars[i] == chars[i - 1]) {
                count++;
            } else {
                chars[index++] = chars[i - 1];
                if(count > 1) {
                    char[] countChars = String.valueOf(count).toCharArray();
                    for(char c : countChars) {
                        chars[index++] = c;
                    }
                }
                count = 1;
            }
        }
        
        return index;
    }
}

                                            
class Solution(object):
    def compress(self, chars):
        """
        :type chars: List[str]
        """
        if len(chars) == 0:
            return 0
        
        count = 1
        prev = chars[0]
        index = 0
        
        for i in range(1, len(chars)):
            if chars[i] == prev:
                count += 1
            else:
                chars[index] = prev
                index += 1
                if count > 1:
                    for digit in str(count):
                        chars[index] = digit
                        index += 1
                prev = chars[i]
                count = 1
        
        chars[index] = prev
        index += 1
        if count > 1:
            for digit in str(count):
                chars[index] = digit
                index += 1
        
        return index

                                            
int compress(char* chars, int charsSize) {
    int index = 0;
    int count = 1;
    for(int i = 0; i < charsSize; i++) {
        if(i + 1 < charsSize && chars[i] == chars[i+1]) {
            count++;
        } else {
            chars[index++] = chars[i];
            if(count > 1) {
                char strCount[5];
                int len = snprintf(strCount, 5, "%d", count);
                for(int j = 0; j < len; j++) {
                    chars[index++] = strCount[j];
                }
            }
            count = 1;
        }
    }
    return index;
}

                                            
public class Solution {
    public int Compress(char[] chars) {
        int index = 0;
        int count = 1;

        for (int i = 1; i <= chars.Length; i++) {
            if (i == chars.Length || chars[i] != chars[i - 1]) {
                chars[index++] = chars[i - 1];
                if (count > 1) {
                    foreach (char c in count.ToString()) {
                        chars[index++] = c;
                    }
                }
                count = 1;
            } else {
                count++;
            }
        }

        return index;
    }
}

                                            
/**
 * @param {character[]} chars
 * @return {number}
 */
const compress = chars => {
    let index = 0;
    let i = 0;
    
    while (i < chars.length) {
        let j = i;
        while (j < chars.length && chars[j] === chars[i]) {
            j++;
        }
        
        chars[index++] = chars[i];
        if (j - i > 1) {
            for (let digit of String(j - i)) {
                chars[index++] = digit;
            }
        }
        
        i = j;
    }
    
    return index;
};

                                            
function compress(chars: string[]): number {
    let index = 0;
    let count = 1;

    for (let i = 1; i <= chars.length; i++) {
        if (i === chars.length || chars[i] !== chars[i - 1]) {
            chars[index++] = chars[i - 1];
            if (count > 1) {
                for (const digit of count.toString()) {
                    chars[index++] = digit;
                }
            }
            count = 1;
        } else {
            count++;
        }
    }

    return index;
};

                                            
class Solution {
    /**
     * @param String[] $chars
     * @return Integer
     */
    function compress(&$chars) {
        $count = count($chars);
        $idx = 0;
        
        for ($i = 0; $i < $count; $i++) {
            $currChar = $chars[$i];
            $charCount = 1;
            while ($i + 1 < $count && $chars[$i] == $chars[$i + 1]) {
                $charCount++;
                $i++;
            }
            $chars[$idx] = $currChar;
            $idx++;
            if ($charCount > 1) {
                $charCountStr = strval($charCount);
                for ($j = 0; $j < strlen($charCountStr); $j++) {
                    $chars[$idx] = $charCountStr[$j];
                    $idx++;
                }
            }
        }
        
        return $idx;
    }
}

                                            
class Solution {
    func compress(_ chars: inout [Character]) -> Int {
        var index = 0
        var count = 1
        
        for i in 1..<chars.count {
            if chars[i] == chars[i - 1] {
                count += 1
            } else {
                chars[index] = chars[i - 1]
                index += 1
                if count > 1 {
                    let countStr = String(count)
                    for char in countStr {
                        chars[index] = char
                        index += 1
                    }
                }
                count = 1
            }
        }
        
        chars[index] = chars[chars.count - 1]
        index += 1
        if count > 1 {
            let countStr = String(count)
            for char in countStr {
                chars[index] = char
                index += 1
            }
        }
        
        return index
    }
}

                                            
class Solution {
    fun compress(chars: CharArray): Int {
        var index = 0
        var i = 0
        while (i < chars.size) {
            var count = 0
            var j = i
            while (j < chars.size && chars[j] == chars[i]) {
                count++
                j++
            }
            chars[index++] = chars[i]
            if (count > 1) {
                for (c in count.toString().toCharArray()) {
                    chars[index++] = c
                }
            }
            i = j
        }
        return index
    }
}

                                            
class Solution {
  int compress(List<String> chars) {
    int index = 0;
    int i = 0;
    while (i < chars.length) {
      int j = i;
      while (j < chars.length && chars[j] == chars[i]) {
        j++;
      }
      chars[index++] = chars[i];
      if (j - i > 1) {
        for (String digit in (j - i).toString().split('')) {
          chars[index++] = digit;
        }
      }
      i = j;
    }
    return index;
  }
}

                                            
func compress(chars []byte) int {
    n := len(chars)
    if n == 0 {
        return 0
    }
    
    write := 0
    anchor := 0
    
    for read := 0; read < n; read++ {
        if read+1 == n || chars[read] != chars[read+1] {
            chars[write] = chars[anchor]
            write++
            if read > anchor {
                for _, c := range []byte(strconv.Itoa(read - anchor + 1)) {
                    chars[write] = c
                    write++
                }
            }
            anchor = read + 1
        }
    }
    
    return write
}

                                            
# @param {Character[]} chars
# @return {Integer}
def compress(chars)
    index = 0
    i = 0
    
    while i < chars.length
        count = 0
        current_char = chars[i]
        
        while i < chars.length && chars[i] == current_char
            count += 1
            i += 1
        end
        
        chars[index] = current_char
        index += 1
        
        if count > 1
            count.to_s.chars.each do |c|
                chars[index] = c
                index += 1
            end
        end
    end
    
    return index
end

                                            
object Solution {
    def compress(chars: Array[Char]): Int = {
        var index = 0
        var count = 1
        
        def addChar(c: Char, cnt: Int): Unit = {
            chars(index) = c
            index += 1
            if (cnt > 1) {
                val cntStr = cnt.toString
                for (i <- 0 until cntStr.length) {
                    chars(index) = cntStr(i)
                    index += 1
                }
            }
        }
        
        for (i <- 1 until chars.length) {
            if (chars(i) == chars(i - 1)) {
                count += 1
            } else {
                addChar(chars(i - 1), count)
                count = 1
            }
        }
        
        addChar(chars(chars.length - 1), count)
        
        index
    }
}

                                            
impl Solution {
    pub fn compress(chars: &mut Vec<char>) -> i32 {
        let mut i = 0;
        let mut j = 0;
        
        while i < chars.len() {
            let mut count = 0;
            let current_char = chars[i];
            while i < chars.len() && chars[i] == current_char {
                i += 1;
                count += 1;
            }
            chars[j] = current_char;
            j += 1;
            if count > 1 {
                for c in count.to_string().chars() {
                    chars[j] = c;
                    j += 1;
                }
            }
        }
        
        j as i32
    }
}

To solve this coding challenge, you need to compress a provided list of characters using a specific algorithm. The goal is to work with limited extra space while transforming the array in place.

# Explanation

The task involves iterating through the list of characters and finding consecutive repeating characters. When such groups are found:

If the group has a length of 1, you simply append the character to the result.
If the group has a length greater than 1, you append the character followed by the group's length (split into individual character components).

The key point is to ensure the transformation is done in place, meaning you modify the original list without creating another one and return the new length of the modified list.

Step-by-Step Explanation

Initialize variables to keep track of the current character and group count.
Traverse the list to identify groups of consecutive characters.
For each group, write the character and its count back into the starting part of the array.
When the groups are processed, the array will contain the compressed form at the beginning, and the new length of the compressed array will be returned.

Pseudocode Explanation

                                            
function compress(chars):
# Handling edge case where input list might be empty
if length of chars is 0:
return 0

# Initialize the initial character count and pointer to the initial character
count = 1
previousCharacter = chars[0]
writeIndex = 0  # This will point to the position in the array where we write characters

# Iterate over the characters starting from the second one
for i from 1 to length of chars - 1:
if chars[i] == previousCharacter:
# Current character is equal to previous, increment the count
count += 1
else:
# Current character is different
# Write the previous character and its count if greater than 1
chars[writeIndex] = previousCharacter
writeIndex += 1
if count > 1:
for digit in string representation of count:
chars[writeIndex] = digit
writeIndex += 1
# Update the previous character and reset count to 1
previousCharacter = chars[i]
count = 1

# Handle the last group of characters
chars[writeIndex] = previousCharacter
writeIndex += 1
if count > 1:
for digit in string representation of count:
chars[writeIndex] = digit
writeIndex += 1

# Return the new length of the modified array
return writeIndex

Detailed Steps in Pseudocode

Initialization :

Start by checking if the input list
chars

is empty. If it is, return
0

as there are no characters to compress.
Initialize
count

to
1

(since any character at least appears once),
previousCharacter

to the first character of the list, and
writeIndex

to
0

(indicating where we write the next character in the list).

Iterate through the characters :

Loop through the list starting from the second character.
For each character, check if it matches
previousCharacter

. If it does, increase the
count

.
If it doesn't, write
previousCharacter

to the current
writeIndex

and increase
writeIndex

.
If
count

is greater than
1

, write each digit of the count to the array, updating
writeIndex

accordingly.
Update
previousCharacter

to the current character and reset
count

to
1

.

Final Characters :

After the loop, handle the last group of characters by writing
previousCharacter

and the count (if greater than
1

) as described above.

Return the New Length :

The
writeIndex

will now point to the end of the compressed array segment we created within the original list. This is also the new length of the compressed array.

Conclusion

By using this approach, you ensure that the array is modified in place and only a constant amount of extra space is used (i.e., variables for counting and position tracking), adhering to the problem constraints effectively.