Zastanów się nad pytaniem napisanym zwykłym angielskim, którego odpowiedź zawiera dwa dość dokładne (ale potencjalnie sprytne) słowa lub frazy, które można oddzielić słowami „i”:

P: Jakie są dwie strony monety? Odp .: głowy i ogony

P: Jakie są najlepsze sposoby podróżowania? Odp .: samolot i plecak odrzutowy

P: Dlaczego kruk jest jak biurko? Odp .: ponieważ w obu występuje „b”, aw żadnym nie ma „n”

Cel

Napisz program, który przy normalnym działaniu generuje takie pytanie.

Kiedy każdy inny znak zostanie usunięty z programu, zaczynając od drugiego znaku, a wynik zostanie ponownie uruchomiony, wynik powinien być taki, jaki jest po lewej stronie „i” w odpowiedzi.

Kiedy każdy inny znak zostanie usunięty z programu, zaczynając od pierwszego znaku, a wynik zostanie ponownie uruchomiony, wynik powinien znajdować się po prawej stronie „i” w odpowiedzi.

(Same „i” nie są generowane.)

Przykład

Jeśli program jest

A1B2C3D4E5F6G7H8I9

a jego wynikiem jest

What are the two sides of a coin?

Wtedy wyjście ABCDEFGHIpowinno być heads, a wyjście 123456789powinno być tails.

Zasady dotyczące pytań i odpowiedzi

• Możesz skorzystać z moich przykładowych pytań, ale zachęcam do samodzielnego przygotowania własnych.
• Pytanie i dwie części odpowiedzi:
  • wszystko musi być wyraźne
  • powinien być powszechnym gramatycznie znaczącym angielskim
  • może zawierać tylko drukowalne ASCII (szesnastkowo od 20 do 7E)
• Idealnie byłoby, gdyby pytanie było pisane wielkimi literami i interpunkcyjne (ale odpowiedzi nie muszą być).
• Pytanie musi mieć co najmniej 30 znaków i entropię większą lub równą 3,5. (Wpisz ciąg, naciśnij oblicz , szukaj ostatniego H (X) .)
• Każda z dwóch części odpowiedzi (bez uwzględnienia [space]and[space]między nimi) musi mieć co najmniej 5 znaków z entropią powyżej lub równą 2.
• Słowo „i” może pojawić się w obu częściach odpowiedzi.

Zasady dotyczące kodu

• Żaden z 3 fragmentów kodu nie może:
  • zawierają komentarze lub inne elementy tradycyjnie ignorowane przez kompilator / interpreter (nie martw się o wstawienie dodatkowego średnika lub dwóch, ale jeśli uważasz, że to komentarz, prawdopodobnie tak jest)
  • zamknij program w trakcie wykonywania
• Kod może zawierać dowolne znaki, w tym Unicode i niedrukowalne ASCII.
• Może mieć nieparzystą lub parzystą liczbę znaków.
• Dane wyjściowe trafiają do standardowego lub pliku lub cokolwiek wydaje się rozsądne. Brak danych wejściowych.

Punktacja

Ponieważ nie chcę zachęcać do gry w golfa, ale chcę jeszcze bardziej zachęcić do sprytnych odpowiedzi, punktacja będzie czymś pomiędzy zawodów w golfie kodowym i konkursie popularności:

Wynik = (upvotes - downvotes) - floor((bytes in code that outputs question) / 3)

Najwyższy wynik wygrywa.

