Tivemos muitos desafios de quine , mas muitos dos formatos de quine são semelhantes, vamos criar alguma variação em nossos quines.

Sua tarefa é criar uma seleção de programas no mesmo idioma (pelo menos 2), todos com saída de seu próprio código-fonte; no entanto, nenhum desses programas pode compartilhar caracteres.

Por exemplo, se você criar um programa usando:

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

Seu próximo programa não pode incluir nenhum dos seguintes:

%()+2finpqrstwx

e assim por diante.

Regras

• Você pode usar caracteres unicode, mas ainda deve pontuar em bytes.
• Todos os programas devem atender à definição da comunidade de uma solução adequada . Isso significa que a cadeia vazia não conta como uma solução válida, entre outras coisas.
• As brechas padrão são proibidas.
• Funções ou programas completos são permitidos desde que atendam à definição acima.
• Os idiomas independentes de símbolos (incluindo Lenguage e Headsecks) não são permitidos.
• A maioria dos programas vence, com o menor código total como desempate.

V , 3 , 5 quines, 46 bytes

2A2A

Experimente online!

Hexdump:

00000000: 3241 3241                                2A2A

Explicação:

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

5­­­a5­­­a

Experimente online!

Hexdump:

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

Explicação:

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

1«I1«I

Experimente online!

Hexdump:

00000000: 31ab 4931 ab49                           1.I1.I

Explicação:

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

Aqui é onde eles começam a ficar descolados ...

ñi34x@-qPÉÑ~ÿ

Experimente online!

Hexdump:

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

Explicação:

ñ                       " 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

Experimente online!

Hexdump:

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

Explicação:

: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 resposta é preenchida com magia negra. Os Quines 1 e 4 não são novos, mas os outros 3 nunca foram encontrados antes, então mais da metade desses quines foram descobertos hoje.

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

3 bytes

”ṘṘ

Experimente online!

Quine padrão. ”Ṙé o literal de um caractere para Ṙ. Ṙimprime a representação de string disso, em seguida, a string Ṙé impressa implicitamente.

4 bytes

⁾⁾ḤḤ

Experimente online!

⁾inicia um literal de cadeia de dois caracteres e Ḥdobra seu argumento. Com uma entrada de string, Ḥé mapeado para cada caractere. Assim, Ḥatuando na cadeia ⁾Ḥproduz ⁾⁾ḤḤo código fonte.

11 bytes

ȮṾṖƊ}“ȮṾṖƊ}

Experimente online!

No lado direito, “ȮṾṖƊ}está a string literal para ȮṾṖƊ}. O caractere de fechamento da sequência é adicionado tacitamente ao EOF.

À esquerda da string literal, Ɗagrupa-se ȮṾṖem uma única mônada e a }transforma em uma díade que usa o argumento correto, a string literal. Ȯimprime a string ( ȮṾṖƊ}), Ṿcria uma representação de string ( “ȮṾṖƊ}”) e Ṗremove o ”caractere. A sequência “ȮṾṖƊ}é deixada após a mônada e é impressa implicitamente.

38 49 36 bytes

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

Experimente online!

Primeira vez que usei um espaço no golfe Jelly.

A lista de números no início contém ordo restante dos caracteres no código. Depois disso:

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

Experimente online!

Usa números e índices de base 250 na página de códigos Jelly. Economizou 72 bytes alterando o algoritmo. Estava usando cada número para indexar na página de código de Jelly, mas agora estou convertendo o número inteiro de volta para a base 250 e depois indexando para a página de código de Jelly, basicamente diminuindo pela metade o número de literais de que preciso na primeira linha. Isso também reduz o número de caracteres únicos necessários, mas não consigo pensar em uma maneira de fazer mais quines.

Eu usei ⁾“”quais criam literais de strings Ọe ØJquais criam strings a partir de números. Não consigo pensar em nenhuma outra maneira de criar strings. Eu ainda tenho o dígito 9e está ‘’disponível, portanto, se houver outra maneira de criar strings a partir de números, poderá ser possível criar outra solução.

Haskell , 3 quines, 1119 bytes

Quine 1, 51 bytes

