Schreiben Sie ein Programm oder eine Funktion, die eine Zeichenfolge aus alphanumerischen Zeichen und einem Unterstrich in beliebiger Reihenfolge ausgibt oder zurückgibt . Um genau zu sein, müssen die folgenden Zeichen ausgegeben werden und nicht mehr :

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Beim Drucken auf Standardausgabe ist eine optionale nachgestellte Zeile nach der Ausgabe zulässig.

Integrierte Konstanten, die 9 oder mehr der oben genannten Zeichen enthalten, sind nicht zulässig.

Kürzester Code in Bytes gewinnt.

_{Dies ist eine sehr einfache Herausforderung, von der ich glaube, dass sie dennoch einige interessante Antworten liefert.}

Bestenlisten

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

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

Konvex, 9 Bytes

Neue Methode! Außerdem habe ich festgestellt, dass es ziemlich genau so ist wie Luis 'Antwort, aber in Convex, aber ich habe dies unabhängig erfunden.

'{,®\W"Oò

Probieren Sie es online!

Erläuterung:

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

Alte Lösung, 10 Bytes:

A,'[,_¬^'_

Probieren Sie es online!

Erläuterung:

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

Ruby, 26 Bytes

Zeichen können in beliebiger Reihenfolge gedruckt werden? Es macht mir nichts aus, wenn ich es tue!

Probieren Sie es online!

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

Perl, 20 Bytes

Benötigt -Ekeine zusätzlichen Kosten.

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

Meine ursprüngliche Antwort (unten) war also etwas zu langweilig. Das einzige, was ich mir ausgedacht habe, ist das Obige, das ist genau das Gleiche, sieht aber etwas verwirrender aus ... Es ist so ziemlich genau wie das Folgende:

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

Ich mag die Vorschläge von @ msh210 in den Kommentaren, aber sie sind einfach ein bisschen zu lang!

Cheddar, 31 27 Bytes

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

Dies zeigt den @"Bediener gut

Nicht abgeschlossen, weil ich mich endlich daran gemacht habe, den @"Operator zu reparieren . Der Fehler war, dass es einen Cheddar-Bereich und keinen JS-Bereich generierte, sodass es nicht richtig funktionieren konnte

Erläuterung

Der @"Operator wurde von @ CᴏɴᴏʀO'Bʀɪᴇɴ entworfen und generiert einen Zeichenfolgenbereich von LHS bis RHS. Bei Verwendung als unärer Operator wird das Zeichen am angegebenen Codepunkt zurückgegeben (wie bei Pythons chr).

Ungolfed

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

Brainfuck, 58 Bytes

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

Probieren Sie es online aus .

Initialisiert das Band auf 3 · 2 ⁿ und arbeitet von dort aus.

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

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

Gibt zurück 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz, also nur 6 Bytes kürzer als eine Funktion, die das Zeichenfolgenliteral zurückgibt. Ja, es ist scheiße.

Haskell, 38 Bytes

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

Hier gibt es nichts zu erklären.

PowerShell v3 +, 35 - 33 Byte

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

Erstellt ein dynamisches Array 1..127und wandelt es in ein charArray um. Dies wird dem -matchOperator zugeführt, der an der Regex arbeitet \w, die alle übereinstimmenden Elemente zurückgibt (dh exakt alphanumerisch und unterstrichen). Wir kapseln diese Array-Elemente in ein, -joinum sie als eine Zeichenfolge zu bündeln. Das bleibt in der Pipeline und die Ausgabe ist implizit.

V, 27 Bytes

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

Probieren Sie es online!

Diese Antwort ist schrecklich verworren. Ich werde später eine Erklärung posten.

Hexdump:

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

Erläuterung:

Lesbar:

i<C-v><C-v>1<esc>                                   "Insert the text "<C-v>1"
                                                    "<C-v> means "literal"
                 122ñ       ñ                       "122 times,
                     Yp                             "Duplicate this line
                       <C-a>                        "And increment the first number on this line
                             vHgJ                   "Join every line together
                                 |éi                "Insert an 'i' at the beginning of this line
                                    dd              "Delete this line
                                      @"<esc>       "And execute it as V code.
                                                    "That will generate every ascii value from 1-123
                                             Í×     "Now remove every non-word character.

