Dato che Halloween sta arrivando, ho pensato di poter iniziare una divertente piccola sfida di golf in codice!

La sfida è abbastanza semplice. Devi scrivere un programma che emetta tricko treat.
"La svolta?" potresti chiedere. Bene, lasciami spiegare:

Il tuo programma deve fare quanto segue:

• Essere compilabili / eseguibili in due lingue diverse. Non contano versioni diverse della stessa lingua.
• Quando si esegue il programma in una lingua, dovrebbe essere visualizzato tricke l'altro dovrebbe essere visualizzato treat. Il caso è irrilevante e il riempimento della stringa con caratteri di spazi bianchi è consentito (vedere esempi).
• Questo è code-golf , quindi vince la soluzione con il minor numero di byte.

Alcune spiegazioni:

Output validi (solo per le parole non per l'esecuzione del codice nelle due lingue. Aggiunta anche di virgolette per segnalare l'inizio o la fine dell'output. Non includerli nella soluzione!):

"trick"

"Treat"

"    TReAt"

"
     tRICk          "

Uscite non valide :

"tri ck"

"tr
eat"

"trck"

Sono interessato a vedere cosa puoi inventare! Buon golf!

Vorrei sottolineare che questa è la mia prima sfida, quindi se avete suggerimenti su questa domanda, lasciateli sotto forma di un commento.

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

# Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=97472,OVERRIDE_USER=23417;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=o.replace(TAGS_REG,"")),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i,TAGS_REG = /(<([^>]+)>)/ig;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:400px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

2sable / pl , 8 byte

0000000: 74 72 65 61 74 93 d0 cb                          treat...

Entrambi i programmi sono stati testati localmente con lo stesso file a 8 byte, quindi questo è un poliglotta corretto.

2 set: trucco

Questo è il programma nella tabella codici 1252 .

treat“ÐË

Provalo online!

pl: treat

Questo è il programma nella tabella codici 437 .

treatô╨╦

Provalo online!

Come funziona

2 set: trucco

t         Square root. Errors since there is no input. The exception is caught, the
          stack left unaltered, and the interpreter pretends nothing happened.
 r        Reverse stack.
          Reversed empty stack is still empty stack. ;(
  e       Compute nCr. Errors since there is no input.
   a      Alphanumeric test. Errors since there is no input.
    t     Square root. Errors since there is no input.
     “    Begin a lowercase string literal.
      Ð     Excluding ‘, ’, “, and ”, Ð is the 71st non-ASCII character in CP1252.
       Ë    Excluding ‘, ’, “, and ”, Ë is the 66th non-ASCII character in CP1252.
          (implicit) End string literal.
          Both characters together fetch the dictionary word at index
          71 * 100 + 66 = 7166, which is 'trick'.

pl: treat

treat     Bareword; push the string "treat" on the stack.
     ô    Unimplemented. Does nothing.
      ╨   Flatten the stack. This doesn't affect the output.
       ╦  Unimplemented. Does nothing.

Python / Windows Batch, 25 byte

print"trick"#||echo.treat

Tutto dopo il # viene interpretato come un commento da Python, mentre il || è un OR in batch, dicendo che poiché il comando precedente non è riuscito, eseguire questo.

Mi piace anche l'uso di un OR in quanto legge quasi "dolcetto o scherzetto" :)

Spazio bianco / stellato, 135 byte

Ecco un cielo sereno ad Halloween!

  + + + + + 
    +

* + + * + *

   + *           
     + +        

 + * +   



 + * +. +. + + * + + *. . .

Si noti che gli spazi bianchi su righe vuote potrebbero non essere conservati se si copia dal codice sopra

Gli spazi bianchi producono "TRICK". Provalo online!
Uscite stellate "TREAT". Provalo online!

Spiegazione

Stellato

Starry ignora tutte le schede e le nuove righe, quindi il codice che legge è il seguente

         + + + + + +  * +   +*   +  *   +  *       + +   +* +   +* + .  + .   +      +* +   +* . . .

In ogni caso, spingere i valori è molto costoso rispetto alle operazioni di stack e aritmetiche in Starry. Il codice inizia spingendo e duplicando 4 e esegue una serie di operazioni su di esso e con 2 e 1 spinti in seguito produce tutti i valori ASCII richiesti.

Codice annotato

Stack (after op)    Code        Operation
4                            +  Push 4
4 4 4 4 4 4          + + + + +  Duplicate top of stack 5 times
4 4 4 4 16            *         Multiply top two items
4 4 4 4 16 16        +          Duplicate top of stack
4 4 4 16 4 16          +        Rotate top three items on stack right
4 4 4 16 20         *           Add top two items
4 4 20 4 16            +        Rotate...
4 4 20 64             *         Multiply...
4 64 4 20              +        Rotate...
4 64 80               *         Multiply...
4 64 80 2                  +    Push 2
4 64 80 2 2          +          Duplicate...
4 64 2 80 2            +        Rotate...
4 64 2 82           *           Add...
4 64 2 82 82         +          Duplicate...
4 64 82 2 82           +        Rotate...
4 64 82 84          *           Add...
4 64 82 84 84          +        Rotate...
4 64 82 84           .          Pop and print as character (T)
4 64 84 82            +         Swap top two items on stack
4 64 84              .          Pop and print... (R)
84 4 64                +        Rotate...
84 4 64 1                 +     Push 1
84 4 65             *           Add...
84 4 65 65           +          Duplicate...
84 65 4 65             +        Rotate...
84 65 69            *           Add...
84 65                .          Pop and print... (E)
84                   .          Pop and print... (A)
                     .          Pop and print... (T)

Lo spazio bianco

Come suggerisce il nome, Whitespace analizza solo i tre caratteri degli spazi bianchi: spazio, tabulazione e nuova riga. A differenza del stellata, gli spazi spinge semplicemente i valori ASCII delle T, R, I, C, e Ke le loro stampe.

Codice annotato

<Space><Space><Space><Tab><Space><Tab><Space><Space><Tab><Space><LF> Push the ASCII value of R
<Space><Space><Space><Tab><Space><Tab><Space><Tab><Space><Space><LF> Push the ASCII value of T
<Tab><LF><Space><Space> Pop and print the T
<Tab><LF><Space><Space> Pop and print the R
<Space><Space><Space><Tab><Space><Space><Tab><Space><Space><Tab><LF> Push the ASCII value of I
<Tab><LF><Space><Space> Pop and print the I
<Space><Space><Space><Tab><Space><Space><Tab><Space><Tab><Tab><LF>   Push the ASCII value of K
<Space><Space><Space><Tab><Space><Space><Space><Space><Tab><Tab><LF> Push the ASCII value of C
<Tab><LF><Space><Space> Pop and print the C
<Tab><LF><Space><Space> Pop and print the K
<LF><LF><LF>            Terminate the program. The following line is not run.
<Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><Space><LF>

L'intreccio di push e stampe è stato scelto in base esclusivamente a ragioni estetiche in quanto non influisce sul conteggio dei byte.

File .COM Linux ELF x86 / DOS, 73 byte

00000000  7f 45 4c 46 01 00 00 00  1a 00 00 00 1a 00 43 05  |.ELF..........C.|
00000010  02 00 03 00 1a 00 43 05  1a 00 43 05 04 00 00 00  |......C...C.....|
00000020  eb 0c b4 09 ba 41 01 cd  21 c3 20 00 01 00 b2 05  |.....A..!. .....|
00000030  b9 3b 00 43 05 cd 80 2c  04 cd 80 74 72 69 63 6b  |.;.C...,...trick|
00000040  00 74 72 65 61 74 24 eb  d9                       |.treat$..|
00000049

Fonte NASM:

ORG 0x05430000

BITS 32                                         ;
                                                ;   ELF HEADER    --   PROGRAM HEADER
; ELF HEADER                                    ; +-------------+
DB 0x7f,'E','L','F'                             ; | magic       |    +--------------------+
                                                ; |             |    |                    |
; PROGRAM HEADERS                               ; |             |    |                    |
DD 1                                            ; |*class 32b   | -- | type: PT_LOAD      |
                                                ; |*data none   |    |                    |
                                                ; |*version 0   |    |                    |
                                                ; |*ABI SysV    |    |                    |
DD 0x01a        ; offset = vaddr & (PAGE_SIZE-1); |*ABI vers    | -- | offset             |
                                                ; |             |    |                    |
entry:  DD 0x0543001a                           ; |*PADx7       | -- | vaddr = 0x0543001a |
DW 2                                            ; | ET_EXEC     | -- |*paddr LO           |
DW 3                                            ; | EM_386      | -- |*paddr HI           |
DD 0x0543001a                                   ; |*version     | -- | filesz             |
;       inc     ebx     ; STDOUT_FILENO         ; |             |    |                    |
;       mov     eax, 4  ; SYS_WRITE             ; |             |    |                    |
DD 0x0543001a                                   ; | entry point | -- | memsz              |
DD 4                                            ; | ph offset   | -- | flags: RX          |
                                                ; |             |    |                    |
        jmp     short skip                      ; |*sh offset   | -- |*align              |
BITS 16                                         ; |             |    |                    |
treat:  mov     ah, 9                           ; |             | -- |                    |
        mov     dx, trick + 0x100 + 6           ; |*flags ______|    |                    |
        int     0x21                            ; |______/      |    +--------------------+
        ret                                     ; |*ehsize      |
BITS 32                                         ; |             |
DW 32                                           ; | phentsize   |
DW 1                                            ; | phnum       |
skip:                                           ; |             |
        mov     dl, 5   ; strlen("trick")       ; |*shentsize   |
        mov     ecx, trick                      ; |*shnum       |
                                                ; |*shstrndx    |
                                                ; +-------------+
        int     0x80
        sub     al, 4   ; SYS_EXIT
        int     0x80


trick:  DB      "trick/treat$"

BITS 16
        jmp     short treat

Questo utilizza il fatto che l'intestazione ELF inizia con 7F 45, che, interpretato come codice x86, è un salto.

Le parti rilevanti per il DOS .COM:

-u100 l2
07D2:0100 7F45          JG      0147
-u147 l2
07D2:0147 EBD9          JMP     0122
-u122 l8
07D2:0122 B409          MOV     AH,09
07D2:0124 BA4101        MOV     DX,0141
07D2:0127 CD21          INT     21
07D2:0129 C3            RET
-d141 l6
07D2:0140     74 72 65 61 74 24   -                           treat$

evil / ZOMBIE , 109 byte

Un'altra risposta spettrale!

xf is a vampire summon task f say "trick" stumble say "jzuueeueeawuuwzaeeaeeaeawuuuuwzuueeueeaw" animate bind

Il ZOMBIEcodice definisce un vampirenome la xfcui unica attività fè attivata all'istanza e verrà emessa trickuna volta prima di essere disattivata da stumble. L'altra saychiamata è il codice morto (come appropriato!) Per ZOMBIE, ma contiene la maggior parte del evilcodice.

Perché evil, il xfnome è una chiamata a saltare al successivo j, che precede il zuueeueeawuuwzaeeaeeaeawuuuuwzuueeueeawgemito zombi che crea e produce treat. Il codice seguente viene eseguito (lettere minuscole) o ignorato, ma poiché non è wnecessario produrre alcun risultato.

Python / Perl, 28 byte

print([]and"trick"or"treat")

Spiegazione

Dato che []è un ArrayRef in Perl, è vero, ma è un array vuoto in Python, quindi falsa.

PHP / JavaScript, 32 30 byte

Viene visualizzato trickin PHP e treatin JS.

NaN?die(trick):alert('treat');

La NaNcostante sconosciuta viene implicitamente convertita in una stringa da PHP, rendendola vera. È falso in JS.

Metodo alternativo, 38 byte

(1?0:1?0:1)?die(trick):alert('treat');

L'operatore ternario è associativo di destra in JS:

                1 ? 0 : 1 ? 0 : 1
 is parsed as:  1 ? 0 : (1 ? 0 : 1)
 which equals:  0

E associativo di sinistra in PHP:

                1 ? 0 : 1 ? 0 : 1
 is parsed as:  (1 ? 0 : 1) ? 0 : 1
 which equals:  1

HTML / HTML + JavaScript, 53 byte

treat<script>document.body.innerHTML='trick'</script>

treatè il contenuto testuale del documento in HTML.
Se JS è abilitato, sostituirà il contenuto HTML con trick.

C / Java 7, 165 155 128 123 122 120 103 byte

//\
class a{public static void main(String[] s){System.out.print("treat"/*
main(){{puts("trick"/**/);}}

// \ rende la riga successiva anche un commento in C ma è un normale commento di una riga in Java, quindi puoi fare in modo che C ignori il codice destinato a Java e aggiungendo / * nella seconda riga puoi fare un commento per Java che è analizzato come codice da C.

Modifica: l'ho migliorato un po 'riorganizzando le righe e i commenti.

Edit2: ho fatto un po 'più di riorganizzazione e abbreviato ancora di più.

Edit3: ho aggiunto le correzioni suggerite da BrainStone per rimuovere 5 byte, grazie :)

Edit4: Una nuova riga si è rivelata superflua, quindi l'ho rimosso.

Edit5: ho cambiato printf in put.

Edit6: ho aggiunto una correzione suggerita da Ray Hamel.

Jolf + Chaîne, 12 byte

Poiché Chaîne non può accettare un file da caricare con una codifica, presumo UTF-8. (Se potessi assumere ISO-8859-7, questo sarebbe di 11 byte, ma sarebbe ingiusto.)

trick«treat

In Chaîne, «inizia un commento, e il resto viene stampato alla lettera. In Jolf, «inizia una stringa. Per fortuna, tricknon fa nulla di dannoso (in 10; range(input, parseInt(input))pratica) e treatviene stampato.

Prova Jolf qui!

Prova Chaîne qui!

Entrambi funzionano sul mio browser (Firefox, ultima versione), ma lo stesso non si può dire per altri browser.

#hell / Agony , 43 byte

Tanto ><>ovunque, che cos'è questa, una sfida per i pesci d'aprile? Ecco una risposta con lingue a tema appropriato.

--<.<.<.<.<.$
io.write("trick")--+<~}~@+{+<

#hellè un sottoinsieme di LUAcui accetta fortunatamente io.writechiamate in uscita. Usiamo LUAi --commenti in modo che esegua solo questo frammento.

Agonyè un Brainfuckderivato, che ha la particolarità di avere il suo codice e la memoria di lavoro sullo stesso nastro. La prima riga stampa solo 5 caratteri (10 celle) dalla fine del segmento di codice, dove ho codificato treatcome Agonycomandi. LUAL 'apertura del commento --modifica il valore di una cella che non viene utilizzata.

Cubix / Hexagony , 31 byte

t;./e;_a]"kcirt">o?@;=v=./r;\;/

