Défi

Ecrivez un programme qui réorganise les caractères ASCII!

Il devrait générer une seule chaîne contenant tous les caractères imprimables ASCII. Le premier caractère de cette chaîne se voit attribuer la valeur 1, le second la valeur 2, etc.

Si deux caractères sont normalement l'un à côté de l'autre (la différence entre leurs codes de caractère est égal à 1), ils ne peuvent pas apparaître l'un à côté de l'autre dans la sortie.

Notation

Votre score sera la somme des valeurs de tous les caractères de votre code source, tel que dicté par la sortie de votre programme.

Veuillez consulter la section Vérification pour calculer votre score.

Le score le plus bas gagne!

Règles

• "ASCII imprimable" désigne les codes de caractères 32 à 126 inclus.

• Vous pouvez écrire un programme complet ou une fonction.

• Votre code ne peut contenir que des caractères ASCII imprimables et des nouvelles lignes.

• Votre programme ne peut prendre aucune entrée.

• Les nouvelles lignes auront toujours la valeur 1. La sortie de votre programme ne doit pas inclure de nouvelle ligne.

Vérification

Utilisez cet extrait de pile pour vérifier que la sortie de votre code est valide et pour calculer le score de votre code!

var result = document.getElementById("result");document.getElementById("submit").onclick = function() {var code = document.getElementById("code").value;var output = document.getElementById("output").value;var values = [];for (var i = 0; i < output.length; i++) {var c = output[i];var v = c.charCodeAt();if (v < 32 || v > 126) {result.innerHTML = "Invalid output! Reason: `" + c + "` (code " + v + ") is out of range.";return;}if (values.indexOf(c) >= 0) {result.innerHTML = "Invalid output! Reason: `" + c + "` (code " + v + ") was repeated.";return;}if (i > 0) {var d = output[i - 1];var w = d.charCodeAt();if (Math.abs(v - w) == 1) {result.innerHTML = "Invalid output! Reason: `" + d + "` and `" + c + "` (codes " + w + " and " + v + ") cannot appear next to each other in the output.";return;}}values.push(c);}for (var j = 32; j <= 126; j++) {var c = String.fromCharCode(j);if (values.indexOf(c) < 0) {result.innerHTML = "Invalid output! Reason: `" + c + "` (code " + j + ") was missing.";return;}}var score = 0;for (var k = 0; k < code.length; k++) {var s = values.indexOf(code[k]) + 1;if (s <= 0) s = 1;score += s}result.innerHTML = "Your score is " + score + "!";}

<textarea id="code" rows=10 cols=50>Enter your code here.</textarea><br/><textarea id="output" rows=1 cols=50>Enter your code's output here.</textarea><br/><button id="submit">Submit</button><br/><p id="result"></p>

Classement

Merci à ce post pour le code de classement!

var QUESTION_ID=57914,OVERRIDE_USER=42844;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

CJam, 356 186 168 131 126 111 111 99 96 94

"_|`'~,Y/G>z`|"_~

Essayez-le en ligne dans l' interprète CJam .

Sortie

"_|`'~,Y/G>z[ \$&(*.02468:<@BDFHJLNPRTVXZ^bdfhjlnprtvx!#%)+-13579;=?ACEIKMOQSUW]acegikmoqsuwy{}

Idée

En utilisant une variante d’une technique courante dans CJam Quines, nous trions les caractères ASCII imprimables selon qu’ils apparaissent ou non dans le code source, et les caractères non apparents - à deux exceptions près - selon les bits de parité de leurs points de code.

Avec la mise en page source appropriée, nous parvenons également à trier les caractères du code source - à une exception près - en fonction de leur fréquence.

Il faut veiller tout particulièrement à ce que deux caractères adjacents n'apparaissent pas l'un après l'autre pour la première fois dans le code source, car cela invaliderait la réponse.

Code

