Роздрукуйте всі буквено-цифрові символи плюс підкреслення


37

Напишіть програму або функцію, яка друкує або повертає рядок буквено-цифрових символів плюс підкреслення в будь-якому порядку . Якщо бути точним, потрібно вивести наступні символи, і не більше :

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

При друкуванні до stdout дозволено додаткове обривання нового рядка після виводу.

Вбудовані константи, що містять 9 або більше вищевказаних символів, заборонені.


Виграє найкоротший код у байтах.

Це дуже простий виклик, який, на мою думку, все ж дасть кілька цікавих відповідей.


Табло лідерів

Ось фрагмент стека для створення як звичайного табло, так і огляду переможців за мовою.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

# Language Name, N bytes

де Nрозмір вашого подання. Якщо ви покращите свій рахунок, ви можете зберегти старі бали у заголовку, прокресливши їх. Наприклад:

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

Якщо ви хочете включити у свій заголовок декілька чисел (наприклад, тому що ваш результат становить суму двох файлів або ви хочете окремо вказати штрафні санкції для перекладача), переконайтесь, що фактичний результат - це останнє число у заголовку:

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

Ви також можете зробити ім'я мови посиланням, яке потім з’явиться у фрагменті таблиць лідерів:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes


2
Коментарі не для розширеного обговорення; ця розмова переміщена до чату .
Денніс

Відповіді:


11

Опукла, 9 байт

Новий метод! Крім того, я зрозумів, що це майже точно так само, як відповідь Луїса, але у Convex, але я придумав це самостійно.

'{,®\W"Oò

Спробуйте в Інтернеті!

Пояснення:

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

Старий розчин, 10 байт:

A,'[,_¬^'_

Спробуйте в Інтернеті!

Пояснення:

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

1
@ mbomb007 Так, це еквівалентно коду A,'[,_el^'_
CJam

Яке кодування це?
Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ CP-1252 або Windows-1252
GamrCorps


12

Perl, 20 байт

Вимагає -Eбез зайвих витрат.

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

Отже, моя оригінальна відповідь (нижче) була трохи надто нудною. Єдине, що мені вдалося придумати, це вище, це саме те саме, але виглядає дещо заплутаніше ... Це майже рівнозначно нижче:

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

Мені подобаються пропозиції @ msh210 в коментарях, але вони просто занадто довгі!


1
+1. Трохи цікавішим, але довшим є будь-який із них, всі 27 байт: say grep/\w/,map chr,1..122|| say map{chr=~/\w/;$&}1..122|| say map{chr=~s/\W//r}1..122
msh210

1
@ msh210 Досі не можу зменшити це більше ... Керував 25, хоча: say chr=~/\w/g for 1..255...
Дом Гастінгс

10

Чеддар, 31 27 байт

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

Це добре демонструє @"оператора

Не завершуючи, тому що я нарешті дійшов до фіксації @"оператора. Помилка в тому, що він генерував діапазон Cheddar, а не діапазон JS, тому він не міг нормально працювати


Пояснення

@"Оператор був розроблений @ CᴏɴᴏʀO'Bʀɪᴇɴ, і що вона робить це генерувати діапазон рядків з LHS в РІТ. Використовуючи його як одинарний оператор, він повертає char в заданій кодовій точці (наприклад, python's chr)

Безумовно

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

10

мозковий ебать, 58 байт

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

Спробуйте в Інтернеті .

Ініціалізує стрічку до 3 · 2 п , і працює звідти.

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

9

JavaScript (ES6), 62 байти

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

Повертає 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz, тож лише на 6 байт коротше функції, яка повертає рядковий літерал. Так, це смокче.


Ви можете спробувати знайти рядок, для якого btoaповертається необхідний вихід.
gcampbell

@gcampbell 60! (60 факторних) рядків може знадобитися деякий час для пошуку ...
Ніл

Ви могли просто використовувати atob.
gcampbell

@gcampbell Я мушу якось виключати нерепрезентативні рядки.
Ніл

@gcampbell Виявляється, версія btoa все одно займає 62 байти: 45 для кодування 60 буквено-цифрових знаків, 3 незашифрованих символів (у тому числі _) та 14 для _=>atob("")+"".
Ніл

9

Haskell, 38 байт

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

Тут нічого пояснювати.


2
питання: в чому різниця між :і ++?
Пуховик

3
@Downgoat: ++бере два рядки і з'єднує їх. :бере значок і рядок і ставить знак перед струною. "_"++['a'..'z']...також працює, але на один байт довше.
Nimi

8

PowerShell v3 +, 35 33 байт

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

Конструює динамічний масив 1..127, видає його як charмасив. Це передається -matchоператору, який працює над регулярним виразом \w, який поверне всі відповідні елементи (тобто, саме буквено-цифрові та підкреслення). Ми інкапсулюємо ці елементи масиву в a-join щоб зв'язати його як одну рядок. Це залишилося на конвеєрі, і вихід неявний.


1
Гей, це не справедливо. Моє власне рішення є ідентичним, за винятком того, що я почав у 0
Joey

@Joey Треба йти швидко. : D
AdmBorkBork

Думаю, особливо для банальних і очевидних рішень ;-)
Joey

