Escriba un programa o función que imprima o devuelva una cadena de caracteres alfanuméricos más guiones bajos, en cualquier orden . Para ser precisos, deben emitirse los siguientes caracteres, y no más :

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Al imprimir en stdout, se permite una nueva línea final opcional después de su salida.

Las constantes incorporadas que contienen 9 o más de los caracteres anteriores no están permitidas.

El código más corto en bytes gana.

_{Este es un desafío muy simple, que creo generará algunas respuestas interesantes, sin embargo.}

Tablas de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

¡Nuevo método! Además, me di cuenta de que es exactamente lo mismo que la respuesta de Luis, pero en Convex, pero se me ocurrió esto de forma independiente.

'{,®\W"Oò

Pruébalo en línea!

Explicación:

'{,           Array of chars from NUL to 'z
   ®\W"       Regex to match non-word characters
       Oò     Replace all matches with emtpy string

Solución anterior, 10 bytes:

A,'[,_¬^'_

Pruébalo en línea!

Explicación:

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

Rubí, 26 bytes

Los caracteres se pueden imprimir en cualquier orden? ¡No me importa si lo hago!

Pruébalo en línea!

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

Perl, 20 bytes

Requiere -Esin costo adicional.

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

Entonces, mi respuesta original (abajo) fue un poco aburrida. Lo único que he logrado hacer es lo anterior, eso es exactamente lo mismo, pero parece un poco más confuso ... Es casi exactamente equivalente a lo siguiente:

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

Me gustan las sugerencias de @ msh210 en los comentarios, ¡pero son demasiado largas!

Cheddar, 31 27 bytes

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

Esto muestra bien al @"operador

No se completó porque finalmente pude arreglar el @"operador. El error fue que estaba generando un rango Cheddar, no un rango JS, por lo que no podía funcionar correctamente

Explicación

El @"operador fue diseñado por @ CᴏɴᴏʀO'Bʀɪᴇɴ, y lo que hace es generar un rango de cadenas de LHS a RHS. Cuando se usa como operador unario, devuelve el carácter en el punto de código dado (como el de Python chr)

Sin golf

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

brainfuck, 58 bytes

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

Pruébalo en línea .

Inicializa la cinta a 3 · 2 ⁿ , y trabaja desde allí.

+++[[<+>->++<]>]    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,'')

Devuelve 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz, por lo que solo 6 bytes más cortos que una función que devuelve el literal de cadena. Sí, apesta.

Haskell, 38 bytes

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

Nada que explicar aquí.

PowerShell v3 +, 35 33 bytes

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

Construye una matriz dinámica 1..127, la convierte como una charmatriz. Eso se alimenta al -matchoperador que trabaja en la expresión regular \w, que devolverá todos los elementos que coincidan (es decir, exactamente alfanuméricos y subrayados). Encapsulamos esos elementos de matriz en a -joinpara agruparlos como una cadena. Eso queda en la tubería y la salida es implícita.

V, 27 bytes

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

Pruébalo en línea!

Esta respuesta es horriblemente complicada. Publicaré una explicación más 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@"...

Explicación:

Legible:

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

¡Guardado un byte gracias a randomra!

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

Salida:

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

Explicación

No proporcionaré una explicación per se , pero proporcionaré resultados intermedios.

   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]

La expresión zip "aA0_" "zZ9_"da la lista de puntos finales [('a','z'),('A','Z'),('0','9'),('_','_')]. La donotación lleva a cada uno (x,y)a lo inclusivo \(x,y)->[x..y]y concatena los resultados. Gracias a Anders Kaseorg por dos bytes en dolugar de >>=.

Compare con las 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

Llama f()sin ningún argumento.

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

Huellas dactilares

zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

/// , 63 bytes

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Python 3, 58 bytes

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

Un programa completo que imprime en STDOUT.

El resultado es: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Cómo 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

Pruébalo en Ideone

Si se permitieran las constantes de cadena, lo siguiente habría sido de 45 bytes:

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

Mi primer intento 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+"":"");}

Muchas gracias a aloisdg, AstroDan, Leaky Nun y Kevin Lau, no a Kenny por toda la ayuda en los comentarios.

Puro golpe, 32

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

Ideone .

Objeto Pascal, 85 83 73 bytes

Simplemente objeto pascal usando un conjunto de caracteres. Escribir un programa completo en lugar de un procedimiento ahorra 2 bytes. La eliminación de la palabra clave del programa afeita 10 bytes más.

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

La salida en mi sistema es:

_0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ

Gracias a Digital Trauma por sus útiles sugerencias.

En algunos sistemas, puede usar en asciilugar de man shguardar un byte.

PHP, 40 bytes

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

Demo en línea .

Retina , 30 19 16 15 12 bytes

Modifiqué mi intento de alfabeto original para esta última versión. Cada personaje se imprime en un bucle.

La primera línea está vacía.

;
+T\`;w`w_

Pruébalo en línea

