Usando C# para resolver um desafio de entrevista da Microsoft

using System;
using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;

/// <summary>
/// Fornece métodos para comprimir e descomprimir strings numéricas longas
/// usando uma abordagem Run-Length Encoding (RLE) com contagem em hexadecimal.
/// </summary>
public static class NumericCompressor
{
  // O caractere que separa a contagem (em hex) do dígito.
  // 'n' é usado para representar a ideia de "n vezes".
  private const char SEPARATOR = 'n';

  /// <summary>
  /// Comprime uma string numérica longa. Exemplo: "111122" se torna "4n12n2".
  /// </summary>
  public static string Compress(string longNumericString)
  {
      if (string.IsNullOrEmpty(longNumericString) || !Regex.IsMatch(longNumericString, @"^[0-9]+$"))
      {
          throw new ArgumentException("A string de entrada deve ser uma sequência numérica não nula.");
      }

      var compressedBuilder = new StringBuilder();
      int currentIndex = 0;

      while (currentIndex < longNumericString.Length)
      {
          char currentDigit = longNumericString[currentIndex];
          int count = 1;
          int nextIndex = currentIndex + 1;
          
          while (nextIndex < longNumericString.Length && longNumericString[nextIndex] == currentDigit)
          {
              count++;
              nextIndex++;
          }

          // Formato: [Contagem em Hex] + 'n' + [Dígito]
          compressedBuilder.Append($"{count:X}{SEPARATOR}{currentDigit}");
          currentIndex = nextIndex;
      }

      return compressedBuilder.ToString();
  }

  /// <summary>
  /// Descomprime uma string de volta para seu formato numérico original. Exemplo: "4n12n2" se torna "111122".
  /// </summary>
  public static string Decompress(string compressedString)
  {
      if (string.IsNullOrEmpty(compressedString))
      {
          throw new ArgumentException("A string de entrada não pode ser nula ou vazia.");
      }

      var decompressedBuilder = new StringBuilder();
      // A Regex encontra todos os padrões de "[ContagemHex]n[Dígito]"
      var matches = Regex.Matches(compressedString, $@"([0-9A-Fa-f]+){SEPARATOR}(\d)");

      foreach (Match match in matches)
      {
          string hexCount = match.Groups[1].Value;
          char digit = match.Groups[2].Value[0];

          int count = int.Parse(hexCount, NumberStyles.HexNumber);
          decompressedBuilder.Append(digit, count);
      }
      
      // Validação final para garantir que a string inteira corresponde ao padrão esperado
      if (decompressedBuilder.Length > 0 && compressedString != Compress(decompressedBuilder.ToString()))
      {
          throw new FormatException("O formato da string comprimida é inválido.");
      }

      return decompressedBuilder.ToString();
  }
}

public class Program
{
  public static void Main(string[] args)
  {
      // Exemplo 1: Sequência variada
      string original1 = "111112223333";
      string compressed1 = NumericCompressor.Compress(original1);
      string decompressed1 = NumericCompressor.Decompress(compressed1);

      Console.WriteLine("--- Exemplo 1 ---");
      Console.WriteLine($"Original:      {original1}");
      Console.WriteLine($"Comprimido:    {compressed1}"); // Saída: 5n13n24n3
      Console.WriteLine($"Descomprimido: {decompressed1}");
      Console.WriteLine($"Sucesso:       {original1 == decompressed1}");
      Console.WriteLine();

      // Exemplo 2: 4095 (FFF em hex) vezes o número 2
      string original2 = new string('2', 4095);
      string compressed2 = NumericCompressor.Compress(original2);
      string decompressed2 = NumericCompressor.Decompress(compressed2);

      Console.WriteLine("--- Exemplo 2: Contagem Grande ---");
      Console.WriteLine($"Original:      (4095 vezes o dígito '2')");
      Console.WriteLine($"Comprimido:    {compressed2}"); // Saída: FFFn2
      Console.WriteLine($"Descomprimido: (Comprimento: {decompressed2.Length})");
      Console.WriteLine($"Sucesso:       {original2 == decompressed2}");
  }
}