Uma IOação anônima que imprime diretamente no stdout.

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

Experimente online!

Quine 2, 265 bytes

A função fpega um argumento fictício e retorna uma string.

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]

Experimente online!

Quine 3, 803 bytes

Tudo depois do LANGUAGEpragma é uma função desagradável, que pega um argumento fictício e retorna uma string.

{-#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'

Experimente online!

Personagens

Quine 1:

"S`adeimnprtu

Quine 2:

	!+,.0123456789;<=[]bcfghosw

Quine 3:

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

Como funciona

Quine 1

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

Quine 1 é uma versão modificada do meu recente Golf, uma resposta quine (com melhorias de H.PWiz):

• Como os programas completos não são necessários, main=foi removido.
• <>e $foram substituídos por seus quase sinônimos mappende id.

Isso libera os caracteres vitais =<>e o operador útil $para as outras peças.

Quine 2

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

O Quine 2 usa métodos semelhantes para programar 2 da minha recente resposta mutuamente exclusiva do Quines , mas adaptado para se ajustar diretamente e especialmente para evitar o uso de caracteres literais, necessários para o quine 3. Ambos são alcançados com a ajuda da showfunção, que por pura sorte ainda não teve nenhum de seus personagens.

Esse quine usa guias em vez de espaços, mas usei os espaços abaixo para facilitar a leitura.

• gsão os dados quine, como uma lista de números inteiros no final do código. Cada número representa um caractere do restante do código.
  • Os números são alterados 9, de modo que a guia é 0. Isso torna a codificação um pouco mais curta, permitindo que as letras minúsculas da função e dos nomes das variáveis ​​caibam em 2 dígitos.
• b c=[[[show 9!!0,show 1!!0..]!!6..]!!c] é uma função para converter um número em um caractere (na verdade, uma cadeia de um caractere).
  • [[show 9!!0,show 1!!0..]!!6..]é um intervalo de caracteres que começa com um caractere de tabulação indexado em !!c.
  • O próprio caracter separador é produzido por indexar para outra gama [show 9!!0,show 1!!0..], começando com os caracteres de dígitos '9'e '1'e salta para baixo em intervalos de 8.
  • Os caracteres do dígito são produzidos pela indexação na showsequência do dígito correspondente.
• f c=[b=<<g]!!0++show gé a função principal. cé um argumento fictício.
  • b=<<gusa =<<para converter cada número em gseu caractere. (O uso de, =<<e não por exemplo, mapé o motivo pelo qual ele bprecisa agrupar seu caractere retornado em uma lista.)
  • show gfornece a representação da glista de ++strings e concatena as strings.
  • Como =<<tem precedência menor que ++, é necessário algum bracketing. Para evitar o uso ()(reservado para o quine 3), [...]!!0indexe em uma lista com um elemento.

Quine 3

Por design dos outros quines, o quine 3 ainda tem acesso a parênteses, expressões lambda, literais de caracteres e o construtor string / list :. Isso será suficiente para construir uma função que precede o código do quine a uma string.

Infelizmente, todas as vogais em letras minúsculas (exceto algumas vezes y) foram usadas, não deixando funções internas alfanuméricas úteis. Também []""se foram. Isso não deixa uma maneira normal de construir uma string vazia para começar a fingir o código.

No entanto, quase todas as letras maiúsculas ainda estão disponíveis, portanto, LANGUAGEé possível um pragma para obter uma extensão de idioma. Novamente, por pura sorte, CPP(ativar o pré-processador C) é a única extensão de idioma nomeada apenas com letras maiúsculas. E macros CPP geralmente têm nomes em maiúsculas.

Portanto, para obter a string vazia essencial, o quine ativa CPP, usa a __TIME__macro para obter uma constante de string da forma "??:??:??"(convenientemente garantido que sempre tenha o mesmo comprimento) e as correspondências de padrões nela.

{-#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&'{'&'-'&......

Após o pragma da linguagem, o quine consiste em uma expressão lambda vinculando seus parâmetros a esses quatro argumentos (deixando um parâmetro fictício final _para ser aplicado posteriormente):

• qvinculado a '\'', fornecendo um caractere de aspas simples;
• _:_:_:_:_:_:_:_:zobrigado a __TIME__, também conhecido como uma string "??:??:??", criando assim zuma string vazia;
• yligado a (\(?)v k x->v$k?x), um combinador lambda usado para ajudar a converter os dados do quine da forma associada à esquerda ("foldl") para a forma associada à direita ("foldr");
• O operador (#)vinculado a \(&)(%)v->v&'{'&'-'&..., os próprios dados quine.

Os dados quine são fornecidos em uma forma de codificação da Igreja, uma expressão lambda com parâmetros (&)(%)v.

• Aplicando a expressão a valores específicos para instanciar (&), (%)e v, essa codificação pode ser usada para construir o código principal do quine ou para reconstruir a própria representação de dados do quine.
• Pela regra de fixidez padrão de Haskell, torne &- %se operadores associativos deixados dentro do lambda. Assim, os parâmetros dos caracteres são combinados com o inicial vinicial da esquerda.
• Para a maioria dos caracteres k, existe um correspondente &'k'.
• Quando ké 'ou \, que precisa ser escapado dentro dos literais de caracteres, a codificação é alternativa %'\k'.

Como a codificação de dados é deixada associativa, mas as seqüências são construídas da maneira associativa correta, o combinador y = (\(?)v k x->v$k?x)é introduzido para preencher a incompatibilidade.

• y(...)destina-se a criar funções adequadas para uso como dados (&)e (%)operadores do quine .
• vé uma função de cadeias de caracteres para cadeias de caracteres (os dados pretendidos do quine vsão exemplos).
• ké um caractere, xuma sequência e ?um operador que os combina em uma nova sequência. (Para o código principal (?)=(:). Para realmente reconstruir a representação de dados quine, é mais complicado.)
• Assim y(?)v k = \x->v$k?xé outra função de strings para strings.

• Como um exemplo de como isso muda a associatividade, se (&)=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)
  

De maneira mais geral, quando (#)é a função de dados quine e f1,f2são funções que combinam caracteres com seqüências de caracteres:

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

aplicar a função de dados quine com (&)=y(f1)e (%)=y(f2), e isso usa o prescrito f1e f2para combinar os caracteres dos dados quine com xe, em seguida, passa a sequência resultante para v.

O corpo da expressão principal lambda reúne tudo isso:

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

• '&':q:k:q:xpara um caractere kprecede &'k'a sequência x, enquanto '%':q:'\\':k:q:xprecede %'\k', que são seus formulários originais de dados quine.
• Assim, y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:xsão os parâmetros corretos para reconstruir a representação de dados quine, anexados à final z(a sequência vazia) e depois transmitidos à função a seguir.
• y(:)#y(:) são os parâmetros corretos para acrescentar o código principal do quine a uma string, sem outra modificação.
• Finalmente, o \x->xque não faz nada com o quine construído, que é retornado.

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}}

Experimente online!

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]))

