Su tarea es crear un programa (utilizando solo caracteres ASCII imprimibles y / o pestañas y líneas nuevas) que imprima exactamente los caracteres en el espacio ASCII imprimible ( 0x20a 0x7e) que no aparecen en el código fuente de su programa (en cualquier orden, sin embargo muchas veces que quieras).

El código más corto para hacer esto en cualquier idioma gana.

GolfScript, 15 12 caracteres

{`),32>^.}.~

Basado en la respuesta de Jan Dvorak con algunos giros y también en el estilo de Peter Taylor .

Polyglot, 95

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

• Perl
• Perl 6
• Cualquier * shell nx-como ( tclsh, bash, sh, ksh, etc)
• Awk (GNU / POSIX)
• Brainfuck , Brian & Chuck , otros derivados
• Rubí
• Coffescript
• Golfscript
• Pitón
• R
• Julia
• Espacio en blanco
• rk
• Gaot ++
• antes de Cristo
• jq
• Alegría
• Tcl
• 99
• V (FMota)
• Acc !!
• C - si no main()se necesita. Gracias a urogen
• Probablemente más.

No hace nada.

PHP 5.2, 4

<?<<

Guardar como un archivo llamado NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.phpen algún lugar /home. short_open_tagnecesita estar Onen tu php.ini.

El resultado es:

PHP Parse error:  syntax error, unexpected T_SL in /home/wherever/NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.php on line 1

JavaScript - 88

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

imprime "bcdfghijkmnpquvxyz"

Espacio en blanco, 61 57 caracteres

No es el más corto, pero probablemente tiene la lógica más simple (en realidad es solo un bucle).

Aquí está completamente comentado, donde S es espacio, T es tabulación, L es avance de línea:

SSSTSSSSSL     # push 0x20
LSSSL          # label S
SSSTL          # push 1
TSSS           # add
SLS            # duplicate top of stack
SLS            # duplicate again
TLSS           # output ASCII character
SSSTTTTTTSL    # push 0x7E
TSST           # subtract (result - 0x7E)
LTTSL          # branch to label S if top of stack is negative
LLL            # end

Gracias a @res por la corrección a lo anterior (duplicado adicional requerido para la instrucción de bifurcación) y por números más pequeños para empujar en la pila.

C, 83 74 69 caracteres

main(z) {for(;++z<96;"\33iE!vk?}GkRP8z"[z/7]&1<<z%7&&putchar(z+32));}

Realmente intenté descifrarlo por debajo de 80 caracteres, pero no pude lograrlo. Finalmente decidí publicar lo que tengo, asumiendo que yo (u otra persona) descubriré la solución de 79 caracteres diez minutos después de publicar esto. De acuerdo, no fueron diez minutos, pero funcionó en principio.

Tenía muchas ganas de publicar una versión que no tenía que tener un espacio gratuito en el código fuente, pero que aterrizó en una órbita de atractor extraño, rebotando entre un puñado de soluciones. Después de muchos minutos de tratar de empujar a uno de ellos a una solución estable, me di por vencido y agregué el espacio.

Golfscript, 26 24 caracteres

"126,32>''+".~\-'.~\-"'-

Toma un script de generación de rango, lo duplica, lo ejecuta, lo resta de su resultado, luego resta el código de sustracción del resultado y el otro carácter de comillas.

Pescado - 80

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

Cuando el pez comete errores, imprime "algo huele a pescado ...". Como z es una mala instrucción, se equivoca de inmediato

Sé que no está ganando ningún concurso. Solo quería probarlo en un idioma que normalmente no se usa, solo por diversión.

Java - 209 195 152 140 caracteres

class a{public static void main(String[]a){for(char c=0;;c++)System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:}".indexOf(c)<0?c:"");}}

Con saltos de línea y pestañas

class a{
    public static void main(String[]a) {
        for(char c=0;;c++)
            System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"");
    }
}

Tenga cuidado si ejecuta: el programa no termina. Jaja

Explicación

1. for(char c=0;;c++): Dado que a charpuede tratarse como un int, lo uso para mi ventaja aquí para incrementar todos los valores posibles de c. Omito la condición de terminación en el ciclo (la que iría entre los dos puntos y comas) para guardar los caracteres, ya que no se especificó que el programa tenía que terminar. :)
2. "publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"": Lamentablemente, no es un enfoque muy elegante, pero hace el trabajo. Enumere manualmente todos los caracteres presentes en el código fuente como un Stringliteral, luego verifique si la corriente char cocurre dentro de él con indexOf(). Si la indexOf()llamada regresa -1, no existe y, por lo tanto, deberíamos imprimirla. El resto solo usa el operador ternario para ahorrar en caracteres y espacio.

Perl, 49 caracteres

say grep/[^+-246\[-^aceghmprsy]/,map chr,041..126

Este es un desafío interesante: es una especie de anti-quine, y he logrado acortar el programa un par de veces al aumentar el rango de caracteres que aparecen en él.

Rubí, 81 78 68 66 62 57

(?!..?~).map{|a|$><<a if/[()ifmap{}|?!.~\/\\\[\]$><]/!~a}

Simplemente se controla a sí mismo. Caracteres duplicados eliminados manualmente.

¡Gracias a Josh por guardar 4 caracteres y minitech por guardar 5 caracteres!

Befunge (48)

<|::-1,+*88:<+3*87
6<@.**85
9>"()~&"/%$ |!#';=?}

Salidas: {zyxwvutsrqponmlkjihgfedcba` _ ^] [ZYXWVUTSRQPONMLKJIHGFEDCBA240

Java - 126 caracteres

minimizado:

class hjq{public static void main(String...w){for(char z='"'|0;++z!='a';)if("'()+.0;=OS".indexOf(z)==~0)System.out.print(z);}}

no minimizado:

class hjq {
    public static void main(String... w) { 
        for (char z = '"'|0; ++z != 'a';) {
            if ("'()+.0;=OS".indexOf(z) == ~0) {
                System.out.print(z);
            }
        }
    }
}

Este es un problema interesante, porque los tokens individuales podrían beneficiarse de su forma más larga porque reutiliza los caracteres. Por ejemplo, normalmente String[]sería más corto, pero String...elimina la necesidad de los corchetes en la cadena condicional.

Descubrí que el truco era tratar de usar caracteres al principio y al final del rango para que pueda excluirlos de la salida simplemente alterando el inicio y el final de su ciclo.

Para Java, un carácter clave para excluir es ", porque tener eso en la cadena requiere escapar, lo que agrega \a su programa, que debe ir en la cadena, que agrega \\. Al eliminar "de su cadena condicional, elimina 4 caracteres. Esto se puede conseguir asegurándose de que utilice y !e iniciar el bucle desde #.

Todas las letras minúsculas aparecen cerca del extremo superior del rango, la única {, |, }y ~viene después de ellos. Debido a la verbosidad de Java, la mayoría de las letras minúsculas se usan solo para la repetitiva. Del mismo modo, {y} son triviales para un programa Java, porque la repetitiva los requiere.

|se puede usar si tiene una condición o, pero no pude encontrar una manera de aprovechar una que conduzca a un programa más corto que simplemente usarla |como operador bit a bit. El |0me hace sentir un poco sucio, porque es la única parte que es un nop sólo para obtener el carácter de allí.

~0rendimientos -1, lo cual es útil porque eso es lo que debemos verificar indexOf. La combinación de esto con el uso !=del bucle condicional elimina el <carácter por completo, lo que significa que no necesita ir dentro de la cadena condicional.

sh (47)

tr</dev/urandom -cd \[:print:]|tr -d "`cat $0`"

Utiliza el enfoque autorreferencial. Se supone /dev/urandomque finalmente generará cada octeto al menos una vez. No termina

Si suponemos que manestá instalado, podríamos utilizar la página de ascii(7)manual (y así tener un programa de finalización) ( 44 caracteres, gracias @fennec).

man ascii|tr -cd \[:print:]|tr -d "`cat $0`"

BitShift , 1038 bytes

BitShift es un lenguaje que solo admite 0y 1como sintaxis. Pensé que sería fácil imprimir todos los demás caracteres, pero como realmente no es compatible con el bucle, terminó siendo un enorme 1038 bytes.
Sin embargo, creo que no es realmente posible ir más pequeño que esto ...

101001100101011011010100110111010100100101011001101111010100100101011001000101011011010100101100110110101001001010110010001010110110101000001101010010010101100100010101101101010000010000011001010110110101000010000101011011010100110111010100100101011111100101011011010100110111010100100101011001101111010100100101011001000101011011010100000000011010100100101011001000101011011010100110010000101011011010100110111010100100101011001101001101010010010101100100010101101101010011001000010101101101010011011101010010010101111011111110010101101101010011011101010010010101100101100101011011010100010001010110110101001000010101101101010011011101010010010101110111110010101101101010011011101010010010101111111100101011011010100110111010100100101011111011110101001001010110010001010110110101001000100000101011011010100110111010100100101011111010011010100100101011001000101011011010100100000101011011010100110111010100100101011001101111010100100101011001000101011011010100010000010101101101010011011101010010010101101001101101010010010101101001101010

Huellas dactilares

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

Pruébalo aquí

Definitivamente la solución más larga aquí, pero codificar en Lino siempre es divertido:

Linóleo -655 523 caracteres

"libraries"/arch/cpu/base;/hmi/conout;/data/bytes;/data/string/t2s;/data/heap;/data/heap/connect/mgrab;"stockfile"a;"directors"displaystatus=engage;"injection"c=524;b<-bytes.bytesizeconvert:c;b<-heap.alloc:b;a<-heap.alloc:c;[filecommand]=readfile;[filename]=stockfile;[fileposition]=0;[fileblocksize]=c;[fileblockpointer]=b;arch.fileread;[string.psource]=b;[string.ptarget]=a;string.t2s;b<-heap.alloc:7fh;c=32;d=b;"f"[d_32]=c;+c;+d;?c<7fh>f;"w"d=[a];+a;?d=0>y;?d<32>w;?d>7eh>w;e=b;e+d;[e]=33;^w;"y"b+32;"v"conout.say:b;bye;

No hay comentarios, solo lee la fuente compilada en binario. ¡Guardar como a.txto no se compilará!

Brainfuck, 133 123 114 110 bytes

++++++++++++++++[->++++++>++>+++>++++>++<<<<<]>-->>->->+[---<.+.+<.+<.+<.+.+.+>>>>]++[-<.+.+.+<.+>>]<+.<+.<++.

Un poco más de ajustes con una solución anterior (antes de darme cuenta de que la siguiente era más pequeña, aunque esto fue antes de que hiciera una gran optimización). Esto funciona almacenando 4 conjuntos de números ASCII e imprimiéndolos con algunos bucles complicados, y luego da los caracteres que faltan después (es decir, los que están entre números ASCII no válidos).

Presentación original

>>+++++++++++[<+<+>>->++>+++<<]<++>>++++++>>+++++[-<<<++++++>>>]<<<+<<[->>+.<<]>>++.++<[->+.<]>++.+>[-<+.>]<++.+>>[-<<+.>>]

Hace lo siguiente:

• Cree 4 registros que contengan 11. 13, 28, 33
• Cree un quinto con el valor 31 para comenzar la impresión.
• Imprimir ascii 32-42 (11)
• Imprimir ascii 44
• Imprimir ascii 47-59 (13)
• Imprimir ascii 61
• Imprimir ascii 63-90 (28)
• Imprimir ascii 92
• Imprimir ascii 94-126 (33)

Haskell (70)

import Data.List
main=putStrLn$[' '..'~']\\" \\\"$'.=DLS[]aimnoprstu~"

La aburrida solución duplicado-caracteres-en-programa-en-una-cadena, resta del conjunto universal. Lejos de ser un ganador de codegolf, aunque es sorprendentemente legible por su longitud.

(Ahora con sustracción de lista en lugar de filter/ notWith.)

J - 21

(u:32+i.97)-.1!:1<":5

escriba esto en un archivo llamado 5en el directorio actual. Luego carga, ejecuta el script con0!:1<'5'

O 25 sin el truco del archivo:

(-.~".)'(":u:32+i.0-~95)'

Clojure (142, 106103)

(defn -main[](let[c"(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]((load-string c)c)))

formateado:

(defn -main []
  (let [c "(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]
    ((load-string c) c)))

Creo que esto lo hace, puede necesitar algunos ajustes. salida:

#{@ ` ! A B b # C $ D % E & F ' G H I * J + K k , L M . N / O 0 P Q q R S 4 T 5 U V v 7 W w 8 X x 9 Y y : Z z { < | = } > ^ ? _}

ejecuta la cadena, que es un código evaluable de clojure, en sí misma. La cadena tiene algunos comentarios al final para que los caracteres se usen fuera de la cadena (método principal, etc.)

Pitón 2, 69

for x in range(38):print chr(x+59)#!"$%&'*,-./012467bdjklmqsuvwyz{|}~

Utilizo la secuencia más larga (que puedo encontrar) de caracteres continuos que puedo imprimir y agrego los otros como comentario después del código.