C# 使用LINQ语法旋转数组

我正在解决这个旋转数组的问题，并且得到了算法和代码

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

int[]旋转（int[]ar，int-k）
{
if（k ar长度-1）
返回ar；
反向（ar，0，k-1）；
反向（ar，k，ar.长度-1）；
反向（ar，0，ar.长度-1）；
返回ar；
}
无效反向（int[]ar，int开始，int结束）
{
while（开始<结束）
{
int temp=ar[启动]；
应收账款[开始]=应收账款[结束]；
ar[结束]=温度；
启动++；
结束--；
}
}

现在我想在LINQ中做这个，我得到了下面的代码，我认为这可以做得更好

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

int[]旋转（int[]ar，int-k）
{
if（k ar长度-1）
返回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（）；
返回ar3；
}

这是一个来自编程pearls的著名算法-

---

一般来说，如何发展我的LINQ技能，如果给我一个编程问题，现在我只考虑for循环或foreach循环，如何考虑LINQ操作符。我在读C#4.0简而言之，除了练习任何建议

老实说，我不知道你为什么有这么多反面。这个怎么样：

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
}

int[]旋转（int[]ar，int-k）
{
if（k ar长度-1）
返回ar；
返回ar.Skip（k）//从最后一个元素开始
.Concat（ar.Take（k））//然后是第一个元素
.ToArray（）；//然后将其设为数组
}

下面是一个简短但完整的程序来演示：

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

使用系统；
使用System.Linq；
课堂测试
{
静态int[]旋转（int[]ar，int k）
{
if（k ar长度-1）
返回ar；
返回ar.Skip（k）//从最后一个元素开始
.Concat（ar.Take（k））//然后是第一个元素
.ToArray（）；//然后将其设为数组
}
静态void Main（）
{
int[]值={1,2,3,4,5}；
int[]旋转=旋转（值3）；
Console.WriteLine（string.Join（“，”，旋转））；
}
}

输出：4,5,1,2,3

编辑：我刚刚注意到我的代码和你的原始代码之间的一个主要区别：你的代码修改了原始数组-我的代码返回一个带有旋转值的新数组。你的LINQ代码也是如此，但这意味着如果你用只看原始数组的东西测试我的代码，你将看不到旋转

---

LINQ一般都是这样设计的——它倾向于返回一个新序列，而不是修改一个现有序列。

老实说，我不知道为什么会有所有的反转。这个怎么样：

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
}

int[]旋转（int[]ar，int-k）
{
if（k ar长度-1）
返回ar；
返回ar.Skip（k）//从最后一个元素开始
.Concat（ar.Take（k））//然后是第一个元素
.ToArray（）；//然后将其设为数组
}

下面是一个简短但完整的程序来演示：

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

使用系统；
使用System.Linq；
课堂测试
{
静态int[]旋转（int[]ar，int k）
{
if（k ar长度-1）
返回ar；
返回ar.Skip（k）//从最后一个元素开始
.Concat（ar.Take（k））//然后是第一个元素
.ToArray（）；//然后将其设为数组
}
静态void Main（）
{
int[]值={1,2,3,4,5}；
int[]旋转=旋转（值3）；
Console.WriteLine（string.Join（“，”，旋转））；
}
}

输出：4,5,1,2,3

编辑：我刚刚注意到我的代码和你的原始代码之间的一个主要区别：你的代码修改了原始数组-我的代码返回一个带有旋转值的新数组。你的LINQ代码也是如此，但这意味着如果你用只看原始数组的东西测试我的代码，你将看不到旋转

---

LINQ一般都是这样设计的——它倾向于返回新序列而不是修改现有序列。

从代码开始：

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(); 

因为您只想获取所有剩余的元素，所以不需要第二行中的Take

ar1和ar2只是枚举的，所以它们不需要是数组。不需要ToArray电话。通过一些创造性的重命名，我们有：

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

将相同的操作应用于代码会

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

---

现在我们有了Jon Skeet的答案，所以我们必须完成。

从您的代码开始：

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(); 

因为您只想获取所有剩余的元素，所以不需要第二行中的Take

ar1和ar2只是枚举的，所以它们不需要是数组。不需要ToArray电话。通过一些创造性的重命名，我们有：

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

将相同的操作应用于代码会

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

现在我们得到了Jon Skeet的答案，所以我们必须完成。

这是我的解决方案

public int[] solution(int[] A, int K) {
        // write your code in C# 6.0 with .NET 4.5 (Mono)
        if (A.Length <= 1)
        {
            return A;
        }
        var rotate = K % A.Length;

        var leftSide = A.Length - rotate;
        var arr1 = A.AsParallel().Skip(leftSide).Take(rotate);
        var arr2 = A.AsParallel().Take(leftSide);

        return arr1.Concat(arr2).ToArray();
}

public int[]解决方案（int[]A，int[]K）{
//用C#6.0和.NET4.5（Mono）编写代码
如果（A.Length这是我的解决方案

public int[] solution(int[] A, int K) {
        // write your code in C# 6.0 with .NET 4.5 (Mono)
        if (A.Length <= 1)
        {
            return A;
        }
        var rotate = K % A.Length;

        var leftSide = A.Length - rotate;
        var arr1 = A.AsParallel().Skip(leftSide).Take(rotate);
        var arr2 = A.AsParallel().Take(leftSide);

        return arr1.Concat(arr2).ToArray();
}

public int[]解决方案（int[]A，int[]K）{
//用C#6.0和.NET4.5（Mono）编写代码
如果（A.Length）这是扩展方法语法。LINQ语法将以…
中的
开始。是的，但是使用LINQ来引用lambdas/Enumerable…我担心cat是完全出格的。：（@Marcelo Cantos，您指的是查询理解语法。没有“LINQ语法”这样的东西.@Marcelo Cantos-这些扩展方法在System.Linq命名空间中。@Thomas:谢谢你指出这一点；我得到了更正。我一直认为Linq专门用于查询语法，但在MSDN上阅读表明并非如此。这是扩展方法语法。Linq synt