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

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

При печати на стандартный вывод разрешается дополнительный завершающий символ новой строки после вывода.

Встроенные константы, содержащие 9 или более вышеперечисленных символов, запрещены.

Самый короткий код в байтах побеждает.

_{Это очень простая задача, которая, я считаю, даст интересные ответы.}

Leaderboards

Вот фрагмент стека, который генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# 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

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>

Выпуклый, 9 байт

Новый метод! Кроме того, я понял, что это в значительной степени совпадает с ответом Луиса, но в выпуклом, но я придумал это независимо.

'{,®\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
'_          _

Рубин, 26 байт

Символы могут быть напечатаны в любом порядке? Не против, если я сделаю!

Попробуйте онлайн!

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

Perl, 20 байт

Требуется -Eбез каких-либо дополнительных затрат.

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

Итак, мой оригинальный ответ (ниже) был слишком скучным. Единственное, что мне удалось придумать, это выше, это точно так же, но выглядит немного более запутанным ... Это в значительной степени точно соответствует приведенному ниже:

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

Мне нравятся предложения @ msh210 в комментариях, но они слишком длинны!

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

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

Это @"хорошо демонстрирует оператора

Незавершенное, потому что я наконец-то понял, как починить @"оператора. Ошибка заключалась в том, что он генерировал диапазон Чеддера, а не диапазон JS, поэтому он не мог работать должным образом

объяснение

@"Оператор был разработан @ CᴏɴᴏʀO'Bʀɪᴇɴ, и что она делает это генерировать диапазон строк из LHS в РИТ. При использовании в качестве унарного оператора, он возвращает символ в заданной кодовой точке (например, Pythonchr )

Ungolfed

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

брейкфук, 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 |
                                          ^

JavaScript (ES6), 62 байта

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

Возвращает 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz, поэтому только на 6 байт короче, чем функция, которая возвращает строковый литерал. Да, это отстой.

Haskell, 38 байт

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

Здесь нечего объяснять.

PowerShell v3 +, 35 33 байта

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

Создает динамический массив 1..127, преобразует его в charмассив. Это передается -matchоператору, работающему с регулярным выражением \w, которое будет возвращать все совпадающие элементы (т. Е. Точно буквы, цифры и подчеркивание). Мы инкапсулируем эти элементы массива в a, -joinчтобы связать их в одну строку. Это осталось на конвейере и вывод неявный.

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.

J, 30 29 28 байт

Сохранил байт благодаря рандоме!

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

Выход:

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

объяснение

Я не буду давать объяснения как такового , но приведу промежуточные результаты.

   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 байт

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

Выражение zip "aA0_" "zZ9_"дает список конечных точек [('a','z'),('A','Z'),('0','9'),('_','_')]. doОбозначение принимает каждый (x,y)к включительно \(x,y)->[x..y]и сцепляет результаты. Спасибо Anders Kaseorg за два байта с doвместо >>=.

Сравните с альтернативами:

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 байтов

Звоните f()без каких-либо аргументов.

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

Печать

zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

/// , 63 байта

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Python 3, 58 байт

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

Полная программа, которая печатает на STDOUT.

Выход: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Как это работает

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

Попробуйте это на Ideone

Если бы строковые константы были разрешены, следующее было бы 45 байтов:

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

Моя первая попытка на Codegolf!

C #, 168 152 150 147 130 127 117 116 115 109 106 байт

for(var a='0';a<'~';a++){Console.Write(System.Text.RegularExpressions.Regex.IsMatch(a+"","\\w")?a+"":"");}

Большое спасибо aloisdg, AstroDan, Leaky Nun и Kevin Lau - не Кенни за помощь в комментариях.

Чистая Баш, 32

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

Ideone .

Объект Паскаль, 85 83 73 байта

Просто обычный паскаль, используя набор символов. Написание полной программы вместо процедуры сбрасывает 2 байта. Удаление ключевого слова программы сокращает еще 10 байтов.

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

Баш - 47 37 байт

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

Вывод в моей системе:

_0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ

Спасибо Digital Trauma за полезные советы.

В некоторых системах вы можете использовать asciiвместо man shсохранения байта.

PHP, 40 байт

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

Демо онлайн .

Сетчатка , 30 19 16 15 12 байт

Я изменил мою первоначальную попытку алфавита для этой последней версии. Каждый символ печатается в цикле.

Первая строка пуста.

;
+T\`;w`w_

Попробуйте онлайн

Выход:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Спасибо Leaky Nun за игру в 4 байта от моей последней попытки.

MATL , 11 байт

7W:'\W'[]YX

Попробуйте онлайн!

7W     % Push  2 raised to 7, i.e. 128
:      % Range [1 2 ... 128]
'\W'   % Push string to be used as regex pattern
[]     % Push empty array
YX     % Regex replace. Uses (and consumes) three inputs: source text, regex pattern, 
       % target text. The first input (source text) is implicitly converted to char.
       % So this replaces non-word characters by nothing.
       % Implicitly display

