blocks|key|5338378|text|这种解决方案需要持续不断的额外内存，并且运行时间为O(nk)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5338379|如果数组的长度为零，或者旋转为零，则跳过循环并返回arr。|5338380|对于每一次旋转，我们存储第一个元素，然后将其他元素向左移动，最后将第一个元素放在列表的后面。我们通过认识到第n次之后的每一次旋转都是重复的解->+k%25+n，从而为大的k值节省了一些工作。|5338381|def+array_left_rotation(arr,+n,+k):
++++for+_+in+range(0+if+0+in+[n,+k]+else+k+%25+n):
++++++++temp+=+arr[0]
++++++++for+idx+in+range(n+-+1):
++++++++++++arr[idx]+=+arr[idx+%2B+1]
++++++++arr[-1]+=+temp
++++return+arr|code-block|syntax|javascript|5338382|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This solution requires constant extra memory, and runs in O(nk). 

If the array has zero length, or there are zero rotations, skip the loop and return arr. 

For every rotation we store the first element, then shift every other element to the left, finally placing the first element at the back of the list. We save some work for large values of k by recognizing that every rotation after the nth is a repeat solution -> k % n.

<pre><code>def array_left_rotation(arr, n, k):
 for _ in range(0 if 0 in [n, k] else k % n):
 temp = arr[0]
 for idx in range(n - 1):
 arr[idx] = arr[idx + 1]
 arr[-1] = temp
 return arr
</code></pre>

blocks|key|3225928|text|一种方法是使用collections.deque|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3225929|from+collections+import+deque
k+=+2
l+=+[1,+2,+3,+4,+5]
dl+=+deque(l)
dl.rotate(k%2B1)
list(dl)
#[3,+4,+5,+1,+2]|code-block|syntax|javascript|3225930|entityMap^0|7|H|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

One way you can do is by using <code>collections.deque</code>

<pre><code>from collections import deque
k = 2
l = [1, 2, 3, 4, 5]
dl = deque(l)
dl.rotate(k+1)
list(dl)
#[3, 4, 5, 1, 2]
</code></pre>

blocks|key|3225969|text|在索引的帮助下，另一种方法如下所示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3225970|def+rotate(l,+n):
++++return+l[n:]+%2B+l[:n]

print(rotate([1,+2,+3,+4,+5],+2))

#output+:+[3,+4,+5,+1,+2]|code-block|syntax|javascript|3225971|这只会在n超出[-len(l),+len(l)]范围时返回原始列表。要使其适用于n的所有值，请使用：|offset|length|style|CODE|3225972|def+rotate(l,+n):
++return+l[-n+%25+len(l):]+%2B+l[:-n+%25+len(l)]|3225973|entityMap^0|0|0|7|H|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Another way to do this with the help of indexing is shown below..

<pre><code>def rotate(l, n):
 return l[n:] + l[:n]

print(rotate([1, 2, 3, 4, 5], 2))

#output : [3, 4, 5, 1, 2]
</code></pre>

This will only return the original list if n is outside the range <code>[-len(l), len(l)]</code>. To make it work for all values of n, use:

<pre><code>def rotate(l, n):
 return l[-n % len(l):] + l[:-n % len(l)]
</code></pre>

blocks|key|321535|text|N,+d+=+map(int,+input().split())+++++#taking+length+N+and+no.+of+rotations+d
a+=+list(input().split())++++++++++++#taking+input+array+as+list
r+=+a[d+%25+N+:+N]+%2B+a[0+:+d+%25+N]++++++#rotating+the+array(list)
print(r)++

5+2++++++++++++++++++++++++++++#giving+N,D+as+input
1+2+3+4+5++++++++++++++++++++++#giving+input+array
['3',+'4',+'5',+'1',+'2']++++++#output|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|321536|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>N, d = map(int, input().split()) #taking length N and no. of rotations d
a = list(input().split()) #taking input array as list
r = a[d % N : N] + a[0 : d % N] #rotating the array(list)
print(r) 

