Herhangi bir sırayla alfasayısal karakterlerin bir dizgisini basan veya döndüren bir program veya işlev yazın . Kesin olarak, aşağıdaki karakterlerin çıktısı olması gerekiyor ve daha fazlası yok :

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Stdout'a yazdırırken, çıktınızdan sonra isteğe bağlı bir takip satırına izin verilir.

Yukarıdaki karakterlerden 9 veya daha fazlasını içeren yerleşik sabitlere izin verilmez.

Bayt cinsinden en kısa kod kazanır.

_{Bu, yine de bazı ilginç cevaplar üreteceğine inandığım çok basit bir sorundur.}

Liderler

Burada hem düzenli bir lider tablosu hem de kazananların dile göre genel bir bakış oluşturması için bir Stack Snippet'i var.

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

# Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

Başlığınıza birden fazla sayı eklemek istiyorsanız (örneğin, puanınız iki dosyanın toplamı olduğundan veya tercüman bayrağı cezalarını ayrı ayrı listelemek istediğiniz için), gerçek puanın başlıktaki son sayı olduğundan emin olun :

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

Dil adını, daha sonra büyük afiş snippet'inde görünecek bir bağlantı da yapabilirsiniz:

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

Dışbükey, 9 bayt

Yeni yöntem! Ayrıca, bunun Luis'in cevabıyla tamamen aynı olduğunu fark ettim ama dışbükeyde, ama bunu bağımsız olarak gördüm.

'{,®\W"Oò

Çevrimiçi deneyin!

Açıklama:

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

Eski çözüm, 10 bayt:

A,'[,_¬^'_

Çevrimiçi deneyin!

Açıklama:

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

Ruby, 26 bayt

Karakterler herhangi bir sırayla basılabilir mi? Yapmamın sakıncası var!

Çevrimiçi deneyin!

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

Perl, 20 bayt

-EEk ücret ödemeden gerektirir .

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

Bu yüzden orijinal cevabım (aşağıda) biraz sıkıcıydı. Ortaya koyduğum tek şey yukarıdaki, aynısı aynı, fakat biraz daha kafa karıştırıcı görünüyor ... Aşağıdakine tamamen eşdeğer:

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

Gibi @ msh210 'ın yorumlardaki öneri, ama sadece biraz fazla uzun demektir!

Çedar, 31 27 bayt

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

Bu, @"operatörü iyi gösterir.

Tamamlanmadı çünkü sonunda @"operatörü tamir etmeye başladım . Hata, bir Cheddar aralığı üretmiyordu, JS aralığı değil, bu yüzden düzgün çalışamadı.

açıklama

@"Operatör CᴏɴᴏʀO'Bʀɪᴇɴ @ tarafından tasarlanan, ve ne işe yaradığına LHS'nin dan RHS bir dize aralığını oluşturmak olduğunu edildi. Tekli bir operatör olarak kullanıldığında, verilen kod noktasındaki karakteri döndürür (python's gibi chr)

Ungolfed

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

brainfuck, 58 bayt

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

Çevrimiçi deneyin .

Kaseti 3 · 2 ^{n olarak} başlatır ve oradan çalışır.

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

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

Döndürür 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz, yani string değişmezini döndüren bir işlevden yalnızca 6 bayt daha kısadır. Evet, berbat.

Haskell, 38 bayt

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

Burada açıklanacak bir şey yok.

PowerShell v3 +, 35 33 bayt

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

Dinamik bir dizi oluşturur 1..127, onu chardizi olarak atar . Bu -match, regex üzerinde çalışan operatöre beslenir ve eşleşen \wtüm öğeleri döndürür (yani tam olarak alfanümerik ve alt çizgi). Bu dizi öğelerini -joinbir dizge halinde bir araya getirmek için içine yerleştiririz. Bu, boru hattında bırakılan ve çıktının kapalı olduğu.

V, 27 bayt

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

Çevrimiçi deneyin!

Bu cevap korkunç şekilde sarstı. Daha sonra bir açıklama göndereceğim.

