วิธีที่มีประสิทธิภาพในการหมุนรายการในหลาม

วิธีที่มีประสิทธิภาพมากที่สุดในการหมุนรายการในหลามคืออะไร? ตอนนี้ฉันมีสิ่งนี้:

>>> def rotate(l, n):
...     return l[n:] + l[:n]
... 
>>> l = [1,2,3,4]
>>> rotate(l,1)
[2, 3, 4, 1]
>>> rotate(l,2)
[3, 4, 1, 2]
>>> rotate(l,0)
[1, 2, 3, 4]
>>> rotate(l,-1)
[4, 1, 2, 3]

มีวิธีที่ดีกว่า?

A ได้collections.dequeรับการปรับให้เหมาะสมสำหรับการดึงและผลักทั้งสอง พวกเขายังมีrotate()วิธีการเฉพาะ

from collections import deque
items = deque([1, 2])
items.append(3)        # deque == [1, 2, 3]
items.rotate(1)        # The deque is now: [3, 1, 2]
items.rotate(-1)       # Returns deque to original state: [1, 2, 3]
item = items.popleft() # deque == [2, 3]

ใช้แค่pop(0)อะไร?

list.pop([i])

ลบรายการที่ตำแหน่งที่กำหนดในรายการและส่งคืน หากไม่มีการระบุดัชนีให้a.pop()ลบและส่งคืนรายการสุดท้ายในรายการ (วงเล็บเหลี่ยมรอบiในลายเซ็นต์ของเมธอดแสดงว่าพารามิเตอร์เป็นทางเลือกไม่ใช่ว่าคุณควรพิมพ์วงเล็บเหลี่ยมที่ตำแหน่งนั้นคุณจะเห็นสัญกรณ์นี้บ่อยใน Python Library Reference)

Numpy สามารถทำได้โดยใช้rollคำสั่ง:

>>> import numpy
>>> a=numpy.arange(1,10) #Generate some data
>>> numpy.roll(a,1)
array([9, 1, 2, 3, 4, 5, 6, 7, 8])
>>> numpy.roll(a,-1)
array([2, 3, 4, 5, 6, 7, 8, 9, 1])
>>> numpy.roll(a,5)
array([5, 6, 7, 8, 9, 1, 2, 3, 4])
>>> numpy.roll(a,9)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

ขึ้นอยู่กับสิ่งที่คุณต้องการให้เกิดขึ้นเมื่อคุณทำสิ่งนี้:

>>> shift([1,2,3], 14)

คุณอาจต้องการเปลี่ยน:

def shift(seq, n):
    return seq[n:]+seq[:n]

ถึง:

def shift(seq, n):
    n = n % len(seq)
    return seq[n:] + seq[:n]

วิธีที่ง่ายที่สุดที่ฉันนึกได้:

a.append(a.pop(0))

หากคุณต้องการวนซ้ำชุดองค์ประกอบเหล่านี้แทนที่จะสร้างโครงสร้างข้อมูลแยกต่างหากให้พิจารณาใช้ตัววนซ้ำเพื่อสร้างนิพจน์ตัวสร้าง:

def shift(l,n):
    return itertools.islice(itertools.cycle(l),n,n+len(l))

>>> list(shift([1,2,3],1))
[2, 3, 1]

นอกจากนี้ยังขึ้นอยู่กับว่าคุณต้องการเปลี่ยนรายการในตำแหน่ง (กลายพันธุ์) หรือถ้าคุณต้องการให้ฟังก์ชันส่งคืนรายการใหม่ เพราะตามการทดสอบของฉันบางอย่างเช่นนี้เร็วกว่าการใช้งานของคุณอย่างน้อยยี่สิบเท่าซึ่งเพิ่มสองรายการ:

def shiftInPlace(l, n):
    n = n % len(l)
    head = l[:n]
    l[:n] = []
    l.extend(head)
    return l

ในความเป็นจริงแม้กระทั่งการเพิ่ม l = l[:]ไปยังด้านบนของสิ่งนั้นเพื่อดำเนินการกับสำเนาของรายการที่ส่งผ่านยังคงเร็วเป็นสองเท่า

การติดตั้งใช้งานที่หลากหลายพร้อมกำหนดเวลาที่http://gist.github.com/288272

เพียงบันทึกบางส่วนเกี่ยวกับเวลา:

หากคุณเริ่มต้นด้วยรายการl.append(l.pop(0))เป็นวิธีที่เร็วที่สุดที่คุณสามารถใช้ได้ สิ่งนี้สามารถแสดงได้ด้วยความซับซ้อนของเวลาเพียงอย่างเดียว:

• deque.rotate คือO (k) (k = จำนวนองค์ประกอบ)
• รายการที่ต้องการยกเลิกการแปลงคือO (n)
• list.append และ list.pop เป็นทั้งO (1)

ดังนั้นหากคุณเริ่มต้นด้วยdequeวัตถุคุณสามารถทำได้deque.rotate()ที่ O (k) แต่ถ้าจุดเริ่มต้นคือรายการความซับซ้อนของเวลาในการใช้deque.rotate()คือ O (n) l.append(l.pop(0)เร็วกว่าที่ O (1)

นี่เป็นตัวอย่างการกำหนดเวลาในการวนซ้ำ 1M:

วิธีการที่ต้องการการแปลงประเภท:

• deque.rotateด้วยวัตถุ deque: 0.12380790710449219 วินาที (เร็วที่สุด)
• deque.rotateด้วยการแปลงประเภท: 6.853878974914551 วินาที
• np.rollด้วย nparray: 6.0491721630096436 วินาที
• np.rollด้วยการแปลงประเภท: 27.558452129364014 วินาที

รายการวิธีที่กล่าวถึงที่นี่:

• l.append(l.pop(0)): 0.32483696937561035 วินาที (เร็วที่สุด)
• " shiftInPlace": 4.819645881652832 วินาที
• ...

รหัสเวลาที่ใช้อยู่ด้านล่าง

collections.deque

แสดงว่าการสร้าง deques จากรายการคือ O (n):

from collections import deque
import big_o

def create_deque_from_list(l):
     return deque(l)

best, others = big_o.big_o(create_deque_from_list, lambda n: big_o.datagen.integers(n, -100, 100))
print best

# --> Linear: time = -2.6E-05 + 1.8E-08*n

หากคุณต้องการสร้างออบเจกต์ deque:

การซ้ำ 1M @ 6.853878974914551 วินาที

setup_deque_rotate_with_create_deque = """
from collections import deque
import random
l = [random.random() for i in range(1000)]
"""

test_deque_rotate_with_create_deque = """
dl = deque(l)
dl.rotate(-1)
"""
timeit.timeit(test_deque_rotate_with_create_deque, setup_deque_rotate_with_create_deque)

หากคุณมี deque objects อยู่แล้ว:

การซ้ำ 1M @ 0.12380790710449219 วินาที

setup_deque_rotate_alone = """
from collections import deque
import random
l = [random.random() for i in range(1000)]
dl = deque(l)
"""

test_deque_rotate_alone= """
dl.rotate(-1)
"""
timeit.timeit(test_deque_rotate_alone, setup_deque_rotate_alone)

np.roll

ถ้าคุณต้องการสร้าง nparrays

การซ้ำ 1M @ 27.558452129364014 วินาที

setup_np_roll_with_create_npa = """
import numpy as np
import random
l = [random.random() for i in range(1000)]
"""

test_np_roll_with_create_npa = """
np.roll(l,-1) # implicit conversion of l to np.nparray
"""

หากคุณมี nparrays อยู่แล้ว:

การซ้ำ 1M @ 6.0491721630096436 วินาที

setup_np_roll_alone = """
import numpy as np
import random
l = [random.random() for i in range(1000)]
npa = np.array(l)
"""

test_roll_alone = """
np.roll(npa,-1)
"""
timeit.timeit(test_roll_alone, setup_np_roll_alone)

"เปลี่ยนตำแหน่ง"

ต้องไม่มีการแปลงประเภท

การซ้ำ 1M @ 4.819645881652832 วินาที

setup_shift_in_place="""
import random
l = [random.random() for i in range(1000)]
def shiftInPlace(l, n):
    n = n % len(l)
    head = l[:n]
    l[:n] = []
    l.extend(head)
    return l
"""

test_shift_in_place="""
shiftInPlace(l,-1)
"""

timeit.timeit(test_shift_in_place, setup_shift_in_place)

l.append (l.pop (0))

ต้องไม่มีการแปลงประเภท

1M การทำซ้ำ @ 0.32483696937561035

setup_append_pop="""
import random
l = [random.random() for i in range(1000)]
"""

test_append_pop="""
l.append(l.pop(0))
"""
timeit.timeit(test_append_pop, setup_append_pop)

ฉันยังสนใจในสิ่งนี้และเปรียบเทียบโซลูชันที่แนะนำกับperfplot (โครงการเล็ก ๆ ของฉัน)

ปรากฎว่า

for _ in range(n):
    data.append(data.pop(0))

คือไกลโดยวิธีที่เร็วที่สุดสำหรับการเปลี่ยนแปลงเล็ก ๆnวิธีที่เร็วที่สุดสำหรับการเปลี่ยนแปลงเล็ก

สำหรับขนาดใหญ่n,

data[n:] + data[:n]

ไม่เลว

โดยพื้นฐานแล้ว perfplot ทำการเปลี่ยนแปลงเพื่อเพิ่มอาร์เรย์ขนาดใหญ่และวัดเวลา นี่คือผลลัพธ์:

shift = 1:

shift = 100:

รหัสในการทำซ้ำพล็อต:

import numpy
import perfplot
import collections


shift = 100


def list_append(data):
    return data[shift:] + data[:shift]


def shift_concatenate(data):
    return numpy.concatenate([data[shift:], data[:shift]])


def roll(data):
    return numpy.roll(data, -shift)


def collections_deque(data):
    items = collections.deque(data)
    items.rotate(-shift)
    return items


def pop_append(data):
    for _ in range(shift):
        data.append(data.pop(0))
    return data


perfplot.save(
    "shift100.png",
    setup=lambda n: numpy.random.rand(n).tolist(),
    kernels=[list_append, roll, shift_concatenate, collections_deque, pop_append],
    n_range=[2 ** k for k in range(7, 20)],
    logx=True,
    logy=True,
    xlabel="len(data)",
)

อาจเป็นแหวนที่เหมาะสมกว่า ไม่ใช่รายการแม้ว่าจะเป็นไปได้ว่ามันสามารถทำตัวเหมือนรายการสำหรับวัตถุประสงค์ของคุณ

ปัญหาคือประสิทธิภาพของการเปลี่ยนแปลงในรายการคือ O (n) ซึ่งมีความสำคัญสำหรับรายการมากพอ

การเลื่อนในแหวนเป็นเพียงการอัปเดตตำแหน่งหัวซึ่งเป็น O (1)

สำหรับการนำไปใช้ที่ไม่เปลี่ยนรูปคุณสามารถใช้สิ่งนี้:

def shift(seq, n):
    shifted_seq = []
    for i in range(len(seq)):
        shifted_seq.append(seq[(i-n) % len(seq)])
    return shifted_seq

print shift([1, 2, 3, 4], 1)

หากประสิทธิภาพคือเป้าหมายของคุณ (รอบ? หน่วยความจำ?) คุณอาจจะดูดีกว่าที่โมดูลอาร์เรย์: http://docs.python.org/library/array.html

อาร์เรย์ไม่มีค่าใช้จ่ายในรายการ

เท่าที่รายการบริสุทธิ์ไปสิ่งที่คุณมีเกี่ยวกับดีเท่าที่คุณสามารถหวังว่าจะทำ

ฉันคิดว่าคุณกำลังมองหาสิ่งนี้:

a.insert(0, x)

ทางเลือกอื่น:

def move(arr, n):
    return [arr[(idx-n) % len(arr)] for idx,_ in enumerate(arr)]

ฉันใช้แบบจำลองต้นทุนนี้เป็นข้อมูลอ้างอิง:

http://scripts.mit.edu/~6.006/fall07/wiki/index.php?title=Python_Cost_Model

วิธีการแบ่งรายการของคุณและต่อเชื่อมรายการย่อยสองรายการเข้าด้วยกันเป็นการดำเนินการตามเวลาเชิงเส้น ฉันขอแนะนำให้ใช้ป๊อปซึ่งเป็นการดำเนินการเวลาคงที่เช่น

def shift(list, n):
    for i in range(n)
        temp = list.pop()
        list.insert(0, temp)

ฉันไม่รู้ว่านี่เป็น 'ประสิทธิภาพ' หรือไม่ แต่ยังใช้งานได้:

x = [1,2,3,4]
x.insert(0,x.pop())

แก้ไข: สวัสดีอีกครั้งฉันเพิ่งพบปัญหาใหญ่กับโซลูชันนี้! พิจารณารหัสต่อไปนี้:

class MyClass():
    def __init__(self):
        self.classlist = []

    def shift_classlist(self): # right-shift-operation
        self.classlist.insert(0, self.classlist.pop())

if __name__ == '__main__':
    otherlist = [1,2,3]
    x = MyClass()

    # this is where kind of a magic link is created...
    x.classlist = otherlist

    for ii in xrange(2): # just to do it 2 times
        print '\n\n\nbefore shift:'
        print '     x.classlist =', x.classlist
        print '     otherlist =', otherlist
        x.shift_classlist() 
        print 'after shift:'
        print '     x.classlist =', x.classlist
        print '     otherlist =', otherlist, '<-- SHOULD NOT HAVE BIN CHANGED!'

เมธอด shift_classlist () เรียกใช้งานรหัสเดียวกันกับ x.insert ของฉัน (0, x.pop ()) - วิธีแก้ปัญหารายการอื่น ๆ เป็นรายการที่แยกจากคลาส หลังจากส่งเนื้อหาของรายการอื่นไปยังรายการ MyClass.classlist การเรียก shift_classlist () จะเปลี่ยนรายการอื่น ๆ ด้วย:

คอนโซลเอาท์พุท:

before shift:
     x.classlist = [1, 2, 3]
     otherlist = [1, 2, 3]
after shift:
     x.classlist = [3, 1, 2]
     otherlist = [3, 1, 2] <-- SHOULD NOT HAVE BIN CHANGED!



before shift:
     x.classlist = [3, 1, 2]
     otherlist = [3, 1, 2]
after shift:
     x.classlist = [2, 3, 1]
     otherlist = [2, 3, 1] <-- SHOULD NOT HAVE BIN CHANGED!

ฉันใช้ Python 2.7 ฉันไม่รู้ว่าเป็นข้อผิดพลาดหรือไม่ แต่ฉันคิดว่ามันเป็นไปได้มากกว่าที่ฉันจะเข้าใจบางสิ่งบางอย่างที่นี่

มีใครบ้างในพวกคุณที่รู้ว่าทำไมสิ่งนี้ถึงเกิดขึ้น?

วิธีการต่อไปนี้คือ O (n) แทนที่ด้วยหน่วยความจำเสริมคงที่:

def rotate(arr, shift):
  pivot = shift % len(arr)
  dst = 0
  src = pivot
  while (dst != src):
    arr[dst], arr[src] = arr[src], arr[dst]
    dst += 1
    src += 1
    if src == len(arr):
      src = pivot
    elif dst == pivot:
      pivot = src

โปรดทราบว่าในไพ ธ อนวิธีนี้ไม่มีประสิทธิภาพอย่างน่ากลัวเมื่อเปรียบเทียบกับวิธีอื่นเนื่องจากไม่สามารถใช้ประโยชน์จากการใช้งานแบบดั้งเดิมของชิ้นส่วนใด ๆ

ฉันมีสิ่งที่คล้ายกัน ตัวอย่างเช่นหากต้องการเลื่อนสอง ...

def Shift(*args):
    return args[len(args)-2:]+args[:len(args)-2]

ฉันคิดว่าคุณมีวิธีที่มีประสิทธิภาพที่สุด

def shift(l,n):
    n = n % len(l)  
    return l[-U:] + l[:-U]

กรณีการใช้งานคืออะไร? บ่อยครั้งที่เราไม่ต้องการอาร์เรย์ที่ถูกเลื่อนอย่างสมบูรณ์ - เราเพียงแค่ต้องเข้าถึงองค์ประกอบจำนวนหนึ่งในอาร์เรย์ที่ถูกเลื่อน

การรับส่วน Python คือ runtime O (k) โดยที่ k เป็นชิ้นดังนั้นการหมุนแบบแบ่งส่วนคือ runtime N คำสั่ง deque rotation คือ O (k) เราทำได้ดีกว่านี้ไหม

ลองพิจารณาอาเรย์ที่มีขนาดใหญ่มาก (สมมุติว่ามันใหญ่มากมันจะคำนวณได้ช้ากว่าที่จะเชือดมัน) ทางเลือกอื่นก็คือปล่อยอาร์เรย์เดิมไว้ตามลำพังและคำนวณดัชนีของไอเท็มที่จะมีอยู่ในดัชนีที่เราต้องการหลังจากการเปลี่ยนแปลงบางอย่าง

การเข้าถึงองค์ประกอบที่ถูกเลื่อนจึงกลายเป็น O (1)

def get_shifted_element(original_list, shift_to_left, index_in_shifted):
    # back calculate the original index by reversing the left shift
    idx_original = (index_in_shifted + shift_to_left) % len(original_list)
    return original_list[idx_original]

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

print get_shifted_element(my_list, 1, 2) ----> outputs 4

print get_shifted_element(my_list, -2, 3) -----> outputs 2 

ฟังก์ชันต่อไปนี้จะคัดลอกรายการที่ส่งไปยัง templist ดังนั้นฟังก์ชั่น pop จะไม่ส่งผลกระทบต่อรายการเดิม:

def shift(lst, n, toreverse=False):
    templist = []
    for i in lst: templist.append(i)
    if toreverse:
        for i in range(n):  templist = [templist.pop()]+templist
    else:
        for i in range(n):  templist = templist+[templist.pop(0)]
    return templist

การทดสอบ:

lst = [1,2,3,4,5]
print("lst=", lst)
print("shift by 1:", shift(lst,1))
print("lst=", lst)
print("shift by 7:", shift(lst,7))
print("lst=", lst)
print("shift by 1 reverse:", shift(lst,1, True))
print("lst=", lst)
print("shift by 7 reverse:", shift(lst,7, True))
print("lst=", lst)

เอาท์พุท:

lst= [1, 2, 3, 4, 5]
shift by 1: [2, 3, 4, 5, 1]
lst= [1, 2, 3, 4, 5]
shift by 7: [3, 4, 5, 1, 2]
lst= [1, 2, 3, 4, 5]
shift by 1 reverse: [5, 1, 2, 3, 4]
lst= [1, 2, 3, 4, 5]
shift by 7 reverse: [4, 5, 1, 2, 3]
lst= [1, 2, 3, 4, 5]

Jon Bentley ในการเขียนโปรแกรม Pearls (คอลัมน์ 2) อธิบายอัลกอริทึมที่หรูหราและมีประสิทธิภาพสำหรับการหมุนnเวกเตอร์องค์ประกอบที่xเหลือโดยiตำแหน่ง:

ลองดูปัญหาเป็นการแปลงอาร์เรย์abให้เป็นอาร์เรย์ baแต่สมมติว่าเรามีฟังก์ชั่นที่ย้อนกลับองค์ประกอบในส่วนที่ระบุของอาร์เรย์ เริ่มต้นด้วยabเราย้อนกลับaที่จะได้รับกลับที่จะได้รับ และจากนั้นย้อนกลับสิ่งที่ทั้งจะได้รับซึ่งเป็นว่า ผลลัพธ์นี้ในรหัสต่อไปนี้สำหรับการหมุน:arbbarbr(arbr)rba

reverse(0, i-1)
reverse(i, n-1)
reverse(0, n-1)

สามารถแปลเป็น Python ได้ดังนี้:

def rotate(x, i):
    i %= len(x)
    x[:i] = reversed(x[:i])
    x[i:] = reversed(x[i:])
    x[:] = reversed(x)
    return x

การสาธิต:

>>> def rotate(x, i):
...     i %= len(x)
...     x[:i] = reversed(x[:i])
...     x[i:] = reversed(x[i:])
...     x[:] = reversed(x)
...     return x
... 
>>> rotate(list('abcdefgh'), 1)
['b', 'c', 'd', 'e', 'f', 'g', 'h', 'a']
>>> rotate(list('abcdefgh'), 3)
['d', 'e', 'f', 'g', 'h', 'a', 'b', 'c']
>>> rotate(list('abcdefgh'), 8)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> rotate(list('abcdefgh'), 9)
['b', 'c', 'd', 'e', 'f', 'g', 'h', 'a']

สำหรับรายการX = ['a', 'b', 'c', 'd', 'e', 'f']และค่ากะที่ต้องการshift น้อยกว่าความยาวของรายการเราสามารถกำหนดฟังก์ชันlist_shift()ดังต่อไปนี้

def list_shift(my_list, shift):
    assert shift < len(my_list)
    return my_list[shift:] + my_list[:shift]

ตัวอย่าง,

list_shift(X,1)ผล['b', 'c', 'd', 'e', 'f', 'a'] list_shift(X,3)ตอบแทน['d', 'e', 'f', 'a', 'b', 'c']

def solution(A, K):
    if len(A) == 0:
        return A

    K = K % len(A)

    return A[-K:] + A[:-K]

# use case
A = [1, 2, 3, 4, 5, 6]
K = 3
print(solution(A, K))

ตัวอย่างเช่นกำหนด

A = [3, 8, 9, 7, 6]
K = 3

[9, 7, 6, 3, 8]ฟังก์ชั่นควรกลับ มีการหมุนสามรอบ:

[3, 8, 9, 7, 6] -> [6, 3, 8, 9, 7]
[6, 3, 8, 9, 7] -> [7, 6, 3, 8, 9]
[7, 6, 3, 8, 9] -> [9, 7, 6, 3, 8]

สำหรับตัวอย่างอื่นให้

A = [0, 0, 0]
K = 1

ฟังก์ชั่นควรกลับมา [0, 0, 0]

ป.ร. ให้ไว้

A = [1, 2, 3, 4]
K = 4

ฟังก์ชั่นควรกลับมา [1, 2, 3, 4]

ฉันกำลังมองหาวิธีแก้ปัญหานี้ สิ่งนี้จะช่วยแก้จุดประสงค์ใน O (k)

def solution(self, list, k):
    r=len(list)-1
    i = 0
    while i<k:
        temp = list[0]
        list[0:r] = list[1:r+1]
        list[r] = temp
        i+=1
    return list

สำหรับฟังก์ชั่นที่คล้ายกันในภาษาอื่น:

def shift(l):
    x = l[0]
    del(l[0])
    return x