Sfida

Scrivi il frammento di codice più breve possibile in modo tale che, quando N copie di esso sono concatenate insieme, il numero di caratteri emessi è N ² . N sarà un numero intero positivo.

Ad esempio, se lo snippet fosse soln();, la corsa soln();stamperebbe esattamente 1 carattere e la corsa soln();soln();stamperebbe esattamente 4 caratteri e la corsa soln();soln();soln();stamperebbe esattamente 9 caratteri, ecc.

Qualsiasi carattere può essere nell'output purché il numero totale di caratteri sia corretto. Per evitare confusione tra sistemi operativi, le \r\nnuove righe vengono conteggiate come un carattere.

I programmi non possono leggere la propria fonte o leggere la dimensione del file o utilizzare altre scappatoie di questo tipo. Trattare questo come un rigoroso Quine sfida.

L'output può andare su stdout o un file o un'alternativa simile. Non ci sono input.

I commenti nel codice vanno bene, così come si esce dalla metà dell'esecuzione.

Qualsiasi personaggio può essere nel programma. Vince l' invio più breve in byte .

TECO, 4 byte

V1\V

Vstampa il contenuto della riga corrente nel buffer di testo. 1\inserisce la rappresentazione in forma di stringa del numero 1 nella posizione corrente.

Così il N ° iterazione del programma, la prima Vuscita volontà N - 1 copie del carattere 1, poi aggiungere un altro 1per il testo, quindi l'uscita N 1 s.

Brainfuck, 17 16 byte

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

Puoi provarlo qui . Basta usare il fatto che .n2+2n+1=(n+1)2

Brainfuck, 11

Ho visto la prima risposta di Brainfuck e ho pensato che fosse troppo lungo :)

[.<]>[.>]+.

L'output potrebbe essere più semplice da vedere se si sostituisce il plus con molti più plus.

Nell'ennesima iterazione, ciascun loop genera copie N - 1 del carattere con valore ASCII 1, e quindi un'altra con +..

Python 2, 22

a='';print a;a+='xx';a

Stampa la stringa vuota, quindi due x', quindi x' quattro e così via. Con la nuova riga dopo ogni stringa, questo viene fuori dai n*ncaratteri.

Una copia: "\n"(1 carattere)
Due copie: "\nxx\n"(4 caratteri)
Tre copie: "\nxx\nxxxx\n"(9 caratteri)

Per impedire che la variabile iniziale avenga reinizializzata ad ogni esecuzione, finisco il codice con a ;a, che è di per sé benigno, ma combinato con il ciclo successivo per creare il capro espiatorio aada assegnare invece. Questo trucco non è mio; L'ho visto in una risposta precedente. Gradirei se qualcuno potesse indicarmi in modo che io possa dare credito.

CJam, 6 byte

LLS+:L

Usa il fatto che .n2 + n + (n+1) = (n+1)2

L      "Push L. Initially this is an empty string, but its length increases by 1 with each copy
        of the snippet.";
 L     "Push another L.";
  S+   "Add a space to the second copy.";
    :L "Store the lengthened string in L for the next copy of the snippet.";

/// , 21 byte

Sono sicuro che esiste un modo davvero breve e contorto per risolverlo in /// ma non sono riuscito a trovare nulla, al di là del modo "semplice":

1/1\//112\///2\//1\//

Questo si basa sull'approccio della stampa di numeri dispari consecutivi. Lo snippet è costituito da 1a all'inizio che viene stampato e da due sostituzioni che aggiungono altre due 1s a quella prima parte di ogni copia consecutiva dello snippet. Andiamo attraverso questo per N = 3. È necessario leggere quanto segue in gruppi di 3 o più righe: 1. il codice corrente, 2. i token elaborati, 3. (e seguenti) un commento su cosa fa il token sopra.

1/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
1
is printed
/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
/1\//112\//
replaces all occurrences of 1/ with 112/. This affects the starts of all further snippets
but not the substitution commands, because the slashes in those are always escaped.
It is necessary to put a 2 in there, because otherwise the interpreter goes into an infinite
loop replacing the resulting 1/ again and again.
/2\//1\//112/1\//112\///2\//1\//112/1\//112\///2\//1\//
/2\//1\//
Replace all occurrences of 2/ with 1/, so the the next snippets substitution works again.
111/1\//112\///2\//1\//111/1\//112\///2\//1\//
111
is printed
/1\//112\///2\//1\//111/1\//112\///2\//1\//
/1\//112\//
add two 1s again
/2\//1\//11112/1\//112\///2\//1\//
/2\//1\//
turn the 2 into a 1 again
11111/1\//112\///2\//1\//
11111
print 11111
/1\//112\///2\//1\//
the last two substitutions have nothing to substitute so they do nothing

