Napisz program lub funkcję, która drukuje lub zwraca ciąg znaków alfanumerycznych oraz podkreślenie, w dowolnej kolejności . Aby być precyzyjnym, następujące znaki muszą być wyprowadzane i nie więcej :

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Podczas drukowania na standardowe wyjście, opcjonalny końcowy znak nowej linii po wydruku jest dozwolony.

Wbudowane stałe zawierające 9 lub więcej powyższych znaków są niedozwolone.

Najkrótszy kod w bajtach wygrywa.

_{To bardzo proste wyzwanie, które, jak sądzę, przyniesie kilka interesujących odpowiedzi.}

Liderów

Oto fragment kodu, który pozwala wygenerować zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka.

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

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

Wypukły, 9 bajtów

Nowa metoda! Uświadomiłem sobie również, że jest to dokładnie to samo co odpowiedź Luisa, ale w wypukłym, ale wymyśliłem to niezależnie.

'{,®\W"Oò

Wypróbuj online!

Wyjaśnienie:

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

Stare rozwiązanie, 10 bajtów:

A,'[,_¬^'_

Wypróbuj online!

Wyjaśnienie:

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

Rubinowy, 26 bajtów

Znaki można wydrukować w dowolnej kolejności? Nie przejmuj się, jeśli to zrobię!

Wypróbuj online!

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

Perl, 20 bajtów

Wymaga -Ebez dodatkowych kosztów.

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

Tak więc moja pierwotna odpowiedź (poniżej) była trochę zbyt nudna. Jedyne, co udało mi się wymyślić, to powyższe, to jest dokładnie to samo, ale wygląda nieco bardziej myląco ... To prawie dokładnie tak samo jak poniżej:

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

Lubię komentarze @ msh210 w komentarzach, ale są one trochę za długie!

Cheddar, 31 27 bajtów

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

To @"dobrze pokazuje operatora

Niedokończenie, ponieważ w końcu zadzwoniłem do naprawiania @"operatora. Błąd polegał na tym, że generował zakres Cheddar, a nie zakres JS, więc nie mógł poprawnie działać

Wyjaśnienie

@"Operator zaprojektowana przez @ CᴏɴᴏʀO'Bʀɪᴇɴ i co robi to generuje szereg ciąg od LHS do RHS. Gdy jest używany jako operator jednoargumentowy, zwraca znak w danym punkcie kodowym (jak python chr)

Bez golfa

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

pieprzenie mózgu, 58 bajtów

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

Wypróbuj online .

Inicjuje taśmę do 3,2 ⁿ i działa od tego momentu .

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

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

Zwraca 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz, więc tylko 6 bajtów krótszych niż funkcja zwracająca literał ciągu. Tak, to do bani.

Haskell, 38 bajtów

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

Nie ma tu nic do wyjaśnienia.

PowerShell v3 +, 35 33 bajtów

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

Konstruuje tablicę dynamiczną 1..127, rzutuje ją jako chartablicę. Jest to podawane -matchoperatorowi, który pracuje nad wyrażeniem regularnym \w, który zwróci wszystkie pasujące elementy (tj. Dokładnie alfanumeryczny i podkreślnik). Hermetyzujemy te elementy tablicy w -joinpaczkę, aby utworzyć jeden ciąg. Pozostaje to w potoku, a dane wyjściowe są niejawne.

V, 27 bajtów

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

Wypróbuj online!

Ta odpowiedź jest strasznie skomplikowana. Wyjaśnię później.

Hexdump:

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

Wyjaśnienie:

Czytelny:

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 bajtów

Zapisano bajt dzięki randomra!

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

Wydajność:

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

Wyjaśnienie

Nie będę wyjaśniał per se , ale dostarczy pośrednich wyników.

   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 bajtów

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

Wyrażenie zip "aA0_" "zZ9_"podaje listę punktów końcowych [('a','z'),('A','Z'),('0','9'),('_','_')]. doNotacja zajmuje każdy (x,y)z posilki \(x,y)->[x..y]i Łączy wyników. Dzięki Andersowi Kaseorgowi za dwa bajty z dozamiast >>=.

Porównaj z alternatywami:

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 bajtów

Zadzwoń f()bez żadnych argumentów.

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

Wydruki

zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

/// , 63 bajty

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Python 3, 58 bajtów

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

Pełny program, który drukuje do STDOUT.

Dane wyjściowe to: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Jak to działa

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

Wypróbuj na Ideone

Gdyby dozwolone były stałe łańcuchowe, następujące byłyby 45 bajtów:

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

Moja pierwsza próba kodegolfa!

C #, 168 152 150 147 130 127 117 116 115 109 106 bajtów

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

Wielkie dzięki dla aloisdg, AstroDan, Leaky Nun i Kevin Lau - nie Kenny za całą pomoc w komentarzach.

Pure Bash, 32

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

Ideone .

Obiekt Pascal, 85 83 73 bajty

Wystarczy zwykły obiekt pascal za pomocą zestawu znaków. Napisanie pełnego programu zamiast procedury goli 2 bajty. Usunięcie słowa kluczowego programu powoduje kolejne 10 bajtów.

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

bash - 47 37 bajtów

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

Dane wyjściowe w moim systemie to:

_0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ

Dzięki Digital Trauma za pomocne sugestie.

W niektórych systemach możesz użyć asciizamiast man shzapisać bajt.

PHP, 40 bajtów

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

Demo online .

Retina , 30 19 16 15 12 bajtów

Zmodyfikowałem oryginalną próbę alfabetu dla tej najnowszej wersji. Każda postać jest drukowana w pętli.

Pierwszy wiersz jest pusty.

