比较来自世界各地的卖家的域名和 IT 服务价格

旋转到正确的阵列 int 在 c#?

我有一个功课：

需要实现一个函数 /RotateRight/, 接收数组 INT 和数字：


int[] res = RotateRight/new int[] { 1, 2, 3, 4, 5, 6 }, 2/;

//so then res will be {5,6,1,2,3,4}


并根据指定号码将所有元素转换为右侧的所有元素，在我们的情况下返回阵列 2.

我必须在记忆空间方面有效地进行。

我最好的想法：

如果给出的数字是相等的 x, 使用新 int[] tmpArray 尺寸 x, 将它复制到最后一切 X 元素。 然后用帮助 for loop 转移一切 rest int 对。
最后，复制元素 tmpArray 到源数组的开头。

提前感谢任何建议或帮助。
2021-04-04 添加评论
分享

没有找到相关结果

    已邀请:

    知食

    赞同来自:

    你可以使用语言的美丽。 Linq, 返回 IEnumerable, 不处理数组大小：


    /// <summary>
    
/// Get c = a mod /b/ with c in [0, b[ like the mathematical definition
    
/// </summary>
    
public static int MathMod/int a, int b/
    
{
    
 int c = //a % b/ + b/ % b;
    
 return c;
    
}
    
public static IEnumerable<t> ShiftRight<t>/IList<t> values, int shift/
    
{
    
 for /int index = 0; index &lt; values.Count; index++/
    
 {
    
 yield return values[MathMod/index - shift, values.Count/];
    
 }
    
}


    使用 :


    [TestMethod]
    
public void TestMethod1//
    
{
    
 var res = ShiftRight/new [] { 1, 2, 3, 4, 5, 6 }, 2/.ToArray//;
    
 Assert.IsTrue/res.SequenceEqual/new[] { 5, 6, 1, 2, 3, 4 }//;
    
}


    </t></t></t>
    2021-04-05 0 0
    分享

    小明明

    赞同来自:

    大多数可能的内存都没有意义，你可能铭记尽可能少的记忆？ 如果是这样，那么您必须使用阵列的每个元素 XOR, IE：


    var a = 2096;
    
var b = 842390;
    

    
a ^= b;
    
b ^= a;
    
a ^= b;


    会在地方改变这些数字。

    EDIT

    要完成所有这些代码：


    public static void RotateRight/int[] input, int right/
    
 {
    
 for /var i = 0; i < right; i += 1/
    
 {
    
 RotateRightOne/input/;
    
 }
    
 }
    

    
 public static void RotateRightOne/int[] input/
    
 {
    
 var last = input.Length - 1;
    
 for /var i = 0; i < last; i += 1/
    
 {
    
 input[i] ^= input[last];
    
 input[last] ^= input[i];
    
 input[i] ^= input[last];
    
 }
    
 }


    使用：


    var arr = new[] {1, 2, 3, 4, 5, 6};
    
 RotateRight/arr, 2/;


    当服务指示时，它只适用于整数
    2021-04-05 0 0
    分享

    小明明

    赞同来自:

    我不知道 C#,, 但这两个版本 C++, 两者都在现场，第一个 /
    rotate

    / 使用旋转重排的循环结构，使元件的最小可能数量的变动，第二个 /
    rotate_k

    / 刚事
    2*n

    数组长度的位移
    n

    . 在两个版本中，它使用它转向右侧
    k

    - 这是相同的 , 那左转
    n - k % n

    , 因此，它们实际上对左侧进行了等效的旋转。


    #include <iostream>
    
#include <vector>
    
#include <algorithm>
    

    
void
    
rotate /size_t k, std::vector<int> &amp;a/ {
    
 size_t n = a.size//;
    
 k = n - k % n;
    

    
 size_t m = n;
    

    
 size_t i = 0;
    
 while /m &gt; 0/ {
    
 int t = a[i];
    
 size_t j = i;
    
 while /i != /j + k/ % n/ {
    
 a[j] = a[/j + k/ % n];
    
 j = /j + k/ % n;
    
 --m;
    
 }
    
 a[j] = t;
    
 --m;
    
 ++i;
    
 }
    
}
    

    
void
    