"             "_~  Push a string, duplicate it and evaluate the copy.
 _|                Perform the set union of the original string with itself.
                   This is just an "excuse" to introduce the underscore.
   `               Inspect the string (surrounds it with double quotes).
    '~,            Push the string of Unicode characters before the tilde.
       Y/          Divide it into pairs.
         G>        Discard the first 16 pairs (control characters).
           z       Zip. This interleaves the pairs, ordering the characters
                   by their code points' parities.
            `      Inspect the array, i.e., push its string representation.
             |     Perform set union with the string of source code characters.

Brainfuck, 1692 826 765

(Encore) non optimisé, je sais. Je travaille dessus (la permission est laissée dans les commentaires).

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

Sortie:

+->.<[] "$&(*,02468:@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~{}ywusqomkigeca_YWUSQOMKIGECA?=;97531/)'%#!

J'utilise déjà le dépassement de capacité sur les cellules 8 bits dans une certaine mesure, mais je suppose que vous pouvez toujours l'optimiser. Bien que cela diminuerait l'utilisation de caractères bon marché :).

Pyth, 173 170

Code

-so%CN2rd\~p"p~\dr2NC%os-

Sortie

p~\dr2NC%os- "$&(*,.0468:<>@BDFHJLPRTVXZ^`bfhjlntvxz|!#')+/13579;=?AEGIKMOQSUWY[]_acegikmquwy{}

Coder en dur une chaîne de type quine. Commodément, le" caractère est très proche du début de la chaîne générée. Imprime même alors les caractères impairs après la "quine".

Merci beaucoup à Dennis d'avoir économisé 3 points et d'avoir rendu le code palindomé!

Essayez-le ici

Java, 3518 3189 2692

Une boucle simple qui imprime même des caractères, puis des cotes. J'ai essayé plusieurs choses pour optimiser les ASCII précédents, mais la plupart ont fini par le rendre plus long et ont obtenu un score plus élevé.

void A(){for(char A=31;A!=126;System.out.print(A+=2))A=A==125?30:A;}

La sortie est:

!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{} "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~

Edit: mal compris le score au début. Après l’avoir retourné en premier, puis en égal, il a obtenu de bien meilleurs résultats.

Octave, 628

Code

["" 32:2:126 33:2:125]

Sortie:

 "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}

Deux plages converties implicitement en chaîne. Pas sûr que retourner en Ans soit acceptable, donne également un avertissement concernant la conversion implicite. J'ai essayé d'autres vecteurs de distance, mais je n'ai rien trouvé de plus efficace.

C, 42 octets, score 1539

main(i){for(;i-191;i+=2)putchar(32+i%95);}

!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{} "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~

C, 39 octets, score 1687

main(i){for(;i-96;)i=putchar(32+i%95);}

!Aa"Bb#Cc$Dd%Ee&Ff'Gg(Hh)Ii*Jj+Kk,Ll-Mm.Nn/Oo0Pp1Qq2Rr3Ss4Tt5Uu6Vv7Ww8Xx9Yy:Zz;[{<\|=]}>^~?_ @`

Dans les deux cas, i le nombre de chaînes sur la ligne de commande est initialisé (aucun argument n’est donné, il s’agit de 1).

La première version fait les choses de façon évidente, incrémentant de 2, en prenant modulo 95 et donc en imprimant toutes les probabilités puis toutes les autres.

La deuxième version tire parti du fait que putchar renvoie le caractère imprimé. Comme 32 est égal à 95, nous pouvons parcourir les caractères. Comme C contient beaucoup de caractères en minuscules, j’espérais que cela, en plus d’être plus court, aurait un score inférieur, mais malheureusement, ce n’est pas le cas.

Befunge-93, 801 797 724 699 627 612

Code:

"!  "     ^
v     _@#$<
>:,2+:"~"`|
^         <

Sortie:

 "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}

Vous pouvez l'essayer ici si vous voulez.

Il fonctionne en affichant 32-126 evens, puis 33-125 cotes. Si quelqu'un veut une explication, je serais prêt à le faire.

Je l'ai joué au golf jusqu'à ce que je l'obtienne mieux que brainf ***, que j'ai jugé être le plus bas possible. En ce qui concerne les stratégies de golf, j’ai généré les personnages ascii puis essayé de remplacer des personnages coûteux par des personnages moins chers (comme 1 avec 2). J'ai découvert que gc'était trop cher, il valait mieux calculer 126 à chaque itération. J'ai aussi enroulé autour du haut car ^c'était moins cher que v.

801 -> 797 : Une modification récente supprimait les espaces supplémentaires qu’il était difficile d’utiliser g.

797 -> 724 : J'ai changé le calcul 126 à chaque fois en ne lisant que tilde "~". cela a également permis de couper les espaces (Et je bat à nouveau une des réponses de BF)

724 -> 699 : Semblable au dernier changement, "" est un moyen extrêmement bon marché (4 points) d'obtenir 32

699 -> 627 : Etant donné que je ne passe qu'une fois la passe de la deuxième rangée, je l'ai simplement changée en 33, au lieu de conserver une autre valeur sur la pile et d'en ajouter une.

627 -> 612 : Déplacé autant que possible vers l'entrée de chaîne. Je suis à peu près sûr que la conception devrait changer radicalement pour la faire évoluer.

C’est probablement la dernière itération, à moins que l’une des langues autres que le golfe obtienne une solution inférieure.

Haskell, 830

['!','#'..'}']++[' ','\"'..'~']

Evalue à la chaîne:

!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{} "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~

Inspiré par la réponse de @ Jørgen et complètement différent de la mienne .

Brainfuck, score 576 667

En y réfléchissant, 576 semblait trop beau pour être vrai: j’ai fait une petite estimation et calculé mon score autour de 95 * 6 + 45 * 2 = 660. Quelque chose a mal tourné la première fois que j’ai couru le validateur. Le score correct est plus proche de mon estimation. Ce n'est toujours pas un mauvais score.

+++++++++++++++++++++++++++++++++++++++++++++.--.+++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.++.---.++.----.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.--.---.--.--.--.--.--.--.+++.--.++++.++.++.

Rester simple.

Fondamentalement, il suffit de parcourir l’ensemble ASCII pour imprimer des caractères. Les trois caractères utilisés dans le programme sont imprimés en premier. Se retourner à chaque extrémité était un peu délicat.

-+.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~{}ywusqomkigeca_][YWUSQOMKIGECA?=;97531/,*(&$" #!%')

Ruby 2.2, 1157

eval s='srand 1;([*s.bytes].shuffle|[*33..0x7e].shuffle).map{|c|putc c}'

Sortie:

f.p|cahu]xens7*0{)3tbmdy[}l1; r(o@&gN/MjzSVv~>D4I`L\KB92=i%PHE?5TQw,W-#6U'^Y!$R"XkO_q+CAGZF<8:J

C'est une solution assez stupide (et je ne suis pas sûr que srand ne devrait pas être une échappatoire standard d'autant plus qu'elle réduit considérablement la portabilité). Mélange (la plupart des) octets dans son propre code source et mélange le reste, puis unique et concatène les tableaux. Utilise une graine choisie au hasard afin que la sortie soit légale (le fait qu'il s'agisse d'un chiffre unique est une pure chance).

CBM BASIC V2, 2553

1FORI=0TO47:PRINTCHR$(32+I*2);:NEXT
2FORI=0TO47:PRINTCHR$(33+I*2);:NEXT 

la sortie (convertie en ASCII par un script python sur pc):

<blank>"$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}

gawk, 2782 1988 1821

END{for(rrf=rrr="rf(3)+=;1\"$?:~ptoin[<-EN% ^.|P";fr++<333;$fr=(ff=sprintf("%c",fr))~"[[(]"?f:ff);for(;r++<33+13+1;rrf=f)printf(rrf)(rrr~(rr=$(31+1+r+r))?f:rr)(rrr~(rr=$(133-(3+3+r+r)))?f:rr)}