(Użyj http://mothereff.in/byte-counter jako licznika bajtów.)

JavaScript (148 bajtów)

Tworzy nonsensowne literały z efektem ubocznym tworzenia alertu * dla pytania. (podziały robią podobnie, ale tworzą alerty * dla każdej odpowiedzi).

"';"+alert( 'What is the ideal breakfast???')+/ " ;apl=e"rbta(k"esnc"r.armebplleadc ee g g s(" ) + " \/)k;e"/+ ",t'hceo 'c)a;kye= ailse rat (lpi)e "

Dzieli:

";+lr('hti h da rafs??)/";p="baken".replace   (    /ke/ ,'co');y=alert(p) 

i

'"aet Wa steielbekat?'+  alert("scrambled eggs")+"\);"+"the cake is a lie"

Pytanie: What is the ideal breakfast???

Odpowiedzi: baconiscrambled eggs

Brainfuck (437 znaków)

Muszę wyznać, że to mój pierwszy program, który robi coś sensownego. Program jest wysoce zoptymalizowany dla systemów o niskiej pamięci, ponieważ wykorzystuje tylko 4 lokalizacje pamięci.

Pytanie: What are the two main groups of trees?

Odpowiedzi: conifersibroadleafs

-+[[++++++++++++++++++++++[+>++++++[+>++++++++++++<>-+]+>+-+.++++++<+<+-+]+>+++++.+>++.+-..------.-<--..-+-+-+..->.-+-+-+.+<+++.+-+-+-+-+.++++.+++.+<.+>-+++-+++-+++-++.->]]++-+[[+-+-[[+++++++++++++++[>++>+++++>+++++++<<<-]>-->>---<++.+++++++++++++++++.-------.>.<<.>.>--.<++++.<.>>++.<+++.---.<.>>.+++.<++++++++++.<.>--.------------.++++++++.+++++.<.>-------.>-----.<++++++++.>+++.<+.>--.<<.>-.---------.<.>>+.--.<-..>+.<<[<++>-]<-.<]]]]

Główna pętla

Program składa się z głównej pętli (która tak naprawdę nie jest pętlą, ponieważ wszystkie bloki [] są wykonywane tylko raz) i dwóch sekcji.

-+[[        // let answers enter
            * SNIP interleaved answer sections *
]]
++-+[[      // let odd answer and question enter
    +-+-[[  // let question enter
            * SNIP question section *
    ]]
]]

Jeśli chcesz testować sekcje niezależnie, musisz wziąć pod uwagę główną pętlę. Lokalizacja 0 zawiera -1 w parzystej odpowiedzi, 1 w parzystej odpowiedzi i 2 w pytaniu.

Sekcja odpowiedzi

Parzysta odpowiedź (usunięte nieparzyste instrukcje):

// location 0 contains minus 1 from main
// set location 1 = 10 * 10 minus 1 = 99 (c)
+++++++++++[>++++++++++<-]>-. // c
++++++++++++.-.     // on
-----.---.          // if
-.+++++++++++++.+.  // ers
<                   // goto 0 (which contains 0)
+-+-+-+-+-          // padding to match length of odd answer

Dziwna odpowiedź (nawet instrukcje usunięte):

// location 0 contains 1 from main
// set location 1 = 16 * 6 plus 2 = 98 (b)  location used for characters below 'l'
// set location 2 = 16 * 7 plus 2 = 114 (r) location used for 'l' and above
+++++++++++++++[>++++++>+++++++<<-]>++.>++. // br
---.<               // o
-.+++.              // ad
>---.<              // l
+.----.+++++.       // eaf
>+++++++.           // s
>                   // goto 3 (which contains 0)

Sekcja pytań

Postanowiłem przechowywać miejsce w oddzielnej lokalizacji, ponieważ jego wartość różni się drastycznie od innych postaci. Umożliwia to proste drukowanie miejsca <.>.

// location 0 contains 2 from main
// set location 1 = 17 * 2 minus 2 = 32 (space)
// set location 2 = 17 * 5 plus 2 = 87 (W)   location used for characters below 'r'
// set location 3 = 17 * 7 minus 3 = 116 (t) location used for 'r' and above
+++++++++++++++[>++>+++++>+++++++<<<-]>-->>---<++. // W
+++++++++++++++++.  // h
-------.>.<         // at
<.>                 // (space)
.>--.<++++.         // are
<.>                 // (space)
>++.<+++.---.       // the
<.>                 // (space)
>.+++.<++++++++++.  // two
<.>                 // (space)
--.------------.    // ma
++++++++.+++++.     // in
<.>                 // (space)
-------.>-----.     // gr
<++++++++.>+++.     // ou
<+.>--.<            // ps
<.>                 // (space)
-.---------.        // of
<.>                 // (space)
>+.--.<-..>+.       // trees
<<[<++>-]<-.<       // ? (value_of_space * 2 minus 1)

Ostatnia aktualizacja

W mojej ostatniej aktualizacji zoptymalizowałem mnożenie, aby były używane minimalne instrukcje. Również włączenie „l” do drugiej grupy postaci w sekcji nieparzystych odpowiedzi okazało się ogromną poprawą. Oszczędności na pojedynczym znaku w odpowiedzi nieparzystej w zasadzie oznaczały dwa znaki z całego programu, ponieważ zmniejszają również dopełnianie od parzystej odpowiedzi. Usunąłem też kilka niepotrzebnych instrukcji tu i tam i nie sądzę, żebym mógł dalej optymalizować kod.

Partia - 84

Całkiem dumny z tego

Pełny program: Jakie są dwie strony monety? (konsola)

echo What are two sides of a coin?  2>>xx  2>>cc&&eecchhoo  hteaaidlss  2>>xx  2>>cc

Tylko Evens: głowy (plik „c”)

eh htaetosdso  on 2>x >c&echo heads 2>x >c

Tylko kursy: ogony (plik „x”)

coWa r w ie faci? >x 2>c&echo tails >x 2>c

Działa poprzez przekierowanie wyjścia błędu do pliku w obu przypadkach.

Python - 104 96 (gra w golfa: 76)

Moje rozwiązanie jest raczej proste (i jakoś czytelne):

"";print 'What is the color of a zebra?' ;""
paraianat= "' b l a c k '"
aparaianat="'w h i t e'"

Wydajność:

What is the color of a zebra?
black
white

Szczerze mówiąc, znalazłem pomysł na pierwszą linię w odpowiedzi Bitpwnera.

Jeszcze bardziej czytelna alternatywa: - 113 105 97

"";print 'What is the color of a zebra?' ;""
"p r i n t ' b l a c k '" ;"p r i n t ' w h i t e '"

Jeszcze krótsza alternatywa: - 86 76

"";print'What is the color of a zebra?';""
"""";;pprriinntt''bwlhaictke''"""

Rebmu : 79 znaków LUB (37 + długość (p1) + 2 * max (długość (p2), długość (p3)))

Najpierw dam 79-znakowe rozwiązanie, które pyta, jakich języków musisz się nauczyć? (entropia 4.0, z wyłączeniem 30 liter ?) i oferuje sugestie Rebola i [czerwonego] :

DD  11  DD :do dd {dd  {p{Which languages must you learn?}qt}} pp{{[RReebdo]l}}

Unikalna taktyka dostępna tutaj, która nie jest w innych językach, wynika z faktu, że nawiasy klamrowe są asymetrycznym ogranicznikiem łańcucha, który może legalnie zagnieżdżać się:

my-string: {"It's cool," said {Dr. Rebmu}, "for MANY reasons--like less escaping."}

To pozwoliło mi stworzyć uogólnione rozwiązanie, które może bez wysiłku działać na każdym programie, który nie używa sekwencji specjalnych. Wersja z 79 znakami była na tyle prosta, że ​​można ją było skrócić, ale aby poprawnie zawierać dowolne źródło programów dla programów p2 i p3, potrzebny byłby pełny szablon. Gdybyśmy tego użyli, byłoby 87 znaków:

DD  11  DD :do dd {dd  {p{Which languages must you learn?}qt}} ddoo{{pp{{[RReebdo]l}}}}

Wzorzec używania tej ogólnej formy jest taki, że jeśli masz trzy źródłowe teksty kolejnych znaków o różnych długościach (użyjmy przykładu AAA:BBBBB , CCCCCCC) można zakodować je jako coś wzdłuż linii:

DD  11  DD :do dd {dd  {AAAqt}} ddoo{{BCBCBCBCBC C C}}

(Uwaga: Chociaż ten wzorzec nie będzie działał bez poprawiania programów używających znaków zmiany znaczenia, nie jest to poważna wada. Uzyskanie niedopasowanego lewego nawiasu w ciągu ograniczonym nawiasami wymaga czegoś takiego jak {Foo ^{ Bar} ... ale można łatwo przepisać to za pomocą alternatywna notacja strun "Foo { Bar"i połączone przypadki mogą być zarządzane przez sklejenie ze sobą mieszanki strun nieskalowanych).

Więc ... a może przykład? Po udostępnieniu ogólnej formy, ten program znaków 573 został złożony w zaledwie kilka minut z 3 wcześniejszych rozwiązań golfowych:

DD 11 DD: do dd {dd {rJ N 0% rN Wa1m2j S {\ x /} D00 Hc & [u [Ze? Wa Qs ~ rpKw [isEL00c [skQd2k] [eEV? KQ [tlQ]] pcSeg - b00 [ eZ 1 5] 3] prRJ [si ~ dSPscSqFHs] eZ 1 [s + dCa + wM2cNO]]] Va | [mpAp2j] prSI ~ w { } Ls2w Wl h01tiVsb01n -1 chRVs { } hLceVn01qt}} ddoo {{BrdSz [f] [sn [{N sbeo [tIt0l1eV} 0e5gXN1 01L {5s0} C {1} 0 {0 Do5f0 0bMe1e0r0} 0]]] tMw9C9 Numz Jl [paN + [KperlCJBn [[ba sWS {B noJn Nt]]] {K, j} b P {. } lf EZ - - n [N m {G otothestoreandbuysome more}] {T akeonedownandpasspassitar ound} c B w P lf]]}}

• Jeśli nie zmodyfikujesz programu, jest to rozwiązanie Hourglass .

• Jeśli weźmiesz tylko nieparzyste postacie i uruchomisz je, zrobi to wydrukuje 99 butelek poematu z piwem

• Tylko parzyste postacie wykonają dla ciebie małą konwersję cyfr rzymskich .

Jeśli ktoś chce spróbować napisać ten program w wybranym przez siebie języku i myśli, że może pokonać 573, daj mi znać. Jeśli to zrobisz, nagrodzę cię dużą reputacją - zakładając, że twoim językiem nie jest Rebmu, ponieważ wiem, że te programy nie są minimalne. :-)

To „marnotrawstwo” odstępów, które dostajesz na końcu, dzieje się, gdy p2 i p3 mają niezrównoważone długości. Ale wszystkie 3 programy mają w tym przypadku różne rozmiary, więc nie ma szczególnie dobrego parowania do wyboru dla p2 / p3. (Wybrałem je, ponieważ nie było danych zewnętrznych jako danych wejściowych, takich jak labirynt itp., Nie dlatego, że miały one podobną długość. Chociaż mogłem napisać nowe programy, które byłyby bardziej optymalne, spędziłem wystarczająco dużo czasu i chodziło o ty nie trzeba pisać nowych programów ...)

Jak to działa

(Uwaga: zacząłem od bardziej „kreatywnego” podejścia, które nie było tak usprawnione, ale bardziej interesujące. Przeniosłem je do wpisu na moim blogu, ponieważ opisywanie tego podejścia jest już długie).

Kluczem tutaj jest sztuczka „eval code as a string”, podobnie jak niektóre inne wpisy, ma ona tylko kartę atutową asymetrycznego ogranicznika łańcucha. Zacznę od wyjaśnienia działania przypadku 80 znaków.

Oto „cały” program, dostosowujący białe znaki do czytelności tego przypadku:

DD 11                    ; assign 11 to dd (about to overwrite again)
DD :do                   ; make dd a synonym for DO (a.k.a. "eval")

; eval a string as source code that ends with QUIT (QT)
dd {dd  {p{Which languages must you learn?}qt}}

; we'll never get here, but whatever's here must be legally parseable
pp{{[RReebdo]l}}

Tutaj kończymy ustawianie DD na synonim DO (aka „eval”). Ale sztuczka polega na tym, że gdy uruchomione zostaną połówki programów, uruchamiają kod, którego jedynym efektem jest zdefiniowanie D na nieszkodliwym literale 1.

Oto, co robi kod nieparzystych znaków, ponownie dostosowuje białe znaki:

D 1                      ; assign 1 to d
D d                      ; assign d to itself, so it's still 1
d                        ; evaluates to integer, no side effect
{d pWihlnugsms o er?q}   ; string literal, no side effect
p {Rebol}                ; print "Rebol"

A oto kod parzystych znaków:

D 1                      ; assign 1 to d
D:od                     ; URL-literal (foo:...), no side effect
d                        ; evaluates to integer, no side effect
{{hc agae utyulan}t}     ; string literal (well-formed!), no side effect
p {[Red]}                ; print "[Red]"

W rzeczywistości w przypadku programu bez połówek program dd {dd {(arbitrary code)qt}}wykona dowolny kod. Istnieją jednak dwa wezwania do oceny zamiast tylko jednego. Jest tak, ponieważ podczas gdy zagnieżdżone nawiasy klamrowe działają świetnie w przeplecionym kodzie, zaburzają one ewaluacyjne zachowanie DO. Dlatego:

do {{print "Hello"}}

Załaduje ciąg jako program, ale ten program kończy się jako ciąg stały {print "Hello"}. Zatem sztuczka, której tu używam, polega na wzięciu mojego DD (zachowującego tę samą wartość funkcji co DO) i uruchomieniu go dwa razy. Połówki żują różne części sznurka, ale nie żują obu, jeśli parzystość / nieparzystość jest poprawna dla zawartości, a ponieważ to, co pozostało poza sznurkiem po połówce, jest tylko stałą stałąd , są nieszkodliwe.

Przy takim wzorcu pisanie zachowania programu nie jest wyzwaniem, gdy nie jest ono przecięte na pół - możesz wstawić wszystko, o ile długość znaków w kodzie jest parzysta (nieparzyste, jeśli liczysz QT, czyli QUIT). Jeśli potrzebujesz uzyskać parzystą liczbę z nieparzystej, wrzuć spację (tak naprawdę w mojej formule powyżej na p1 znajduje się +1 dla nieparzystych długości programu p1) . Wydaje się, że sztuczka polega na napisaniu kodu z przeplotem, który musi przejść przez analizator składni, jeśli nie jest podzielony na pół. (Nie zostanie uruchomiony z powodu QT, ale musi być ŁADOWALNY, zanim zostanie wykonany).

Ta sprawa jest trywialna; ppładuje się dobrze jako symbol, mimo że jest niezdefiniowany, i jest podzielony na pdruk w każdym programie połówkowym. Ale możemy zrobić kolejną sztuczkę, ponownie używając literału łańcuchowego. Połówki programów nadal mają DO zdefiniowane normalnie, więc moglibyśmy również powiedzieć:

ddoo{{pp{{[RReebdo]l}}}}

Ponieważ jedyną częścią wybraną przez analizator składni w całym przypadku jest słowo symboliczne ddooi literał łańcuchowy, możemy następnie przeplatać dowolne dwa programy, które chcemy w tym łańcuchu literalnym, i nie gniewać parsera. Połówki wersji powiedzą tylko:

do{p{Rebol}}

..i...

do{p{[Red]}}

Jak mówię, ta część wygląda znajomo na inne rozwiązania, które traktują programy jako ciągi znaków i je ewaluują. Ale w przypadku konkurencji, gdy pakowane programy zawierają zagnieżdżone ciągi znaków, to rzuca za nie klucze. Tutaj jedyne rzeczy, które wpędzą cię w kłopoty, to ucieczka przez carets ( ^) ..., którą można łatwo obejść.

(Mała uwaga „oszukująca”: dodałem QT do „QUIT” w odpowiedzi na ten problem. Właściwie wcześniej celowo usunąłem skrót dla quit… ponieważ jakoś myślałem, że to jest dobre tylko do użycia na konsoli i po prostu biorąc dwuliterowe spacja, jeśli nie było go w REPL. Dodam go, ponieważ widzę, że się myliłem, nie dodając go w tym przypadku w szczególności. Jednak przed tą zmianą byłoby o 2 znaki dłużej. Ponadto, kiedy po raz pierwszy opublikowałem rozwiązanie, w Rebmu wystąpił błąd, który uniemożliwiał jego faktyczne działanie, mimo że powinien mieć ... teraz działa.)

Perl 186 139 135

"";print'What are the best things in life?';""&&pprriinntt("'hceraurs ht hyeo ulra meennetmaiteiso'n s   o f   t h e i r   w o m e n ")

Jakie są najlepsze rzeczy w życiu?

"pitWa r h ettig nlf?;"&print('crush your enemies'                 )

zmiażdżyć swoich wrogów

";rn'htaetebs hnsi ie'"&print"hear the lamentations of their women"

usłyszeć lamenty ich kobiet

Korzystanie z krótszych odpowiedzi:

Perl 79 72

"";print'What are my preferred weapons?';""&&pprriinntt("'smwaocredss'")

What are my preferred weapons?(30 bajtów, H (X) = 3,76) swords(H (X) = 2,25) i maces(H (X) = 2,32)

Python - 139 103

"";print'What are the ingredients for success?';""; ";" ;id=='"RUaniincboorwnss'";;pprriinntt  id++"'"'

What are the ingredients for success?-> UnicornsiRainbows

Test:

c="\"\";print\'What are the ingredients for success?\';\"\"; \";\" ;id==\'\"RUaniincboorwnss\'\";;pprriinntt  id++\"\'\"\'"
exec c        # What are the ingredients for success?
exec c[::2]   # Unicorns
exec c[1::2]  # Rainbows
print 
print c[::2]  # ";rn'htaeteigeinsfrsces'";"";d="Unicorns";print d+''
print c[1::2] # "pitWa r h nrdet o ucs?;" ; i='Rainbows';print i+""

Stara wersja:

# What are the ingredients for success?
"";print(('What are the ingredients for success?'));""; ";" ;"pHrEiRnEt (C'OUMnEiSc oZrAnLsG'O)"; ";" ; "p,r iTnOtN(Y' RTaHiEn bPoOwNsY'.)"
# Unicorns
";rn('htaeteigeinsfrsces')";"";print('Unicorns');"";", TONY THE PONY."
# Rainbows
"pit(Wa r h nrdet o ucs?);" ; "HERE COMES ZALGO" ;  print('Rainbows')

Haskell, 117

Konieczność pracy z paradygmatem funkcjonalnym Haskell oznacza, że ​​wszystko musi być przypisane do zmiennej lub skomentowane komentarzem liniowym --lub blokowym {- -}; uruchamianie bezsensownych funkcji bez przypisania jest wyłączone. Aby zachować rozsądek, zadałem pytanie i odpowiedzi tak krótkie, jak pozwalają na to reguły.

Pytanie: Czego nie mam dość?

main=putStrLn{---}"What can I not have enough of?"{- }
=u"Scrank=e"sS"h
omeasi"n
=mpauitnS=tpru taSntprt tmLi

-----}

