The Saltine Challenge

23

Ecco un cracker al sale ASCII :

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

Ecco due cracker impilati:

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

Scrivi il programma più breve possibile che richiede un numero intero positivo e disegna una pila di quei cracker salini ASCII.

L'input può provenire da stdin, dalla riga di comando oppure puoi semplicemente scrivere una funzione. L'input sarà sempre valido. L'output deve passare allo stdout o all'alternativa più vicina.

Ogni cracker in pila viene sempre spostato di 2 caratteri in basso e 7 caratteri a destra del cracker sotto di esso. Non dovrebbero esserci spazi finali o newline estranee.

Vince il programma più breve in byte .

Esempi

Se l'ingresso è 1l'uscita è

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

Se l'ingresso è 2l'uscita è

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

Se l'ingresso è 3l'uscita è

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

E così via.

la vera sfida salina

code-golf  ascii-art  kolmogorov-complexity 
— Hobby di Calvin
fonte
1
In che modo il contorno del cracker in basso sostituisce il contorno di quello sopra di esso?
— orgoglioso haskeller il
1
@Calvin'sHobbies: Penso che si stia chiedendo perché il bordo superiore dei cracker sovrapposti sia ___|___invece di _______. Immagino che sembrerebbe strano se fosse quest'ultimo
— Claudiu,
2
@Claudiu Oh. Sì, non è perfetto ma sembra più strano nell'altro modo.
— Calvin's Hobbies,
6
@ Calvin'sHobbies In effetti, penso che il singolo personaggio sia la parte più interessante di questa sfida. ^^
— Martin Ender,
3
Il passaggio 0 dovrebbe essere segfault.
— Naftuli Kay,

Risposte:

4

CJam, 140 125 119 116 byte

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

Provalo online.

Una sola salina

Lo snippet di codice

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.                                            ";

lascia quanto segue nello stack:

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

Saltine impilate

Supponiamo che la salina dall'alto sia salvata in 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) 249259289 304 345

Non sono così sicuro della compressione delle stringhe. Trovato una buona compressione per le stringhe. La semplice custodia da 1 cracker sembra difficile da gestire. Potrebbe esserci un modo migliore ...

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 più o meno

Questo è il codice di base, prima di iniziare a giocare a golf. Non è esattamente lo stesso e funziona solo per 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)+'|_________________|')
}

Test nella console FireFox / FireBug

F(4)

Produzione

 _________________
|  .     .     .  |
|     . __________|______
|  .   |  .     .     .  |
|     .|     . __________|______
|  .   |  .   |  .     .     .  |
|______|     .|     . __________|______
       |  .   |  .   |  .     .     .  |
       |______|     .|     .     .     |
              |  .   |  .     .     .  |
              |______|     .     .     |
                     |  .     .     .  |
                     |_________________|
— edc65
fonte
8

Python, 252 241 caratteri

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)

Grazie a FryAmTheEggman e Vincent per aver tagliato 11 caratteri.

Una preponderanza di cracker:

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

Questo codice sembra davvero inefficiente, ma altre risposte lo diranno. Copia e incolla il cracker di salsedine in un array nel punto giusto, rappresenta il cracker più in basso con 1 carattere, quindi stampa tutto.

Posso ottenere fino a 230 caratteri se uso un file esterno (codice 202 + 38 dimensioni file + 1 nome file).

— Claudiu
fonte
11
Si prega di mostrare ogni output per in n=1 upto 2^10modo che possiamo essere sicuri che il tuo programma fa davvero la cosa giusta.
— Flawr,
list(' '*(7*N+12))potrebbe essere [' ']*(7*N+12).
— FryAmTheEggman,
1
@flawr: Signore, è quello di dire - stai dicendo - stai, ah, alludendo a - insinuando o forse solo suggerendo, che ero sciocco?
— Claudiu,
1
@Claudiu Posso assicurarti che non oserei nemmeno pensare di insinuarti in un atto che avrebbe anche solo un tocco impalabile di sillynes. = P
— flawr
1
E G=[list(' '*(7*N+12))for _ in R(2*N+5)]conG=map(list,[' '*(7*N+12)]*(2*N+5))
— Vincent,
7

Perl 189

Rubando alcune idee di compressione delle stringhe da Choroba, ho capito:

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

Per una visualizzazione più semplice nel tuo browser:

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]

Per il contesto, il mio meglio prima di quello:

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]

Aggiunta di nuove righe e rientri per facilitare la lettura nel browser:

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

È possibile sostituire "pop" con "<>" per prendere il conteggio da STDIN anziché come parametro della riga di comando e arrivare a 206 byte. Andare su STDERR lo lascerebbe cadere a 204 byte.

Se potessi abilitare la funzione 'dire' senza penalità di byte, allora potrei arrivare 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]

invocato come:

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
Puoi abilitare saysenza penalità perché è uguale a quello eseguito sulla riga di comando con -Einvece di -e. perl -E''non conta per i tuoi personaggi totali.
— hmatt1,
Il tuo output non è corretto. Controlla il _|_.
— Choroba,
@choroba, grazie! Ho dimenticato di rimettere quel substrato dopo aver provato a sostituirlo con y / | / _ / (ma finendo sempre con un codice più lungo). Dal 168 al 189.
— Tye,
4

Perl 201

