Hemos tenido muchos desafíos de quine , pero muchos de los formatos de quine son similares, creemos alguna variación en nuestras quines.

Su tarea es crear una selección de programas en el mismo idioma (al menos 2), todos los cuales generan su propio código fuente, sin embargo, ninguno de estos programas puede compartir ningún carácter.

Por ejemplo, si crea un programa usando:

printf+qw(printf+qw(%s)x2)x2

Su próximo programa no puede incluir ninguno de:

%()+2finpqrstwx

y así.

Reglas

• Puede usar caracteres unicode, pero aún debe puntuar en bytes.
• Todos los programas deben cumplir con la definición de la comunidad de una quine adecuada . Esto significa que la cadena vacía no cuenta como una quine válida, entre otras cosas.
• Las lagunas estándar están prohibidas.
• Se permiten funciones o programas completos siempre que cumplan con la definición anterior.
• Los idiomas independientes de los símbolos (incluidos Lenguage y Headsecks) no están permitidos.
• La mayoría de los programas ganan, con el código total más corto como un desempate.

V , 3 , 5 quines, 46 bytes

2A2A

Pruébalo en línea!

Hexdump:

00000000: 3241 3241                                2A2A

Explicación:

2     " 2 times...
 A    " (A)ppend the following text...
  2A  "   '2A'

5­­­a5­­­a

Pruébalo en línea!

Hexdump:

00000000: 35ad adad 6135 adad ad61                 5...a5...a

Explicación:

5---        " 5 - 3 times...
    a       " (a)ppend the following text...
     5---a  "   '5---a'

1«I1«I

Pruébalo en línea!

Hexdump:

00000000: 31ab 4931 ab49                           1.I1.I

Explicación:

1«      " 1 + 1 times...
  I     " (I)nsert the following text...
   1«I  "   '1«I'

Aquí es donde comienzan a ponerse funky ...

ñi34x@-qPÉÑ~ÿ

Pruébalo en línea!

Hexdump:

00000000: f169 1633 341b 7840 2d71 50c9 d17e ff    .i.34.x@-qP..~.

Explicación:

ñ                       " Wrap all the following in macro '"q':
 i<C-v>34               "   Insert character code 34 `"`
         <esc>          "   Return to normal mode
              x         "   Delete the character we just inserted. Now, running `@-` will be equal to running `"`
                  P     "   Paste...
               @-       "   From Register...
                 q      "   "q
                   ÉÑ   "   Insert 'Ñ' at the beginning of this line
                     ~  "   Toggle the case of the character we just inserted
                      ÿ "   Black magic

:norm é:":p

Pruébalo en línea!

Hexdump:

00000000: 3a6e 6f72 6d20 e93a 223a 70              :norm .:":p

Explicación:

