Les caractères ASCII du code décimal 33 à 126 sont:

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

Notez que dans la plupart des polices, 25 de ces caractères ont des "trous": (un genre supérieur à 0, pourriez-vous dire)

#$%&04689@ABDOPQRabdegopq

Les 68 autres personnages "non masqués" sont:

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

Votre tâche consiste à écrire le programme le plus court possible à l’aide des seuls caractères non masqués, générant chacun des caractères troués exactement une fois, dans n’importe quel ordre.

Etant donné que les espaces, tabulations et nouvelles lignes (saut de ligne et / ou retour chariot) sont des espaces vides, elles peuvent apparaître dans votre programme ou dans sa sortie. Ils comptent toujours pour le nombre de caractères. Les autres caractères ASCII ne peuvent pas être utilisés (et certainement pas les caractères non-ASCII).

Remarques

• Vous n'êtes pas obligé d'utiliser tous les caractères non masqués, ni un seul de chacun.
• La sortie ne doit pas contenir de caractères non masqués.
• Le langage Whitespace peut être utilisé.
• La sortie devrait aller à stdout ou peut aller dans un fichier. Il ne devrait y avoir aucune entrée.

Bonus: Juste pour le plaisir, essayez d'imprimer tous les personnages impossibles à l'aide des caractères troués. Je suis sceptique sur le fait que cela peut être fait dans une langue existante.

Pyth , 43 35 caractères

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

Essayez ici .

Imprime les caractères dans l’ordre, sauf que 9 est au début, séparés par une nouvelle ligne.

La chaîne contient tous les caractères 7 supérieurs à ceux nécessaires, sauf que 9 deviendrait un @, il est donc casé spécial. Algorithme grâce à @Howard.

Explication:

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 caractères

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

Essayez le code ici .

La chaîne contient les caractères interdits xorés avec 25. Heureusement, tous les caractères sont mappés sur ceux qui sont valides.

Brainfuck 119

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

Bonus - dc, 179 caractères

Oh bien, un autre défi de jeu de caractères restreint où Pest autorisé.

6A44469PD684P44D4898PDB99P4008D0BP486B48BPA60BPD096P4A68666P460A0D4P690490AP8084088P6B6AB66P6BBB608P80D4BAAPA046PBAD4P60A6668P480DD96P4A040BBP848BP40DD8D0P46840B6P696B48BP48D64BAP

Puisque dcest apparemment assez obscur pour exiger une explication (étrange pour moi compte tenu des choses étranges ici!), Voici un aperçu:

C'est principalement une calculatrice RPN avec une arithmétique à précision arbitraire. Mais pour ce défi, je me sers de la Pcommande, qui interprète un nombre comme une série de caractères en base 256 et les imprime. Exemples: 65 Pimpressions A(code ASCII 65). 16706 Pimpressions AB(16706 = 65 * 256 + 66).

En dehors de cela, la seule autre caractéristique intéressante est qu'il reconnaît tous les chiffres hexadécimaux, 0-9A-Fmême s'ils ne sont pas contenus dans un nombre hexadécimal. L'entrée décimale étant la valeur par défaut, le jeton d'entrée 999signifie 9 hundreds + 9 tens + 9et ABCsignifie le 10 hundreds + 11 tens + 12rendre équivalent à 1122.

La possibilité d'utiliser les chiffres ABDen décimal compense en partie l'incapacité à utiliser 12357, et le choix de l'ordre et du regroupement fait le reste. (Si je besoin de quelques chiffres x, y, zet ils ne sont pas représentables avec des chiffres autorisés, alors j'essaie représenter la x*256*256+y*256+zplace.)

Le programme peut probablement être légèrement raccourci en utilisant des groupes plus importants. Je n'ai pas dépassé 3 octets par numéro.

Bash + coreutils, 56 octets

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

