Votre tâche consiste à créer un programme (en utilisant uniquement des caractères ASCII imprimables et / ou des onglets et des nouvelles lignes) qui imprime exactement les caractères de l'espace imprimable ASCII ( 0x20à 0x7e) qui n'apparaissent pas dans le code source de votre programme (dans n'importe quel ordre). plusieurs fois que vous voulez).

Le code le plus court pour le faire dans n'importe quelle langue gagne.

GolfScript, 15 12 caractères

{`),32>^.}.~

Basé sur la réponse de Jan Dvorak avec quelques rebondissements et sur le style de celui de Peter Taylor .

Polyglotte, 95

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

• Perl
• Perl 6
• Tout * shell nx-like ( tclsh, bash, sh, ksh, etc.)
• Awk (GNU / POSIX)
• Brainfuck , Brian & Chuck , autres dérivés
• Rubis
• Coffescript
• Golfscript
• Python
• R
• Julia
• Espace blanc
• rk
• Gaot ++
• avant JC
• jq
• Joie
• Tcl
• 99
• V (FMota)
• Acc !!
• C - si non main()est nécessaire. Merci à urogen
• Probablement plus.

Ne fait rien.

PHP 5.2, 4

<?<<

Enregistrer sous un fichier appelé NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.phpquelque part dans /home. short_open_tagdoit être Ondans votre php.ini.

La sortie est:

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

estampes "bcdfghijkmnpquvxyz"

Espace blanc, 61 57 caractères

Ce n'est pas le plus court mais il a probablement la logique la plus simple (c'est vraiment une boucle).

Ici, il est complètement commenté, où S est l'espace, T est la tabulation, L est le saut de ligne:

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

Merci à @res pour la correction ci-dessus (copie supplémentaire requise pour l’instruction de branche) et pour des nombres plus petits pousser sur la pile.

C, 83 74 69 caractères

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

J'ai vraiment essayé de le réduire à moins de 80 caractères, mais je n'ai tout simplement pas réussi à le faire. J'ai finalement décidé de publier ce que j'ai, en partant du principe que moi-même (ou quelqu'un d'autre) trouverai une solution à 79 caractères dix minutes après sa publication. D'accord, ce n'était pas tout à fait dix minutes, mais cela fonctionnait en principe.

Je voulais vraiment publier une version qui n'avait pas besoin d'un espace gratuit dans le code source, mais qui atterrissait dans une orbite étrange, en se balançant entre une poignée de solutions. Après plusieurs minutes d’essais de pousser l’un d’eux à une solution stable, j’ai abandonné et ajouté de l’espace.

Golfscript, 26 24 caractères

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

Prend un script de génération d'intervalle, le duplique, l'exécute, le soustrait de son résultat, puis soustrait le code de soustraction du résultat et l'autre caractère de citation.

Poisson - 80

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

Lorsque le poisson se trompe, il affiche "quelque chose sent le poisson ...". Puisque z est une mauvaise instruction, il se trompe tout de suite

Je sais que ce n'est pas gagner des concours. Je voulais juste l'essayer dans une langue qui n'est pas utilisée normalement, juste pour le plaisir.

Java - 209 195 152 140 caractères

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:"");}}

Avec des sauts de ligne et des tabulations

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:"");
    }
}

Attention si vous exécutez: le programme ne se termine pas. Haha

Explication

1. for(char c=0;;c++): Puisque a charpeut être traité comme un int, j’utilise cela à mon avantage ici pour incrémenter toutes les valeurs possibles de c. J'omets la condition de fin dans la boucle (celle qui irait entre les deux points-virgules) afin d'économiser sur les caractères, car il n'était pas spécifié que le programme devait se terminer. :)
2. "publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"": Malheureusement, ce n’est pas une approche très élégante, mais le travail est fait. Répertoriez manuellement tous les caractères présents dans le code source en tant que Stringlittéral, puis vérifiez si le courant s'y char ctrouve indexOf(). Si l’ indexOf()appel revient -1, il n’existe pas et nous devons donc l’imprimer. Le reste utilise simplement l'opérateur ternaire pour économiser sur les caractères et l'espace.

Perl, 49 caractères

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

C'est un défi intéressant - c'est en quelque sorte l'anti-quine, et j'ai réussi à raccourcir le programme plusieurs fois en augmentant le nombre de caractères qui y figurent.

Ruby, 81 78 68 66 62 57

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

Se vérifie simplement. Les caractères en double ont été supprimés manuellement.

Merci à Josh pour avoir sauvegardé 4 caractères et à minitech pour avoir sauvegardé 5 caractères!

Befunge (48)

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

Sorties: {zyxwvutsrqponmlkjihgfedcba` _ ^] [ZYXWVUTSRQPONMLKJIHGFEDCBA240

Pas très grave, mais je devais essayer:

JSFuck (138152)

(source compilée ici)

Source primaire:

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

Imprime tous les caractères sauf () + []!

Votre tâche consiste à créer un programme (en utilisant uniquement des caractères ASCII imprimables et / ou des tabulations et des nouvelles lignes).

Gosh, vous avez rendu la tâche difficile à APL (est-ce un délit?)
J'ai donc décidé d' ignorer toutes les règles !

APL (Dyalog), 3 10

⎕AV

Imprime le vecteur atomique (qui inclut tous les caractères ASCII imprimables)

Il s'avère que j'ai complètement oublié la partie "sans" ...
Mais c'est une solution facile

⎕AV~'AV'''

~'AV'''signifie exclure ( ~) les caractères A, V et guillemets simples (échappés sous forme de guillemets simples doublés)

En ce qui concerne l’impression non-ASCII, j’ignore toutes les règles.

GolfScript ( 18 16 caractères)

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

Démo en ligne avec une ligne supplémentaire qui effectue une vérification de l'exactitude et affiche le nombre de caractères erronés.

(J'ai plusieurs alternatives équivalentes. @`^Peuvent être remplacées par \\`; #peuvent être remplacées par `ou ]. La bonne combinaison peut être utilisée avec le tour d'Howard pour égaler son score de 15, car les barres obliques inversées n'ont pas besoin de s'échapper par blocs comme elles le sont dans les littéraux de chaîne: {),\`^32>].~}.~Mais Howard mérite le crédit pour ce tour).

Brainfuck, 173

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

Assez longtemps, je pourrais réessayer plus tard.

J ( 52 40)

Edit: Duh, oublié e.

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

Ancienne version:

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

Autre variante (même longueur mais moins sortie):

([#~*/"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)

... Merci à @WolframH pour les améliorations.

PowerShell: 96

Doit être enregistré et exécuté en tant que script.

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

diffest un alias intégré pour Compare-Object.

gcest un alias intégré pour Get-Content.

$MyInvocation.InvocationName obtient le chemin complet du script en cours d'exécution.

32..126est l'équivalent décimal de 0x20..0x7e, et crée ainsi un tableau des codes ASCII décimaux que nous recherchons.

[char[]]prend le contenu de l'objet suivant et le met dans un tableau, le divise et le convertit en caractères ASCII. Nous avons donc maintenant deux tableaux de caractères ASCII: l’un tiré de ce script, l’autre défini par les critères de challenge.

-Padéfinit le Compare-Objectformat "Passthru", de sorte que seuls les éléments qui se trouvent différents entre les entrées sont sortis sur la console - les indicateurs indiquant les éléments dans lesquels les entrées sont toujours stockées dans les données de l'objet, mais ne sont pas affichés.

|?{$_.SideIndicator-eq'=>'}Compare-ObjectLa sortie de pipes to Where-Object, qui la filtre en fonction des éléments exclusifs à la seconde entrée.

PHP - 92

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

Sortie:

rien

Le PO demande à imprimer tous les caractères non utilisés, eh bien, je les utilise tous

Javascript, 92

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

Java - 126 caractères

minimisé:

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

non minimisé:

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

Ceci est un problème intéressant, car les jetons individuels pourraient bénéficier de leur forme plus longue car ils réutilisent des caractères. Par exemple, normalement String[]serait plus court, mais String...supprime la nécessité des crochets dans la chaîne conditionnelle.

J'ai trouvé que le truc était d'essayer d'utiliser des caractères au début et à la fin de la plage pour pouvoir les exclure de la sortie simplement en modifiant le début et la fin de votre boucle.

Pour Java, un caractère de clé à exclure est ", car avoir cela dans la chaîne nécessite de l'échapper, ce qui ajoute \à votre programme, ce qui doit aller dans la chaîne, ce qui ajoute \\. En supprimant "de votre chaîne conditionnelle, vous supprimez 4 caractères. Ceci peut être réalisé en veillant à ce que vous utilisez et !et démarrer votre boucle à partir #.

Toutes les lettres minuscules apparaissent à la fin de la plage, avec seulement {, |, }et à ~venir après eux. En raison de la verbosité de Java, la plupart des lettres minuscules sont utilisées uniquement pour le passe-partout. De même, {et }sont triviales pour un programme Java, parce que le passe-partout les requiert.

|peut être utilisé si vous avez une condition ou, mais je ne trouvais pas le moyen de tirer parti d’une condition qui conduirait à un programme plus court qu’un simple emploi en |tant qu’opérateur au niveau du bit. La |0me fait me sentir un peu sale, car il est la seule partie qui est un nop juste pour obtenir le caractère là - dedans.

~0les rendements -1, ce qui est pratique car c’est ce que nous devons vérifier indexOf. En combinant ceci avec l'utilisation !=de la boucle conditionnelle, le <caractère est totalement éliminé , ce qui signifie qu'il n'est pas nécessaire d'entrer dans la chaîne conditionnelle.

sh (47)

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

Utilise l'approche auto-référentielle. Suppose que /dev/urandomtous les octets seront finalement sortis au moins une fois. Ne se termine pas.

Si nous supposons que cela manest installé, nous pourrions utiliser la ascii(7)page de manuel (et avoir ainsi un programme de terminaison) ( 44 caractères, merci @fennec).

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

BitShift , 1038 octets

BitShift est un langage qui ne supporte que 0et 1comme syntaxe. Je pensais qu'il serait facile d'imprimer tous les autres caractères, mais comme il ne supportait pas vraiment la boucle, il restait encore un énorme 1038 octets.
Cependant, je crois qu’il n’est pas vraiment possible de faire plus petit que cela.

101001100101011011010100110111010100100101011001101111010100100101011001000101011011010100101100110110101001001010110010001010110110101000001101010010010101100100010101101101010000010000011001010110110101000010000101011011010100110111010100100101011111100101011011010100110111010100100101011001101111010100100101011001000101011011010100000000011010100100101011001000101011011010100110010000101011011010100110111010100100101011001101001101010010010101100100010101101101010011001000010101101101010011011101010010010101111011111110010101101101010011011101010010010101100101100101011011010100010001010110110101001000010101101101010011011101010010010101110111110010101101101010011011101010010010101111111100101011011010100110111010100100101011111011110101001001010110010001010110110101001000100000101011011010100110111010100100101011111010011010100100101011001000101011011010100100000101011011010100110111010100100101011001101111010100100101011001000101011011010100010000010101101101010011011101010010010101101001101101010010010101101001101010

Impressions

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

Essayez-le ici

La solution la plus longue ici, mais coder dans Lino est toujours amusant:

L.in.oleum -655 523 caractères

"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;

Pas de commentaire, lit simplement le source compilé en binaire. Enregistrez sous a.txtou ne compilerez pas!

Brainfuck, 133 123 114 110 octets

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

Un peu plus de bricolage avec une ancienne solution (avant que je réalise que le dessous était plus petit - bien que ce fût avant que je ne fasse une optimisation lourde). Cela fonctionne en stockant 4 séries de numéros ascii et en les imprimant avec des boucles délicates, puis en donnant les caractères manquants par la suite (c.-à-d. Ceux se trouvant entre des numéros ascii non valides).

Soumission originale

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

Il fait ce qui suit:

• Créez 4 registres contenant 11. 13, 28, 33
• Créez une cinquième avec la valeur 31 pour lancer l'impression
• Imprimer ascii 32-42 (11)
• Imprimer ascii 44
• Imprimer ascii 47-59 (13)
• Imprimer ascii 61
• Imprimer ascii 63-90 (28)
• Imprimer ascii 92
• Imprimer ascii 94-126 (33)

Haskell (70)

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

La solution ennuyeuse de doublons-caractères-dans-programme-dans-une-chaîne, soustrait-de-universel-set. Loin d'un vainqueur de code-golf, sa longueur est étonnamment lisible.

(Maintenant avec soustraction de liste au lieu de filter/ notWith.)

J - 21

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

écrivez ceci dans un fichier appelé 5dans le répertoire en cours. Puis chargez le script avec0!:1<'5'

Ou 25 sans l'astuce de fichier:

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

Clojure (142, 106, 103)

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

formaté:

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

Pense que cela le fait, peut-être besoin de quelques ajustements. sortie:

#{@ ` ! 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 { < | = } > ^ ? _}

exécute la chaîne, qui est un code pouvant être évalué, sur elle-même. String a quelques commentaires à la fin pour obtenir les caractères utilisés en dehors de la chaîne (méthode principale, etc.)

Python 2, 69

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

J'utilise la plus longue séquence (que je suis capable de trouver) de caractères continus que je peux imprimer et ajouter les autres comme commentaire après le code.