检测连续整数并折叠成字符串

Question

_{免责声明：A very similar question was already asked in a Python context here. 这是关于 C# 的。}

我有一个包含整数的枚举，例如：

[1, 2, 3, 4, 7, 8, 10, 11, 12, 13, 14]

我想获得一个字符串，输出连续整数的范围：

1-4, 7-8, 10-14

我想出了：

public static void Main()
{
    System.Diagnostics.Debug.WriteLine(FindConsecutiveNumbers(new int[] { 1,2, 7,8,9, 12, 15, 20,21 }));
}

private static string FindConsecutiveNumbers(IEnumerable<int> numbers)
{
    var sb = new StringBuilder();
    int? start = null;
    int? lastNumber = null;
    const string s = ", ";
    const string c = "-";

    var numbersPlusIntMax = numbers.ToList();
    numbersPlusIntMax.Add(int.MaxValue);
    foreach (var number in numbersPlusIntMax)
    {
        var isConsecutive = lastNumber != null && lastNumber + 1 == number;
        if (!isConsecutive)
        {
            if (start != null)
            {
                if (sb.Length > 0) { sb.Append(s); }
                if (start == lastNumber)
                {
                    sb.Append(start); ;
                }
                else
                {
                    sb.Append(start + c + lastNumber); ;
                }
            }

            start = number;
        }
                
        lastNumber = number;
    }

    return sb.ToString();
}

此算法适用于有序输入。是否有内置/LINQ/更短的 C# 方式来执行此操作？

Answer 1

int[] numbers = { 1, 2, 3, 4, 7, 8, 10, 11, 12, 13, 14 };

return string.Join(", ",
    numbers
        .Select((n, i) => new { value = n, group = n - i })
        .GroupBy(o => o.group)
        .Select(g => g.First().value + "-" + g.Last().value)
);

Answer 2

我建议分解：让我们将初始例程拆分为逻辑：

private static IEnumerable<(int left, int right)> Consecutive(IEnumerable<int> numbers) {
  int start = -1;
  int stop = -2;  

  foreach (var item in numbers) // numbers.OrderBy(x => x) to sort numbers
    if (item == stop + 1)
      stop = item;
    else {
      if (stop >= start)
        yield return (start, stop);

      start = item;
      stop = item;
    }  

  if (stop >= start)
    yield return (start, stop);  
}

和表示

private static string FindConsecutiveNumbers(IEnumerable<int> numbers) =>
  string.Join(", ", Consecutive(numbers)
    .Select(item => item.left == item.right 
       ? $"{item.left}" 
       : $"{item.left}-{item.right}"));

然后一切照旧：

public static void Main()
{
    // 1-2, 7-9, 12, 15, 20-21
    System.Diagnostics.Debug.WriteLine(FindConsecutiveNumbers(new int[] { 
      1, 2, 
      7, 8, 9, 
      12, 
      15, 
      20, 21 }
    ));
}

Answer 3

如果我们可以在 List 而不是枚举中获取数字，那么我们不需要访问所有数字。前面的答案的时间复杂度为 O(n)，其中 n 是数组的大小。而如果我们有一个列表，这个问题可以在 O(klogn) 中解决，其中 k 是组数。

基本上你可以使用稍微修改的二分搜索来找到一个组的终点，这可以在 O(logn) 中完成，然后从 end+1 开始，你可以为下一个组做同样的事情。