;
+T\`;w`w_

Wypróbuj online

Wydajność:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Dzięki Leaky Nun za grę w golfa 4 bajty mojej ostatniej próby.

MATL , 11 bajtów

7W:'\W'[]YX

Wypróbuj 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

Brachylog , 25 bajtów

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

Spowoduje to wydrukowanie następujących elementów STDOUT:

_9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

Wyjaśnienie

"_"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 bajtów

s:#"\w"0rk\|

Wypróbuj online!

Znajduje wszystkie znaki od U + 0000 do U + 007B pasujące do wyrażenia regularnego /\w/.

Wyjścia 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.

alternatywne podejście: 15 bajtów

ssrMc4"0:A[a{_`

Wypróbuj online!

zasadniczo wytwarza się pół-inclusive wymagane zakresy: 0-:, A-[, a-{, _-`.

CJam , 15 14 11 bajtów

4 bajty wyłączone dzięki @FryAmTheEggman i @Dennis!

A,'[,_el^'_

Wypróbuj online!

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

Brainfuck, 89 bajtów

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

Wypróbuj tutaj

Detale:

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

Gdybym mógł skomentować, musiałbym poprawić odpowiedzi innych. Ale ponieważ nie mogę, równie dobrze mogę opublikować własne. Gdy zacząłem pisać, najniższy BF miał 96 długości.

F #, 50 59 bajtów

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

Wydajność:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Edycja: brakowało cyfr po raz pierwszy

Edit2, zainspirowany tym rozwiązaniem Haskell, ten fragment F # ma 67 bajtów.

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

Wydajność:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Sześciokąt, 33

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

Rozszerzony:

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

Wydajność:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_

Wypróbuj online!

Zauważ, że 0x1Ajako pierwszy bajt programu istnieje znak, którego nie można wydrukować . To również sprawia, że ​​pierwszy rząd rozszerzonego sześciokąta wygląda trochę nie tak. Bardzo dziękuję Martinowi za pokazanie mi tej sztuczki, a także za zasugerowanie algorytmu drukowania alfabetu!

Spowoduje to wydrukowanie alfabetu poprzez zapisanie ai Ana dwóch krawędziach sześciokąta oraz cyfry 26 na krawędzi sześciokąta, która dotyka połączenia między literami. Wygląda to mniej więcej tak:

A \ / a
   |
   26

Następnie wchodzi w pętle, które drukuje litery, a następnie zwiększa je, a następnie zmniejsza liczbę. Po jednej iteracji mielibyśmy:

B \ / b
   |
   25

I tak dalej. Kod liniowy dla inicjalizacji jest: 0x1A " A } a. Kod liniowy pętle zewnątrz zmian przepływu sterowania wynosi: ; ) ' ; ) { ( ' =.

Gdy licznik osiągnie zero, podążamy inną ścieżką, aby wydrukować liczby i znak podkreślenia. Rozpisane liniowo to: x 3 5 6 8 4 7 9 ! ; { @. Zastępuje to bieżącą wartość krawędzi pamięci liczbą 1203568479 (zauważ, że xkod ASCII to 120), który zawiera wszystkie cyfry dziesiętne. Drukujemy ten numer, a następnie używamy ciekawej funkcji Hexagony: drukujemy numer mod 256 jako znak ASCII. To akurat ma 95 lub podkreślenie.

Brainfuck, 114 103 98 90 76 71 bajtów

Kolejne trywialne (teraz nietrywialne) rozwiązanie, ale tym razem jest BF!

Zaoszczędź 14 (!) Bajtów dzięki @primo.

Zaoszczędziłem jeszcze 4 bajty dzięki sugestii @ primo, aby wygenerować zakres do tyłu, a kolejny zaoszczędziłem, zwiększając przed drukowaniem małych liter.

Nowość (cykl 4, 71):

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

Stare (wartości, 114):

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

Stare (rekurencja 1, 103):

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

Old (recurrence 2, 90):

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

Stare (rekurencja 3, 76):

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

Zakłada 8-bitowe zawijanie komórek i pamięć zawijania. Użyłem Wypróbuj online .

Wszystko wydrukowane _AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789

Po pierwsze, ta część

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

inicjuje taśmę tymi wartościami

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

Działa to, ponieważ relacja wzorca, którą modelowałem, jest w zasadzie f(x) = 7 * (3 * x + 1)wstecz. Zobacz @ Witaj, świecie! Odpowiedz na wyjaśnienie, czym jest relacja powtarzalności.

Następnie zmiana tych wartości na przydatne jest dość prosta. (i wydrukuj podkreślenie)

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

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

Następnie proste pętle używają wartości do drukowania reszty znaków. Oszczędzam 1 bajt dzięki przyrostowi przed wydrukiem.

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

Naprawdę muszę znaleźć krótszą generację sekwencji.

Znalazłem relację nawrotów, która wydaje się działać dobrze, ale może być krótsza bez polowania i dziobania.

Użyłem kalkulatora regresji liniowej, aby znaleźć możliwie najkrótszą możliwą relację liniowej rekurencji, więc prawdopodobnie powinienem znaleźć inną formułę, jeśli chcę poprawić.

@primo bardzo poprawiło relację powtarzalności, dzięki.

Sesos , 17 bajtów

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

Wydajność

0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_

Wypróbuj online! Zaznacz opcję Debuguj, aby wyświetlić wygenerowany kod binarny.

Jak to działa

Powyższy plik binarny został wygenerowany przez skompletowanie następującego kodu 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 bajtów

150m.C#P)\_+s

Wypróbuj tutaj!

Generuje ascii 0-150 i filtruje według alfanumeryczności i dodaje _do końca