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

No es muy serio, pero tuve que intentarlo:

JSFuck (138152)

(fuente compilada aquí)

Fuente original:

for(x=0x7e;x>0x19;x--){
    console.log(String.fromCharCode(x).replace(/[\[\]!\+\(\)]/ig, ''))
}

Imprime todos los caracteres excepto () + []!

Su tarea es crear un programa (utilizando solo caracteres ASCII imprimibles y / o pestañas y líneas nuevas)

Gosh, lo hiciste difícil para APL (¿es eso deliberar?)
Así que decido ignorar todas las reglas !!!

APL (Dyalog), 3 10

⎕AV

Imprime el vector atómico (que incluye todos los caracteres ASCII imprimibles)

Resulta que olvidé por completo la parte "sin" ...
Pero esa es una solución fácil

⎕AV~'AV'''

~'AV''' significa excluir (~ ) los caracteres A, V y comillas simples (se escaparon como comillas simples duplicadas)

Con respecto a la impresión que no es ASCII, bueno, estoy ignorando todas las reglas.

GolfScript ( 18 16 caracteres)

"),@`^^32>#.~".~

Demostración en línea con una línea adicional que verifica la corrección y genera el número de caracteres por error.

(Tengo varias alternativas equivalentes. @`^Se puede reemplazar con \\`; #se puede reemplazar con `o ]. La combinación correcta se puede usar con el truco de Howard para igualar su puntaje de 15 porque las barras invertidas no necesitan escapar en bloques como lo hacen en los literales de cadena: {),\`^32>].~}.~Pero Howard merece el crédito por ese truco).

Brainfuck, 173

+++++[->++++++<]>>>++[------<+>]<++++>>----[----<+>]>-[-------<+>]>-[---<+>]<------->>-[---<+>]<+++++++++>>--[-----<+>]<+++++>>+[---------<++>]+++++++++++++[<[.+<]>[>]<-]\=,

Bastante largo, podría intentarlo más tarde.

J ( 52 40)

Editar: Duh, se olvidó de e.

'''(-@.e#[)~95{32}a'(-.@e.#[)~95{.32}.a.

Versión antigua:

(>@(*/@('(>@*/''&~:).#]32{95}a'&~:)&.>)#])95{.32}.a.

Otra variante (misma longitud pero menos salida):

([#~*/"1@('([#~*/"1@''&:0)95{.32}a'&~:"0))95{.32}.a.

Python 3 - 68 61

x=r"print(*set(map(chr,range(32,127)))-set(x+'=\"'))"
exec(x)

... gracias a @WolframH por las mejoras.

PowerShell: 96

Debe guardarse y ejecutarse como un script.

diff([char[]](gc $MyInvocation.InvocationName))([char[]](32..126))-Pa|?{$_.SideIndicator-eq'=>'}

diff es un alias incorporado para Compare-Object.

gces un alias incorporado para Get-Content.

$MyInvocation.InvocationName obtiene la ruta completa al script que se está ejecutando.

32..126es el equivalente decimal para 0x20..0x7ey, por lo tanto, crea una matriz de los códigos decimales ASCII que estamos buscando.

[char[]]toma el contenido del siguiente objeto y los coloca en una matriz, dividiéndolos y convirtiéndolos en caracteres ASCII. Entonces, ahora tenemos dos conjuntos de caracteres ASCII: uno extraído de este script y el otro definido por los criterios de desafío.

-Pa conjuntos Compare-Object en formato "Passthru", por lo que solo los elementos que se encuentran diferentes entre las entradas se emiten en la consola; los indicadores de qué elementos estaban en qué entrada todavía se almacenan en los datos del objeto, pero no se muestran.

|?{$_.SideIndicator-eq'=>'}Compare-Objectsalida de tuberías a Where-Object, que lo filtra solo a los elementos que son exclusivos de la segunda entrada.

PHP - 92

<? //A"$%&'()*+[,.]0123456789:=-@ABCDEFGHIJKLMNOPQRSTUVWYZ\^_`abcdefghijklmopqrstuvwxyz{|}~#

Salida:

nada

El OP pide imprimir todos los caracteres no utilizados, bueno, solo los uso todos

Javascript, 92

(function f(){for(i=32;126>i++;)!~(""+f).indexOf(c=String.fromCharCode(i))&&console.log(c)})()

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.