Experimente online!

Quine 3, 120 bytes

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

Experimente online!

Verificação de conjuntos distintos de bytes

Houve muitas manobras na obtenção do terceiro quine. Perl 6 tem 4 métodos de saída (que eu saiba), say, put, printe printf. Ambas saye putnovas linhas de saída, pois não posso usar as duas. put, print, printfTodos contêm pe t. Podemos contornar isso parcialmente usando EVALpara usar maiúsculas PRINT. A partir daí, acho que não é possível obter 4 quines ... (embora talvez algo como shell "echo 'quine'"possa funcionar)

Podemos então resolver problemas de espaçamento usando diferentes tipos de espaço em branco para separar operadores, espaços, guias e novas linhas.

Explicações:

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:

Isso é um quine no formato printf |(q[printf q[%s]]xx 2), ou seja, formata uma cópia da string em si mesma. No entanto, não podemos usar, suma vez que isso é usado no quine anterior say. Então, usamos a string OR operator ( ~|) em @e !3, para produzir a %speça, mas não podemos fazer isso com a string de formato e a string a ser inserida, por isso temos a ver Z~com a string extra e uma string vazia, embora não possamos usar ,para separar os dois, fazemos isso Xx qw[1 0]para multiplicar por 1 e 0.

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:

Este é um quine EVAL que tenta o máximo possível para tornar tudo maiúsculo para evitar conflitos com os outros quines. Trata-se de um monte de EVALs, bem como muito poucos lce ucconverter entre os 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

