Escreva um programa ou função que imprima ou retorne uma sequência de caracteres alfanuméricos mais sublinhado, em qualquer ordem . Para ser preciso, os seguintes caracteres precisam ser impressos, e não mais :

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Ao imprimir em stdout, é permitida uma nova linha à direita após a saída.

As constantes internas que contêm 9 ou mais dos caracteres acima não são permitidas.

O menor código em bytes vence.

_{Este é um desafio muito simples, que acredito que irá gerar algumas respostas interessantes.}

Classificação

Aqui está um snippet de pilha para gerar uma classificação 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 de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-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 deseja listar as penalidades de sinalizador de intérprete separadamente), verifique se a pontuação real é o último número no cabeçalho:

# Perl, 43 + 2 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

# [><>](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 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>

Convexo, 9 bytes

Novo método! Além disso, eu percebi que é exatamente a mesma resposta de Luis, mas em Convex, mas eu a criei de forma independente.

'{,®\W"Oò

Experimente online!

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,'[,_¬^'_

Experimente online!

Explicação:

A,          0-9
'[,_¬^      A-Za-z
'_          _

Ruby, 26 bytes

Os caracteres podem ser impressos em qualquer ordem? Não se importe se eu fizer!

Experimente online!

$><<(?0..?z).grep(/\w/)*''

Perl, 20 bytes

Requer -Esem custo extra.

say+a.._,A.._,_..9,_

Então, minha resposta original (abaixo) foi um pouco chata. A única coisa que consegui sugerir é o acima, é exatamente o mesmo, mas parece um pouco mais confuso ... É praticamente equivalente ao abaixo:

say a..z,A..Z,0..9,_

Gosto das sugestões de @ msh210 nos comentários, mas elas são um pouco longas demais!

Queijo Cheddar, 31 27 bytes

->97@"123+65@"91+48@"58+"_"

Isso mostra @"bem o operador

Não concluído porque finalmente consegui resolver o problema do @"operador. O problema era que ele estava gerando um intervalo Cheddar e não um JS, por isso não funcionava corretamente

Explicação

O @"operador foi projetado por @ CᴏɴᴏʀO'Bʀɪᴇɴ e o que faz é gerar um intervalo de cadeias de caracteres de LHS a RHS. Quando usado como um operador unário, ele retorna o caractere no ponto de código especificado (como o de python chr)

Ungolfed

->
  97 @" 123 +
  65 @" 91  +
  48 @" 58  +
  "_"

brainfuck, 58 bytes

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

Experimente online .

Inicializa a fita para 3,2 · ⁿ e funciona 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 |
                                          ^

JavaScript (ES6), 62 bytes

_=>String.fromCharCode(...Array(123).keys()).replace(/\W/g,'')

Retorna 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz, portanto, apenas 6 bytes mais curtos que uma função que retorna a string literal. Sim, é péssimo.

Haskell, 38 bytes

'_':['a'..'z']++['A'..'Z']++['0'..'9']

Nada a explicar aqui.

PowerShell v3 +, 35 33 bytes

-join([char[]](1..127)-match'\w')

Constrói uma matriz dinâmica 1..127, lança-a como uma charmatriz. Isso é fornecido ao -matchoperador que trabalha na regex \w, que retornará todos os elementos correspondentes (ou seja, exatamente alfanuméricos e sublinhados). Encapsulamos esses elementos de matriz em um -joinpara agrupá-lo como uma sequência. Isso é deixado no pipeline e a produção está implícita.

V, 27 bytes

i1122ñYpñvHgJ|éidd@"Í×

Experimente online!

Esta resposta é terrivelmente complicada. Vou postar 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.

J, 30 29 28 bytes

Guardou um byte graças a randomra!

~.u:95,;48 65 97+i."*10,,~26

Saída:

   ~.u:95,;48 65 97+i."*10,,~26
_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Explicação

Não fornecerei uma explicação propriamente dita , 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

Haskell, 31 bytes

do(x,y)<-zip"aA0_""zZ9_";[x..y]

A expressão zip "aA0_" "zZ9_"fornece a lista de terminais [('a','z'),('A','Z'),('0','9'),('_','_')]. A donotação leva cada um (x,y)para o inclusivo \(x,y)->[x..y]e concatena os resultados. Obrigado a Anders Kaseorg por dois bytes com em dovez de >>=.

Compare com 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 __"

C, 50 bytes

Ligue f()sem argumentos.

f(n){for(n=128;--n;)isalnum(n)|n==95&&putchar(n);}

Impressões

zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

/// , 63 bytes

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Python 3, 58 bytes

print('_',*filter(str.isalnum,map(chr,range(123))),sep='')

Um programa completo que imprime em STDOUT.

A saída é: _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

Experimente no Ideone

Se constantes de string fossem permitidas, o seguinte seria 45 bytes:

from string import*
print('_'+printable[:62])

Minha primeira tentativa no 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.

Pure bash, 32

printf %s {a..z} {A..Z} {0..9} _

Ideone .

Objeto Pascal, 85 83 73 bytes

