Il tuo compito è di scrivere un programma di lunghezza pari , che stampa un quadrato di arte ASCII (descritto di seguito), che aumenta la sua lunghezza laterale di 1 unità ogni volta che il codice sorgente originale viene incollato nel mezzo del codice corrente.

È abbastanza difficile per me definire questo compito molto bene, quindi ti faccio un esempio:

• Supponiamo che il tuo codice iniziale fosse CODEe che fosse stampato:

  0
  

• Quindi, inserisci CODEal centro: il tuo codice diventa COCODEDEe dovrebbe essere stampato:

  00
  00
  

• Reinserisci CODEnel mezzo: il codice diventa COCOCODEDEDE e deve essere stampato:

  000
  000
  000
  

• E così via. La tua risposta dovrebbe teoricamente funzionare dopo un numero qualsiasi di iterazioni, ma capisco se, a causa delle limitazioni delle prestazioni linguistiche, non può ragionevolmente superare una determinata soglia.

Alcune regole:

• Puoi usare qualsiasi ASCII stampabile (32-127) come personaggio da usare per il tuo quadrato. La tua scelta deve essere costante (dovresti usare lo stesso carattere per ogni iterazione).

• Il quadrato di output iniziale deve avere una lunghezza laterale 1 .

• Un quadrato ascii-art è definito come una stringa con N linee (separate da N-1 avanzamenti di riga / nuove righe) e con ogni riga contenente N copie del carattere scelto.

• Il tuo output non può contenere spazi bianchi estranei, tranne una nuova riga finale.

• È possibile utilizzare i valori predefiniti per input e output (sono consentiti programmi o funzioni, ma non gli snippet).

• La parte centrale del codice viene definita come il punto in cui il codice sorgente può essere diviso in due parti in modo che le due siano uguali.

• Le risposte verranno assegnate in base alla lunghezza del programma originale , in byte. Vince il conteggio dei byte più basso. In caso di pareggio, vince la risposta inviata in precedenza.

• È possibile utilizzare questo programma per applicare gli inserimenti senza farlo manualmente.

Pyth , 2 byte

5

Provalo online! Inoltre Provalo raddoppiato , triplicato !

Come funziona?

\nè il comando che stampa il suo argomento con una nuova riga finale, restituendolo contemporaneamente. Quindi, ogni volta che si effettua un inserimento, si trasforma il numero intero letterale 5 in un numero contenente N copie di 5 concatenate e le nuove linee principali in pratica si assicurano che sia stampata il numero di volte appropriato, mantenendolo così quadrato.

JavaScript (ES6), 42 32 30 byte

s=[this.s]+0;  console.log(s);

Seconda iterazione:

s=[this.s]+0;  s=[this.s]+0;  console.log(s);console.log(s);

Questo funziona aggiungendo 0a sogni volta che viene eseguita la prima metà del codice e stampandosi sogni volta che viene eseguita la seconda metà. Sfrutta quattro stranezze di JavaScript:

1. È possibile fare riferimento all'ambiente attuale con this. Questo ci permette di fare this.sal posto di s.
2. Quando si accede a una proprietà che non è stata definita su un oggetto, anziché generare un errore, viene restituito JavaScript undefined.
3. Un array più un numero restituisce una stringa. [1,2,3] + 4 === "1,2,34"
4. Quando si stringe un array, undefinedviene convertito nella stringa vuota, il che significa che [undefined] + 0 === "0".

Complessivamente, ciò significa che possiamo esprimere la prima metà (generando una stringa di zero) in soli 13 byte. Se si utilizza alertinvece di console.logè consentito, è possibile salvare altri 4 byte accorciando la seconda metà.

05AB1E , 2 byte

5=

Provalo online!

Porta della mia risposta Pyth .

Python 2 , 42 38 28 byte

id='%s@'%id  ;print id[22:];

Provalo online! . Puoi anche provare la seconda e la terza iterazione

Python 2 , 22 byte

i=0;i+=1; i
print'*'*i

Provalo online!

raddoppiato:

i=0;i+=1; ii=0;i+=1; i
print'*'*i
print'*'*i

Si noti che la seconda metà inizia con un carattere di nuova riga.

C (gcc) , 170 168 96 80 72 70 byte

Versione molto più breve. Vorrei ancora poter trovare una soluzione senza il preprocessore.