5 2 #giving N,D as input
1 2 3 4 5 #giving input array
['3', '4', '5', '1', '2'] #output
</code></pre>

blocks|key|3225987|text|我是这样做的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3225988|def+rotate_left3(nums):
++++return+[+nums[1]+,+nums[2]+,+nums[0]+]|code-block|syntax|javascript|3225989|它100%25完美地工作，但如果你添加更多的和，你必须为问题指定的3添加它的just集合。|3225990|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This is how I did it:

<pre><code>def rotate_left3(nums):
 return [ nums[1] , nums[2] , nums[0] ]
</code></pre>

It worked perfect 100%, but if you add more sums, you'd have to add its just set for the 3 that the problem specified.

blocks|key|321545|text|def+rotate_left3(nums):
temp=[]
for+i+in+range(len(nums)-1):
++temp=nums[i]
++nums[i]=nums[i%2B1]
++nums[i%2B1]=temp

return+nums|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|321546|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def rotate_left3(nums):
temp=[]
for i in range(len(nums)-1):
 temp=nums[i]
 nums[i]=nums[i+1]
 nums[i+1]=temp

return nums
</code></pre>

blocks|key|321548|text|def+leftRotation(a,+d,+n):
++++i=0
++++while+i+<+n:
++++++++print+(a[(i%2Bd)%25n],+end+=+'+')
++++++++i%2B=1
++++return+i

if+__name__+==+'__main__':
++++a+=[1,+2,+3,+4,+5,+6,+7]
++++d+=+4
++++n+=+7+or+len(a)
++++leftRotation(a,+d,+n)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|321549|这就是我如何解决我的hackerrank左旋转挑战|unstyled|321550|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>def leftRotation(a, d, n):
 i=0
 while i &lt; n:
 print (a[(i+d)%n], end = ' ')
 i+=1
 return i

if __name__ == '__main__':
 a =[1, 2, 3, 4, 5, 6, 7]
 d = 4
 n = 7 or len(a)
 leftRotation(a, d, n)
</code></pre>

This is how I solved my hackerrank left rotation challenge