HexDump:

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

Açıklama:

Okunabilir:

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 bayt

Randomra sayesinde bir bayt kaydedildi!

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

Çıktı:

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

açıklama

Bir açıklama alışkanlık kendi başına , ancak orta sonuçlar verecektir.

   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 bayt

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

İfade zip "aA0_" "zZ9_", bitiş noktalarının listesini verir [('a','z'),('A','Z'),('0','9'),('_','_')]. doNotasyonu her sürer (x,y)Anin için \(x,y)->[x..y]ve sonuçları birleştirir. Anders Kaseorg'a iki bayt doyerine teşekkür ederiz >>=.

Alternatiflerle karşılaştırın:

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 bayt

f()Herhangi bir argüman olmadan arayın .

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

Baskılar

zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

/// , 63 bayt

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Python 3, 58 bayt

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

STDOUT'a yazdıran tam bir program.

Çıktı: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Nasıl çalışır

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'da dene

Dize sabitlerine izin verilirse, aşağıdakiler 45 bayt olurdu:

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

Codegolf'teki ilk denemem!

C #, 168 152 150 147 130 127 117 116 115 109 106 bayt

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

Aloisdg, AstroDan, Leaky Nun ve Kevin Lau için çok teşekkürler - yorumlarda tüm yardım için Kenny.

Saf bash, 32

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

Ideone .

Nesne Pascal, 85 83 73 bayt

Bir karakter kümesi kullanarak sadece düz nesne pascal. Bir yordam yerine tam bir program yazmak 2 bayt'ı tıraş eder. Program anahtar sözcüğünü kaldırmak, 10 bayt daha fazla tıraş eder.

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

bash - 47 37 bayt

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

Sistemimdeki çıktı:

_0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ

Yardımcı öneriler için Dijital Travma'ya teşekkürler.

Bazı sistemlerde kullanmak mümkün olabilir asciiyerine man shbir bayt kaydedin.

PHP, 40 bayt

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

Çevrimiçi Demo .

Retina , 30 19 16 15 12 bayt

Bu son sürüm için orijinal alfabe girişimi değiştirdim . Her karakter bir döngüde yazdırılır.

İlk satır boş.

;
+T\`;w`w_

Çevrimiçi deneyin

Çıktı:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

En son girişimden 4 bayt golf attığım için Leaky Nun'a teşekkürler.

MATL , 11 bayt

7W:'\W'[]YX

Çevrimiçi deneyin!

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 bayt

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

Bu, aşağıdakileri yazdırır STDOUT:

_9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

açıklama

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

s:#"\w"0rk\|

Çevrimiçi deneyin!

U + 0000 ila U + 007B'deki tüm karakterleri regex ile eşleşen bulur /\w/.

Çıkışlar 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.

alternatif yaklaşım: 15 bayt

ssrMc4"0:A[a{_`

Çevrimiçi deneyin!