Fallo fuori! Trattalo online!

Halloween a tema ? Nota i fatti terrificanti su queste lingue e il codice:

1. Se e anche se non fai nulla (basta mettere le operazioni), non puoi mai uscire dal ciclo che è determinato a funzionare per sempre ...
2. Ed essere bloccato nel mezzo di un linguaggio di programmazione 3D e 2D (Oh agonia ...)
3. All'interno delle dimensioni, perderai gradualmente dove sei ... dove eri ...
4. E c'è un =v=sorriso su di te che agisce in caso di no-op nel codice

Scaviamo nel mistero del protocollo di comunicazione nascosto di 31 byte di dimensioni e terrore ...

trucco

Quando il codice si ripiega o si sviluppa da solo ... Cioè cubified, il layout è simile al seguente:

      t ; .
      / e ;
      _ a ]
" k c i r t " > o ? @ ;
= v = . / r ; \ ; / . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

E la parte principale è questa parte nel mezzo:

" k c i r t " > o ? @ .
. . . . . . . \ ; / . .

Spinge k,c,i,r,tsullo stack, oemette e si ;apre all'interno di un loop delimitato da riflettori e? che ti guida a seconda del valore nella parte superiore dello stack ...

trattare

Improvvisamente, il codice si trasforma da un cubo in un esagono. (Immaginalo)

   t ; . /
  e ; _ a ] 
 " k c i r t 