„Buty” i „ciastka”:

mi=uSrn--"htcnInthv nuho?{ 
uSrn="Shoes"
main=putStr mi
--}

anpttL{-}Wa a  o aeeog f"-}="cakes"
main=putStr anpttL
---

NB Pojawienie się crankpod „Czego nie mam dość?” nie powinny być postrzegane jako znaczące.

Lisp (76 znaków)

31-znakowe pytanie, 6 znaków w każdej odpowiedzi ⟹ długość - ładunek = 33

'(: (pprriinncc''fmuacghesnitaa))':(princ "What is your favorite pink hue?")

Chciałem użyć „Jaki jest twój ulubiony kolor?”, Ale nawet rozciągnięty na pisownię brytyjską, osiągnął on jedynie minimum 30 znaków dla długości pytania i potrzebowałem pytania o nietypowej długości, aby zrównoważyć podwójne cudzysłowy.

Mówi się, że Common Lisp jest gadatliwy, ale nie pomyślałbyś, że tak będzie. To nawet nie jest bardzo zaciemnione, wystarczy wstawić odrobinę spacji, aby zobaczyć, co jest cytowane i co jest wykonywane.

Wiele implementacji Lisp wykrzykuje kolory, ponieważ wypacza symbole na wielkie litery. Jeśli ci to przeszkadza, zmień ''fmuacghesnitaana ""fmuacghesnitaa"".

