Escribe un programa o función que imprima o devuelva una cadena de caracteres alfanuméricos más un guión bajo, en cualquier orden . Para ser precisos, se deben generar los siguientes caracteres, y no más :

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

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

Constantes integradas que contienen 9 o más de los caracteres anteriores no están permitidos.

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

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

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 aparezca, comience su respuesta con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

donde N es el tamaño de su envío. Si mejora su puntaje, puede mantener puntajes antiguos en el titular, 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 si desea incluir un intérprete marcar las penalizaciones por separado), asegúrese de que la puntuación real sea el último número del encabezado:

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

También puede hacer que nombre del idioma 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> <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>

Comentarios

Los comentarios no son para una discusión extensa; esta conversación ha sido movida al chat .

Responder

Convexo, 9 bytes

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

"{,®\W"Oò

Pruébelo 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ébelo en línea

Explicación:

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

Comentarios

@ mbomb007 Sí, es equivalente al código CJam A,'[,_el^'_
¿Qué codificación es esta?
@ CᴏɴᴏʀO ' Bʀɪᴇɴ CP-1252 o Windows-1252

Respuesta

Ruby, 26 bytes

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

¡Pruébalo en línea!

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

Respuesta

Perl, 20 bytes

Requiere -E sin costo adicional .

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

Entonces, mi respuesta original (a continuación) era un poco aburrida . Lo único que se me ha ocurrido es lo anterior, que 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 gusta @ msh210 «s sugerencias en los comentarios, ¡pero son demasiado largas!

Comentarios