ÿ'ÿ⌐_'ÿ⌐_

Experimente online!

45 bytes

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

Experimente online!

49 bytes

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

Experimente online!

99 bytes

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

Experimente online!

4488 bytes

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

Experimente online!

188.845 bytes

Eu realmente não posso vincular a este, então aqui está um programa Perl 6 que gera a solução atual

Verificação da distinção

Definitivamente, posso extrair outra solução disso, embora eu ache que tenha ficado sem meios de empurrar as cordas diretamente para a pilha, então terei que recorrer a métodos mais estranhos. Métodos ainda mais estranhos são recebidos enquanto eu tento uma sexta dose. Em alguns casos, os quines podem ser mais curtos, mas estou reduzindo os bytes usados ​​na preparação.

Tudo bem, tecnicamente eu posso ser capaz de fazer mais uma solução, já que ainda tenho alguns operadores necessários (cadeia de push, cadeia de incremento, duplicação, mapeamento, popping), é o loop que nos restringe. Os {}únicos operadores que podem indicar um bloco de código de tamanho arbitrário, e eu realmente preciso deles no 6º quine. Eu poderia usar alguns dos outros blocos de código, mas eles são limitados, e duvido que as seções de loop sejam tão curtas, já que estamos ficando sem operadores fáceis.

Ok, algumas explicações tardias:

Todos os quines têm quase a mesma estrutura:

• Empurre uma sequência ou lista de sequências ou lista de caracteres para a pilha.
• Combine tudo em uma lista
• Duplicar a lista
• Mapeie a cópia, imprimindo / pressionando os caracteres usados ​​para obter os caracteres originais
• Imprimir a lista original de caracteres como uma sequência

Quine 1:

É basicamente o mesmo que eu postei na pergunta normal do 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:

A razão deste Quine é assim muito mais tempo do que os outros é que incrementar cordas usa representações Unicode, que realmente é uma porcaria para a alguns dos personagens no código, especialmente quando estamos a tentar criar o personagem ⌂no código, que infla o código por mais de 8000 caracteres, que aumentam a parte da representação em uma quantidade muito 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

Esse último quine seria reduzido significativamente se o MathGolf fosse consistente se as strings usavam a página de código nativa ou não.

Python 2, 2 quines, 434 353 349 446 bytes

Isso foi principalmente apenas para ver se eu poderia fazê-lo em Python.

30 bytes (incluindo uma nova linha à direita):

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

e 416 bytes, sem nova linha à direita:

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

(Golpeou 81 bytes graças a Lynn, mas adicionou uma carga devido a se preocupar com a nova linha.)

Explicação

O primeiro é apenas o quine curto padrão do Python , mas modificado para não ser usado _. Como esse é o Python 2, ele também não usa (ou ).

O segundo pensou um pouco. A cadeia longa é codificada usando o hexcodec (garantindo assim que ele conterá apenas 0- 9e a- f) e decodifica conforme

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")')

Isso usa truques de quine para obter seu próprio código-fonte, depois codifica-o usando hex_codece depois imprime-o ao redor exec"".decode("hex"), usando-o sys.stdout.writepara evitar a impressão de uma nova linha. A execução desse código gera o segundo quine, que é como eu o gerei.

Suspeito que mais de dois sejam impossíveis no Python, embora eu gostaria de ver se estou errado!

Se você não se importa com as avaliações

Ørjan Johansen sugeriu o seguinte para o segundo quine pré-codificado

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

que pontuaria 30 + 248 = 278 bytes para a seguinte saída:

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

O uso execdessa maneira não é trapacear de acordo com as regras de quine apropriadas do PPCG, mas me parece um pouco barato (elegante e inteligente, mas ainda barato), porque alguns caracteres estão sendo usados ​​como código e dados. (Embora minha versão use exec, o código e os dados são separados.) Portanto, vou manter minha pontuação em 446.

