Question

我正在尝试解决HackerRank中的一个问题，当我提交我的解决方案时，我收到错误声明＆＃34;由于超时终止＆＃34;。

请检查代码并建议我如何优化。

问题： 在n个阵列上的左旋转操作将每个阵列的元件1单元向左移位。例如，如果在数组[1,2,3,4,5]上执行了2次左旋转，则数组将变为[3,4,5,1,2]。

给定n个整数和数字d的数组，在数组上执行左旋转。然后将更新的数组打印为一行以空格分隔的整数。

输入格式

第一行包含两个以空格分隔的整数，表示n（整数）和d（必须执行的左旋转数）的相应值。第二行包含空格分隔的整数，用于描述数组初始状态的各个元素。

输出格式

打印一行n个以空格分隔的整数，表示执行左转后的数组的最终状态。

示例输入

5 4 1 2 3 4 5

示例输出

5 1 2 3 4

解释

当我们执行d = 4左旋转时

因此，我们将数组的最终状态打印为单行空格分隔值，即5 1 2 3 4。

我的代码：

def array_left_rotation(ar, n, k):
    for j in range(k):
        temp = ar[0]
        for i in range(0,n-1):
            ar[i] = ar[i+1]
        ar[n-1] = temp
    return ar
n, k = map(int, input().strip().split(' '))
a = list(map(int, input().strip().split(' ')))
answer = array_left_rotation(a, n, k);
print(*answer, sep=' ')

Answer 1

这里最好的方法不是自己实际执行操作。在这种情况下，您手动旋转列表，这是不必要的计算。

首先，分析问题以及它对各种输出的行为方式。所以让我们分析：

假设一个包含5个元素的数组

array = [1,2,3,4,5]

如果你这个2 times，你会得到：

[3,4,5,1,2]

现在，尝试在原始数组上使用7 times进行旋转。你再次得到：

[3,4,5,1,2]

类似的试验将会出现这种模式。即，对于k times的轮换，它与k % n times相同。

现在我们有了这个，转到计算部分。为此，只需使用list slicing来获得轮换，如下所示：

#n -> number of elements in array
#k -> number of rotations to be performed
#a -> (list) array

def rotate(a,n,k) :
    rotations = k % n
    new_array = a[rotations:] + a[:rotations]

    return new_array

Answer 2

>>> a = [1, 2, 3, 4, 5]
>>> a[2:] + a[:2]
[3, 4, 5, 1, 2]
>>> ' '.join(str(i) for i in (a[2:] + a[:2]))
'3 4 5 1 2'
>>>
>>> def rotate_list(array, d):
...    return array[d:] + array[:d]
>>>
>>> ' '.join(str(i) for i in rotate_list([1, 2, 3, 4, 5], 4))
... '5 1 2 3 4'

Answer 3

number_of_elements = int(input("Enter the number of elements to be inserted in array:"))
rotations = int(input("Enter the number of rotations:"))
array = []
for i in range(number_of_elements):
    number = int(input("Enter a number:"))
    array.append(number)

array = array[rotations:] + array[:rotations]
print(*array, end=' ')

Python程序因超时而终止 - HackerRank

3 个答案: