我想在不导入任何模块的情况下打乱列表的元素。洗牌的类型是浅滩洗牌。你想在哪里划分号码。将列表的元素分成两部分,然后将它们交错。
如果有奇数没有。的元素,那么后半部分应该包含额外的元素
例如:列表 = [1,2,3,4,5,6,7]
then the final list should look like [1,4,2,5,3,6,7]
我想在不导入任何模块的情况下打乱列表的元素。洗牌的类型是浅滩洗牌。你想在哪里划分号码。将列表的元素分成两部分,然后将它们交错。
如果有奇数没有。的元素,那么后半部分应该包含额外的元素
例如:列表 = [1,2,3,4,5,6,7]
then the final list should look like [1,4,2,5,3,6,7]
只是为了好玩,递归解决方案:
def interleave(lst1, lst2):
if not lst1:
return lst2
elif not lst2:
return lst1
return lst1[0:1] + interleave(lst2, lst1[1:])
在 Python 2.x 中按如下方式使用它(在 Python 3.x 中,使用//
代替/
):
lst = [1,2,3,4,5,6,7]
interleave(lst[:len(lst)/2], lst[len(lst)/2:])
=> [1, 4, 2, 5, 3, 6, 7]
以上内容适用于任何长度的列表,长度是偶数还是奇数都没有关系。
例如:list = [1,2,3,4,5,6,7] 那么最终列表应该看起来像 [1,4,2,5,3,6,7]
这是一个应该可靠地做到这一点的函数:
def riffle(deck):
'''
Shuffle a list like a deck of cards.
i.e. given a list, split with second set have the extra if len is odd
and then interleave, second deck's first item after first deck's first item
and so on. Thus:
riffle([1,2,3,4,5,6,7])
returns [1, 4, 2, 5, 3, 6, 7]
'''
cut = len(deck) // 2 # floor division
deck, second_deck = deck[:cut], deck[cut:]
for index, item in enumerate(second_deck):
insert_index = index*2 + 1
deck.insert(insert_index, item)
return deck
并对其进行单元测试...
import unittest
class RiffleTestCase(unittest.TestCase):
def test_riffle(self):
self.assertEqual(riffle(['a','b','c','d','e']), ['a','c','b','d','e'])
self.assertEqual(riffle([1,2,3,4,5,6,7]), [1,4,2,5,3,6,7])
unittest.main()
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
listA = [1,2,3,4,5,6,7,8,9]
listLen = len(listA)/2
listB = listA[:listLen]
listC = listA[listLen:]
listD = []
num = 0
while num < listLen:
if len(listB) >= num:
listD.append(listB[num])
listD.append(listC[num])
num += 1
if len(listA)%2 != 0:
listD.append(listC[num])
print listD
在查看了另一个答案后,我还添加了一个递归版本,这是另一个人的答案的修订版,但更容易调用,因为您只需使用单个参数调用函数(您尝试改组的列表) 它会做其他所有事情:
def interleave(lst):
def interleaveHelper(lst1,lst2):
if not lst1:
return lst2
elif not lst2:
return lst1
return lst1[0:1] + interleaveHelper(lst2, lst1[1:])
return interleaveHelper(lst[:len(lst)/2], lst[len(lst)/2:])
当你去调用它时,你可以说interleave(list)
def riffle(deck):
new_deck = []
deck_1 = deck[:len(deck)//2]
deck_2 = deck[len(deck)//2::]
for i in range(len(deck)//2):
new_deck.append(deck_1[i])
new_deck.append(deck_2[i])
if len(deck) % 2 == 1:
new_deck.append(deck[-1])
return new_deck
deck = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
print(riffle(deck))
通过利用next
Python 中的迭代器的特性,你可以很容易地做到这一点。
您要做的第一件事是将元素分成两部分。
接下来,使用 Python 的iter
函数将这两部分转换为迭代器。你可以跳过这一步,但我发现调用next(iterable)
比手动索引列表要干净得多。
最后,您将遍历列表的前半部分,并为您添加的每一个元素添加后半部分的相应元素(调用next
会给出序列中的下一项)。
例如:
elements = [1,2,3,4,5,6,7]
half_point = len(elements)/2
a = iter(elements[0:half_point])
b = iter(elements[half_point: ])
result = []
for i in range(half_point):
result.append(next(a))
result.append(next(b))
if len(elements) % 2 != 0:
result.append(next(b))
print result
>>> [1, 4, 2, 5, 3, 6, 7]
底部的最后一位检查列表是否为奇数。如果是,它将最后一个元素附加到列表的末尾。
如果你有创意,你可能会通过压缩然后打开包装来压缩它,但我会把它留到你探索的时候itertools
;)
>>> ll = list(range(1,8))
>>> mid = len(ll)/2 # for Python3, use '//' operator
>>> it1 = iter(ll[:mid])
>>> it2 = iter(ll[mid:])
>>> riff = sum(zip(it1,it2), ()) + tuple(it2)
>>> riff
(1, 4, 2, 5, 3, 6, 7)
如果这是家庭作业,请准备好在这里解释如何sum
和zip
工作,第二个参数sum
的用途,为什么tuple(it2)
要添加到最后,以及该解决方案如何具有固有的低效率。
您可以将输入列表分成两部分,然后使用 zip 和一些列表操作来交错项目。
n = 9
l = range(1,n+1)
a = l[:n/2]
b = l[n/2:]
c = zip(a,b)
d = list()
for p in c :
d.extend(list(p))
if n%2==1:
d.append(b[n/2])
print(d)
如果 deck 是一个列表,请编写一个执行列表推导的函数来执行洗牌:
def riffle_shuffle(deck):
return [deck[i//2 + (i%2)*(len(deck)//2)] for i in range(len(deck))]