" > o ? @ ; = 
 v = . / r ;
  \ ; / . .
   . . . .

E la parte principale è questa parte:

   t ; . /
  e ; _ a ] 
 . . . . . . 
. . . . @ ; = 
 . . . / r ;
  . . . . .
   . . . .

Funziona t;che stampa te colpisce lo specchio e gira la sua direzione verso NW partendo dall'angolo SE e colpisce un altro specchio. Questo corre r;e si avvolge e;_ae lo ]porta al Puntatore di istruzioni 1 che inizia all'angolo NE che punta a SE e colpi /che si riflettono in orizzontale fino ad ;allora t.

Poi si avvolge a =, ;e @si conclude il pasticcio.

Quindi ... Cosa _ci fa li?

Perché è dentrot e a (le prime 3 lettere del codice)?

Arriva la fine della storia -

non fa niente .

Sembra la fine di una storia dell'orrore?

SQL / Javascript, 54 byte

select('trick')
--a;function select(){alert("treat")}

Stesso approccio della mia risposta QB / JS : la prima riga ha l'istruzione SQL, la seconda riga ha un 'commento' per SQL e un NOP per JS. Quindi, definiamo l' selectistruzione SQL come una funzione JS valida.

/Brainf..k/, 143 + 3 = 146 byte

Questa risposta richiede l' -Aoutput del flag in ASCII per Brain-Flak e per fortuna a Brainfuck non interessa quel flag, quindi non influisce sull'output in Brainfuck.

