Votre tâche consiste à créer le programme le plus court (A) qui génère un autre programme (B) avec les octets les plus uniques, qui à son tour génère le programme d'origine (A). Essentiellement, vous jouez à la moitié d'une paire de programmes ouroboros (aka quine d'itération périodique) et jouez à l'autre moitié. A et B peuvent être dans des langues différentes.

Règles et notation

Votre score final est <number of unique bytes in B> / <number of bytes in A>. Le score le plus élevé l'emporte. Il convient de noter que le score maximum théorique est de 256.

• Le programme A doit comporter au moins un octet
• Le programme B ne peut pas être entièrement composé de non-opérations, c'est-à-dire qu'au moins un caractère doit affecter la sortie d'une manière ou d'une autre.
• Les règles standard de quines s'appliquent aux deux programmes. Notamment, les quines d'erreur ne sont pas autorisées dans les deux cas.

Par souci de cohérence du format de réponse, commencez votre réponse par quelque chose comme ceci:

# <Language for A> & <Language for B>, Score: <B score> / <A score> = <combined score>

Japt & Japt , Score: 255/38 = 6,71

Programme A :

"iQ ²¯24
G²õ@i'#+Xd"iQ ²¯24
G²õ@i'#+Xd

Le programme B fait plus de 8 Ko, si long que le lien se brise, donc je ne collerai pas le tout. Voici un exemple:

#þ"iQ ²¯24
G²õ@i'#+Xd"iQ ²,#ÿ"iQ ²¯24
G²õ@i'#+Xd"iQ ²,#Ā"iQ ²¯24
G²õ@i'#+Xd"iQ ²

Je ne pouvais pas trouver un moyen de faire fonctionner un NULoctet, c'est pourquoi le programme B n'a que 255 caractères uniques. Le programme B consiste essentiellement en 255 copies d'un seul programme, où un seul octet non pertinent est changé à chaque fois, et les 254 premières exécutions sont ignorées.

Pour l'explication, je vais commencer par cette version simplifiée de A afin que le B résultant soit plus facile à discuter.

"iQ ²¯23
3õ@i'#+Xd"iQ ²¯23
3õ@i'#+Xd

Ce programme est basé sur le quine Japt de base capable de charge utile . La chaîne au début contient un doublon du reste du programme, iQ ²insère une citation et des doublons pour créer une représentation sous forme de chaîne de l'ensemble du programme, puis se ¯23coupe lui-même et tout ce qui se trouve après. La chaîne résultante est un programme qui génère le programme A :

"iQ ²¯23
3õ@i'#+Xd"iQ ²

Je ferai référence à cette chaîne comme U.

La dernière ligne de A duplique Uun tas de fois avec un petit changement à chaque fois. Plus précisément, pour chaque numéro Xde la plage, [1...3]il affiche "#c" + Uoù se ctrouve le caractère avec le code de char X. Le comportement par défaut de Japt est de sortir ces chaînes sans guillemets et séparées par des virgules, c'est donc la sortie de notre A simplifié (notez qu'il y a un octet non imprimable entre chaque #et "iQ:

#"iQ ²¯23
3õ@i'#+Xd"iQ ²,#"iQ ²¯23
3õ@i'#+Xd"iQ ²,#"iQ ²¯23
3õ@i'#+Xd"iQ ²

Nous l'appellerons B simplifié .

Le B simplifié a une structure simple, alternant entre #cet U. Heureusement pour cette réponse, chacun #cet Uest traité comme séparé par une virgule, et dans cette situation, le comportement de tout est sauf le dernier Un'a aucun effet sur la sortie. La seule partie de Simplified B qui affecte la sortie est la suivante:

"iQ ²¯23
3õ@i'#+Xd"iQ ²

Ce qui est identique à Ucelui que nous connaissons déjà des sorties simplifiées A.

La seule différence entre Simplified A et Program A est qu'au lieu de générer des copies pour la plage, [1...3]le programme réel génère des copies pour la plage [1...256]. Cela se traduit par 256 versions de #cchacune d'entre elles ayant un caractère différent, bien que la dernière version "Ā" soit un caractère multi-octets, de sorte qu'il n'ajoute aucun octet unique, mais tout sauf le dernier Uest toujours ignoré.

Programme A, Gol> <> , 256/20 octets = 12,8

"44XFL|r2ssl3%Q4s]|H

Essayez-le en ligne!

Programme B, Gol> <>

"44XFL|r2ssl3%Q4s]|H	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ

Essayez-le en ligne!

Le programme alterne entre la sortie elle-même suivie de chaque octet et juste la sortie elle-même.

Explication:

"            Wrapping string literal pushes the first line to the stack backwards
 44X         Push 256
    FL|      Push the range from 0 to 255
       r                  Reverse the stack
        2ss               Push a quote
           l3%            If the stack length is divisible by 3
              Q4s]|       Only take the top 20 characters
                   H      And output the stack

Programme A: 05AB1E , score: 256/41 256/31 octets = 8,258 ...

0"D34çý₅Ýç'q†22ǝ"D34çý₅Ýç'q†22ǝ

Essayez-le en ligne.

Programme B: 05AB1E

0"D34çý₅Ýç'q†22ǝ"D34çýq 

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoprstuvwxyz{|}~ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿÝç'q†22ǝ

Essayez-le en ligne.

Explication:

Le quine le plus court pour 05AB1E est celui-ci: 0"D34çý"D34çý( 14 octets ) fourni par @OliverNi . Ma réponse utilise une version modifiée de cette quine en ajoutant ₅Ýç'q†vy27ǝD}J.

0            # Push a 0 to the stack
             #  STACK: [0]
 "D34çý₅Ýç'q†vDy27ǝ}J"
             # Push the string "D34çý₅Ýç'q†vDy27ǝ}J" to the stack
             #  STACK: [0,"D34çý₅Ýç'q†vDy27ǝ}J"]
  D          # Duplicate the string
             #  STACK: [0,"D34çý₅Ýç'q†vDy27ǝ}J","D34çý₅Ýç'q†vDy27ǝ}J"]
   34çý      # Join the stack by '"'
             #  STACK: ['0"D34çý₅Ýç'q†vDy27ǝ}J"D34çý₅Ýç'q†vy27ǝD}J']
₅Ý           # Push a list in the range [0,255]
  ç          # Convert each integer to an ASCII character
   'q†      '# Filter the "q" to the front
      22ǝ    # Insert it at index 22 in the string (replacing the second '₅')
             # (and output the result implicitly)

Le programme B se terminera dès qu'il atteindra le q, donc le programme B réel est:

0"D34çý₅Ýç'q†22ǝ"D34çýq

Tout ce qui suit est ignoré et le haut de la pile ( 0"D34çý₅Ýç'q†22ǝ"D34çý₅Ýç'q†22ǝ) est implicitement affiché.