Замена не являющиеся частые элементы в sequencial C#

Question

У меня есть массив, содержащий целые числа

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-способ для этого.

Любые предложения?

Answer 1

Просто используйте OrderBy FUNC так:

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

Answer 2

Используйте вид и регулярное выражение, как этот

 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); 
     }​ 

Answer 3

Было бы трудно, если не невозможно реализуйте это только в 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; 
     } 
    } 
} 

EDIT:

Предыдущая программа не была правильной, потому что она не смотрела на обоих adjectant полях , Таким образом, программа не работала для тестового примера в вашем вопросе. Так что это новый ответ. Он просматривает оба поля прилагательного, и если текущее значение отличается от обоих, оно заменяет текущее значение слева. Также он заботится о краях. Если длина меньше 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; 
     } 
    } 
} 

Адрес ideone.