23

Aqui está um biscoito salgado ASCII :

 _________________
|  .     .     .  |
|     .     .     |
|  .     .     .  |
|     .     .     |
|  .     .     .  |
|_________________|

Aqui estão dois biscoitos empilhados:

 _________________
|  .     .     .  |
|     . __________|______
|  .   |  .     .     .  |
|     .|     .     .     |
|  .   |  .     .     .  |
|______|     .     .     |
       |  .     .     .  |
       |_________________|

Escreva o programa mais curto possível, que use um número inteiro positivo e desenhe uma pilha desses muitos crackers de solução salina ASCII.

A entrada pode vir de stdin, linha de comando ou você pode simplesmente escrever uma função. A entrada sempre será válida. A saída deve ir para stdout ou alternativa mais próxima.

Cada cracker empilhado é sempre deslocado 2 caracteres para baixo e 7 caracteres à direita do cracker abaixo dele. Não deve haver espaços à direita ou novas linhas estranhas.

O programa mais curto em bytes vence.

Exemplos

Se a entrada é 1a saída é

 _________________
|  .     .     .  |
|     .     .     |
|  .     .     .  |
|     .     .     |
|  .     .     .  |
|_________________|

Se a entrada é 2a saída é

 _________________
|  .     .     .  |
|     . __________|______
|  .   |  .     .     .  |
|     .|     .     .     |
|  .   |  .     .     .  |
|______|     .     .     |
       |  .     .     .  |
       |_________________|

Se a entrada é 3a saída é

 _________________
|  .     .     .  |
|     . __________|______
|  .   |  .     .     .  |
|     .|     . __________|______
|  .   |  .   |  .     .     .  |
|______|     .|     .     .     |
       |  .   |  .     .     .  |
       |______|     .     .     |
              |  .     .     .  |
              |_________________|

E assim por diante.

o verdadeiro desafio salino

code-golf ascii-art kolmogorov-complexity

— Passatempos de Calvin
fonte

1

Como o contorno do cracker abaixo substitui o contorno do acima?

— haskeller orgulhoso

1

@ Calvin'sHobbies: Acho que ele está questionando por que a borda superior dos biscoitos empilhados está em ___|___vez de _______. Eu estou supondo que ficaria estranho se fosse o último

— Claudiu

2

@Claudiu Oh. Sim, não é perfeito, mas parece mais estranho para o outro lado.

— Hobbies de Calvin

6

@ Calvin'sHobbies Na verdade, acho que esse personagem é a parte mais interessante desse desafio. ^^

— Martin Ender

3

Passar 0 deve ser falhado.

— Naftuli Kay

4

CJam, 140 125 119 116 bytes

li__7*C+S*a\2*5+*\{5m>S'|6*+_" ."5*5/{'__@\++}:U%3*0@t{S5*U_}%\a+zsB'|tJ/{\(J>@\+a+}/{7m<}%}*{Cm<0{;)_' =}g+}%N*B'_t

Experimente online.

Uma única solução salina

O trecho de código

