Eğer bir yığını krep kadar kalın bu tarafı aşağı çalıştıramaz üzerine şurup bir topak içeren bir plaka. Her krepin her iki yüzü de en azından şurupa dokunana kadar yemek yemekten hoşlanmayacaksınız, ama şu anda üst krepin sadece bir yüzü.

Şurubun asla bir krepten bile ıslanmayacağını biliyorsunuz, ancak iki krep arasındaki yüz yüze temas yoluyla süresiz olarak aktarılabiliyor. Bir krepin bir yüzüne şurup dokunduktan sonra, sonsuza dek şurupta kaplanmış olarak kabul edilir ve şurup kaplanmış herhangi bir şurupsuz kaplanmış yüz yapacaktır. Şurubun levhanın üst tarafına ve üst tarafına aktarılması da mümkündür.

Bir veya daha fazla krepin altına bir spatula takarak ve tam olarak krep sıralamada yapıldığı gibi, üzerine çevirerek her krep yüzünü şurupla kaplamaya devam edin . (Ne yazık ki bu spatula şuruplara karşı dayanıklıdır ve şurup yüzlerine dokunarak şurubu dağıtmaya yardımcı olmaz.) Ne yazık ki, gözleme yüzlerinin şuruplara dokunduğu kederi kaybedersiniz, ancak yaptığınız kâğıtları hatırlarsınız.

Geçmiş yazıların göz önüne alındığında, kreplerin hepsinin şurupla kaplı olup olmadığını belirleyebilir misin?

Meydan okuma

Krep sayısı için N pozitif tamsayı alan bir program ve şu ana kadar yaptığınız çeviriler için pozitif tamsayıların listesini (tümü <= N) yazın. Listedeki her sayı, çevrilen krep sayısını temsil eder. Krep kaplanırsa bir aldatma değeri ve eğer değilse bir sahte değer verin. ( truthy / falsy tanımı )

Giriş, stdin veya komut satırından gelmeli ve çıkış stdout'a (veya en yakın alternatiflere) gitmelidir. Girişiniz biraz fazladan biçimlendirme gerektiriyorsa sorun olmaz: örneğin liste [1, 1, 2, 2]yerine 1 1 2 2.

Örnekler

N = 2 olduğunu varsayalım, bu yüzden bir tabağın üzerinde iki şurup var, üstteki şurupla başlıyoruz.

Eğer liste ise 1 1 2 2, bu demek oluyor ki ...

• üst krepi çevirin - alt krepin üst yüzünü kaplayın
• üst kısmı tekrar çevirin - üst krepin orijinal alt yüzünü kaplayın
• ikisini de çevirin - plakanın kaplanması
• ikisini de yeniden çevirin - alt gözleme parçasının orijinal alt yüzünü kaplayın

Dört yüzün tamamı kaplandığından, çıktı Trueveya gibi bir şey olur 1.

Eğer liste ise 1 2 2 1, bu demek oluyor ki ...

• üst krepi çevirin - alt krepin üst yüzünü kaplayın
• ikisini birden çevirin - hiçbir şeyi kaplama
• ikisini de ters çevirin - hiçbir şeyi kaplama
• üst kısmı tekrar çevirin - üst krepin orijinal alt yüzünü kaplayın

Plakaya temas eden yüz hala şurupsuz olduğundan, çıktı Falseveya benzeri bir şey olacaktır 0.

notlar

• Kapak listesi isteğe bağlı olarak büyük olabilir ve boş olabilir, bu durumda çıktı yanlış olur.
• Plaka bir şurup taşıyıcı görevi görür ancak kaplanıp kaplanmaması önemli değildir. (Aslında herhangi çevirme çözüm irade ceket plaka dokunduğu gözleme yüz bakılmaksızın kaplanmış, ancak gerektiğinden.)
• Plaka çevrilemez.
• Bu kreplerin konuşacak tarafı olmayan, yalnızca iki zıt yüzü olan birim diskler olduğunu varsayabilirsiniz .

puanlama

Bu kod golfü. En kısa çözüm bayt kazanır.

CJam, 32 30 29 bayt

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

Çevrimiçi deneyin.

Test durumları

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

Nasıl çalışır

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

tam bir programın gerekliliği çok can sıkıcıdır. Neden birisinin buna ihtiyaç duymasını merak ediyorum.

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

bu çözüm, bitişik krepler aynı tarafı paylaştığında, krep yığınını bir taraf listesiyle temsil ederek çalışır. her taraf bir sayıdır ve sıfır değeri varsa bir taraf kaplanır.

olarak çalıştırmak:

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

Python, 92 bayt

Bence bu işe yarıyor:

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)

Şurupla kaplı olanları hatırlamak için gözleme yüzlerinin bir listesini (plaka dahil) kullanır. Krepler listenin bir kısmı ters çevrilerek çevrilir, ancak herhangi bir şurup ilk önce üst yüz ile yeni açılan yüz arasında aktarılır.

Kullanımı:

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

Python 2: 75

Grc ve feersum'un çözümünün basitleştirilmesi.

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

2*n+1Gözleme kenarlarının şurup durumunu saklamak gereksizdir çünkü dokunma kenarları her zaman aynıdır. Bu, bunun yerine, her bir n+1gözleme kavşağının durumunu hatırlar . Bu şekilde, şurup transferi otomatik olarak muhasebeleştirilir.

Gerekli olan tek güncelleme x, bir kapak kesildiğinde şurubu birleşme yerinde korumaktır . Bu, post-flip şurubunun 0içine yerleştirilerek yapılır x.

İki kere giriş yapılması karakter sayısını etkilemez.

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

Python 2, 93 bayt

İlk başta cevabımı gönderecektim ama daha sonra bir dakika önce grc çok benzer bir mesaj atmıştı. Bu yüzden bazı gelişmelerle gelmeye çalıştım. Bulabildiğim tek şey, onun yerine sözlükbilimsel liste karşılaştırması kullanmak all().

Düzenleme: Karakter sayısını değiştirmeyen farklı giriş yöntemlerinin başarısızlıkla denenmesiyle ortaya çıkan bir hata düzeltildi.

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

Örnek giriş / çıkış:

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

Muhtemelen henüz tamamen golf oynamamış, ancak kaplanmış tarafların bir listesini değiştirmeden çalışmaktadır. Bunun yerine, belirli bir krepin belirli bir tarafının başlangıçta en üst kısımda olan herhangi bir şeyle temas edip etmediğini bulmak için geriye doğru çalışır. foldretkili bir şekilde geriye doğru çevirir, bu yüzden yok reverse.

Yani burada algoritmasıdır: İlgili tüm tarafları (over map [0..m]) ve bizim yan devralır arkasından başlayarak her adımda gelen şurup o tarafın bir listesini yapmak: Başlangıçta liste adildir [i]ama bir dokunmanızda nkrep, her girişin olur, [n-i]eğer i<n, [n,0]eğer i==nve [i]eğer i>n. Söz konusu taraf, eğer ve sadece tüm çevirilerden sonra gelen listede bir 0( any (<1)) içeriyorsa kaplanmıştır . allgerisini yapar ve maintüm bunları çalıştırılabilir bir programa dönüştürür.

Program, girişini bir newline ile sonlandırılmış stdinbiçimde alır [n_pancakes, flip1, flip2, flip3, ...].