blocks|key|319650|text|def+rotate_left(array,+shift):
+length+=+len(array)
+overflow+=+length+*+(shift//length+%2B+1)
+return+[array[i%2Bshift+-+overflow]+for+i+in+range(length)]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|319651|如果你输入负数，这也是有效的，所以如果你愿意，你可以向右旋转。|unstyled|319652|缺点是它没有在适当的位置旋转，所以你得到了一个新的数组，但是由于你的解决方案返回了一个数组，所以让原始的数组保持不变更有意义。|319653|数组中项的新索引是当前索引，加上您想要向左移动的距离(尽管这实际上会将它们向右移动)减去绕数组移动多少次，这将使您加1。正1强制结果索引为负，因此我们从后面遍历原始数组。|319654|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>def rotate_left(array, shift):
 length = len(array)
 overflow = length * (shift//length + 1)
 return [array[i+shift - overflow] for i in range(length)]
</code></pre>

This works if you put in negative numbers, as well, so you can rotate right if you want.

The downside is that it's not in place rotation, so you get a new array, but since your solution returns an array, it makes more sense to leave the original array untouched.

The new index for items in the array is the current index, plus how far left you want to move (although this would actually move them right) minus how many times around the array this would take you plus one. The plus one forces the resulting index to be negative, so we go through the original array from the back.

blocks|key|3226051|text|一种将数组旋转n次的简单方法是使用切片，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3226052|def+left_rotate(arr,+n):
++++#+arr+-+array+to+rotate
++++#+n+-+n+number+of+rotations
++++#+For+number+of+rotations+greater+than+length+of+array
++++n+=+n+%25+len(arr)
++++return+arr[n:]+%2B+arr[:n]|code-block|syntax|javascript|3226053|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A simple way rotate an array n times would be to use slicing, 

<pre><code>def left_rotate(arr, n):
 # arr - array to rotate
 # n - n number of rotations
 # For number of rotations greater than length of array
 n = n % len(arr)
 return arr[n:] + arr[:n]
</code></pre>

blocks|key|2233635|text|请尝试以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2233636|import+math
import+os
import+random
import+re
import+sys



if+__name__+==+'__main__':

++++n+=+5++#number+of+elements

++++d+=+4++#number+of+times+left+operation+needs+to+be+performed

++++a+=+[1,2,3,4,5]+#array+to+be+rotated

++++def+leftRotate(a,+n,+d):+
++++++++#+To+get+the+starting+point+of+rotated+array+
++++++++mod+=+d+%25+n+
++++++++print(mod)


++++#+Prints+the+rotated+array+from+start+position+
++++++++for+i+in+range(n):+
++++++++++++print+(str(a[(mod+%2B+i)+%25+n]),+end+=+'+')

(leftRotate(a,+n,+d))|code-block|syntax|javascript|2233637|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Please try this :

<pre><code>import math
import os
import random
import re
import sys



if __name__ == '__main__':

 n = 5 #number of elements

 d = 4 #number of times left operation needs to be performed

 a = [1,2,3,4,5] #array to be rotated

 def leftRotate(a, n, d): 
 # To get the starting point of rotated array 
 mod = d % n 
 print(mod)


 # Prints the rotated array from start position 
 for i in range(n): 
 print (str(a[(mod + i) % n]), end = ' ')

(leftRotate(a, n, d))
</code></pre>

blocks|key|5338528|text|def+rotateLeft(rotation,+arr):
++++res+=+[None]+*+len(arr)
++++rotation+=+rotation+%25+len(arr)
++++
++++for+i+in+range(0,+len(arr)):
++++++++index+=+i+-+rotation
++++++++if+index+<+0:
++++++++++++index+=+index+%2B+len(arr)
++++++++++++
++++++++res[index]+=+arr[i]
++++
++++return+res|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5338529|或|unstyled|5338530|def+rotateLeft(rotation,+arr):
+++return+arr[rotation:]+%2B+arr[:rotation|5338531|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>def rotateLeft(rotation, arr):
 res = [None] * len(arr)
 rotation = rotation % len(arr)
 
 for i in range(0, len(arr)):
 index = i - rotation
 if index &lt; 0:
 index = index + len(arr)
 
 res[index] = arr[i]
 
 return res
</code></pre>
or
<pre><code>def rotateLeft(rotation, arr):
 return arr[rotation:] + arr[:rotation
</code></pre>

blocks|key|5338552|text|我尝试在golang中通过递归向左旋转数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5338553|func+rotLeft(a+[]int32,+d+int32)+[]int32+{++
++++if+d==0{return+a}
++++newArr+:=+make([]int32,+len(a)-1)++
++++copy+(newArr,+a[1:])
++++newArr+=+append(newArr,a[0])
++++return+rotLeft(newArr,+d-1)
}|code-block|syntax|javascript|5338554|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I try to left rotate array via recursion in golang:
<pre class="lang-golang prettyprint-override"><code>func rotLeft(a []int32, d int32) []int32 { 
 if d==0{return a}
 newArr := make([]int32, len(a)-1) 
 copy (newArr, a[1:])
 newArr = append(newArr,a[0])
 return rotLeft(newArr, d-1)
}
</code></pre>

I have a question where I need to rotate an array left k times.

i.e. if k = 2, [1, 2, 3, 4, 5] . -> [3, 4, 5, 1, 2]

So, my code is:

<pre><code>def array_left_rotation(a, n, k):
 for i in range(n):
 t = a[i]
 a[i] = a[(i+n-1+k)%n]
 a[(i+n-1+k)%n] = t

 return a
</code></pre>

where n = length of the array.

I think the problem is a mapping problem, a[0] -> a[n-1] if k = 1.

What is wrong with my solution?

Left Rotation on an Array

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个问题，我需要将一个数组向左旋转k次。即如果k= 2，1，2，3，4，5。-> 3、4、5、1、2所以，我的代码是：def array_left_rotation(a, n, k):    for i in range(n):        t = a[i]        a[i] = a[(i+n-1+k)%n...

问数组上的左旋转
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问数组上的左旋转EN