(rimuovi le nuove righe tranne la prima per ottenere il #)

$_=" 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
"Non dovrebbero esserci spazi finali"
— Tye,
@Tye: OK, torna a 202 :-(
— choroba
2

Haskell, 215 byte

Questo costruisce la pila di cracker in modo induttivo, estraendo parti di cracker e spaziando da un paio di liste cicliche:

(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

Il flusso di controllo è piuttosto semplice; la maggior parte dell'inganno sta nel riutilizzare quante più parti possibili del 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

Pensavo di essere intelligente, ma la soluzione si è rivelata eccessivamente complicata e più lunga di qualsiasi approccio diretto, ma non ho potuto resistere a pubblicarla. Il programma calcola esplicitamente quale carattere deve essere tracciato nelle diverse posizioni della stringa di output, senza passare in rassegna i singoli cracker.

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 l'ultima riga si è espansa per vedere cosa sta succedendo:

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

Per la funzione fe la #defines, esclusi gli spazi bianchi non necessari e main. In accordo con il commento di edc65, ho incluso un tipo intero a 128 bit (cosa che avrei fatto comunque) ma ho sbagliato di nuovo il calcolo e posso fare solo 29 cracker prima che le cime inizino a scomparire.

Programma completo di funzioni e test di seguito. Lo commenterò più tardi.

#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);
}

Ci sono solo quattro caratteri diversi nell'output. Questi sono decodificati dai numeri binari 0-3 da " _.|". L'array s[]contiene un numero intero per ogni colonna dell'output, 2 bit per simbolo, che è inizializzato per contenere il cracker più a destra.

Il primo foranello copia il cracker precedente, lo sposta a sinistra per spostarlo verso l'alto, elimina l'angolo in basso a destra usando &e lo OR con il cracker precedente, 7 passi a sinistra.

Il secondo forloop decodifica la rappresentazione a 2 bit di ciascun personaggio nel personaggio reale e stampa il personaggio. C'è un sacco di codice qui solo per sopprimere gli spazi bianchi non necessari nell'output. Sono deluso dal fatto che il mio punteggio sia aumentato invece che in calo rispetto alla mia precedente revisione.

Produzione

Sono 29 cracker. Ho sostituito lo spazio con a -per un aspetto diverso e per mostrare che non ci sono spazi finali o nuove righe estranee nell'output.

-_________________
|--.-----.-----.--|
|-----.-__________|______
|--.---|--.-----.-----.--|
|-----.|-----.-__________|______
|--.---|--.---|--.-----.-----.--|
|______|-----.|-----.-__________|______
-------|--.---|--.---|--.-----.-----.--|
-------|______|-----.|-----.-__________|______
--------------|--.---|--.---|--.-----.-----.--|
--------------|______|-----.|-----.-__________|______
---------------------|--.---|--.---|--.-----.-----.--|
---------------------|______|-----.|-----.-__________|______
----------------------------|--.---|--.---|--.-----.-----.--|
----------------------------|______|-----.|-----.-__________|______
-----------------------------------|--.---|--.---|--.-----.-----.--|
-----------------------------------|______|-----.|-----.-__________|______
------------------------------------------|--.---|--.---|--.-----.-----.--|
------------------------------------------|______|-----.|-----.-__________|______
-------------------------------------------------|--.---|--.---|--.-----.-----.--|
-------------------------------------------------|______|-----.|-----.-__________|______
--------------------------------------------------------|--.---|--.---|--.-----.-----.--|
--------------------------------------------------------|______|-----.|-----.-__________|______
---------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
---------------------------------------------------------------|______|-----.|-----.-__________|______
----------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
----------------------------------------------------------------------|______|-----.|-----.-__________|______
-----------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-----------------------------------------------------------------------------|______|-----.|-----.-__________|______
------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
-------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
--------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
--------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
---------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
---------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
----------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
----------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
-----------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-----------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
-------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
--------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
--------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
---------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
---------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
----------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
----------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
-----------------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-----------------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
------------------------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-__________|______
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.---|--.-----.-----.--|
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.|-----.-----.-----|
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--.---|--.-----.-----.--|
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|______|-----.-----.-----|
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--.-----.-----.--|
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|_________________|
— Level River St
fonte
Non c'era un valore massimo nella domanda, solo "un numero intero positivo". Quindi da 1 a 5 è la tua idea di un numero intero positivo?
— edc65,
@ edc65 Per qualche byte in più puoi avere un tipo intero a 128 bit invece di 32 bit. Ciò richiederà fino a 56 cracker, il che dovrebbe essere sufficiente (oltre 20kb di output). Devo ammettere che ho calcolato male il numero di cracker che ho potuto ottenere con un numero intero a 32 bit quando ho iniziato, ho pensato che fossero almeno dieci. Ma sì, tutti i programmi avranno una sorta di limite superiore sul numero di cracker che possono produrre e spetta all'OP decidere quale sia. Si deve essere specificato nella domanda. Come accetto, accetterò la decisione del PO sulla validità della mia risposta (che non è finita)
— Level River St
0

JavaScript (ES6) HTML5 - 233 236 byte

Probabilmente non è una risposta valida, ma non ho potuto resistere alla pubblicazione, mi dispiace :-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+"_____|"}

Prova in Firefox con F(1), F(2), F(3), etc.

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

— io e il mio gatto
fonte
Non conosco JavaScript, ma questo Fiddle non sembra fare nulla (mentre sono stato in grado di eseguire altri Fiddles senza problemi.) Ho Google Chrome e Internet Explorer.
— Level River St,
@steveverrill funziona solo su Firefox, come quasi tutto ciò che viene venduto come JavaScript qui. Chrome e IE non supportano EcmaScript 6.
— io e il mio gatto il
Funziona (su Firefox), anche se non è proprio quello che sto cercando;)
— Hobby di Calvin il
Non riesco a farlo funzionare neanche ... Sto ricevendo una risposta "indefinita" ogni volta che inserisco F(1)o qualsiasi altro numero, dopo aver inserito questo codice nella console JS in Firefox ...
— WallyWest
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.