Citações-inversas-quine

29

A perspectiva desse desafio é:

  • Se o seu programa for executado normalmente, todo o código nas marcas de fala ( "- aspas duplas) deve ser impresso.
  • Se o seu programa estiver entre aspas duplas (por sua vez, invertendo as marcas de fala), o código que normalmente não está entre aspas deve ser impresso.

Por exemplo:

Digamos que você tenha o seguinte código:

fancyStuff("myCode"); "I like".isGreat();

Se eu executá-lo, esperaria uma saída de:

myCode
I like

No entanto, se eu o envolvesse entre aspas, obteria:

"fancyStuff("myCode"); "I like".isGreat();"

Quando esse código é executado, a saída esperada seria:

fancyStuff(
); 
.isGreat();

Obviamente, o exemplo acima não é uma resposta funcional em nenhum idioma. Seu trabalho é escrever o código que executa dessa maneira.

Regras

  • Aplicam-se brechas padrão.
  • Os valores impressos, nos formulários entre aspas e não entre aspas, devem ser não vazios ou consistir apenas em espaços em branco. Isso também significa que todos os programas devem incluir pelo menos um conjunto de cotações.
  • No entanto, espaços em branco à direita / à direita são permitidos.
  • Não é necessário procurar seu próprio código, nomes de arquivos necessários etc.
  • Citações sem correspondência não são permitidas
  • Se houver várias cadeias, elas podem ser impressas como novas linhas (como no exemplo) ou de outra maneira legível por humanos - sem matrizes ou objetos
  • Isso é código-golfe , então a resposta mais curta em bytes vence.
code-golf  restricted-source  quine 
— Geza Kerecsenyi
fonte
As cotações sem correspondência são permitidas e, em caso afirmativo, como elas devem ser tratadas?
— negativo sete
3
@GezaKerecsenyi Então, é necessário um separador ou podemos simplesmente concatenar as strings?
— Erik the Outgolfer
9
Como uma matriz não é um formato legível por humanos?
— Wheat Wizard
4
As strings devem ser exibidas na mesma ordem em que aparecem no nosso código?
— Shaggy
11
Eu acho que isso seria um pouco mais complexo se você tivesse que imprimir o que não estava entre aspas
— Jo King

Respostas:

28

Python 2 , 20 bytes

print";print'print'"

-7 bytes graças ao tsh

Experimente online!

Resposta antiga:

Python 2 , 27 bytes

'';print";print 2*"'';print

Experimente online!

Linha de pensamento por trás desta resposta:

Comece com uma impressão simples, porque precisamos imprimir alguma coisa .

print"a"

Também precisamos imprimir algo no caso invertido, ie. tenha uma impressão dentro de aspas.

print"print"

O caso não invertido é muito bom neste momento. Vamos nos concentrar no caso invertido. Agora começamos com a string print, que não pode ser seguida imediatamente por uma declaração de impressão. Vamos corrigir isso com um ponto e vírgula.

print";print"

Coisa boa. Exceto que o código invertido não imprime nada. Precisamos imprimir o printno início, porque ele termina entre aspas, mas também imprime o que vier após a segunda cotação, porque também termina entre aspas. A maneira óbvia de contornar isso é anexar printe multiplicar a última string por 2.

print";print 2*"print

Agora, o código invertido funciona bem, embora tenhamos que ter cuidado com o fato de que a seção antes da primeira cotação e a seção após a segunda cotação precisam ser mantidas as mesmas durante as alterações futuras. Quanto ao código não invertido, ele gera um erro de sintaxe - mais uma vez, precisamos introduzir um ponto e vírgula para separar expressões.

;print";print 2*";print

O Python realmente não gosta da aparência desse ponto e vírgula solitário, portanto, devemos satisfazer a fome da cobra com duas da mesma expressão não operacional, inseridas antes do primeiro ponto e vírgula e do último ponto e vírgula. A maioria das expressões funcionará bem no primeiro caso, mas no segundo caso deve seguir print";print 2*"no código não invertido sem quebrar nada. Podemos usar '', que simplesmente é concatenado com a string anterior.

'';print";print 2*"'';print
— sete negativos
fonte
5
print(";print('print()');")também tem 27 bytes e também Python 3.
— tsh
2
@tsh Este código revela uma solução Python 2 de 20 bytes que deveria ter sido óbvia em retrospectiva, muito boa!
— negativo sete
19

CSS, 66 bytes

body:after{content:"{}body:after{content:'body:after{content:}'}"}
Expandir snippet

"body:after{content:"{}body:after{content:'body:after{content:}'}"}"
Expandir snippet

Poucas perguntas podem ser resolvidas pelo CSS ...

— tsh
fonte
Parece que body:aftertambém funciona em algumas implementações?
— Shieru Asakoto 21/06
@ShieruAsakoto Você está certo. :afterestá disponível na maioria dos navegadores para razão compatibilidade com versões anteriores
— TSH
@ Shaggy Mas é difícil definir como "envolver seu código-fonte entre aspas" funciona quando HTML e CSS são fornecidos.
— tsh
@tsh Tudo bem - eu não especifiquei sobre vários arquivos nas regras, pois não esperava uma resposta tão única!
— Geza Kerecsenyi
10

HQ9 + [veja notas abaixo] , 1016 bytes

"Olá Mundo""""""""""""""""""""""""""""""""""""""""""""""" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """"""""""""""""""""""""""""""""""""""Olá Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """""""""""""""""""""""""""""""""""Olá Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """""""""""""""""""""""""""""""""""Olá Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """"""""""""""""""""""""""""Olá Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """"""""""""""""""""""""""""Olá Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """""""""""""""Olá Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """""""""""""""Olá Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """"""""""""""""""""""""""""""""""""""Olá Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """"""""""""""""""""""""""""""""""""""Olá Mundo"""""""""""""""""""""""""""""""""""Olá Mundo"""""""""""""""""""""""""""""""""""Olá Mundo

Use a implementação em https://esolangs.org/w/index.php?title=HQ9%2B&oldid=59995 e compile o intérprete com o MinGW GCC 5.3.0 no Windows. Não tenho certeza se ele funciona com outra versão do compilador, pois é necessário um comportamento indefinido de C para finalizar o programa. O buffer tem 1000 bytes. E o código fonte com mais de 1000 bytes é o suficiente. Não tenho certeza de como isso aconteceu.

— tsh
fonte
7
Talvez esta seja a resposta mais longa do HQ9 + neste site. (?)
— tsh 21/06
11
"um comportamento indefinido de C é necessário para finalizar o programa" O comportamento indefinido é indefinido : ele pode fazer qualquer coisa.
— Solomon Ucko
De acordo com a página 4 da norma C18 : "Possível comportamento indefinido varia de ignorar a situação completamente com resultados imprevisíveis, a se comportar durante a tradução ou a execução do programa de maneira documentada, característica do ambiente (com ou sem a emissão de uma mensagem de diagnóstico ), para encerrar uma tradução ou execução (com a emissão de uma mensagem de diagnóstico). "
— Solomon Ucko
@SolomonUcko Mas nós definimos uma linguagem por seu compilador / intérprete neste site. E a resposta é boa, desde que pelo menos um compilador / intérprete possa produzir o resultado correto.
— tsh 23/06
9

05AB1E , 4 bytes

"A"§

Saídas concatenadas sem separador.

Experimente online ou online com aspas .

Explicação:

        # Program without surrounding quotes will output string "A"
"A"     # Push "A" to the stack
   §    # Cast it to a string
        # (output the top of the stack implicitly as result)

        # Program with surrounding quotes will output string "§"
""      # Push an empty string to the stack
  A     # Push the alphabet to the stack: "abcdefghijklmnopqrstuvwxyz"
   "§"  # Push "§" to the stack
        # (output the top of the stack implicitly as result)
— Kevin Cruijssen
fonte
Infelizmente, isso viola a regra 2. Embora seja bom ter algumas aspas vazias no seu código, deve haver pelo menos uma não vazia nas formas envolvente e não circundada.
— Geza Kerecsenyi
@GezaKerecsenyi Opa, leia a parte " nas formas entre aspas e não citadas ". Deve ser corrigido agora.
— Kevin Cruijssen 20/06
6

Japonês , 4 bytes

"P"s

Experimente não cotadas ou cotadas

Pé a variável Japt da string vazia e o smétodo corta uma string - sem argumentos, ele não faz nada.

Ou, ainda que um pouco menos trivial:

"+"u

Experimente não cotadas ou cotadas

O primeiro está em maiúsculas +e o segundo uem uma string vazia.

— Shaggy
fonte
3
Observe que 4 é a pontuação mínima para esta pergunta, uma vez que viola as restrições.
— Jo King
5

C # (Compilador interativo do Visual C #) , 113 112 107 70 64 bytes

Write(".f();static void f(this string s){Write(s+')'+';');}//");

Economizou 5 bytes graças a @negative seven

Não citado e citado

Depois de um tempo, percebi que minha solução era muito complicada. O programa mais recente mostrado aqui simplesmente oculta o restante do programa em um comentário para evitar erros quando estiver entre aspas.

Quando colocado entre aspas, Write(é passado para um método de extensão, que o imprime junto );.

— Modalidade de ignorância
fonte
Split()-> Trim()e var a->_
— negativo sete
11
@negativeseven Obrigado, eu nunca pensei em usar um descarte!
— Modalidade de ignorância
11
@negativeseven Na verdade, minha solução nem precisava ser tão complicada, olhe para a minha edição mais recente
— Modalidade de Ignorância
64 bytes usando um método de extensão. Muito surpreso que isso funcionou tão bem!
— negativo sete
11
@negativeseven Thanks! E você me deu uma idéia para a parte dois do desafio: Eu estava capturando o exterior em uma variável e, em seguida, usando Removee Insertsobre ele, agora eu posso apenas usar um método de extensão!
— Modalidade de ignorância
4

Foo , 4 bytes

"P"s

Experimente online! Também trabalha em Japt.

5 bytes (UTF-8)

"A"§

Experimente online! Também funciona em 05AB1E.

9 bytes

"!""$;"$;

Experimente online! Também trabalha em encantamentos rúnicos.

11 bytes

say ".say~"

Experimente online! Também funciona em Perl 6.

20 bytes

print";print'print'"

Experimente online! Também funciona em Python 2.

69 bytes

body::after{content:"{}body::after{content:'body::after{content:}'}"}

Experimente online! Também funciona em CSS.

Hmm ... Foo é uma linguagem altamente adaptável.

— jimmy23013
fonte
“ Hmm ... Foo é uma linguagem altamente adaptável. ” Para quem não conhece Foo: tudo dentro de aspas duplas é produzido e tudo o resto (exceto alguns caracteres incorporados) não é operacional. " A linguagem perfeita para o trabalho " é um eufemismo aqui. ;)
— Kevin Cruijssen
2
Então, basicamente, apenas arranque todas as outras soluções para esse desafio ?!
— Shaggy
@ Shaggy O idioma é Foo. Quase tudo com pelo menos um par de aspas e as duas saídas não vazias esperadas funcionam no Foo neste desafio. O "a"b 1"2"mesmo acontece com Foo. A única resposta nesse desafio que não é poliglota de Foo até agora está no HQ9 +, porque o intérprete de Foo também tem o problema de transbordamento.
— jimmy23013 22/06
4

> <> , 18 9 bytes

"|o<"r>o|

-9 bytes graças a Jo King

Experimente online! ( citado )

Explicação

"|o<"r>o|
"|o<"     Pushes the quoted characters onto the stack
     r    Reverses the stack
      >o| Outputs all characters on stack & errors

""|o<"r>o|"
""          No-op
  |         Reverses the IP direction
     "r>o|" Pushes the quoted characters onto the stack (backwards)
  |o<       Outputs all characters on stack & errors
— tjjfvi
fonte
5
Bem-vindo ao Code Golf!
— Stephen
@ Stephen Obrigado!
— tjjfvi 22/06
2

Encantos Rúnicos , 9 bytes

"!""$;"$;

Experimente online! e""!""$;"$;"

De Kevin Cruijssen, que essencialmente corrigiu minha primeira tentativa utilizando o que fiz na segunda.

Descendo a rota "fungoids nunca tem aspas incomparáveis", flexão de regras ", há algo sobre isso que não deve ser bom", mencionado no meu próprio comentário:

7 bytes

0".""$;

Experimente online! e"0".""$;"

Em circunstâncias normais, esse programa é executado como 0".""$;0".""$;pressionar um número inteiro e 0, em seguida, a string .concatena $;0NOP, concatena uma string vazia, imprime o topo da pilha (a string .$;0) e termina. O "0".""$;"agrupamento entre aspas produz o que empurra uma string 0, NOPs , concatena uma string vazia, imprime o topo da pilha e termina (renderizando o número inteiro não impresso anteriormente 0na forma de string). O último não "é executado (e não faz parte do programa original ).

Os fungos não possuem literais de seqüência de caracteres, eles têm um comando que alterna o modo "ler a própria fonte como uma seqüência de caracteres" e alguma forma de regra "ponteiro de instrução atingiu o limite da fonte" (geralmente quebra de borda), portanto o mesmo código-fonte -posicional-byte atua como instrução "string inicial" e "string final", criando uma literal de string dessa linha / coluna inteira (excluindo a "própria).

— Draco18s
fonte
Resposta super rápida! Só estou me perguntando se não entendi algo sobre a sua submissão, mas para mim ela não imprime $;o final da versão citada.
— Geza Kerecsenyi
Percebi isso ao reler e estou tentando descobrir se o rúnico pode executar esse pedaço. Começando a investigar citações "não emparelhadas" agora; eg "$;e ""$;"(aspas envolventes rúnicas emparelhadas).
— Draco18s 20/06
@GezaKerecsenyi Deixe-me saber se meu programa atualizado viola alguma regra.
— Draco18s 20/06
Umm .. Como isso é válido? Seu programa sem saída de aspas !.(o que é correto), mas não deveria o seu programa com saída de aspas 0$;? PS: Eu não conheço nenhum Runic Enchantments, mas uma possível correção com base no seu layout atual que eu acho que seria válida 0"!""$;"$;(que sai!$; como está ou sai0$; se estiver entre aspas). EDIT: Na verdade, acho que você pode soltar o 0e output !$;e $;.
— Kevin Cruijssen 20/06
11
@KevinCruijssen $é "imprimir parte superior da pilha" e ;termina. Mas você basicamente tem uma resposta válida.
— Draco18s 20/06
0

R, 16 bytes

 ";print(";");"

Observe que o código acima não está entre aspas adicionais e possui espaços à esquerda e à direita.

Experimente (versão não empacotada)

— James Otto
fonte
Convém adicionar uma observação de que o programa vinculado é a versão sem quebra automática.
— Jonathan Frech
Eu também acrescentaria uma observação sobre os espaços à esquerda e à direita. É difícil notá-los de outra maneira.
— mbomb007 21/06
Editado, obrigado pelas sugestões!
— James Otto
0

AppleScript, 9 bytes

return"&"

Explicado:

return"&"    -- returns "&"

Citado:

"return"&""  -- implied return of the string "return" concatenated with ""
— um aracnídeo de pedra
fonte
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.