Quines mutuamente exclusivos


27

Seu desafio é simples. Escreva dois programas que não compartilhem caracteres que tenham saída um do outro.

Exemplo

Dois programas P e Q são quines mutuamente exclusivos se:

  1. Saídas P Q
  2. Q produz P
  3. Não existe um caractere c que pertença a P e Q
  4. Cada programa P e Q são quines adequados
    1. Isso considera quines vazios e quines que lêem seu próprio código-fonte (ou o do outro) como inválido .

Mais regras

  • O menor comprimento combinado desses programas vence. Ou seja, tamanho ( P ) + tamanho ( Q ) é a sua pontuação, e a pontuação mais baixa vence.
  • Ambos os programas estão no mesmo idioma
  • Cada programa pode ser um programa ou função completo e não precisa ser o mesmo.
    • Por exemplo, P pode ser um programa completo e Q pode ser uma função.

Verificação

Este Experimente online! O snippet aqui pode verificar se dois programas são ou não mutuamente exclusivos. As entradas são colocadas nos dois primeiros argumentos.




3
Eu presumo que dois programas que lêem a fonte um do outro também sejam banidos.
Giuseppe

2
Eu adoraria ver uma resposta não esolang para esse desafio. (Pensei um pouco sobre como fazer isso, mas até agora não vi uma maneira. Pode ser possível no Forth, pois não diferencia maiúsculas de minúsculas e não depende muito de caracteres não alfabéticos. )
Nathaniel

1
Se eu posso passar o mesmo argumento, não para os próprios programas, mas para o compilador de ambos os programas. Normalmente, os sinalizadores do compilador são permitidos se você pagar por eles, mas, para esse desafio, você pode argumentar que é contrário à regra mutuamente exclusiva.
precisa saber é

Respostas:


37

> <> , Pontuação: 41 + 41 = 82

Editar: ambos continham um 3. Corrigido

'd3*}>a!o-!<<8:5@lI55>@z:5ll55>>q:>|q::|,

e

"r00gr40g44++bb+0p64++?b6+0.22#eW4s )Z

Experimente online! (troque as linhas para obter a outra saída) Com a verificação desta vez!

><>é uma linguagem especialmente difícil de usar aqui, como há apenas uma maneira de caracteres de saída, o comando o. Felizmente, podemos usar o comando p ut para colocar um ono código-fonte durante a execução, como na minha resposta de Programação em um mundo intocado .

Este levou muitas tentativas e erros. Comecei com os dois programas mutuamente exclusivos:

'd3*}>N!o-!<<data

e

"r00gr40g8+X0pN+?Y0.data

Cada um se transforma e seus dados por N, o primeiro subtraindo e o segundo adicionando. Em seguida, o resultado é inverso. O ponto é que os dados após cada programa são o outro programa em sentido inverso, deslocados por N. ( Xé o número da célula onde o programa precisa colocar a otecla e Y é a célula na qual o ponteiro volta para. ?É onde ela oé colocada) .

Ambos seguem a mesma estrutura, representada de maneiras diferentes. Eles executam uma string literal sobre todo o código, adicionando-o à pilha. Eles recriam o comando literal de cadeia de caracteres que eles usaram e o colocam na parte inferior da pilha. Eles passam pela pilha, adicionando / subtraindo N a cada caractere e imprimindo-os.

O primeiro programa usa 'como a string literal e o simples d3*}de criar o valor 39 e empurrá-lo para o final da pilha. O segundo usa "como a string literal com a mesma função. Ele reverses a pilha, gets o caractere na célula 0,0 e inverte a pilha novamente. Em seguida, ele gdefine o valor na célula 4,0 ( g) e adiciona 8 a ele para obter oe coloca isso em X.

Ambos os programas usam um método diferente de loop. O primeiro programa usa o comando skip ( !) para executar apenas metade das instruções enquanto vai para a esquerda, inverte a direção e executa a outra metade. O segundo usa o comando jump ( .) para retroceder para o início do loop na célula Y. Ambos são executados até que não haja mais itens na pilha e os erros do programa.

Eu tive vários problemas com a maioria dos valores mais baixos de N, porque a troca de um caractere o tornaria outro caractere essencial para esse programa (e, portanto, não poderia ser usado como dados para o outro programa) ou dois caracteres do dois programas mudariam para o mesmo personagem. Por exemplo:

  1. ++1 = ,= --1
  2. .+2 = 0
  3. *= --3
  4. g+4 = k= o-4