J 30 29 28 Bytes

Dank randomra ein Byte gespeichert!

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

Ausgabe:

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

Erläuterung

Ich gebe keine Erklärung an sich , werde aber Zwischenergebnisse liefern.

   10,,~26
10 26 26
   i. b. 0
1 _ _
   *  b. 0
0 0 0
   i."* b. 0
   i."*2 3 4
0 1 0 0
0 1 2 0
0 1 2 3
   i. 2
0 1
   i. 3
0 1 2
   i. 4
0 1 2 3
   i."*10,,~26
0 1 2 3 4 5 6 7 8 9  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
   0 1 2 + i."*10,,~26
0 1 2 3 4 5 6 7  8  9  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
1 2 3 4 5 6 7 8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
   48 65 97+i."*10,,~26
48 49 50  51  52  53  54  55  56  57  48  48  48  48  48  48  48  48  48  48  48  48  48  48  48  48
65 66 67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
   ;48 65 97+i."*10,,~26
48 49 50 51 52 53 54 55 56 57 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
   95,;48 65 97+i."*10,,~26
95 48 49 50 51 52 53 54 55 56 57 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 ...
   u:95,;48 65 97+i."*10,,~26
_01234567890000000000000000ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
   ~.u:95,;48 65 97+i."*10,,~26
_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Haskell, 31 Bytes

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

Der Ausdruck zip "aA0_" "zZ9_"gibt die Liste der Endpunkte an [('a','z'),('A','Z'),('0','9'),('_','_')]. Die doNotation nimmt jeweils (x,y)das Inklusive \(x,y)->[x..y]und verkettet die Ergebnisse. Danke an Anders Kaseorg für zwei Bytes mit dostatt >>=.

Vergleichen Sie mit Alternativen:

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

zip"aA0_""zZ9_">>= \(x,y)->[x..y]
f(x,y)=[x..y];f=<<zip"aA0_""zZ9_"
id=<<zipWith enumFromTo"aA0_""zZ9_"
[c|(a,b)<-zip"aA0_""zZ9_",c<-[a..b]]
f[x,y]=[x..y];f=<<words"az AZ 09 __"

C 50 Bytes

Rufen Sie f()ohne Argumente an.

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

Druckt

zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

/// 63 Bytes

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Python 3, 58 Bytes

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

Ein vollständiges Programm, das auf STDOUT gedruckt wird.

Die Ausgabe ist: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Wie es funktioniert

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

Probieren Sie es auf Ideone

Wenn Zeichenfolgenkonstanten zulässig wären, wären die folgenden 45 Bytes:

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

Mein erster Versuch mit 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+"":"");}

Vielen Dank an Aloisdg, AstroDan, Leaky Nun und Kevin Lau - nicht an Kenny für die Hilfe in den Kommentaren.

Pure Bash, 32

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

Ideone .

Object Pascal, 85 83 73 Bytes

Nur einfaches Objekt Pascal mit einer Reihe von Zeichen. Das Schreiben eines vollständigen Programms anstelle einer Prozedur spart 2 Byte. Durch das Entfernen des Programmschlüsselworts werden 10 weitere Bytes gespart.

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

Bash - 47 37 Bytes

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

Die Ausgabe auf meinem System ist:

_0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ

Vielen Dank an Digital Trauma für hilfreiche Vorschläge.

Auf einigen Systemen können Sie möglicherweise ein Byte speichern, asciianstatt es man shzu verwenden.

PHP, 40 Bytes

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

Online Demo .

Retina , 30 19 16 15 12 Bytes

Ich habe meinen ursprünglichen Alphabetversuch für diese neueste Version geändert . Jedes Zeichen wird in einer Schleife gedruckt.

Die erste Zeile ist leer.