È interessante notare che funziona altrettanto bene se spostiamo il 1fino alla fine:

/1\//112\///2\//1\//1

> <> , 14 byte

1:na*a*';'10p!

Utilizza l'idea "somma di numeri interi dispari consecutivi a partire da 1". Inizia con 1 e lo moltiplica per 100 ogni volta, aumentando progressivamente la lunghezza dell'uscita con incrementi di 2.

Ad esempio, si aggiungono 5 copie

1100100001000000100000000

Ho provato eseguendo il piping dell'output in un file e non ho visto una riga finale trascinata.

Abbattersi

1                   Push 1, skipped by ! every time except the first
 :n                 Copy top of stack and output as num                  
   a*a*             Multiply by 10 twice
       ';'10p       Modify the source code so that the first : becomes a ; for termination
             !      Skip the next 1

CJam, 10 9 byte

],)_S*a*~

Questo stampa N ² spazi dove Nè il numero di copie del codice.

Espansione del codice :

],            "Wrap everything on stack and take length";
  )_          "Increment and take copy";
    S*        "Get that length space string";
      a*      "Wrap that space string in an array and create that many copies";
        ~     "Unwrap so that next code can use to get length";

Provalo online qui

Python 2, 20 byte

g=0
print'g'*g;g+=2#

Java - 91 byte

{String s=System.getProperty("a","");System.out.println(s);System.setProperty("a","xx"+s);}

Questa soluzione è equivalente a questa in Python. Sicuramente non vincerà, ma è stato divertente :)

Perl, 14 byte

print;s//__/;

Questo deve essere eseguito con l'opzione di -lcomando di Perl , che provoca printl'aggiunta di nuove righe.

Stampa la variabile predefinita $_, quindi antepone due caratteri di sottolineatura tramite sostituzione.

Esempio:

$ perl -le 'print;s//__/;print;s//__/;print;s//__/;print;s//__/;'

__
____
______

Brainfuck, 10 caratteri

Entrambe le soluzioni precedenti brainfuck erano waaay troppo lunga (16 e 11 caratteri) ecco uno più corto:

+[.->+<]>+

Nel nblocco X stampa i 2*n-1caratteri (con punti di codice da 2*n-1a 1)

Preludio , 18 12 byte

^1+(9!1-)#2+

Questo stampa N ² schede. Presuppone un interprete conforme allo standard che stampa i caratteri anziché i numeri, quindi se si utilizza l'interprete Python è necessario impostare NUMERIC_OUTPUTsu False.

L'idea è semplicemente di usare la parte superiore della pila (che inizialmente è 0) come 2(N-1), e stampare le 2N-1schede, quindi incrementare la parte superiore della pila di 2. Quindi ogni ripetizione stampa il numero dispari successivo di schede.

Java - 59/44 (a seconda dei requisiti)

static String n="1";
static{System.out.print(n);n+="11";}//

Apparentemente possiamo ammettere che il codice venga eseguito in una classe.

Se può andare all'interno di un metodo principale:

String n="1";
System.out.print(n);n+="11";//

C, 87 byte

#if!__COUNTER__
#include __FILE__
main(a){a=__COUNTER__-1;printf("%*d",a*a,0);}
#endif

Questo utilizza due macro magiche. __COUNTER__è una macro che si espande alla 0prima volta che viene utilizzata, 1la seconda, ecc. È un'estensione del compilatore, ma è disponibile almeno in gcc, clang e Visual Studio. __FILE__è il nome del file sorgente. Includere un file in C / C ++ equivale letteralmente a incollarlo direttamente nel codice sorgente, quindi è stato un po 'complicato da usare.

Sarebbe ancora possibile usare questa tecnica senza __COUNTER__. In tal caso, la protezione standard contro l'uso del codice due volte potrebbe essere utilizzata per l' #ifaffermazione e __LINE__potrebbe essere utilizzata per contare il numero di caratteri necessari.

