Desde que o Halloween está chegando, pensei em começar um divertido e desafiante desafio de golfe com código!

O desafio é bastante simples. Você precisa escrever um programa que produza trickou treat.
"A torção?" você pode perguntar. Bem, deixe-me explicar:

Seu programa precisa fazer o seguinte:

• Seja compilável / executável em dois idiomas diferentes. Versões diferentes do mesmo idioma não contam.
• Quando você executa o programa em um idioma, ele deve ser exibido tricke o outro deve ser exibido treat. O caso é irrelevante e o preenchimento da string com caracteres de espaço em branco é permitido (veja exemplos).
• Isso é código-golfe , então a solução com o menor número de bytes vence.

Algumas explicações:

Saídas válidas (apenas para as palavras que não são para executar o código nos dois idiomas. Também adicionando aspas para sinalizar o início ou o final da saída. Não as inclua na sua solução!):

"trick"

"Treat"

"    TReAt"

"
     tRICk          "

Saídas inválidas :

"tri ck"

"tr
eat"

"trck"

Estou interessado em ver o que você pode criar! Golfe feliz!

Gostaria de observar que este é o meu primeiro desafio, portanto, se você tiver sugestões sobre essa questão, deixe-as na forma de um comentário.

Classificação

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

# [><>](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 bytes

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

Ambos os programas foram testados localmente com o mesmo arquivo de 8 bytes, portanto, este é um poliglota adequado.

2sable: truque

Este é o programa na página de código 1252 .

treat“ÐË

Experimente online!

pl: tratar

Este é o programa na página de código 437 .

treatô╨╦

Experimente online!

Como funciona

2sable: truque

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: tratar

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

Lote Python / Windows, 25 bytes

print"trick"#||echo.treat

Tudo depois do # é interpretado como um comentário por python, enquanto o || é um OR em lote, dizendo que, como o comando anterior falhou, execute este.

Eu também gosto do uso de uma sala de cirurgia, pois quase lê "gostosuras ou travessuras" :)

Espaço em branco / estrelado, 135 bytes

Aqui está um céu noturno claro no Halloween!

  + + + + + 
    +

* + + * + *

   + *           
     + +        

 + * +   



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

Observe que o espaço em branco nas linhas vazias pode não ser preservado se você copiar do código acima

O espaço em branco gera "TRICK". Experimente Online!
Saídas estreladas "TRATAR". Experimente Online!

Explicação

Estrelado

Estrelado ignora todas as guias e novas linhas, de modo que o código que lê é o seguinte

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

Por outro lado, enviar valores é muito caro comparado às operações de empilhamento e aritmética no Starry. O código começa pressionando e duplicando 4 e executa várias operações nele, e com 2 e 1 pressionados posteriormente produz todos os valores ASCII necessários.

Código anotado

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)

Espaço em branco

Como o nome pode sugerir, o espaço em branco analisa apenas os três caracteres de espaço em branco - espaço, tabulação e nova linha. Ao contrário do estrelado, o espaço em branco simplesmente empurra os valores ASCII de T, R, I, C, e Ke as impressões deles.

Código anotado

<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>

O entrelaçamento de pushes e impressões foi escolhido com base apenas em razões estéticas, pois não afeta a contagem de bytes.

Arquivo Linux ELF x86 / DOS .COM, 73 bytes

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

Isso usa o fato de que o cabeçalho ELF começa com 7F 45, que, interpretado como código x86, é um salto.

As partes relevantes para o 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$

mal / ZOMBI , 109 bytes

Outra resposta assustadora!

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

O ZOMBIEcódigo define um vampirenome xfcuja única tarefa fé ativada na instanciação e será exibida trickuma vez antes de ser desativada stumble. A outra saychamada é código morto (como apropriado!) Para ZOMBIE, mas contém a maior parte do evilcódigo.

Pois evil, o xfnome é uma chamada para pular para o próximo j, que precede o zuueeueeawuuwzaeeaeeaeawuuuuwzuueeueeawgemido de zumbi que é produzido e produzido treat. O código a seguir é executado (letras minúsculas) ou ignorado, mas como não whá saída, deve ser produzido.

Python / Perl, 28 bytes

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

Explicação

Como []é um ArrayRef em Perl, é verdade, mas é um array vazio em Python, portanto falso.

PHP / JavaScript, 32 30 bytes

Exibe trickem PHP e treatem JS.

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