Temelde gerekli yarı dahil aralıkları oluşturur: 0-:, A-[, a-{, _-`.

CJam , 15 14 11 bayt

@FryAmTheEggman ve @Dennis sayesinde 4 bayt!

A,'[,_el^'_

Çevrimiçi deneyin!

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 bayt

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

Burada dene

Detaylar:

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

Eğer yorum yapabilseydim, diğerlerinin cevaplarını iyileştirmem gerekecekti. Ama yapamadığımdan, kendime gönderebilirim. Bunu yazmaya başladığımda en düşük BF olanı 96 idi.

F #, 50 59 bayt

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

Çıktı:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Düzenleme: ilk kez rakamları özledim

Edit2, bu Haskell çözümünden esinlenerek bu F # pasajı 67 bayttır.

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

Çıktı:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

Altıgen, 33

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

Expanded:

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

Çıktı:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_

Çevrimiçi deneyin!

0x1AProgramın ilk baytı olarak yazdırılamayan bir karakter olduğuna dikkat edin. Bu aynı zamanda genişletilmiş Altıgen'in ilk satırının kapalı görünmesini sağlar. Martin'e bana bu numarayı gösterdiği için ve alfabenin basılması için algoritmayı önerdiği için teşekkürler!

Bu depolayarak alfabe basar ave Abir altıgen, iki kenar ve harfler arasındaki ortak temas altıgenin kenarında sayısı 26. Bu şuna benziyor:

A \ / a
   |
   26

Sonra harfleri basan ve ardından onları artıran bir döngüye girer ve ardından sayıyı azaltır. Bir yinelemeden sonra şunları yapardık:

B \ / b
   |
   25

Ve bunun gibi. Başlangıç noktaları için doğrusal kodudur: 0x1A " A } a. Kontrol akışı değişikliklerin ilmekleri dış doğrusal kodudur: ; ) ' ; ) { ( ' =.

Sayaç sıfıra ulaştığında, sayıları ve alt çizgiyi yazdırmak için farklı bir yol izleriz. Doğrusal olarak dışarı Yazılı şudur: x 3 5 6 8 4 7 9 ! ; { @. Bu, geçerli xondalık sayının tümünü 1203568479 (bunun ASCII kodunun 120 olduğunu not edin ) ile değiştirir, bu sayı tüm ondalık basamakları içerir. Bu sayıyı yazdırıyoruz ve daha sonra Hexagony'nin düzgün bir özelliğini kullanıyoruz: mod 256 sayısını bir ASCII karakteri olarak yazdırıyoruz. Bu sadece 95 veya alt çizgi olur.

Brainfuck, 114 103 98 90 76 71 bayt

Diğer önemsiz (şimdi önemsiz) bir çözüm, ancak bu sefer BF!

@Primo sayesinde 14 (!) Bayt kaydedildi.

@ Primo'nun menzili tersine çevirme önerisi sayesinde 4 bayt daha tasarruf ettim ve küçük harflere baskı yapmadan önce artanlar yaparak bir tane daha tasarruf ettim.

Yeni (tekrarlama 4, 71):

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

Eski (değerler, 114):

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

Eski (yineleme 1, 103):

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

Eski (nüks 2, 90):

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

Eski (nüks 3, 76):

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

8 bitlik sarma hücreleri ve sarma belleği olduğunu varsayar. Ben kullanılan çevrimiçi deneyin .

Hepsi yazdırıldı _AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789

İlk olarak, bu bölüm

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

bandı bu değerlerle başlatır

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

Bu işe yarıyor, çünkü temelde modellenen nüks ilişkisi f(x) = 7 * (3 * x + 1)geriye doğru. Bkz Primo Hello, Dünya @! Bir yineleme ilişkisinin ne olduğunu açıklamaya cevap .

O zaman, bu değerleri faydalı olanlara değiştirmek oldukça basittir. (ve alt çizgiyi yazdır)

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

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

Sonra basit döngüler, kalan karakterleri yazdırmak için değerleri kullanır. Baskıdan önce bir artış yaparak 1 bayt tasarruf ediyorum.

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

Gerçekten daha kısa bir dizi üretimi bulmam gerekiyor.

İyi işleyen bir nüks ilişkisi buldum, ancak daha az avlanıp gagalanabileceği bir tane daha olabilir.

Mümkün olan en kısa doğrusal yineleme ilişkisinin ne olması gerektiğini bulmak için doğrusal bir regresyon hesaplayıcısı kullandım, bu yüzden geliştirmek istersem muhtemelen başka bir formül bulmalıyım.

@primo yinelenme ilişkisini gerçekten geliştirdi, teşekkürler.

Sesos , 17 bayt

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

Çıktı

0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_

Çevrimiçi deneyin! Kontrol Debug oluşturulan ikili kodunu görebilirsiniz.

Nasıl çalışır

Yukarıdaki ikili dosya aşağıdaki SASM kodunu birleştirerek oluşturulmuştur.

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 bayt

150m.C#P)\_+s

Burada dene!

Ascii 0-150 oluşturur ve alfanümerikliğe göre filtreler ve _sonuna ekler