Los caracteres ASCII del código decimal 33 a 126 son:

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

Tenga en cuenta que en la mayoría de las fuentes, 25 de estos caracteres tienen "agujeros" en ellos: (un género mayor que 0 se podría decir)

#$%&04689@ABDOPQRabdegopq

Los otros 68 personajes "no desenterrados" son:

!"'()*+,-./12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\]^_`cfhijklmnrstuvwxyz{|}~

Su tarea es escribir el programa más corto posible utilizando solo los caracteres sin orificios que generan cada uno de los caracteres con orificios exactamente una vez en cualquier orden.

Dado que el espacio, la pestaña y las nuevas líneas (avance de línea y / o retorno de carro) son espacios vacíos, pueden aparecer en su programa o en su salida. Todavía cuentan para la cantidad de personajes. No se pueden usar otros caracteres ASCII (y ciertamente no caracteres no ASCII).

Notas

• No tiene que usar todos los caracteres no desechados ni solo uno de cada uno.
• La salida no puede contener caracteres sin orificios.
• El lenguaje de espacios en blanco puede usar el .
• La salida debe ir a stdout o puede ir a un archivo. No debe haber ninguna entrada.

Bonificación: solo por diversión, intente imprimir todos los caracteres no deseados utilizando los caracteres ocultos. Soy escéptico de que se pueda hacer en un idioma existente.

Pyth , 43 35 caracteres

tTFk"*+,-7;=?GHIKVWXYhiklnvwx"C-Ck7

Probarlo aquí .

Imprime los caracteres en orden, excepto que 9 está al principio, nueva línea separada.

La cadena contiene todos los caracteres 7 mayores que los necesarios, excepto que 9 se convertiría en @, por lo que es un caso especial. Algoritmo gracias a @Howard.

Explicación:

tT                print(10-1)                T=10, t(x)=x-1 if x is an int.
Fk"<string>"      for k in "<string>":
C-Ck7             print(chr(ord(k)-7))       Note that C is overloaded as ord and chr.

GolfScript, 37 36 caracteres

[":=<?)-/! YX[]VIHKx{}|~vih"{25^}/]+

Prueba el código aquí .

La cadena contiene los caracteres prohibidos xor'ed con 25. Afortunadamente, todos los caracteres se asignan a los válidos.

Brainfuck 119

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

Bonus - dc, 179 caracteres

Oh bien, otro desafío de juego de caracteres restringido donde Pestá permitido.

6A44469PD684P44D4898PDB99P4008D0BP486B48BPA60BPD096P4A68666P460A0D4P690490AP8084088P6B6AB66P6BBB608P80D4BAAPA046PBAD4P60A6668P480DD96P4A040BBP848BP40DD8D0P46840B6P696B48BP48D64BAP

Como dcaparentemente es lo suficientemente oscuro como para requerir una explicación (¡extraño para mí teniendo en cuenta las cosas raras por aquí!) Aquí hay una descripción general:

Es principalmente una calculadora RPN con aritmética de precisión arbitraria. Pero para este desafío, estoy haciendo uso del Pcomando, que interpreta un número como una serie de caracteres en la base 256 y los imprime. Ejemplos: 65 Pimpresiones A(código ASCII 65). 16706 Pimpresiones AB(16706 = 65 * 256 + 66).

Aparte de eso, la única otra característica interesante es que reconoce todos los dígitos hexadecimales, 0-9A-Fincluso cuando no están contenidos en un número hexadecimal. La entrada decimal es la predeterminada, por lo que el token de entrada 999significa 9 hundreds + 9 tens + 9y ABCsignifica 10 hundreds + 11 tens + 12hacer que sea equivalente a 1122.

La capacidad de usar los dígitos ABDen decimal compensa parcialmente la incapacidad de uso 12357, y la elección de ordenar y agrupar hace el resto. (Si necesito algunos números x, y, zy no son representables con dígitos permitidos, entonces trato que representa x*256*256+y*256+zen su lugar.)

El programa probablemente se puede acortar un poco usando grupos más grandes. No pasé 3 bytes por número.

Bash + coreutils, 56 bytes