i;main(n){for(;i++<n;)printf
#if 0

#endif
(" %*c",n=__LINE__/4, 10);}

Provalo online!

Vecchia versione da 168 byte:

#ifndef A
#define A p(c){putchar(c);}j,n;main(i){for(
#else
#define A n++,
#endif
A



#ifndef B
#define B i=++n;i--;p(10))for(j=n;j--;)p(64);}
#else
#define B
#endif
B

Provalo online!

Python 2 , 30 byte

False+=1      ;print'*'*False;

Provalo online! , 2a e 3a iterazione

Questo fa uso del fatto che i bool in Python sono fondamentalmente ints e i nomi Falseed Trueerano riassegnabili in Python 2.

Python 1 , 32 byte

exit=exit+'*'  ;print exit[30:];

Provalo online! , 2a e 3a iterazione

In Python 1 le stringhe incorporate exite quitesistito per informare l'utente della shell interattiva come uscire di esso. Il valore predefinito è "Use Ctrl-D (i.e. EOF) to exit.".

Carbone , 6 byte

⊞υωＬυ⸿

Provalo online! Spiegazione:

  ω     Predefined empty string (any variable would do here)
 υ      Predefined initially empty list
⊞       Push

υ finisce con una lunghezza del numero di ripetizioni.

    υ   List
   Ｌ    Length
        Implicitly print as a row of `-`s
     ⸿  Move to start of next line

Haskell , 68 byte

let s@(z:n)="0\n"in case lines<$>[]of(h:t):_->(h:h:t)>>(z:h++n);_->s

Provalo online una volta , due o tre volte .

A causa della pigrizia di Haskell, un'espressione come quella sopra conta come una funzione che non accetta argomenti, come da questa domanda Meta .

brainfuck , 44 34 byte

^{barrato 44 è ancora regolare 44;}

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

Provalo online!

Provalo raddoppiato , triplicato . Guarda, nessuna imbottitura!

Stampa i quadrati di U. Si divide proprio al centro degli 10 +s.

Rubino, 18 byte

$/=?x+$/;  puts$/;

Provalo online! Raddoppiato! Triplicato!

Brain-Flak , 74 byte

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

Provalo online!

Provalo raddoppiato e triplicato .

Spiegazione

(((((()()()){}){}){}){}) # push 48 ("0") onto first stack
((()()()()()<>){})       # push 10 (\n) onto second stack
<>([]){({}[()]<          # a number of times equal to the height of the first stack:
  (({})<>)<>             #   copy the top of the first stack to the second stack
>)}{}<>                  # cleanup and return to second stack

Il punto di interruzione si trova al centro della <>sezione "push 10". La rottura di questo lascerà un 5 sul terzo stack fino a raggiungere la seconda metà corrispondente, a quel punto spingendo 10 riprenderà da dove era stato interrotto.

Mentre è possibile spingere un valore ASCII (spazio) stampabile in 22 byte, questo farebbe eseguire la centrale <>dopo aver premuto 5. Aggiungendo altri due byte, sono stato in grado di spostare in <>modo che tutti i progressi verso il push 10fossero sul terzo stack. Come bonus, questo ha anche reso il quadrato risultante più esteticamente piacevole.

tinylisp , 112 byte

(load library) (d N((q((x)(i x(inc x)1)))(v(h(t(t(h(t(q())))))))))(join(repeat-val(string(repeat-val 42 N))N)nl)

Provalo online! Anche raddoppiato e cinque volte .

L'approccio "costruisci una stringa nella prima metà, stampala nella seconda metà" che molte lingue stanno adottando non funzionerà in tinylisp, poiché non ci sono variabili mutabili. Invece, eseguiamo un serio annidamento del codice.

Quando viene inserita una seconda copia del codice, questo viene inserito all'interno di (q()), che lo avvolge in un elenco. Quindi (h(t(t(h(t(...))))))esegue il drill-up in tale elenco nella parte successiva (d N. (v(...))lo valuta; quindi lo passiamo alla funzione senza nome (q((x)(i x(inc x)1))), che aumenta il valore risultante se è un numero e restituisce 1 se è l'elenco vuoto. Viene assegnato il risultato finale nella versione nidificata più esterna del codice N. In sostanza, abbiamo creato uno strano tipo di ricorsione che conta il numero di livelli di annidamento.