etc.

Finalmente cheguei a 10 ( a), onde consegui evitar esses problemas. Pode haver uma versão mais curta em que os turnos são revertidos e o primeiro programa está adicionando N enquanto o segundo o subtrai. Isso pode ser pior, porém, como o primeiro programa geralmente está na extremidade inferior da escala ASCII, é melhor subtrair para evitar conflitos.


19

Quarto (gforth little-endian de 64 bits) , 428 + 637 = 1065 bytes

s"	:	l	bl	-	;	:	m	l	emit	;	:	s	space	;	:	z	m	m	m	m	s	;	:	p	.	't	'i	'm	'e	z	;	'e	'r	'e	'h	z	:	q	>r	char	l	bl	l	do	dup	@	.	'L	m	s	cell+	loop	r>	.	;	:	n	'e	'p	'y	't	z	;	q	;	's	p	'B	l	p	#tab	p	'p	'u	'd	'Q	char+	z	n	'B	l	p	n":	l	bl	-	;	:	m	l	emit	;	:	s	space	;	:	z	m	m	m	m	s	;	:	p	.	't	'i	'm	'e	z	;	'e	'r	'e	'h	z	:	q	>r	char	l	bl	l	do	dup	@	.	'L	m	s	cell+	loop	r>	.	;	:	n	'e	'p	'y	't	z	;	q	;	's	p	'B	l	p	#tab	p	'p	'u	'd	'Q	char+	z	n	'B	l	p	n
HERE 3245244174817823034 , 7784873317282429705 , 665135765556913417 , 7161128521877883194 , 682868438367668581 , 679209482717038957 , 680053688600562035 , 678116140452874542 , 682868623551327527 , 680649414991612219 , 682868636436227367 , 7136360695317203258 , 7809815063433470312 , 8458896374132993033 , 5487364764302575984 , 7810758020979846409 , 680166068077538156 , 4181938639603318386 , 8081438386390920713 , 8793687458429085449 , 2812844354006760201 , 7784826166316108147 , 676210045490917385 , 681493840106293616 , 7521866046790788135 , 679491013524025953 , 7928991804732031527 , 216 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE 

Experimente online!

Script de verificação

Obrigado a Nathaniel pela idéia de usar o Forth - ele me lembrou nos comentários que Forth não diferencia maiúsculas de minúsculas . Depois vieram as mudanças de humor - eu tenho encontrado razões pelas quais isso não vai funcionar, seguidas por soluções para esses problemas, repetidas vezes. Enquanto gira a minha bicicleta de treinamento indoor como um girador de fidget deformado e deformado (basta pegar uma extremidade do guidão e inclinar um pouco).

Antes de escrever esses programas, rascunhei quais caracteres podem ser usados ​​por qual programa. Especificamente, o segundo programa pode usar apenas letras maiúsculas, dígitos decimais, tabulações e vírgulas. Isso significa que o primeiro programa é todo em minúsculas, mas usei algumas letras maiúsculas para seus valores ASCII.

Como as guias são pesadas, usarei espaços na explicação.

O primeiro programa é do formato s" code"code- s"inicia uma literal de cadeia de caracteres, que é processada pela segunda cópia do código - uma estrutura padrão de quine. No entanto, em vez de emitir seu próprio código-fonte, ele criará o outro programa, que se parece com isso:

  • HERE
  • Para cada 8 bytes na cadeia original, 64-bit-number-literal ,
  • length-of-the-string
  • 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE

Isso usa o espaço de dados da Forth. HEREretorna o ponteiro para o final da área de espaço de dados alocada no momento e ,acrescenta uma célula preenchida com um número a ele. Portanto, os três primeiros pontos de marcador podem ser vistos como uma literal de string criada usando s". Para finalizar o segundo programa:

  • EMIT gera um caractere devido ao seu valor ASCII, portanto:
    • 115 EMIT imprime uma letra minúscula s
    • 34 EMIT imprime o caractere de citação "
    • 9 EMIT imprime uma guia
  • 2DUPduplica os dois principais elementos da pilha ( a b -- a b a b ), aqui está o ponteiro e o comprimento da string
  • TYPE imprime uma string para gerar a primeira cópia do código
  • 34 EMITimprime a cotação de fechamento "e, finalmente,
  • TYPE gera a segunda cópia do código

Vamos ver como o primeiro programa funciona. Em muitos casos, é necessário evitar números, o que é feito usando a 'xextensão de sintaxe gforth para literais de caracteres e, algumas vezes, subtraindo o valor ASCII do espaço, que pode ser obtido usando bl:

