Desafio

Codifique um cookie ASCII de um tipo de acordo com a entrada.

Entrada

• O tipo de biscoito. Essa é uma das três seqüências de caracteres: "Simples", "Chocolate" ou "Nozes". Podem ser argumentos de função, stdin (ou equivalente mais próximo) ou argumentos de arquivo.

Resultado

• Um cookie ASCII. Ver abaixo.

Devemos ser

     ___
    /   \
    |   |
    \___/

para entrada simples,

     ___
    /. .\
    | . |
    \___/

para entrada de chocolate e, finalmente,

     ___
    /^  \
    |^ ^|
    \___/

para entrada de porca.

Outra informação

• Este é o meu primeiro desafio, é o mais simples possível. O feedback construtivo é muito apreciado.
• Use qualquer meio para fazê-lo.
• Espaços à direita são bons.
• Este é um desafio de código de golfe, pelo que a entrada mais curta no final de 9 dias (quarta-feira, 12 de agosto de 2015) vence.

Obrigado!

O vencedor é Jakube usando Pyth com 41 bytes. Obrigado a todos que participaram. Agora me encarregarei de apresentar desafios mais complicados.

Pitão, 42 41 bytes

X" ___
/d a\\
|cac|
\___/"G.>"^X .  .^"Cz

Experimente on-line: Conjunto regular de entrada / teste

Explicação:

 "..."                      template string
X     G                     replace "a..z" in ^ with:
                   Cz         convert z to an integer (base 256 of ord(char))
       .>"^X .  .^"           rotate "^X .  .^"
                              ["Plain"     -> " .  .^^X", 
                               "Chocolate" -> ".  .^^X ", 
                               "Nuts"      -> " .^^X . "]

Ruby, 73