Dyalog APL, 20 19 byte

Una soluzione basata su matrice.

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'

Provalo qui . Restituisce una stringa di ripetizioni di . Spiegazione per esplosione per :N2aN = 2

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'
                                  ⍪'a'  Wrap 'a' into a 1x1 matrix.
                'a'{            }⍨      Binary function: bind 'a' to ⍵ and the matrix to ⍺.
                    ⍺≢⍵:                The arguments are not identical,
                        ⍵⍪⍵,⍺           so add to the matrix 1 column and 1 row of 'a's.
               ⍪                        Identity function for a matrix.
{            }⍨                         Unary function: bind the matrix to both ⍵ and ⍺.
 ⍺≢⍵:                                   The arguments are identical,
           ∊⍺                           so flatten the matrix into the string 'aaaa'.

STATA 20

di _n($a)
gl a=$a+2

C'è una nuova riga finale per assicurarsi che l'istruzione display (di) funzioni. Per prima cosa visualizza il numero corrente in $ a newline (e uno in più rispetto alla visualizzazione predefinita). Quindi aggiungi 2 a $ a.

Utilizza l'approccio dei numeri pari (ovvero l'approccio ai numeri dispari meno 1) con una nuova riga in più ogni volta.

T-SQL 117

IF OBJECT_ID('tempdb..#')IS NULL CREATE TABLE #(A INT)INSERT INTO # VALUES(1)SELECT REPLICATE('a',COUNT(*)*2-1)FROM #

Notare lo spazio finale per assicurarsi che la condizione if sia controllata correttamente ogni volta.

Utilizza l'approccio dei numeri dispari. Non sono sicuro se c'è una nuova riga su determinate istruzioni.

Non sono sicuro se esiste un modo più breve per creare una tabella se non esiste.

PostScript, 35 caratteri

count dup 2 mul 1 add string print

Ogni passaggio "perde" una cosa nello stack, quindi countaumenta di 1 ogni volta. Quindi usa solo la somma del trucco dei numeri dispari.

I byte di output sono tutti \000perché questo è il valore iniziale delle stringhe.

Haskell, 72

putStr$let a="1";aputStr=(\n->take(n^2)$show n++cycle" ").(+1).read in a

Spiegazione

L'operatore apply si $comporta come se si posizionassero le parentesi circostanti intorno al resto della linea (ci sono eccezioni a questo, ma funziona in questo caso). aputStrè una funzione che accetta una stringa con il formato "abc ...", dove "abc" è la radice quadrata della lunghezza della stringa, incluso abc. Analizzerà la stringa come un numero intero e restituirà una stringa che inizia con abc + 1 e ha quella lunghezza al quadrato. A causa $dell'operatore, questo verrà chiamato ricorsivamente su "1" N volte.

Pyth, 8 byte

*d*2Z~Z1

Ciò si basa sul fatto che N ² è uguale alla somma dei Nnumeri dispari. Ora Pyth automatica stampa una linea nuova, quindi devo stampare solo Z * 2caratteri in ogni codice in cui Zva da 0a N - 1.

Espansione del codice :

*d               "Print d whose value is a space character"
  *2Z            "2 * Z times where Z's initial value is 0"
     ~Z1         "Increment the value of Z";

Provalo online qui

Golflua, 23 byte

X=2+(X|-2)w(S.t("&",X))

genera una combinazione di &e \ncaratteri.

Codice Lua equivalente

X = 2 + (X or -2)          -- initialize X to 0 the first time, add 2 ever other time

print(string.rep("&", X))

Ogni volta che lo snippet di codice viene eseguito, produce 2 caratteri di output in più rispetto all'ultima volta, a partire da 1 carattere. La printfunzione aggiunge una nuova riga, quindi inizializzo X su 0 anziché 1.

ActionScript - 27/26 byte

var n=""
trace(n);n+="11"//

o

var n=1
trace(n);n+="11"//

Come funziona:

var n=""
trace(n);n+="11"//var n=""
trace(n);n+="11"//

Commenta semplicemente la prima riga. Nota: traceaggiunge una nuova riga. O forse tutti gli IDE che uso lo fanno automaticamente.

GML, 27

a=''show_message(a)a+='xx'a