S'|6*+_      " Push ' ||||||' twice.                                                      ";
" ."5*5/     " Push [' . . ' '. . .'].                                                    ";
{'__@\++}:U% " Prepend and append an underscore to each string in the previous array.     ";
3*           " Repeat the resulting array thrice.                                         ";
0@t          " Replace its first element with ' ||||||'.                                  ";
{S5*U_}%     " Insert '_     _' after each element of the array.                          ";
\a+          " Append ' ||||||' to the array.                                             ";
z            " Zip; transpose rows with columns.                                          ";
sB'\t        " Flatten the array of strings and replace the 12th element with a '|'.      ";
19/          " Split into chunks of length 19.                                            ";

deixa o seguinte na pilha:

[
  " __________|______ "
  "|  .     .     .  |"
  "|     .     .     |"
  "|  .     .     .  |"
  "|     .     .     |"
  "|  .     .     .  |"
  "|_________________|"
]

Salgadinhos empilhados

Suponha que a solução salina de cima seja salva em Z.

li               " I := int(input())                                                      ";
__7*C+S*a\2*5+*  " R:= [(I * 7 + 12) * ' '] * (I * 2 + 5)                                 ";
\{               " Repeat I times:                                                        ";
  5m>            "   R := R[-5:] + R[:-5]                                                 ";
  Z              "   Push a single saltine, as an array of lines.                         ";
  {              "   For each line L of the saltine:                                      ";
    \(J>@\+a+    "     R := R[1:] + [R[0][19:] +     L]                                   ";
  }/             "                                                                        ";
  {7m<}%         "   R := [ L[7:] + L[:7] : L in R ]                                      ";
}*               "                                                                        ";
{                " R := [                                                                 ";
  Cm<            "   (L[12:] + L[:12])                                                    ";
  0{;)_' =}g+    "                    .rstrip()                                           ";
}%               " : L in R ]                                                             ";
N*               " R := '\n'.join(R)                                                      ";
B'_t             " R[11] := '|'                                                           ";

— Dennis
fonte

11

JavaScript (E6) 24925928930345

~~Não é tão confiante sobre a compressão das cordas.~~ Encontrou uma boa compressão para as cordas. ~~O caso simples de 1 cracker parece difícil de gerenciar. Pode haver uma maneira melhor ...~~

F=n=>{
  for(B=",|4.,|1.2,|1.4.4.1|,|5,|4.4.4|, 9|5, 87 ,|87|".replace(/\d/g,c=>' _'[c>4|0][R='repeat'](-~c)).split(','),
  O=(c,b=0,a=0)=>console.log(' '[R](y)+B[a]+B[b][R](x)+B[c]),
  r=x=y=0,
  O(7);
  O(3,2),
  !(z=++r>2)|x;)
    x+=(v=r<n)-z,O(v+5,1,z*4),y+=z*7;
  O(8)
}

Ungolfed mais ou menos

Esse é o código básico, antes de começar a jogar golfe. Não é exatamente o mesmo e funciona apenas para n> 2

F=n=>{
  O=t=>console.log(t)

  r=0
  x=0
  y=0

  O(' _________________')
  O(' '.repeat(y)+'|  .   '.repeat(x)+'|  .     .     .  |')

  while (++r<n)
  {
    x++;
    if (r>2)
    {
       x--;
       O(' '.repeat(y)+'|______'+'|     .'.repeat(x)+' __________|______')
       y+=7;
       O(' '.repeat(y)+'|  .   '.repeat(x)+'|     .     .     |')
    }
    else
    {
       O(' '.repeat(y)+'|     .'.repeat(x)+' __________|______')
       O(' '.repeat(y)+'|  .   '.repeat(x)+'|  .     .     .  |')
    }

  }  
  while(x--)
  {
     O(' '.repeat(y)+'|______'+'|     .'.repeat(x)+'|  .     .     .  |')
     y+=7;
     O(' '.repeat(y)+'|  .   '.repeat(x)+'|     .     .     |')
  }

  O(' '.repeat(y)+'|_________________|')
}

Teste no console do FireFox / FireBug

F(4)

Saída

 _________________
|  .     .     .  |
|     . __________|______
|  .   |  .     .     .  |
|     .|     . __________|______
|  .   |  .   |  .     .     .  |
|______|     .|     . __________|______
       |  .   |  .   |  .     .     .  |
       |______|     .|     .     .     |
              |  .   |  .     .     .  |
              |______|     .     .     |
                     |  .     .     .  |
                     |_________________|

— edc65
fonte

8

Python, 252 241 caracteres

s="eJxTiIeDGgiloBBRo6CgpwACcLIGJKaAKlxDmbp4dFADAL+oIFI=".decode('base64').decode('zip').split('X')
N=input()
R=range
G=map(list,[' '*(7*N+12)]*(2*N+5))
for n in R(N):
 for y in R(7):G[2*n+y][7*n:]=s[y]
G[0][11]='_'
for g in G:print''.join(g)

Agradecemos a FryAmTheEggman e Vincent por cortar 11 caracteres.

Uma preponderância de crackers:

$ echo 17 | python saltines.py
 _________________
|  .     .     .  |
|     . __________|______
|  .   |  .     .     .  |
|     .|     . __________|______
|  .   |  .   |  .     .     .  |
|______|     .|     . __________|______
       |  .   |  .   |  .     .     .  |
       |______|     .|     . __________|______
              |  .   |  .   |  .     .     .  |
              |______|     .|     . __________|______
                     |  .   |  .   |  .     .     .  |
                     |______|     .|     . __________|______
                            |  .   |  .   |  .     .     .  |
                            |______|     .|     . __________|______
                                   |  .   |  .   |  .     .     .  |
                                   |______|     .|     . __________|______
                                          |  .   |  .   |  .     .     .  |
                                          |______|     .|     . __________|______
                                                 |  .   |  .   |  .     .     .  |
                                                 |______|     .|     . __________|______
                                                        |  .   |  .   |  .     .     .  |
                                                        |______|     .|     . __________|______
                                                               |  .   |  .   |  .     .     .  |
                                                               |______|     .|     . __________|______
                                                                      |  .   |  .   |  .     .     .  |
                                                                      |______|     .|     . __________|______
                                                                             |  .   |  .   |  .     .     .  |
                                                                             |______|     .|     . __________|______
                                                                                    |  .   |  .   |  .     .     .  |
                                                                                    |______|     .|     . __________|______
                                                                                           |  .   |  .   |  .     .     .  |
                                                                                           |______|     .|     . __________|______
                                                                                                  |  .   |  .   |  .     .     .  |
                                                                                                  |______|     .|     .     .     |
                                                                                                         |  .   |  .     .     .  |
                                                                                                         |______|     .     .     |
                                                                                                                |  .     .     .  |
                                                                                                                |_________________|

Esse código parece realmente ineficiente, mas outras respostas dirão. Ele apenas copia e cola o cracker de água salgada em uma matriz no ponto certo, explica o cracker mais baixo com 1 caractere e imprime tudo.

Eu posso reduzi-lo a 230 caracteres se eu usar um arquivo externo (código 202 + tamanho do arquivo 38 + 1 nome do arquivo).

— Claudiu
fonte

11

Mostre todas as saídas para n=1 upto 2^10que possamos ter certeza de que seu programa realmente faz a coisa certa.

— flawr

list(' '*(7*N+12))poderia ser [' ']*(7*N+12).

— FryAmTheEggman

1

@ flawr: Senhor, isso é para dizer - você diz - você está, ah, fazendo alusão a - insinuar ou talvez apenas sugerir que eu estava sendo boba?

— Claudiu

1

@ Claudiu Posso garantir que nem ousaria pensar em insinuá-lo de um ato que teria apenas um toque impalável de bobagens. = P

— flawr

1

E G=[list(' '*(7*N+12))for _ in R(2*N+5)]comG=map(list,[' '*(7*N+12)]*(2*N+5))

— Vincent

7

Perl 189

Roubando algumas idéias de compressão de cordas da choroba, eu consegui:

echo 4 | perl -E 's/\d/($&<8?$":_)x$&/ge for@l=("|2.5.5.2|"," 98","|5.5.5|","|98|",7)[102020344=~/./g];map{say for@l[0,1];$l[$_]=substr($l[$_+2],0,7).$l[$_]for 0..6;substr$l[0],-7,1,"|"}2..<>;say for@l[0..6]'

Para uma visualização mais fácil no seu navegador:

s/\d/($&<8?$":_)x$&/ge for@l=
("|2.5.5.2|"," 98","|5.5.5|","|98|",7)[102020344=~/./g];map{
    say for@l[0,1];
    $l[$_]=substr($l[$_+2],0,7).$l[$_]for 0..6;
    substr$l[0],-7,1,"|"
}2..<>;say for@l[0..6]

Por contexto, o meu melhor antes disso:

Perl 207

$u='_'x11;s/:/ .  /g,s/.(.)/$&$1/g,$_.=$/for@l=("|:: . |"," $u","|  :: |","|$u|",$"x5)[102020344=~/./g];map{print@l[0,1];$l[$_]=substr($l[$_+2],0,7).$l[$_]for 0..6;substr$l[0],-8,1,'|'}2..pop;print@l[0..6]

Adicionando novas linhas e recuo para facilitar a leitura no seu navegador:

$u="_"x11;
s/:/ .  /g,s/.(.)/$&$1/g,$_.=$/for@l=
("|:: . |"," $u","|  :: |","|$u|",$"x5)[102020344=~/./g];
map{
    print@l[0,1];
    $l[$_]=substr($l[$_+2],0,7).$l[$_]for 0..6;
    substr$l[0],-8,1,"|"
}2..pop;
print@l[0..6]

Você pode substituir "pop" por "<>" para obter a contagem de STDIN em vez de como um parâmetro da linha de comando e obter 206 bytes. Ir para STDERR reduziria para 204 bytes.

Se eu pudesse ativar o recurso 'dizer' sem uma penalidade de bytes, chegaria a 202.

$u="_"x11;s/:/ .  /g,s/.(.)/$&$1/g for@l=("|:: . |"," $u","|  :: |","|$u|",$"x5)[102020344=~/./g];map{say for@l[0,1];$l[$_]=substr($l[$_+2],0,7).$l[$_]for 0..6;substr$l[0],-7,1,"|"}2..<>;say for@l[0..6]

invocado como:

echo 4 | perl -E '$u="_"x11;s/:/ .  /g,s/.(.)/$&$1/g for@l=("|:: . |"," $u","|  :: |","|$u|",$"x5)[102020344=~/./g];map{say for@l[0,1];$l[$_]=substr($l[$_+2],0,7).$l[$_]for 0..6;substr$l[0],-7,1,"|"}2..<>;say for@l[0..6]'

— Tye
fonte

Você tem permissão para ativar saysem penalidade, porque é o mesmo que executar na linha de comando com, em -Evez de -e. perl -E''não conta para o total de personagens.

— precisa saber é

Sua saída está incorreta. Verifique o _|_.

— choroba

@choroba, obrigado! Esqueci de colocar o substr novamente depois de tentar substituí-lo por y / | / _ / (mas sempre terminando com código mais longo). De 168 a 189.

— Tye

4

Perl 201

(remova as novas linhas, exceto a primeira a obter o #)

$_=" 46|6
15.5.5|15.5.5|198|";
s/1/|  .5.5.  ||/g;
s/\d/(5^$&?_:$")x$&/ge;
@o=@l=/.{18}.?/g;
map{
$s=$_*7;
substr$o[$_-5],$s,12,$l[$_]for 0..4;
push@o,($"x$s).$l[$_]for 5,6
}1..-1+pop;
$o[$,=$/]=~y/|/_/;
print@o

say+ <>= 198.

— choroba
fonte

"Não deve haver espaços à direita"

— Tye

@Tye: OK, volte para 202 :-(

— choroba

2

Haskell, 215 bytes

Este cria a pilha de crackers indutivamente, puxando as partes do cracker e espaçando algumas listas cíclicas:

(b:u:i)=" _|"
(%)=replicate
z=5%b++'.':z
m!n=i++map(z!!)[m..n]
s=7%b:s
d=3!19++i
e=0!16++i
y=i++6%u
g 1=[e,d,e,d,i++17%u++i]
g k=zipWith(++)(0!5:3!8:0!5:3!8:y:s)$(b:10%u++y):d:g(k-1)
f k=mapM putStrLn$(b:17%u):d:g k

O fluxo de controle é bem direto; a maior parte das artimanhas consiste em reutilizar o máximo possível de peças do cracker.

Ungolfed:

top     = " _________________"
top'    = " __________|______"
dots3   = "|  .     .     .  |"
dots2   = "|     .     .     |"
bot     = "|_________________|"

halfR   = "|     ."
halfL   = "|  .   "
halfBot = "|______"

spacer  = "       "
spaces = repeat spacer

saltine = above ++ [dots2, dots3, dots2, dots3, bot]
above   = [top, dots3]
left    = [halfR, halfL, halfR, halfL, halfBot] ++ spaces

another (oldTop:oldCracker) = above ++ zipWith (++) left (top' : oldCracker)

crackers 1 = saltine
crackers k = another $ crackers (k - 1)

test = putStr . unlines . crackers

— Matt Noonan
fonte

1

Python, 299

Eu pensei que estava sendo inteligente, mas a solução acabou sendo muito complicada e mais longa do que qualquer abordagem direta, mas não pude resistir a publicá-la. O programa calcula explicitamente qual caractere deve ser plotado nas diferentes posições da string de saída, sem repetir os crackers individuais.

N=input()
m,n,c,r=12+7*N,5+2*N,3.5,range
print''.join(i>m-2and'\n'or(i%7<(i/c<j<7+i/c)*(i<N*7)or(i+4)%7<(i/c<j+4<2+4*(i>m-3)+i/c)*(i>16))and'|'or j%2<(j*c<i<17+j*c)*(j<n-5)+(j*c<i+22<8+10*(j>n-3)+j*c)*(j>5)and'_'or(i-j*3-min(i/7,~-j/2,N-1)+1)%6<(-3<-~i/7-j/2<3)and'.'or' 'for j in r(n)for i in r(m))

E a última linha foi expandida para ver o que estava acontecendo:

print ''.join(
              '\n' if i>m-2 else
              '|' if i%7<(i/c<j<7+i/c)*(i<N*7) or (i+4)%7<(i/c<j+4<2+4*(i>m-3)+i/c)*(i>16) else
              '_' if j%2<(j*c<i<17+j*c)*(j<n-5)+(j*c<i+22<8+10*(j>n-3)+j*c)*(j>5) else
              '.' if (i-j*3-min(i/7,~-j/2,N-1)+1)%6<(-3<-~i/7-j/2<3) else
              ' '
              for j in r(n)
              for i in r(m)
             )

— Emil
fonte

1

C, 284

Para a função fea #defines, excluindo espaços em branco desnecessários e main. De acordo com o comentário do edc65, incluí um número inteiro de 128 bits (o que eu faria de qualquer maneira), mas calculei novamente mal e só consigo fazer 29 crackers antes que os tops comecem a desaparecer.

Função completa e programa de teste abaixo. Irá comentar mais tarde.

#define C b,b,c,b,b
#define S s[i/v*7-i%v
f(n){
  __int128 a=4095,b=a+2,c=6281,d=4641,w=998,v=19,s[998]={a,C,d,C,d,C,a},i=v;
  for(;i<n*v;i++)S+18]|=S+11]*16&-1<<(12+i/v*2-i%v/18)*(i%v>7); 
  for(i=(5+n*2)*w;i--;i%w||puts(""))i%w>i/w/2*7-21+i/w%2*6&&s[i%w]&&putchar(" _.|"[(s[i%w]>>i/w*2)&3]);
}


main(){
  int m;
  scanf("%d",&m);f(m);
}

Existem apenas quatro caracteres diferentes na saída. Estes são decodificados a partir de números binários 0-3 por " _.|". A matriz s[]contém um número inteiro para cada coluna da saída, 2 bits por símbolo, que é inicializado para conter o cracker mais à direita.

O primeiro forloop copia o cracker anterior, pressiona-o para movê-lo para cima, exclui o canto inferior direito usando &e ORs com o cracker anterior, 7 passos para a esquerda.

O segundo forloop decodifica a representação de 2 bits de cada caractere no caractere real e imprime o caractere. Há muito código aqui apenas para suprimir espaços em branco desnecessários na saída. Estou desapontado por minha pontuação ter subido, em vez de ter sido inferior à minha revisão anterior.

Saída

São 29 bolachas. Substituí o espaço por um -para uma aparência diferente e para mostrar que não há espaços à direita ou novas linhas estranhas na saída.

-_________________
|--.-----.-----.--|
|-----.-__________|______
|--.---|--.-----.-----.--|
|-----.|-----.-__________|______
|--.---|--.---|--.-----.-----.--|
|______|-----.|-----.-__________|______
-------|--.---|--.---|--.-----.-----.--|
-------|______|-----.|-----.-__________|______
--------------|--.---|--.---|--.-----.-----.--|
--------------|______|-----.|-----.-__________|______
---------------------|--.---|--.---|--.-----.-----.--|
---------------------|______|-----.|-----.-__________|______
----------------------------|--.---|--.---|--.-----.-----.--|
----------------------------|______|-----.|-----.-__________|______
-----------------------------------|--.---|--.---|--.-----.-----.--|
-----------------------------------|______|-----.|-----.-__________|______
------------------------------------------|--.---|--.---|--.-----.-----.--|
------------------------------------------|______|-----.|-----.-__________|______
-------------------------------------------------|--.---|--.---|--.-----.-----.--|
-------------------------------------------------|______|-----.|-----.-__________|______
--------------------------------------------------------|--.---|--.---|--.-----.-----.--|
--------------------------------------------------------|______|-----.|-----.-__________|______
---------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
---------------------------------------------------------------|______|-----.|-----.-__________|______
----------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
----------------------------------------------------------------------|______|-----.|-----.-__________|______
-----------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-----------------------------------------------------------------------------|______|-----.|-----.-__________|______
------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
-------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
--------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
--------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
---------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
---------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
----------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
----------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
-----------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-----------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
-------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
--------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
--------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
---------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
---------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
----------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
----------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
-----------------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-----------------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
------------------------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-----.-----|
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.-----.-----.--|
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.-----.-----|
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--.-----.-----.--|
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|_________________|

— Level River St
fonte

Não havia valor máximo na pergunta, apenas "um número inteiro positivo". Então 1 a 5 é sua idéia de qualquer número inteiro positivo?

— edc65

@ edc65 Por mais alguns bytes, você pode ter um tipo inteiro de 128 bits em vez de 32 bits. Isso levará até 56 crackers, o que deve ser suficiente (mais de 20kb de saída). Admito que calculei mal o número de crackers que eu poderia obter com um número inteiro de 32 bits quando comecei, pensei que fossem pelo menos dez. Mas sim, todos os programas terão algum tipo de limite superior no número de crackers que podem produzir e cabe ao OP decidir o que é isso. Ele deve ser especificado na pergunta. Sendo assim, aceitarei a decisão do OP quanto à validade da minha resposta (que não foi finalizada).

— Level River St

0

JavaScript (ES6) HTML5 - 233 236 bytes

Provavelmente não é uma resposta válida, mas não resisti a postar, desculpe :-P

F=n=>{d="______";b="\n|  .     .     .  |";a=b+"\n|     .     .     |";for(i=0;i<n;)document.body.innerHTML+="<pre style='background:#fff;position:fixed;top:"+i*28+"px;left:"+i*56+"px'> ____"+d+'|_'[+!i++]+d+a+a+b+"\n|"+d+d+"_____|"}

Teste no Firefox com F(1), F(2), F(3), etc.

Exemplo: http://jsfiddle.net/Lvmg9fe8/7/

— eu e meu gato
fonte

Não sei JavaScript, mas este Fiddle parece não fazer nada (embora eu tenha sido capaz de executar outros Fiddles sem problemas.) Tenho o Google Chrome e o Internet Explorer.

— Level River St

@steveverrill, funciona apenas no Firefox, como quase tudo o que é vendido como JavaScript aqui. O Chrome e o IE não suportam o EcmaScript 6.

— eu e meu gato

Ele funciona (no Firefox), mas não é bem o que eu estou procurando;)

— Passatempo de Calvino

Parece que não consigo fazer isso funcionar ... Estou recebendo uma resposta "indefinida" sempre que digito F(1)ou qualquer outro número, depois de ter inserido esse código no console JS no Firefox ...

— WallyWest

O Desafio Saltine