(((((()(()()()){})({}){}){}){})+++++++[<+++<(((()()()())((((({}){}){}){}){}()))[][][][]())>>-])<[<++++>-]<.--.---------.------.>++[<++++>-]<.>>

Provalo online!

Provalo online!

Come funziona

L'unica sovrapposizione tra la sintassi di Brain-Flak e Brainfuck sono i personaggi <>[]. Per il brain-flak ciò significa principalmente che il programma deve garantire un numero pari di switch di stack <>. E per Brainfuck questo significa che dobbiamo evitare cicli infiniti causati dall'uso della []monade.

Il codice Brain-Flak è il seguente:

(((((()(()()()){})({}){}){}){})[<<(((()()()())((((({}){}){}){}){}()))[][][][]())>>])<[<>]<>[<>]<>>

A parte il [<<...>>]bit nel mezzo e <[<>]<>[<>]<>>alla fine questo codice è abbastanza alla pari per quanto riguarda i programmi Brain-Flak. Il negativo attorno allo zero ( [<...>]) è lì per creare un loop per Brainfuck. L'interno <...>è usato per spostare il Brainfuck in una cella vuota prima che incontri il[][][][] che altrimenti si avvolerebbe all'infinito.

Il codice Brainfuck è il seguente:

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

Oltre ai suddetti bit, questo è anche un programma piuttosto standard, quindi ti risparmierò i dettagli.

