Создание функции сдвига в 2048 году

Question

Допустим, у меня есть список:

board = [2, 4, 0, 2, 8, 4, 4, 8, 0, 2, 0, 0, 4, 0, 2, 2]

и у меня уже есть некоторый код, который сделает список отображаемым так:

2 4 0 2
8 4 4 8
0 2 0 0
4 0 2 2

Так есть ли способ удалить каждый 0 из каждой строки и добавить его обратно в конец (даже если в списке есть разные значения), чтобы доска теперь выглядела так:

2 4 2 0
8 4 4 8
2 0 0 0
4 2 2 0

Я хочу сделать это с помощью цикла, а не для того, чтобы по отдельности писать отдельный код для каждой строки.

Также вы можете сделать это, не внося начальный список в

board = [[2, 4, 0, 2], [8, 4, 4, 8], [0, 2, 0, 0], [4, 0, 2, 2]]

Код для 1 строки:

board = [2, 0, 0, 2]
k = len(board)
board[:] = (value for value in board if value != 0)
while len(board) < k:
    board.append(0)
print(board)

Output = [2, 2, 0, 0]

Answer 1

Просто для удовольствия, вот одна строка с использованием некоторых функциональных инструментов Python. Ключевыми ингредиентами являются functools.partial, itertools.chain.from_iterable и operator.not_, все из которых получены из Модули функционального программирования раздел документации стандартной библиотеки Python.

>>> import functools, itertools, operator
>>> board = [2, 4, 0, 2, 8, 4, 4, 8, 0, 2, 0, 0, 4, 0, 2, 2]
>>> list(itertools.chain.from_iterable(map(functools.partial(sorted, key=operator.not_), zip(*[iter(board)]*4))))
[2, 4, 2, 0, 8, 4, 4, 8, 2, 0, 0, 0, 4, 2, 2, 0]

Большая часть работы здесь заключается в том, чтобы превратить линейное представление платы в представление вложенных списков списков, а затем снова повернуть его обратно. Вот это пошагово.

Во-первых, превратив плоское представление во вложенное:

>>> nested = list(zip(*[iter(board)]*4))
>>> nested
[(2, 4, 0, 2), (8, 4, 4, 8), (0, 2, 0, 0), (4, 0, 2, 2)]

Я добавил этот дополнительный внешний list вызов, чтобы показать содержимое итерируемого zip. Это не обязательно, если все шаги объединены. Теперь отсортируйте каждую строку подходящим ключом, чтобы переместить нули вправо:

>>> sorted_nested = list(map(functools.partial(sorted, key=operator.not_), nested))
>>> sorted_nested
[[2, 4, 2, 0], [8, 4, 4, 8], [2, 0, 0, 0], [4, 2, 2, 0]]

Опять же, вызов внешнего списка не нужен, и мы потеряем его, когда соберем все вместе. Ключевым моментом здесь является то, что функция Python sorted обеспечивает стабильную сортировку, поэтому ненулевые элементы остаются в том же порядке по отношению друг к другу. Наконец, вернемся в список:

>>> list(itertools.chain.from_iterable(sorted_nested))
[2, 4, 2, 0, 8, 4, 4, 8, 2, 0, 0, 0, 4, 2, 2, 0]

Собрав все это вместе и удалив ненужные внутренние преобразования в список, вы получите один вкладыш вверху этого поста.

>>> list(itertools.chain.from_iterable(map(functools.partial(sorted, key=operator.not_), zip(*[iter(board)]*4))))
[2, 4, 2, 0, 8, 4, 4, 8, 2, 0, 0, 0, 4, 2, 2, 0]

Answer 2

Иногда в простом цикле нет ничего плохого:

board = [2, 4, 0, 2, 8, 4, 4, 8, 0, 2, 0, 0, 4, 0, 2, 2]

x=4
nb=[]
for e in zip(*[iter(board)]*x):
    ne=[se for se in e if se!=0]
    nb.extend(ne+[0]*(x-len(ne)))  #.append if you want to maintain sub lists

>>> nb
[2, 4, 2, 0, 8, 4, 4, 8, 2, 0, 0, 0, 4, 2, 2, 0]

Answer 3

Вы можете использовать list.count:

board = [2, 4, 0, 2, 8, 4, 4, 8, 0, 2, 0, 0, 4, 0, 2, 2]
new_board = [board[i:i+4] for i in range(0, len(board), 4)]
final_board = [list(filter(None, i))+([0]*i.count(0)) for i in new_board]
last_board = [i for b in final_board for i in b]

Выход:

[2, 4, 2, 0, 8, 4, 4, 8, 2, 0, 0, 0, 4, 2, 2, 0]