Брахилог , 25 байт

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

Это печатает следующее STDOUT:

_9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

объяснение

"_"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 байт

s:#"\w"0rk\|

Попробуйте онлайн!

Находит все символы от U + 0000 до U + 007B, которые соответствуют регулярному выражению /\w/.

Выходы 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.

альтернативный подход: 15 байтов

ssrMc4"0:A[a{_`

Попробуйте онлайн!

в основном генерирует половину включена диапазоны , требуемые: 0-:, A-[, a-{, _-`.

CJam , 15 14 11 байт

4 байта, благодаря @FryAmTheEggman и @Dennis!

A,'[,_el^'_

Попробуйте онлайн!

A,    e# Push range [0 1 ... 9]
'[,   e# Push range of chars from 0 to "Z" ("[" minus 1)
_el   e# Duplicate and convert to lowercase
^     e# Symmetric difference. This keeps letters only, both upper- and lower-case
'_    e# Push "_".
      e# Implicitly display stack contents, without separators

Brainfuck, 89 байт

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

Попробуй здесь

Детали:

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

Если бы я мог прокомментировать, мне пришлось бы улучшать ответы других. Но так как я не могу, я мог бы также опубликовать свой собственный. Когда я начал писать это, самый низкий BF был 96 длинным.

F #, 50 59 байт

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

Выход:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Изменить: пропустил цифры в первый раз

Edit2, вдохновленный этим решением Haskell, этот фрагмент кода F # составляет 67 байт.

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

Выход:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Гексагония, 33

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

Expanded:

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

Выход:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_

Попробуйте онлайн!

Обратите внимание, что в 0x1Aкачестве первого байта программы есть непечатаемый символ . Это также заставляет первый ряд расширенного Шестиугольника выглядеть немного не так. Большое спасибо Мартину за то, что он показал мне этот трюк, а также за предложенный алгоритм печати алфавита!

Это печатает алфавит, сохраняя aи Aна двух краях шестиугольника и число 26 на краю шестиугольника, который касается соединения между буквами. Это выглядит примерно так:

A \ / a
   |
   26

Затем он входит в цикл, который печатает буквы, а затем увеличивает их, а затем уменьшает число. После одной итерации мы получили бы:

B \ / b
   |
   25

И так далее. Линейный код инициализации: 0x1A " A } a. Линейный код петли снаружи изменения потока управления: ; ) ' ; ) { ( ' =.

Как только счетчик достигнет нуля, мы пойдем другим путем, чтобы напечатать числа и подчеркивание. Выписали линейно это: x 3 5 6 8 4 7 9 ! ; { @. Это заменяет текущее значение края памяти числом 1203568479 (обратите внимание, что xкод ASCII равен 120), которое содержит все десятичные цифры. Мы печатаем это число и затем используем аккуратную особенность Hexagony: мы печатаем число mod 256 как символ ASCII. Это просто 95, или подчеркивание.

Brainfuck, 114 103 98 90 76 71 байт

Еще один тривиальный (теперь нетривиальное) решение, но на этот раз BF!

Благодаря @primo сохранено 14 (!) Байтов.

Сохранил еще 4 байта благодаря предложению @ primo сгенерировать диапазон в обратном порядке, а я сохранил еще один, увеличив его перед печатью строчных букв.

Новое (повторение 4, 71):

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

Старый (значения, 114):

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

Старый (повторение 1, 103):

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

Старый (повторение 2, 90):

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

Старый (повторение 3, 76):

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

Предполагает 8-битные оберточные ячейки и оборачивающую память. Я использовал Попробовать онлайн .

Все распечатать _AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789

Во-первых, эта часть

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

инициализирует ленту с этими значениями

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

Это работает, потому что рекуррентное отношение, которое я смоделировал в основном f(x) = 7 * (3 * x + 1), задом наперед. Смотрите @ primo's Привет, Мир! Ответьте за объяснение того, что такое рекуррентное отношение.

Затем довольно просто изменить эти значения на полезные. (и распечатайте подчеркивание)

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

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

Затем простые циклы используют значения для печати остальных символов. Я сохраняю 1 байт, имея приращение перед печатью.

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

Мне действительно нужно найти более короткую последовательность поколений.

Я нашел рекуррентное отношение, которое, кажется, работает хорошо, но может быть более короткое без охоты и клевки.

Я использовал калькулятор линейной регрессии, чтобы найти самое короткое из возможных линейных рекуррентных соотношений, поэтому, возможно, мне нужно найти какую-то другую формулу, если я хочу улучшить.

@Primo действительно значительно улучшил отношение повторения, спасибо.

Sesos , 17 байт

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

Выход

0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_

Попробуйте онлайн! Проверьте Debug, чтобы увидеть сгенерированный двоичный код.

Как это работает

Двоичный файл выше был сгенерирован путем сборки следующего кода 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.

Пайк, 13 байт

150m.C#P)\_+s

Попробуй это здесь!

Создает ASCII 0-150 и фильтрует по буквенно-цифровой и добавляет _в конец