Salida:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Gracias a Leaky Nun por jugar 4 bytes en mi último intento.

MATL , 11 bytes

7W:'\W'[]YX

Pruébalo en línea!

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

Brachylog , 25 bytes

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

Esto imprime lo siguiente para STDOUT:

_9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

Explicación

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

Pyth, 13 12 bytes

s:#"\w"0rk\|

Pruébalo en línea!

Encuentra todos los caracteres en U + 0000 a U + 007B que coinciden con la expresión regular /\w/.

Salidas 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.

enfoque alternativo: 15 bytes

ssrMc4"0:A[a{_`

Pruébalo en línea!

básicamente genera los rangos medio incluido requeridos: 0-:, A-[, a-{, _-`.

CJam , 15 14 11 bytes

¡4 bytes de descuento gracias a @FryAmTheEggman y @Dennis!

A,'[,_el^'_

Pruébalo en línea!

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

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

Pruébalo aquí

Detalles:

+++++++++[>+++++>+<<-]>+++.  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

Si hubiera podido comentar, tendría que mejorar las respuestas de otros. Pero como no puedo, podría publicar el mío. Cuando comencé a escribir esto, el BF más bajo tenía 96 de largo.

F#, 50 59 bytes

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

Salida:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Editar: perdió los dígitos la primera vez

Edit2, inspirado en esta solución de Haskell este fragmento de F # tiene 67 bytes.

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

Salida:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Hexagonía, 33

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

Expandido:

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

Salida:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_

Pruébalo en línea!

Tenga en cuenta que hay un carácter no imprimible 0x1A como primer byte del programa. Esto también hace que la primera fila del Hexágono expandido se vea un poco apagada. ¡Muchas gracias a Martin por mostrarme este truco, así como por sugerir el algoritmo para imprimir el alfabeto!

Esto imprime el alfabeto almacenando ay Aen dos bordes de un hexágono y el número 26 en el borde del hexágono que toca la unión entre las letras. Esto se parece a esto:

A \ / a
   |
   26

Luego ingresa un bucle que imprime las letras y luego las incrementa, y luego disminuye el número. Después de una iteración tendríamos:

B \ / b
   |
   25

Y así. El código lineal para la inicialización es: 0x1A " A } a. El código lineal para los bucles fuera de los cambios de flujo de control es:; ) ' ; ) { ( ' = .

Una vez que el contador llega a cero, seguimos un camino diferente para imprimir los números y un guión bajo. Escrito a cabo linealmente esto es: x 3 5 6 8 4 7 9 ! ; { @. Esto reemplaza el valor actual del borde de la memoria con el número 1203568479 (tenga en cuenta que xel código ASCII es 120), que contiene todos los dígitos decimales. Imprimimos este número y luego usamos una característica ordenada de Hexagony: imprimimos el número mod 256 como un carácter ASCII. Esto pasa a ser 95, o subrayado.

Brainfuck, 114 103 98 90 76 71 bytes

Otro trivial solución (ahora no trivial), ¡pero esta vez es BF!

Ahorró 14 (!) Bytes gracias a @primo.

Ahorré 4 bytes más gracias a la sugerencia de @ primo de generar el rango hacia atrás, y guardé otro incrementando antes de imprimir las letras minúsculas.

Nuevo (recurrencia 4, 71):

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

Antiguo (valores, 114):

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

Antiguo (recurrencia 1, 103):

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

Antiguo (recurrencia 2, 90):

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

Viejo (recurrencia 3, 76):

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

Asume celdas de envoltura de 8 bits y memoria de envoltura. Solía probarlo en línea .

Todos imprimir _AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789

Primero, esta parte

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

inicializa la cinta con estos valores

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

Esto funciona porque la relación de recurrencia que modelé básicamente es f(x) = 7 * (3 * x + 1)hacia atrás. Ver @ primo Hello, World! Responda para una explicación de qué es una relación de recurrencia.

Entonces, es bastante simple cambiar estos valores a valores útiles. (e imprime el guión bajo)

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

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

Luego, los bucles simples usan los valores para imprimir el resto de caracteres. Ahorro 1 byte al tener un incremento antes de la impresión.

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

Realmente necesito encontrar una generación de secuencia más corta.

Encontré una relación de recurrencia que parece funcionar bien, pero podría haber una relación más corta con menos caza y picoteo.

Utilicé una calculadora de regresión lineal para encontrar cuál debería ser la relación de recurrencia lineal más corta posible, por lo que probablemente debería encontrar alguna otra fórmula si quiero mejorar.

@primo realmente mejoró mucho la relación de recurrencia, gracias.

Sesos , 17 bytes

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

Salida

0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_

Pruébalo en línea! Verifique la depuración para ver el código binario generado.

Cómo funciona

El archivo binario anterior se ha generado al ensamblar el siguiente 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

Pruébalo aquí!

Genera ascii 0-150 y filtra por alfanumérico y agrega _al final