Sfida

In questa sfida, si scriverà il primo programma, p ₁ , di una sequenza infinita di programmi, in cui l'esecuzione di p _n genera / genera il programma p _{n + 1} . Quando si concatenano i primi n> = 2 programmi, la sequenza dovrebbe essere emessa n.

Esempio

Diciamo che i primi 4 programmi sono:

p1 p2 p3 p4

Se dovessi correre p1, dovrebbe produrre:

p2

Se dovessi correre p1p2, dovrebbe produrre:

2

Se dovessi eseguirlo p1p2p3p4dovrebbe produrre:

4

Se dovessi eseguire p4, dovrebbe generare il programma successivo nella sequenza:

p5

punteggio

Il tuo punteggio è il conteggio dei byte dei primi 10programmi.

Pyth, 12

p1:

l"1

p2: 1

P3: 1

eccetera..

p1p2p3:

l"111 

Produzione: 3

Spiegazione:

l        length
 "1      string "1"

Al primo avvio, questo emette la lunghezza di una singola stringa di caratteri, 1. Anche questo sembra essere un programma Pyth valido, in uscita di 1nuovo. Pertanto, pn + 1 è sempre 1. Quando i programmi sono concatenati, p1genera la lunghezza dei programmi concatenati, che sarà n.

Lua, 950 900 byte

s=io.open(arg[0]):read()if#s<95 then print(s)do return end end print(#s/90) do return end;

Ungolfed:

s=io.open(arg[0]):read'*a'
if #s < 96 then 
    print(s)
    do return end 