> <> / Pesca , 38 byte

_"kcirt"ooooo;
[+vCCCCCCCC
   `treat`N

Per fare un ><>/ Fishingpoliglotta.

È il mio primo pezzo di Fishingcodice dopo aver giocato a lungo con ><>.
La mia prima impressione: come in natura, il pescatore ha meno capacità fisiche della sua preghiera ma compensa con il suo strumento!

Qui il codice è estremamente semplice: ><>eseguirà solo la prima riga, dove si _trova uno specchio verticale e non ha alcun effetto poiché il pesce inizia a nuotare in orizzontale. Spinge semplicemente tricksulla pila e poi la stampa prima di fermarsi.
Per Fishing, l' _istruisce di scendere. Il pescatore seguirà il mazzo che è la seconda linea mentre cattura i personaggi della terza linea. Questi spingerannotreat il nastro quindi lo stamperanno, fermandosi quando raggiunge la fine del deck.

Se è consentito l'errore, è possibile scendere a 35 byte con il seguente codice che genererà un errore quando eseguito come ><>una volta che trickviene stampato dallo stack:

_"kcirt">o<
[+vCCCCCCCC
   `treat`N

Dovresti anche controllare le risposte delle mie lingue a tema, #hell / Agony and evil / ZOMBIE !

05AB1E / In realtà , 10 byte

"trick"’®Â

Spiegazione

05AB1E

"trick"     # push the string "trick"
       ’®Â  # push the string "treat"
            # implicitly print top of stack (treat)

Provalo online

In realtà

"trick"     # push the string "trick"
       ’®Â  # not recognized commands (ignored)
            # implicit print (trick)

Provalo online

Haskell / Standard ML , 56 byte

fun putStr x=print"treat";val main=();main=putStr"trick"

Vista di Haskell

I punti e virgola consentono più dichiarazioni in una riga e si comportano come interruzioni di riga, quindi otteniamo

fun putStr x=print"treat"
val main=()
main=putStr"trick"

Un programma Haskell viene eseguito chiamando la mainfunzione, quindi nell'ultima riga putStr"trick"viene eseguita la stampa trick.
Le prime due righe vengono interpretate come dichiarazioni di funzioni che seguono il modello <functionName> <argumentName1> ... <argumentNameN> = <functionBody>. Così in prima fila una funzione denominata funviene dichiarato che prende due argomenti con nome putStre xed il corpo della funzione print"treat". Questa è una funzione Haskell valida con tipo fun :: t -> t1 -> IO (), il che significa che accetta un argomento di tipo arbitrario te una seconda di un tipo t1e quindi restituisce un'azione IO. I tipi te t1non contano poiché gli argomenti non vengono utilizzati nel corpo della funzione. Il tipo di azione IO risulta da print"treat", che stampa "treat"su StdOut (notare" , ecco perchéputStrinvece di printè usato in main). Tuttavia, poiché è solo una dichiarazione di funzione, in realtà non viene stampato nulla in quanto funnon viene richiamato main.
Lo stesso accade nella seconda riga val main=();, valviene dichiarata una funzione che accetta un argomento arbitrario chiamato maine restituisce unità , la tupla vuota (). Il tipo è val :: t -> ()(Sia il valore che il tipo di unità sono indicati con ()).

Provalo su Ideone.

Vista ML standard

ML standard è un linguaggio principalmente funzionale con una sintassi correlata, ma non uguale a Haskell. In particolare, le dichiarazioni di funzione sono precedute dalla parola chiave funse accettano argomenti e dalla parola chiave valse non lo fanno. Inoltre è possibile avere un'espressione ai massimi livelli (che significa non all'interno di alcuna dichiarazione) che viene eseguita quando il programma viene eseguito. (In Haskell scrivere 1+2fuori da una dichiarazione genera un naked expression at top levelerrore). Finalmente il simbolo per testare l'uguaglianza è =invece che ==in Haskell. (Ci sono molte più differenze, ma queste sono le uniche che contano per questo programma.)
Quindi SML vede due dichiarazioni

fun putStr x=print"treat";
val main=();

seguito da un'espressione

main=putStr"trick"

che viene quindi valutato. Per determinare se mainuguali putStr"trick", entrambe le parti devono essere valutate ed entrambe devono avere lo stesso tipo, poiché SML (così come Haskell) viene tipizzato staticamente. Diamo prima uno sguardo al lato destro: putStrnon è una funzione di libreria in SML, ma abbiamo dichiarato una funzione denominata putStrnella riga fun putStr x=print"treat";- prende un argomento x(questa è la stringa "trick"nel nostro caso) e la dimentica immediatamente di nuovo, poiché non si verifica nel corpo della funzione. Quindi print"treat"viene eseguito il corpo che stampa treat(senza racchiudere ", SML printè diverso da quello di Haskell print).
printha il tipo string -> unit, quindi putStrha il tipo a -> unite quindi putStr"trick"ha solo il tipounit . Per essere ben scritto,main devi avere unitanche il tipo . Il valore per unità è in SML lo stesso di Haskell (), quindi dichiariamo val main=();e tutto è ben scritto.

Provalo su codingground.
Nota: l'output nella console è

val putStr = fn : 'a -> unit                                   
val main = () : unit                                                    
treatval it = true : bool

perché in SML \ NJ il valore e il tipo di ogni istruzione vengono visualizzati dopo ogni dichiarazione. Quindi, prima i tipi di putStre mainsono mostrati, allora le espressioni viene valutato facendo treatda stampare, quindi il valore dell'espressione ( truecome entrambi i lati =sono ()) è vincolata alla variabile risultato implicito itche viene poi visualizzata anche.

Rubino / C, 64 62 51 48 byte

#define tap main()
tap{puts(0?"trick":"treat");}

Cosa vede Ruby:

tap{puts(0?"trick":"treat");}

Il tapmetodo prende un blocco e lo esegue una volta. È un breve identificatore che possiamo creare a#define macro in C. Ci consente anche di inserire un blocco racchiuso tra parentesi graffe nel codice condiviso, anche se Ruby non consente {}s nella maggior parte dei contesti.

Gli unici valori falsi in Ruby sono falseenil . In particolare, 0 è vero. Pertanto, Ruby stamperà "trucco".

Cosa vede C (dopo il pre-processore):

main(){puts(0?"trick":"treat");}

0 è falso in C, quindi C stamperà "tratta".

2 byte salvati grazie a daniero.

QBasic / JavaScript, 51 44 byte

'';PRINT=a=>{alert("Treat")}
PRINT("Trick")

In QBasic, stampa la seconda riga e non esegue la prima riga perché si ritiene che sia un commento (grazie '). In JS, chiama la funzione PRINT, che è definita sulla prima riga, subito dopo JS NOP '';.

ShapeScript / Foo , 13 byte

'trick'"treat

Provalo online! trucco | trattare

Come funziona

ShapeScript è analizzato carattere per carattere. Quando EOF viene colpito senza incontrare una quotazione di chiusura, nulla viene mai inserito nello stack.'trick'inserisce la stringa tra virgolette, che viene stampata implicitamente su STDOUT.

Foo non ha alcun comando assegnato ai personaggi 'trick', quindi quella parte viene silenziosamente ignorata. Tuttavia, stampa qualsiasi cosa tra virgolette doppie immediatamente su STDOUT, anche se manca la citazione di chiusura.

Ruby / Perl, 21 byte

print"trick"%1||treat

Perl

Calcola "trick" % 1che è 0 % 1quindi la ||invia treatal printinvece, poiché Perl accetta bareword.

Rubino

Formatta la stringa "trick"con l'argomento1 , che risulta "trick"veritiero, quindi ||non viene elaborato.

MATL / CJam , 17 byte

'TRICK'%];"TREAT"

In MATL questo produce TRICK . In CJam esso emette TREAT .

Spiegazione

MATL

'TRICK'         Push this string
%];"TREAT"      Comment: ignored
                Implicit display

CJam

'T              Push character 'T'
R               Push variable R, predefined to empty string
I               Push variable I, predefined to 18
C               Push variable C, predefined to 12
K               Push variable K, predefined to 20
'%              Push character '%'
]               Concatenate stack into an array
;               Discard
"TREAT"         Push this string
                Implicit display