Comme par hasard, ajouter 7 à la valeur ascii des caractères perforés génère tous les caractères non masqués (à l'exception de "9"). Nous effectuons donc simplement cette transformation à l’inverse, puis une transformation similaire (soustrayez 12 de "E") pour obtenir le "9".

Sortie:

#$%&0468@ABDOPQRabdegopq
9

Perl - 49 octets

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

C'est à peu près une version Perl de la solution de Howard. XORing la chaîne avec 25. La sortie est un fichier avec le nom #$%&04689@ABDOPQRabdegopq. J'ai eu l'idée d'utiliser symlinket le nom du fichier comme format de sortie car tout le reste est banni.

Voici une autre solution Perl que j'ai proposée. Cela peut probablement être beaucoup amélioré et c'est assez long, alors je pars dans un format lisible pour le moment.

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

Celui-ci génère de nombreux fichiers, le nom de chacun d'eux étant l'un des caractères. Je ne pouvais pas comprendre comment ajouter des chaînes sans utiliser un caractère interdit.

for, while, map, say, print, eval, s///eEt un nom de variable ne peut pas être utilisé (variables commencent par @ou $en Perl) qui a rendu la tâche difficile.

J'espère que les noms de fichiers sont acceptables en tant que format de sortie car je suis à peu près sûr que tous les autres moyens de produire des informations utilisent l'un des caractères interdits.

MATLAB, 36 octets

SO CLOSE .... Seulement 1 octet de plus que le gagnant actuel (isaacg)! Ce qui, après une inspection plus poussée, a déjà fait ce que je voulais faire aussi. Eh bien, pas de mal à réinventer la roue ...

Je sais que c'est un vieux défi, mais je ne m'en suis rendu compte qu'après m'être intéressé.

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

Si seulement je pouvais faire comprendre à MATLAB que je veux une chaîne sans autre ''suggestion ... suggérée, ça vous tente ?

Brainfuck 303 275

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

Brainfuck, le langage ésotérique ultime et impie (à part Whitespace);)

JS - 196 - l' essayer

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 caractères

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

Génère simplement un tableau de tous les caractères ASCII et en soustrait les caractères non "masqués".

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 octets

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

Est-ce en 3 parties. Une où les valeurs de caractère non masquées diffèrent de 5 le caractère percé. Ensuite, celles qui diffèrent de 1, et enfin une liste de caractères non divisés qui diffèrent de 3 à partir de ceux percés. L'instruction de fin de programme dans Befunge est "@" (valeur de caractère 64), donc à la fin je charge "?" (valeur de caractère 63), ajoutez 1, puis mettez cela dans le code avec l'instruction 's'.

Je pourrais peut-être jouer au golf plus en consolidant les trois

>:5j2 ,(differ value)_

section, mais probablement pas par beaucoup.

JavaScript 240 228

Soumission initiale:

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=="))')()

Voilà un bon début, voici comment cela se décompose ...

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

Et puis j'ai pensé ... "Il doit y avoir un moyen plus simple ..." et il y a ...

Soumission révisée: 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=="))')

Voyant que je peux l’utiliser eval (en assemblant les éléments, en s’inspirant de @bebe; ce qui est beaucoup plus rapide que d’utiliser constructorun élément constructorde number...), je l’ai descendue à 228 ... Je sais que ce ne sera peut-être pas le cas de ce Golf Challenge. , mais c’est ma façon de montrer à quel point vous pouvez abuser de JavaScript et obtenir le résultat souhaité ...

Main - Insomnie , 50

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

Il produit:

abdegopq04689@ABDOPQR#$%&

Bonus - Insomnie, 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@

Il produit:

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

Je pense qu'il devrait être possible de réduire la longueur du programme si la sortie est réorganisée, mais je dois modifier mon programme de recherche pour le faire.

Juste pour montrer le cas une autre langue qui est capable de fonctionner avec un nombre limité de caractères. À propos, il peut écrire à peu près n'importe quelle sortie avec seulement 3 caractères uniques dans la source.

Actuellement, c'est la seule langue qui peut faire à la fois le défi principal et le bonus parmi toutes les réponses existantes.

Interprète de l'insomnie .

Befunge 98 - 46 octets

Befunge-ified version de l'entrée Pyth de isaacg:

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

Japt , 33 octets

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

Essayez-le en ligne!

Même algorithme que la soumission Python d’isaacg , il est juste plus court dans Japt.

Comment ça fonctionne

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

Oui, c'est JS, qui est l' une des langues les plus abusables , juste plus courte (et vous n'avez pas besoin alertou console.logici).