STATA 295

Pytanie: Jakie są najlepsze desery do wypieku w tej chwili? Odpowiedź: ciasteczka i ciasteczka.

Objaśnienie: Polecenia w STATA są ograniczone nowymi wierszami.
Podczas gdy „//” jest komentarzem w STATA, „///” informuje kompilator o przejściu do następnego wiersza i dołączeniu jego zawartości do bieżącego polecenia.

Polecenia w STATA można często skracać do tego stopnia, że ​​uważa się je za wystarczająco unikalne, aby można je było rozróżnić (więc „generuj” staje się „g”, „globalny” staje się „gl” lub „glo”, „przechwytywanie” staje się „cap”, „ display „staje się„ di ”itp.). Polecenie display wyświetla tekst na ekranie. Polecenie przechwytywania rejestruje wszystkie błędy (w tym błędy składniowe), dlatego ten program poprawnie się kompiluje.

Myślę, że jeśli chcesz być wybredny, wszelkie dodatkowe „/” po pierwszych 3 kolejnych w linii są ignorowane przez kompilator. Ponadto w programie „ciasteczka” technicznie + „” jest komentarzem. Ale twierdzę, że nadal się liczy, ponieważ polecenie przechwytywania nadal uczyniłoby go nieistotnym, nawet gdyby nie był komentarzem.

Dziękuję za przeczytanie mojego naprawdę długiego wyjaśnienia. Teraz kod:

„Jakie są najlepsze desery do wypieku?”

g   a = "g   q   /b/a/" 
g l= "b = ""b r o w n i e s "
g   c = "g   /b/a/" 
g lpo= "d = ""c o o k i e s "
g   e = "c a p  "  /////
 +  "d i ""$ b "
g   f = "c a p  "  /////
 +  "d i ""$ d "
g   g = "c a p  "  /////
 + "c a p   / / /  "+ "/ / /"
di "What are the best desserts to bake right now?"

„ciasteczka”

g a="    ba"
gl b="brownies"
    g /// 
 p="  "       
g e="   " //
 di "$b"
    cap ///
+" "  
g g="   " //
  cap ///   +"  "
i"htaetebs esrst aergtnw"

"ciasteczka"

    g q /// 
 ="  "        
g c="  ba"
glo d="cookies"
    cap ///
+" "  
g f="   " //
 di "$d"
    cap  ///
+ "       " ///
d Wa r h etdset obk ih o?

Ksh (82 znaków)

35-znakowe pytanie, 5 znaków w każdej odpowiedzi ⟹ długość - ładunek = 37

ec=\'o'(;)eehc(h)oe cChroi m$e1;; '\'
echo  What\'s the  country\'s worst problem?

