Todos sabemos o que é uma solução . Um quine invertido é um programa não vazio que imprime o inverso de seu código-fonte sem ler seu código-fonte e consiste apenas em caracteres ASCII imprimíveis (espaço através ~).

Aqui, “inverso do código fonte” significa o seguinte: a saída do seu programa deve conter cada caractere ASCII imprimível (m - c) vezes, em que c é o número de vezes que o caractere ocorre no código e m é o máximo número de vezes que um caractere é repetido no seu código.

(Em outras palavras: seu código + sua saída = permutação de m vezes todos os ASCII imprimíveis.)

Por exemplo, se o seu programa for 12345, então m = 1 , e você deve gerar qualquer permutação dessa string:

 !"#$%&'()*+,-./06789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Se o seu programa for AAB, então m = 2 , e você deverá gerar qualquer permutação de:

  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@BCCDDEEFFGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~

Observe como há dois se faltando Ae um faltando B.

Embora um programa que contenha todos os caracteres ASCII imprimíveis e não produza nada seja um quine inverso válido (satisfazendo m = 1 ), essa resposta não seria muito competitiva, dada a sua extensão.

Você deve escrever um programa que seja uma solução invertida, conforme descrito no parágrafo acima. Como esse é o código-golfe , o programa mais curto em bytes será vencedor. Boa sorte!

Flak cerebral , 221 207 bytes

Inclui +1 para -A

(((((((()()()()){}){}()){}){})()){}{}){({}[()]<((((((()()()()){}){}){})<>[()()()])[()])((((()()()){})){}{})<>((()()()()){}){({}[()]<(({})())>)}{}({}()())<>{{({}<>[()]<(({})())><>)}{}<>(({}())()())<>}<>>)}{}

Experimente online!

# Push 206 (the number of times to duplicate the output)
(((((((()()()()){}){}()){}){})()){}{})

# For 0 to 206
{({}[()]<

    # Push 32 on this stack and 18, 28 and 29 to the other
    # 18, 28 and 29 are the distances between the sets of braces 
    ((((((()()()()){}){}){})<>[()()()])[()])((((()()()){})){}{})<>

    # For 0 to 8
    ((()()()()){}){({}[()]<

        # Push TOS, TOS + 1
        (({})())

    # end For 0 to 8
    >)}{}

    # Push TOS + 2 
    # skips '(' and ')'
    ({}()())

    # For each value on the off stack (18, 28, 28)
    <>{

        # For 0 to that number
        {({}<>[()]<

            # Push TOS, TOS + 1
            (({})())

        # End for 0 to that number
        ><>)}{}

        # Push TOS + 1, TOS + 3 (skips this set of braces)
        <>(({}())()())<>

    # End for each value on the off stack (18, 28, 28)
    }<>

 # End for 0 to 206
 >)}{}

CJam , 17 bytes

{s95c+'|,32>\-}_~

Experimente online!

Impressões

 !"#$%&()*./014678:;<=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^`abdefghijklmnopqrtuvwxyz

Explicação

O objetivo era modificar o padrão quine

{"_~"}_~

de modo que nenhum caractere seja repetido no programa. A razão para isso é que o CJam possui um operador diferente definido que podemos usar para remover caracteres do intervalo ASCII imprimível, mas isso não leva em consideração o número de ocorrências. Implementar isso manualmente provavelmente seria mais longo, então eu precisava garantir que todos os personagens aparecessem apenas uma vez e não precisássemos nos preocupar com as ocorrências.

{      e# Quine framework. Executes the block while leaving another copy of the
       e# block on the stack.
  s    e#   Stringify the block, giving us "{s95c+'|,32>\-}".
  95c  e#   Convert 95 to a character, which gives us '_' without repeating
       e#   it in the source code.
  +    e#   Append it to the string. We don't need to worry about '~', we'll just
       e#   leave it out of the printable ASCII range to begin with.
  '|,  e#   Get a character range from the null byte up to '{'. This omits "|}~",
       e#   but those are in the program anyway, it doesn't matter.
  32>  e#   Discard the unprintable characters.
  \-   e#   Subtract the source string from the printable ASCII range.
}_~

Python 3 , 83 bytes

print(~2/8,6>9)#!"$%&'*+14:;<=?@ABCDEGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdfghjkmoquvwxyz{|}

Experimente online!

Imprime -0.375 False.

05AB1E , 95 61 60 bytes (não 58 b / c não gosto desse)

A?9L<J, !"'#$%&()*+-./:;=>@BCDEFGHIKMNOPQRSTUVWXYZ[\]^_`{|}~

Experimente online!

Resposta antiga invalidada por "apenas caracteres ASCII", muitos comandos não são válidos aqui.

Imprime abcdefghijklmnopqrstuvwxyz012345678uma vez, pois não há caracteres duplicados.

Versão BCDEFGHIKMNOPQRSTUVWXYZremovida:

Trabalho em andamento ... acho que ~ 60 bytes é o mais baixo possível sem caracteres não ASCII em 05AB1E ..

05AB1E , 58 bytes

T5+FA'uK?Au"ADLJFKST"SK?9L<5KJ?} !#$%&()*>-./:;=@[]^_`{|~\

Experimente online!

Imprime a saída x12 devido aos caracteres repetidos:

['""', '55', '???', 'AAA', 'FF', 'JJ', 'KKKK', 'LL', 'SS', 'TT', 'uu']

Também não termina corretamente, trabalhando nisso agora ...

Respostas antigas inválidas (devido a caracteres não ASCII) foram removidas, consulte o histórico de edições.

Java 8, 106 99 190 bytes

class i {/*{}!"#$%&'()+,-.0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bdefghjkmnopqrtuvwxyz|~!"#$%&'()+,-.0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`claibdefghjkmnopqrtuvwxyz|~*/}

Javascript (ES6), 103 101 bytes

_=>` !"#$%&'()*+,-.0123456789:;<?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^abcdefghijklmnopqrstuvwxyz{|}~`//_=>\\

Solução antiga (103 bytes usando alert)

alert;;alert`\ \!"#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_bcdfghijkmnopqsuvwxyz{|}~`

Solução antiga (inválida) (96 bytes)

alert()// !"#$%&'*+,-.0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdfghijkmnopqsuvwxyz{|}~