C# 替换顺序c中的非频繁元素

我有一个包含整数的数组

1,1,2,1,1,2,2,2,3,3,3,2,4,4,4,4  

我希望能够替换不能完成序列重复顺序的元素，因此从上面的示例来看

1,1,1,1,1,2,2,2,3,3,3,3,4,4,4,4.      

我尝试过使用一些丑陋的扩展功能，但我喜欢循环，但我也是如此

想知道是否有一个整洁的LINQ方法来做到这一点

---

有什么建议吗？

只需像这样使用orderBy func：

List<int> list = new List<int>() { //your data };
list = list.OrderBy(i=> i);

---

像这样使用sort和regex

        static void Main(string[] args)
        {
            string input = "00H1,00H1,00H2,00H1,00H1,00H2,00H2,00H2,00H3,00H3,00H2,00H3";
            List<string> array = input.Split(new char[] { ',' }).ToList();
            array.Sort((x,y) => GetSuffix(x).CompareTo(GetSuffix(y)));
            string output = string.Join(",",array);


        }
        static int GetSuffix(string input)
        {
            string pattern = "H(?'suffix'\\d*)";
            Match match = Regex.Match(input, pattern);
            return int.Parse(match.Groups["suffix"].Value);
        }​

这是Linq解决方案

       static void Main(string[] args)
        {
            string input = "00H1,00H1,00H2,00H1,00H1,00H2,00H2,00H2,00H3,00H3,00H2,00H3";
            List<string> array = input.Split(new char[] { ',' }).ToList();

            array = array.Select(x => new
            {
                suffix = GetSuffix(x),
                item = x
            }).OrderBy(x => x.suffix).Select(x => x.item).ToList();

            string output = string.Join(",",array);


        }
        static int GetSuffix(string input)
        {
            string pattern = "H(?'suffix'\\d*)";
            Match match = Regex.Match(input, pattern);
            return int.Parse(match.Groups["suffix"].Value);
        }​

---

仅在LINQ中实现这一点即使不是不可能，也是很困难的。如果您希望具有您描述的功能性，则必须实现以下方法：

using System;

namespace LinqSequence
{
    class Program
    {
        static void Main(string[] args)
        {
            var arr = new int[]
            {
                1,1,2,2,2,1,2,3,3,3,2,4,4,4,5,5,4,4
            };
            var newArr = SequenceReplace(arr);
            Console.WriteLine(String.Join(", ",newArr));
            //OUT: 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 5
        }
        static int[] SequenceReplace(int[] arr) 
        {
            int length = arr.Length;
            var newArr = new int[length];
            int previous = 0;

            for (int i = 0; i < length; i++)
            {
                if (newArr[previous] > arr[i]) 
                {
                    newArr[i] = newArr[previous];
                }
                else
                {
                    newArr[i] = arr[i];
                }
                previous = i;
            }
            return newArr;
        }
    }
}

编辑： 前面的程序不正确，因为它没有同时查看两个邻接字段。所以这个程序对你问题中的测试用例不起作用。这就是新的答案。它观察两个邻接场，如果电流与两个邻接场不同，它将用左边的一个取代电流。它还处理边缘情况。如果长度小于2，则返回该数组；如果长度为2，则返回包含2个元素0的数组。如果没有下一个元素，它将用上一个元素替换该元素

using System;

namespace LinqSequence
{
    class Program
    {
        static void Main(string[] args)
        {
            var arr1 = new int[]
            {
                1,1,2,1,1,2,2,2,3,3,3,2,4,4,4,4
            };

            var newArr1 = SequenceReplace(arr1);
            Console.WriteLine(String.Join(",",newArr1));
            //OUT: 1,1,1,1,1,2,2,2,3,3,3,3,4,4,4,4

            var arr2 = new int[]
            {
                1,1,2,2,2,1,2,3,3,3,2,4,4,4,5,5,4,4
            };
            var newArr2 = SequenceReplace(arr2);
            Console.WriteLine(String.Join(",",newArr2));
            //OUT: 1,1,2,2,2,2,2,3,3,3,3,4,4,4,5,5,4,4
        }
        static int[] SequenceReplace(int[] arr) 
        { 
            int length = arr.Length;
            if (length == 2) return new int[] { arr[0], arr[0] };
            else if (length < 2) return arr;
            var newArr = new int[length];
            newArr[0] = arr[0];
            int previous = 0, next = 2;

            for (int i = 1; i < length; i++)
            {
                if ((next < length &&
                    newArr[previous] != arr[i] && 
                    arr[next] != arr[i]) ||
                    next >= length)
                {
                    newArr[i] = newArr[previous];
                }
                else
                {
                    newArr[i] = arr[i];
                }
                previous++;
                next++;
            }
            return newArr;
        }
    }
}

---

这是。

如果他得到的数字像是1 1 2 1 5 4怎么办？他希望结果是1 1 1 5 4 4，那么订购它并不能解决问题。订购任何东西都不是问题，而是用当前的号码替换一个坏了的号码谢谢。但我遇到的问题是，我必须将这些数字从字符串中切掉，然后进行比较。比如00H1,00H1,00H2,00H1,00H1,00H2,00H2,00H3,00H3,00H2,00H3。我需要的是寻找那些不符合顺序的，比如00H2，在这种情况下，它们之间的数字不会太多，比如00H1，00H2，00H1。因此，我将00H2替换为00H1，然后继续下一个。。Thanx如果原始序列是1,1,2,2,2,1,2,3,3,2,4,4,4,5,5,4,4，这可能会升级为一个非常复杂的问题除了@Steve comment之外，如果输入是1,1,2,2,2,1,2,3,3,3,2,4,4,4,1,5,4怎么办？@shay_uuuuuuuu粗体1将变成4@Miro Bels您可以编辑这个问题并用字符串提取更彻底地描述这个问题吗。解释要比较字符串的哪一部分或整个字符串。还包括更多的测试示例和您当前使用的代码，如果您从internet提取字符串以将其包含在数组中，则可能会将其改编为测试。当用户只想更改顺序时，为什么要使用替换？我的解决方案更好。@jdweng如果你仔细看这个问题，这与顺序无关，这是一个序列，如果元素不符合，则用序列中先前已知的数字递增的序列替换当前序列数。@jdweng您是否至少查看了OP给出的输入的预期输出？输入中没有像输出中那样的5个1。这不是分类，但我不知道还能告诉你什么来说服你。另外，我的评论来自上一个答案，而不是我下一个发布的编辑。因此，请看更新后的答案中更清晰的地方。@jdweng请看上面包含的ideone示例，并查看通用方法。我一直在看Mirro的更新注释。看起来他正在尝试对字母数字字符串进行排序：谢谢。但我遇到的问题是，我必须将这些数字从字符串中切掉，然后进行比较。比如00H1,00H1,00H2,00H1,00H1,00H2,00H2,00H3,00H3,00H2,00H3。我需要的是寻找那些不符合顺序的，比如00H2，在这种情况下，它们之间的数字不会太多，比如00H1，00H2，00H1。因此，我将00H2替换为00H1，然后继续下一个。。为什么有人把它评为-1？很好的解决方案。