XOR çözümü için gerekli bazı ilham kaynakları için FryAmTheEggman'a teşekkürler.
0000 !@
0001 ?.|@!
0010 #?#!)@
0011 ?!@
0100 +?|@!?
0101 ??!@
0110 ?<@!!<_\~(
0111 ?<<@!
1000 )\!#?@{
1001 (~?/@#!
1010 ??|@!)
1011 \#??!1@
1100 ?(~!@
1101 ?.|@!)
1110 ?$@#)!<
1111 1!@
Tüm programlar 0yanlış ve 1doğru için kullanır .
Çevrimiçi deneyin! Bu bir test paketi değildir, farklı programlara kopyalamanız ve kendiniz girmeniz gerekir.
Yukarıdaki çözüm 2-bayt optimallik içindedir (sanırım truthy / falsy yorumunu gevşetmezsek). Ben yani en fazla 7 bayt (değil, yan uzunluğu 2 sığacak tüm programları üzerinde iki gün yakın bir kaba kuvvet arama çalışmasına izin ettik oldukça tüm programlar - Bilirim her geçerli programı ihtiyaçlarına ve ne üzerinde birkaç varsayımlar yapılmış hiçbir geçerli program olabilir). Arama, 16 olası kapıdan 15'i için çözüm buldu - ve çoğu zaman birden fazla değil. Tüm alternatif çözümlerin bir listesini bu pastebin içinde bulabilirim, burada bunları eşdeğer davranışlara göre gruplandırdım. Yukarıda gösterdiklerimi seçtim çünkü bunlar en basit ya da en ilginç çözüm, ve yarın onlar için açıklamalar ekleyeceğim.
16. kapıya gelince: XOR, görünüşte 7 bayta uygulanamayan tek kapıdır. Büyük programlar üzerinde kaba bir kuvvet araştırması maalesef şu anda sahip olduğum kodla mümkün değil. Yani XOR elle yazılmış olması gerekiyordu. Şimdiye kadar bulduğum en kısa süre, FryAmTheEggman'ın başarısız (ancak çok yakın) bir girişimini temel alan 10 baytlık program. 8 baytlık veya 9 baytlık bir çözüm mevcut olabilir, ancak bunun dışında tüm çözümlerin gerçekten optimum olması gerekir.
açıklamalar
Uyarı: metin duvarı. Bu yüksek oranda sıkıştırılmış Hexagony programlarının gerçekte nasıl çalıştıklarını ilgilendiren birinin şansını kaybetme ihtimaline karşı, her biri için açıklamalar getirdim. Açıklamaları oldukça kısa tutmak için birden fazla optimal programın bulunduğu durumlarda her geçit için en basit çözümü seçmeye çalıştım. Ancak, bazıları hala akıllara durgunluk veriyor, bu yüzden biraz daha fazla detaylandırma hak ettiklerini düşündüm.
0000: Yanlış
Bunun için bir şemaya ihtiyacımız olacağını sanmıyorum:
! @
. . .
. .
Tüm bellek ızgarası sıfırlanmaya başladığından, !sadece sıfır yazdırır ve @programı sonlandırır.
Bu aynı zamanda sadece 2 baytlık bir çözümdür.
0001: Ve
? .
| @ !
. .
Bu temelde kısa devre uygular . Aşağıdaki gri diyagram, ilk girişin okunduğu ?ve komut göstergesinin (IP) |aynanın yansıtdığı sol köşeye dolandığı programın başlangıcını göstermektedir . Şimdi köşe koşullu olarak hareket ediyor, ilk girişin değerine bağlı olarak iki farklı yürütme yolu var. Kırmızı şema için kontrol akışını A = 0ve şunun için yeşil diyagramı gösterir A = 1:
Gördüğünüz gibi, ne zaman Aolduğunu 0, o zaman basitçe (bütün unutmayın yazdırmak ve sonlandırmak .no-op vardır). Ama Aise 1, bu durumda IP okuma, yine ilk satırı geçtiği Bve bunun yerine baskı söyledi.
Toplamda bu kapı için on altı 5 baytlık çözüm bulunmaktadır. Bunların on dördü esasen yukarıdakiyle aynıdır, ya etkin biçimde etkin olmayan bir komutu >yerine |ya da yerine .koyarak ya ?da ikinci pozisyona koyarak :
?.|@! .?|@! ?=|@! =?|@! ?_|@! _?|@! ?0|@!
?.>@! .?>@! ?=>@! =?>@! ?_>@! _?>@! ?0>@!
Ve sonra diğer iki çözüm var (bunlar birbirine eşdeğer). Bunlar aynı kısa devre mantığını da uygularlar, ancak yürütme yolları biraz daha çılgıncadır (ve okuyucuya bir egzersiz olarak bırakılmıştır):
?<!@|
?<!@<
0010: A ve B değil
# ?
# ! )
@ .
Bu aynı zamanda bir kısa devre şekli de uygulamaktadır, ancak #kontrol akışının kullanılması nedeniyle daha zorlayıcıdır. #koşullu bir IP anahtarıdır. Hexagony aslında etiketli altı IP ile birlikte 0için 5kendi saat kenarı boyunca işaret ızgara altı köşe başlar (ve programı her zaman IP ile başlar 0). A #ile karşılaşıldığında, mevcut değer modulo alınır 6ve kontrol akışı ilgili IP ile devam eder. Ne çılgınlık uyumunun bana bu özelliği eklediğinden emin değilim, ama kesinlikle bazı şaşırtıcı programlara (bunun gibi) izin veriyor.
Üç vakayı ayırt edeceğiz. Ne zaman A = 0değeri her zaman olduğundan, program, oldukça basittir 0zaman #hiçbir IP anahtarlama gerçekleşecek şekildedir karşılaşıldığında:
#hiçbir şey yapmaz, ?okur A(yani hiçbir şey yapmaz), #yine de hiçbir şey yapmaz, !yazdırır 0, )arttırır (bu önemlidir, aksi takdirde IP üçüncü satıra atlamaz), @programı sonlandırır. Yeterince basit. Şimdi durumu ele alalım (A, B) = (1, 0):
Kırmızı yol hala IP'ye karşılık geliyor 0ve ben IP için yeşil yolu ekledim 1. ?Okuduktan sonra A( 1bu sefer) #sağ üst köşeden başlayan IP’ye geçiş yaptığını görüyoruz . Bunun anlamı ?okuyabilir B( 0). Şimdi bunu )arttırır 1, öyle ki #sol üst köşedeki hiçbir şey yapmaz ve IP ile kalırız 1. !Baskılar 1ve IP sol çapraz sarar. #hala hiçbir şey yapmaz ve @programı sonlandırır.
Son olarak, her iki girdinin de bulunduğu garip durum 1:
Bu kez, ikinci giriş de 1ve )bu için artırır 2. Bunun anlamı #sol üst köşede neden başka IP IP anahtarını 2, mavi göstermektedir. Bu yolda, ilk önce onu daha da 3arttırırız (ilgisiz olmasına rağmen) ve sonra ?üçüncü kez geçiririz. Şimdi EOF'ye (yani giriş bitmiştir) çarptığımız için programı ?geri döndürür 0, !yazdırır ve @sonlandırır.
Özellikle, bu kapı için tek 6-byte çözüm budur.
0011: A
? !
@ . .
. .
Bir şemaya ihtiyacımız olmayacak kadar basittir: ?okur A, !yazdırır, @sonlandırır.
Bu, bu kapı için tek 3-byte çözümdür. (Prensip olarak, yapmak da mümkün olacaktı ,;@, ama arama dahil değildi ;, çünkü !bu iş için baytları hiçbir zaman kurtarabileceğini sanmıyorum .)
0100: B ve A değil
+ ?
| @ !
? .
Bu, "kardeşinden" çok daha basittir 0010. Kontrol akışı aslında yukarıda 0001(And) için gördüğümüz aynıdır . Eğer A = 0öyleyse, IP, son çizgiden geçer, Bsonlandırmadan önce bunu okur ve yazdırır. Eğer A = 1o zaman IP ayrıca okuma, yine ilk satırı geçtiği B, ancak +iki kullanılmayan bellek öyle herkese geçerli değerini sıfırlamak yani kenarları ekler 0, böylece !her zaman baskılar 0.
Buna oldukça 6-byte alternatif var (toplamda 42). İlk olarak, yukarıdakilere denk bir tonluk çözüm var. Tekrar arasında serbestçe seçebilir |ve >ve +bize boş bir avantaj sağlar başka komutuyla değiştirilebilir:
"?|@!? &?|@!? '?|@!? *?|@!? +?|@!? -?|@!? ^?|@!? {?|@!? }?|@!?
"?>@!? &?>@!? '?>@!? *?>@!? +?>@!? -?>@!? ^?>@!? {?>@!? }?>@!?
Ayrıca ]yerine de kullanabiliriz ?. ]bir sonraki IP'ye gider (yani IP'yi seçer 1), böylece bu dal yerine ?sağ üst köşeyi yeniden kullanır . Bu da 18 çözüm daha veriyor:
"?|@!] &?|@!] '?|@!] *?|@!] +?|@!] -?|@!] ^?|@!] {?|@!] }?|@!]
"?>@!] &?>@!] '?>@!] *?>@!] +?>@!] -?>@!] ^?>@!] {?>@!] }?>@!]
Ve sonra farklı çılgınlık seviyelerinde farklı şekilde çalışan altı başka çözüm var:
/[<@!? ?(#!@] ?(#>@! ?/@#/! [<<@!? [@$\!?
0101: B
? ?
! @ .
. .
Woohoo, basit bir tane daha: oku A, oku B, yazdır B, sonlandır. Aslında buna alternatifler var. Yana Asadece tek bir karakter, biz de bunu birlikte okuyabilir ,:
,?!@
Ayrıca tek ?kullanma ve iki kez çalıştırmak için bir ayna kullanma seçeneği de var :
?|@! ?>@!
0110: Xor
? < @
! ! < _
\ ~ ( . .
. . . .
. . .
Yukarıda söylediğim gibi, bu, 2. tarafa sığmayacak tek geçitti, bu yüzden FryAmTheEggman ve kendimin el yazısıyla yazdığı bir çözüm. Ayırt etmek için iki durum var. Eğer A = 0kontrol akışı (bu durumda sadece yazdırmak gerekiyor çünkü oldukça basittir B):
Kırmızı yoldan başlıyoruz. ?okur A, <sola sıfır saptırıcı bir daldır. IP dibe sarılır, sonra _başka bir ayna olur ve IP köşeye çarptığında sol üst köşeye sarılır ve mavi yolda devam eder. ?okur B, !yazdırır. Şimdi (onu azaltır. Bu önemlidir, çünkü değerin pozitif olmadığını garanti eder (ya 0ya -1şimdi ya da şimdi). Bu, IP sargısını @, programı sonlandırdığı sağ köşeye kaydırır .
Ne zaman A = 1işler biraz yanıltıcıdır olsun. Bu durumda not B, kendi içinde çok zor olmayan bir baskı yapmak istiyoruz , ancak uygulama yolu biraz trippy.
Bu sefer, <IP'nin yönünü saptırıyor ve sonra bir sonraki adım <sadece ayna gibi davranıyor. Böylece IP aynı yolu tersten çevirir ve tekrar Bkarşılaştığında okur ?. IP sağ köşeye dolanır ve yeşil yolda devam eder. Daha sonra (~, “değişim, -1 ile çarpma” olan 0ve takas eden 1ve dolayısıyla hesaplayan karşılaşmalar ortaya çıkıyor not B. \sadece bir aynadır ve !istenen sonucu basar. Sonra ?başka bir numara döndürmeye çalışır, ancak sıfır döndürür. IP şimdi mavi yolun sol alt köşesinde devam ediyor. (azalmalar, <yansıtır,(IP köşeye çarptığında geçerli değer negatif olacak şekilde yeniden azalır. Sağ alt köşegen boyunca hareket eder ve sonunda @programı sonlandırmak için vurur .
0111: Veya
? <
< @ !
. .
Daha kısa devre.
A = 0Vaka (kırmızı yol) burada biraz çelişkilidir olduğunu. IP sola saptırılır, sol alt köşeye kaydırılır, hemen yansır <ve ?okumaya geri döner B. Daha sonra, rigt köşeye sarar yazdırır Bile !ve sonlandırır.
A = 1Vaka (yeşil yol) biraz daha basittir. <Biz sadece yazdırmak böylece şube, IP sağ saptırarak !, başa dön sola kaydırmak ve en sona @.
Sadece bir tane 5 baytlık çözüm var:
\>?@!
Esasen aynı şekilde çalışır, ancak gerçek yürütme yolları oldukça farklıdır ve a yerine dallanma için bir köşe kullanır <.
1000: Nor
) \
! # ?
@ {
Bu, bu aramada bulunan en sevdiğim program olabilir. En güzel şey, bu uygulamanın noraslında 5 girişe kadar çalışmasıdır. Bunu açıklamak için biraz bellek modelinin ayrıntılarına girmem gerekecek. Hızlı bir tazeleme olarak, Hexagony'nin bellek modeli, her bir kenarın bir tamsayı değeri tuttuğu ayrı bir altıgen ızgaradır (başlangıçta hepsi sıfırdır). Bu kenar boyunca bir kenarı ve yönü belirten bir bellek işaretçisi (MP) vardır (öyle ki, geçerli solun önünde ve arkasında, anlamlı sol ve sağ komşularıyla birlikte iki komşu kenar vardır). İşte, MP ile kırmızı renkte gösterildiği gibi başlayarak, kullanacağımız kenarların bir şeması:
Öncelikle her iki girişin olduğu durumu düşünelim 0:
Biz sadece kenar artırır gri yolu, günü başlayacak A için 1böylece #IP'ye anahtarlar 1, mavi yolunu olduğunu sağ üst köşede başlayan. \orada hiçbir şey yapmaz ve ?bir girdi okur. Sol üst köşeye )kaydırarak girişleri artırır. Giriş sıfır olduğu sürece, bu a ile sonuçlanır 1, bu #hiçbir şey yapmaz. Daha sonra {birinci yineleme yani sola, MP hareket bir üzere B . Bu kenar hala ilk sıfıra sahip olduğundan, IP sağ üst köşeye ve yeni bir bellek kenarına geri sarılır. Bu yüzden bu döngü ?sıfır okur, MP'yi B'den altıgen etrafında hareket ettirir.ila C arasında D ve benzeri. ?Girdi olduğu için sıfır mı yoksa EOF olduğu için mi önemi yok .
Bu döngüdeki altı yinelemeden sonra, A'ya{ geri döner . Bu kez, kenar zaten ilk yinelemenin değerini tutar , böylece IP sol köşeye kaydırılır ve bunun yerine yeşil yolda devam eder. sadece bunu yazdırır ve programı sonlandırır.1!1@
Şimdi, girişlerden herhangi biri ne olacak 1?
Sonra bir noktada bunu ?okur 1ve )arttırır 2. Bu #, şimdi IP'leri tekrar değiştirecek ve kırmızı yolda sağ köşeye devam edeceğiz demektir . ?gerçekten önemli olmayan ve {bir kenarı daha ileriye taşıyan başka bir girişi (varsa) okur . Bunun kullanılmayan bir kenar olması gerekir, bu nedenle 5 girişe kadar çalışır. IP, hemen yansıdığı ve sağ köşeye sarıldığı için sağ üste sarılır. kullanılmayan kenara !basar ve IP'ye geri döner . O IP hala devam ediyor , güneybatıya gidiyordu (gri yol), bu yüzden hemen vurur ve programı sonlandırır.0#0#@
Toplamda bu kapı için yedi adet 7 baytlık çözüm bulunmaktadır. 5 tanesi bununla aynı şekilde çalışır ve kullanılmayan bir kenara geçmek için basitçe başka komutlar kullanır (ve farklı bir altıgen etrafında veya farklı bir yönde yürüyebilir):
)\!#?@" )\!#?@' )\!#?@^ )\!#?@{ )\!#?@}
Ve yalnızca iki girdiyle çalışan, ancak yürütme yolları aslında daha da karmaşık olan bir başka çözüm sınıfı var:
?]!|<)@ ?]!|<1@
1001: Eşitlik
( ~
? / @
# !
Bu ayrıca koşullu IP seçimini çok akıllıca kullanır. Biz arasına tekrar ayırmak gerekir A = 0ve A = 1. İlk durumda basmak istiyoruz not B, ikincisinde basmak istiyoruz B. Çünkü A = 0bu iki durumu da ayırt ediyoruz B. İle başlayalım A = B = 0:
Gri yoldan başlıyoruz. (~göz ardı edilebilir, IP (hala gri yolda) sol köşeye sarar ve okur Aile ?. (azalır, böylece biz almak -1ve IP sol alt köşeye kaydırın. Şimdi daha önce de söylediğim gibi, IP'yi seçmeden önce #modulo değerini alır 6, bu yüzden -1aslında 5kırmızı yolun sol köşesinde başlayan IP değerini alır . ?okur B, yeniden vurduğumuzda (IP’de 5kalmamızı sağlar #. IP'nin sağ alt köşeye sarılması, yazdırması ve sonlandırması için ~olumsuzlar .-11
Şimdi ise B, 1geçerli değer ikinci kez 0çarptığımız #zaman olacaktır, bu yüzden IP'ye geri dönelim 0(şimdi yeşil yoldayız). Bu ?üçüncü kez vurur , verir 0, !yazdırır ve @sonlandırır.
Son olarak, nerede durum A = 1. Bu kez, #ilk defa vurduğumuzda mevcut değer zaten sıfırdır , bu yüzden bu asla 5ilk etapta IP'ye geçmez . Hemen yeşil yol üzerinde devam ediyoruz. ?Şimdi sadece sıfır vermek değil, Bbunun yerine döner . !yazdırır ve @tekrar sonlandırır.
Toplamda bu kapı için üç adet 7 baytlık çözüm bulunmaktadır. Diğer ikisi çok farklı bir şekilde çalışıyor (birbirlerinden bile) ve daha da tuhaf kullanıyorlar #. Özellikle ,(bir tamsayı yerine bir karakter kodunu okuyarak) ile bir veya daha fazla değer okurlar ve daha sonra bir IP seçmek için bu modulo 6 değerini kullanırlar. Güzel fındıklar.
),)#?@!
?~#,~!@
1010: B değil
? ?
| @ !
) .
Bu oldukça basittir. Yürütme yolu, anddaha önce bildiğimiz yatay koldur. hemen ??okur Ave sonra B. |Yansıttıktan ve dallanmadan sonra B = 0, alt dalı uygulayacağız, burada )değerin artırılacağı değer 1artmaktadır !. Üst dalda (eğer ise B = 1) basılacak ?kenarı kolayca sıfırlayın .0!
Bu kapı için sekiz adet 6 baytlık program var. Bunlardan dördü hemen hemen aynıdır, >yerine |ya da 1yerine )(ya da her ikisini de) kullanarak:
??>@!) ??>@!1 ??|@!) ??|@!1
İki ?ayna nedeniyle iki kez kullanılan bir tek kullanın . Olumsuzluk sonra xorya (~da ile yaptığımız gibi olur ~).
?>!)~@ ?>!~(@
Ve son olarak, iki çözüm koşullu bir IP anahtar kullanmaktadır, çünkü kıvrımlı olanın da çalışması durumunda neden basit bir yöntem kullanıyorsanız:
??#)!@ ??#1!@
1011: B, A anlamına gelir.
\ #
? ? !
1 @
Bu, bazı oldukça ayrıntılı IP anahtarlama kullanır. A = 1Bu sefer dava ile başlayacağım , çünkü daha basit:
Biz okur gri yolu, günü başlayacak Aolan ?ve daha sonra vurur #. Yana Aolan 1bu IP geçer 1(yeşil yol). !Hemen, IP sol üst sarar ki okur yazdırır B(gereksiz yere) ve sonlandırır.
Ne zaman A = 0işler biraz daha ilginç olsun. İlk önce düşünelim A = B = 0:
Bu sefer, #hiçbir şey yapmıyor ve IP üzerinde kalıyoruz 0(o noktadan itibaren kırmızı yol). ?okur Bve 1a'ya dönüştürür 1. Sol üst köşeye kaydırdıktan sonra #tekrar vururuz, bu yüzden sonuçta yeşil yola son buluruz ve 1sonlandırmadan önce olduğu gibi yazdırırız .
Son olarak, işte, (A, B) = (0, 1)sahte dava:
Açıklık için başlangıçtaki gri yolu kaldırdığımı unutmayın, ancak program aynı şekilde başlar ve daha önce olduğu gibi kırmızı yola çıkarız. Yani bu sefer ikinci ?döner 1. Şimdi karşılaşıyoruz 1. Bu noktada Hexagony'de rakamların gerçekte ne yaptığını anlamak önemlidir (şimdiye kadar yalnızca sıfırlarda kullandık): bir rakamla karşılaşıldığında, geçerli değer 10 ile çarpılır ve sonra rakam eklenir. Bu normalde kaynak koduna yazılan ondalık sayıları yazmak için kullanılır, ancak bunun B = 1aslında değere eşlendiği anlamına gelir 11. Böylece, vurduğumuzda #, bu 6vermek için modulo alınır 5ve dolayısıyla IP'ye 5( 1daha önce olduğu gibi) geçip mavi yolda devam ederiz . İsabet?üçüncü bir zaman sıfırı döndürür, bu nedenle !yazdırır ve başka bir ikisinden sonra ?IP, programın sonlandırıldığı sağ alt köşeye kaydırılır.
Bunun için dört 7 baytlık çözüm var ve hepsi farklı çalışıyor:
#)/!?@$ <!?_@#1 \#??!1@ |/)#?@!
1100: A Değil
? (
~ ! @
. .
Sadece basit doğrusal bir: okumak Aile ?birlikte etkisiz hale (~ile yazdırmak !ile sona, @.
Alternatif bir çözüm var, ~)bunun yerine olumsuz geliyor :
?~)!@
1101: A, B anlamına gelir.
? .
| @ !
) .
Bu, henüz bahsettiğimiz zıt imadan çok daha basittir. Yine bu gibi yatay dal programlarından biri and. Eğer Abir 0, sadece artırılır alır 1alt dalda ve baskılı. Aksi halde, üst dal tekrar ?okunur Bve !bunun yerine onu yazdırır.
Çoğunlukla etkili no-op seçeneklerinden dolayı burada bir ton alternatif var (toplamda 66 çözüm). Bir başlangıç için yukarıdaki çözümü değiştirebildiğimiz gibi değiştirebiliriz ve andayrıca )ve arasında seçim yapabiliriz 1:
?.|@!) .?|@!) ?=|@!) =?|@!) ?_|@!) _?|@!) ?0|@!)
?.|@!1 .?|@!1 ?=|@!1 =?|@!1 ?_|@!1 _?|@!1 ?0|@!1
?.>@!) .?>@!) ?=>@!) =?>@!) ?_>@!) _?>@!) ?0>@!)
?.>@!1 .?>@!1 ?=>@!1 =?>@!1 ?_>@!1 _?>@!1 ?0>@!1
Daha sonra, ilk komutun neredeyse keyfi bir şekilde seçilebildiği koşullu IP seçimini kullanan farklı bir sürüm var )ve 1bu seçeneklerin bazıları için ve arasında bir seçenek var :
"?#1!@ &?#1!@ '?#1!@ )?#1!@ *?#1!@ +?#1!@ -?#1!@ .?#1!@
0?#1!@ 1?#1!@ 2?#1!@ 3?#1!@ 4?#1!@ 5?#1!@ 6?#1!@ 7?#1!@
8?#1!@ 9?#1!@ =?#1!@ ^?#1!@ _?#1!@ {?#1!@ }?#1!@
"?#)!@ &?#)!@ '?#)!@ *?#)!@ +?#)!@ -?#)!@
0?#)!@ 2?#)!@ 4?#)!@ 6?#)!@
8?#)!@ ^?#)!@ _?#)!@ {?#)!@ }?#)!@
1110: Nand
? $
@ # )
! <
Son karmaşık olanı. Hala okuyorsan, neredeyse başardın. :) A = 0İlk önce bakalım :
?okur Ave sonra vururuz $. Bu, bir #sonraki komutu atlayan , böylece sonlandırmamamız gereken bir atlama komutudur (Befunge'ninki gibi ) @. Bunun yerine IP devam ediyor #. Ancak bu yana Ais 0bu bir şey yapmaz. IP , yazdırıldığı alt yolda devam edecek şekilde )artar . Tarafa döner sola köşeye sarar ve program sonlanır sağa IP.11<
Ardından, girdi olduğunda (A, B) = (1, 0)bu durumu anlarız:
Aslında #biz IP'ye 1(yeşil yol) geçtikten sonra öncekiyle aynı , ancak o zamandan beri Bolduğu gibi ikinci kez (şimdi mavi yoldan) bastığımızda 0IP'ye geri dönüyoruz .0#1
Sonunda A = B = 1durum:
Bu kez, #ikinci kez olduğumuzda , geçerli değer hala 1IP'yi tekrar değiştirmememiz için geçerlidir. <Bunu yansıtır ve biz vurmak üçüncü kez ?bir sıfır olsun. Bu nedenle IP !, sıfırı yazdırdığı ve programın bittiği alt solda kaydırır.
Bunun için toplam dokuz adet 7 baytlık çözüm var. İlk alternatif, 1bunun yerine sadece kullanır ):
?$@#1!<
Daha sonra, devam eden IP anahtarlama miktarını kafanıza sokacak iki çözüm var:
)?#_[!@ 1?#_[!@
Bunlar aslında aklımı başımdan aldı: ilginç olan kısım IP değişiminin ertelenmiş bir şartlı olarak kullanılabileceği. Dilin IP anahtarlama kuralları, geçerli IP anahtar gerçekleşmeden önce bir adım daha atar. Eğer bu adım bir köşeden geçerse, o zaman geçerli değer IP'ye geri dönersek IP'nin hangi dalda devam edeceğine karar verir. Tam olarak giriş olduğunda bu olur A = B = 1. Her ne kadar bu dili nasıl tasarladığımla tutarlı olsa da, spekülasyonun bu anlamının hiçbir zaman farkında değildim, bu yüzden dilimin bana yeni püf noktaları öğretmesi güzel: D.
Öyleyse, IP değişim miktarı daha da kötü olan üçüncü bir çözüm var (bu ertelenmiş koşullu etkiden faydalanmasa da):
>?1]#!@
Ve sonra bir tane daha var:
?$@#)!<
Ve sonra bazı koşulsuz IP anahtarlama kullanan ve bunun yerine tüm mantığı dallar ve köşelerden alan dört eşdeğer çözüm var:
]<?<@!) ]<?<@!1 ]|?<@!) ]|?<@!1
1111: Doğru
1 !
@ . .
. .
Sonu için kendinize basit bir şey kazandınız: kenar koymak 1, yazdırmak !, sonlandırmak @. :)
Tabii ki, bir alternatif var:
)!@
Her zamanki gibi, Timwi'nin HexagonyColorer'ı ile oluşturulan tüm kontrol akış şemaları ve Ezoterik'siyle hafıza şeması .
