Desafio

Escreva um programa que reordene os caracteres ASCII!

Ele deve gerar uma única sequência contendo todos os caracteres ASCII imprimíveis exatamente uma vez. O primeiro caractere dessa sequência recebe o valor 1, o segundo caractere, o valor 2, e assim por diante.

Se dois caracteres estiverem normalmente próximos um do outro (a diferença entre os códigos de caracteres é 1), eles podem não aparecer um ao lado do outro na saída.

Pontuação

Sua pontuação será a soma dos valores para todos os caracteres no seu código-fonte, conforme determinado pela saída do seu programa.

Consulte a seção Verificação para calcular sua pontuação.

Menor pontuação ganha!

Regras

• "ASCII imprimível" é definido para significar códigos de caracteres 32 - 126, inclusive.

• Você pode escrever um programa completo ou uma função.

• Seu código pode conter apenas caracteres ASCII imprimíveis e novas linhas.

• Seu programa pode não receber nenhuma entrada.

• As novas linhas sempre terão o valor 1. A saída do seu programa não deve incluir uma nova linha.

Verificação

Use esse trecho de pilha para verificar se a saída do seu código é válida e para calcular a pontuação do seu 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>

Entre os melhores

Obrigado a este post pelo código do placar!

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

Experimente online no intérprete CJam .

Saída

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

Idéia

Usando uma variação de uma técnica comum em CJam quines, classificamos os caracteres ASCII imprimíveis por eles aparecerem no código-fonte e os que não aparecem - com duas exceções - pelos bits de paridade de seus pontos de código.

Com o layout de fonte adequado, também conseguimos classificar os caracteres do código fonte - com uma exceção - por suas frequências.

É preciso ter cuidado especial para que dois caracteres adjacentes não apareçam um após o outro pela primeira vez no código-fonte, pois isso invalidaria a resposta.

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

(Ainda) Não otimizado, eu sei. Estou trabalhando nisso (deixe opta nos comentários).

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

Saída:

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

Já estou utilizando o estouro de células de 8 bits até certo ponto, mas acho que você ainda pode otimizá-lo. Embora isso diminua o uso de caracteres baratos :).

Pyth, 173 170

Código

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

Saída

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

Codificação codificada de uma string semelhante a uma solução quine. Convenientemente, o "personagem está muito próximo do início da sequência gerada. Imprime caracteres pares e ímpares depois do "quine".

Muito obrigado a Dennis por economizar 3 pontos e tornar o código um palindome!

Experimente aqui

Java, 3518 3189 2692

Um loop simples que imprime caracteres pares e depois probabilidades. Tentei algumas coisas para otimizar os ASCIIs anteriores, mas a maioria acabou tornando-o mais longo no geral e obteve uma pontuação mais alta.

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

A saída é:

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

Edit: Entendeu mal a pontuação em primeiro lugar. Depois de passar para ímpar primeiro, depois para o mesmo, obtém uma pontuação muito melhor.

Oitava, 628

Código

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

Saída:

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

Dois intervalos implicitamente convertidos em string. Não tenho certeza se retornar como Ans é aceitável, também fornece um aviso sobre a conversão implícita. Tentei alguns outros vetores de intervalo, mas não consegui encontrar nada mais eficiente.

C, 42 bytes, pontuação 1539

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

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

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

Nos dois casos, ié inicializado com o número de seqüências de caracteres na linha de comando (como nenhum argumento é fornecido, é 1.)

A primeira versão faz as coisas da maneira óbvia, aumentando em 2, tomando o módulo 95 e, portanto, imprimindo todas as probabilidades e todos os pares.

A segunda versão aproveita o fato de putchar retornar o caractere impresso. Como 32 é coprime para 95, podemos alternar entre os caracteres. Como C contém muitos caracteres em minúsculas, eu esperava que isso, além de mais curto, tivesse uma pontuação mais baixa, mas infelizmente não é esse o caso.

Befunge-93, 801 797 724 699 627 612

Código:

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

Saída:

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

Você pode experimentá-lo aqui, se quiser.

Ele funciona produzindo 32-126 pares e, em seguida, 33-125 probabilidades. Se alguém quiser uma explicação, eu estaria disposto.

