Reto

¡Escriba un programa que reordena los caracteres ASCII!

Debería generar una sola cadena que contenga todos los caracteres ASCII imprimibles exactamente una vez. Al primer carácter de esta cadena se le asigna el valor 1, el segundo carácter al valor 2, y así sucesivamente.

Si dos caracteres están normalmente uno al lado del otro (la diferencia entre sus códigos de caracteres es 1), es posible que no aparezcan uno al lado del otro en la salida.

Tanteo

Su puntaje será la suma de los valores para todos los caracteres en su código fuente, según lo dicte la salida de su programa.

Consulte la sección Verificación para calcular su puntaje.

¡La puntuación más baja gana!

Reglas

• "ASCII imprimible" se define para significar los códigos de caracteres 32 - 126, inclusive.

• Puede escribir un programa completo o una función.

• Su código solo puede contener caracteres ASCII imprimibles y líneas nuevas.

• Su programa no puede tomar ninguna entrada.

• Las líneas nuevas siempre tendrán el valor 1. La salida de su programa no debe incluir una línea nueva.

Verificación

Utilice este fragmento de pila para verificar que la salida de su código sea válida y para calcular la puntuación de su código.

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>

Tabla de clasificación

¡Gracias a esta publicación por el código de la tabla de clasificación!

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 99 96 94

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

Pruébelo en línea en el intérprete de CJam .

Salida

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

Idea

Usando una variación de una técnica común en quines CJam, clasificamos los caracteres ASCII imprimibles según aparezcan en el código fuente y los que no aparecen, con dos excepciones, por los bits de paridad de sus puntos de código.

Con el diseño de fuente adecuado, también logramos ordenar los caracteres del código fuente, con una excepción, por sus frecuencias.

Se debe tener especial cuidado en que dos caracteres adyacentes no aparezcan uno tras otro por primera vez en el código fuente, ya que esto invalidaría la respuesta.

Código

"             "_~  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

(Todavía) Sin optimizar, lo sé. Estoy trabajando en ello (deja las opciones en los comentarios).

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

Salida:

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

Ya estoy utilizando el desbordamiento en las celdas de 8 bits hasta cierto punto, pero supongo que aún podría optimizarlo. Aunque eso disminuiría el uso de caracteres baratos :).

Pyth, 173 170

Código

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

Salida

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

Codificar una cadena tipo quine. Convenientemente, el "carácter está muy cerca del comienzo de la cadena generada. Imprime incluso caracteres impares después de la "quine".

¡Muchas gracias a Dennis por ahorrar 3 puntos y hacer que el código sea insignificante!

Pruébalo aquí

Java, 3518 3189 2692

Un bucle simple que imprime incluso personajes, luego probabilidades. Intenté algunas cosas para optimizar ASCII anteriores, pero la mayoría terminó haciéndolo más largo en general, y terminó con una puntuación más alta.

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

Salida es:

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

Editar: no entendí la puntuación al principio. Después de cambiarlo a impar primero, luego incluso, obtiene un puntaje mucho mejor.

Octava, 628

Código

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

Salida:

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

Dos rangos implícitamente convertidos en cadena. No estoy seguro de si regresar como Ans es aceptable, también da una advertencia sobre la conversión implícita. Intenté algunos otros vectores de rango, pero no pude encontrar nada más eficiente.

C, 42 bytes, puntaje 1539

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

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