->s{' ___
/'+['^  \
|^ ^','. .\
| . ','   \
|   '][s[0].ord%3]+'|
\___/'}

Esta é uma função lambda anônima. Aqui está em um programa de teste:

g=->s{' ___
/'+['^  \
|^ ^','. .\
| . ','   \
|   '][s[0].ord%3]+'|
\___/'}

puts g.call(gets)

Ele apenas usa a primeira letra do tipo de cookie (em maiúsculas) e leva o módulo 3 para obter um índice no intervalo 0..2. Em seguida, ele retorna a cadeia que representa o cookie, com as cadeias apropriadas incorporadas nos lugares certos.

Python 2.7.6, 99 bytes

def c(t):n=hash(t)%3;return" ___\n/"+" ^."[n]+" "+"  ."[n]+"\\\n|"+[" ","^ ^"," . "][n]+"|\n\\___/"

Esse algoritmo baseia-se no fato de hash(cookie)%3fornecer 0 quando cookie = "Plain", 1 quando cookie = "Nute 2 quando cookie = "Chocolate. Se alguém souber como diminuir esse código, informe-me nos comentários.

C: 122

q(char *p){char *t,*m;int i=*p%3;t=i?i%2?". .":"   ":"^  ";m=i?i%2?" . ":"   ":"^ ^";printf(" ___\n/%s\\ \n|%s|\n\\___/",t,m);}

Explicação depois de terminar o golfe.

Exemplo de uso:

 int main(void){
 q("Plain");
 printf("\n");
 q("Nut");
 printf("\n"); 
 q("Chocolate");
 }

CJam, 49 48 bytes

" ___
/""^  ^ ^. . ."S7*+6/rci=3/"\
|"*"|
\___/"

Experimente online no intérprete CJam .

Como funciona

" ___
/"

e# Push that string.

"^  ^ ^. . ."S7*+6/

e# Push that string, append 7 spaces and split into chunks of length 6.
e# This pushes ["^  ^ ^" ". . . " "      "].

rci

e# Read from STDIN, cast to character, then to integer.
e# "Plain", "Chocolate", "Nuts" -> 'P', 'C', 'N' -> 80, 67, 78

=

e# Select the corresponding element from the array.
e# Arrays wrap around in CJam, so for an array A of length 3,
e# A80= is A2=, A67= is A1= and A78= is A0=.

3/

e# Split into chunks of length 3.

"\
|"*

e# Join those chunks, using that string as separator.

"|
\___/"

e# Push that string.

No final, o CJam imprime automaticamente todos os elementos na pilha.

Javascript (ES6), 90

s=>" ___\n/"+(s.length-4?s.length-5?". .\\\n| . ":"   \\\n|   ":"^  \\\n|^ ^")+"|\n\\___/"

Esta é uma função de seta anônima. Ele usa o comprimento da entrada para determinar qual cookie desenhar.

Explicação:

s=>
 " ___\n/" +               //build the first part of the cookie

 (s.length - 4 ?           //if the length is 4, this condition will evaluate to 0, which coerces to false. Otherwise it is true

      s.length - 5 ?            //if the length is 5, this evaluates to false; otherwise true

           ". .\\\n| . " :      //build the unique part of the Chocolate cookie, if length was not 5
           "   \\\n|   "        //build the unique part of the Plain cookie, if length was 5

      : "^  \\\n|^ ^"      //build the unique part of the Nuts cookie, if length was 4
 )

 + "|\n\\___/"             //build the last part of the cookie, and implicitly return the built string

Testar:

f=s=>" ___\n/"+(s.length-4?s.length-5?". .\\\n| . ":"   \\\n|   ":"^  \\\n|^ ^")+"|\n\\___/"

console.log(f("Nuts"))
console.log(f("Plain"))
console.log(f("Chocolate"))

BrainFuck, 481 447 436 bytes

Por que não o BrainFuck ?, o programa provavelmente pode ser mais jogado, mas acho que é bem legal.

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

C # Com recuo e quebra de linha

using System;
class Cookie
{
    static void Main()
    {
      String E="",N="",C=Console.ReadLine();
      if(C=="P"){E="   ";N="   ";}
      if(C=="C"){E=". .";N=" . ";}
      if(C=="N"){E="^  ";N="^ ^";}
      Console.Write(" ___ \n/" + E + "\\ \n|" + N + "|\n\\___/");
    }
}

Golfe (225 caracteres)

using System;class X{static void Main(){String E="",N="",C=Console.ReadLine();if(C=="P"){E="   ";N="   ";}if(C=="C"){E=". .";N=" . ";}if(C=="N"){E="^  ";N="^ ^";}Console.Write(" ___ \n/" + E + "\\ \n|" + N + "|\n\\___/");}}[![enter image description here][1]][1]

C # 6, 105 bytes

Então, quase consegui esses sub-100 bytes, mas não faço ideia de onde extrair os últimos bytes: C

string C(string t)=>$" ___\n/{(t[0]=='C'?". .\\\n| . ":t[0]=='N'?"^  \\\n|^ ^":"   \\\n|   ")}|\n\\___/";

Pitão, 58 54 53 52 50 bytes

+d*\_3p+\/j"\\
|"c@["^  ^ ^"*". "3*d6)Chz3\|"\___/

Eu não acho que isso possa ser jogado mais. Eu estava realmente tentando colocar isso em menos de 50 bytes

JavaScript (ES6), 72 bytes

Tão simples quanto possível ... novas linhas são contadas como 1 byte cada.

f=s=>` ___
/${s[4]?s[5]?`. .\\
| . `:`   \\
|   `:`^  \\
|^ ^`}|
\\___/`

Demo

Como é o ES6, esta demonstração só funciona no Firefox e Safari por enquanto.

f=s=>` ___
/${s[4]?s[5]?`. .\\
| . `:`   \\
|   `:`^  \\
|^ ^`}|
\\___/`

// Snippet stuff

A.innerHTML = f("Nuts");
B.innerHTML = f("Plain");
C.innerHTML = f("Chocolate");

<p>Nuts</p>
<pre id=A></pre>

<p>Plain</p>
<pre id=B></pre>

<p>Chocolate</p>
<pre id=C></pre>

Commodore 64 BASIC, 181 bytes

10 INPUT A$
20 IF A$="PLAIN" THEN B$="/   \":C$="|   |"
30 IF A$="CHOCOLATE" THEN B$="/. .\":C$="| . |"
40 IF A$="NUTS" THEN C$="/^  \":C$="|^ ^|"
50 PRINT" ___":PRINT B$:PRINT C$:PRINT"\___/"

Notas:

Em vez de barras invertidas, \os caracteres SHIFT-M foram usados, para barras /- SHIFT-N e para tubos |- SHIFT-T. Foi utilizado o SHIFT-Z (sinal de losango do cartão) ^. De fato, os caracteres não importam, pois todos ocupam um byte cada.

Como no C64, cada comando (PRINT, INPUT, THEN, etc.) ocupa 2 bytes na memória (ou até mesmo um IIRC), vale a pena tentar o idioma BASIC (no entanto, foram necessários mais bytes do que eu esperava).

O tamanho do programa foi calculado medindo a memória livre antes de digitar o programa (38909 bytes) e depois (38728 bytes), usando o PRINT FRE(0)+65536comando, fornecendo 181 bytes de diferença.

Código testado e capturas de tela preparadas com esta ferramenta: http://codeazur.com.br/stuff/fc64_final/ (GPL).

Imagens:

Lua 5.3, 113 bytes 112 bytes

c=io.read()print(' ___\n/'..(c=='plain'and'   \\\n|   'or c=='nut'and'^  \\\n|^ ^'or'. .\\\n| . ')..'|\n\\___/')

Ele usa grande parte do operador ternário e da concatenação de strings, e eu espremi todo o espaço em branco que não faz parte da saída em si.

Java 258 217 caracteres / bytes

class C{public static void main(String[] a){p(" ___");if(a[0].equals("Chocolate")) {p("/. .\\");p("| . |");}if(a[0].equals("Nut")){p("/^  \\");p("|^ ^|");}p("\\___/");}static void p(String s) {System.out.println(s);}}

Original

class C {
    public static void main(String[] a) {
        p(" ___");
        if(a[0].equals("Chocolate")) {
            p("/. .\\");
            p("| . |");
        }
        if(a[0].equals("Nut")){
            p("/^  \\");
            p("|^ ^|");
        }
        p("\\___/");
    }
    static void p(String s) {
        System.out.println(s);
    }
}

LUA 270 caracteres 270 bytes

    c = io.read()
    if c == "plain" then
    print" ___"
    print"/   \\"
    print"|   |"
    print"\\___/"
    io.read()
    elseif c == "chocolate" then
    print" ___"
    print"/. .\\"
    print"| . |"
    print"\\___/"
    io.read()
    elseif c == "nut" then
    print" ___"
    print"/^  \\"
    print"|^ ^|"
    print"\\___/"
    end

LOLCODE 265 caracteres

HAI
I HAS A T
GIMMEH T
VISIBLE " ___"
BOTH SAEM T AN "Chocolate", O RLY?
YA RLY
VISIBLE "/. .\"
VISIBLE "| . |"
OIC
BOTH SAEM T AN "Nut", O RLY?
YA RLY
VISIBLE "/^ ^\"
VISIBLE "|^  |"
OIC
BOTH SAEM T AN "Plain", O RLY?
YA RLY
VISIBLE "/   \"
VISIBLE "|   |"
OIC
VISIBLE "\___/"
KTHXBYE

Run