Em uma linguagem de programação de sua escolha, escreva 95 programas, cada um com um dos 95 caracteres ASCII imprimíveis, sem que esse caractere ocorra em qualquer lugar do programa .
Por exemplo, se sua linguagem era Python , seu programa que gera o caractere Ppode ser
print(chr(80))
porque Ppossui o código ASCII 80. Este programa é válido porque Pnunca aparece no código-fonte. No entanto, para o programa que exibe letras minúsculas p, algo como
print(chr(112))
seria inválido porque, enquanto é impresso p, pestá presente no código. Um programa válido pode ser
exec(chr(112)+'rint(chr(112))')
que imprime, pmas não contém p.
Seu objetivo é tornar cada um de seus 95 programas o mais curto possível. Sua pontuação é a soma dos comprimentos de caracteres de todos os seus programas.
Se, por algum motivo, você não conseguir escrever programas válidos para alguns caracteres, poderá marcá-los como "Não programou" ou DNP e omitir os programas por completo. Dessa forma, idiomas sintaticamente estritos poderão competir.
A resposta vencedora é a resposta que tem a pontuação mais baixa do conjunto de respostas que têm o menor número de DNP.
Regras
O código fonte de todos os seus programas pode conter apenas guias e novas linhas ASCII imprimíveis e novas, todas contadas como um caractere. (Como em uma codificação diferente, seria fácil omitir caracteres que não existem!)
- Nota: Essa regra parece necessária, mas há muitos idiomas com codificações diferentes e tenho certeza de que seria legal ver as respostas para elas. Portanto, você pode violar essa regra , pode usar os caracteres que quiser, mas sua resposta se tornará não competitiva e não poderá vencer.
Os programas devem ser reais, completos programas , de acordo com as convenções padrão do seu idioma. Funções e snippets REPL não são permitidos.
A saída de cada programa deve ir para stdout ou a alternativa aceita pelo seu idioma.
Os programas não devem solicitar ou exigir entrada. (Se a solicitação de entrada é inerente ao seu idioma, tudo bem.)
Os programas devem ser determinísticos, finitos em tempo de execução e independentes. por exemplo, não importa se um é executado em uma pasta separada dos outros programas.
A saída de um programa deve ser o caractere ASCII imprimível preciso a que corresponde, opcionalmente seguido por uma única nova linha à direita, nada mais, nada menos.
Certifique-se de incluir informações sobre todos os 95 programas (idealmente) em sua resposta, assim como sua pontuação e qualquer DNP. Você não tem que listar todos os programas que seguem um padrão simples como " , ...", mas verifique se você está certo de que todos eles iria funcionar e que a sua pontuação é adicionado corretamente.print(chr(80))print(chr(81))print(chr(82))
Para referência, aqui estão as 95 ASCII imprimíveis que seus programas devem gerar:
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
fonte
0Respostas:
Python 2,
10751065104310401039 bytesCada programa tem o formato
print'\<octal char code>', exceto:'→print"\47"0através de8→print~-<N+1>9→print-~8\→print'%c'%92i→exec'pr\151nt"\151"'n→exec'pri\156t"\156"'p→exec'\160rint"\160"'r→exec'p\162int"\162"'t→exec'prin\164"\164"'Para referência e facilidade de teste, eis a lista completa de programas, separados por nova linha.
Testar:
-1 bytes graças a @ Sp3000!
fonte
print~-<N+1>não funciona para1. Você disse que ele trabalha para0a8.<angle brackets>não é literal. Substitua<N+1>pelo valor literal deN+1; neste caso, o programa para1seriaprint~-2. Veja a lista completa de programas.CJam, 269 bytes
Cada um dos programas está no formato,
'<char - 1>)exceto:S, 1 byte'=>39c, 3 bytes)=>'*(, 3 bytes0=>T, 1 byte1=>X, 1 byte2=>Y, 1 byte3=>Z, 1 byte4-9=><num-1>), 2 bytesA pontuação é:
3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269fonte
39cpara'? Além disso, você está esquecendo que um dígito pode ser apenas esse número1)para2etc para salvar um byte não1)era o que eu queria dizer simTXYZCódigo de máquina x86 com restrição ASCII para DOS,
310431012913 bytesBem ... É mais curto que Java, eu acho ...
32.30 bytes para quase todos os caracteres, para exceções, veja abaixo.Na maioria das vezes, apenas segue o padrão:
xorpara obter um ponteiro para o fim.subdas 2 últimas palavras, porque o opcode paraintnão está em ASCII.AHe o personagemDL. Ambos sãoxoreditados porque o caractere em si não pode aparecer no programa e 2 não é um caractere ASCII imprimível.int 21hint 20hNa maioria das vezes, se um caractere for desaprovado, ele poderá ser substituído, mexendo um pouco com os dados ou alternando para um registro diferente.
Torna-se um pouco mais interessante quando você de repente se vê incapaz de subtrair ou incapaz de pressionar ou abrir o único registro utilizável para cálculos ...
fonte
Brainfuck,
1770171017031686 bytes60 bytes salvos pelo Dennis
17 bytes salvos pelo Sp3000
DNP: 46 (
.)Todos, exceto 43, 45, 60, 62, 91 e 93, são descaradamente roubados da Esolangs.org
fonte
--[>-<---]>[<->--]<[->-<]>.trabalha para saída+.-----[[----<]>>-]<.+[+[+>]<<++++]>.MATL,
305, 302, 300297 bytesCada programa é assim:
Exceto por
Dígitos. Aqui estão os programas para 0-9:
'c'. Este programa é
espaço. Isto é
Desde hoje, aprendi que o MATL trata o caractere 0 como espaço. Obrigado @LuisMendo!
Você pode usar o matl.tio para verificar qualquer um deles.
Para referência, aqui estão todos eles:
fonte
Java 8,
679865826577 bytessuspiro
Esta é basicamente uma porta da minha resposta do Python 2 , mas com todo o boilerplate que vem com a escrita de um programa completo em Java.
Agora sem DNPs! Obrigado, Kevin Cruijssen!
A maioria dos programas tem o formato
interface A{static void main(String[]a){System.out.print("\<octal char code>");}}, exceto:interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(mas com os\ts substituídos por guias não processadas)"→interface A{static void main(String[]a){System.out.print('\42');}}(→interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}})→interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}.→interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}0→interface A{static void main(String[]a){System.out.print(1-1);}}1→interface A{static void main(String[]a){System.out.print(3-2);}}2→interface A{static void main(String[]a){System.out.print(3-1);}}3→interface A{static void main(String[]a){System.out.print(4-1);}}4→interface A{static void main(String[]a){System.out.print(5-1);}}5→interface A{static void main(String[]a){System.out.print(6-1);}}6→interface A{static void main(String[]a){System.out.print(7-1);}}7→interface A{static void main(String[]a){System.out.print(8-1);}}8→interface A{static void main(String[]a){System.out.print(9-1);}}9→interface A{static void main(String[]a){System.out.print(8+1);}};→interface A{static void main(String[]a){System.out.print("\73")\u003B}}A→interface B{static void main(String[]a){System.out.print("\101");}}S→interface A{static void main(\u0053tring[]a){\u0053ystem.out.print("\123");}}[→interface A{static void main(String...a){System.out.print("\133");}}\→interface A{static void main(String[]a){System.out.print((char)92);}}]→interface A{static void main(String...a){System.out.print("\135");}}a→interf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}c→interfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}d→interface A{static voi\u0064 main(String[]a){System.out.print("\144");}}e→class A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}f→class A{public static void main(String[]a){System.out.print("\146");}}g→interface A{static void main(Strin\u0067[]a){System.out.print("\147");}}// \u0067i→\u0069nterface A{stat\u0069c vo\u0069d ma\u0069n(Str\u0069ng[]a){System.out.pr\u0069nt("\151");}}m→interface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}n→class A{public static void mai\u006E(Stri\u006Eg[]a){System.out.pri\u006Et("\156");}}o→interface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}p→interface A{static void main(String[]a){System.out.\u0070rint("\160");}}r→class A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}s→interface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}t→class A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}u→interface A{static void main(String[]a){System.console().printf("%c",117);}}v→interface A{static \u0076oid main(String[]a){System.out.print("\166");}}y→interface A{static void main(String[]a){S\u0079stem.out.print("\171");}}{→interface A\u007Bstatic void main(String[]a)\u007BSystem.out.print("\173");}}}→interface A{static void main(String[]a){System.out.print("\175");\u007D\u007DUfa
O compilador Java processa escapes Unicode como
\u007Bantes de qualquer outro processamento, o que possibilita escrever código que usa escapes unicode nos identificadores e até nas palavras-chave. Portanto, para escrever um programa que não utiliza um caractere presente no clichê, simplesmente o substituímos pelo escape unicode.Para referência e facilidade de teste, eis a lista completa de programas, separados por nova linha e com as guias brutas substituídas por quatro espaços:
Observe que o programa
ufaz uso deSystem.console(), que retornará nulo (e, portanto, fará com que o código gere aNullPointerException) se você o chamar de qualquer coisa que não seja o terminal nativo do seu sistema operacional (cmdno Windows e, suponho,bashno Linux / OSX) .Para testar, crie um novo diretório e coloque o código acima em um arquivo nomeado
printablesnesse diretório. Em seguida, execute o seguinte script Bash:O script acima colocará cada linha
printablesem seu próprio diretório, nomeie todos elesA.java(exceto o arquivo que imprimeA, que é renomeadoB.java), compile cada arquivo, execute-os e exclua as evidências. Demora cerca de dez segundos para os caracteres ASCII imprimíveis começarem a aparecer no seu shell.Se você estiver no Windows, execute o seguinte arquivo em lote:
Esse arquivo em lotes tem uma abordagem um pouco diferente; em vez de pré-dividir as linhas, ele processa o arquivo linha por linha, compila e executa cada programa sucessivamente. Mais uma vez, ele exclui as evidências após o término.
Economizou inúmeros bytes + 1 DNP graças a Kevin Cruijssen!
fonte
class Bpara impressãoAinterfacevez da classe para remover opublic) e se o seu sistema operacional possui um console integrado, para que você não precise usarSystem.out.print:interface A{static void main(String[]a){System.console().printf("%1",(char)117);}}Eclipse, IntelliJ e compiladores on-line ainda não possuem esse console, resultando em umNullPointerException.print> <> ,
443437 bytesLink do intérprete TIO . Há muitos padrões aqui:
[num][num]*o;: Multiplicação de dois números e, em seguida, imprima o resultado como um caractere comoe pare com;. > <> dígitos chegam a 15, ou seja0123456789abcdef.[num][num]-n;, que leva a diferença de dois números e sai como um número comn.'-o[invalid char]: > <> é toroidal; portanto, quando o ponteiro de instrução chega ao final de uma linha, ele volta ao início. Nesse caso, isso faz com que o código seja executado duas vezes, ou seja'-o[char]'-o[char]. A primeira'-o[char]'parte envia três caracteres para a pilha,-calcula'o' - [char]eogera o resultado como um caractere. > <> então ocorre um erro quando é atingido[char], devido a um comando não reconhecido ou ao aparecer uma pilha vazia.'-n[invalid char], que sai como um número.'[num][op]o[invalid char], o que se aplica[op]com[num]on[char], com erro no char. Por exemplo,'2+oJsaídasL, que são duas a mais queJ.'código é"-oH, usando em"vez disso.-código é'%oB, usando em%vez disso.ln;: Empurre o comprimento da pilha, produza como num e depois para, dando0. Da mesma formalln;para1e'ln;para3.4|n+: Pressione 4, salte para fora|e pressione outro 4, adicione e depois a saída8como num. Salte|novamente e erro ao tentar executarnnovamente em uma pilha vazia.3|n*para9.[num]|o*para@Qdy.'1-:00p: O mais interessante para oocaso. Para evitar usaroem nosso código, precisamospcolocar umona caixa de código e executá-lo. A inicial'1-:00p'configura a pilha para ter umpno topo e a1-diminui para umo.:duplica issooe00pcoloca umoem (0, 0), transformando o codebox emo1-:00p. O ponteiro de instruções é quebrado novamente, produzindo o outroo. O caractere (0, 0) é então substituído mais algumas vezes antes que o programa finalmente desapareça.fonte
Dyalog APL ,
527522 bytes(não concorrente porque o APL realmente não pode ser gravado usando apenas ASCII)
A maioria está no formato
nn⊃⎕AVounnn⊃⎕AV, com as exceções:Aqui está a lista completa:
fonte
⍨é o meu novo emoticon favoritoRuby, 869 bytes
Para os 63 caracteres
@completos~, temos uma solução de 10 bytes:Para a maioria (21) a partir de caracteres
spaceatravés?, temos uma solução de 9-byte:Restam onze casos especiais:
No total, a pontuação é 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869.
fonte
?\xxxvez de"\xxx"1 byte cada.p 1+8e nãop-~8?-, ou algo assim. :(putc 65=>AWolframAlpha , 368 bytes
Formato geral:
Exceções:
Aqui está a lista completa:
fonte
PHP (
891680674 bytes,20 DNP)Edit: economizou 203 bytes graças ao jimmy23013 e implementou o 2 DNP graças ao Mego
Essa resposta abusa muito da natureza generosa do PHP. A maioria dos casos assume um destes formulários (7 bytes cada):
O PHP converte as letras dos dois lados do operador em seqüências de caracteres, depois executa a operação bit a bit apropriada, convertendo cada sequência em seu valor de caractere ASCII e, finalmente, converte o resultado novamente em um caractere.
No primeiro exemplo acima,
Y^xtorna-se89^78. O resultado disso é33, que é então enviado para STDOUT como o caractere!.Um script foi escrito para bruteforce todas as combinações possíveis: os resultados podem ser encontrados aqui .
Exceções:
;é<?=Z^a?>(8 bytes)|é<?='9'^E;(9 bytes)<e?normalmente seria DNP devido à tag inicial necessária, mas usando o-rsinalizador, o código pode ser executado sem eles:<éecho Z^f;(9 bytes)?éecho Z^e;(9 bytes)=éecho Z^g;(9 bytes)Ponto:
(7 * 90) + 8 + 9 + 9 + 9 + 9 = 674 bytes
fonte
&|^entre duas letras para gerar todos os caracteres ascii imprimíveis, exceto<?=|;.~vez de XOR, AND ou OR. O PHP pode usar mais caracteres imprimíveis como constantes do que apenas letras.Braquilog ,
546477 bytesCréditos para Fatalizar para o código
@.Na lista abaixo, o primeiro caractere é o caractere a ser impresso (para fácil referência).
@S ! @Ht "@P: 2m # @P: 3m $ @P: 4m % @P: 5m & @P: 6m '@P: 7m (@P: 8m ) @P: 9m * @P: 10m + @P: 11m , @H: 5m - @P: 13m . @P: 14m / @P: 15m 0 1- 1 0+ 2 1+ 3 2+ 4 3+ 5 4+ 6 5+ 7 6+ 8 7+ 9 8+ : @ P @ 4bhbbbh ; @P: 27m <@P: 28m = @P: 29m > @P: 30m ? @P: 31m @ "?": "A" ybh A @ Zt @ u B @ Ch @ u C @P: 35m D @P: 36m E @P: 37m F @P: 38m G @P: 39m H @P: 40m I @P: 41m J @P: 42m K @P: 43m L @P: 44m M @P: 45m N @P: 46m O @P: 47m P @ A: 15m @ u Q @P: 49m R @P: 50m S @P: 51m T @P: 52m U @ Vt @ u V @P: 54m W @ Qt @ u X @P: 56m Y @ Wt @ u Z @ At @ u [@P: 59m \ @P: 60m ] @P: 61m ^ @P: 62m _ @P: 63m `@P: 64m a @Vh b @Ch c @Dbh d @A: 3m e @Vbh f @A: 5m g @A: 6m h @A: 7m i @A: 8m j @A: 9m k @C: 7m l @C: 8m m @ D @ 2ht n @A: 13m o @H: 4m p @A: 15m q @Z: 9m r @Z: 8m s @Z: 7m t @Z: 6m u @Vt v @Z: 4m w @Qt x @Z: 2m y @Wt z @At {@P: 91m | @P: 92m } @Prbh ~ @PtTodos eles são predicados, portanto,
Zprecisa ser o argumento para receber a saída: Experimente online!Explicação
@Pé esta sequência:que contém todos os ASCII imprimíveis.
fonte
"@"desta forma> <> , 531 bytes
Os programas assumem duas formas principais:
O primeiro é para caracteres com códigos de caracteres com dois fatores menores que 16, o outro é para os outros casos. A maioria dos números para os quais eu uso o segundo formulário tem muitas soluções de igual comprimento, mas eu escolhi esse para facilitar a leitura.
Exceções:
Lista completa:
fonte
;usos;. Além disso, tenho certeza de que a maioria deles pode ser jogada em erro, eoé definitivamente possível.oeO, não vejo comooé possível. E como o final de um erro seria mais curto?opode ser feito usandop. Posso postar separadamente por erro, porque provavelmente haverá muitos padrões diferentes envolvidos.;programa embora. Obrigado por apontar isso!Hexagonia ,
376373 bytes, 1 DNPObrigado a FryAmTheEggman por salvar 3 bytes.
Quase todos os programas têm a mesma forma:
Existem algumas exceções:
;sem usar;, portanto, 1 DNP.@, não podemos usar@para finalizar o programa. Em vez disso, usamos umS2;:ouS3;%. Isso termina com um erro de divisão por zero, mas esse erro não é visível no STDOUT. Portanto, ainda são quatro bytes.Uqual seria necessárioU3;@. Existem várias maneiras de corrigir isso, incluindo alternar para minúsculas, ou sejan9;@, usando incremento ou decremento,T);@ou sejaV(;@. De qualquer forma, ainda são quatro bytes.0e!imprimem um valor inteiro, para que possamos obter0e1com!@e)!@, respectivamente, economizando 3 bytes.Quanto ao funcionamento dos
<letter><digit>;@programas: o layout hexagonal de um programa da forma1234é sempreComo nenhum dos programas contém comandos que redirecionam o fluxo de controle, esses são simplesmente programas lineares executados em ordem.
Em todos os casos, a letra no início do código define a borda da memória atual como seu código de caractere. Por exemplo, no programa
P1;@,Pdefine o valor80. Em seguida, o dígito multiplica esse valor por 10 e se adiciona (ou seja, o dígito é anexado ao valor atual). Isso dá801no exemplo acima. Por fim,;imprime esse valor usando o módulo 256 e usando-o como um valor de byte. Nesse caso,801 % 256 = 33e a!é impresso.fonte
Espaço em branco , 1643 bytes, 1 DNP
17 bytes para os caracteres [33-63] e 18 bytes para os caracteres [64-126]
No espaço em branco, isso é simples, porque os caracteres imprimíveis (exceto o espaço) não têm qualquer significado:
O programa acima imprime um '!' (100001b). Mude
[TAB][SPACE][SPACE][SPACE][SPACE][TAB]na primeira linha para o caractere que desejar. Não é possível imprimir um espaço sem usá-lo, porque a impressão de qualquer coisa sempre começa com[TAB][LF][SPACE]fonte
Retina , 712 bytes, 2 DNPs
Este foi um esforço colaborativo com FryAmTheEggman.
Existem várias classes de soluções. Para a maioria dos caracteres do espaço para
^, usamos um programa da seguinte forma:O caractere na segunda linha percorre os intervalos
_0-9A-Za-zenquanto o restante permanece inalterado. Isso transforma a entrada vazia nesse caractere e a substitui pelo caractere ASCII imprimível (representado porp) na posição correspondente. Cada um desses programas tem 8 bytes.Dentro desse intervalo, existem apenas algumas exceções. Mais importante ainda, os dígitos podem ser reduzidos:
x(conta o número dexs na entrada vazia)(weehoo, programa vazio; conta o número de correspondências vazias na entrada vazia)2: agora transformamos a entrada em um único caractere, antes de contar as strings vazias:
3: mesma coisa, mas transformamos a entrada em dois caracteres:
4: você entendeu a idéia ...
5 - 9: reviravolta na trama ... usamos a repetição de caracteres para evitar que a segunda linha fique mais longa:
...
A outra exceção é que
Té um DNP: não achamos possível gerar um caractere que não seja um dígito sem que ele apareça no código-fonte se os estágios de transliteração não puderem ser usados.Para os caracteres restantes. Para imprimir
_, usamos um programa semelhante à solução geral acima:Fazendo uso do fato que
wcomeça com_.A seguir,
`é o segundo DNP, porque os estágios de transliteração também os exigem.Em seguida, a maioria das letras minúsculas é impressa com algo assim (que é impresso
a):Novamente, o caractere na segunda linha é incrementado
_0-9A-O. Aqui, precisamos apenas tomar cuidado comlew, que podemos imprimir com os seguintes programas, respectivamente:Finalmente, restam apenas
{|}~, que exigem 9 bytes cada. Aqui, usamos o estágio de transliteração para incrementar o caractere que os precede. Por exemplo,~pode ser impresso com:fonte
Pyke,
364362355 bytesTudo no formato
w<chr(charcode+32)>.C(4 bytes), exceto:->d1 byte0->Z1 byte1->~W2 bytesa->Gh2 bytesz->Ge2 bytesa) no formulárioG<number>@(3 bytes)k->GT@3 bytes>->~Bh3 bytes]->~Be3 bytesZ->~le3 bytes9->~ue3 bytesw->G22@4 bytes.->~B4@4 bytesC->~K38@5 bytesIntérprete online de Pyke
fonte
JavaScript (ES6),
10831068 bytesForma geral:
Exceções:
Editar: salvou 15 bytes graças a @ GOTO0.
fonte
alert(atob`XA`)"\" para salvar alguns bytes.x.\uescapes no código fonte? Legal05AB1E , 417 bytes
Explicação
A maioria é 5 bytes do formulário:
convert nr to base nr+1.>precisa de um byte extra, pois não podemos usar incremento para isso.a,b,x,y,z,Y,Zsão extraídos dosAquais contém o alfabeto em letras minúsculas.A,B,C,D,E,Fsão números convertidos em hexadecimal.0-9são simples incrementos / decréscimos, bem como variáveis predefinidas.fonte
Marbelous, 220 bytes
Para um caractere que não é um dígito, são apenas os dois dígitos hexa maiúsculos do código de caractere. Por exemplo, o seguinte programa gera
A:Para um dígito que não seja
3, substitua2Fno código a seguir pelos dígitos hexa maiúsculos do código de caractere - 1:Para
3:Pontuação total: 2 * 85 + 5 * 10 = 220.
Intérprete.
Minha primeira tentativa foi Bubblegum e não funcionou para personagens antes
?...fonte
Perl 6: 921 bytes
Tradução da solução Python.
Cada programa tem o formato
say "\x<hex escape code>", exceto:s→put "\x73"a→put "\x61"y→put "\x79"→"\x20".say"→say chr 34\→say chr 92x→say chr 1200→say 1-11→say 3-22para9→say <n minus one>+1Para referência e facilidade de teste, eis a lista completa de programas, separados por nova linha.
Aqui está o código que usei para testar a lista acima e conte a pontuação:
fonte
sayé necessário e as seqüências de escape octais são escritas como\o77. Sinta-se à vontade para postar uma solução Perl 5 separada ... :)Haskell,
1874 1864 1856 1855 1795 17911589 bytes, 7 DNPsA maioria dos programas é
main=putChar '\xx'oumain=putChar '\xxx'ondexx/xxxé o código ascii do caractere a ser impresso. Isso funciona para todos, exceto 14 caracteres:No entanto, para os dígitos
1 74 bytes podem ser salvos (graças a Christian Sievers!):Os 52 programas até
c(código 99) recebem 18 bytes, os 19 restantes, 19 bytes cada.Pontuação parcial:
10*14 + 52*18 + 19*19 = 1437Para 7 dos caracteres restantes, os seguintes programas funcionam:
Pontuação parcial:
18 + 22 + 18 + 21 + 19 + 27 + 27 = 152Isso deixa 7 DNPs:
=aimnrtCada programa Haskell precisa definir um main (
main=), então são 5 DNPs. Para imprimir a StdOut,putChar,putStrouinteractpode ser utilizado, dando origemtercomo mais DNPS. (Há tambémprint, no entanto,print 'a'imprime'a'e nãoa- e também contémte derqualquer maneira.) Haskell também possui umachrfunção que retorna o caractere correspondente dado um número, no entanto, para usá-loimport Data.Charé necessário.Pontuação total
1437 + 152 = 1589:, 7 DNPsfonte
main=print$1-1etc.succ)BBC Basic,
422413 bytesFaça o download do intérprete gratuitamente em http://www.bbcbasic.co.uk/bbcwin/bbcwin.html
9 bytes salvos graças a Leaky Nun.
Forma geral
32..99, excluindo 12 casos especiais: 56x4 = 224 bytes
100..126 : 27x5 = 135 bytes
12 casos especiais: 54 bytes
A maioria dos números segue a forma geral, mas incluí todos aqui para mostrar onde está o problema.
Primeiro caractere é o caractere a ser impresso.
fonte
V.48para0?V.eP.sempre estiveram lá?.será expandida para uma palavra-chave. Esse desafio é estrito sobre o uso de ASCII não imprimível, mas, sem dúvida, com outros desafios, você poderia dizer que as palavras-chave tokenizadas (ascii 127-255) eram de um byte. Dito isto, nunca tentei esse argumento e geralmente dou as duas pontuações.Minkolang 0.15 , 604 bytes
Para a maioria dos personagens,
"<char-1>"1+O.seria um programa válido, talvez um dos mais curtos. No entanto, devido ao fato de os caracteres serem armazenados como pontos de código na pilha, muitos deles podem ser produzidos por multiplicação e adição, em cinco bytes ou menos. Além disso, observe quel, $1, $2, $3, $4, $5, $6, $lsão10, 11, 12, 13, 14, 15, 16, 100respectivamente.Formato:
<character>: <program>Menções especiais:
(Experimente.) Minkolang tem a capacidade de modificar os caracteres na caixa de código; portanto, o que este programa faz é que ele substitua isso
-no final por., necessário para interromper o programa."N"1+d90pN.paraOfunciona da mesma maneira.(Experimente.)
lZEmpurra os alfabetos em maiúsculas e minúsculas para a pilha eIempurra o comprimento da pilha, que é 52, precisamente o ponto de código de "4". A melhor parte é que eu estava inicialmente pensando na solução de4$3*O., que multiplica 4 e 13 para obter 52, mas não consegui porque tinha 4, então acabei encontrando uma solução para golfista de qualquer maneira!(Tente.)
dDuplica a parte superior da pilha, então o que esse trecho de código faz é que ele empurra11, duplica e multiplica. Uma maneira alternativa de escrever isso seria$12;O., com a mesma contagem de bytes.(Experimente.)
;É exponenciação, então isso faz 5 ^ 3 para obter 125.fonte
Groovy, 1019 bytes
Eu tinha uma solução Groovy diferente escrita (veja abaixo), mas depois que a enviei, me aprofundou um pouco mais nas fugas de caracteres, na esperança de encontrar uma maneira de reduzir mais o programa, e descobri que o Groovy tem uma fuga octal de caracteres que eu não sabia. Isso simplifica significativamente o código, a ponto de, infelizmente, remover a necessidade de quase todas as soluções alternativas peculiares que eu criei.
Também parece quase idêntico à solução Python 2 da Copper , a ponto de basicamente parecer que plagiei o trabalho deles. Ugh.
Cada programa tem o formato
print'\<octal value>', exceto:p,r,i,n,t→'print''\<octal value>'(mas com a letra correspondente de "print" também substituído com o valor octal)0-9→print~-<next int>Aqui está a lista completa de programas por personagem.
Groovy, 1130 bytes
Meu programa anterior, antes de descobrir que existem fugas octais. Muito mais interessante, IMO.
Cada programa tem o formato
print(--'<next char>'), exceto:-,[,~→print(++'<previous char>')&→print(--"'")p,r,i,n→System.out<<--'<next char>'t→'prin\u0074'(--'u')(→print'\u0028')→print'\u0029'0-9→print~-<next int>Aqui está a lista completa de programas para cada personagem:
fonte
Na verdade ,
383382381 bytes1 byte graças ao Mego.
Para fácil referência, a primeira coluna é o código do caractere, a segunda coluna é o caractere e a terceira coluna é o código.
O código para
0é um espaço único.Experimente online!
Sugestões de golfe são bem-vindas.
fonte
:em 5:9P2*cFourier, 306 bytes, 1 DNP
Praticamente todos os programas seguem o padrão em
naque n é o código de caractere de cada um dos caracteres. Por exemplo:Experimente online!
Então, apenas listarei as exceções:
0 (zero)
Como o acumulador é predefinido para zero, podemos exibir isso usando um único caractere:
Experimente online!
1 1
Semelhante a zero, isso incrementa o acumulador para obter 1.
Experimente online!
5
O código ASCII para 5 é 53, então tive que contornar isso:
Experimente online!
uma
Por
aser a função de saída de caractere, não há outra maneira de produzir o caractere a, então esse é o meu único DID NOT PROGRAM .Veja todos os programas aqui
fonte
Matlab,
12381224 bytes, 2 DNPO padrão principal é:
Para dígitos, é um pouco menor:
Para caracteres
[]'é:Os caracteres
dsdedispsão exibidos usandofprintf( obrigado @Stewie Griffin );ipno entanto pertencem também lá, então estou mudando a string e usandoeval:()No entanto, ambos os caracteres são necessários paradispoueval, portanto, são DNP.Para referência a lista inteira:
fonte
[100 105 115 112](char-codes) funcionadisp?disp([100 105 115 112])também não produzirá uma stringeval([100 105 115 112]).fprintfpara d ans s:fprintf([115,'']). Salva 2x7 bytes =) não vai torná-lo um projeto vencedor, mas hey: 14 bytes é de 14 bytes ,,,disp([0 ''])contém um espaço.disp([0,''])não.fprintf.Gelatina (não competitiva), 406 bytes
Isso imprime todos os caracteres de 32 a 126. A contagem de bytes é calculada com https://mothereff.in/byte-counter .
Experimente online!
fonte
In a programming language of your choice, write 95 programs, each of which outputs a different one of the 95 printable ASCII characters without that character occurring anywhere in the program.Befunge-93, 530 bytes
A maneira mais fácil de gerar um caractere, sem usá-lo, é calcular o valor ASCII e usar o
,comando (saída de caractere) para renderizá-lo. Por exemplo,49*,@gera o caractere do dólar (ASCII 36, 4 * 9). Porém, isso raramente é o melhor, já que a maioria dos valores leva mais de 3 bytes para calcular.Outra maneira de gerar um número em 3 bytes é aproveitar o fato de o
gcomando (get) na primeira célula do campo de jogo gerar o valor ASCII de g (presume-se que uma pilha vazia seja preenchida com zeros, portanto, é lendo o valor do campo de jogo em 0,0). Assim,g1+,@você recebe h , eg1-,@você recebe f . Obviamente, isso funciona para uma série de compensações e operações diferentes+e-também são possíveis. Assim, por exemplo,g3/,@você recebe uma citação dupla.Uma variação disso é preceder o
gcomando com outro comando que deixa todos os zeros na pilha. Então você ainda está lendo um valor do campo de jogo em 0,0, mas o personagem que está sendo lido agora é diferente. Isso custa mais um byte, mas você obtém acesso a muitos outros valores. Por exemplo,0g1-,@você obtém uma barra e:g1+,@um ponto e vírgula. Outros prefixos viáveis incluem*,+,-,>,\e_. E, novamente, observe que outras operações são possíveis:>g2*,@obtenha uma barra vertical.Uma variação adicional é preceder o
gcom a1, então você não está mais lendo de 0,0, mas da célula em branco em 0,1. No Befunge, as células vazias são inicializadas com espaços por padrão, então1g,@você recebe um espaço e1g1+,@um ponto de exclamação.Para os dígitos, há mais truques duvidosos que podemos usar. Em vez de tentar produzi-los como caracteres, nós os produzimos como números (um número pequeno é mais fácil de gerar do que seu equivalente ASCII). Assim, por exemplo,
11+.@você fornece 2 e, em particular, observe os casos especiais:.@para 0 e!.@para 1 . A parte duvidosa disso é que uma saída numérica no Befunge inclui um espaço após o número, portanto não é uma saída pura de caracteres.Outro truque duvidoso que podemos usar é uma variação da
gtécnica acima. Em vez de nos limitarmos aos comandos Befunge para o prefixo, também podemos usar tecnicamente qualquer caractere que não seja um comando Befunge. Na maioria dos intérpretes, um comando não reconhecido será ignorado e, portantog, acabará lendo o valor ASCII do caractere anterior. Isso nos permite gerar a maioria dos outros valores ASCII que não poderiam ser calculados em 3 bytes. Como um exemplo:Qg1+,@você recebe R .Finalmente, existem três casos especiais. Um g não pode ser gerado em menos de 5 bytes, por isso temos que recorrer
"f"1+,@. A vírgula é o mais complicado, exigindo a alteração dinâmica do campo de jogo:0g4-:80p @. Poderíamos usar uma técnica semelhante para evitar o caractere at, mas um hack mais eficiente é usar o%comando (modulo) como terminador, ie88*,%. Quando o%é atingido, não há nada na pilha; portanto, o cálculo do módulo gera uma divisão por zero, e no intérprete de referência isso encerrará o programa.Abaixo está a lista completa de programas, um por linha.
fonte