C, 39 bytes, puntaje 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;[{<\|=]}>^~?_ @`

En ambos casos, i se inicializa con el número de cadenas en la línea de comando (como no se dan argumentos, este es 1.)

La primera versión hace las cosas de la manera obvia, incrementando en 2, tomando el módulo 95 y, por lo tanto, imprimiendo todas las probabilidades y luego todas las igualaciones.

La segunda versión aprovecha el hecho de que putchar devuelve el carácter impreso. Como 32 es coprimo a 95, podemos recorrer los caracteres. Como C contiene muchos caracteres en minúscula, esperaba que esto, además de ser más corto, tuviera una puntuación más baja, pero desafortunadamente este no es el caso.

Befunge-93, 801 797 724 699 627 612

Código:

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

Salida:

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

Puedes probarlo aquí si quieres.

Funciona produciendo 32-126 pares, y luego 33-125 probabilidades. Si alguien quiere una explicación, estaría dispuesto a hacerlo.

Lo jugué hasta que lo conseguí mejor que Brainf ***, que consideré el más bajo que pude. En cuanto a las estrategias de golf, generé los caracteres ascii y luego intenté reemplazar los personajes costosos por otros más baratos (como 1 con 2). Descubrí que como gera tan costoso, era mejor calcular 126 cada iteración. También me envolví en la parte superior ya que ^era más barato que v.

801 -> 797 : el cambio reciente estaba eliminando espacios adicionales que era una reliquia del uso g.

797 -> 724 : cambié el cálculo de 126 cada vez a solo leer tilde usando "~". esto también permitió cortar espacios en blanco (y estoy superando una de las respuestas BF nuevamente)

724 -> 699 : Similar al último cambio, "" es una forma extremadamente barata (4 puntos) de obtener 32

699 -> 627 : dado que solo paso por el pase de la segunda fila una vez, simplemente lo cambié a la configuración 33 en lugar de mantener otro valor en la pila y agregar uno.

627 -> 612 : Moví todo lo que pude para encadenar la entrada. Estoy bastante seguro de que el diseño tendría que cambiar drásticamente para seguir jugando al golf.

Esta es probablemente la iteración final, a menos que uno de los idiomas que no sean de golf obtenga una solución más baja.

Haskell, 830

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

Evalúa a la cadena:

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

Inspirado por la respuesta de @ Jørgen y completamente diferente de la mía .

Brainfuck, puntaje 576 667

Pensando en ello, 576 parecía bueno para ser verdad: hice una pequeña estimación y calculé que mi puntaje era de alrededor de 95 * 6 + 45 * 2 = 660. Algo debe haber salido mal la primera vez que ejecuté el validador. La puntuación correcta está más cerca de mi estimación. Todavía no es un mal puntaje.

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

Mantenlo simple.

Básicamente solo sube y baja el conjunto ASCII, imprimiendo caracteres. Los tres caracteres utilizados en el programa se imprimen primero. Dar la vuelta en ambos extremos fue un poco complicado.

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

Ruby 2.2, 1157

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

Salida:

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

Esta es una solución bastante tonta (y no estoy seguro de que srand no deba ser una escapatoria estándar, especialmente porque reduce drásticamente la portabilidad). Baraja (la mayoría de) los bytes en su propio código fuente y baraja el resto, luego unifica y concatena las matrices. Utiliza una semilla aleatoria elegida para que la salida sea legal (el hecho de que sea un solo dígito es pura suerte).

CBM BASIC V2, 2553

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

La salida (convertida en ASCII por un script de Python en la 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)}

Salida

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

Uso

Copie y pegue lo siguiente en su consola
(mawk no funcionará, porque es demasiado estricto con 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

los < /dev/null al final señala el final de la entrada, por lo que se ejecutará el bloque END.

Básicamente entretejí a los personajes que venían desde abajo y desde arriba. Luego analicé qué caracteres se usaron más en el programa y los imprimí primero, en orden de frecuencia. Luego tuve que asegurarme de que ningún carácter se imprima más de una vez. El tejido en direcciones opuestas hizo más probable que un personaje ya usado no condujera a la impresión de vecinos. Pero se encontraron en el medio P, así que tuve que imprimir eso al principio también. Luego hubo algunos problemas con los caracteres que se usan en expresiones regulares ... Luego cambié el nombre de las variables a bajo precio e hice todo de nuevo. Luego encontré algunos caracteres que podía reemplazar en mi programa, e hice todo de nuevo. Y así sucesivamente ... Finalmente pellizqué un poco la cadena con los caracteres preferidos probando.

Creo que he terminado :D

Durante el proceso, nunca ejecuté el programa desde la línea de comandos, sino que construí una cadena que ejecuté desde el interior de un script, que analizaría la salida para ver si era correcta y me daría la puntuación y demás. Esa salida de puntaje ayudó mucho. Por supuesto que volví a verificar aquí (nunca se sabe), pero me dio el mismo resultado.

Allí el programa se ve así

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

Por supuesto, es bastante imposible superar la solución Octave en MATLAB, ya que no tiene "cuál es 'temprana' en el rango ASCII. Sin embargo, decidí ser un poco creativo y pensé en abusar randperm. Admito que es un poco hacky y algunos podrían considerarlo hacer trampa, pero supongo que es un buen toque. Primero, el programa y la salida:

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

Para calcular una semilla adecuada, utilicé el siguiente programa, que ejecuté hasta la semilla = 4648029 (es decir, hasta que se terminaron los platos)

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

Quizás una forma de mejorar el programa es probar también las semillas de coma flotante, por ejemplo, 2.3e4 aumenta el número de semillas sin tener una mayor longitud de semilla. Si alguien tiene ganas de hacer un programa para calcular todos los números de n caracteres representables por Matlab ....;)

Haskell, 1660 1376

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

Define la función aque devuelve la cadena:

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

No es realmente óptimo en absoluto, pero realidad reasigna los caracteres (en lugar de simplemente imprimir un conjunto de caracteres modificados).

Sin golf:

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

Salida

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

Ordena los caracteres usando el mismo método que la respuesta de Geobits , y hace algo similar a esta respuesta para cambiar los caracteres.

BBC BASIC, 2554

Código

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

Salida

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

Fortran 90, 1523 1519 1171

Este es un bucle de salida anidado, similar a otras respuestas. No estoy demasiado seguro de que sea posible mejorar mucho ...

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

Salida:

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

Editar: Olvidé que Fortran 90 es necesario para este código, 77 requiere que el código comience en la séptima columna. Por otro lado, el lenguaje no distingue entre mayúsculas y minúsculas, lo que permite una mejora fácil. Los contadores de bucle son Jy Lporque estas son las dos primeras letras en la cadena de salida declaradas implícitamente como enteras por Fortran.

Perl, 1089 922

Resulta que imprimir los valores ASCII en pasos de 42 58 da la puntuación más baja con este enfoque:

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

Salida:

 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

Código

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

Salida

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 bytes (3188) 116 bytes (1383) (1306) (1303)

gracias @FryAmTheEggman por el truco de unión;)

gracias @nim (¿Leí mal el texto?: P)

gracias @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])

salida:

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

PHP, 1217 1081

El código:

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

Debido a que las variables no se inicializan, necesita suprimir los avisos al ejecutarse (PHP se queja pero continúa la ejecución y utiliza un valor predeterminado que es apropiado en el contexto; 0en este caso):

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

Su salida:

 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

Observaciones:

• la salida comienza con un espacio en blanco (chr(32));
• el código imprime el espacio en blanco y luego cada 52o carácter, envolviendo el rango;
• el número mágico 52fue "descubierto" buscando en todo el rango (1..94) de posibles compensaciones; 1 produce la lista de caracteres imprimibles en el orden ascendente de sus códigos ASCII, 94 produce la lista en el orden inverso, ambos son incorrectos; los múltiplos de 5 y 19 (los divisores de 95) producen ciclos cortos y no cubren todo el rango de valores (también malo);
• 52parece ser mágico; es el mejor desplazamiento para este código; pero también es el mejor para algunas variaciones del código (que producen puntajes ligeramente mayores); las variaciones que probé: use en while()lugar de for(), use $f++, $f--o en --$flugar de ++$f, intercambie los operandos alrededor de los operadores <y +; exprimir la modificación de $Ten 32+$T;
• los nombres de las variables ( $Ty$f ) son las primeras letras de la salida;
• Traté de inicializar $Tcon 4o 11pero las puntuaciones fueron peores; comenzando con 4hace $el primer carácter en la salida; Es el carácter más utilizado en un código fuente PHP; 11trae +al frente; $y +son los caracteres más utilizados en este código.

El código, las pruebas, los cambios incrementales que probé hasta que llegué a esta solución y el script que probó todos los valores de paso posibles (el proveedor autorizado 52como el mejor paso) se pueden encontrar en github .

Fourier, 1236

Básicamente una conversión de mi programa BBCB

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

Salida

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

AWK, 49 bytes, Score: 1755

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

Try it online!

Simply prints every other character then starts over filling in the blanks. First character printed is an f. I attempted printing in reverse order, but that greatly increased the score. Other patterns are possible by simply changing the multiplier and the loop criteria.

Perl 5, 1069

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

Try it online!