Írjon programot vagy függvényt, amely kinyomtatja vagy visszaküldi az alfanumerikus karakterek és az aláhúzás, tetszőleges sorrendben . Hogy pontos legyünk, a következő karaktereket kell kiírni: és nem több :
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_ Az stdout fájlba történő nyomtatáskor a kimenet után opcionális új sor kerül engedélyezésre.
Beépített konstansok, amelyek 9 vagy több fenti karakter nem engedélyezett.
A bájtokban található legrövidebb kód nyer.
Ez egy nagyon egyszerű kihívás, amely véleményem szerint mégis érdekes válaszokat generál.
ranglisták
Itt van egy veremrészlet, amely mind a rendes ranglistát, mind az áttekintést generálja. A nyertesek nyelve nyelv szerint.
Annak biztosítása érdekében, hogy a válasz megjelenjen, kérjük, kezdje a választ egy címsorral, a következő Markdown sablonnal:
# Language Name, N bytes ahol N a beküldött fájl mérete. Ha javítja a pontszámát, megtarthatja a régi pontszámokat a címsorban, áthúzva azokat. Például:
# Ruby, <s>104</s> <s>101</s> 96 bytes Ha ott több számot szeretne felvenni a fejlécébe (pl. Mert a pontszáma két fájl összege, vagy tolmácsot szeretne felsorolni) külön jelölje meg a büntetéseket), győződjön meg arról, hogy a tényleges pontszám az utolsó szám a fejlécben:
# Perl, 43 + 2 (-p flag) = 45 bytes A a nyelvnek nevezzen el egy linket, amely azután megjelenik a ranglista részletében:
# [><>](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> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody> </tbody> </table> </div><div> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody> </tbody> </table> </div><table style="display: none"> <tbody> <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> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
Megjegyzések
- A megjegyzéseket nem lehet kibővített vita tárgyává tenni; ez a beszélgetés csevegésbe került .
Válasz
Konvex, 9 bájt
Új módszer! Rájöttem, hogy nagyjából pontosan ugyanaz, mint Luis válasza, de a Convex-ben, de ezt önállóan találtam ki.
"{,®\W"Oò Magyarázat:
"{, Array of chars from NUL to "z ®\W" Regex to match non-word characters Oò Replace all matches with emtpy string régi megoldás, 10 bájt :
A,"[,_¬^"_ Magyarázat:
A, 0-9 "[,_¬^ A-Za-z "_ _ Megjegyzések
Válasz
Rubin, 26 bájt
A karakterek tetszőleges sorrendben nyomtathatók? gond, ha megteszem!
$><<(?0..?z).grep(/\w/)*"" Válasz
Perl, 20 bájt
-E szükséges külön költség nélkül .
say+a.._,A.._,_..9,_
Tehát az eredeti válaszom (lent) kissé túl unalmas volt . Az egyetlen dolog, amivel sikerült előállnom, az a fentiek, amelyek pontosan ugyanazok, de kissé zavarosabban néznek ki … Nagyjából pontosan megfelel az alábbiaknak:
say a..z,A..Z,0..9,_
Tetszik a @ msh210 “s javaslatok a megjegyzésekben, de ezek egy kicsit túl hosszúak!
Megjegyzések
- +1. Kicsit érdekesebb, de hosszabb ezek közül , mind a 27 bájt:
say grep/\w/,map chr,1..122||say map{chr=~/\w/;$&}1..122||say map{chr=~s/\W//r}1..122 - @ msh210 Még mindig nem lehet ‘ ezt jobban összezsugorítani … Bár a 25-öt sikerült:
say chr=~/\w/g for 1..255…
Válasz
Cheddar, 31 27 bájt
->97@"123+65@"91+48@"58+"_" Ez jól bemutatja a @" operátort
Nem teljes, mert végre rátértem a @" operátor. A hiba az volt Cheddar tartományt generált, nem pedig JS tartományt, így nem tud megfelelően működni
Magyarázat
A @" operátor @ CᴏɴᴏʀO “Bʀɪᴇɴ tervezte, és amit csinál, az LHS-től RHS-ig terjedő húr tartományt generál.Egyetlen operátorként használva a karaktert a megadott kódpontban adja vissza (mint például a python “s chr)
Ungolfed
-> 97 @" 123 + 65 @" 91 + 48 @" 58 + "_" Válasz
agymenés, 58 bájt
+++[[<+>->++<]>]<<[-<->]<<-.+<<++[->>+.>+.<<<]<--[->>.+<<]
Inicializálja a szalagot 3 · 2 n és onnan működik.
+++[[<+>->++<]>] 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 | ^
Válasz
JavaScript (ES6), 62 bájt
_=>String.fromCharCode(...Array(123).keys()).replace(/\W/g,"") 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz eredményt ad vissza, tehát csak 6 bájttal rövidebb, mint egy függvény, amely visszaadja a karakterlánc karakterláncát. Igen, szar.
Megjegyzések
- Megpróbálhat olyan karakterláncot találni, amelyhez
btoavisszaadja a szükséges kimenetet. - @gcampbell 60! A (60 faktoriális) karakterlánc keresése némi időt vehet igénybe.
- Csak a
atobszót használhatja. - @gcampbell valamilyen módon kizárja a reprezentálhatatlan karakterláncokat.
- @gcampbell Kiderült, hogy a btoa verzió egyébként 62 bájtot igényel: 45-et 60 alfanumerikus, 3 kódolatlan karakter kódolásához (beleértve a
_) és 14-et_=>atob("")+""esetén.
Válasz
Haskell, 38 bájtok
"_":["a".."z"]++["A".."Z"]++["0".."9"] Itt nincs magyarázat.
Megjegyzések
- kérdés: mi a ‘ különbség
:és++? - @Downgoat:
++két húrt vesz fel és összefűzi őket.:vesz egy karaktert és egy karakterláncot, és a karaktert a karakterlánc elé helyezi. A"_"++['a'..'z']...szintén működik, de egy bájttal hosszabb.
Válasz
PowerShell v3 +, 35 33 bájt
-join([char[]](1..127)-match"\w") Dinamikus tömböt szerkeszt 1..127 , char tömbként adja át. Ezt a -match operátor kezeli, amely a \w regexen dolgozik, amely az összes megfelelő elemet visszaadja (azaz pontosan alfanumerikus és aláhúzás) ). Ezeket a tömb elemeket egy -join fájlba foglaljuk, hogy egy karaktersorozatba csomagolhassuk. Azok, amelyek a folyamaton maradnak, és a kimenet implicit.
Megjegyzések
- Hé, ez ‘ nem igazságos. A saját megoldásom megegyezik azzal, hogy a
0-nél kezdtem … - @ Joe Gotta gyorsan megy. : D
- Főleg a triviális és kézenfekvő megoldásokra gondolok 😉
Válasz
V, 27 bájt
i1122ñYpñvHgJ|éidd@"Í× Ez a válasz borzalmasan zavaros. Később magyarázatot teszek.
Hexdump:
00000000: 6916 1631 1b31 3232 f159 7001 f176 4867 i..1.122.Yp..vHg 00000010: 4a7c e969 6464 4022 1bcd d7 J|.idd@"... Magyarázat:
Olvasható:
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. Megjegyzések
- : D: D: D Cheddart golflánggal kötik össze!
Válasz
J, 30 29 28 bájt
Bájtot mentett a randomra jóvoltából!
~.u:95,;48 65 97+i."*10,,~26 Kimenet:
~.u:95,;48 65 97+i."*10,,~26 _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz Magyarázat
Nem adok magyarázatot önmagában , de közbenső eredményeket adok.
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 Válasz
Haskell, 31 bájt
do(x,y)<-zip"aA0_""zZ9_";[x..y]
A zip "aA0_" "zZ9_" kifejezés megadja a végpontok listáját [("a","z"),("A","Z"),("0","9"),("_","_")]. div id = “77c0d2706f”>
jelölés minden (x,y) t a befogadó \(x,y)->[x..y] -be visz, és összefűzi az eredményt s. Köszönet Anders Kaseorg-nak két bájtért do -vel >>= helyett.
Összehasonlítás az alternatívákkal:
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 __"
Megjegyzések
-
dojelölés két bájtot ment:do(x,y)<-zip"aA0_""zZ9_";[x..y]
Válasz
C, 50 bájt
Hívja a f() -t minden argumentum nélkül.
f(n){for(n=128;--n;)isalnum(n)|n==95&&putchar(n);} Nyomatok
zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210 Megjegyzések
-
isalnum(n)|n==95&&putchar(n) - Van ‘ s UB ott. Nem adta meg a szükséges argumentumokat ‘.
- @orlp – A iv id = helyett a
putcszót használta. “637c69bd7c”>
. A putc elvárja, hogy egy adatfolyam is írjon, amelyet ‘ nem adott át.Maga a funkció jól működik (próbálja meg teljesen eltávolítani a putc fájlt, és működik).
If the number of arguments does not equal the number of parameters, the behavior is undefined. 6.5.2.2/6, lásd: N1570 . Válasz
/// , 63 bájt
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_ Megjegyzések
- Hogyan érvényes a válasz? Úgy tűnik, hogy ‘ sértik a szabályokat.
- @nicael melyik szabály?
- ” A fenti karakterek közül legalább 9-et tartalmazó beépített konstansok nem engedélyezettek. ” … Hiányzik valami nyilvánvaló, @Leaky?
- Igen, hogy ez nem használt ‘ semmilyen beépített állandót.
- Ok, de ez legalább furcsa. Határozottan az OP nem ‘ nem kéri, hogy másolja be a sorrendet, ami ‘ nem érdekes.
Válasz
Python 3, 58 bájt
print("_",*filter(str.isalnum,map(chr,range(123))),sep="") Teljes program az STDOUT-ra nyomtat.
A kimenet: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
Hogyan működik
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 Ha a karakterlánc konstansok megengedettek, akkor a következő 45 bájt lett volna:
from string import* print("_"+printable[:62]) Megjegyzések
-
print('_'+*filter(str.isalnum,map(chr,range(123)))) - @LeakyNun Ez szintaktikai hibát vet fel. Gondoltam valami hasonlót csinálni a
print('_',*filter(str.isalnum,map(chr,range(123))))vel, de ez elválasztja a szóközöket; az OP a megjegyzésekben azt mondta, hogy ‘ … egyáltalán nem engedélyezett szóköz a kimenetben ‘. - A Python 2 ezzel a megközelítéssel egy bájtot menthet:
print''.join(filter(str.isalnum,map(chr,range(123)))),'_'
Válasz
Az első kísérletem a codegolfra!
C #, 168 152 150 147 130 127 117 116 115 109 106 bájt
for(var a="0";a<"~";a++){Console.Write(System.Text.RegularExpressions.Regex.IsMatch(a+"","\\w")?a+"":"");} Nagyon köszönöm az aloisdg-nek, az AstroDan-nak, a Leaky Nun-nak és Kevin Lau-nak – nem Kenny-nek a kommentekben nyújtott minden segítségért.
Megjegyzések
- Üdvözöljük a PPCG-n! Nyugodtan távolítson el minden helyet! Nézzen meg néhány tippet a Tippek a golfozáshoz a C # kategóriában.
- Remek – 2 bájttal többet spóroltam meg. Nekem ‘ nagyon tetszik ez a codegolf 🙂
- AFAIK, a
\wregex osztály lefedi az alfanumerikus és szintén_, amelynek a"\\w"-et kellően érvényesnek kell lennie a regex egyezési függvényéhez. - A kódnak függvénynek kell lennie vagy egy teljes program nem nyilatkozat. A .NetFiddle használatával ossza meg a kód bemutatóját is.
- ” C # nem ‘ t a legjobban codegolf ” A C # kódot elég szórakoztatónak találom. Szerintem nagyszerű mainstream nyelv, amellyel játszhatunk. Ha győzni vagy itt, akkor elveszíted. Határozza meg a célját tanulásként és jól érezheti magát, és mindig nyerni fog.
Válasz
Válasz
Object Pascal, 85 83 73 bájt
Csak egyszerű objektum pascal karakterkészlet használatával. Ha egy eljárás helyett egy teljes programot írunk, 2 bájt borotválkozik. A program kulcsszó eltávolításával további 10 bájt borotválkozik.
var c:char;begin for c in["a".."z","A".."Z","0".."9","_"]do write(c);end. Megjegyzések
- Mindig is voltam és valószínűleg leszek mindig zavarja meg az Object Pascal pontos besorolása. A Turbo / Borland Pascal és a FreePascal minden bizonnyal boldogok a haszontalan
programkulcsszó nélkül. - @manatwork I did ‘ t tudjuk, hogy. Furcsa módon most a pascalt versenyképessé teszi itt …
- A nyelv, amellyel felnőttem. Tudom, hogy még nem halt meg …
- @rexkogitans Igen, az iskolában megtanultam, de ‘ nem emlékszem semmire akkoriban … ‘ Most újra játszok valamilyen programozással
Válasz
bash – 47 37 bájt
man sh|egrep -o \\w|sort -u|tr -d \\n A rendszerem kimenete:
_0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ Köszönet a Digitális traumának a hasznos javaslatokért.
Egyes rendszerekben előfordulhat, hogy a iv id = “helyett a ascii alkalmazható. 885696af20 “>
bájt mentéséhez.
Megjegyzések
-
man sh|egrep -io _\|\\w|sort -u|tr -d \\n - @DigitalTrauma Köszönöm!Kísérletezett és kiderítette, hogy
\wegyezik-e a_, és már kis- és nagybetűk nem érzékenyek, így még jobban lerövidítheti. Az id = “caf9767759”> -nek aman shhelyett a legtöbb környezetben működnie kell. Az enyémre tesz.$ env|egrep -o \\w|sort -u|tr -d \\n– >0123456789ABCDEFGHIKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz. - Ott ‘ s nem
J. Rossz.
Válasz
PHP, 40 bájt
_0<?for(;$a++^9?$a^q:$a=A;)echo" $a"|$a;
Megjegyzések
- +1 a kiválóságért. Mellékjegyzet: A PHP 7.2 figyelmeztetéseket ad, amelyek megemlítik, hogy a jövőbeni verziók hibákat vetnek fel nem definiált konstansok esetén. 🙁
Válasz
Retina , 30 19 16 15 12 bájt
Módosítottam a eredeti ábécé kísérlet ehhez a legújabb verzióhoz. Minden karakter ciklusban nyomtatódik.
Az első sor üres.
; +T\`;w`w_Kimenet:
_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz Köszönöm Leaky Nun-nak, hogy 4 bájtot golfozott a legújabb próbálkozásomból.
Hozzászólások
- I ‘ d szerint a
wállandónak számít, amely legalább 9 szükséges karaktert tartalmaz. Ön ‘ ll-nek valószínűleg ki kell terjesztenie a jobb oldalt, és a bal oldaliw-et lecserélni ao-re. egy bájt mentése aEOhasználatával adhelyett, mivel ezek csak 5 karaktert tartalmaznak. - @ mbomb007
wsemmi köze a regexhez. ‘ egy rövidítés, amely kibővül a szükséges 63 karakter listájára. Legalább ‘ konkrétan kérdeztem az orlp-t erről az esetről, mivel ‘ egészen más, mint a\wegy regexben.
Válasz
MATL , 11 bájt
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 Megjegyzések
- 2 bájttal rövidebb:
8W:'\w'XX - @DrGreenEggsandIronMan Köszönjük! De azt gondolom, hogy az új sorok nem engedélyezettek elválasztóként. A kihívás azt mondja, hogy ” egy alfanumerikus karakterlánc és aláhúzás … és nincs több ”
- Szóval miért Nem tudtam ‘ t csinálni
8W:'\w'XX!, amit kipróbáltam, de nem működik ‘ > - @DrGreenEggsandIronMan Nagyon jó kérdés! Engedje meg, hogy válaszoljak Önnek a csevegésben , így még több karaktert tudok használni
Válasz
Brachylog , 25 bájt
"_"w9yrcw"A":"Z"ycL@l:Lcw Ez a következőket nyomtatja ki: STDOUT:
_9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ Magyarázat
"_"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 Válasz
Dialog APL , 18 bájt
∊"\w"⎕S"&"⎕UCS⍳255 nyomtat:
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz Megjegyzések
- @user A fenti karakterek közül 9 vagy többet tartalmazó beépített konstansok nem engedélyezettek.
Válasz
Pyth, 13 12 bájt
s:#"\w"0rk\| Megkeresi az U + 0000 – U + 007B összes karakterét, amely illeszkedik a regexhez /\w/.
O utputs 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz.
alternatív megközelítés: 15 bájt
ssrMc4"0:A[a{_` alapvetően létrehozza a félig inkluzív tartományokat: 0-:, A-[, a-{, _-`.
Válasz
CJam , 15 14 11 bájt
4 bájt a @FryAmTheEggman és a @Dennis jóvoltából!
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 Válasz
Brainfuck, 89 bájt
+++++++++[>+++++>+<<-]>+++.>[<+.>-]<+++++++>>+++++++++++++[<+<+.+.>>-]<<+++++.+>[<+.+.>-] Részletek:
+++++++++[>+++++>+<<-]>+++. 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 Ha tudtam volna megjegyzést fűzni, javítanom kellene más válaszokon. De mivel nem tudok, a sajátomat is közzétehetem. Amint elkezdtem ezt írni, a legalacsonyabb BF 96 hosszú volt.
Válasz
F #, 50 59 bájt
Seq.iter(printf"%c"<<char)(95::[48..57]@[65..90]@[97..122]) Kimenet:
_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz Szerkesztés: először hiányzott a számjegy
Edit2, ez a Haskell-megoldás ihlette , ez az F # kódrészlet 67 bájtok.
Seq.zip"aA0_""zZ9_"|>Seq.iter(fun(x,y)->Seq.iter(printf"%c")[x..y]) Kimenet:
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_ Válasz
Hexagony, 33
"A}_8_47<=">({a/[email protected]!\356);"); Kiterjesztett:
" A } _ 8 _ 4 7 < = " > ( { a / _ x . @ . 9 ! \ 3 5 6 ) ; " ) ; . . . . Kimenet:
aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_ Ne feledje, hogy a program első bájtjaként van egy nem nyomtatható karakter 0x1A. Ez a kibővített hatszög első sorát is kikapcsolja. Nagyon köszönöm Martinnak megmutatva ezt a trükköt, valamint a t nyomtatásához szükséges algoritmus javaslatát ő ábécé!
Ez kinyomtatja az ábécét úgy, hogy a és A tárolja egy hatszög két szélén és a számot 26 a hatszög szélén, amely megérinti a betűk közötti csatlakozást. Ez így néz ki:
A \ / a | 26 Ezután belép egy ciklusba, amely kinyomtatja a betűket, majd növeli őket, majd csökkenti a számot. Egy ismétlés után:
B \ / b | 25 És így tovább. Az inicializálás lineáris kódja: 0x1A " A } a. A vezérlési folyamaton kívül eső hurkok lineáris kódja: ; ) " ; ) { ( " =.
Amint a számláló eléri a nullát, más utat követünk a számok és egy aláhúzás. Lineárisan ki van írva: x 3 5 6 8 4 7 9 ! ; { @. Ez a jelenlegi memóriaél értékét az 1203568479 számmal helyettesíti (vegye figyelembe, hogy az x “ASCII kódja 120), amely az összes tizedesjegyet tartalmazza. Kinyomtatjuk ezt a számot, majd használjuk a Hexagony szép funkcióját: a mod 256 számot ASCII karakterként nyomtatjuk ki. Ez véletlenül 95, vagyis aláhúzás.
Válasz
Brainfuck, 114 103 98 90 76 71 bájt
Újabb triviális (most nem -trivial) megoldás, de ez az idő BF!
14 (!) bájtot mentett a @primo-nak köszönhetően.
További 4 bájtot mentett a @primo javaslatának köszönhetően, hogy létrehozza a tartomány hátrafelé, és megtakarítottam egy másikat azzal, hogy növeltem a nyomtatást a kisbetűk nyomtatása előtt.
Új (4., 71. ismétlés):
+[--[<+++++++>->+<]>-]<<+++<--<-<-----<++++.+>>>[-<<.+<+.>>>]>[-<<.+>>] Régi (értékek, 114):
-[----->+<]>--->++++++++++>--[----->+<]>-------.++>----[---->+<]>++>++++[->++++++<]>++[-<<.+<<.+>>>>]<<<<<<[-<.+>] Régi (1., 103. ismétlés):
++++++++++[[<+>->+<]>+++++++++++++++]<<[<]>>+>++++++++>>----->>-----.++<<<<<[->>>.+>>.+<<<<<]<[->>.+<<] Régi (2., 90. ismétlés):
+++++++[[<+>->+<]>>+++[-<+++++++>]<]<<[<]>+++>-->->----->++++.++<<<[->>.+>.+<<<]<[->>.+<<] Régi (3., 76. ismétlés):
+[[<+++++++>->+<]>+++]<<[<]>+++>-->->----->++++.++<<<[->>.+>.+<<<]<[->>.+<<] 8 bites cellákat és memóriát csomagol. Feltételezem, hogy Próbálja ki online .
Az összes kinyomtatva _AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789
Először ez a rész
+[--[<+++++++>->+<]>-]<< ezekkel inicializálja a szalagot értékek
[91, 70, 49, 21, 7] ^ Ez azért működik, mert az általam modellezett ismétlődési reláció alapvetően f(x) = 7 * (3 * x + 1), hátrafelé. Lásd: @primo “Hello, World! Válasz , hogy megmagyarázza, mi is az ismétlődési összefüggés.
Ezután meglehetősen egyszerű hogy ezeket az értékeket hasznosakra változtassuk. (és nyomtassa ki az aláhúzást)
Code: +++<--<-<-----<++++.+ Tape: [96, 65, 48, 26, 10] ^ Ezután az egyszerű hurkok az értékeket használják a többi karakter kinyomtatására. 1 bájtot spórolok azzal, hogy növekszik a nyomtatás előtt.
>>>[-<<.+<+.>>>]>[-<<.+>>] Valóban rövidebb szekvencia-generációt kell találnom.
Találtam egy megismétlődési relációt, amely látszólag jól működik, de lehet, hogy rövidebb lesz a kevesebb vadászat és csipegetés.
Lineáris regressziós számológépet használtam hogy megtaláljam a lehető legrövidebb lineáris megismétlődési relációt, ezért valószínűleg találnom kellene valami más képletet, ha javítani akarok.
A @primo nagyon sokat javított a megismétlődés relációján, köszönöm. h3> Megjegyzések
- Mit szólnál egy visszafelé építkezéshez?
+[--[<+++++++>->+<]>-] - @primo Wow! Hogyan működik?
- 3 egyenetlen, így teljes 256-szoros hurkolást végez. A (z)
>-]végződéssel biztos lehet benne, hogy a végső tag 1 (x7) lesz. Valójában valószínűleg a következővel kell kezdeni:-, sokkal gyorsabban fejeződik be.
Válasz
Sesos , 17 bájtok
00000000: a854be 2cbc9e 71d597 14bc56 1ad99e 713b .T.,..q....V...q; Kimenet
0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_ Próbálja ki online! Ellenőrizze a Debug elemet a létrehozott bináris kód megtekintéséhez.
Hogyan működik
A fenti bináris fájl létrehozva a következő SASM-kód összeállításával.
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.
Megjegyzések
- Hú, épp a -et akartam közzétenni, amely nagyon hasonlít a tiédhez .
- Mind az elmék remekül gondolkodnak !
- @LeakyNun Hm, meglehetősen későn, de úgy tűnik, hogy a tiéd 3 bájttal rövidebb …
- A @EriktheOutgolfer Sesos korábban kevésbé hatékonyan volt kódolva. Mindkét program 17 bájt hosszú.
- @Dennis Ah, nos, a TIO gyorsítótár időnként zavaró lehet.
A,'[,_el^'_