A NaNconstante desconhecida é implicitamente convertida em uma string pelo PHP, tornando-a verdadeira. É falso em JS.

Método alternativo, 38 bytes

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

O operador ternário é associativo à direita no JS:

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

E associativo à esquerda em PHP:

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

HTML / HTML + JavaScript, 53 bytes

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

treaté o conteúdo de texto do documento em HTML.
Se o JS estiver ativado, ele substituirá o conteúdo HTML por trick.

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

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

// \ faz com que a próxima linha também faça um comentário em C, mas é um comentário comum de uma linha em Java, para que você possa fazer com que C ignore o código destinado a Java e, adicionando / * na segunda linha, faça um comentário para Java que seja analisado como código por C.

Edit: Eu melhorei um pouco reorganizando as linhas e comentários.

Edit2: Eu fiz um pouco mais de reorganização e reduzi ainda mais.

Edit3: Eu adicionei correções sugeridas pelo BrainStone para remover 5 bytes, obrigado :)

Edit4: Uma nova linha acabou por ser desnecessária, então eu a removi.

Edit5: Eu mudei printf para puts.

Edit6: Eu adicionei uma correção sugerida por Ray Hamel.

Jolf + Chaîne, 12 bytes

Como Chaîne não pode aceitar um arquivo para carregar com uma codificação, eu assumo UTF-8. (Se eu pudesse assumir a ISO-8859-7, isso seria 11 bytes, mas isso seria injusto.)

trick«treat

Em Chaîne, «começa um comentário e o restante é impresso literalmente. Em Jolf, «começa uma string. Felizmente, tricknão faz nada prejudicial ( 10; range(input, parseInt(input))basicamente) e treaté impresso.

Tente Jolf aqui!

Tente Chaîne aqui!

Ambos funcionam no meu navegador (firefox, versão mais recente), mas o mesmo não pode ser dito para outros navegadores.

#hell / Agonia , 43 bytes

Tanta coisa em ><>todo lugar, o que é isso, um desafio para os enganados? Aqui está uma resposta com idiomas com temas apropriados.

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

#hellé um subconjunto do LUAqual felizmente aceita io.writechamadas de saída. Usamos LUAos --comentários para que ele execute apenas este fragmento.

Agonyé um Brainfuckderivado, que tem a particularidade de ter seu código e memória de trabalho na mesma fita. A primeira linha imprime apenas 5 caracteres (10 células) no final do segmento de código, onde codifiquei treatcomo Agonycomandos. LUAA abertura do comentário --modifica o valor de uma célula que não é usada.

Cubix / Hexagony , 31 bytes

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

Engane-o! Trate-o online!

Temático de Halloween ? Observe os fatos terríveis sobre esses idiomas e o código:

1. Se e mesmo se você não fizer nada (basta colocar no-ops), você nunca poderá sair do loop que está determinado a funcionar para sempre ...
2. E estar preso no meio de uma linguagem de programação 3D e 2D (Oh agonia ...)
3. Dentro das dimensões, você gradualmente se perde onde está ... onde estava ...
4. E há um =v=sorriso para você que atua no no-ops no código

Vamos nos aprofundar no mistério do protocolo de comunicação oculto de 31 bytes de dimensões e terror ...

truque

Quando o código se dobra ou se desdobra ... Ou seja cubified, o layout fica assim:

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

E a parte principal é essa parte no meio:

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

Empurra k,c,i,r,tpara a pilha e ogera e ;aparece dentro de um loop delimitado por refletores e ?que o guia dependendo do valor no topo da pilha ...

tratar

De repente, o código se transforma de um cubo em um hexágono. (Imagine isso)

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

E a parte principal é esta parte:

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

Ele executa o t;que imprime te atinge o espelho e vira sua direção para NW a partir do canto SE e atinge outro espelho. Este é executado r;e passará para e;_aea ]traz para o ponteiro de instrução 1 que começa no NE esquina apontando SE e sucessos /que reflete horizontalmente para ;depois t.

Em seguida, ele passará para =, ;e @termina a confusão.

Então ... O que está _fazendo lá?

Por que está dentro das t e a(as 3 primeiras letras do código)?

Aí vem o fim da história -

isso não faz nada .

Parece o fim de uma história de terror?

SQL / Javascript, 54 bytes

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

