Todos sabemos lo que es una quine . Un quine invertido es un programa no vacío que imprime el inverso de su código fuente sin leer su código fuente, y consiste únicamente en caracteres ASCII imprimibles (espacio a través ~).

Aquí, "inverso del código fuente" significa lo siguiente: la salida de su programa debe contener cada carácter ASCII imprimible (m - c) veces, donde c es el número de veces que dicho carácter aparece en su código, ym es el máximo Número de veces que se repite cualquier carácter en su código.

(En otras palabras: su código + su salida = permutación de m veces todos los imprimibles-ASCII).

Por ejemplo, si su programa es 12345, entonces m = 1 , y debería generar cualquier permutación de esta cadena:

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

Si su programa es AAB, entonces m = 2 , y debe generar cualquier permutación de:

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

Tenga en cuenta cómo faltan dos Asy una falta B.

Aunque un programa que contiene todos los caracteres ASCII imprimibles y no genera nada es una suma inversa válida (que satisface m = 1 ), dicha respuesta no sería muy competitiva, dada su longitud.

Debe escribir un programa que sea una línea invertida, como se describe en el párrafo anterior. Como se trata de code-golf , ganará el programa más corto en bytes. ¡Buena suerte!

Brain-Flak , 221 207 bytes

Incluye +1 para -A

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

Pruébalo en línea!

# 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>\-}_~

Pruébalo en línea!

Huellas dactilares

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

Explicación

El objetivo era modificar la quine estándar.

{"_~"}_~

tal que no se repita ningún carácter en el programa. La razón de esto es que CJam tiene un operador diferente que podemos usar para eliminar caracteres del rango ASCII imprimible, pero no tiene en cuenta la cantidad de ocurrencias. Implementar eso a mano probablemente sería más largo, por lo que necesitaba asegurarme de que cada personaje aparezca solo una vez y no tengamos que preocuparnos por los sucesos.

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

Pruébalo en línea!

Impresiones -0.375 False.

05AB1E , 95 61 60 bytes (no 58 b / c no me gusta)

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

Pruébalo en línea!

Respuesta anterior invalidada por "solo caracteres ASCII", muchos comandos no son válidos aquí.

Se imprime abcdefghijklmnopqrstuvwxyz012345678una vez ya que no hay caracteres duplicados.

Versión con BCDEFGHIKMNOPQRSTUVWXYZeliminado:

Trabajo en progreso ... Creo que ~ 60 bytes es lo más bajo posible sin caracteres no ASCII en 05AB1E ...

05AB1E , 58 bytes

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

Pruébalo en línea!

Imprime la salida x12 debido a los caracteres repetidos:

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

Tampoco termina correctamente, trabajando en eso ahora ...

Se han eliminado las respuestas antiguas no válidas (debido a caracteres no ASCII), consulte el historial de edición.

Java 8, 106 99 190 bytes

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

Javascript (ES6), 103101 bytes

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

Solución anterior (103 bytes usando alert)

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

Solución antigua (no válida) (96 bytes)

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