s" ..."      \ the data
: l bl - ;   \ define a word, `l`, that subtracts 32
: m l emit ; \ define a word, `m`, that outputs a character. Because 32 is
             \ subtracted using `l`, lowercase characters are converted to
             \ uppercase, and uppercase characters are converted to some
             \ symbols, which will become useful later
: z m m m m space ; \ `z` outputs four characters using `m`, followed by a
                    \ space. This is very useful because all words used in the
                    \ second program are four characters long
: p . 't 'i 'm 'e z ; \ define a word, `p`, that, given a number, outputs that
                      \ number, followed by a space, `EMIT`, and another space
'e 'r 'e 'h z \ here is where outputting the second program starts - `HERE `
: q \ define a helper word, `q`, that will be called only once. This is done
    \ because loop constructs like do...loop can't be used outside of a word.
  >r \ q is called with the address and the length of the data string. >r saves
     \ the length on the return stack, because we don't need it right now. While
     \ it might seem like this is too complicated to be the best way of doing
     \ this for codegolf, just discaring the length would be done using four
     \ characters - `drop`, which would give you the same bytecount if you could
     \ get the length again in... 0 characters.
  char l \ get a character from after the call to q, which is `;`, with the
         \ ASCII value of $3B, subtract $20 to get $1B, the number of 64-bit
         \ literals necessary to encode the string in the second program.
  bl l \ a roundabout way to get 0
  do   \ iterate from 0 (inclusive) to $1B (exclusive)
    \ on the start of each iteration, the address of the cell we are currently
    \ processing is on the top of the stack.
    dup @ . \ print the value. The address is still on the stack.
    'L m space \ the ASCII value of L is exactly $20 larger than the one of ,
    cell+ \ go to the next cell
  loop
  r> . \ print the length of the string
;
: n 'e 'p 'y 't z ; \ define a word, `n`, that outputs `TYPE`
q ; \ call q, and provide the semicolon for `char` (used to encode the length
    \ of the string in 64-bit words). Changing this to an uppercase U should
    \ make this work on 32-bit systems, but I don't have one handy to check that
's p \ print the code that outputs the lowercase s
'B l p \ likewise, 'B l <=> $42 - $20 <=> $22 <=> the ASCII value of a comma
#tab p \ print the code that outputs a tab
'p 'u 'd 'Q char+ z \ char+ is the best way to add 1 without using any digits.
                    \ it is used here to change the Q to an R, which can't be
                    \ used because of `HERE` in the second program. R has an
                    \ ASCII value exactly $20 larger than the ASCII value of 2,
                    \ so this line outputs the `2DUP`.
n 'B l p n \ output TYPE 34 EMIT TYPE to finish the second program. Note the
           \ that the final `n` introduces a trailing space. Trying to remove
           \ it adds bytes.

Para finalizar, gostaria de dizer que tentei usar EVALUATE, mas o segundo programa se torna maior que os dois apresentados acima. Enfim, aqui está:

: s s" ; s evaluate"s" : l bl - ; : m l emit ; : d here $b $a - allot c! ; : c here swap dup allot move ; : q bl l do #tab emit dup @ bl l u.r cell+ #tab emit 'L m loop ; here bl 'B l 's bl 's bl 'Z l d d d d d d d -rot c bl 'B l 's 'B l d d d d s c 'B l d c 'e 'r 'e 'h m m m m 'A q #tab emit 'e 'p 'y 't m m m m"; s evaluate

Se você conseguir jogar o suficiente para superar minha s" ..."...abordagem, vá em frente e publique como sua própria resposta.


1
Ótimo! Estou feliz que meu comentário tenha desencadeado esta solução!
Nathaniel

16

Perl, (311 + 630 = 941 bytes) 190 + 198 = 388 bytes

Ambos os programas são impressos na saída padrão.

O primeiro programa perl contém principalmente caracteres ASCII imprimíveis e novas linhas, e termina em exatamente uma nova linha, mas as duas letras ÿ representam o byte não ASCII \ xFF:

@f='^"ÿ"x92;@f=(@f,chr)for 115,97,121,36,126,191,153,194,216,113;print@f[1..5,5,10,5..9,0,9,0,5]'^"ÿ"x92;@f=(@f,chr)for 115,97,121,36,126,191,153,194,216,113;print@f[1..5,5,10,5..9,0,9,0,5]

O segundo contém principalmente bytes não ASCII, incluindo vários caracteres de alto controle que são substituídos por estrelas nesta postagem e nenhuma nova linha:

say$~~q~¿*ÂØ¡Ý*Ý*ÆÍÄ¿*Â׿*Ó***Ö***ßÎÎÊÓÆÈÓÎÍÎÓÌÉÓÎÍÉÓÎÆÎÓÎÊÌÓÎÆËÓÍÎÉÓÎÎÌÄ*****¿*¤ÎÑÑÊÓÊÓÎÏÓÊÑÑÆÓÏÓÆÓÏÓʢءÝ*Ý*ÆÍÄ¿*Â׿*Ó***Ö***ßÎÎÊÓÆÈÓÎÍÎÓÌÉÓÎÍÉÓÎÆÎÓÎÊÌÓÎÆËÓÍÎÉÓÎÎÌÄ*****¿*¤ÎÑÑÊÓÊÓÎÏÓÊÑÑÆÓÏÓÆÓÏÓÊ¢~

Um hexdump do primeiro programa com xxdé:

00000000: 4066 3d27 5e22 ff22 7839 323b 4066 3d28  @f='^"."x92;@f=(
00000010: 4066 2c63 6872 2966 6f72 2031 3135 2c39  @f,chr)for 115,9
00000020: 372c 3132 312c 3336 2c31 3236 2c31 3931  7,121,36,126,191
00000030: 2c31 3533 2c31 3934 2c32 3136 2c31 3133  ,153,194,216,113
00000040: 3b70 7269 6e74 4066 5b31 2e2e 352c 352c  ;print@f[1..5,5,
00000050: 3130 2c35 2e2e 392c 302c 392c 302c 355d  10,5..9,0,9,0,5]
00000060: 275e 22ff 2278 3932 3b40 663d 2840 662c  '^"."x92;@f=(@f,
00000070: 6368 7229 666f 7220 3131 352c 3937 2c31  chr)for 115,97,1
00000080: 3231 2c33 362c 3132 362c 3139 312c 3135  21,36,126,191,15
00000090: 332c 3139 342c 3231 362c 3131 333b 7072  3,194,216,113;pr
000000a0: 696e 7440 665b 312e 2e35 2c35 2c31 302c  int@f[1..5,5,10,
000000b0: 352e 2e39 2c30 2c39 2c30 2c35 5d0a       5..9,0,9,0,5].

E um hexdump do segundo programa é:

00000000: 7361 7924 7e7e 717e bf99 c2d8 a1dd 00dd  say$~~q~........
00000010: 87c6 cdc4 bf99 c2d7 bf99 d39c 978d d699  ................
00000020: 908d dfce ceca d3c6 c8d3 cecd ced3 ccc9  ................
00000030: d3ce cdc9 d3ce c6ce d3ce cacc d3ce c6cb  ................
00000040: d3cd cec9 d3ce cecc c48f 8d96 918b bf99  ................
00000050: a4ce d1d1 cad3 cad3 cecf d3ca d1d1 c6d3  ................
00000060: cfd3 c6d3 cfd3 caa2 d8a1 dd00 dd87 c6cd  ................
00000070: c4bf 99c2 d7bf 99d3 9c97 8dd6 9990 8ddf  ................
00000080: cece cad3 c6c8 d3ce cdce d3cc c9d3 cecd  ................
00000090: c9d3 cec6 ced3 ceca ccd3 cec6 cbd3 cdce  ................
000000a0: c9d3 cece ccc4 8f8d 9691 8bbf 99a4 ced1  ................
000000b0: d1ca d3ca d3ce cfd3 cad1 d1c6 d3cf d3c6  ................
000000c0: d3cf d3ca a27e                           .....~

No segundo programa, a cadeia de caracteres entre aspas (189 bytes de comprimento, delimitada por tildes) é o primeiro programa inteiro, exceto a nova linha final, codificada apenas complementando bit a bit cada bit. O segundo programa simplesmente decodifica a string complementando cada um dos bytes, o que o ~operador faz em perl. O programa imprime a string decodificada seguida por uma nova linha (o saymétodo adiciona uma nova linha).

Nesta construção, o decodificador do segundo programa usa apenas seis caracteres ASCII diferentes, de modo que o primeiro programa pode ser praticamente arbitrário, desde que contenha apenas caracteres ASCII e exclua esses seis caracteres. Não é difícil escrever nenhum programa perl sem usar esses cinco caracteres. A lógica quine atual está, portanto, no primeiro programa.