A mesma abordagem da minha resposta QB / JS : a primeira linha possui a instrução SQL, a segunda linha possui um 'comentário' para SQL e um NOP para JS. Em seguida, definimos a selectinstrução do SQL como uma função JS válida.

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

Essa resposta requer que a -Aflag seja exibida em ASCII para Brain-Flak e, felizmente, Brainfuck não se importa com essa flag, portanto não afeta a saída em Brainfuck.

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

Experimente Online!

Experimente Online!

Como isso funciona

A única sobreposição entre a sintaxe de Brain-Flak e Brainfuck são os personagens <>[]. Para ataques cerebrais, isso significa principalmente que o programa precisa garantir um número par de comutadores de pilha <>. E para Brainfuck isso significa que precisamos evitar infinitos loops causados ​​pelo uso da []mônada.

O código Brain-Flak é o seguinte:

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

Além da parte [<<...>>]do meio e do <[<>]<>[<>]<>>final, esse código é bastante parecido no que diz respeito aos programas Brain-Flak. O negativo em torno do zero ( [<...>]) existe para criar um loop para o Brainfuck. O interior <...>é usado para mover o Brainfuck para uma célula vazia antes de encontrar o [][][][]que seria repetidamente infinito.

O código Brainfuck é o seguinte:

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

Além dos bits mencionados acima, este também é um programa bastante padrão, portanto, pouparei os detalhes.

> <> / Pesca , 38 bytes

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

Para fazer um ><>/ Fishingpolyglot.

É o meu primeiro pedaço de Fishingcódigo depois de jogar por um longo tempo ><>.
Minha primeira impressão: como na natureza, o pescador tem menos capacidade física do que reza, mas a compensa com sua ferramenta!

Aqui o código é extremamente simples: ><>só executará a primeira linha, onde _é um espelho vertical e não tem efeito, já que o peixe começa a nadar na horizontal. Apenas empurra tricka pilha e imprime-a antes de parar.
Pois Fishing, o _instrui a descer. O pescador seguirá o convés que é a segunda linha enquanto captura os caracteres da terceira linha. Eles pressionam treata fita e a imprimem, parando quando atingem o final do baralho.

Se o erro for permitido, você poderá descer para 35 bytes com o código a seguir, que emitirá um erro quando executado como ><>uma vez trickimpresso na pilha:

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

Você também deve verificar minhas respostas em idiomas temáticos, #hell / Agony and evil / ZOMBIE !

05AB1E / Na verdade , 10 bytes

"trick"’®Â

Explicação

05AB1E

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

Experimente online

Na realidade

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

Experimente online

Haskell / ML padrão , 56 bytes

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

Visualização Haskell

Os pontos-e-vírgulas permitem várias declarações em uma linha e agem como quebras de linha.

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

