Escreva um programa ou função que imprima ou retorne uma sequência de caracteres alfanuméricos mais o sublinhado em qualquer ordem . Para ser preciso, os seguintes caracteres precisam ser produzidos, e não mais :
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_ Ao imprimir em stdout, uma nova linha final opcional após sua saída é permitida.
Constantes integradas que contêm 9 ou mais dos caracteres acima não são permitidos.
O código mais curto em bytes ganha.
Este é um desafio muito simples, que acredito que irá gerar algumas respostas interessantes.
Placares
Aqui está um fragmento de pilha para gerar um placar regular e uma visão geral dos vencedores por idioma.
Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo Markdown:
# Language Name, N bytes onde N é o tamanho do seu envio. Se você melhorar sua pontuação, pode manter as pontuações antigas no título, riscando-as. Por exemplo:
# Ruby, <s>104</s> <s>101</s> 96 bytes Se você quiser incluir vários números em seu cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar o intérprete sinalizar penalidades separadamente), certifique-se de que a pontuação real seja o último número no cabeçalho:
# Perl, 43 + 2 (-p flag) = 45 bytes Você também pode fazer o language name um link que aparecerá no snippet do placar:
# [><>](http://esolangs.org/wiki/Fish), 121 bytes var QUESTION_ID=85666,OVERRIDE_USER=4162;function answersUrl(e){return"https://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"https://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;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> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody> </tbody> </table> </div><div> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody> </tbody> </table> </div><table style="display: none"> <tbody> <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> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
Comentários
- Os comentários não são para discussões extensas; esta conversa foi movida para o bate-papo .
Resposta
Convexo, 9 bytes
Novo método! Além disso, percebi que é exatamente a mesma resposta do Luis “, mas no Convexo, mas eu vim com isso de forma independente.
"{,®\W"Oò Explicação:
"{, Array of chars from NUL to "z ®\W" Regex to match non-word characters Oò Replace all matches with emtpy string Solução antiga, 10 bytes :
A,"[,_¬^"_ Explicação:
A, 0-9 "[,_¬^ A-Za-z "_ _ Comentários
Resposta
Ruby, 26 bytes
Os caracteres podem ser impressos em qualquer ordem? Não importa se eu fizer isso!
$><<(?0..?z).grep(/\w/)*"" Resposta
Perl, 20 bytes
Requer -E sem custo extra .
say+a.._,A.._,_..9,_
Então, minha resposta original (abaixo) foi um pouco chata . A única coisa que consegui sugerir é o acima, que é exatamente o mesmo, mas parece um pouco mais confuso … É exatamente equivalente ao seguinte:
say a..z,A..Z,0..9,_
Eu gosto de @ msh210 “s sugestões nos comentários, mas eles são um pouco longos demais!
Comentários
- +1. Um pouco mais interessante, mas mais longo é qualquer um desses , todos os 27 bytes:
say grep/\w/,map chr,1..122||say map{chr=~/\w/;$&}1..122||say map{chr=~s/\W//r}1..122 - @ msh210 Ainda pode ' encolher mais … Mas conseguiu 25:
say chr=~/\w/g for 1..255…
Resposta
Cheddar, 31 27 bytes
->97@"123+65@"91+48@"58+"_" Isso mostra o @" operador bem
Não completando porque finalmente consegui consertar @". O bug era que estava gerando um intervalo de Cheddar, não um intervalo de JS, então não poderia funcionar corretamente
Explicação
O operador @" era projetado por @ CᴏɴᴏʀO “Bʀɪᴇɴ, e o que faz é gerar uma faixa de string de LHS a RHS.Quando usado como um operador unário, ele retorna o caractere no ponto de código fornecido (como python “s chr)
Ungolfed
-> 97 @" 123 + 65 @" 91 + 48 @" 58 + "_" Resposta
brainfuck, 58 bytes
+++[[<+>->++<]>]<<[-<->]<<-.+<<++[->>+.>+.<<<]<--[->>.+<<]
Inicializa o fita em 3 · 2 n e trabalha a partir daí.
+++[[<+>->++<]>] initialize the tape | 0 | 3 | 6 | 12 | 24 | 48 | 96 | 192 | 128 | 0 | 0 | ^ <<[-<->] subract 128 from 192 | 0 | 3 | 6 | 12 | 24 | 48 | 96 | 64 | 0 | 0 | 0 | ^ <<-.+<<++ ouput "_"; increment 24 twice | 0 | 3 | 6 | 12 | 26 | 48 | 96 | 64 | 0 | 0 | 0 | ^ [->>+.>+.<<<] output aAbBcC ~ zZ | 0 | 3 | 6 | 12 | 0 | 48 | 122 | 90 | 0 | 0 | 0 | ^ <--[->>.+<<] decrement 12 twice; output 0 ~ 9 | 0 | 3 | 6 | 0 | 0 | 58 | 122 | 90 | 0 | 0 | 0 | ^
Resposta
JavaScript (ES6), 62 bytes
_=>String.fromCharCode(...Array(123).keys()).replace(/\W/g,"") Retorna 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz, portanto, apenas 6 bytes a menos do que uma função que retorna o literal de string. Sim, é uma merda.
Comentários
- Você pode tentar encontrar uma string para a qual
btoaretorna a saída necessária. - @gcampbell 60! (60 fatoriais) strings podem levar algum tempo para pesquisar …
- Você poderia apenas usar
atob. - @gcampbell eu tenho que exclua strings não representáveis de alguma forma.
- @gcampbell Acontece que a versão btoa leva 62 bytes de qualquer maneira: 45 para codificar 60 alfanuméricos, 3 caracteres não codificados (incluindo
_) e 14 para_=>atob("")+"".
Resposta
Haskell, 38 bytes
"_":["a".."z"]++["A".."Z"]++["0".."9"] Nada a explicar aqui.
Comentários
- pergunta: qual ' é a diferença entre
:e++? - @Downgoat:
++pega duas strings e as concatena.:pega um caractere e uma string e coloca o caractere na frente da string."_"++['a'..'z']...também funciona, mas é um byte a mais.
Resposta
PowerShell v3 +, 35 33 bytes
-join([char[]](1..127)-match"\w") Constrói uma matriz dinâmica 1..127 , converte-o em uma matriz char. Isso é enviado ao operador -match trabalhando no regex \w, que retornará todos os elementos que correspondem (ou seja, exatamente alfanumérico e sublinhado ). Encapsulamos esses elementos da matriz em um -join para agrupá-los como uma string. Isso é deixado no pipeline e a saída é implícita.
Comentários
- Ei, isso ' não é justo. Minha própria solução é idêntica, exceto que comecei em
0… - @Joey Tenho que ir rápido. : D
- Especialmente para as soluções triviais e óbvias, eu acho 😉
Resposta
V, 27 bytes
i1122ñYpñvHgJ|éidd@"Í× Esta resposta é terrivelmente complicada. Postarei uma explicação mais tarde.
Hexdump:
00000000: 6916 1631 1b31 3232 f159 7001 f176 4867 i..1.122.Yp..vHg 00000010: 4a7c e969 6464 4022 1bcd d7 J|.idd@"... Explicação:
Legível:
i<C-v><C-v>1<esc> "Insert the text "<C-v>1" "<C-v> means "literal" 122ñ ñ "122 times, Yp "Duplicate this line <C-a> "And increment the first number on this line vHgJ "Join every line together |éi "Insert an "i" at the beginning of this line dd "Delete this line @"<esc> "And execute it as V code. "That will generate every ascii value from 1-123 Í× "Now remove every non-word character. Comentários
- : D: D: D Cheddar está empatado com uma língua de golfe!
Resposta
J, 30 29 28 bytes
Salvo um byte graças a randomra!
~.u:95,;48 65 97+i."*10,,~26 Resultado:
~.u:95,;48 65 97+i."*10,,~26 _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz Explicação
Não vou fornecer uma explicação per se , mas fornecerei resultados intermediários.
10,,~26 10 26 26 i. b. 0 1 _ _ * b. 0 0 0 0 i."* b. 0 i."*2 3 4 0 1 0 0 0 1 2 0 0 1 2 3 i. 2 0 1 i. 3 0 1 2 i. 4 0 1 2 3 i."*10,,~26 0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 0 1 2 + i."*10,,~26 0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 48 65 97+i."*10,,~26 48 49 50 51 52 53 54 55 56 57 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 ;48 65 97+i."*10,,~26 48 49 50 51 52 53 54 55 56 57 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 95,;48 65 97+i."*10,,~26 95 48 49 50 51 52 53 54 55 56 57 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 ... u:95,;48 65 97+i."*10,,~26 _01234567890000000000000000ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ~.u:95,;48 65 97+i."*10,,~26 _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz Resposta
Haskell, 31 bytes
do(x,y)<-zip"aA0_""zZ9_";[x..y]
A expressão zip "aA0_" "zZ9_" fornece a lista de endpoints [("a","z"),("A","Z"),("0","9"),("_","_")]. div id = “77c0d2706f”>
a notação leva cada (x,y) ao \(x,y)->[x..y] inclusivo e concatena o resultado s. Agradecimentos a Anders Kaseorg pelos dois bytes com do em vez de >>=.
Compare com as alternativas:
do(x,y)<-zip"aA0_""zZ9_";[x..y] zip"aA0_""zZ9_">>= \(x,y)->[x..y] f(x,y)=[x..y];f=<<zip"aA0_""zZ9_" id=<<zipWith enumFromTo"aA0_""zZ9_" [c|(a,b)<-zip"aA0_""zZ9_",c<-[a..b]] f[x,y]=[x..y];f=<<words"az AZ 09 __"
Comentários
-
doa notação economiza dois bytes:do(x,y)<-zip"aA0_""zZ9_";[x..y]
Resposta
C, 50 bytes
Chame f() sem nenhum argumento.
f(n){for(n=128;--n;)isalnum(n)|n==95&&putchar(n);} Impressões
zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210 Comentários
-
isalnum(n)|n==95&&putchar(n) - Há ' s UB lá. Você não ' passou os argumentos necessários.
- @orlp – Você usou
putcem vez deputchar.putcespera um fluxo para gravar também, o que você não ' passou.A função em si funciona bem (tente remover seusputccompletamente e funciona). - @owacoder Oops!
- @QPaysTaxes que ' está errado.
If the number of arguments does not equal the number of parameters, the behavior is undefined.6.5.2.2/6, consulte N1570 .
Resposta
/// , 63 bytes
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_ Comentários
- Como é a resposta válida? Parece que ' está violando as regras.
- @nicael, qual regra?
- " Constantes incorporadas que contêm 9 ou mais dos caracteres acima não são permitidas. " … Estou perdendo algo óbvio, @Leaky?
- Sim, que isto não ' usava nenhuma constante embutida.
- Ok, mas isso é estranho, pelo menos. Definitivamente, o OP não ' pede que você copie e cole a sequência, isso ' não é interessante.
Resposta
Python 3, 58 bytes
print("_",*filter(str.isalnum,map(chr,range(123))),sep="") Um programa completo que imprime em STDOUT.
O resultado é: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
Como funciona
map(chr,range(123)) Yield an iterator containing all ascii characters with code-points in [0,122]... *filter(str.isalnum,...) ...keep characters if alphanumeric and unpack into tuple... print("_",...,sep="") ...add underscore and print all characters with no separating space Se constantes de string fossem permitidas, o seguinte teria 45 bytes:
from string import* print("_"+printable[:62]) Comentários
-
print('_'+*filter(str.isalnum,map(chr,range(123)))) - @LeakyNun Isso gera um erro de sintaxe. Pensei em fazer algo semelhante com
print('_',*filter(str.isalnum,map(chr,range(123)))), mas isso imprime espaços separados; o OP disse nos comentários que ' … nenhum espaço é permitido na saída '. - Python 2 pode economizar um byte com esta abordagem:
print''.join(filter(str.isalnum,map(chr,range(123)))),'_'
Resposta
Minha primeira tentativa de codegolf!
C #, 168 152 150 147 130 127 117 116 115 109 106 bytes
for(var a="0";a<"~";a++){Console.Write(System.Text.RegularExpressions.Regex.IsMatch(a+"","\\w")?a+"":"");} Muito obrigado a aloisdg, AstroDan, Leaky Nun e Kevin Lau – não Kenny por toda a ajuda nos comentários.
Comentários
- Bem-vindo ao PPCG! Sinta-se à vontade para remover todo o espaço! Verifique também Dicas para jogar golfe em C # para obter algumas dicas.
- Ótimo – economizei mais 2 bytes. Eu ' estou realmente começando a gostar deste codegolf 🙂
- AFAIK, a
\wclasse regex cobre os alfanuméricos e também_, que deve tornar"\\w"válido o suficiente para a função de correspondência de regex. - Seu código deve ser uma função ou um programa completo, não uma declaração. Use também .NetFiddle para compartilhar uma demonstração de seu código 🙂
- " C # isn ' o melhor para codegolf " Acho C # divertido o suficiente para codificar golfe. Eu acho que é uma ótima linguagem mainstream para brincar. Se você está aqui para vencer, você perderá. Defina seu objetivo como aprender e se divertir e você vai vencer todas as vezes.
Resposta
Resposta
Object Pascal, 85 83 73 bytes
Apenas objeto simples pascal usando um conjunto de caracteres. Escrever um programa completo em vez de um procedimento corta 2 bytes. Remover a palavra-chave do programa corta mais 10 bytes.
var c:char;begin for c in["a".."z","A".."Z","0".."9","_"]do write(c);end. Comentários
- Eu sempre fui e provavelmente irei sempre ser confundido com a classificação exata de Object Pascal. Turbo / Borland Pascal e FreePascal certamente ficam felizes sem a palavra-chave
programinútil. - @manatwork que eu não ' t sabe disso. Curiosamente, agora torna o pascal competitivo aqui …
- A linguagem com a qual cresci. Eu sei que ainda não está morto …
- @rexkogitans Sim, eu aprendi na escola, mas não consigo ' não me lembrar de nada daquela época … Eu ' estou brincando com alguma programação novamente
Resposta
bash – 47 37 bytes
man sh|egrep -o \\w|sort -u|tr -d \\n A saída em meu sistema é:
_0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ Obrigado ao Digital Trauma pelas sugestões úteis.
Em alguns sistemas, você pode usar ascii em vez de man sh para salvar um byte.
Comentários
-
man sh|egrep -io _\|\\w|sort -u|tr -d \\n - @DigitalTrauma Obrigado!Experimentou e descobriu que
\wcorresponde a_e já não faz distinção entre maiúsculas e minúsculas, então poderia reduzir ainda mais. -
envem vez deman shdeve funcionar na maioria dos ambientes. Faz no meu.$ env|egrep -o \\w|sort -u|tr -d \\n– >0123456789ABCDEFGHIKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz. - Lá ' s não
J. Meu mal.
Resposta
PHP, 40 bytes
_0<?for(;$a++^9?$a^q:$a=A;)echo" $a"|$a;
Comentários
- +1 por excelência. Nota lateral: PHP 7.2 produz avisos mencionando que versões futuras irão lançar erros para constantes indefinidas. 🙁
Resposta
Retina , 30 19 16 15 12 bytes
Eu modifiquei meu tentativa de alfabeto original para esta versão mais recente. Cada caractere é impresso em um loop.
A primeira linha está vazia.
; +T\`;w`w_Resultado:
_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz Obrigado a Leaky Nun por jogar 4 bytes na minha última tentativa.
Comentários
- I ' d dizer que
wconta como uma constante contendo 9 ou mais dos caracteres obrigatórios. Você ' provavelmente terá que expandir o lado direito e substituir owà esquerda poro. Embora você c salvar um byte usandoEOem vez ded, pois eles contêm apenas 5 caracteres cada. - @ mbomb007
wdentro do estágio de transliteração não tem nada a ver com regex. É ' é uma abreviação que se expande para uma lista dos 63 caracteres necessários. Pelo menos eu ' d perguntaria ao orlp sobre este caso especificamente, já que ' é bastante diferente de usar\wem um regex.
Resposta
MATL , 11 bytes
7W:"\W"[]YX 7W % Push 2 raised to 7, i.e. 128 : % Range [1 2 ... 128] "\W" % Push string to be used as regex pattern [] % Push empty array YX % Regex replace. Uses (and consumes) three inputs: source text, regex pattern, % target text. The first input (source text) is implicitly converted to char. % So this replaces non-word characters by nothing. % Implicitly display Comentários
- 2 bytes mais curtos:
8W:'\w'XX - @DrGreenEggsandIronMan Obrigado! Mas acho que novas linhas não são permitidas como separadores. O desafio diz " uma string de caracteres alfanuméricos mais sublinhado … e não mais "
- Então, por quê não poderia ' você fazer
8W:'\w'XX!o que eu tentei, mas não ' não funcionou - @DrGreenEggsandIronMan Muito boa pergunta! Deixe-me responder no bate-papo para que eu possa usar um pouco mais de caracteres
Resposta
Brachylog , 25 bytes
"_"w9yrcw"A":"Z"ycL@l:Lcw Isso imprime o seguinte em STDOUT:
_9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ Explicação
"_"w Write "_" 9y Get the list [0:1:2:3:4:5:6:7:8:9] rcw Reverse it, concatenate into one number, write "A":"Z"y Get the list of all uppercase letters cL Concatenate into a single string L @l:Lcw Concatenate L to itself lowercased and write Resposta
Dyalog APL , 18 bytes
∊"\w"⎕S"&"⎕UCS⍳255 impressões:
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz Comentários
- @user Constantes integradas que contêm 9 ou mais dos caracteres acima não são permitidas.
Resposta
Pyth, 13 12 bytes
s:#"\w"0rk\| Encontra todos os caracteres em U + 0000 a U + 007B que correspondem ao regex /\w/.
O utputs 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.
abordagem alternativa: 15 bytes
ssrMc4"0:A[a{_` basicamente gera os intervalos meio-inclusivos necessários: 0-:, A-[, a-{, _-`.
Resposta
CJam , 15 14 11 bytes
4 bytes de desconto graças a @FryAmTheEggman e @Dennis!
A,"[,_el^"_ A, e# Push range [0 1 ... 9] "[, e# Push range of chars from 0 to "Z" ("[" minus 1) _el e# Duplicate and convert to lowercase ^ e# Symmetric difference. This keeps letters only, both upper- and lower-case "_ e# Push "_". e# Implicitly display stack contents, without separators Resposta
Brainfuck, 89 bytes
+++++++++[>+++++>+<<-]>+++.>[<+.>-]<+++++++>>+++++++++++++[<+<+.+.>>-]<<+++++.+>[<+.+.>-] Detalhes:
+++++++++[>+++++>+<<-]>+++. Goes to "0" while remembering a 9 for the 9 other numbers [<+.>-] Simply prints for the next 9 characters <+++++++> Moves it 7 space to the letters >+++++++++++++ Saves a 13 [<+<+.+.>>-] Prints 2 char at a time while making a second "13" space <<+++++.+> Moves 5, prints "_" and moves to the lowercases [<+.+.>-] And again the double print Se eu pudesse comentar, teria que melhorar as respostas dos outros. Mas, como não posso, também posso postar meu próprio. Quando comecei a escrever este, o menor BF tinha 96 anos.
Resposta
F #, 50 59 bytes
Seq.iter(printf"%c"<<char)(95::[48..57]@[65..90]@[97..122]) Resultado:
_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz Editar: errou os dígitos da primeira vez
Edit2, inspirado esta solução Haskell este fragmento F # é 67 bytes.
Seq.zip"aA0_""zZ9_"|>Seq.iter(fun(x,y)->Seq.iter(printf"%c")[x..y]) Resultado:
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_ Resposta
Hexagonia, 33
"A}_8_47<=">({a/[email protected]!\356);"); Expandido:
" A } _ 8 _ 4 7 < = " > ( { a / _ x . @ . 9 ! \ 3 5 6 ) ; " ) ; . . . . Resultado:
aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_ Observe que há um caractere não imprimível 0x1A como o primeiro byte do programa. Isso também faz com que a primeira linha do hexágono expandido pareça meio desligada. Muito obrigado a Martin por mostrando-me este truque, bem como sugerindo o algoritmo para imprimir t O alfabeto!
Isso imprime o alfabeto armazenando a e A nas duas arestas de um hexágono e o número 26 na borda do hexágono que toca a junta entre as letras. Isso se parece com isto:
A \ / a | 26 Em seguida, ele entra em um loop que imprime as letras e as incrementa e, em seguida, diminui o número. Depois de uma iteração, teríamos:
B \ / b | 25 E assim por diante. O código linear para a inicialização é: 0x1A " A } a. O código linear para os loops fora das mudanças de fluxo de controle é: ; ) " ; ) { ( " =.
Quando o contador chega a zero, seguimos um caminho diferente para imprimir os números e um sublinhado. Escrito linearmente é: x 3 5 6 8 4 7 9 ! ; { @. Isso substitui o valor atual da borda da memória “s pelo número 1203568479 (observe que o código ASCII de x” é 120), que contém todos os dígitos decimais. Imprimimos esse número e, em seguida, usamos um recurso bacana do Hexagony: imprimimos o número mod 256 como um caractere ASCII. Acontece que é 95 ou sublinhado.
Resposta
Brainfuck, 114 103 98 90 76 71 bytes
Outro trivial (agora não -trivial) solução, mas desta vez é BF!
Economizou 14 (!) bytes graças a @primo.
Economizou mais 4 bytes graças à sugestão de @primo para gerar o intervalo para trás, e salvei outro incrementando antes de imprimir para as letras minúsculas.
Novo (recorrência 4, 71):
+[--[<+++++++>->+<]>-]<<+++<--<-<-----<++++.+>>>[-<<.+<+.>>>]>[-<<.+>>] Antigo (valores, 114):
-[----->+<]>--->++++++++++>--[----->+<]>-------.++>----[---->+<]>++>++++[->++++++<]>++[-<<.+<<.+>>>>]<<<<<<[-<.+>] Antigo (recorrência 1, 103):
++++++++++[[<+>->+<]>+++++++++++++++]<<[<]>>+>++++++++>>----->>-----.++<<<<<[->>>.+>>.+<<<<<]<[->>.+<<] Antigo (recorrência 2, 90):
+++++++[[<+>->+<]>>+++[-<+++++++>]<]<<[<]>+++>-->->----->++++.++<<<[->>.+>.+<<<]<[->>.+<<] Antigo (recorrência 3, 76):
+[[<+++++++>->+<]>+++]<<[<]>+++>-->->----->++++.++<<<[->>.+>.+<<<]<[->>.+<<] Assume células de encapsulamento de 8 bits e memória de encapsulamento. Usei Experimente online .
Todos imprimem _AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789
Primeiro, esta parte
+[--[<+++++++>->+<]>-]<< inicializa a fita com estes valores
[91, 70, 49, 21, 7] ^ Isso funciona porque a relação de recorrência que modelei basicamente é f(x) = 7 * (3 * x + 1), ao contrário. Veja @primo “s Olá, Mundo! Resposta para uma explicação do que é uma relação de recorrência.
Então, é bastante simples para alterar esses valores para valores úteis. (e imprimir o sublinhado)
Code: +++<--<-<-----<++++.+ Tape: [96, 65, 48, 26, 10] ^ Então, os loops simples usam os valores para imprimir o resto dos caracteres. Eu economizo 1 byte tendo um incremento antes da impressão.
>>>[-<<.+<+.>>>]>[-<<.+>>] Eu realmente preciso encontrar uma geração de sequência mais curta.
Encontrei uma relação de recorrência que parece funcionar bem, mas pode haver uma mais curta com menos caça e bicada.
Usei uma calculadora de regressão linear para descobrir qual deve ser a relação de recorrência linear mais curta possível, então provavelmente devo encontrar alguma outra fórmula se quiser melhorar.
@primo realmente melhorou muito a relação de recorrência, obrigado.
Comentários
- Que tal uma construção ao contrário?
+[--[<+++++++>->+<]>-] - @primo Uau! Como isso funciona?
- 3 é irregular, por isso fará um loop total de 256 vezes. Ao terminar com
>-], você pode ter certeza de que o termo final será 1 (x7). Na verdade, você provavelmente deve começar com-, ele termina muito mais rápido.
Resposta
Sesos , 17 bytes
00000000: a854be 2cbc9e 71d597 14bc56 1ad99e 713b .T.,..q....V...q; Saída
0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_ Experimente online! Verifique Debug para ver o código binário gerado.
Como funciona
O arquivo binário acima foi gerado montando o seguinte código SASM.
add 48 ; Set cell 0 to 48 ("0"). fwd 1 ; Advance to cell 1. add 10 ; Set cell 1 to 10. jmp ; Set an entry marker and jump to the jnz instruction. rwd 1 ; Retrocede to cell 0. put ; Print its content (initially "0"). add 1 ; Increment cell 0 ("0" -> "1", etc.). fwd 1 ; Advance to cell 1. sub 1 ; Decrement cell 1. jnz ; While cell 1 in non-zero, jump to "rwd 1". ; This loop will print "0123456789". rwd 1 ; Retrocede to cell 0, which holds 48 + 10 = 58. add 7 ; Set cell 0 to 65 ("A"). fwd 1 ; Advance to cell 1. add 26 ; Set cell 1 to 26. jmp ; Set an entry marker and jump to the jnz instruction. rwd 1 ; Retrocede to cell 0. put ; Print its content (initially "A"). add 32 ; Add 32 to convert to lowercase ("A" -> "a", etc.). put ; Print the cell"s content. sub 31 ; Subtract 31 to switch to the next uppercase letter ("a" -> "B", etc.). fwd 1 ; Advance to cell 1. sub 1 ; Decrement cell 1. jnz ; While cell 1 in non-zero, jump to "rwd 1". ; This loop will print "AaBb...YyZz". rwd 1 ; Retrocede th cell 0, which holds 65 + 26 = 91. add 4 ; Set cell 0 to 95 ("_"). put ; Print its content.
Comentários
- Uau, eu estava prestes a postar uma solução muito semelhante à sua .
- Mentes semelhantes pensam muito !
- @LeakyNun Hm, meio tarde, mas parece que o seu é 3 bytes mais curto …
- @EriktheOutgolfer Sesos costumava ser codificado de uma maneira menos eficiente. Os dois programas agora têm 17 bytes.
- @Dennis Ah, bem, o cache TIO pode ser confuso às vezes.
A,'[,_el^'_