:norm       " Run the following commands as if typed:
      é:    "   insert ':'. Somehow also does black magic and resets the value of '":`
        ":p "   Paste the last ex command to be run ('norm é:":p')

Esta respuesta está llena de magia negra. Las quines 1 y 4 no son nuevas, pero las otras 3 nunca se han encontrado antes, por lo que hoy se descubrió más de la mitad de estas quines.

Gelatina , _{2 3 4} 5 quines, _{14 18 81 65 59 56 326 265 247 229} 216 bytes

3 bytes

”ṘṘ

Pruébalo en línea!

Quine estándar. ”Ṙes el único carácter literal para Ṙ. Ṙimprime la representación de cadena de esta, luego la cadena Ṙse imprime implícitamente.

4 bytes

⁾⁾ḤḤ

Pruébalo en línea!

⁾comienza un literal de cadena de dos caracteres y Ḥduplica su argumento. Con una entrada de cadena, Ḥse asigna a cada carácter. Por lo tanto, Ḥactuando sobre la cadena ⁾Ḥproduce ⁾⁾ḤḤ, el código fuente.

11 bytes

ȮṾṖƊ}“ȮṾṖƊ}

Pruébalo en línea!

En el lado derecho, “ȮṾṖƊ}es la cadena literal para ȮṾṖƊ}. El carácter de cierre de cadena se agrega tácitamente en EOF.

A la izquierda del literal de cadena, se Ɗenvuelve ȮṾṖen una sola mónada y la }convierte en una díada que usa su argumento correcto, el literal de cadena. Ȯimprime la cadena ( ȮṾṖƊ}), Ṿcrea una representación de cadena de la cadena ( “ȮṾṖƊ}”) y Ṗelimina el ”carácter. La cadena “ȮṾṖƊ}se deja después de la mónada y se imprime implícitamente.

38 49 36 bytes

32,52,52,7884,106,64,44,7884 44Ọj@,Ọ

Pruébalo en línea!

La primera vez que he usado un espacio en Jelly golf.

La lista de números al principio contiene ordel resto de los caracteres en el código. Después de esto:

jṛ44Ọ$,Ọ
j           Join this list with...
 ṛ          right argument. Avoiding using ¤ so I can use it in the next program.
  44Ọ       chr(44)==',': [106, ',', ...]
     $      Causes Ọ to act on 44 before j acts on it.
      ,     Pair this list with...
       Ọ    chr of each number in the list. Yields jṛ44Ọ$,Ọ

270 198 180 162 bytes

⁽¢_;⁽⁽¤;⁽¡_;⁽⁽¡;⁽¡¤;⁽$+;⁽⁽y;⁽Ẹ$;⁽⁺$;⁽AƑ;⁽?€;⁽b⁽;⁽¢¡;⁽_⁽;⁽¡¡;⁽¤ị;⁽ØJ;⁽µṭ;⁽€⁽;⁽¡S;⁽;⁽;⁽¡ʠ;⁽¤ị;⁽ØJ;⁽¤F;⁽ḊṄ;⁽ȧF
¢_⁽¤¡_⁽¡¡¤$+⁽yẸ$⁺$AƑ?€b⁽¢¡_⁽¡¡¤ịØJµṭ€⁽¡S;⁽¡ʠ¤ịØJ¤FḊṄȧF

Pruébalo en línea!

Utiliza 250 números de base e índices en la página de códigos Jelly. Ahorró 72 bytes al cambiar el algoritmo. Estaba usando cada número para indexar en la página de códigos de Jelly, pero ahora estoy convirtiendo el entero de nuevo a la base 250 y luego indexando en la página de códigos de Jelly, básicamente reduciendo a la mitad el número de literales que necesito en la primera línea. Esto también reduce la cantidad de caracteres únicos necesarios, pero no puedo pensar en una forma de hacer más quines.

He usado los ⁾“”que crean literales de cadena Ọy los ØJque crean cadenas de números. No puedo pensar en ninguna otra forma de hacer cuerdas. Todavía tengo el dígito 9y ‘’disponible, así que si hay otra forma de hacer cadenas a partir de números, es posible hacer otra quine.

Haskell , 3 quines, 1119 bytes

Quine 1, 51 bytes

Una IOacción anónima que se imprime directamente en stdout.

putStr`mappend`print`id`"putStr`mappend`print`id`"

Pruébalo en línea!

Quine 2, 265 bytes

La función ftoma un argumento ficticio y devuelve una cadena.

f	c=[b=<<g]!!0++show	g;b	c=[[[show	9!!0,show	1!!0..]!!6..]!!c];g=[93,0,90,52,82,89,52,51,51,94,84,24,24,39,34,34,106,95,102,110,0,94,50,89,0,90,52,82,82,82,106,95,102,110,0,48,24,24,39,35,106,95,102,110,0,40,24,24,39,37,37,84,24,24,45,37,37,84,24,24,90,84,50,94,52]

Pruébalo en línea!

Quine 3, 803 bytes

Todo lo que LANGUAGEsigue al pragma es una función cualquiera que toma un argumento ficticio y devuelve una cadena.

{-#LANGUAGE CPP#-}(\q(_:_:_:_:_:_:_:_:z)y(#)_->(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z)'\''__TIME__(\(?)v k x->v$k?x)$ \(&)(%)v->v&'{'&'-'&'#'&'L'&'A'&'N'&'G'&'U'&'A'&'G'&'E'&' '&'C'&'P'&'P'&'#'&'-'&'}'&'('%'\\'&'q'&'('&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'z'&')'&'y'&'('&'#'&')'&'_'&'-'&'>'&'('&'y'&'('%'\\'&'k'&' '&'x'&'-'&'>'%'\''&'&'%'\''&':'&'q'&':'&'k'&':'&'q'&':'&'x'&')'&'#'&'y'&'('%'\\'&'k'&' '&'x'&'-'&'>'%'\''&'%'%'\''&':'&'q'&':'%'\''%'\\'%'\\'%'\''&':'&'k'&':'&'q'&':'&'x'&')'&'$'&'y'&'('&':'&')'&'#'&'y'&'('&':'&')'&'$'&' '%'\\'&'x'&'-'&'>'&'x'&')'&'z'&')'%'\''%'\\'%'\''%'\''&'_'&'_'&'T'&'I'&'M'&'E'&'_'&'_'&'('%'\\'&'('&'?'&')'&'v'&' '&'k'&' '&'x'&'-'&'>'&'v'&'$'&'k'&'?'&'x'&')'&'$'&' '%'\\'&'('&'&'&')'&'('&'%'&')'&'v'&'-'&'>'&'v'

Pruébalo en línea!

Caracteres

Quine 1:

"S`adeimnprtu

Quine 2:

	!+,.0123456789;<=[]bcfghosw

Quine 3:

 #$%&'()-:>?ACEGILMNPTU\_kqvxyz{}

Cómo funciona

Quine 1

putStr`mappend`print`id`"putStr`mappend`print`id`"

Quine 1 es una versión modificada de mi reciente Golf, una respuesta quine (con mejoras de H.PWiz):

