缩短一串数字

Question

我有以下数字序列：

您可以看到很多这些数字。我想缩短那个字符串。假设字符串包含超过 20 个数字，它应该显示 18 个数字，然后是“...”，然后是序列的最后两个。

我可以通过在 List<int> 或 HashSet<int> 中添加这些数字来做到这一点（在这种情况下 HashSet 可能更快），但我认为它会很慢。

StringBuilder temp = new StringBuilder();

for (...)
{
    temp.Append($"{number} ");
}

var sequence = temp.ToString();

我想要的示例：

7 9 12 16 18 21 25 27 30 34 36 39 43 45 48 52 54 57 ... 952 954

请注意，我只想要快速方法。

Answer 1

这个版本比其他答案快大约 8 倍，并且只分配大约 6% 的内存。我想你很难找到更快的版本：

static string Truncated(string input)
{
    var indexOfEighteenthSpace = IndexOfCharSeekFromStart(input, ' ', 18);
    if (indexOfEighteenthSpace <= 0) return input;

    var indexOfSecondLastSpace = IndexOfCharSeekFromEnd(input, ' ', 2);
    if (indexOfSecondLastSpace <= 0) return input;

    if (indexOfSecondLastSpace <= indexOfEighteenthSpace) return input;

    var leadingSegment = input.AsSpan().Slice(0, indexOfEighteenthSpace);
    var trailingSegment = input.AsSpan().Slice(indexOfSecondLastSpace + 1);

    return string.Concat(leadingSegment, " ... ", trailingSegment);

    static int IndexOfCharSeekFromStart(string input, char value, int count)
    {
       var startIndex = 0;
       for (var i = 0; i < count; i++)
       {
           startIndex = input.IndexOf(value, startIndex + 1);
           if (startIndex <= 0) return startIndex;
       }

        return startIndex;
    }

    static int IndexOfCharSeekFromEnd(string input, char value, int count)
    {
       var endIndex = input.Length - 1;
       for (var i = 0; i < count; i++)
       {
           endIndex = input.LastIndexOf(value, endIndex - 1);
           if (endIndex <= 0) return endIndex;
       }

        return endIndex;
    }
}   

Answer 2

单独的小步骤

如何从这个序列（字符串）中创建一个列表？

var myList = myOriginalSequence.Split(' ').ToList();

如何从列表中取出前 18 个数字？

var first18Numbers = myList.Take(18);

如何从列表中取出最后 2 个数字？

var last2Numbers = myList.Skip(myList.Count() - 2);

您如何确保仅当列表中的数字超过 20 个时才执行此操作？

if(myList.Count() > 20)

如何从列表中创建一个新的序列字符串？

var myNewSequence = String.Join(" ", myList);

---

把它们放在一起

var myList = myOriginalSequence.Split(' ').ToList();

string myNewSequence;

if(myList.Count() > 20)
{
    var first18Numbers = myList.Take(18);
    var first18NumbersString = String.Join(" ", first18Numbers);

    var last2Numbers = myList.Skip(myList.Count() - 2);
    var last2NumbersString = String.Join(" ", last2Numbers);

    myNewSequence = $"{first18NumbersString} ... {last2NumbersString}"
}
else
{
    myNewSequence = myOriginalSequence;
}

Console.WriteLine(myNewSequence);

Answer 3

试试这个：

public string Shorten(string str, int startCount, int endCount)
    {
        //first remove any leading or trailing whitespace
        str = str.Trim();

        //find the first startCount numbers by using IndexOf space
        //i.e. this counts the number of spaces from the start until startCount is achieved
        int spaceCount = 1;
        int startInd = str.IndexOf(' ');
        while (spaceCount < startCount && startInd > -1)
        {
            startInd = str.IndexOf(' ',startInd +1);
            spaceCount++;
        }

        //find the last endCount numbers by using LastIndexOf space
        //i.e. this counts the number of spaces from the end until endCount is achieved
        int lastSpaceCount = 1;
        int lastInd = str.LastIndexOf(' ');
        while (lastSpaceCount < endCount && lastInd > -1)
        {
            lastInd =  str.LastIndexOf(' ', lastInd - 1);
            lastSpaceCount++;
        }

        //if the start ind or end ind are -1 or if lastInd <= startIndjust return the str 
        //as its not long enough and so doesn't need shortening
        if (startInd == -1 || lastInd == -1 || lastInd <= startInd) return str;

        //otherwise return the required shortened string
        return $"{str.Substring(0, startInd)} ... {str.Substring(lastInd + 1)}";
    }