+1. Un poco más interesante pero más largo es cualquiera de estos , los 27 bytes: say grep/\w/,map chr,1..122 || say map{chr=~/\w/;$&}1..122 || say map{chr=~s/\W//r}1..122
@ msh210 Todavía puedo ' reducir esto más … Sin embargo, administré un 25: say chr=~/\w/g for 1..255 …

Respuesta

Cheddar, 31 27 bytes

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

Esto muestra el @" operador bien

No completado porque finalmente logré arreglar el @" operador. El error era que estaba generando un rango Cheddar, no un rango JS, por lo que no podía funcionar correctamente

Explicación

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

Ungolfed

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

Respuesta

brainfuck, 58 bytes

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

Pruébelo en línea .

Inicializa el cinta a 3 · 2 ⁿ , y funciona 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 | ^

Respuesta

JavaScript (ES6), 62 bytes

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

Devuelve 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz, por lo que solo 6 bytes menos que una función que devuelve la cadena literal. Sí, apesta.

Comentarios

Puede intentar encontrar una cadena para la cual btoa devuelve la salida requerida.
@gcampbell 60! (60 factorial) las cadenas pueden tardar algún tiempo en buscar …
Podrías usar atob.
@gcampbell Tengo que excluir cadenas no representables de alguna manera.
@gcampbell Resulta que la versión btoa toma 62 bytes de todos modos: 45 para codificar 60 caracteres alfanuméricos, 3 caracteres no codificados (incluido _) y 14 para _=>atob("")+"".

Responder

Haskell, 38 bytes

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

No hay nada que explicar aquí.

Comentarios

pregunta: ¿Cuál ' es la diferencia entre : y ++?
@Downgoat: ++ toma dos cadenas y las concatena. : toma un carácter y una cadena y coloca el carácter delante de la cadena. "_"++['a'..'z']... también funciona, pero es un byte más largo.

Respuesta

PowerShell v3 +, 35 33 bytes

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

Construye una matriz dinámica 1..127 , lo convierte en una matriz char. Eso «se alimenta al operador -match 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 la matriz en un -join para agruparlos como una sola cadena. Eso se deja en la tubería y la salida es implícita.

Comentarios

Oye, eso ' no es justo. Mi propia solución es idéntica excepto que comencé en 0 …
@Joey Tengo que ir rápido. : D
Especialmente para las soluciones triviales y obvias, supongo 😉

Responder

V, 27 bytes

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

Pruébelo 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.

Comentarios

: D: D: D ¡Cheddar está empatado con un idioma de golf!

Respuesta

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

Respuesta

Haskell, 31 bytes

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

La expresión zip "aA0_" "zZ9_" da la lista de extremos [("a","z"),("A","Z"),("0","9"),("_","_")]. La do la notación lleva cada (x,y) al \(x,y)->[x..y] inclusivo y concatena el resultado s. Gracias a Anders Kaseorg por dos bytes con do en lugar de >>=.

Comparar con 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 __"

Comentarios

do la notación guarda dos bytes: do(x,y)<-zip"aA0_""zZ9_";[x..y]

Respuesta

C, 50 bytes

Llame a f() sin ningún argumento.

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

Impresiones

zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Comentarios

isalnum(n)|n==95&&putchar(n)
Hay ' s UB ahí. No ' t pasó los argumentos requeridos.
@orlp – Usó putc en lugar de putchar. putc también espera una transmisión en la que escribir, que no ' t pasó.La función en sí funciona bien (intente eliminar su putc por completo, y funciona).
@owacoder ¡Ups!
@QPaysTaxes that ' s incorrecto. If the number of arguments does not equal the number of parameters, the behavior is undefined. 6.5.2.2/6, consulte N1570 .

Respuesta

/// , 63 bytes

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Comentarios

¿Cómo es la respuesta válida? Parece que ' está violando las reglas.
@nicael, ¿qué regla?
" No se permiten las constantes integradas que contienen 9 o más de los caracteres anteriores. " … ¿Me estoy perdiendo algo obvio, @Leaky?
Sí, que esto no ' t usó ninguna constante incorporada.
Ok, pero esto es extraño al menos. Definitivamente OP no ' no le pide que copie y pegue la secuencia, que ' no es interesante.

Respuesta

Python 3, 58 bytes

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

Un programa completo que se imprime en STDOUT.

La salida 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ébelo en Ideone

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

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

Comentarios

print('_'+*filter(str.isalnum,map(chr,range(123))))
@LeakyNun Eso arroja un error de sintaxis. Pensé en hacer algo similar con print('_',*filter(str.isalnum,map(chr,range(123)))), pero imprime espacios de separación; el OP dijo en los comentarios que ' … no se permiten espacios en la salida en absoluto '.
Python 2 puede guardar un byte con este enfoque: print''.join(filter(str.isalnum,map(chr,range(123)))),'_'

Respuesta

¡Mi primer intento en 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.

Comentarios

¡Bienvenido a PPCG! ¡Siéntete libre de eliminar todo el espacio! Consulte también Consejos para jugar al golf en C # para ver algunos consejos.
Genial, me ahorró 2 bytes más. ' realmente me está empezando a gustar este codegolf 🙂
AFAIK, la \w clase regex cubre los caracteres alfanuméricos y también _, que debe hacer que "\\w" sea lo suficientemente válido para su función de coincidencia de expresiones regulares.
Su código debe ser una función o un programa completo, no una declaración. También use .NetFiddle para compartir una demostración de su código 🙂
" C # isn ' t es el mejor para codegolf " Encuentro C # lo suficientemente divertido como para codificar golf. Creo que es un gran idioma convencional para jugar. Si estás aquí para ganar, perderás. Define tu objetivo como aprender y pasar un buen rato y ganarás todos los tiempos.

Responder

Pure bash, 32

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

Ideone .

Respuesta

Objeto Pascal, 85 83 73 bytes

Simplemente pascal de objeto simple usando un conjunto de caracteres. Escribir un programa completo en lugar de un procedimiento reduce 2 bytes. Eliminar la palabra clave del programa reduce 10 bytes más.

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

Comentarios

Siempre lo fui y probablemente lo haré Confundirse siempre con la clasificación exacta de Object Pascal. Turbo / Borland Pascal y FreePascal están ciertamente felices sin la palabra clave program inútil.
@manatwork No ' t saber que. Por extraño que parezca, ahora pascal es competitivo aquí …
El idioma con el que crecí. Sé que aún no está muerto …
@rexkogitans Sí, lo aprendí en la escuela, pero no puedo ' recordar nada de ese entonces … ' estoy jugando con algo de programación de nuevo

Responder

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, es posible que pueda usar ascii en lugar de man sh para guardar un byte.

Comentarios

man sh|egrep -io _\|\\w|sort -u|tr -d \\n
@DigitalTrauma ¡Gracias!Experimenté y descubrí que \w coincide con _ y ya no distingue entre mayúsculas y minúsculas, por lo que podría acortar aún más.
env en lugar de man sh debería funcionar en la mayoría de los entornos. Lo hace en el mío. $ env|egrep -o \\w|sort -u|tr -d \\n – > 0123456789ABCDEFGHIKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.
Allí ' s no J. Mi mal.

Respuesta

PHP, 40 bytes

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

Demostración en línea .

Comentarios

+1 por excelencia. Nota al margen: PHP 7.2 produce advertencias que mencionan que las versiones futuras arrojarán errores para constantes indefinidas. 🙁

Respuesta

Retina , 30 19 16 15 12 bytes

Modifiqué mi intento de alfabeto original para esta última versión. Cada carácter está impreso en un bucle.

La primera línea está vacía.

 ; +T\`;w`w_

Pruébelo en línea

Salida:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Gracias a Leaky Nun por sacar 4 bytes de descuento en mi último intento.

Comentarios

I ' d dice que w cuenta como una constante que contiene 9 o más de los caracteres requeridos. Usted ' probablemente tenga que expandir el lado derecho y reemplazar el w del lado izquierdo con o. Aunque c y guarde un byte usando EO en lugar de d ya que solo contienen 5 caracteres cada uno.
@ mbomb007 w dentro de la etapa de transliteración no tiene nada que ver con regex. Es ' una abreviatura que se expande a una lista de los 63 caracteres requeridos. Al menos ' le pregunto a orlp sobre este caso específicamente, ya que ' es bastante diferente de usar \w en una expresión regular.

Responder

MATL , 11 bytes

7W:"\W"[]YX

¡Pruébelo 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

Comentarios

2 bytes más corto: 8W:'\w'XX
@DrGreenEggsandIronMan ¡Gracias! Pero creo que las nuevas líneas no están permitidas como separadores. El desafío dice " una cadena de caracteres alfanuméricos más un guión bajo … y no más "
Entonces, ¿por qué couldn ' t haces 8W:'\w'XX! que probé pero no ' no funciona
@DrGreenEggsandIronMan ¡Muy buena pregunta! Déjame responderte en el chat para poder usar un poco más de caracteres

Responder

Brachylog , 25 bytes

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

Esto imprime lo siguiente en 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

Respuesta

Dyalog APL , 18 bytes

∊"\w"⎕S"&"⎕UCS⍳255

imprime:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz

Comentarios

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

Respuesta

Pyth, 13 12 bytes

s:#"\w"0rk\|

Pruébelo en línea

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

O utputs 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.

enfoque alternativo: 15 bytes

ssrMc4"0:A[a{_`

¡Pruébelo en línea!

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

Respuesta

CJam , 15 14 11 bytes

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

A,"[,_el^"_

¡Pruébelo 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

Respuesta

Brainfuck, 89 bytes

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

Pruébelo 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 pudiera haber comentado, tendría que mejorar las respuestas de otros. Pero como no puedo, también podría publicar el mío. Cuando comencé a escribir esto, el BF más bajo tenía 96 de largo.

Respuesta

F #, 50 59 bytes

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

Salida:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Editar: se perdieron los dígitos la primera vez

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

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

Salida:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Respuesta

Hexagony, 33

"A}_8_47<=">({a/[email protected]!\356);");

Ampliado:

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

Resultado:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_

Pruébelo en línea

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

Esto imprime el alfabeto almacenando a y A en 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í sucesivamente. 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 una ruta diferente para imprimir los números y un guion bajo. Escrito 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 el código ASCII de x es 120), que contiene todos los dígitos decimales. Imprimimos este número y luego usamos una característica interesante de Hexagony: imprimimos el número mod 256 como un carácter ASCII. Esto resulta ser 95, o guión bajo.

Responder

Brainfuck, 114 103 98 90 76 71 bytes

Otro ~~trivial~~ (ahora no -trivial), pero esta vez es BF!

Se ahorraron 14 (!) bytes gracias a @primo.

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

Nuevo (recurrencia 4, 71):

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

Antiguo (valores, 114):

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

Antiguo (recurrencia 1, 103):

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

Antiguo (recurrencia 2, 90):

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

Antiguo (recurrencia 3, 76):

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

Supone celdas de envoltura de 8 bits y memoria de envoltura. Usé Pruébelo en línea .

Todo se imprime _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), al revés. Consulte @primo «s Hello, World! Answer para obtener una explicación de qué es una relación de recurrencia.

Entonces, es bastante simple para cambiar estos valores por otros útiles. (e imprima 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 más corta con menos caza y picoteo.~~

Usé 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.

Comentarios

¿Qué tal una construcción al revés? +[--[<+++++++>->+<]>-]
@primo ¡Vaya! ¿Cómo funciona?
3 es desigual, por lo que se repetirá un total de 256 veces. Al terminar con >-], puede estar seguro de que el término final será 1 (x7). En realidad, probablemente debería comenzar con -, termina mucho más rápido.

Responder

Sesos , 17 bytes

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

Salida

0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_

¡Pruébelo en línea! Revise Depurar para ver el código binario generado.

Cómo funciona

El archivo binario anterior ha sido generado ensamblando 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.

Comentarios

Vaya, estaba a punto de publicar una solución muy similar a la suya .
Mentes parecidas piensan bien !
@LeakyNun Hm, un poco tarde, pero parece que el tuyo es 3 bytes más corto …
@EriktheOutgolfer Los sesos solían estar codificados de una manera menos eficiente. Ambos programas tienen ahora 17 bytes de longitud.
@Dennis Ah, bueno, la caché TIO puede ser confusa a veces.