Il tuo compito è quello di creare il programma più breve (A) che genera un altro programma (B) con i byte più unici, che a sua volta genera il programma originale (A). In sostanza, stai giocando a golf metà di un paio di programmi ouroboros (ovvero quine di iterazione periodica) e lanciando l'altra metà. A e B possono essere in diverse lingue.

Regole e punteggio

Il tuo punteggio finale è <number of unique bytes in B> / <number of bytes in A>. Il punteggio più alto vince. Va notato che il punteggio massimo teorico è 256.

• Il programma A deve essere lungo almeno un byte
• Il programma B non può consistere interamente in nessuna operazione, ovvero almeno un carattere deve influenzare l'output in qualche modo.
• Le regole standard dei quines si applicano ad entrambi i programmi. In particolare, in entrambi i casi non sono consentiti errori di interrogazione.

Per motivi di coerenza del formato della risposta, inizia la tua risposta con qualcosa del genere:

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

Japt & Japt , Punteggio: 255/38 = 6.71

Programma A :

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

Il programma B è lungo più di 8 KB, così a lungo che il collegamento si interrompe, quindi non incollerò il tutto. Ecco un esempio:

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

Non riuscivo a trovare un modo per far funzionare un NULbyte, motivo per cui il programma B ha solo 255 caratteri univoci. Il programma B consiste essenzialmente di 255 copie di un singolo programma, in cui un singolo byte irrilevante viene cambiato ogni volta e le prime 254 esecuzioni vengono ignorate.

Per la spiegazione, inizierò con questa versione semplificata di A in modo che la B risultante sia più facile da discutere.

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

Questo programma si basa sul Japt Quine di base in grado di supportare il payload . La stringa all'inizio contiene un duplicato del resto del programma, iQ ²inserisce una citazione e duplicati per creare una rappresentazione di stringa dell'intero programma, quindi ¯23ritaglia se stesso e tutto ciò che lo segue. La stringa risultante è un programma che emette il Programma A :

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

Mi riferirò a questa stringa come U.

L'ultima riga di A si duplica più Uvolte con una piccola modifica ogni volta. Specificamente, per ogni numero Xnell'intervallo [1...3]emette "#c" + Udove cè il carattere con charcode X. Il comportamento predefinito di Japt è di generare quelle stringhe senza virgolette e separate da virgole, quindi questo è l'output della nostra A semplificata (nota che c'è un byte non stampabile tra ciascuna #e "iQ:

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

Chiameremo questo B semplificato .

B semplificato ha una struttura semplice, alternando tra #ce U. Fortunatamente per questa risposta, ciascuno #ce Uviene trattato come separato da una virgola, e in questa situazione il comportamento di questo è tutto tranne l'ultimo Unon ha alcun effetto sull'output. L'unica porzione di B semplificata che influenza l'output è questa:

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

Il che è identico a Uquello che già conosciamo come output semplificato A.

L'unica differenza tra A semplificato e Programma A è che invece di generare copie per l'intervallo [1...3]il programma reale genera copie per l'intervallo [1...256]. Ciò si traduce in 256 versioni di #cognuna delle quali ha un carattere diverso, sebbene l'ultima versione "Â" sia un carattere multi-byte, quindi non aggiunge alcun byte univoco, ma tutto tranne l'ultimo Uviene comunque ignorato.

Programma A, Gol> <> , 256/20 byte = 12,8

"44XFL|r2ssl3%Q4s]|H

Provalo online!

Programma B, Gol> <>

"44XFL|r2ssl3%Q4s]|H	

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

Provalo online!

Il programma si alterna tra l'output stesso seguito da ogni byte e l'output stesso.

Spiegazione:

"            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

Programma A: 05AB1E , punteggio: 256/41 256/31 byte = 8.258 ...

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

Provalo online.

Programma B: 05AB1E

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

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

Provalo online.

Spiegazione:

Il quine più breve per 05AB1E è questo: 0"D34çý"D34çý( 14 byte ) fornito da @OliverNi . La mia risposta usa una versione modificata di quel quine aggiungendo ₅Ýç'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)

Il programma B termina non appena raggiunge il q, quindi il programma effettivo B è:

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

Tutto ciò che segue viene ignorato e la parte superiore dello stack ( 0"D34çý₅Ýç'q†22ǝ"D34çý₅Ýç'q†22ǝ) viene emessa implicitamente.