Eu jogava golfe até conseguir algo melhor do que uma merda cerebral, que eu considerava a mais baixa possível. Quanto às estratégias de golfe, gerei os caracteres ASCII e tentei substituir caracteres caros por caracteres mais baratos (como 1 com 2). Descobri que, por gser tão caro, era melhor calcular 126 todas as iterações. Eu também envolvi o topo, já que ^era mais barato do que v.

801 -> 797 : As alterações recentes estavam removendo espaços extras que eram uma relíquia de usar g.

797 -> 724 : Eu mudei o cálculo 126 todas as vezes para apenas ler til usando "~". isso também permitiu cortar espaço em branco (e estou batendo em uma das respostas da BF novamente)

724 -> 699 : Semelhante à última alteração, "" é uma maneira extremamente barata (4 pontos) de obter 32

699 -> 627 : Como passo apenas a segunda passagem de linha uma vez, apenas a alterei para a configuração 33, em vez de manter outro valor na pilha e adicionar um.

627 -> 612 : movido o máximo que pude para inserir a string. Tenho certeza de que o design precisaria mudar drasticamente para jogar ainda mais.

Esta é provavelmente a iteração final, a menos que um dos idiomas que não seja de golfe obtenha uma solução mais baixa.

Haskell, 830

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

Avalia para a sequência:

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

Inspirado pela resposta de @ Jørgen e completamente diferente da minha .

Brainfuck, pontuação 576 667

Pensando bem, 576 parecia bom demais: fiz uma pequena estimativa e calculei minha pontuação em torno de 95 * 6 + 45 * 2 = 660. Algo deve ter dado errado na primeira vez em que corri o validador. A pontuação correta está mais próxima da minha estimativa. Ainda não é uma pontuação ruim.

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

Mantenha simples.

Basicamente, apenas sobe e desce o conjunto ASCII, imprimindo caracteres. Os três caracteres usados ​​no programa são impressos primeiro. Virar em cada extremidade foi um pouco 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}'

Saída:

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 é uma solução bastante burra (e não tenho certeza se srand não deve ser uma brecha padrão, especialmente porque reduz drasticamente a portabilidade). Baralha (na maior parte) os bytes em seu próprio código-fonte e embaralha o restante, depois unifica e concatena as matrizes. Usa uma semente aleatória escolhida para que a saída seja legal (o fato de ser um dígito é pura sorte).

CBM BASIC V2, 2553

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

a saída (convertida em ASCII por um script python no 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)}

Saída

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

Uso

Copie e cole o seguinte no seu console
(o mawk não funcionará, porque é muito mais rigoroso com o 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

O < /dev/nullno final sinaliza o final da entrada, então o bloco END será executado.

Basicamente, eu intercalei os personagens vindos de baixo e de cima. Depois, analisei quais caracteres foram mais utilizados no programa e os imprimi primeiro, em ordem de frequência. Então tive que me certificar de que nenhum caractere fosse impresso mais de uma vez. A tecelagem em direções opostas tornou mais provável que um personagem já usado não levasse à impressão de vizinhos. Mas eles se conheceram no meio àsP , então eu tive que imprimir isso também no começo. Houve alguns problemas com caracteres usados ​​em regexps ... Então, renomeei as variáveis ​​de forma barata e refiz a coisa toda. Então eu encontrei alguns caracteres que eu poderia substituir no meu programa e fiz tudo de novo. E assim por diante .. Finalmente ajustei a string com os caracteres preferidos um pouco testando.

Acho que terminei :D

Durante o processo, nunca executei o programa a partir da linha de comando, mas construí uma string que executei de dentro de um script, que analisaria a saída para correção e me forneceria a pontuação e outras coisas. Essa saída de pontuação ajudou muito. É claro que voltei a verificar aqui (você nunca sabe), mas o resultado foi o mesmo.

Lá, o programa se parece com isso

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

Obviamente, é impossível vencer a solução Octave no MATLAB, pois ela não possui o "que é "precoce" na faixa ASCII. No entanto, decidi ser um pouco criativo e pensei em abusar randperm. Admito que é um pouco hacky e alguns podem considerá-lo trapaça, mas acho que é um toque agradável. Primeiro, o programa e a saída:

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 uma semente apropriada, usei o seguinte programa, que funcionou até a semente = 4648029 (ou seja, até a louça estar pronta)

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

Talvez uma maneira de melhorar o programa seja experimentar também sementes de ponto flutuante, por exemplo, 2.3e4 aumente o número de sementes sem ter um comprimento maior. Se alguém quiser criar um programa para calcular todos os números de n caracteres representáveis ​​pelo Matlab ....;)