rotate_k /size_t k, std::vector<int> &amp;a/ {
    
 size_t n = a.size//;
    

    
 k = n - k % n;
    

    
 std::reverse /a.begin//, a.end///;
    
 std::reverse /a.begin//, a.begin// + n - k/;
    
 std::reverse /a.begin// + n - k, a.end///;
    
}
    

    
int
    
main // {
    
 std::vector<int> a = { 1, 2, 3, 4, 5, 6, 7, 8, 9};
    
 rotate /12, a/;
    

    
 for /auto i : a/
    
 std::cout &lt;&lt; i &lt;&lt; " ";
    

    
 std::cout &lt;&lt; std::endl;
    
}


    </int></int></int></algorithm></vector></iostream>
    2021-04-05 0 0
    分享

    冰洋

    赞同来自:

    您只需要在旋转后计算每个项目的最终索引。 k 一旦，实际上并没有旋转它 k 时间。
    它为我工作：


    for/int i=0;i<a.length;i++ %="" <="" ]="a[i];" a.length="" code]="" div="" k+i="" rotated[="" {="" }[="">
    
<div class="answer_text">
    
这是阵列转弯的一个简短示例 a 对 K 脚步：
    

    

    
[code]var splitPoint=A.Length-/K%A.Length/;
    

    
 var result=new int[A.Length];
    
 int idx=0;
    
 for/var pos=0;pos<a.length;pos++ <="" code]="" div="" else="" idx++;="" if="" pos<a.length-splitpoint="" result;[="" result[pos]="A[idx];" return="" {="" }="">
    
<div class="answer_text">
    
C# 8 现在有
    
[url=https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#indices-and-ranges]https://docs.microsoft.com/en- ... anges[/url]
    
右转...
    

    

    
[code]int[] r = t[1..].Concat/t[0..1]/.ToArray//;


    转左 ...


    int[] r = t[^1..^0].Concat/t[..^1]/.ToArray//;


    反而 "1" 您还可以使用上面的变量：
    int[] r = t[amt..].Concat/t[0..amt]/.ToArray//;


    </div>
    </a.length;pos++></div></a.length;i++>
    2021-04-05 0 0
    分享

    裸奔

    赞同来自:

    这是阵列转弯的一个简短示例 a 对 K 脚步：


    var splitPoint=A.Length-/K%A.Length/;
    

    
 var result=new int[A.Length];
    
 int idx=0;
    
 for/var pos=0;pos<a.length;pos++ <="" code]="" div="" else="" idx++;="" if="" pos<a.length-splitpoint="" result;[="" result[pos]="A[idx];" return="" {="" }="">
    
<div class="answer_text">
    
C# 8 现在有
    
[url=https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#indices-and-ranges]https://docs.microsoft.com/en- ... anges[/url]
    
右转...
    

    

    
[code]int[] r = t[1..].Concat/t[0..1]/.ToArray//;


    转左 ...


    int[] r = t[^1..^0].Concat/t[..^1]/.ToArray//;


    反而 "1" 您还可以使用上面的变量：
    int[] r = t[amt..].Concat/t[0..amt]/.ToArray//;


    </div>
    </a.length;pos++>
    2021-04-06 0 0
    分享

    董宝中

    赞同来自:

    C# 8 现在有
    https://docs.microsoft.com/en- ... anges
    右转...


    int[] r = t[1..].Concat/t[0..1]/.ToArray//;


    转左 ...


    int[] r = t[^1..^0].Concat/t[..^1]/.ToArray//;


    反而 "1" 您还可以使用上面的变量：
    int[] r = t[amt..].Concat/t[0..amt]/.ToArray//;
    2021-04-06 0 0
    分享
    为什么被折叠? 0 个回复被折叠

    要回复问题请先登录或注册

    Copyright © 2023, All Rights Reserved