Défi

Dans ce défi, vous allez écrire le premier programme, p ₁ , d'une séquence infinie de programmes, dans laquelle l'exécution de p _n sorties / génère le programme p _{n + 1} . Lors de la concaténation des premiers n> = 2 programmes, la séquence doit sortir n.

Exemple

Disons que les 4 premiers programmes sont:

p1 p2 p3 p4

Si je devais courir p1, il devrait produire:

p2

Si je devais courir p1p2, il devrait produire:

2

Si je devais l'exécuter, p1p2p3p4il devrait produire:

4

Si je devais courir p4, il devrait générer le programme suivant dans la séquence:

p5

Notation

Votre score est le nombre d'octets des premiers 10programmes.

Pyth, 12

p1:

l"1

p2: 1

p3: 1

etc..

p1p2p3:

l"111 

Sortie: 3

Explication:

l        length
 "1      string "1"

Au premier lancement, cette commande affiche la longueur d'une seule chaîne de caractères, 1. Cela se trouve également être un programme Pyth valide, renvoyant à 1nouveau. Par conséquent, pn + 1 est toujours 1. Lorsque les programmes sont chaînés, p1affiche la longueur des programmes chaînés, qui sera n.

Lua, 950 900 octets

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

Non golfé:

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

Explication:

La première ligne saisit la source entière du programme. Ensuite, nous comparons la longueur du programme entier à 1 + la longueur d'un seul programme. Si la taille du programme en cours est inférieure à cette valeur, la source est imprimée, qui est le programme suivant, p2, et nous quittons. Chaque itération n'est qu'une quine. Lorsque plusieurs d'entre eux sont réunis, le conditionnel échoue et nous imprimons la longueur du programme concaténé divisée par la longueur d'un programme, qui est le nombre de programmes concaténés, n.

Vitsy , 19 octets

Ne pas traiter les chaînes ici, mais utiliser des astuces de méthode.

p1

1ml1-\+N
1

p2

1

p3

1

Ainsi de suite.

Explication ci-dessous:

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.

Essayez-le en ligne!

Vitsy , 14 octets

Semblable aux réponses Pyth et Jolf, je mappe des chaînes. La seule différence est que j'utilise les fonctionnalités de retour à la ligne pour m'assurer d'avoir toujours la bonne longueur.

p1

'l3-N

p2

1

Remplacez 1 par un numéro unique.

p3 et ainsi de suite correspondent à ce modèle, et vous pouvez le faire jusqu'à Integer.MAX_VALUEla restriction entière de la langue.

Explication:

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

Essayez-le en ligne!

Sérieusement, 15 octets

Premier programme, 6 octets (contient un non imprimable):

5Ql-.

Vidage hexadécimal:

35516c2d2e7f

Ce programme imprime 1: Essayez-le en ligne

Les autres programmes sont tous 1, un programme valide qui s'imprime comme la réponse Pyth. Le programme d'origine imprime la longueur de son code source moins 5 et se termine immédiatement. 1s ajoutés à la fin augmentent la longueur du code source d'un octet à chaque fois, mais ne sont jamais exécutés.

Jolf , 14 octets

Essayez-le ici!

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

Une fois exécuté, cela s'imprime 1. Ainsi, p2 = 1. Exécution des p2rendements 1. Donc, pour tous N > 1, pN = 1.

Observer p1p2: a-1q41. Cela se traduit par:

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

Étant donné que l'impression implicite est désactivée après la première impression, cela s'imprime 2, car la longueur du code source moins 4 est 2. Et ainsi de suite.

Rubis, 318 octets

p ₁ :

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

Chaque programme séparé p _i sorties cette Quine une ligne: _="_=%p;puts _%%_";puts _%_.

Lorsque vous ajoutez ces quines à la fin de p ₁ , elles finissent comme des lignes dans l' DATAobjet car elles sont en dessous de la magie __END__.

Voici 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

Les dix premiers programmes concaténés ressemblent à ceci (318 octets):

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 octets

Premier programme (utilise le drapeau du compilateur /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);}}

Deuxième programme:

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("\"","\"\""));}}

Troisième programme:

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("\"","\"\""));}}

Vous avez eu l'idée.

Javascript ES6, score 483 455

Programme 1, 77 octets:

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

Programme 2 et au-delà, 42 octets chacun:

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

PHP, 1470 octets

Programme 1: 219 octets:

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();

programme 2 et au-delà de 139 octets:

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

utiliser comme:

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();"

Utilise une version légèrement golfée de la technique de php quine détaillée ici: http://10types.co.uk/the-lab/a-minimal-php-quine/