Gelatina / pl , 12 byte

0000000: 74 72 65 61 74 0a 7f fe 00 ba 49 fb                 treat.....I.

Questo è il programma visualizzato usando la tabella codici di Jelly .

treatµ
“¡ṾI»

Provalo online!

Questo è il programma visualizzato usando la tabella codici 437 .

treat
⌂■␀║I√

Provalo online!

Entrambi i programmi sono stati testati localmente con lo stesso file a 12 byte, quindi questo è un poliglotta corretto.

Come funziona

In Jelly, ogni riga definisce un collegamento (funzione); l'ultima riga definisce il collegamento principale , che viene eseguito automaticamente all'avvio del programma. A meno che il codice prima dell'ultimo 7fbyte (l'avanzamento della riga nella codepage di Jelly) contenga un errore parser (che interromperebbe immediatamente l'esecuzione), vengono semplicemente ignorati. L'ultima riga, “¡ṾI»semplicemente indicizza nel dizionario di Jelly per recuperare il trucco delle parole , che viene stampato implicitamente alla fine del programma.

Non so molto su pl, ma sembra che l'interprete recuperi solo una riga di codice e ignori tutto ciò che viene dopo. Come in Perl, le parole nude vengono trattate come stringhe, quindi treatstampa esattamente quello.

Obiettivo-C / C, 50 byte

puts(){printf("trick");}main(){printf("treat\n");}

Objective-C ha ricevuto caramelle e stampe , ma C non le ha stampate .

Come funziona

Non so molto di Objective-C , ma fa quello che ci aspetteremmo ragionevolmente da questa situazione. La ridefinizione di putsnon influisce sull'output poiché non chiamiamo mai la funzione, e le mainstampe trattano e un avanzamento di riga su STDOUT.

Potresti aspettarti C faccia lo stesso, ma almeno gcc 4.8, gcc 5.3 e clang 3.7 no.

Poiché non abbiamo bisogno del vero printf (che accetta una stringa di formato e argomenti aggiuntivi) e la stringa da stampare termina con un avanzamento di riga, possiamo usare invece put . put è leggermente più veloce di printf (che deve analizzare i suoi argomenti prima di stampare), quindi a meno che non ridefiniamo anche la funzione printf , il compilatore ottimizza e sostituisce la chiamata a printf con una chiamata a put . Il compilatore non sa che invece chiamare putscon argomento "treat"stamperà il trucco !

Non includere stdio.h è cruciale qui, poiché la definizione di put richiederebbe l'utilizzo dello stesso tipo che ha nel file header ( puts(const char*)).

Infine, è interessante notare che la chiamata a printf in inserisce una stringa senza un avanzamento di riga finale. Altrimenti, il compilatore "ottimizzerebbe" anche quella chiamata, causando un errore di segmentazione.

Batch / sh, 30 byte

:;echo Treat;exit
@echo Trick

Spiegazione. Batch vede la prima riga come un'etichetta, che ignora, ed esegue la seconda riga, che stampa Trick. @ Sopprime l'eco predefinito di Batch del comando su stdout. (Le etichette non fanno mai eco.) Nel frattempo sh vede quanto segue:

:
echo Treat
exit
@echo Trick

La prima riga non fa nulla (è un alias di true), la seconda riga stampa Treat e la terza riga esce dallo script, quindi il Trucco @echo non viene mai raggiunto.

sed / Hexagony 32 byte

/$/ctrick
#$@$a</;r;e;/t;....\t;

sed

Provalo online!

La prima riga viene stampata trickse è presente una stringa vuota alla fine dell'input. (sed non fa nulla se non c'è input, ma in questo caso è consentita una riga vuota su stdin)

