Faire pivoter un tableau en utilisant la syntaxe LINQ

Question

Je résoudre ce problème de la rotation d'un tableau et obtenu algorithme et le code de travail

int[] Rotate(int[] ar,int k) 
     { 
      if (k <= 0 || k > ar.Length - 1) 
       return ar; 
      Reverse(ar, 0, k - 1); 
      Reverse(ar, k, ar.Length - 1); 
      Reverse(ar, 0, ar.Length - 1); 
      return ar;    
     } 

void Reverse(int[] ar,int start, int end) 
     { 
      while (start < end) 
      { 
       int temp = ar[start]; 
       ar[start] = ar[end]; 
       ar[end] = temp; 
       start++; 
       end--; 
      } 
     } 

Maintenant, je veux faire dans LINQ et moi avons le code ci-dessous, je pense que cela peut être fait beaucoup mieux.

int[] Rotate(int[] ar,int k) 
    { 
     if (k <= 0 || k > ar.Length - 1) 
      return ar; 
     int[] ar1=ar.Take(k-1).Reverse().ToArray(); 
     int[] ar2=ar.Skip(k - 1).Take(ar.Length - k+1).Reverse().ToArray(); 
     int[] ar3 = ar1.Concat(ar2).Reverse().ToArray(); 
     return ar3; 
    } 

Ceci est un algorithme bien connu de perles de programmation - http://books.google.com/books?id=kse_7qbWbjsC&lpg=PA14&ots=DfzTzQCSar&dq=rotate%20an%20array%20programming%20pearls&pg=PA14#v=onepage&q&f=false

Et en général comment développer mes compétences LINQ, si on me donne un problème de programmation, en ce moment je ne pense à des boucles ou foreach boucles, comment penser en termes d'opérateurs linq. Je lis C# 4.0 en bref, autre que de pratiquer des conseils?

Answer 1

A partir de votre code:

int[] ar1=ar.Take(k-1).Reverse().ToArray(); 
int[] ar2=ar.Skip(k - 1).Take(ar.Length - k+1).Reverse().ToArray(); 
int[] ar3 = ar1.Concat(ar2).Reverse().ToArray(); 

Puisque vous voulez juste obtenir tous les éléments restants, la Prenez dans la deuxième ligne n'est pas nécessaire. Ar1 et ar2 sont juste énumérés, donc ils n'ont pas besoin d'être des tableaux. Les appels ToArray ne sont pas nécessaires. Avec un peu de changement de nom créatif jeté dans, nous avons:

IEnumerable<int> revFirst = ar.Take(k-1).Reverse(); 
IEnumerable<int> revLast = ar.Skip(k-1).Reverse(); 
int[] ar3 = revFirst.Concat(revLast).Reverse().ToArray(); 

Maintenant, nous avons

rev (rev (premier) + rev (dernier))

distribuer le rev externe donne

rev (rev (dernier)) + rev (rev (premier))

qui est le même que

last + first 

appliquant les mêmes opérations au code donne

IEnumerable<int> first = ar.Take(k-1); 
IEnumerable<int> last = ar.Skip(k-1); 
int[] ar3 = last.Concat(first).ToArray(); 

ce qui simplifie encore à

int[] ar3 = ar.Skip(k-1).Concat(ar.Take(k-1)).ToArray(); 

et nous avons maintenant la réponse de Jon Skeet nous devons donc être fait.

Answer 2

Je ne sais pas pourquoi vous avez tous les retournements, pour être honnête. Que diriez-vous ceci:

int[] Rotate(int[] ar,int k) 
{ 
    if (k <= 0 || k > ar.Length - 1) 
     return ar; 
    return ar.Skip(k)   // Start with the last elements 
      .Concat(ar.Take(k)) // Then the first elements 
      .ToArray();   // Then make it an array 
} 

Voici un programme court mais complet pour le démontrer:

using System; 
using System.Linq; 

class Test 
{ 
    static int[] Rotate(int[] ar,int k) 
    { 
     if (k <= 0 || k > ar.Length - 1) 
      return ar; 
     return ar.Skip(k)   // Start with the last elements 
       .Concat(ar.Take(k)) // Then the first elements 
       .ToArray();   // Then make it an array 
    } 

    static void Main() 
    { 
     int[] values = { 1, 2, 3, 4, 5 }; 
     int[] rotated = Rotate(values, 3); 

     Console.WriteLine(string.Join(", ", rotated)); 
    } 
} 

Sortie: 4, 5, 1, 2, 3

EDIT: Je viens de remarquer une différence majeure entre mon code et votre original: le vôtre modifie le tableau d'origine - le mien renvoie un nouveau tableau nouveau avec les valeurs tournées. De même que votre code LINQ, mais cela signifie que si vous étiez en train de tester mon code avec quelque chose qui ne regardait que le tableau d'origine, vous ne verriez pas la rotation.

LINQ est conçu pour fonctionner de cette manière en général - il favorise le retour d'une nouvelle séquence plutôt que la modification d'une séquence existante.