• Como no se necesitan programas completos, main=se ha eliminado.
• <>y $han sido reemplazados por sus casi sinónimos mappendy id.

Esto libera los caracteres vitales =<>y el operador útil $para las otras quines.

Quine 2

f	c=[b=<<g]!!0++show	g;b	c=[[[show	9!!0,show	1!!0..]!!6..]!!c];g=[93,0,......]

Quine 2 utiliza métodos algo similares para programar 2 de mi respuesta reciente de Quines mutuamente excluyentes , pero adaptado para quine directamente y especialmente para evitar el uso de literales de caracteres, que son necesarios para quine 3. Ambos se logran con la ayuda de la showfunción, que por pura suerte aún no se ha utilizado ninguno de sus personajes.

Esta línea utiliza pestañas en lugar de espacios, pero he usado los espacios a continuación para facilitar la lectura.

• gson los datos de quine, como una lista de enteros al final del código. Cada número representa un carácter del resto del código.
  • Los números se desplazan por 9, de modo que la pestaña es 0. Esto hace que la codificación sea un poco más corta al permitir que las letras minúsculas para la función y los nombres de las variables quepan en 2 dígitos.
• b c=[[[show 9!!0,show 1!!0..]!!6..]!!c] es una función para convertir un número en un carácter (en realidad, una cadena de un carácter).
  • [[show 9!!0,show 1!!0..]!!6..]es un rango de caracteres que comienza con un carácter de tabulación, que se indexa con !!c.
  • El propio carácter de tabulación se produce mediante la indexación en otra gama [show 9!!0,show 1!!0..], a partir de los caracteres de dígitos '9'y '1'y saltando hacia abajo en pasos de 8.
  • Los caracteres del dígito se producen indexando en la showcadena del dígito correspondiente.
• f c=[b=<<g]!!0++show gEs la función principal. cEs un argumento ficticio.
  • b=<<gutiliza =<<para convertir cada número en gsu carácter. (El uso de, en =<<lugar de, por ejemplo, mapes el motivo por el que bdebe incluir su carácter devuelto en una lista).
  • show gda la representación de cadena de gla lista de 's, y ++concatena las cadenas.
  • Debido a que =<<tiene una precedencia más baja que ++, se necesita un paréntesis. Para evitar el uso ()(reservado para quine 3), [...]!!0indexa en una lista con un elemento.

Quine 3

Por diseño de los otros quines, el quine 3 todavía tiene acceso a paréntesis, expresiones lambda, literales de caracteres y el constructor de cadenas / listas :. Esto será suficiente para construir una función que anteponga el código del quine a una cadena.

Desafortunadamente, yse han usado todas las vocales en minúsculas (excepto algunas veces ), sin dejar funciones alfanuméricas incorporadas útiles. También []""se han ido. Esto no deja una forma normal de construir una cadena vacía para comenzar a simular el código.

Sin embargo, casi todas las letras mayúsculas todavía están disponibles, por lo que LANGUAGEes posible un pragma para obtener una extensión de idioma. Nuevamente, por pura suerte, CPP(habilitar el preprocesador C) es la única extensión de lenguaje nombrada con solo letras mayúsculas. Y las macros CPP a menudo tienen nombres en mayúscula.

Entonces, para obtener la cadena vacía esencial, la función quine habilita CPP, usa la __TIME__macro para obtener una cadena constante de la forma "??:??:??"(convenientemente garantizada que siempre tenga la misma longitud), y coincide con el patrón.