tr \(-y \!-r<<<'*+,-7;=?GHIKVWXYhiklnvwx'
tr C-F 7-:<<<E

Por suerte, agregar 7 al valor ascii de los caracteres guardados produce todos los caracteres no guardados (con la excepción de "9"). Así que solo hacemos esta transformación a la inversa, luego una transformación similar (resta 12 de "E") para obtener el "9".

Salida:

#$%&0468@ABDOPQRabdegopq
9

Perl - 49 bytes

symlink".",':=<?)-/! YX[]VIHKx{}|~vih'^chr(25)x25

Esta es más o menos una versión de Perl de la solución de Howard. XORing la cadena con 25. La salida es un archivo con el nombre #$%&04689@ABDOPQRabdegopq. Se me ocurrió la idea de usarsymlink y el nombre del archivo como formato de salida porque todo lo demás está prohibido.

Aquí hay otra solución de Perl que se me ocurrió. Probablemente se puede mejorar mucho y es bastante largo, por lo que me voy en un formato legible por ahora.

until(y/1/1/>32){s//1/}
until(y/1/1/>125+1){
    if(chr(y/1/1/)!~/[!"'()*+,-.\/12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\\\]^_`cfhijklmnrstuvwxyz{|}~]/) {
        symlink".",chr y/1/1/;
    }
    s/^/1/
}

Este genera muchos archivos, el nombre de cada uno es uno de los caracteres. No pude encontrar la manera de agregar cadenas sin usar un carácter prohibido.

for, while, map, say, print, eval, s///e, Y cualquier nombre de variable no se puede utilizar (las variables comienzan con @o$ en Perl) que hizo que esto sea difícil.

Esperemos que los nombres de archivo estén bien como formato de salida porque estoy bastante seguro de que cualquier otra forma de generar información utiliza uno de los caracteres prohibidos.

MATLAB, 36 bytes

TAN CERCA ... ¡Solo 1 byte más que el ganador actual (isaacg)! Lo cual, en una inspección posterior, ya hizo lo que me propuse hacer también. Bueno, no hay daño en reinventar la rueda ...

Sé que este es un viejo desafío, pero solo me di cuenta de eso después de que me interesé.

['*+,-7;=?GHIKVWXYhiklnvwx'-7,57,'']

Si tan solo pudiera hacer que MATLAB entendiera que quiero una cadena sin una ''... sugerencias, ¿alguien?

Brainfuck 303 275

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

Brainfuck, el último lenguaje esotérico sin orificios (aparte del espacio en blanco);)

JS - 196 - pruébalo

h=(c=!1+[])[1];i=c[2*2];j=(f=[]+{})[1];this[i+'v'+h+'l'](h+'l'+i+'rt('+h+'t'+j+f[2]+'("Iy\x51lJj\\x'+2*2+'1\\x3'+~-1+'Nj\\x'+2*3+'75\x51EFC\x52E\\x3'+3*3+'\x51UVJhYm\x52lZ2\\x3'+3*3+'wc\x51=="))')

GolfScript, 89 caracteres

71 22+,{33+}/]''+'!"\'()*+,-./12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\]^_`cfhijklmnrstuvwxyz{|}'-

Simplemente construye una matriz de todos los caracteres ASCII y resta de ellos los caracteres que no están "guardados".

71 22+,  # Builds array of 0..93
{33+}/]  # Converts to 33..126
''+      # Convert ASCII codes to string
'stuff'- # Subtracts "stuff" (the non-holed characters) from the string

Befunge 98 - 69 bytes

"()+ijWI=*">:5j2 ,-5_"157:h">:5j2 ,-1_"=>?LMN^_lmn">:5j2 ,+3_"?"1+s <

Lo hace en 3 partes. Uno en el que los valores de los personajes no alojados difieren del carácter oculto en 5. Luego, los valores que difieren en 1 y, finalmente, una lista de los caracteres no alojados que difieren en 3 de los caracteres ocultados. La instrucción de finalización del programa en Befunge es "@" (valor de char 64), así que al final cargo "?" (valor de carácter 63) agregue 1 y luego póngalo en el código con la instrucción 's'.

Tal vez podría jugar más golf al consolidar los tres

>:5j2 ,(differ value)_

sección, pero probablemente no por mucho.

JavaScript 240 228

Presentación inicial:

z=(!1+"")[1];y=(!!1+"")[3];x={}+"";w=x[1];v=x[2];u=z+"t"+w+v;1[_="c\157nstruct\157r"][_](z+'l'+y+'rt('+u+'("Iy\x51lJj"+'+(t=u+'("\x51\x51==")')+'+'+u+'("M"+'+t+'+"==")+"Nj"+'+u+'("Zw==")+"5\x51EFC\x52E\71\x51UVJhYm\x52lZ2\71wc\x51=="))')()