7

V, 27 байт

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

Спробуйте в Інтернеті!

Ця відповідь жахливо перекручена. Пояснення я опублікую пізніше.

Hexdump:

00000000: 6916 1631 1b31 3232 f159 7001 f176 4867  i..1.122.Yp..vHg
00000010: 4a7c e969 6464 4022 1bcd d7              J|.idd@"...

Пояснення:

Читає:

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.

5
:D :D :D Cheddar is tied with a golfing lang!
Downgoat

7

J, 30 29 28 bytes

Saved a byte thanks to randomra!

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

Output:

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

Explanation

I wont provide an explanation per se, but will provide intermediate results.

   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

6

Haskell, 31 bytes

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

The expression zip "aA0_" "zZ9_" gives the list of endpoints [('a','z'),('A','Z'),('0','9'),('_','_')]. The do notation takes each (x,y) to the inclusive \(x,y)->[x..y] and concatenates the results. Thanks to Anders Kaseorg for two bytes with do instead of >>=.

Compare to alternatives:

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

2
do notation saves two bytes: do(x,y)<-zip"aA0_""zZ9_";[x..y]
Anders Kaseorg

4

C, 50 bytes

Call f() without any arguments.

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

Prints

zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

1
isalnum(n)|n==95&&putchar(n)
orlp

There's UB there. You didn't pass the required arguments.
Ven

@orlp - You used putc instead of putchar. putc expects a stream to write to as well, which you didn't pass. The function itself works fine (try removing your putc altogether, and it works).
owacoder

@owacoder Oops!
orlp

1
@QPaysTaxes that's wrong. If the number of arguments does not equal the number of parameters, the behavior is undefined. 6.5.2.2/6, see N1570.
Ven

4

///, 63 bytes

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

How is it the valid answer? Looks like it's violating the rules.
nicael

@nicael which rule?
Leaky Nun

"Built-in constants that contain 9 or more of the above characters are disallowed."... Am I missing something obvious, @Leaky?
nicael

4
Yes, that this didn't use any built-in constants.
Leaky Nun

Ok, but this is weird at least. Definitely OP doesn't ask you to copy-paste the sequence, that's not interesting.
nicael

4

Python 3, 58 bytes

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

A full program that prints to STDOUT.

The output is: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

How it works

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

Try it on Ideone

If string constants were allowed, the following would have been 45 bytes:

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

1
print('_'+*filter(str.isalnum,map(chr,range(123))))
Leaky Nun

@LeakyNun That throws a syntax error. I thought about doing something similar with print('_',*filter(str.isalnum,map(chr,range(123)))), but that prints separating spaces; the OP said in the comments that '...no spaces are permitted in the output at all'.
TheBikingViking

Python 2 can save one byte with this approach: print''.join(filter(str.isalnum,map(chr,range(123)))),'_'
atlasologist

4