Sortie

rf(3)+=;1"$?:~ptoin[<-EN% ^.|P}{&yw*u,sq02m4k68gec>a@_B]DFYHWJULSQORMTKVIXGZ\CA`bd9h7j5l/vx'z#!

Usage

Copiez et collez les éléments suivants sur votre console
(mawk ne fonctionnera pas car il est trop strict avec printf)

awk 'END{for(rrf=rrr="rf(3)+=;1\"$?:~ptoin[<-EN% ^.|P";fr++<333;$fr=(ff=sprintf("%c",fr))~"[[(]"?f:ff);for(;r++<33+13+1;rrf=f)printf(rrf)(rrr~(rr=$(31+1+r+r))?f:rr)(rrr~(rr=$(133-(3+3+r+r)))?f:rr)}' < /dev/null

le < /dev/null fin indique la fin de l'entrée, le bloc END sera donc exécuté.

J'ai essentiellement entrelacé les personnages qui viennent du bas et qui viennent du haut. Ensuite, j'ai analysé quels caractères étaient les plus utilisés dans le programme et les ai imprimés en premier, par ordre de fréquence. Ensuite, je devais m'assurer qu'aucun personnage n'était imprimé plus d'une fois. Le tissage dans des directions opposées rendait plus probable qu'un personnage déjà utilisé ne conduirait pas à imprimer des voisins. Mais ils se sont rencontrés au milieu àP , donc je devais imprimer ça au début aussi. Ensuite, il y a eu quelques problèmes avec les caractères qui sont utilisés dans les expressions rationnelles ... Ensuite, j'ai renommé les variables à moindre coût et j'ai tout refait. Ensuite, j'ai trouvé des personnages que je pouvais remplacer dans mon programme et j'ai tout refait. Et ainsi de suite .. J'ai finalement modifié un peu la chaîne avec les caractères préférés en testant.

Je pense que j'ai fini :D

Pendant le processus, je n’ai jamais exécuté le programme à partir de la ligne de commande, mais j’ai construit une chaîne que j’ai exécutée à l’intérieur d’un script, qui analysait la sortie pour en vérifier l’exactitude et me donnait le score et les éléments correspondants. Ce résultat a beaucoup aidé. Bien sûr, j'ai revérifié ici (on ne sait jamais) mais cela m'a donné le même résultat.

Là le programme ressemble à ceci

p=sprintf("END{"\
"for(rrf=rrr=%c%s%c;fr++<333;$fr=(ff=sprintf(%c%cc%c,fr))~%c[[(]%c?f:ff);"\
"for(;r++<33+13+1;rrf=f)printf"\
"(rrf)(rrr~(rr=$(31+1+r+r))?f:rr)(rrr~(rr=$(133-(3+3+r+r)))?f:rr)}"\
,34,s=sprintf("rf(3)+=;1%c%c$?:~ptoin[<-EN%c ^.|P",92,34,37),34,34,37,34,34,34)

Matlab, 763

Bien sûr, il est impossible de battre la solution Octave dans MATLAB, car elle n’a pas "ce qui est «précoce» dans la gamme ASCII. Cependant, j’ai décidé de faire preuve de créativité et d’abus.randperm . J'admets que c'est un peu hacky et que certains pourraient envisager de tricher, mais je suppose que c'est une bonne idée. Tout d'abord, le programme et la sortie:

rng(1194663);['' randperm(95)+31]

Ouput:

p2)[]913r~jZe:'Xf +b(Atd@LHT*7&xmN>6!?CJgwsaSh|/McO4_EkK=$5VP-%D<"Gz#Yq08n};WB`{.l\Quy^vR,IFoiU

Pour calculer une graine appropriée, j'ai utilisé le programme suivant, que j'ai exécuté jusqu'à graine = 4648029 (c'est-à-dire, jusqu'à ce que la vaisselle soit prête)