Haskell, 1660 1376

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

Define a função aque retorna a string:

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

Não é realmente ideal, mas na verdade remapeia os caracteres (em vez de apenas imprimir um conjunto de caracteres modificados).

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

Saída

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

Ele ordena os caracteres usando o mesmo método da resposta do Geobits e faz algo semelhante a essa resposta para alterar os caracteres.

BBC BASIC, 2554

Código

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

Saída

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

Fortran 90, 1523 1519 1171

Este é um loop de saída aninhado, semelhante a outras respostas. Não muito confiante de que muitas melhorias sejam possíveis ...

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

Saída:

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

Edit: Esqueceu que o Fortran 90 é necessário para este código, 77 requer que o código inicie na 7ª coluna. Por outro lado, o idioma não diferencia maiúsculas de minúsculas, permitindo uma melhoria fácil. Os contadores de loop são Je Lporque essas são as duas primeiras letras na string de saída declaradas implicitamente como números inteiros pelo Fortran.

Perl, 1089 922

Acontece que a impressão dos valores ASCII nas etapas de 42 58 fornece a pontuação mais baixa com esta abordagem:

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

Saída:

 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)

Saída

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)

obrigado @FryAmTheEggman pelo truque de junção;)

thanks @nim (Eu interpretei mal o texto?: P)

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

saída:

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

PHP, 1217 1081

O código:

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

Como as variáveis ​​não são inicializadas, ele precisa suprimir os avisos na execução (o PHP reclama, mas continua a execução e usa um valor padrão que é apropriado no contexto; 0neste caso):

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

Sua saída:

 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

Observações:

• a saída começa com um espaço em branco ( chr(32));
• o código imprime o espaço em branco e, em seguida, cada 52º caractere, envolvendo o intervalo;
• o número mágico 52foi "descoberto" pesquisando todo o intervalo (1..94) de possíveis compensações; 1 produz a lista de caracteres imprimíveis na ordem crescente de seus códigos ASCII; 94 produz a lista na ordem inversa, ambos são ruins; os múltiplos de 5 e 19 (os divisores de 95) produzem ciclos curtos e não cobrem todo o intervalo de valores (também ruim);
• 52parece ser mágico; é o melhor deslocamento para esse código; mas também é o melhor para algumas variações do código (que produzem pontuações um pouco maiores); as variações que eu tentei: utilização while()em vez de for(), uso $f++, $f--ou --$fem vez de ++$f, trocar os operandos ao redor do <e +operadores; aperte a modificação de $Tem32+$T ;
• os nomes das variáveis ​​( $Te$f ) são as primeiras letras da saída;
• Tentei inicializar $Tcom 4ou 11mas as pontuações eram piores; começando com 4cria $o primeiro caractere na saída; é o caractere mais usado em um código-fonte PHP; 11traz +na frente; $e +são os caracteres mais usados ​​neste código.

O código, testes, alterações incrementais que tentei até chegar a essa solução e o script que testou todos os valores possíveis de etapas (o provedor autorizado 52como a melhor etapa) podem ser encontrados no github .

Fourier, 1236

Basicamente, uma conversão do meu programa BBCB

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

Saída

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

AWK , 49 bytes, Pontuação: 1755

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

Experimente online!

Simplesmente imprime todos os outros caracteres e recomeça preenchendo os espaços em branco. O primeiro caractere impresso é um f. Tentei imprimir em ordem inversa, mas isso aumentou muito a pontuação. Outros padrões são possíveis simplesmente alterando o multiplicador e os critérios de loop.

Perl 5 , 1069

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

Experimente online!