Você tem uma pilha de panquecas em um prato com uma calda de xarope por cima, tão espessa que não pode escorrer pelos lados. Você não ficará feliz em comer até que os dois rostos de cada panqueca tenham tocado pelo menos a calda, mas agora apenas uma face da panqueca superior o faz.

Você sabe que o xarope nunca absorve nem uma panqueca, mas pode ser transferido indefinidamente por meio do contato cara a cara entre duas panquecas. Depois que o rosto de uma panqueca toca o xarope, ele é considerado revestido em xarope para sempre e fará qualquer rosto sem revestimento com xarope que toque nele também. É possível transferir o xarope de e para o lado superior da placa também.

Você passa a revestir cada rosto de panqueca com calda, inserindo uma espátula abaixo de uma ou mais panquecas e virando-as por toda parte, exatamente como é feito na classificação de panquecas . (Infelizmente, essa espátula é resistente a xarope e não ajuda a distribuir o xarope tocando as faces da panqueca.) Infelizmente você perde a noção de quais faces da panqueca tocaram no xarope, mas você se lembra dos movimentos que fez.

Dadas as mudanças anteriores, você pode determinar se suas panquecas já estão todas revestidas com xarope?

Desafio

Escreva um programa que obtenha um número inteiro positivo N para o número de panquecas e uma lista de números inteiros positivos (todos <= N) para os lançamentos que você fez até agora. Cada número na lista representa o número de panquecas que foram invertidas. Produza um valor verdadeiro se as panquecas tiverem sido revestidas e um valor falso caso contrário. ( definição de verdade / falsidade )

A entrada deve vir de stdin ou da linha de comando e a saída deve ir para stdout (ou alternativas mais próximas). Tudo bem se sua entrada precisar de uma formatação extra: por exemplo, em [1, 1, 2, 2]vez de 1 1 2 2para a lista.

Exemplos

Suponha N = 2, então temos uma pilha de duas panquecas em um prato, começando com a calda por cima.

Se a lista for 1 1 2 2, isso significa que ...

• vire a panqueca superior - revestindo a face superior da panqueca inferior
• vire a parte superior novamente - revestindo a face inferior original da panqueca superior
• virar ambos - revestindo a placa
• vire os dois novamente - revestindo a face inferior original da panqueca inferior

Como todas as quatro faces são revestidas, a saída seria algo como Trueou 1.

Se a lista for 1 2 2 1, isso significa que ...

• vire a panqueca superior - revestindo a face superior da panqueca inferior
• virar ambos - nada de revestimento
• vire os dois novamente - revestindo nada
• vire a parte superior novamente - revestindo a face inferior original da panqueca superior

Como o rosto que toca a placa ainda está sem xarope, a saída seria algo como Falseou 0.

Notas

• A lista inversa pode ser arbitrariamente grande e pode estar vazia; nesse caso, a saída é falsa.
• A placa atua como transportadora de xarope, mas não importa se é revestida ou não. (Na verdade, qualquer solução de aleta vontade revestimento da placa, porque a face panqueca que toca deve ser revestida, mas independentemente.)
• A placa não pode ser virada.
• Você pode assumir que essas panquecas são discos de unidade sem lados para falar, apenas duas faces opostas.

Pontuação

Isso é código-golfe. A solução mais curta em bytes vence.

CJam, 32 30 29 bytes

q~2@#2b\{)/(W%)1$0=|@]s:~}/:&

Experimente online.

Casos de teste

$ cjam pancakes.cjam <<< '2 [1 1 2 2]'; echo
1
$ cjam pancakes.cjam <<< '2 [1 2 2 1]'; echo
0

Como funciona

q~                            " N, L := eval(input())                                     ";
  2@#2b                       " P := base(2 ** N, 2)                                      ";
       \{                }/   " for F in L:                                               ";
         )/                   "   P := split(P, F + 1)                                    ";
           (W%)               "   T, U, V := P[1:], reverse(P[0])[:-1], reverse(P[-1])[0] ";
               1$0=|          "   V |= U[0]                                               ";
                    @]s:~     "   P := map(eval, str([U, V, T]))                          ";
                           :& " print and(P)                                              ";

Haskell, 92 90 86 84 114 110 99 98