Esempio di esecuzione:

$ echo | sed -f TrickOrTreat.sed
trick

Hexagony

Provalo online!

Il primo /reindirizza il puntatore dell'istruzione verso l'alto e verso sinistra, quindi avvolge l'angolo in basso a sinistra, saltando il testo utilizzato per sed. Riutilizza r dal codice sed e ne esegue alcuni altri senza alcun effetto. L'esagono espanso è simile al seguente:

   / $ / c 
  t r i c k
 # $ @ $ a <
/ ; r ; e ; /
 t ; . . . . 
  \ t ; . .
   . . . .

Produzione:

treat

C # / Java

Questo probabilmente non si qualifica perché non funziona da solo, ma la sfida mi ha ricordato una stranezza nel modo in cui C # e Java gestiscono il confronto delle stringhe in modo diverso con cui ci si può divertire un po 'per l'offuscamento del codice.

La seguente funzione è valida in C # e Java, ma restituirà un valore diverso ...

public static String TrickOrTreat(){
    String m = "Oct";
    String d = "31";
    return m + d == "Oct31" ? "Trick" : "Treat";
}

Brain-Flak / Brain-Flueue, 265 253 219 165 139 115 113 101 byte

Include +1 per -A

Grazie a Wheat Wizard per andare avanti e indietro, giocando a golf a pochi byte dal codice degli altri, con me.