Japt , 2 3 quines, 106 172 bytes

O primeiro é uma versão bastante detalhada da minha resposta ao 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¹¬]¬

Experimente aqui .

O segundo quine é o maior quine bom da ETHProduction , que é um bom quine padrão para Japt.

"iQ ²"iQ ²

Experimente aqui .

O terceiro usa ``e codifica o código XORing para armazenar os dados.

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

Experimente aqui .

Como ()'ainda estão disponíveis, pode ser possível extrair mais uma solução.

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

6 bytes

"r2ssH

Experimente online!

_{11 10} 9 bytes

'3d*Wo{|;

Experimente online!

11 bytes

Eh`#Ma0piS0

Experimente online!

Gol> <> tem três maneiras de imprimir qualquer caractere:

• o Pop um valor e imprimir como char
• H Estale tudo, imprima como char e pare
• S"..." Imprimir literal da string sem afetar a pilha

Mas não consegui encontrar uma maneira de escrever um quine usando S"..."como o único método de saída, então criei os dois acima, utilizando os dois tipos de literais de string.

O terceiro (de Jo King) usa o pcomando para criar o "in S"-the-fly, que por sua vez imprime tudo, exceto o zero no final. Em seguida, Ehimprime o zero e sai.

Agora que usamos todos os comandos de saída E o pcomando, acredito que seja impossível criar outro quine (a menos que alguém venha com o S"quine sem p).

Ruby , 2 quines, 27 + 44 = 71 bytes

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

Experimente online!

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

Experimente online!

Estou limitado principalmente por métodos de saída, aqui. Existem várias maneiras de manipular seqüências de caracteres, mas além de $><<todos os métodos de saída utilizáveis, eles parecem se cruzar demais. Eu acho que pode haver uma saída, evalmas é complicado ter que aninhar várias manipulações de strings 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:"

Experimente online!

Retirado desta resposta .

16 bytes

'r3d*d8*7+e0p>>|

Experimente online!

Esta baseia-se no 'r3d*>o<quine, excepto oe <não pode ser utilizado, portanto, I substituídos <com |e criado dinamicamente o(111 = 8 * 13 + 7) e colocou-a em que o segundo >é.

2 quines é o limite

Infelizmente, estamos limitados pelo número de comandos de saída. nnão é útil porque só gera números; portanto, odeve ser executado em qualquer quine. A única maneira de criar dinamicamente oé com p. Portanto, um quine pode usar oe outro pode criá-lo p, mas não pode haver um terceiro quine.

Pode ser possível que um terceiro quine deixe o código-fonte na pilha, se isso for importante.

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

Experimente online.

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

Explicação:

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()retornará nullquando nenhum for fornecido; portanto, o TIO retornará a NullPointerExceptionnesse caso .

Para provar que é uma solução funcional, substitua System.console()por System.out: Experimente online.

Explicação:

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

Explicação geral:

Em Java, um quine geralmente é feito assim:

• O String scontém o código fonte não formatado.
• %sé usado para inserir esta String em si mesma com o s.format(...).
• %c, %1$cE 34são usados para formatar as aspas.
• s.format(s,34,s) coloca tudo junto.

Nesse caso, a função lambda quine mais curta no Java 10 seria 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);}

Experimente online.

Como a única maneira de ter dois quines em Java é usar a versão unicode com \uHEXA, que é convertida em caracteres durante a compilação, não consigo usar os caracteres 0123456789ABCDEF\una versão não unicode. Portanto, a versão menor não unicode usará em System.console()vez de returnou System.out(ambos contendo um 'u') e usará '}'-'['duas vezes em %cvez de 34e %1$c.

Algumas coisas a serem observadas sobre a versão unicode:

• Estou de propósito usando em %04Xvez de %04x(para maiúsculas hexadecimal em vez de minúsculas).
• Eu estou usando 92, %ce %3$cpara formatar as barras.
• Usar uma capital em \Uvez de minúscula \unão é permitido, aparentemente, caso contrário, eu teria usado apenas returnna versão mais curta, não unicode.