a exigência de um programa completo é tão irritante. Eu me pergunto por que alguém exigiria isso.

m(n:s)=all(<1)$foldl(\r@(p:s)n->reverse(take n s)++(p*r!!n):drop n s)[0..n]s
main=readLn>>=print.m

essa solução funciona representando a pilha de panquecas por uma lista dos lados, quando panquecas adjacentes compartilham o mesmo lado. cada lado é um número e um lado é revestido se tiver um valor zero.

correr como:

*Main> main
[2,1,1,2,2]
True

Python, 92 bytes

Eu acho que isso funciona:

s=[1]+[0,0]*input()
for f in input():x=f*2;s[0]=s[x]=s[0]|s[x];s[:x]=s[x-1::-1]
print all(s)

Ele usa uma lista de faces de panqueca (placa incluída) para lembrar quais são revestidas com calda. As panquecas são invertidas invertendo parte da lista, mas qualquer xarope é transferido primeiro entre a face superior e a face recém-revelada.

Uso:

$ python pancakes.py
2
1, 1, 2, 2
True

Python 2: 75

Uma simplificação da solução de grc e feersum.

n,b=input()
s=[1]+[0]*n
for x in b:s[:x+1]=s[x::-1];s[x]|=s[0]
print all(s)

O armazenamento do estado de xarope das 2*n+1bordas da panqueca é redundante porque as bordas tocantes são sempre as mesmas. Em vez disso, ele lembra o estado de cada uma das n+1junções de panqueca. Dessa forma, a transferência de xarope é contabilizada automaticamente.

A única atualização necessária é preservar o xarope na xjunção quando um flip o corta. Isso é feito com o xarope pós-flip em 0into x.

Receber a entrada duas vezes não afeta a contagem de caracteres.

s=[1]+[0]*input()
for x in input():s[:x+1]=s[x::-1];s[x]|=s[0]
print all(s)

Python 2, 93 bytes

No começo, eu ia postar minha resposta, mas depois o grc já havia postado uma resposta muito semelhante um minuto antes. Então, eu tentei apresentar algumas melhorias. O único que eu pude encontrar é usar uma comparação de lista lexicográfica em vez de all().

Edit: Corrigido um erro introduzido ao tentar, sem sucesso, diferentes métodos de entrada que não alteram a contagem de caracteres.

n,F=input()
L=[1]+2*n*[0]
for f in F:f*=2;L[0]=L[f]=L[0]|L[f];L[:f]=L[~-f::-1]
print[1]*2*n<L

Entrada / saída de amostra:

2, [1, 1, 2]

False

APL, 77

∧/⊃{x[1]+←⍺⌷x←⍵⋄(⌽⍺↑x),⍺↓x}/(⌽1+⎕),⊂1,⎕⍴0

Python 2, 107

d=[1]+[0,0]*input()
for i in input():n=2*i;d[:n]=reversed(d[:n]);d[n]=d[n-1]=d[n]|d[n-1]
print(all(d[:-1]))

Haskell, 129 125

t(m:l)=all(any(<1).(\i->foldr(\n->foldr($)[].map(n%))[i]l))[0..m]
n%i|i>n=(i:)|i<n=(n-i:)|1>0=(n:).(0:)
main=readLn>>=print.t

Provavelmente ainda não completamente jogado, mas funciona sem manipular uma lista de lados revestidos. Em vez disso, ele segue o caminho inverso para descobrir se um determinado lado de uma panqueca já entrou em contato com algo que era o lado superior no início. foldrefetivamente percorre a lista de inversões para trás, portanto não há reverse.

Então, aqui está o algoritmo: mapeamos todos os lados relevantes ( [0..m]) e fazemos uma lista dos lados dos quais nosso lado herda o xarope em cada etapa, começando pelo verso: inicialmente a lista é justa [i], mas com um toque de npanquecas, cada entrada torna- [n-i]se se i<n, [n,0]se i==ne [i]se i>n. O lado em questão foi revestido se, e somente se, a lista resultante após todos os lançamentos contiver um 0(any (<1) ). allfaz o resto e mainconverte tudo isso em um programa executável.

O programa recebe sua entrada stdinna forma de [n_pancakes, flip1, flip2, flip3, ...], finalizada por uma nova linha.