No primeiro programa, a lógica quine usa um dicionário de 11 palavras @fe monta a saída dessas palavras. As primeiras palavras repetem a maior parte do código fonte do primeiro programa. O restante das palavras são caracteres únicos específicos. Por exemplo, a palavra 5 é um til, que é o delimitador para as duas cadeias literais no segundo programa. A lista de números entre colchetes é a receita para quais palavras serão impressas em que ordem. Este é um método de construção geral bastante comum para quines, a única mudança nesse caso é que as primeiras palavras do dicionário são impressas com seus bytes complementados em bits.


14

Haskell , 306 + 624 = 930 bytes

Programa 1: Uma função anônima pegando um argumento fictício e retornando uma string.

(\b c()->foldr(\a->map pred)b(show()>>c)`mappend`show(map(map fromEnum)$tail(show c):pure b))"İĴİóđđđÝöÝâÝæÝääē××êääē××İēÀħđĮâħēĕóİóòòĮááħááđéêâéêēááĮÀħ""(\b c()->foldr(\a->map pred)b(show()>>c)`mappend`show(map(map fromEnum)$tail(show c):pure b))"

Experimente online!

Programa 2: q[[40,...]]no final, é uma função anônima que pega um argumento fictício e retorna uma string.

z~z=[[['@','0'..]!!4..]!!z]
q[x,q]_=z=<<x++q++[34,34]++x
q[[40,92,98,32,99,40,41,45,62,102,111,108,100,114,40,92,97,45,62,109,97,112,32,112,114,101,100,41,98,40,115,104,111,119,40,41,62,62,99,41,96,109,97,112,112,101,110,100,96,115,104,111,119,40,109,97,112,40,109,97,112,32,102,114,111,109,69,110,117,109,41,36,116,97,105,108,40,115,104,111,119,32,99,41,58,112,117,114,101,32,98,41,41,34],[304,308,304,243,273,273,273,221,246,221,226,221,230,221,228,228,275,215,215,234,228,228,275,215,215,304,275,192,295,273,302,226,295,275,277,243,304,243,242,242,302,225,225,295,225,225,273,233,234,226,233,234,275,225,225,302,192,295]]

Experimente online!

Conjunto de caracteres 1 (inclui espaço):

 "$()-:>E\`abcdefhilmnoprstuw×ÝáâäæéêñòóöđēĕħĮİĴ

Conjunto de caracteres 2 (inclui nova linha):

!'+,.0123456789<=@[]_qxz~

Como apenas o conjunto 1 contém caracteres não ASCII, seus bytes UTF-8 também são disjuntos.

Como funciona

  • O Programa 1 geralmente é escrito com expressões lambda, espaços e parênteses, uso gratuito de funções alfanuméricas incorporadas e com os dados quine como literais de string no final.

    • O código principal do próprio programa 1 é transformado em dados literais de cadeia de caracteres simplesmente envolvendo-o entre aspas.
      • Para suportar isso, toda barra invertida é seguida por aou b, que formam seqüências de escape válidas que percorrem o caminho show.
      • Outro pequeno benefício é que a, be csão as únicas letras minúsculas cujos códigos ASCII são menores que 100, economizando um dígito na codificação numérica usada pelo programa 2.
    • A codificação literal de cadeia de caracteres do código principal do programa 2 é mais ofuscada usando Unicode não ASCII: Cada caractere foi adicionado ao seu ponto de código 182 para garantir que não haja sobreposição com os caracteres originais.
      • 182 costumava ser 128, até que percebi que poderia abusar do fato de 182 ter o dobro do comprimento da string literal para o código do programa 1 reduzir a decodificação. (Como bônus, o programa 2 pode usar novas linhas.)
  • O Programa 2 geralmente é escrito com equações de função de nível superior (exceto a final anônima), literais de caracteres e números decimais, sintaxe de lista / intervalo e operadores, e com os dados quine como uma lista de listas de Ints no final.

    • O código principal do programa 1 é codificado como uma lista de seus pontos de código, com uma citação dupla final.
    • O código principal do programa 2 é codificado como a lista de pontos de código da cadeia literal usada no programa 1, ainda deslocada para cima em 182.