Simples objeto pascal usando um conjunto de caracteres. Escrever um programa completo em vez de um procedimento reduz 2 bytes. A remoção da palavra-chave do programa reduz mais 10 bytes.

var c:char;begin for c in['a'..'z','A'..'Z','0'..'9','_']do write(c);end.

bash - 47 37 bytes

man sh|egrep -o \\w|sort -u|tr -d \\n

A saída no meu sistema é:

_0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ

Agradecemos ao Digital Trauma por sugestões úteis.

Em alguns sistemas, você pode usar em asciivez de man shsalvar um byte.

PHP, 40 bytes

_0<?for(;$a++^9?$a^q:$a=A;)echo" $a"|$a;

Demonstração Online .

Retina , 30 19 16 15 12 bytes

Modifiquei minha tentativa de alfabeto original para esta versão mais recente. Cada caractere é impresso em um loop.

A primeira linha está vazia.

;
+T\`;w`w_

Experimente online

Saída:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Agradecimentos a Leaky Nun por jogar 4 bytes na minha última tentativa.

MATL , 11 bytes

7W:'\W'[]YX

Experimente online!

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

Braquilog , 25 bytes

"_"w9yrcw"A":"Z"ycL@l:Lcw

Isso imprime o seguinte para 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

Pitão, 13 12 bytes

s:#"\w"0rk\|

Experimente online!

Localiza todos os caracteres em U + 0000 a U + 007B que correspondem ao regex /\w/.

Saídas 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.

abordagem alternativa: 15 bytes

ssrMc4"0:A[a{_`

Experimente online!

basicamente gera os intervalos de meia incluído necessários: 0-:, A-[, a-{, _-`.

CJam , 15 14 11 bytes

4 bytes de desconto, graças a @FryAmTheEggman e @Dennis!

A,'[,_el^'_

Experimente online!

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

Brainfuck, 89 bytes

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

Experimente aqui

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, posso postar o meu. Quando comecei a escrever este, o menor BF tinha 96 anos.

F #, 50 59 bytes

Seq.iter(printf"%c"<<char)(95::[48..57]@[65..90]@[97..122])

Saída:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Editar: perdeu os dígitos pela primeira vez

Edit2, inspirado nesta solução Haskell, este trecho de F # é de 67 bytes.

Seq.zip"aA0_""zZ9_"|>Seq.iter(fun(x,y)->Seq.iter(printf"%c")[x..y])

Saída:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Hexagonia, 33

"A}_8_47<='>({a/_x.@.9!\356);');

Expandido:

    " A }
  _ 8 _ 4 7
 < = ' > ( {
a / _ x . @ .
 9 ! \ 3 5 6
  ) ; ' ) ;
   . . . .

Saída:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_

Experimente online!

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 Hexagon expandido pareça meio fora de controle. Muito obrigado a Martin por me mostrar esse truque, bem como por sugerir o algoritmo para imprimir o alfabeto!

Isso imprime o alfabeto armazenando ae Anas duas bordas de um hexágono e o número 26 na borda do hexágono que toca a junta entre as letras. Isso é algo como isto:

A \ / a
   |
   26

Em seguida, ele insere um loop que imprime as letras e as incrementa e, em seguida, diminui o número. Após 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 isto é: x 3 5 6 8 4 7 9 ! ; { @. Isso substitui o valor da borda da memória atual pelo número 1203568479 (observe que xo código ASCII é 120), que contém todos os dígitos decimais. Imprimimos esse número e, em seguida, usamos um recurso interessante do Hexagony: imprimimos o número mod 256 como um caractere ASCII. Acontece que isso é 95, ou sublinhado.

Brainfuck, 114 103 98 90 76 71 bytes

Outro trivial solução (agora não trivial), mas desta vez é BF!

Economizou 14 (!) Bytes graças a @primo.

Economizei mais 4 bytes graças à sugestão de @ primo de 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 quebra de 8 bits e memória de quebra. Eu usei Experimente online .

Todos imprimem _AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789

Primeiro, esta parte

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

inicializa a fita com esses valores

[91, 70, 49, 21, 7]
                 ^

Isso funciona porque a relação de recorrência que modelei é basicamente f(x) = 7 * (3 * x + 1)inversa. Veja Olá, mundo! Responda a uma explicação sobre o que é uma relação de recorrência.

Então, é bastante simples alterar esses valores para valores úteis. (e imprima o sublinhado)

Code: +++<--<-<-----<++++.+

Tape: [96, 65, 48, 26, 10]
       ^

Em seguida, os loops simples usam os valores para imprimir o restante dos caracteres. Economizo 1 byte por ter 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 beijinhos.

Usei uma calculadora de regressão linear para descobrir qual deveria ser a menor relação de recorrência linear possível, então provavelmente encontro outra fórmula se quiser melhorar.

O @primo realmente melhorou muito a relação de recorrência, obrigado.

Sesos , 17 bytes

00000000: a854be 2cbc9e 71d597 14bc56 1ad99e 713b           .T.,..q....V...q;

Saída

0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_

Experimente online! Marque 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.

Pyke, 13 bytes

150m.C#P)\_+s

Experimente aqui!

Gera ascii 0-150 e filtra por alfanuméricos e adiciona _ao final