这个的输出：

 Console.WriteLine(Shorten("123 123 123 123 123 123 123 123 123 123 123",4,3));

是：

123 123 123 123 ... 123 123 123

Answer 4

我认为这可能会有所帮助：

    public IEnumerable<string> ShortenList(string input)
    {
       List<int> list = input.Split(" ").Select(x=>int.Parse(x)).ToList();
        if (list.Count > 20)
        {
            List<string> trimmedStringList = list.Take(18).Select(x=>x.ToString()).ToList();
            trimmedStringList.Add("...");
            trimmedStringList.Add(list[list.Count-2].ToString());
            trimmedStringList.Add(list[list.Count - 1].ToString());

            return trimmedStringList;
        }

        return list.Select(x => x.ToString());
    }

Answer 5

不知道这会是什么速度，但作为一个疯狂的建议，你说数字是字符串格式的，看起来它们是用空格分隔的。您可以使用here 找到的任何方法获取第 19 个空格的索引（显示 18 个数字），以及从索引 0 到该索引的子字符串并连接 3 个点。像这样的：

numberListString.SubString(0, IndexOfNth(numberListString, ' ', 19)) + "..."

（可能需要不准确的代码，增加或减少索引或调整值（19）。

编辑：刚刚看到在您想要最后 2 个数字的点之后，您可以使用相同的技术！只需再次连接该结果即可。

注意：我使用这种古怪的技术是因为 OP 说他们想要快速的方法，我只是提供了一个潜在的基准选项:)

Answer 6

有一种替代方法可以防止对整个数字字符串进行迭代，而且速度相当快。

.NET 中的字符串基本上是一个字符数组，可以使用数组引用 ([1..n]) 单独引用。这可以通过简单地分别从开始和结束测试正确的空格数来利用我们的优势。

代码中没有任何细节，但可以稍后对其进行优化（例如，通过确保字符串中确实存在某些内容、字符串被修剪等）。

如果您感觉精力充沛，也可以将以下功能优化为单个功能。

string finalNumbers = GetStartNumbers(myListOfNumbers, 18);
if(finalNumbers.EndsWith(" ... "))
    finalNumbers += GetEndNumbers(myListOfNumbers, 2);


public string GetStartNumbers(string listOfNumbers, int collectThisManyNumbers) 
{
    int spaceCounter = 0;    //  The current count of spaces
    int charPointer = 0;     //  The current character in the string
    //  Loop through the list of numbers until we either run out of characters
    //  or get to the appropriate 'space' position...
    while(spaceCounter < collectThisManyNumbers && charPointer <= listOfNumbers.Length)
    {
        //  The following line will add 1 to spaceCounter if the character at the
        //  charPointer position is a space. The charPointer is then incremented...
        spaceCounter += ( listOfNumbers[charPointer++]==' ' ? 1 : 0 );
    }
    //  Now return our value based on the last value of charPointer. Note that
    //  if our string doesn't have the right number of elements, then it will
    //  not be suffixed with ' ... '
    if(spaceCounter < collectThisManyNumbers) 
        return listOfNumbers.Substring(0, charPointer - 1);
    else
        return listOfNumbers.Substring(0, charPointer - 1) + " ... ";
}

public string GetEndNumbers(string listOfNumbers, int collectThisManyNumbers) 
{
    int spaceCounter = 0;                       //  The current count of spaces
    int charPointer = listOfNumbers.Length;     //  The current character in the string
    //  Loop through the list of numbers until we either run out of characters
    //  or get to the appropriate 'space' position...
    while(spaceCounter < collectThisManyNumbers && charPointer >= 0)
    {
        //  The following line will add 1 to spaceCounter if the character at the
        //  charPointer position is a space. The charPointer is then decremented...
        spaceCounter += ( listOfNumbers[charPointer--]==' ' ? 1 : 0 );
    }
    //  Now return our value based on the last value of charPointer...
    return listOfNumbers.Substring(charPointer);
}

有些人认为++ 和-- 的使用令人反感，但这取决于您。如果你想做数学和逻辑，把自己搞砸！

请注意，这段代码很长，因为它被注释到了屁的远端。