Создание алгоритма решения задачи на питоне

Рекурсивная версия:

def cell_compete(states, days):
    s = [0] + states + [0]
    states = [i ^ j for i, j in zip(s[:-2], s[2:])]  # Thanks @RoyDaulton
    return cell_compete(states, days - 1) if days > 1 else states

Нерекурсивная версия, которая также избегает расширения списка за счет добавления краевых элементов [0], будет выглядеть так:

def cell_compete(states, days):
    for _ in range(days):
        states = [states[1]] + [i ^ j for i, j in zip(states[:-2], states[2:])] + [states[-2]]
    return states

Вот гораздо более короткая процедура, которая решает вашу проблему.

def cellCompete(states, days):
    n = len(states)
    for day in range(days):
        houses = [0] + states + [0]
        states = [houses[i-1] ^ houses[i+1] for i in range(1, n+1)]
    return states

print(cellCompete([1,0,0,0,0,1,0,0] , 1))
print(cellCompete([1,1,1,0,1,1,1,1] , 2))

Распечатка из этого - это то, что вы хотите (хотя и с включенными скобками списка):

[0, 1, 0, 0, 1, 0, 1, 0]
[0, 0, 0, 0, 0, 1, 1, 0]

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

Расчет нового состояния дома: houses[i-1] ^ houses[i+1]. Этот символ ^ является побитовым исключающим ИЛИ. Значение равно 1, если два значения различаются, и 0, если два значения совпадают. Это как раз то, что нужно в вашей проблеме.

Другая возможность:

def cellCompete(states,days):
    newstates = []
    added_states = [0] + states + [0]
    for counter,value in enumerate(states):
        newstates.append(int((added_states[counter] != added_states[counter+2])))

    if days > 1:
        return cellCompete(newstates,days-1)
    else:
        return newstates

print(cellCompete([1,1,1,0,1,1,1,1],2))

Подобно тому, как Рори использует XOR, но без необходимости внутреннего понимания. Сдвиньте число на 2 и обрежьте лишний бит слева, взяв модуль:

def process(state, r):
    n = int(''.join(map(str,state)), 2)
    for i in range(r):
        n = ((n ^ n << 2) >> 1) % 256

    return list(map(int,format(n, "08b")))

process([1,1,1,0,1,1,1,1], 2)
# [0, 0, 0, 0, 0, 1, 1, 0]

process([1,0,0,0,0,1,0,0] , 1)
# [0, 1, 0, 0, 1, 0, 1, 0]

Пока все пытаются сделать простейшую версию возможной, вот более сложная версия. Это очень похоже на предыдущие ответы, за исключением того, что вместо сохранения состояния в функции это решение состоит из двух частей. Одна из них — функция полезности, которую мы хотим вызывать, а другая — генератор, который отслеживает состояния.

Основное отличие здесь в том, что генератор берет компаратор и начальное состояние, которое будет видоизменяться. Генератор также может быть отправлен в качестве параметра, чтобы генератор мог помочь разделить логику того, сколько состояний вы хотите сгенерировать, и иметь возможность бесконечно мутировать из фактического состояния.

def mutator(state, comparator):
    while True:
        states = [0] + state + [0]
        state = [
            comparator(states[cellid-1], states[cellid+1])
            for cellid in range(1, len(states)-1)
        ]
        yield state

def cellCompete(states, days):
    generator = mutator(states, lambda x, y: x ^ y)

    for idx, states in enumerate(generator):
        if idx+2 > days:
            break

    return states

print(cellCompete([1,0,0,0,0,1,0,0] , 1))
print(cellCompete([1,1,1,0,1,1,1,1] , 2))

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