La seconda metà del codice crea quindi una stringa di Nasterischi, quindi un elenco di Ntali stringhe, quindi unisce l'elenco su newline. Il risultato viene visualizzato con una nuova riga finale.

R , 44 byte

F=F+1;T=TRUE*TRUE+12;
write(strrep(1,F),"");

Provalo online!

Stampa con una nuova riga finale. Il T=TRUE*TRUE+12è solo per riempire la lunghezza.

Provalo raddoppiato e provalo triplicato .

Julia 0.6 , 29 byte

Tutte le mie idee erano più lunghe rispetto all'adattamento della soluzione intelligente di pitone di xnor.

i=0;i+=1;    i
println("0"^i)

diventa

i=0;i+=1;    ii=0;i+=1;    i
println("0"^i)
println("0"^i)

Provalo online!

SNOBOL4 (CSNOBOL4) , 130 68 byte

Ora senza commenti! Vedi la cronologia delle modifiche per una spiegazione del vecchio algoritmo.

	X =X + 1
	A =ARRAY(X,DUPL(1,X));
I	I =I + 1
	OUTPUT =A<I>	:S(I)
END

Provalo online!

Provalo raddoppiato e triplicato

Spiegazione:

	X =X + 1		;* increment X
	A =ARRAY(X,DUPL(1,X));	;* create an x-length array with 1 repeated x times for each element
I	I =I + 1		;* for i < x
	OUTPUT =A<I>	:S(I)	;* output a[i]
END

Poiché ENDè richiesta un'etichetta e qualsiasi cosa dopo la prima ENDetichetta viene ignorata, otteniamo due vantaggi per questa sfida:

• le operazioni nella prima metà del programma sono Xtempi ripetuti per le Xripetizioni
• ci sarà (per l'interprete) una sola copia della seconda metà, comprese le etichette .

Questo suggerisce che usiamo la ripetizione per la prima metà e quindi possiamo usare un approccio di etichettatura più "convenzionale" per ripetere i Xtempi di uscita .

La prima metà è

	X =X + 1
	A =ARRAY(X,DUPL(1,X));

che, una volta ripetuto, incrementa Xil numero appropriato di volte e crea un ARRAY Aindice con da e 1verso Xcui ogni elemento di Aè la stringa 1ripetuta Xvolte.

Quindi, indipendentemente da quante volte il programma viene ripetuto, l'interprete vede solo:

I	I =I + 1
	OUTPUT =A<I>	:S(I)
END

che è un tipico programma SNOBOL che stampa gli elementi di Auno alla volta fino a quando l'indice esce dai limiti, quindi termina il programma.

;è un terminatore di linea opzionale solitamente riservato a una riga EVALo CODEistruzioni che porta abbastanza ordinatamente il conteggio dei byte a 68 e segna il punto a metà strada, consentendo di aggiungere il codice lì.

shortC , 56 44 byte

^{-12 byte: aspetta duh sto usando shortC perché non usare alcune cose C accorciate}

s[];A
strcat(s,"@");//
Js);/*filling space*/

Avrei usato lo standard C, ma questo richiede un }alla fine che guasta con la replica. shortC lo inserisce implicitamente in EOF.

• Provalo online! (1x1)
• Provalo online! (2x2)
• Provalo online! (3x3)
• ...
• Provalo online! (15x15)

Perl 5 , 25 byte

24 byte codice + 1 per -p.

Apprezzo che potresti non voler consentire i flag della riga di comando, per favore fammi sapere se questo non è valido.

$@=0 x++$n;;$_="$@
"x$n;

Provalo online!

Zsh , 10 byte

s+=0
<<<$s

Prova una suite di test completa online!

... sì, è un po 'meglio. Aggiungi alla stringa N volte, quindi stampa N volte. Risulta <<<foo<<<foofunziona bene.

Zsh , 64 byte

Personaggio utilizzato: (spazio).

f(){printf '%*s\n' $1}
:<<'E'

E
repeat $[i=LINENO/3];f $i
exit

Prova una suite di test completa online!

Il punto medio si trova tra il secondo Ee la nuova riga che lo seguono. Una eredità termina quando c'è Euna linea su se stessa, che avviene proprio nel mezzo del codice.