((((()()()))([]((({}{}))({}([((({}()())))]([](({}{}){}){}{})))[]))[])[()()])({}()()){}({})({}[][]){}

Brain-Flak: provalo online!
Brain-Flueue: provalo online!

Spiegazione:
La prima sezione elenca i valori che vede Brain-Flak.
Quando passa a Brain-Flueue, inizio a elencare i valori come li vedono Brain-Flueue.

# Brain-Flak
(
 (((()()()))             # Push 3 twice
  ([]                    # Use the height to evaluate to 2
   (
    (({}{}))             # Use both 3s to push 6 twice
    ({}                  # Use one of those 6s to evaluate to 6
     ([((({}()())))]     # Use the other 6 to push 8 three times and evaluate to -8
      ([](({}{}){}){}{}) # Use all three 8s to push 75
     )                   # The -8 makes this push 67
    )                    # The 6 makes this push 73
   [])                   # Use the height and the 6 to push 82
  )                      # Use the 2 to push 84

# Brain-flueue
 [])     # Use the height and 3 to push 84
[()()])  # Push 82
({}()()) # 67 is at the front of the queue, so use that to push 69
{}       # Pop one from the queue
({})     # 65 is next on the queue so move to the end
({}[][]) # 74 is next, so use that and the height to push 84
{}       # Pop that last value from TRICK

PowerShell / Foo, 14 byte

'trick'#"treat

In 'trick'PowerShell crea una stringa e la lascia sulla pipeline. Il #inizia un commento, in modo che il programma completa e le implicite Write-Outputstampe trick.

In Foo, (Provalo online!) , 'trick'Viene ignorato, #causa la sospensione del programma per 0secondi (poiché non c'è nulla sul puntatore dell'array), quindi "treatavvia una stringa. Poiché viene raggiunto EOF, è implicito "chiudere la stringa e questa viene stampata su stdout.

PHP / Perl, 28 byte

print defined&x?trick:treat;

defined&x
dà qualcosa di vero in PHP (non ho idea del perché, ma lo fa).
In Perl verifica se la funzione xè definita, il che non lo è.
-> trickin PHP, treatin Perl.