minscore=Inf;
for(seed=1:1e9)
    rng(seed)
    p=randperm(95)+31;
    if(any(abs(diff(p))==1))
        continue
    end
    codestring=sprintf('rng(%d);['''' randperm(95)+31]',seed);
    score=0;
    for(i=1:length(codestring))
        score=score + find(codestring(i)==p,1);
    end
    if(score<minscore)
        minscore=score;
        bestseed=seed;
    end
end

Un moyen d’améliorer le programme est peut-être d’essayer également les graines en virgule flottante, par exemple, 2.3e4 augmenter le nombre de graines sans avoir une longueur de graine plus longue. Si quelqu'un a envie de faire un programme pour calculer tous les nombres à n caractères pouvant être représentés par Matlab ....;)

Haskell, 1660 1376

""!_="O"
(a:b)!(c:d)=a:c:b!d
a=[' '..'N']!['P'..]

Définit la fonction aqui retourne la chaîne:

 P!Q"R#S$T%U&V'W(X)Y*Z+[,\-].^/_0`1a2b3c4d5e6f7g8h9i:j;k<l=m>n?o@pAqBrCsDtEuFvGwHxIyJzK{L|M}N~O

Java, 15470

class A{public static void main(String[]I) throws Exception{java.lang.reflect.Field C=Character.class.getDeclaredClasses()[0].getDeclaredField("cache");C.setAccessible(true);Character[]E=(Character[])C.get(C);for(char A=31,G=31;A!=126;E[G++]=new Character(A+=2))A=A==125?30:A;for(char A=31;A!=126;A++)System.out.printf("%c", A);}}

Pas vraiment optimal du tout, mais en réalité , il remappe les caractères (plutôt que de simplement imprimer un ensemble de caractères modifiés).

Ungolfed:

public class Main {
    public static void main(String[] args) throws Exception {
        java.lang.reflect.Field feild = Character.class.getDeclaredClasses()[0].getDeclaredField("cache");
        feild.setAccessible(true);
        Character[] array = (Character[]) feild.get(args); //Since it's a static field, we can supply whatever we want here, and args is cheaper than null.

        char i = 31;
        for (char c = 31; c != 126; array[i++] = new Character(c += 2)) {
            c = c == 125 ? 30 : c;
        }

        for (char c = 31; c < 126; c++) {
            System.out.printf("%c", c);
        }
    }
}

Sortie

!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{} "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~

Il ordonne les caractères en utilisant la même méthode que la réponse de Geobits et fait quelque chose de similaire à cette réponse pour changer les caractères.

BBC BASIC, 2554

Code

n=32
s$=""
REPEAT
  s$+=CHR$(n)
  n+=2
  IFn=128THENn=33
UNTILn=127
PRINTs$

Sortie

 "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}

Fortran 90, 1523 1519 1171

C'est une boucle de sortie imbriquée, semblable aux autres réponses. Pas trop confiant que beaucoup d'amélioration est possible ...

PRINT*,((CHAR(J),J=L,126,2),L=32,33)
END

Sortie:

 "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}

Edit: Vous avez oublié que Fortran 90 est nécessaire pour ce code, 77 nécessite que le code commence dans la 7ème colonne. D'autre part, le langage est insensible à la casse, ce qui permet une amélioration facile. Les compteurs de boucle sont Jet Lparce que ce sont les deux premières lettres de la chaîne de sortie implicitement déclarée comme un entier par Fortran.

Perl, 1089 922

Il s’avère que l’impression des valeurs ASCII par incréments de 42 à 58 donne le score le plus bas avec cette approche:

print chr$_*58%95+32for 0..94

Sortie:

 Z5oJ%_:tO*d?yT/iD~Y4nI$^9sN)c>xS.hC}X3mH#]8rM(b=wR-gB|W2lG"\7qL'a<vQ,fA{V1kF![6pK&`;uP+e@zU0jE

JavaScript, 3169 2548 2144 2104 2071 1885 1876 1872

Code

t=''
i=S=95
while(i--)t+=String.fromCharCode(i*2291%S-
-32)
alert(t)

Sortie

ti^SH=2'{peZOD9.#wlaVK@5*~sh]RG<1&zodYNC8-"vk`UJ?4)}rg\QF;0%yncXMB7,!uj_TI>3(|qf[PE:/$xmbWLA6+ 

Python 2, 72 octets (3188) 116 octets (1383) (1306) (1303)

merci @FryAmTheEggman pour le tour de jointure;)

merci @nim (Ai-je mal interprété le texte?: P)

merci @Mathias Ettinger

n='nr i(a)2:]o[c=fh1+t"3egj,p.7'
a=[chr(r)for r in range(32,127)if not chr(r)in n]
print n+"".join(a[::2]+a[1::2])

sortie:

 nr<blank>i(a)2:]o[c=fh1+t"3egj,p.7!$&*/469<?ACEGIKMOQSUWY\_bkmsvxz|~#%'-058;>@BDFHJLNPRTVXZ^`dlquwy{}

PHP, 1217 1081

Le code:

for(;$T!=T;$T=($T+52)%95)echo chr(32+$T);

Comme les variables ne sont pas initialisées, il est nécessaire de supprimer les notifications lors de leur exécution (PHP se plaint mais poursuit l'exécution et utilise une valeur par défaut appropriée dans le contexte; 0dans ce cas):

$ php -d error_reporting=0 remapping-ascii.php

Sa sortie:

 T)]2f;oDxM"V+_4h=qFzO$X-a6j?sH|Q&Z/c8lAuJ~S(\1e:nCwL!U*^3g<pEyN#W,`5i>rG{P%Y.b7k@tI}R'[0d9mBvK

Remarques:

• la sortie commence par un espace blanc ( chr(32));
• le code imprime l'espace blanc, puis chaque 52ème caractère, en entourant la plage;
• le nombre magique a 52été "découvert" en recherchant toute la gamme (1..94) des décalages possibles; 1 produit la liste des caractères imprimables dans l'ordre croissant de leurs codes ASCII, 94 produit la liste dans l'ordre inverse, les deux sont incorrects; les multiples de 5 et 19 (les diviseurs de 95) produisent des cycles courts et ne couvrent pas toute la plage de valeurs (également mauvaises);
• 52semble être magique; c'est le meilleur offset pour ce code; mais c'est aussi le meilleur pour certaines variations du code (qui produisent des scores légèrement plus grands); les variations que j'ai essayé: utiliser au while()lieu de for(), l' utilisation $f++, $f--ou au --$flieu de ++$f, échanger les opérandes autour du <et les +opérateurs; presser la modification de $Ten 32+$T;
• les noms des variables ( $Tet $f) sont les premières lettres de la sortie;
• J'ai essayé d'initialiser $Tavec 4ou 11mais les scores étaient pires; en commençant par 4fait $le premier caractère de la sortie; c'est le caractère le plus utilisé dans un code source PHP; 11apporte +devant; $et +sont les caractères les plus utilisés dans ce code.

Le code, les tests et les modifications incrémentielles que j’ai essayés jusqu’à ce que j’atteigne cette solution, ainsi que le script qui teste toutes les valeurs d’étape possibles (le fournisseur faisant autorité en 52tant que meilleure étape), sont disponibles sur github .

Fourier, 1236

Fondamentalement une conversion de mon programme BBCB

32~N127(Na^^~N{128}{33~N}N)

Sortie

 "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}

AWK , 49 bytes, Score: 1755

BEGIN{for(f=82;++f<178;)printf"%c",(2*f-1)%95+32}

Essayez-le en ligne!

Imprime simplement tous les autres caractères puis recommence à remplir les espaces vides. Le premier caractère imprimé est un f. J'ai essayé d'imprimer dans l'ordre inverse, mais cela a considérablement augmenté le score. D'autres modèles sont possibles en changeant simplement le multiplicateur et les critères de la boucle.

Perl 5 , 1069

print chr$_*2%95+32for 0..94

Essayez-le en ligne!