My first attempt at 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+"":"");}

Thanks a lot to aloisdg, AstroDan, Leaky Nun and Kevin Lau - not Kenny for all the help in comments.


2
Welcome to PPCG! Feel free to remove all the space! Also check Tips for golfing in C# for some tips.
aloisdg says Reinstate Monica

1
Great - saved me 2 bytes more. I'm really starting to like this codegolf :)
Daniel

1
AFAIK, the \w regex class covers the alphanumerics and also _, which should make "\\w" valid enough for your regex match function.
Value Ink

1
Your code should a be function or a full program not a statement. Also use .NetFiddle to share a demonstration of your code :)
aloisdg says Reinstate Monica

2
"C# isn't the best to codegolf" I find C# fun enough to code golf. I think it is a great mainstream language to play with. If you are here to win, you will loose. Define your objective as learning and having a good time and you will win all the times.
aloisdg says Reinstate Monica


4

Object Pascal, 85 83 73 bytes

Just plain object pascal using a set of chars. Writing a full program instead of a procedure shaves off 2 bytes. Removing the program keyword shaves 10 more bytes.

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

I always was and probably will always be confused by the exact classification of Object Pascal. Turbo/Borland Pascal and FreePascal are certainly happy without the useless program keyword.
manatwork

@manatwork I didn't know that. Oddly enough it now makes pascal competitive here...
hdrz

The language I grew up with. I know that it is not yet dead...
rexkogitans

@rexkogitans Yeah I learned it at school, but can't remember anything from back then... I'm playing with some programming again now
hdrz

4

bash – 47 37 bytes

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

Output on my system is:

_0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ

Thanks to Digital Trauma for helpful suggestions.

On some systems you might be able to use ascii instead of man sh to save a byte.


1
man sh|egrep -io _\|\\w|sort -u|tr -d \\n
Digital Trauma

1
@DigitalTrauma Thank you! Experimented and found out \w matches _ and is already case insensitive, so could shorten even more.

env instead of man sh should work on most environments. It does on mine. $ env|egrep -o \\w|sort -u|tr -d \\n -> 0123456789ABCDEFGHIKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.
YSC

There's no J. My bad.
YSC

4

PHP, 40 bytes

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

Online Demo.