;
+T\`;w`w_

Probieren Sie es online aus

Ausgabe:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Vielen Dank an Leaky Nun für das Golfen von 4 Bytes aus meinem letzten Versuch.

MATL , 11 Bytes

7W:'\W'[]YX

Probieren Sie es 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 Bytes

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

Dies druckt Folgendes aus STDOUT:

_9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

Erläuterung

"_"w               Write "_"
9y                 Get the list [0:1:2:3:4:5:6:7:8:9]
  rcw              Reverse it, concatenate into one number, write
"A":"Z"y           Get the list of all uppercase letters
        cL         Concatenate into a single string L
          @l:Lcw   Concatenate L to itself lowercased and write

Pyth, 13 12 Bytes

s:#"\w"0rk\|

Probieren Sie es online!

Findet alle Zeichen in U + 0000 bis U + 007B, die dem regulären Ausdruck entsprechen /\w/.

Ausgänge 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.

alternativer Ansatz: 15 Bytes

ssrMc4"0:A[a{_`

Probieren Sie es online!

im Grunde erzeugt die Halb inklusive Bereiche erforderlich: 0-:, A-[, a-{, _-`.

CJam , 15 14 11 Bytes

4 Bytes weniger dank @FryAmTheEggman und @Dennis!

A,'[,_el^'_

Probieren Sie es 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 Bytes

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

Probieren Sie es hier aus

Einzelheiten:

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

Wenn ich hätte kommentieren können, müsste ich die Antworten anderer verbessern. Aber da ich nicht kann, könnte ich auch meine eigenen posten. Als ich anfing, dies zu schreiben, war der niedrigste BF 96 lang.

F #, 50 59 Bytes

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

Ausgabe:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Bearbeiten: Verpasste die Ziffern beim ersten Mal

Edit2, inspiriert von dieser Haskell-Lösung, dieses F # -Snippet ist 67 Bytes.

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

Ausgabe:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Hexagony, 33

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

Erweitert:

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

Ausgabe:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_

Probieren Sie es online!

Beachten Sie, dass 0x1Adas erste Byte des Programms ein nicht druckbares Zeichen enthält . Dies lässt auch die erste Reihe des erweiterten Hexagons irgendwie anders aussehen. Vielen Dank an Martin, der mir diesen Trick gezeigt und den Algorithmus zum Drucken des Alphabets vorgeschlagen hat!

Dieser druckt das Alphabet durch Speicher aund Aan zwei Kanten eines Sechsecks und die Zahl 26 an der Kante des Sechsecks, das die Verbindung zwischen den Buchstaben berührt. Das sieht ungefähr so ​​aus:

A \ / a
   |
   26

Anschließend wird eine Schleife aufgerufen, in der die Buchstaben gedruckt und anschließend inkrementiert und anschließend die Zahl dekrementiert werden. Nach einer Iteration hätten wir:

B \ / b
   |
   25

Und so weiter. Der lineare Code für die Initialisierung ist: 0x1A " A } a. Der lineare Code für die Schleifen außerhalb der Steuerstromänderungen ist: ; ) ' ; ) { ( ' =.

Sobald der Zähler Null erreicht, folgen wir einem anderen Pfad, um die Zahlen und einen Unterstrich auszudrucken. Ausgeschrieben linear ist dies: x 3 5 6 8 4 7 9 ! ; { @. Dies ersetzt den Wert der aktuellen Speicherflanke durch die Nummer 1203568479 (beachten Sie, dass xder ASCII-Code 120 lautet), die alle Dezimalstellen enthält. Wir drucken diese Nummer aus und verwenden dann eine nette Funktion von Hexagony: Wir drucken die Nummer mod 256 als ASCII-Zeichen aus. Dies ist zufällig 95 oder ein Unterstrich.

Brainfuck, 114 103 98 90 76 71 Bytes

Eine andere triviale (jetzt nicht-triviale) Lösung, aber diesmal ist es BF!

14 (!) Bytes dank @primo gespeichert.

Dank des Vorschlags von @primo, den Bereich rückwärts zu generieren, wurden 4 weitere Bytes gespart, und vor dem Drucken für Kleinbuchstaben habe ich einen weiteren durch Inkrementieren gespeichert.

Neu (Wiederholung 4, 71):

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

Alt (Werte, 114):

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

Alt (Wiederholung 1, 103):

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

Alt (Wiederholung 2, 90):

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

Alt (Wiederholung 3, 76):

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

Nimmt 8-Bit-Umbruchzellen und Umbruchspeicher an. Ich habe es online ausprobiert .

Alles ausdrucken _AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789

Erstens dieser Teil

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

Initialisiert das Band mit diesen Werten

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

Dies funktioniert, weil die Wiederholungsbeziehung, die ich im Grunde genommen modelliert habe f(x) = 7 * (3 * x + 1), rückwärts ist. Siehe @primo Hallo, Welt! Beantworten Sie die Frage, was eine Wiederholungsbeziehung ist.

Dann ist es ziemlich einfach, diese Werte in nützliche Werte umzuwandeln. (und den Unterstrich ausdrucken)

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

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

Die einfachen Schleifen verwenden dann die Werte, um den Rest der Zeichen zu drucken. Ich spare 1 Byte, indem ich ein Inkrement vor dem Druck habe.

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

Ich muss wirklich eine kürzere Sequenzgenerierung finden.

Ich habe eine Wiederholungsbeziehung gefunden, die gut zu funktionieren scheint, aber es könnte eine kürzere mit weniger Hunting and Peck geben.

Ich habe einen linearen Regressionsrechner verwendet, um die kürzestmögliche lineare Wiederholungsrelation zu finden. Daher sollte ich wahrscheinlich eine andere Formel finden, wenn ich sie verbessern möchte.

@primo hat die Wiederholungsrelation sehr verbessert, danke.

Sesos , 17 Bytes

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

Ausgabe

0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_

Probieren Sie es online! Überprüfen Sie Debug , um den generierten Binärcode anzuzeigen.

Wie es funktioniert

Die obige Binärdatei wurde durch Zusammenstellen des folgenden SASM-Codes generiert.

add 48     ; Set cell 0 to 48 ('0').
fwd 1      ; Advance to cell 1.
add 10     ; Set cell 1 to 10.
jmp        ; Set an entry marker and jump to the jnz instruction.
    rwd 1  ;   Retrocede to cell 0.
    put    ;   Print its content (initially '0').
    add 1  ;   Increment cell 0 ('0' -> '1', etc.).
    fwd 1  ;   Advance to cell 1.
    sub 1  ;   Decrement cell 1.
jnz        ; While cell 1 in non-zero, jump to 'rwd 1'.
           ; This loop will print "0123456789".
rwd 1      ; Retrocede to cell 0, which holds 48 + 10 = 58.
add 7      ; Set cell 0 to 65 ('A').
fwd 1      ; Advance to cell 1.
add 26     ; Set cell 1 to 26.
jmp        ; Set an entry marker and jump to the jnz instruction.
    rwd 1  ; Retrocede to cell 0.
    put    ; Print its content (initially 'A').
    add 32 ; Add 32 to convert to lowercase ('A' -> 'a', etc.).
    put    ; Print the cell's content.
    sub 31 ; Subtract 31 to switch to the next uppercase letter ('a' -> 'B', etc.).
    fwd 1  ; Advance to cell 1.
    sub 1  ;   Decrement cell 1.
jnz        ; While cell 1 in non-zero, jump to 'rwd 1'.
           ; This loop will print "AaBb...YyZz".
rwd 1      ; Retrocede th cell 0, which holds 65 + 26 = 91.
add 4      ; Set cell 0 to 95 ('_').
put        ; Print its content.

Pyke, 13 Bytes

150m.C#P)\_+s

Probieren Sie es hier aus!

Erzeugt ASCII 0-150 und filtert nach Alphanumerik und fügt _am Ende