{-#LANGUAGE CPP#-}(\q(_:_:_:_:_:_:_:_:z)y(#)_->(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z)'\''__TIME__(\(?)v k x->v$k?x)$ \(&)(%)v->v&'{'&'-'&......

Después del pragma del lenguaje, la quine consiste en una expresión lambda que une sus parámetros a estos cuatro argumentos (dejando un parámetro ficticio final _que se aplicará más adelante):

• qobligado a '\'', dando una comilla simple;
• _:_:_:_:_:_:_:_:zunido a __TIME__, también conocido como una cadena "??:??:??", haciendo así zuna cadena vacía;
• yenlazado a (\(?)v k x->v$k?x), un combinador lambda usado para ayudar a convertir los datos de quine del formulario asociado a la izquierda ("foldl") al formulario asociado a la derecha ("foldr");
• El operador (#)vinculado a \(&)(%)v->v&'{'&'-'&...los datos de quine en sí.

Los datos de quine se dan en forma de codificación de Church, una expresión lambda con parámetros (&)(%)v.

• Al aplicar la expresión a valores particulares para crear instancias (&), (%)y v, esta codificación se puede usar para construir el código central de la quine o para reconstruir la representación de datos de quine en sí.
• Por la regla de fijación predeterminada de Haskell, &y se %convierten en operadores asociativos a la izquierda dentro de la lambda. Por lo tanto, los parámetros de caracteres se combinan con el vinicio inicial desde la izquierda.
• Para la mayoría de los personajes k, hay un correspondiente &'k'.
• Cuando kis 'o \, que deben escaparse dentro de los literales de caracteres, la codificación es en su lugar %'\k'.

Dado que la codificación de datos se deja asociativa, pero las cadenas se construyen de manera asociativa derecha, el combinador y = (\(?)v k x->v$k?x)se introduce para cerrar la falta de coincidencia.

• y(...)está destinado a construir funciones adecuadas para usar como datos (&)y (%)operadores de quine .
• ves una función de cadenas a cadenas (los datos de quine vson ejemplos).
• kes un personaje, xuna cadena y ?un operador que los combina en una nueva cadena. (Para el código central,. (?)=(:)Para reconstruir realmente la representación de datos de quine, es más complicado).
• Por y(?)v k = \x->v$k?xlo tanto, es otra función de cadenas a cadenas.

• Como ejemplo de cómo esto cambia la asociatividad, si (&)=y(:):

  (v&k1&k2&k3) x
  = (((v&k1)&k2)&k3) x
  = y(:)(y(:)(y(:)v k1)k2)k3 x
  = y(:)(y(:)v k1)k2 (k3:x)
  = y(:)v k1 (k2:(k3:x))
  = v (k1:(k2:(k3:x)))
  = v (k1:k2:k3:x)

En términos más generales, cuándo (#)es la función de datos de quine y f1,f2son funciones que combinan caracteres con cadenas:

(y(f1)#y(f2)$v) x
= (...(y(f1)(y(f1)v '{') '-')...) x
= v(f1 '{' (f1 '-' (... x)))

aplicando la función de datos de quine con (&)=y(f1)y (%)=y(f2), y esto usa los caracteres prescritos f1y f2para combinar los datos de quine con x, y luego pasa la cadena resultante a v.

El cuerpo de la expresión lambda principal pone todo esto junto:

(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z

• '&':q:k:q:xpara un carácter kantecede &'k'a la cadena x, mientras que '%':q:'\\':k:q:xantepone %'\k', que son sus formas originales de datos de quine
• Por y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:xlo tanto, son los parámetros correctos para reconstruir la representación de datos de quine, antepuestos al final z(la cadena vacía) y luego pasados ​​a la siguiente función.
• y(:)#y(:) son los parámetros correctos para anteponer el código central de la quine a una cadena, sin otra modificación.
• Finalmente, \x->xno puede hacer nada con la quine construida, que se devuelve.

Perl 6 , 3 quines, 274 bytes

Quine 1, 52 bytes

my&d={S{\d}=$_};say
d
Q{my&d={S{\d}=$_};say
d
Q{4}}

Pruébalo en línea!

Quine 2, 102 bytes

printf	|(q[printf	|(q[@]xx	2	Z~|(q[printf	|(q[!3]]Xx	qw[1	0]))]xx	2	Z~|(q[printf	|(q[!3]]Xx	qw[1	0]))

Pruébalo en línea!

Quine 3, 120 bytes

<'.EVAL'.UC,' GIVEN ',｢｢PRINT "<'.EVAL'.UC,' GIVEN ',｢｢".UC,.UC,"｣｣>.LC",".EVAL.EVAL".UC｣｣>.lc.EVAL.EVAL

Pruébalo en línea!

Verificación de conjuntos distintos de bytes

Hubo muchas maniobras para obtener esa tercera quine. Perl 6 tiene 4 métodos de salida (que yo sepa), say, put, printy printf. Ambas líneas de salida sayy putsalida, ya que no puedo usar ambas. put, print, printfTodos contienen py t. Podemos solucionar esto parcialmente usando EVALlas mayúsculas PRINT. A partir de ahí, no creo que sea posible obtener 4 quines ... (aunque quizás algo así shell "echo 'quine'"podría funcionar)

Luego, podemos solucionar los problemas de espacio utilizando diferentes tipos de espacios en blanco para separar operadores, espacios, pestañas y líneas nuevas.

Explicaciones:

Quine 1:

my&d={        };         # Declare a function d which 
      S{\d}=$_           # Which substitutes a digit with the string again
                say      # Print with a newline
d                        # The function
Q{my&d={S{\d}=$_};say    # Applied to the string with the program
d
Q{4}}                    # With a digit where the it should be inserted again

Quine 2:

Esta es una quine en el formato printf |(q[printf q[%s]]xx 2), es decir, formatea una copia de la cadena en sí misma. Sin embargo, no podemos usarlo, sya que se usó en las líneas anteriores say. Entonces, utilizamos el operador OR ( ~|) en la cadena @y !3, para producir la %sparte, pero no podemos hacer eso tanto en la cadena de formato como en la cadena que se va a insertar, por lo que tenemos que ver Z~con la cadena adicional y una cadena vacía, aunque no podemos usar ,para separar los dos, entonces hacemos Xx qw[1 0]multiplicar por 1 y 0 la cadena.

printf |(                                  )      # Print with formatting
         q[...]       # The string of the program
               xx 2   # Duplicated
                    Z~| (                 )     # String or'd with
                         q[...]                 # A copy to insert the %s
                                Xx              # String multiplied to
                                   qw[1 0]      # itself and an empty string

Quine 3:

Esta es una quine EVAL que hace todo lo posible para poner todo en mayúscula para evitar conflictos con las otras quines. Esto implica una gran cantidad de EVALs, así como unos pocos, lcy la ucconversión entre casos.

<...>.lc.EVAL        # Evaluate the lowercase version of the string which results in
.EVAL  given  ｢print "<'.eval'.uc,' given ',｢｢".uc,.uc,"｣｣>.lc",".eval.eval".uc｣
             .EVAL   # Evaluate again 

.EVAL  given  ｢...｣   # Set the string to $_ and pass it to .EVAL
print "<'.eval'.uc,' given ',｢｢".uc       # Print the first half of the quine uppercased
                                   ,.uc   # Print the string uppercased
                                       ,"｣｣>.lc"  # Print the .lc part lowercased
                                                ,".eval.eval".uc # Print the EVAL part uppercased

MathGolf , 4 5 6 quines, 193,535 bytes

9 bytes

ÿ'ÿ⌐_'ÿ⌐_

Pruébalo en línea!

45 bytes

û]∙ûxôû¬ûûûûû╡¬ûô╡û╡xûxxû¬ô]∙xô¬ûûû╡¬ô╡╡xxx¬ô

Pruébalo en línea!

49 bytes

ùa6æù\a\ù+6┼ù\ùùùùù\ù§\+ùΣ\Σa6æ\a\+6┼\ùùùù\§\+Σ\Σ

Pruébalo en línea!

99 bytes

"""▐ ⌠▌ ⌠▌ ⌠▌ ⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠"`~

Pruébalo en línea!

4488 bytes

♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((DÄß─·ö♠,♦M-$*DÄß─ö7($$$qq$Äq╘

Pruébalo en línea!

188,845 bytes

Realmente no puedo vincularme con este, así que aquí hay un programa Perl 6 que genera la quine real

Verificación de distinción

Definitivamente puedo sacar otra quine de esto, aunque creo que me he quedado sin formas de empujar cadenas directamente a la pila, por lo que tendré que recurrir a métodos más extraños. Métodos aún más extraños cuando intento una sexta quine. En algunos casos, las cuotas pueden ser más cortas, pero estoy reduciendo los bytes usados ​​en preparación.

De acuerdo, técnicamente podría ser capaz de hacer una quine más, ya que todavía tengo algunos operadores que necesito (cadena de inserción, cadena de incremento, duplicación, mapeo, popping), es el bucle que nos constriñe. El {}son los únicos operadores que se pueden indicar un bloque de código de longitud arbitraria, y realmente los necesitan en el sexto quine. Podría usar algunos de los otros bloques de código, pero son limitados, y dudo que las secciones de bucle sean tan cortas, ya que nos estamos quedando sin operadores fáciles.

Bien, algunas explicaciones tardías:

Todas las quines tienen casi la misma estructura:

• Empuje una cadena, o una lista de cadenas, o una lista de caracteres a la pila.
• Combina todo en una lista
• Duplicar la lista
• Mapa sobre la copia, imprimiendo / empujando los caracteres utilizados para obtener los caracteres originales
• Imprima la lista original de caracteres como una cadena

Quine 1:

Esto es básicamente lo mismo que publiqué en la pregunta normal de quine.

ÿ'ÿ⌐_'ÿ⌐_
ÿ            Push the next 4 bytes as a string
 'ÿ⌐_        Stack ["'ÿ⌐_"]
     'ÿ      Push the byte ÿ (I realise I could have used this in a later quine)
       ⌐     Rotate the ÿ to the bottom of the stack : ["ÿ", "'ÿ⌐_"]
        _    Duplicate top of stack: ["ÿ", "'ÿ⌐_", "'ÿ⌐_"]
             Implicitly print stack joined together : ÿ'ÿ⌐_'ÿ⌐_

Quine 2

û                Push the next 2 bytes as a string
 ]∙              Stack: ["]∙û"]
   û  û...      Repeat this for the rest of the code
           ]              Wrap the stack in an array : [["]∙","xô"...]]
            ∙             Triplicate                 : [[..],[..],[..]]
             x            Reverse the top array
              ô           Loop over the array, executing the next 6 instructions
                          Stack: [[..],[..],str]
               ¬          Rotate the stack : [str,[..],[..]]
                ûûû╡      Push the string "ûû" and discard the left character
                    ¬     Rotate the "û" to the bottom : ["û",str,[..],[..]]
                          This produces the initialisation part
                     ô    Loop over the array with the next 6 characters again
                      ╡╡xxx¬      Basically discard the string
                            ô     Flatten the last copy of the array onto the stack
                                  Implicitly output the code

Quine 3:

ùa6æù\a\ù+6┼ù\ùùùùù\ù§\+ùΣ\Σa6æ\a\+6┼\ùùùù\§\+Σ\Σ
ù...          Push the next 3 bytes as a string
              You know how this goes
    a         Wrap the top element in an array
     6æ       Repeat the next 4 instructions 6 times
       \      Swap the two top items
        a     Wrap the top item in an array
         \    Swap back
          +   Combine the two arrays
              This puts all the strings into a single array
           6            Push a 6
            ┼           Push the element two items down (the array)
             \          Swap with the 6 (this basically duplicates the array)
              ùùùù      Push "ùùù"
                  \§    Swap and get the 6th character (wrapping)
                    \   Swap with array : ["ù", [..]]
                     +  Prepend to array (implicitly mapping)
                      Σ\Σ     Join both the lists to strings and output

Quine 4:

"""▐ ⌠▌ ⌠▌ ⌠▌ ⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠"`~
""             Push the empty string
  "..."        Push some code : ['','...']
       `       Copy the top two elements of the stack : ['','...','','...']
        ~      Evaluate the top element as code : ['','...','']
▐              Prepend the empty string to the code
  ⌠            Push a space and increment by 2 to get a quote
   ▌           Prepend to the array
     ⌠▌ ⌠▌ ⌠   Repeat three more times, leaving the last on top : ['', '""...','"']
              ⌠⌠...       Push a space and increment until it reaches a '`'
                    ⌠⌠... Repeat for the '~' : ['','"""...','"','`','~']
                          Implicitly output

Quine 5:

♠              Push 256
 ((...         Decrement until it reaches the correct byte representing the code
               Repeat for each character of the code
      DÄ       Repeat the next instruction 14 times
        ß      Wrap the top 4 elements in an array
         ─     Flatten the resulting monstrosity
          ·    Triplicate the array
           ö   Map the next 7 instructions over the array
                      Stack : [[..],[..],num]
            ♠         Push 128
             ,        Reverse subtraction : [[..],[..],128-num
              ♦M-$    Push the ( character
                  *   Repeat it 128-num times
                   DÄß─         Gather that up in an array and flatten again
                       ö        Map the next 6 instructions
                        7($$$qq
                    7($$$q    Print a ♠, without newline
                              q   Print the brackets without newline
                                  Stack : [[..],[..]]
                               $     Map the number to their values in the code page
                                Äq   Map print over each element
                                  ╘  Discard the last element of the stack

Quine 6:

La razón de esto es quine así mucho más tiempo que los otros es que incrementando cuerdas utiliza representaciones Unicode, que es una mierda para el algunos de los caracteres en el código, especialmente cuando estamos tratando de crear el personaje ⌂en el código, que se infla el código en más de 8000 caracteres, que luego infla la parte de representación en una cantidad muy grande

⌂         Push an * character
 ))...    Increment until we reach the right character + 8
      ♫{ }            Repeat 10000 times
        α             Wrap the top two elements in an array
          ♫{     }    Then repeat 10000 times
            m{{}}     Shallowly flatten the array
                  h∞<     Double the array
                     m{          Map the doubled array to
                       ïí½<¿{    If it is the first half of the array
                             ⌂⌂  Push two asterisks
                               )))...    Increment into a '⌂' (there are something like 8000 )s here, with a couple of ! to help
                                     @   Rotate the top three elements
                                         Stack : ["⌂",char,"*"]
                                      0{     α4<{}=}←  Repeat while the asterisk is not the char
                                        ⌂⌡)   Push a )
                                           @  Rotate it under the char
                                            ) Increment the asterisk
                                                     ;;   Pop the extra copies of the character
                                                       }{  Else
                                                         ⌡⌡⌡⌡}   Subtract 8 from the character
                                                              }{}  End map and flatten array
                                                                   Print implicitly

Este último quine se reduciría significativamente si MathGolf fuera consistente en si las cadenas usaban la página de códigos nativa o no.

Python 2, 2, quines 434 353 349 446 bytes

Esto fue principalmente para ver si podía hacerlo en Python.

30 bytes (incluida una nueva línea final):

z='z=%r;print z%%z';print z%z

y 416 bytes, sin nueva línea final:

exec"696d706f7274207379730a793d222222696d706f7274207379730a793d7b7d0a7379732e7374646f75742e777269746528276578656322272b792e666f726d6174282722272a332b792b2722272a33292e656e636f6465282268657822292b27222e6465636f64652822686578222927292222220a7379732e7374646f75742e777269746528276578656322272b792e666f726d6174282722272a332b792b2722272a33292e656e636f6465282268657822292b27222e6465636f6465282268657822292729".decode("hex")

(Golfed 81 bytes gracias a Lynn pero agregó una carga debido a la preocupación por la nueva línea).

Explicación

El primero es solo la quine corta estándar de Python , pero modificada para no usar _. Como se trata de Python 2, tampoco usa (o ).

El segundo pensó un poco. La cadena larga se codifica utilizando el hexcódec (lo que garantiza que solo contendrá 0- 9y a- f) y se decodifica como

import sys
y="""import sys
y={}
sys.stdout.write('exec"'+y.format('"'*3+y+'"'*3).encode("hex")+'".decode("hex")')"""
sys.stdout.write('exec"'+y.format('"'*3+y+'"'*3).encode("hex")+'".decode("hex")')

Esto utiliza el truco de quine para obtener su propio código fuente, luego lo codifica usando hex_codec, y luego lo imprime rodeado exec"".decode("hex"), sys.stdout.writepara evitar imprimir una nueva línea. La ejecución de este código genera el segundo quine, que es cómo lo generé.

Sospecho que más de dos son imposibles en Python, ¡aunque me gustaría verlo si me equivoco!

Si no te importa evaluar quines

Ørjan Johansen sugirió lo siguiente para la segunda quine precodificada

y="""import sys
sys.stdout.write('exec"'+('y='+'"'*3+y+'"'*3+';exec y').encode("hex")+'".decode("hex")')""";exec y

que obtendría 30 + 248 = 278 bytes para la siguiente salida:

exec"793d222222696d706f7274207379730a7379732e7374646f75742e777269746528276578656322272b2827793d272b2722272a332b792b2722272a332b273b65786563207927292e656e636f6465282268657822292b27222e6465636f64652822686578222927292222223b657865632079".decode("hex")

El uso de execesta manera no es hacer trampa de acuerdo con las reglas de quine adecuadas de PPCG , pero me parece algo engañoso (elegante e inteligente, pero aún así es engañoso), porque algunos caracteres se utilizan como código y datos. (Aunque mi versión sí usa exec, el código y los datos están separados). Así que mantendré mi puntaje en 446.

Japt , 2 3 quines, 106 172 bytes

La primera es una versión bastante detallada de mi respuesta N char quine .

[91,57,49,100,185,44,85,44,186,57,51,100,185,44,186,49,48,100,185,44,186,85,109,100,185,172,93,172]
[91d¹,U,º93d¹,º10d¹,ºUmd¹¬]¬

Probar aquí .

La segunda quine es la quine más buena de ETHProduction , que es una buena quine estándar para Japt.

"iQ ²"iQ ²

Probar aquí .

El tercero usa un ``código de caracteres XORing para almacenar los datos.

T=`f=fR;Zff-R-ReX%`;`T=\``+T+Tc^#

Probar aquí .

Dado que ()'todavía están disponibles, que podría ser posible exprimir una quine más.

Gol> <> , ₂ 3 quines, _{17 28 27} 26 bytes

6 bytes

"r2ssH

Pruébalo en línea!

_{11 10} 9 bytes

'3d*Wo{|;

Pruébalo en línea!

11 bytes

Eh`#Ma0piS0

Pruébalo en línea!

Gol> <> tiene tres formas de imprimir cualquier carácter:

• o Pop un valor e imprimir como char
• H Pop todo, imprimir como char, y detener
• S"..." Imprimir literal de cadena sin afectar la pila en absoluto

Pero no pude encontrar una manera de escribir un quine usando S"..."como único método de salida, así que se me ocurrieron los dos anteriores, utilizando los dos tipos de literales de cadena.

El tercero (por Jo King) usa el pcomando para crear el "in S"sobre la marcha, que a su vez imprime todo excepto el cero al final. Luego Ehimprime el cero y sale.

Ahora que utilizamos todos los comandos de salida Y el pcomando, creo que es imposible crear otra quine (a menos que alguien presente la S"quine sin ella p).

Ruby , 2 quines, 27 + 44 = 71 bytes

$><<<<2*2<<2
$><<<<2*2<<2
2

Pruébalo en línea!

s=%q{s=%q{S};s[?S]=s;puts s};s[?S]=s;puts s

Pruébalo en línea!

Estoy principalmente limitado por los métodos de salida, aquí. Hay bastantes formas de manipular cadenas, pero aparte de $><<todos los métodos de salida utilizables, parecen cruzarse demasiado. Creo que podría haber una salida, evalpero es complicado tener que anidar múltiples manipulaciones de cadenas de diferentes tipos.

Javascript ES6, 2 quines, 43 + 22 = 65 bytes

Quine 1:

(function f(){return[,f,'))'].join('(')}())

Quine 2:

g=z=>"g="+g+";g``";g``

> <> , 2 quines, 8 + 16 = 24 bytes

8 bytes

#o<}-1:"

Pruébalo en línea!

Tomado de esta respuesta .

16 bytes

'r3d*d8*7+e0p>>|

Pruébalo en línea!

Esto se basa en la 'r3d*>o<quine, excepto oy <no se puede utilizar, por lo que sustituye <con |y crea dinámicamente o(111 = 8 * 13 + 7) y la coloqué en el que el segundo >es.

2 quines es el límite

Desafortunadamente, estamos limitados por la cantidad de comandos de salida. nno es útil porque solo genera números, por lo que odebe ejecutarse en cualquier quine. La única forma de crear dinámicamente oes con p. Entonces, una quine puede usar oy otra puede crearla p, pero no puede haber una tercera quine.

Es posible que una tercera quine deje el código fuente en la pila si eso cuenta.

Java 10, 2 quines, 1448 1248 bytes

1350 1122 bytes

\u0076\u002D\u003E\u007B\u0076\u0061\u0072\u0020\u0072\u003D\u0022\u0076\u002D\u003E\u007B\u0076\u0061\u0072\u0020\u0072\u003D\u0025\u0063\u0025\u0073\u0025\u0031\u0024\u0063\u003B\u0072\u002E\u0066\u006F\u0072\u006D\u0061\u0074\u0028\u0072\u002C\u0033\u0034\u002C\u0072\u002C\u0039\u0032\u0029\u002E\u0063\u0068\u0061\u0072\u0073\u0028\u0029\u002E\u0066\u006F\u0072\u0045\u0061\u0063\u0068\u0028\u0063\u002D\u003E\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0066\u0028\u0025\u0031\u0024\u0063\u0025\u0063\u0025\u0033\u0024\u0063\u0075\u0025\u0025\u0030\u0034\u0058\u0025\u0031\u0024\u0063\u002C\u0063\u0029\u0029\u003B\u007D\u0022\u003B\u0072\u002E\u0066\u006F\u0072\u006D\u0061\u0074\u0028\u0072\u002C\u0033\u0034\u002C\u0072\u002C\u0039\u0032\u0029\u002E\u0063\u0068\u0061\u0072\u0073\u0028\u0029\u002E\u0066\u006F\u0072\u0045\u0061\u0063\u0068\u0028\u0063\u002D\u003E\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0066\u0028\u0022\u005C\u005C\u0075\u0025\u0030\u0034\u0058\u0022\u002C\u0063\u0029\u0029\u003B\u007D

Pruébalo en línea.

Equivalente a:

v->{var r="v->{var r=%c%s%1$c;r.format(r,34,r,92).chars().forEach(c->System.out.printf(%1$c%c%3$cu%%04X%1$c,c));}";r.format(r,34,r,92).chars().forEach(c->System.out.printf("\\u%04X",c));}

Explicación:

v->{                   // Method with empty unused parameter and no return-type
  var r="v->{var r=%c%s%1$c;r.format(r,34,r,92).chars().forEach(c->System.out.printf(%1$c%c%3$cu%%04X%1$c,c));}";
                       //  Unformatted source code
  r.format(r,34,r,92)  //  Formatted quine
   .chars()            //  Loop over the characters as integers
   .forEach(c->System.out.printf("\\u%04X",c));}
                       //   Print "\u" with hexadecimal value of these characters

126 bytes

v->{int i='}'-'[';var s="v->{int i='}'-'[';var s=%c%s%c;System.console().printf(s,i,s,i);}";System.console().printf(s,i,s,i);}

System.console()regresará nullcuando no se proporcione ninguno, por lo que TIO devuelve un NullPointerExceptionen este caso .

Para probar que es una quine funcional, reemplácela System.console()con System.out: Pruébelo en línea.

Explicación:

v->{              // Method with empty unused parameter and no return-type
  int i='}'-'[';  //  Integer `i` = 34 (unicode value for double-quote)
  var s="v->{int i='}'-'[';var s=%c%s%c;System.console().printf(s,i,s,i);}";
                  //  Unformatted source code
  System.console().printf(s,i,s,i);}
                  //  Print formatted quine

Explicación general:

En Java, una quine se suele hacer así:

• El String scontiene el código fuente sin formato.
• %sse utiliza para ingresar esta cadena en sí misma con el s.format(...).
• %c, %1$cy 34se usan para formatear las comillas dobles.
• s.format(s,34,s) lo pone todo junto

En cuyo caso, la función lambda quine más corta en Java 10 sería esta ( 82 bytes ):

v->{var s="v->{var s=%c%s%1$c;return s.format(s,34,s);}";return s.format(s,34,s);}

Pruébalo en línea.

Dado que la única forma de tener dos quines en Java es usar la versión Unicode con \uHEXA, que se convierte en caracteres durante la compilación, no puedo usar los caracteres 0123456789ABCDEF\uen la versión no Unicode. Entonces, la versión más pequeña no unicode usará en System.console()lugar de returno System.out(ambas contienen una 'u'), y usará '}'-'['y dos veces en %clugar de 34y %1$c.

Algunas cosas a tener en cuenta sobre la versión Unicode:

• Estoy a propósito usando en %04Xlugar de %04x(para mayúsculas hexadecimales en lugar de minúsculas).
• Estoy usando 92, %cy %3$cpara formatear las barras.
• Aparentemente, no se permite el uso de mayúscula \Uen minúscula \u, de lo contrario, lo habría utilizado returnen la versión más corta no unicode.