Passo a passo, programa 1

  • be csão os valores das literais de cadeia de caracteres para o programa 2 e 1, respectivamente, dados como argumentos finais para a expressão lambda. ()é um argumento falso apenas para satisfazer a regra do PPCG de que o programa deve definir uma função.
  • foldr(\a->map pred)b(show()>>c)decodifica a string bno código principal do programa 2 aplicando map preda ela um número de vezes igual ao comprimento de show()>>c == c++c, ou 182.
  • tail(show c)converte a string cno código principal do programa 1, com uma aspas dupla final anexada.
  • :pure bcombina isso em uma lista com a sequência b.
  • map(map fromEnum)$ converte as seqüências de caracteres em listas de pontos de código.
  • `mappend`show(...) serializa a lista de listas resultante e, finalmente, anexa-a ao código principal do programa 2.

Passo a passo, programa 2

  • O nível superior z~z=[[['@','0'..]!!4..]!!z]é uma função que converte pontos de código em caracteres (necessário para escrever, pois nem todos os caracteres toEnumestão disponíveis).
    • Seu argumento de ponto de código também é chamado z. O marcador de preguiça ~não tem efeito nessa posição, mas evita um caractere de espaço.
    • ['@','0'..] é um intervalo da lista de passos para trás, começando no código ASCII 64 e pulando 16 para baixo a cada passo.
    • A aplicação !!4a isso fornece um \NULpersonagem.
    • O agrupamento em um [ ..]intervalo fornece uma lista de todos os caracteres, que são !!zindexados.
    • O personagem é finalmente envolvido em uma lista de singleton. Isso permite mapear a função znas listas usando em =<<vez de indisponível mape <$>.
  • O nível superior q[x,q]_=z=<<x++q++[34,34]++xé uma função que constrói o programa 1 a partir da lista de dados quine.
    • xsão os dados para o núcleo do programa 1 (incluindo uma citação dupla final) e os internos qsão os dados ofuscados para o núcleo do programa 2. _é outro argumento fictício apenas para tornar a função anônima final uma função em vez de apenas uma string.
    • x++q++[34,34]++x concatena as peças, incluindo duas aspas duplas com o código ASCII 34.
    • z=<<constrói o programa 1 mapeando za concatenação para converter de pontos de código em caracteres.
  • A final q[[40,...]]é uma função anônima combinada qcom os dados do quine.

5

Gelatina , 128 90 87 86 85 79 16 + 32 = 48 bytes

“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs

Experimente online!

79,7806,8318,7885,7769,338,115ỌṘ

Experimente online!

O primeiro programa faz o seguinte:

“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs
“OṾ⁾ọṙŒs”          String literal: 'OṾ⁾ọṙŒs'
         O         ord: [79, 7806, 8318,...]
          Ṿ        Uneval. Returns '79,7806,8318,7885,7769,338,115'
           ⁾ọṙ     Two character string literal: 'ọṙ'
              Œs   Swap case the two char literal: 'ỌṘ'.

Isso deixa as strings 79,7806,8318,7885,7769,338,115e ỌṘos dois argumentos da cadeia e são implicitamente concatenadas e impressas no final.

O segundo programa calcula o chr( ) da lista de números que retorna OṾ⁾ọṙŒs. imprime “OṾ⁾ọṙŒs”(entre aspas) e retorna a entrada, deixando “OṾ⁾ọṙŒs”OṾ⁾ọṙŒscomo saída total.


5

Gol> <> , 23 + 23 = 46 22 + 22 = 44 20 + 20 = 40 bytes

"lF{3+|3d*HqlJJJQpp2

Experimente online!

'5ssTMMMotK-g6.6~Io

Experimente online!

Verifique online!

Como eles trabalham

"lF{3+|3d*HqlJJJQpp2

"..."        Push everything to the stack
 lF{3+|      Add 3 to everything on the stack
       3d*   Push 39 `'`
          H  Print everything on the stack (from the top) and halt

'5ssTMMMotK-g6.6~Io

'...'        Push everything to the stack
 5ss         Push 37 (34 `"` + 3)
    T    t   Loop indefinitely...
     MMMo      Decrement 3 times, pop and print
               At the end, `o` tries to print charcode -3, which is fishy (thanks Jo King)
               Program terminates

Adaptado da resposta de Jo King> <> . Tendo muito mais comandos alternativos para saída e repetição, não havia necessidade de gou p, e os dois corpos principais ficaram muito mais curtos.

Outra diferença principal é que eu gero a cotação do oponente diretamente no topo da pilha. Dessa forma, era um pouco mais fácil manter o invariante de quote + my code + opponent code(reversed and shifted).

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.