1
+1 for excellence. Side note: PHP 7.2 yields warnings mentioning that future versions will throw errors for undefined constants. :-(
Titus

4

Retina, 30 19 16 15 12 bytes

I modified my original alphabet attempt for this latest version. Each character is printed in a loop.

The first line is empty.


;
+T\`;w`w_

Try it online

Output:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Thanks to Leaky Nun for golfing 4 bytes off my latest attempt.


I'd say that w counts as a constant containing 9 or more of the required characters. You'll probably have to expand the right hand side and replace the w on the left with o. Although you can save a byte by using EO instead of d since they only contain 5 characters each.
Martin Ender

@mbomb007 w inside the transliteration stage has nothing to do regex. It's a shorthand that expands to a list of the required 63 characters. At least I'd ask orlp about this case specifically, since it's quite different from using \w in a regex.
Martin Ender

3

MATL, 11 bytes

7W:'\W'[]YX

Try it 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

2 bytes shorter: 8W:'\w'XX
DJMcMayhem

2
@DrGreenEggsandIronMan Thanks! But I think newlines are not allowed as separators. The challenge says " a string of the alphanumeric characters plus underscore... and no more"
Luis Mendo

1
So why couldn't you do 8W:'\w'XX! which I tried but doesn't work
DJMcMayhem

@DrGreenEggsandIronMan Very good question! Let me answer you in chat so I can use a little more characters
Luis Mendo

3

Brachylog, 25 bytes

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

This prints the following to STDOUT:

_9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

Explanation

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

3

Pyth, 13 12 bytes

s:#"\w"0rk\|

Try it online!

Finds all characters in U+0000 to U+007B that matches the regex /\w/.

Outputs 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.

alternative approach: 15 bytes

ssrMc4"0:A[a{_`

Try it online!

basically generates the half-inclusive ranges required: 0-:, A-[, a-{, _-`.


3

CJam, 15 14 11 bytes

4 bytes off thanks to @FryAmTheEggman and @Dennis!

A,'[,_el^'_

Try it 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

3

Brainfuck, 89 bytes

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

Try it here

Details:

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

If I could have commented, I would have to improve others answers. But since I can't, I might as well post my own. As I started writing this the lowest BF one was 96 long.


3

F#, 50 59 bytes

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

Output:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Edit: missed the digits the first time

Edit2, inspired by this Haskell solution this F# snippet is 67 bytes.

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

Output:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

3

Hexagony, 33

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

Expanded:

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

Output:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_

Try it online!

Note that there is an unprintable character 0x1A as the first byte of the program. This also makes the first row of the expanded Hexagon look sort of off. Many thanks to Martin for showing me this trick, as well as for suggesting the algorithm for printing the alphabet!

This prints the alphabet by storing a and A on two edges of a hexagon and the number 26 on the edge of the hexagon that touches the joint between the letters. This looks something like this:

A \ / a
   |
   26

Then it enters a loops that prints the letters and then increments them, and then decrements the number. After one iteration we would have:

B \ / b
   |
   25

And so on. The linear code for the initialisation is: 0x1A " A } a. The linear code for the loops outside of control flow changes is: ; ) ' ; ) { ( ' =.

Once the counter reaches zero, we follow a different path to print the numbers and an underscore. Written out linearly this is: x 3 5 6 8 4 7 9 ! ; { @. This replaces the current memory edge's value with the number 1203568479 (note that x's ASCII code is 120), which contains all of the decimal digits. We print out this number and then we use a neat feature of Hexagony: we print out the number mod 256 as an ASCII character. This just happens to be 95, or underscore.


3

Brainfuck, 114 103 98 90 76 71 bytes

Another trivial (now non-trivial) solution, but this time is BF!

Saved 14 (!) bytes thanks to @primo.

Saved 4 more bytes thanks to @primo's suggestion to generate the range backwards, and I saved another by incrementing before printing for the lowercase letters.

New (recurrence 4, 71):

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

Old (values, 114):

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

Old (recurrence 1, 103):

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

Old (recurrence 2, 90):

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

Old (recurrence 3, 76):

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

Assumes 8 bit wrapping cells and wrapping memory. I used Try it online.

All print out _AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789

First, this part

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

initializes the tape with these values

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

This works because the recurrence relation I modeled basically is f(x) = 7 * (3 * x + 1), backwards. See @primo's Hello, World! Answer for an explanation of what a recurrence relation is.

Then, it's fairly simple to change these values to useful ones. (and print the underscore)

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

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

Then, the simple loops use the values to print the rest of characters. I save 1 byte by having an increment before the print.

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

I really need to find a shorter sequence generation.

I found a recurrence relation that seems to work well, but there might be a shorter one w/ less hunt and peck.

I used a linear regression calculator to find what should be the shortest possible linear recurrence relation, so I should probably find some other formula if I want to improve.

@primo really improved the recurrence relation a lot, thanks.


How about a backwards construction? +[--[<+++++++>->+<]>-]
primo

@primo Wow! How does that work?
Blue

3 is uneven so it will loop a full 256 times. By ending with >-], you can be sure that the final term will be 1 (x7). Actually, you should probably start with -, it finishes a lot faster.
primo

3

Sesos, 17 bytes

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

Output

0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_

Try it online! Check Debug to see the generated binary code.

How it works

The binary file above has been generated by assembling the following SASM code.

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.

Wow, I was about to post a solution very similar to yours.
Leaky Nun

Alike minds think great!
Dennis

@LeakyNun Hm, kinda late, but it looks like yours is 3 bytes shorter...
Erik the Outgolfer

@EriktheOutgolfer Sesos used to be encoded in a less efficient manner. Both programs are 17 bytes long now.
Dennis

@Dennis Ah, well, the TIO cache can be confusing at times.
Erik the Outgolfer

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.