Nadużywam składni definicji funkcji poza POSIX. Dash i bash nie mogą tego zrobić, ale ksh (domena publiczna lub ATT) może.

Nie dzieje się nic niezwykłego, tylko echo. Nie marnuj nie chcij.

PowerShell 88

"" > $x;{What is my favorite equipment?};"" >> ${x}

${XsXwXoXrXdX};;;${XsXhXiXeXlXdX}

Jaki jest mój ulubiony sprzęt? (30 znaków, H (X) = 4,0314)

"  x{hti yfvrt qimn?;"> {}
{sword};$XXXXXXX

miecz (5 znaków, H (X) = 2,32193)

">$;Wa sm aoieeupet}" >$x
$XXXXXX;;{shield}

tarcza (5 znaków, H (X) = 2,58496)

W pełnym programie przekierowuje puste ciągi do nieistniejącej zmiennej ${x}(cudzysłowy dla tych pustych ciągów są używane do utworzenia nonsensownego ciągu, który jest przekierowywany do pustego bloku {}lub nieistniejącej zmiennej $xw wersjach parzystych / nieparzystych), a następnie drukuje pytanie i deklaruje 2 nieużywane zmienne (które są drukowane i umieszczane obok innej nieużywanej zmiennej $XXXXXXlub $XXXXXXXw różnych przypadkach).

GolfScript, 51 bajtów

"Which are the sides of a coin? ".;""thaeialdss""

Wydajność

Which are the sides of a coin? 

Jak to działa

.;duplikuje ciąg i usuwa kopię. ""wypycha pusty ciąg. thaeialdssjest niezdefiniowany, więc nic nie robi.

Dziwne znaki

"hc r h ie faci?";"heads"

Wydajność

heads

Jak to działa

; usuwa pierwszy ciąg ze stosu.

Nawet znaki

Wihaetesdso  on ."tails"

Wydajność

tails

Jak to działa

Wihaetesdsoi onsą noops. .duplikuje pusty ciąg na stosie.