Um programa Haskell é executado chamando a mainfunção, portanto, na última linha putStr"trick"é executada que apenas imprime trick.
As duas primeiras linhas são interpretadas como declarações de função seguindo o padrão <functionName> <argumentName1> ... <argumentNameN> = <functionBody>. Portanto, na primeira linha, funé declarada uma função nomeada, que recebe dois argumentos nomeados putStre xe o corpo da função print"treat". Essa é uma função Haskell válida com tipo fun :: t -> t1 -> IO (), o que significa que é necessário um argumento de um tipo arbitrário te um segundo de algum tipo t1e, em seguida, retorna uma ação de IO. Os tipos te t1não importam, pois os argumentos não são usados ​​no corpo da função. O tipo de ação de IO resulta de print"treat", que imprime "treat"no StdOut (observe o ", é por isso queputStrem vez de printé usado em main). No entanto, como é apenas uma declaração de função, nada é realmente impresso como funnão é chamado main.
O mesmo acontece na segunda linha val main=();, valé declarada uma função que recebe um argumento arbitrário chamado maine retorna a unidade , a tupla vazia (). Seu tipo é val :: t -> ()(tanto o valor quanto o tipo de unidade são indicados ()).

Experimente em Ideone.

Visualização ML padrão

ML padrão é uma linguagem principalmente funcional com uma sintaxe relacionada a, mas não a mesma que Haskell. Em particular, as declarações de função são prefixadas com a palavra-chave funse eles aceitarem algum argumento e a palavra- chave se não aceitarem val. Também é possível ter uma expressão no nível superior (significando que não está em nenhuma declaração) que é executada quando o programa é executado. (Em Haskell, escrever 1+2fora de uma declaração gera um naked expression at top levelerro). Finalmente, o símbolo para testar a igualdade está no =lugar de ==Haskell. (Existem muitas outras diferenças, mas essas são as únicas que importam para este programa.)
Portanto, o SML vê duas declarações

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

seguido por uma expressão

main=putStr"trick"

que é então avaliado. Para determinar se mainiguais putStr"trick", ambos os lados devem ser avaliados e ambos devem ter o mesmo tipo, pois SML (assim como Haskell) é estaticamente tipado. Vamos primeiro dar uma olhada no lado direito: putStrnão é uma função de biblioteca no SML, mas declaramos uma função nomeada putStrna linha fun putStr x=print"treat";- ela recebe um argumento x(esta é a string "trick"no nosso caso) e a esquece imediatamente novamente, pois não ocorre no corpo da função. Em seguida, print"treat"é executado o corpo que imprime treat(sem anexar ", os SMLs printsão diferentes dos de Haskell print).
printtem o tipo string -> unit, então putStrtem o tipo a -> unite, portanto, putStr"trick"tem apenas o tipounit. Para ser bem digitado, também maindeve ter o tipo unit. O valor da unidade é no SML o mesmo que no Haskell (), por isso declaramos val main=();e tudo está bem digitado.

Experimente no codingground.
Nota: A saída no console é

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

porque em SML \ NJ, o valor e o tipo de cada instrução são exibidos após cada declaração. Então, primeiro os tipos putStre mainsão mostrados, depois as expressões são avaliadas fazendo treatcom que sejam impressas, então o valor da expressão ( truecomo ambos os lados =são ()) é vinculado à variável implícita do resultado itque também é exibida.

Ruby / C, 64 62 51 48 bytes

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

O que Ruby vê:

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

O tapmétodo pega um bloco e o executa uma vez. É um identificador curto para o qual podemos criar uma #definemacro em C. Ele também nos permite colocar um bloco entre chaves no código compartilhado, mesmo que Ruby não permita {}s na maioria dos contextos.

Os únicos valores falsos em Ruby são falsee nil. Em particular, 0 é verdade. Assim, Ruby imprimirá "truque".

O que C vê (depois do pré-processador):

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

0 é falso em C, então C imprimirá "tratar".

2 bytes salvos graças a daniero.

QBasic / JavaScript, 51 44 bytes

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

No QBasic, ele imprime a segunda linha e não executa a primeira porque acredita-se ser um comentário (obrigado). No JS, ele chama a função PRINT, que é definida na primeira linha, logo após o JS NOP '';.

ShapeScript / Foo , 13 bytes

'trick'"treat

Experimente online! truque | tratar

Como funciona

O ShapeScript é analisado caractere por caractere. Quando o EOF é atingido sem encontrar uma cotação de fechamento, nada é empurrado na pilha. 'trick'empurra a string dentro das aspas, que é impressa em STDOUT implicitamente.

Foo não possui nenhum comando atribuído aos caracteres 'trick', portanto essa parte é ignorada silenciosamente. No entanto, imprime qualquer coisa entre aspas duplas imediatamente para STDOUT, mesmo se a cotação de fechamento estiver ausente.

Ruby / Perl, 21 bytes

print"trick"%1||treat

Perl

Calcula "trick" % 1qual é0 % 1 assim que o ||envia treatao printinvés, já que Perl aceita barewords.

Rubi

Formata a string "trick"com o argumento 1, o que resulta em "trick"que é verdade, para que ||não seja processado.

MATL / CJam , 17 bytes

'TRICK'%];"TREAT"

Em MATL isso gera TRICK . No CJam, ele gera TREAT .

Explicação

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 bytes

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

Este é o programa exibido na página de códigos de Jelly .

treatµ
“¡ṾI»

Experimente online!

Este é o programa exibido na página de códigos 437 .

treat
⌂■␀║I√

Experimente online!

Ambos os programas foram testados localmente com o mesmo arquivo de 12 bytes, portanto, este é um poliglota adequado.

Como funciona

No Jelly, toda linha define um link (função); a última linha define o link principal , que é executado automaticamente quando o programa é executado. A menos que o código antes do último 7fbyte (o avanço de linha na página de códigos do Jelly) contenha um erro do analisador (que interromperia a execução imediatamente), eles são simplesmente ignorados. A última linha, “¡ṾI»simplesmente indexa no dicionário de Jelly para buscar a palavra truque , que é impressa implicitamente no final do programa.

Não sei muito sobre pl, mas parece que o intérprete busca apenas uma linha de código e ignora tudo o que vem depois dela. Como no Perl, as palavras de bar são tratadas como seqüências de caracteres, então treatimprime exatamente isso.

Objective-C / C, 50 bytes

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

Objective-C tem doces e estampas deliciosas , mas C não gosta e estampas .

Como funciona

Não sei muito sobre o Objective-C , mas faz o que esperávamos razoavelmente nessa situação. A redefinição de putsnão afeta a saída, pois nunca chamamos a função e as mainimpressões tratam e um avanço de linha para STDOUT.

Você pode esperar C faça o mesmo, mas pelo menos o gcc 4.8, o gcc 5.3 e o clang 3.7 não.

Como não precisamos do printf real (que recebe uma sequência de caracteres de formato e argumentos adicionais) e a sequência a ser impressa termina com um avanço de linha, podemos usar put em vez disso. put é um pouco mais rápido que printf (que precisa analisar seus argumentos antes de imprimir), portanto, a menos que redefinamos a função printf , o compilador otimiza e substitui a chamada para printf por uma chamada para put . Mal sabe o compilador que chamar com argumento irá imprimir truques !puts"treat"

Não incluir stdio.h é crucial aqui, pois a definição de putaria exigiria o mesmo tipo de arquivo no cabeçalho (puts(const char*) ).

Finalmente, é de salientar que a chamada para printf em puts passa uma corda sem um avanço de linha final. Caso contrário, o compilador "otimizará" essa chamada também, resultando em uma falha de segmentação.

Lote / sh, 30 bytes

:;echo Treat;exit
@echo Trick

Explicação. O lote vê a primeira linha como um rótulo, que ele ignora, e executa a segunda linha, que imprime Truque. O @ suprime o eco padrão do lote do comando para stdout. (As etiquetas nunca ecoam.) Enquanto isso, sh vê o seguinte:

:
echo Treat
exit
@echo Trick

A primeira linha não faz nada (é um apelido de true), a segunda linha imprime Treat e a terceira linha sai do script, para que o @echo Trick nunca seja alcançado.

sed / Hexagony 32 bytes

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

sed

Experimente Online!

A primeira linha imprime trick se houver uma sequência vazia no final da entrada. (sed não faz nada se não houver entrada, mas uma linha em branco no stdin é permitida neste caso)

Exemplo de execução:

$ echo | sed -f TrickOrTreat.sed
trick

Hexagonia

Experimente Online!

O primeiro /redireciona o ponteiro de instruções para cima e para a esquerda, de modo que envolve o canto inferior esquerdo, pulando o texto usado para sed. Ele reutiliza or do código sed e executa alguns outros sem nenhum efeito. O hex expandido é assim:

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

Resultado:

treat

C # / Java

Isso provavelmente não se qualifica, pois não é executado por conta própria, mas o desafio me lembrou uma peculiaridade de como C # e Java lidam com a comparação de strings de maneira diferente com a qual você pode se divertir com a ofuscação do código.

A função a seguir é válida em C # e Java, mas retornará um valor diferente ...

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

Brain-Flak / Brain-Flueue, 265253 219 165 139 115 113 101 bytes

Inclui +1 para -A

Agradeço ao Wheat Wizard por ir e voltar, jogando alguns bytes do código um do outro comigo.

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

Brain-Flak: Experimente online!
Brain-Flueue: Experimente online!

Explicação:
A primeira seção lista os valores que o Brain-Flak vê.
Quando muda para o Brain-Flueue, começo a listar os valores como o Brain-Flueue os vê.

# 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 bytes

'trick'#"treat

O 'trick'PowerShell cria uma string e a deixa no pipeline. Ele #inicia um comentário, para que o programa seja concluído e as Write-Outputimpressões implícitastrick .

Em Foo, (Experimente Online!) , O 'trick'é ignorado, #faz com que o programa durma por 0segundos (já que não há nada no ponteiro da matriz) e "treatinicia uma sequência. Desde que o EOF é alcançado, há um implícito "para fechar a sequência, e isso é impresso em stdout.

PHP / Perl, 28 bytes

print defined&x?trick:treat;

defined&x
dá algo verdadeiro em PHP (não faço ideia do porquê, mas faz).
No Perl, verifica se a função xestá definida - o que não é.
-> trickem PHP, treatem Perl.