문자열 압축 풀이: 연속한 문자만 횟수로 묶는 방법

function solution(s) {
  const answer = [];
  const text = s + ' ';
  let count = 1;

  for (let i = 0; i < s.length; i++) {
    if (text[i] === text[i + 1]) {
      count++;
    } else {
      answer.push(text[i]);
      if (count > 1) answer.push(String(count));
      count = 1;
    }
  }

  return answer.join('');
}

문자열 s를 solution(s)에 전달하고 압축한 문자열을 반환합니다. 예: solution("KKHSSSSSSSE") → "K2HS7E". 함수에는 입력을 읽거나 출력하는 코드를 넣지 않습니다.

s[i]로 문자를 읽고 ===로 다음 문자와 비교합니다. 같으면 count를 늘리고, 다르면 push()로 문자와 필요한 횟수만 배열에 넣습니다. join('')은 조각을 구분자 없이 합칩니다.
ABBA는 A | BB | A이므로 AB2A입니다. A는 A, 마지막 묶음이 반복되는 ABCCC는 ABC3이 됩니다. 대문자와 다른 공백은 마지막 묶음을 닫는 표시이며 출력하지 않습니다.
원래 길이만큼 순회하므로 시간 O(n), 센티널 문자열과 결과 조각을 포함한 추가 공간 O(n)입니다.

def solution(s):
    answer = []
    text = s + ' '
    count = 1

    for i in range(len(s)):
        if text[i] == text[i + 1]:
            count += 1
        else:
            answer.append(text[i])
            if count > 1:
                answer.append(str(count))
            count = 1

    return ''.join(answer)

str s를 solution(s)에 전달하고 압축한 str을 반환합니다. 예: solution("KKHSSSSSSSE") → "K2HS7E". input()과 print()는 필요하지 않습니다.

range(len(s))는 원래 문자열의 인덱스만 순회합니다. append()로 문자와 str(count)를 리스트에 모은 뒤 join()으로 합치므로 횟수와 문자열의 자료형이 섞이지 않습니다.
ABBA → AB2A에서 양끝 A는 따로 기록합니다. A → A처럼 1을 생략하고, ABCCC → ABC3처럼 끝 묶음도 공백 센티널과 비교해 기록합니다.
시간 O(n), 센티널 문자열·결과 리스트를 포함한 추가 공간 O(n)입니다.

class Solution {
  public String solution(String s) {
    StringBuilder answer = new StringBuilder();
    String text = s + " ";
    int count = 1;

    for (int i = 0; i < s.length(); i++) {
      if (text.charAt(i) == text.charAt(i + 1)) {
        count++;
      } else {
        answer.append(text.charAt(i));
        if (count > 1) answer.append(count);
        count = 1;
      }
    }

    return answer.toString();
  }
}

new Solution().solution(String s)를 호출하고 압축한 String을 반환합니다. 예: new Solution().solution("KKHSSSSSSSE") → "K2HS7E". main과 표준 입력·출력은 필요하지 않습니다.

charAt(i)는 한 문자를 읽습니다. StringBuilder.append()는 문자와 정수 횟수를 결과 뒤에 붙이며, 정수 10도 두 자리 문자열로 기록합니다. 마지막에 toString()으로 String을 반환합니다.
ABBA → AB2A처럼 묶음 종료 뒤 count를 1로 초기화합니다. A → A는 횟수를 생략하고 ABCCC → ABC3은 끝의 공백 센티널 덕분에 마지막 묶음까지 처리합니다.
시간 O(n), 센티널 문자열·StringBuilder·반환 문자열을 포함한 추가 공간 O(n)입니다.

#include <string>

std::string solution(const std::string& s) {
  std::string answer;
  const std::string text = s + " ";
  int count = 1;

  for (std::size_t i = 0; i < s.size(); i++) {
    if (text[i] == text[i + 1]) {
      count++;
    } else {
      answer += text[i];
      if (count > 1) answer += std::to_string(count);
      count = 1;
    }
  }

  return answer;
}

std::string solution(const std::string& s)를 호출하고 압축한 std::string을 반환합니다. 예: solution("KKHSSSSSSSE") → "K2HS7E". main과 표준 입력·출력은 필요하지 않습니다. C++11 이상을 사용합니다.

입력은 const 참조로 받아 불필요하게 복사하지 않습니다. text[i]로 대문자를 비교하고, std::to_string(count)로 반복 횟수를 문자열로 바꿔 붙입니다. std::size_t는 문자열 인덱스와 크기에 맞는 자료형입니다.
ABBA → AB2A처럼 떨어진 A는 합치지 않습니다. A → A는 1을 생략하고 ABCCC → ABC3은 공백 센티널로 마지막 묶음을 닫습니다.
문자열 뒤에 붙이는 비용을 포함한 시간은 O(n), 센티널과 결과 문자열을 포함한 추가 공간은 O(n)입니다.

using System.Text;

public class Solution {
  public string Solve(string s) {
    var answer = new StringBuilder();
    string text = s + " ";
    int count = 1;

    for (int i = 0; i < s.Length; i++) {
      if (text[i] == text[i + 1]) {
        count++;
      } else {
        answer.Append(text[i]);
        if (count > 1) answer.Append(count);
        count = 1;
      }
    }

    return answer.ToString();
  }
}

new Solution().Solve(string s)를 호출하고 압축한 string을 반환합니다. 예: new Solution().Solve("KKHSSSSSSSE") → "K2HS7E". Main과 표준 입력·출력은 필요하지 않습니다.

s.Length로 원래 길이만큼 순회합니다. StringBuilder.Append()는 문자와 정수 횟수를 덧붙이고, ToString()은 최종 string을 만듭니다. 정수 횟수를 문자 코드로 바꾸지 않으므로 10이나 100도 그대로 기록됩니다.
ABBA → AB2A처럼 묶음이 끝나면 count를 1로 되돌립니다. A → A는 횟수를 생략하고 ABCCC → ABC3은 마지막 문자를 공백 센티널과 비교해 처리합니다.
시간 O(n), 센티널 문자열·StringBuilder·반환 문자열을 포함한 추가 공간 O(n)입니다.