Ahora, este es un gran comienzo, así es como se descompone ...

z=(!1+"")[1];        // assigns "a" to z, !1+"" === "false"
y=(!!1+"")[3];       // assigns "e" to y, !!1 === "true"
x={}+"";             // assigns "[object Object]" to x
w=x[1];v=x[2]        // assigns "o" to w, and "b" to v
u=z+"t"+w+v;         // creates the mystical "atob" command, yes, I'm gonna use it!
1[_="c\157nstruct\157r"][_] // sets up the primitive to a number object... this acts similar to the "window" primitive object so that I can play off functions...
z+'l'+y+'rt(         // starts creating an alert call
'+u+'("Iy\x51lJj"+'+(t=u+'("\x51\x51==")')+'+'+u+'("M"+'+t+'+"==")+"Nj"+'+u+'("Zw==")+"5\x51EFC\x52E\71\x51UVJhYm\x52lZ2\71wc\x51=="))')()
// Above line abuses atob command with a couple of nested instances of the command, also using hex and octal equivalents of characters

Y luego pensé ... "Debe haber una forma más simple ..." y hay ...

Presentación revisada: z=(!1+"")[1];y=(!!1+"")[3];x={}+"";w=x[1];v=x[2];u=z+"t"+w+v;this[y+"v"+z+"l"](z+'l'+y+'rt('+u+'("Iy\x51lJj"+'+(t=u+'("\x51\x51==")')+'+'+u+'("M"+'+t+'+"==")+"Nj"+'+u+'("Zw==")+"5\x51EFC\x52E\71\x51UVJhYm\x52lZ2\71wc\x51=="))')

Al ver que puedo usar eval (al unirlo, inspiración de @bebe; que es mucho más rápido que usar el constructorde un constructorde number...) Lo profundicé hasta 228 ... Sé que puede que no gane este particular Golf Challenge , pero esta es solo mi manera de mostrar cuánto puede abusar de JavaScript y aún así obtener el resultado deseado ...

Principal - Insomnio , 50

FFy~~jF~y<={*n<<ztf>={.f=(tHL~k<yf={*n>Lj(FunLn<j~

Produce:

abdegopq04689@ABDOPQR#$%&

Bono - Insomnio, 268

ogeeoddp@poe@ggep@oe@opge@gee@%d@p@gqeo@p@ge@e9de49ed9e4dppe@%e@geee@ge@p%ee@%e@dp@%ep@%ee@%d@%eeee@%e@%ee@%e@geee@%e@gee@ggopop@peo@ggep@p@ge@ggeep@ge@gee@%e@geee@ge@gee@ge@ppoep@%ee@%edep@gepe@ge@%ee@%e@geee@ge@%ee@%%eeoe@ge@pep@%gep@p@%e@%%eep@%e@gee@e%e@oe@%gep@p@

Produce:

!"'()*+,-./12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\]^_`cfhijklmnrstuvwxyz{|}~

Creo que debería ser posible reducir la duración del programa si la salida se reorganiza, pero necesito modificar mi programa de búsqueda para hacer esto.

Solo para mostrar el caso en otro idioma que es capaz de operar con un número restringido de caracteres. Por cierto, puede escribir casi cualquier salida con solo 3 caracteres únicos en la fuente.

Actualmente, este es el único lenguaje que puede hacer tanto el desafío principal como la bonificación entre todas las respuestas existentes.

Intérprete de insomnio .

Befunge 98 - 46 bytes

Versión de Iffunge-ified de la entrada Pyth de isaacg:

"xwvnlkihYXWVKIHG?=;7-,+*">:5j2 ,-7_"?"1+:,s <

Japt , 33 bytes

7+2+"*+,-7;=?GHIKVWXYhiklnvwx"c-7

Pruébalo en línea!

Mismo algoritmo que la presentación Pyth de Isaac , resulta ser más corto en Japt.

Cómo funciona

7+2+"*+,-7;=?GHIKVWXYhiklnvwx"c-7

7+2           Obviously the number 9
    "..."c-7  Apply -7 on each char's charcode of this string
   +          String concatenation

Sí, es JS, que es uno de los lenguajes más abusivos , solo que más corto (y no lo necesitas alertni console.logaquí).