end 
print(#s/90) 
do return end;

Spiegazione:

La prima riga prende l'intera fonte del programma. Quindi confrontiamo la lunghezza dell'intero programma con 1 + la lunghezza di un singolo programma. Se la dimensione del programma corrente è inferiore a questo valore, viene stampata la sorgente, che è il programma successivo, p2, e usciamo. Ogni iterazione è solo una quina. Quando molti di questi sono messi insieme, il condizionale fallisce e stampiamo la lunghezza del programma concatenato divisa per la lunghezza di un programma, che è il numero di programmi concatenati, n.

Vitsy , 19 byte

Non si tratta di stringhe qui, ma usando trucchi di metodo.

p1

1ml1-\+N
1

p2

1

p3

1

Così via, così via.

Spiegazione di seguito:

1ml1-\+N
1m       Execute the first index of lines (the bit with the ones)
  l1-    Get the length minus 1.
     \+  Add them all up.
       N Output as number.

1        Push one to the stack.

Provalo online!

Vitsy , 14 byte

Simile alle risposte di Pyth e Jolf, sto mappando le stringhe. L'unica differenza è che utilizzo le funzionalità di avvolgimento linea per assicurarmi di ottenere sempre la lunghezza giusta.

p1

'l3-N

p2

1

Sostituisci 1 con un singolo numero.

p3 e così via corrispondono a questo modello e puoi farlo fino Integer.MAX_VALUEalla restrizione intera della lingua.

Spiegazione:

'l3-N
'     Wrap around the line until finding another '. Since no ' is found before the
      End of the line, it wraps around.
 l    Get the length of the stack.
  3-  Subtract three.
    N Output as number.

Provalo online!

Scherzi a parte, 15 byte

Primo programma, 6 byte (contiene un non stampabile):

5Ql-.

Dump esadecimale:

35516c2d2e7f

Questo programma stampa 1: provalo online

Il resto dei programmi è tutto 1, un programma valido che si stampa come la risposta di Pyth. Il programma originale stampa la lunghezza del suo codice sorgente meno 5 e termina immediatamente. 1s aggiunto alla fine aumenta la lunghezza del codice sorgente di 1 byte ogni volta, ma non viene mai eseguito.

Jolf , 14 byte

Provalo qui!

a-lq4
a      print
  lq   the length of the source code
 -  4  minus 4

Quando eseguito, questo stampa 1. Così, p2 = 1. Esecuzione dei p2rendimenti 1. Quindi, per tutti N > 1, pN = 1.

Osservare p1p2: a-1q41. Questo traspila a:

alert(sub(length("a-lq41"),4));
1;

Poiché la stampa implicita è disabilitata dopo la prima stampa, questa stampa 2, poiché la lunghezza del codice sorgente meno 4 è 2. E ancora e ancora e ancora.

Rubino, 318 byte

p ₁ :

x=DATA.readlines.size
_="_=%p;puts _%%_"
puts x>0?x+1:_%_
__END__

Ogni programma p separato _i emette questa sola linea quine: _="_=%p;puts _%%_";puts _%_.

Quando aggiungi queste quine alla fine di p ₁ , finiscono come linee DATAnell'oggetto perché sono al di sotto della magia __END__.

Ecco un test:

$ ruby chain.rb                                    # running p1
_="_=%p;puts _%%_";puts _%_

$ ruby -e '_="_=%p;puts _%%_";puts _%_'            # running p2
_="_=%p;puts _%%_";puts _%_

$ ruby -e '_="_=%p;puts _%%_";puts _%_'            # running p3
_="_=%p;puts _%%_";puts _%_

$ # Concatenating p2 and p3 to p1:
$ ruby -e '_="_=%p;puts _%%_";puts _%_' >> chain.rb
$ ruby -e '_="_=%p;puts _%%_";puts _%_' >> chain.rb

$ ruby chain.rb                                    # running p1p2p3
3

I dieci primi programmi concatenati si presentano così (318 byte):

x=DATA.readlines.size
_="_=%p;puts _%%_"
puts x>0?x+1:_%_
__END__
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_

C #, 2099 + 7 = 2106 byte

Primo programma (usa il flag del compilatore /main:A ):

class A{static void Main(){int a=System.Reflection.Assembly.GetEntryAssembly().GetTypes().Length;var b=@"class A{0}{{static void Main(){{var a=@""{1}"";System.Console.Write(a,{0}+1,a.Replace(""\"""",""\""\""""));}}}}";System.Console.Write(a>1?"{2}":b,0,b.Replace("\"","\"\""),a);}}

Secondo programma:

class A0{static void Main(){var a=@"class A{0}{{static void Main(){{var a=@""{1}"";System.Console.Write(a,{0}+1,a.Replace(""\"""",""\""\""""));}}}}";System.Console.Write(a,0+1,a.Replace("\"","\"\""));}}

Terzo programma:

class A1{static void Main(){var a=@"class A{0}{{static void Main(){{var a=@""{1}"";System.Console.Write(a,{0}+1,a.Replace(""\"""",""\""\""""));}}}}";System.Console.Write(a,1+1,a.Replace("\"","\"\""));}}

Ti viene l'idea.

Javascript ES6, punteggio 483 455

Programma 1, 77 byte:

v=1;setTimeout(_=>alert(v>1?v:'a=_=>this.v?v++:alert("a="+a+";a();");a();'));

Programma 2 e oltre, 42 byte ciascuno:

a=_=>this.v?v++:alert("a="+a+";a();");a();

PHP, 1470 byte

Programma 1: 219 byte:

class O{public$n=1;function __destruct(){echo($n=$this->n)>1?$n:'if(!$o->n++)echo str_replace(chr(9),$a=aWYoISRvLT5uKyspZWNobyBzdHJfcmVwbGFjZShjaHIoOSksJGE9CSxiYXNlNjRfZGVjb2RlKCRhKSk7,base64_decode($a));';}}$o=new O();

programma 2 e oltre 139 byte:

if(!$o->n++)echo str_replace(chr(9),$a=aWYoISRvLT5uKyspZWNobyBzdHJfcmVwbGFjZShjaHIoOSksJGE9CSxiYXNlNjRfZGVjb2RlKCRhKSk7,base64_decode($a));

usare come:

php -r "class O{public$n=1;function __destruct(){echo($n=$this->n)>1?$n:'if(!$o->n++)echo str_replace(chr(9),$a=aWYoISRvLT5uKyspZWNobyBzdHJfcmVwbGFjZShjaHIoOSksJGE9CSxiYXNlNjRfZGVjb2RlKCRhKSk7,base64_decode($a));';}}$o=new O();"

Utilizza una versione leggermente golfata della tecnica php quine dettagliata qui: http://10types.co.uk/the-lab/a-minimal-php-quine/