Giriş:

• Bir dizi üç tamsayı: 0, 1ve 2herhangi bir sırada (örneğin [2, 0, 1])
• Ve sadece> alfabetik harfler (hem küçük hem de büyük harf) ve rakamlar (yani a1B2c3) içeren bir uzunluk>> 2 dizesi

Çıktı:

Diziye göre dizgiyi sıralar ve çıkarırız.
Bu nasıl çalışıyor?

• Dizi sırası öncelik gösterir a-z, A-Zve 0-9birinci varlık 0; ikinci varlık 1; ve üçüncü varlık 2.
• Dizenin bireysel karakterleri daha sonra buna göre sıralanabilir.

Örnek:

• Dizi: [2, 0, 1]
• Dize: a1B2c3

Diziye dayanarak, sipariş önceliğimizin olduğunu biliyoruz 0-9a-zA-Z.
Buna dayanarak, biz dize ve çıkış dönüştürebilirsiniz: 123acB.

Meydan okuma kuralları:

• Dizi için 0 indeksli veya 1 indeksli giriş kullanmayı seçebilirsiniz, bu yüzden [3, 1, 2]1 indeksli dizileri kullanmayı tercih ederseniz geçerli bir giriş olur.
• Dize (giriş ve çıkış) yalnızca geçerli karakterler içeriyor: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.
• Dil dizileri desteklemiyorsa (eğer seçerseniz veya), ilk parametre (yani yerine Dizilerin dizeleri kullanmak serbesttir 012, [0,1,2]vs.).

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyonlar / yöntem ile uygun parametreler, tam programlar kullanabilirsiniz. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, lütfen gerekirse bir açıklama ekleyin.

Test durumları:

[2, 0, 1]  &  a1B2c3             ->   123acB
[2, 1, 0]  &  aAaA909UuHWw9gh2   ->   02999AAHUWaaghuw
[2, 1, 0]  &  6Bx43              ->   346Bx
[1, 0, 2]  &  jfjf33g            ->   ffgjj33
[0, 2, 1]  &  AbC13              ->   b13AC
[1, 2, 0]  &  Qfl0l              ->   Q0fll
[0, 1, 2]  &  9870abcABC         ->   abcABC0789
[0, 2, 1]  &  test123            ->   estt123
[2, 0, 1]  &  WHAT               ->   AHTW
[2, 0, 1]  &  WhAt               ->   htAW
[1, 0, 2]  &  102BACbac          ->   ABCabc012

05AB1E , 15 14 12 bayt

Kod:

v²žK26ôyèÃ{?

Açıklama:

v             # For each in the input array.
  žK          #   Push a-zA-Z0-9.
    26ô       #   Split into pieces of 26.
       yè     #   Get the element-th element of the array.
 ²       Ã    #   Keep the characters of that element from the second input.
          {?  #   Sort pop and print without a newline.

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin! .

Python 2, 67 66 bayt

lambda s,k:`sorted(s,key=lambda c:`k.index(3-ord(c)/32)`+c)`[2::5]

İdeone üzerinde test et .

JavaScript (ES6), 87 bayt

(a,s)=>a.map(n=>[...s].sort().join``.replace([/[^a-z]/g,/[^A-Z]/g,/\D/g][n],``)).join``

Giriş dizisi, üç aralığın önceliğinden ziyade sırasını verdiyse (bu yalnızca farkları olan [1, 2, 0]ve [2, 1, 0]etkilerini değiştiren), o zaman 80 bayt için işe yarardı:

(a,s,o=c=>a[(c<'a')+(c<'A')])=>[...s].sort((a,b)=>o(a)-o(b)||(a>b)-(a<b)).join``

Soruyu yanlış okudum ve hâlâ bununla 7 oy aldım. Yaklaşımlarınızı kaldırmaktan çekinmeyin ve bunları @CharlieWynn'e verin, benim yaklaşımım için en iyi düzeltmeyi yaptı.

(a,s)=>a.map(n=>s.replace([/[^a-z]/g,/[^A-Z]/g,/\D/g][n],``)).join``

Jöle , 13 bayt

2_ịØWs26¤Ff@€

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

2_ịØWs26¤Ff@€  Main link. Arguments: k (permutation of [0, 1, 2]), s (string)

2_             Subtract the integers in k from 2, mapping [0, 1, 2] -> [2, 1, 0].
        ¤      Combine the three links to the left into a niladic chain.
   ØW          Yield the string following string.
               'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_'
     s26       Split it into chunks of 26 chars, i.e., ['A...Z', 'a...z', '0...9'].
  ị            Retrieve the chunks from the right result at the indices of the
               left result. The indices of the chunks are modular and 1-based;
               1 retrieves 'A...Z', 2 retrieves 'a...z', and 3 retrieves '0...9'.
         F     Flatten the resulting array of strings.
          f@€  Filter (swapped, each); for each character in the constructed
               string, select all occurrences of that character from s.

Pyth, 17 16 15 bayt

s@RSz@L[GrG1`UT

Test odası.

       [          array literal containing...
        G           the alphabet (lowercase)
         rG1        the alphabet, converted to uppercase
            `UT     inspect-range-10, generating the range [0,10) and
                      stringifying it, resulting in a string that contains no
                      letters and all numbers (so equivalent to '0123456789' for
                      filtering)
                    this creates ['ab...z', 'AB...Z', '01...9']

     @L           map over first (implicit) input (the ordering array) and take
                   the nth element in this array for each item
                   this gives us ['01...9', 'ab...z', 'AB...Z']

   Sz             take another line of input as a string and sort it, and then...
 @R               map over intersection: filter the line of input over presence
                    in each element in the new array
                    this results in ['123', 'ac', 'B']

s                 concatenate all and implicitly output

Sayesinde @FryAmTheEggman bir byte ve için @Jakube diğeri için!

Javascript es6 77 bayt

(a,s)=>a.map(o=>s.match([/[a-z]?/g,/[A-Z]?/g,/\d?/g][o]).sort().join``).join``

//test
f=(a,s)=>a.map(o=>(s.match([/[a-z]/g,/[A-Z]/g,/\d/g][o])||[]).sort().join``).join``


f([2, 0, 1], "a1B2c3")             == "123acB" &&
f([2, 1, 0], "aAaA909UuHWw9gh2")   == "02999AAHUWaaghuw" &&
f([2, 1, 0], "6Bx43")              == "346Bx" &&
f([1, 0, 2], "jfjf33g")            == "ffgjj33" &&
f([0, 2, 1], "AbC13")              == "b13AC" &&
f([1, 2, 0], "Qfl0l")              == "Q0fll" &&
f([0, 1, 2], "9870abcABC")         == "abcABC0789" &&
f([0, 2, 1], "test123")            == "estt123" &&
f([2, 0, 1], "WHAT")               == "AHTW" &&
f([2, 0, 1], "WhAt")               == "htAW" &&
f([1, 0, 2], "102BACbac")          == "ABCabc012"

TSQL, 199 191 bayt

golfed:

DECLARE @i varchar(99)='abA7B34',@s char(3)='213'

,@ varchar(99)=''SELECT @+=n FROM(SELECT top 99n FROM(SELECT top 99substring(@i,row_number()over(order by 1/0),1)n FROM sys.messages)c ORDER BY CHARINDEX(CHAR(ascii(n)/32+48),@s),n)d SELECT @

Ungolfed:

DECLARE @i varchar(99)='abA7B34'
-- 1 numbers, 2 upper case, 3 lower case
DECLARE @s char(3)='213'


,@ varchar(99)=''
SELECT @+=n
FROM
  (
    SELECT top 99 n 
    FROM
      (
         SELECT top 99substring(@i, row_number()over(order by 1/0), 1)n
         FROM sys.messages
      )c
    ORDER BY CHARINDEX(CHAR(ascii(n)/32+48),@s),n
  )d

SELECT @

Keman

APLX , 19 bayt

s[(∊(⎕a⎕A⎕D)[a])⍋s]

⎕a⎕A⎕D alt üst basamak

(... )[a]yeniden düzenlemek dizisi göre a

∊ düzleştirmek

(… )⍋sBu “alfabe” ye göre, s dizgesini sıralayacak endeksleri verin

s[... ]kullanım olduğunu sipariş için s

Python 2, 121 Bayt

lambda a,s:"".join(sum([[sorted(filter(eval(u),s))for u in["str.islower","str.isupper","str.isdigit"]][i]for i in a],[]))

Clojure, 74 bayt

#(apply str(mapcat sort(for[i %](re-seq([#"[a-z]"#"[A-Z]"#"[0-9]"]i)%2))))

İlk listedeki her değer için uygun regex alır ve giriş dizesine uygular. Sonuç, regex ile eşleşen sembollerin listesidir. Sonra her birini sıralayın ve sonucu bir listeye birleştirin ve dizgeye dönüştürün.

Burada çevrimiçi olarak görebilirsiniz: https://ideone.com/dqAkxg

Retina , 43 39 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar. Sondaki satır besleme kayda değerdir.

2=`.
!$&"
T04`¶d`#^@%
O`\W?.
O`.\w+
\W

Girişin, birinci satırdaki sınırlayıcılar olmadan sıfır tabanlı bir liste olarak sıralama sırası ve ikinci satırda sıralanacak dize olması beklenir;

120
fOo42BaR

Çevrimiçi deneyin!

açıklama

Yukarıdaki giriş örneğini kodda size göz atmak için kullanacağım

120
fOo42BaR

Aşama 1: Değiştirme

2=`.
!$&"

Regex kendisi .ile çevrili sadece (herhangi bir satır besleme olmayan karakter eşleşir) !...". Bununla birlikte, Retina'nın yerine geçenleri yalnızca regex'in ikinci maçına uygulamasını söyleyen 2=bir sınırdır . Yani bunu anlıyoruz:

1!2"0
fOo42BaR

2. Aşama: Harf çevirisi

T04`¶d`#^@%

Bir harf çevirisi aşaması sadece karakter karakter değiştirmesi yapar. ¶Bir besleme ve temsil dgenişler 0123456789(tüm basamak sonra göz ardı edilebilir olmasına rağmen 2). Bu, bu harf çevirisi, aşağıdaki haritalamaya karşılık gelir:

¶012
#^@%

04Ön birlikte bu kümesinden yalnızca ilk dört karakteri harf çevirisi gerektiğini belirtmek iki limitleri vardır. İlk satırdaki rakamlar ve iki satırı birbirinden ayıran satır beslemesi olur.

@!%"^#fOo42BaR

Dizenin önünde şu anda bu karakterlerden üç çiftimiz var:

@!
%"
^#

Çiftlerin ikinci karakterlerinin normal ASCII sıralarında olduklarını (ve daima aynı olacağını) unutmayın. Bunları daha sonra ana girdideki karakter gruplarını gerekli sıraya göre sıralamak için kullanacağız.

İlk karakterler biraz daha ilginç: %Önemleri ASCII tablosundaki rakamlardan önce gelir, @büyük harflerden önce gelir (ancak rakamlardan sonra) ve ^küçük harflerden önce gelir (ancak büyük harflerden sonra). Bu, konum işaretleyicilerini (yani her çiftin ikinci karakteri) doğru karakter grubuyla gruplamamıza yardımcı olacaktır.

Aşama 3: Sırala

O`\W?.

Bu basit bir sıralama aşamasıdır. Birincisi bir kelime karakteri (bu yüzden az önce konuştuğum üç çiftin her biriyle eşleşiyorsa) veya tek bir karakter değilse (ana girişin her karakterini ayrı ayrı eşleştiriyorsa) iki karakterle eşleşir ve bu dizeleri sıralar. Bu karakter getirir: Bu iki amacı vardır içinde doğru sırayla her bir grup (ve sıralama dayanıklı olduğu için, bu sırada bir sonraki aşamada haberci edilmez) ve bunun nedeni %@^belirteçler, bu çiftleri ekler doğru pozisyonlar:

%"24@!BOR^#afo

Aşama 4: Sıralama

O`.\w+

Bu aşama .\w+, açgözlülük nedeniyle, bir konum işaretleyicisiyle (yani bir tanesiyle !"#) aynı sözcük karakterleriyle eşleştirilen regex'in tüm eşleşmelerini sıralar . Başka bir deyişle, sırasını yalnızca işaretleyici karakteriyle belirleyen bu üç dizeyi sıralar:

"24!

Bu, bu işaretleyicilerin etrafını karıştırırken (diğer üç işaretleyiciyi yerinde bırakırken), en önemlisi, rakamları ve harfleri doğru sırayla getirir:

%!BOR@"24^#afo

Aşama 5: İkame

\W

Geriye kalan tek şey biraz temizliktir; burada tüm işaretleri işaretleyerek onları eşleştirip hiçbir şeyle değiştirmeyiz.

JavaScript (ES6), 65

Not: 'doğal' ASCII emri 0-9, AZ, az, OP 0,1,2'nin tam tersidir. Yani

• çalışmaların ayrılması için geçersiz karakterler ekleyen dizenin siparişini vermek
• 3 parçaya bölün - her biri geçersiz karakterler işaretlenir
• İstenilen sırayla segmentleri birer birer almak
• reassemble

s=>w=>w.map(w=>[...'^@'+s].sort().join``.split(/\W/)[2-w]).join``

F=s=>w=>w.map(w=>[...'^@'+s].sort().join``.split(/\W/)[2-w]).join``

;[['201','a1B2c3','123acB']
,['210','aAaA909UuHWw9gh2','02999AAHUWaaghuw']
,['210','6Bx43','346Bx']
,['102','jfjf33g','ffgjj33']
,['021','AbC13','b13AC']
,['120','Qfl0l','Q0fll']
,['012','9870abcABC','abcABC0789']
,['021','test123','estt123']
,['201','WHAT','AHTW']
,['201','WhAt','htAW']
,['102','102BACbac','ABCabc012']]
.forEach(t=>{
  var w=t[0],s=t[1],k=t[2], r=F(s)([...w])
  console.log(w,s,r,(r==k?'OK':'KO (expected '+k+')'))
})

Haskell, 62 63 bayt

a#b=[c|i<-b,c<-[' '..],d<-a,d==c,div(fromEnum c)16==[6,4,3]!!i]

Kullanım örneği: "cD12ab" # [2,0,1]-> "12abcD".

Nasıl çalışır:

i<-b                                  -- loop i through the input array
   [c|   c<-[' '..]]                  -- loop through all chars c
       d<-a                           -- loop through all chars d in the input string
       d==c                           -- and keep those that are in the input string
       div(fromEnum c)16==[6,4,3]!!i  -- and where the the ascii value divided by
                                      -- 16 equals the number from [6,4,3] indexed
                                      -- by the current i

Düzenleme: @ Hıristiyan Sievers bir hata buldu. Teşekkürler! 1 ek bayt için düzeltildi.

Stax , 15 bayt

┐°!'àÉgYg8∟╗`╖ë

Çevrimiçi çalıştırın ve hata ayıklayın

Bu 15 bayt gönderim CP437 karakter kümesinin bir varyantına paketlenmiştir . Karşılık gelen ascii gösterimi 18 bayt alır:

EVlVd+26/s@:fs{[Io

Yine de kesilebileceğinden eminim.

E                   Put the two inputs on main stack
 Vl                 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
   Vd               "0123456789"
     +              Concatenate
      26/           Partition to blocks of size 26 (array `a`)
         s@         Index array `a` with the input index array
           :fs      Flatten to get a string `s`
              {[Io  Order the input string
                        Using the char array `s` as the key
                    Implicit output

VlVd+ayrıca VLA|(, kalan 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZon elemenet tarafından döndürülebilir. Bütün kodu da olabilir VlVd+26/,e@:f,{[Iogösterildiği gibi, ana yığınına başında hepsini okuma iki kez yerine girdi yığını okur ve farklı (daha geleneksel) giriş formatını kullandığı, bu .

Dyalog APL , 22 bayt

s[s⍋⍨∊(819⌶⎕A)⎕A⎕D[a]]

(819⌶⎕A) büyük harfli alfabeyi küçük harfe katlayın

(… )⎕A⎕D[a]Alt dizilerin a sırasına göre yeniden sıralanması

∊ düzleştirmek

s⍋⍨s dizgisi için, bu "alfabe" ye göre s sıralama yapan dizini al

s[... ]kullanım olduğunu sipariş için s

PowerShell v2 +, 107 bayt

param($n,[char[]]$s)-join(-join(($s=$s|sort)|?{$_-ge97}),-join($s|?{$_-in65..96}),-join($s|?{$_-lt58}))[$n]

Regex kullanarak algoritmaları araştırıyorum, ancak şimdiye kadar hepsi daha uzun görünüyor.

Girdiyi açık dizi olarak alır $n(aşağıdaki örneklere bakın) ve $shemen bir char-array'e gönderilen dize. Daha sonra, her biri a ile kapsüllenmiş yeni bir dinamik dizinin üç öğesini oluşturuyoruz -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

İlk alıp $sgeçip geçiyoruz Sort-Object. Neyse ki, onu zaten bir karakter dizisi olarak kullandığımızdan, büyük / küçük harfe duyarlı sıralama. Bu yeniden kaydedilir $sve daha Where-Objectbüyük bir maddeye 97(ASCII küçük harf a-z) sahip bir maddeye aktarılır . İkincisi A-Zve üçüncüsü 0-9.

Böylece, şimdi her dizenin üç karakter tipinden birinden oluştuğu ve sıralandığı bir dizi dizimiz var. Biz o dilim [$n]ve sonra -joinbirlikte sonuç bizim son çıkış dizesi oluşturmak üzere. Bu, boru hattında bırakılır ve yazdırma gizlidir.

Test Kılıfları

PS C:\Tools\Scripts\golfing> $test = (@(2,0,1),'a1B2c3'), (@(2,1,0),'aAaA909UuHWw9gh2'), (@(2,1,0),'6Bx43'), (@(1,0,2),'jfjf33g'), (@(0,2,1),'AbC13'), (@(1,2,0),'Qfl0l'), (@(0,1,2),'9870abcABC'), (@(0,2,1),'test123'), (@(2,0,1),'WHAT'), (@(2,0,1),'WhAt'), (@(1,0,2),'102BACbac')

PS C:\Tools\Scripts\golfing> $test |%{"($($_[0]-join',')) & $($_[1])".PadRight(28)+" -> " + (.\post-determined-array-sorting.ps1 $_[0] $_[1])}
(2,0,1) & a1B2c3             -> 123acB
(2,1,0) & aAaA909UuHWw9gh2   -> 02999AAHUWaaghuw
(2,1,0) & 6Bx43              -> 346Bx
(1,0,2) & jfjf33g            -> ffgjj33
(0,2,1) & AbC13              -> b13AC
(1,2,0) & Qfl0l              -> Q0fll
(0,1,2) & 9870abcABC         -> abcABC0789
(0,2,1) & test123            -> estt123
(2,0,1) & WHAT               -> AHTW
(2,0,1) & WhAt               -> htAW
(1,0,2) & 102BACbac          -> ABCabc012

Ruby, 56 bayt

@Dennis yanıtından alınmıştır.

->a,s{s.chars.sort_by{|c|a.index(3-c.ord/32).to_s+c}*''}

Ben daha çok sevdiğim, @ Neil'den ilham alan ve cevabından biraz değiştirilen alternatif bir 58 baytlık çözüm.

->a,s{a.map{|i|s.scan([/[a-z]/,/[A-Z]/,/\d/][i]).sort}*''}

Her iki sürümü de çevrimiçi deneyin! (yorumlanan sürüm alternatif çözümdür)

32 bit x86 makine kodu, 70 bayt

Onaltılı olarak:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

Bu yordam, karakter sınıfı sıralama düzeninin 3 char (0..2) NULL sonlandırılmış dize ESIve sıralanacak dize olmasını bekler EDI. Sınıflandırma, kabarcık sınıfının son derece düşük optimal (performans açısından) sürümü kullanılarak yerinde yapılır.

0:  fc                  cld
1:  31 c0               xor eax, eax
3:  31 c9               xor ecx, ecx
5:  51                  push ecx        ;Allocate 4 bytes on the stack
6:  89 e3               mov ebx, esp    ;char EBX[4]
_loop0:                                 ;Parsing class order string
8:  ac                  lodsb
9:  84 c0               test al,al      ;Break on NULL
b:  74 0a               jz _break0
d:  34 cf               xor al, 0xCF    ;AL=~atoi(AL)
f:  04 04               add al, 4       ;'0'->3, '1'->2, '2'->1
11: 88 0c 03            mov [ebx+eax], cl    ;EBX[AL]=CL
14: 41                  inc ecx
15: eb f1               jmp _loop0
_break0:
17: 89 fe               mov esi,edi
19: 91                  xchg eax,ecx    ;ECX=0
_bsort:
1a: 60                  pusha
_cx2b:
1b: ac                  lodsb           ;Get the first char to compare
1c: 88 c2               mov dl,al       ;Save to DL
1e: c0 e8 05            shr al,5        ;Char class: [0-9]->1, [A-Z]->2, [a-z]->3
21: d7                  xlat            ;AL=EBX[AL] - priority for the char class 
22: 88 c6               mov dh,al       ;... goes to DH
24: 52                  push edx        ;First "comparable char" in DX goes to the stack
25: ac                  lodsb           ;Get the second char to compare
26: 88 c2               mov dl,al       ;\
28: c0 e8 05            shr al,5        ; > Same as the above
2b: d7                  xlat            ;/
2c: 88 c6               mov dh, al      ;Second "comparable char" in DX
2e: 58                  pop eax         ;The first one goes to AX
2f: 74 0e               jz _endpass     ;ZF is set by the last 'shr', and only on AL==0
31: 66 39 d0            cmp ax,dx       ;Upper halves of 32-bit regs may contain trash
34: 76 02               jbe _sorted
36: 92                  xchg eax,edx    ;Now AX<=DX
37: 41                  inc ecx         ;Swap counter
_sorted:
38: aa                  stosb           ;Store AL in-place
39: 92                  xchg eax,edx    ;AL=DL
3a: aa                  stosb           ;Store the second char
3b: 4e                  dec esi         ;Move pointers...
3c: 4f                  dec edi         ;...back one byte
3d: eb dc               jmp _cx2b       ;Repeat with the next two chars
_endpass:
3f: 85 c9               test ecx,ecx    ;Full pass completed, checking # of swaps made
41: 61                  popa            ;Restores ECX(0), ESI, EDI. Doesn't affect flags
42: 75 d6               jnz _bsort      ;If there were changes, repeat
_end:
44: 58                  pop eax         ;Deallocate EBX[]
45: c3                  ret

Emacs Lisp, 183 bayt

(lambda(s p)(let(l u n)(apply'concat(mapcar(lambda(l)(sort l'<))(dolist(e(string-to-list s)(mapcar(lambda(i)(nth i(list l u n)))p))(push e(cond((< ?` e)l)((< ?@ e)u)((< ?/ e)n))))))))

Java'dan biraz daha kısa ...

Clojure, 77 bayt

#(apply str(mapcat sort(map(group-by(fn[v](condp <(int v)90 0,57 1,2))%2)%)))

Temel olan kadar kısa değil re-seqve bunu nasıl ifade edeceğimi bulamadım "(apply str(mapcat sort(map(...)))) ve daha az uzayda " . group-byİşlev olarak kullanılabilecek bir karma haritası oluşturur, 0 ile 2 arasındaki bir ingeger ile sorgulandığında karşılık gelen grubu döndürür, bu üç farklı karakter sınıfını sıralar.

re-seqEğer böyle bir 57 1,ifade için 8 yerine sadece 5 fazla karakter / grup alırsa, ele alınacak daha fazla karakter sınıfı varsa , bu çözümden daha kompakt olacaktır #"[a-z]".

Python 2, 140 117 101 100 99 bayt

Herkes "ewww!" Diyor. En azından okunabilir ... öksürük gerçekten öksürük değil

lambda l,s:`sorted(s,key=lambda c:[[c<'a',c<'A'or'Z'<c,c>'9'][l[i]]for i in 0,1,2]+[ord(c)])`[2::5]

Çevrimiçi deneyin

R , 101 bayt

function(a,s,o=unlist(list(letters,LETTERS,0:9)[a]))cat(o[sort(match(strsplit(s,'')[[1]],o))],sep='')

Verilen sırada az, AZ ve 0-9 ile bir vektör oluşturur ve giriş sırasının karakterlerini bu sıralamaya göre yeniden sıralar.

Çevrimiçi deneyin!

J, 40 bayt

;@:{[:(<@/:~@}./.~2-64 96 I.3&u:)'aA0'&,

Java 8, 221 212 193 156 bayt

Elbette kendi zorluğuma da cevap vermeye çalışmalıyım. :) (Ve her zamanki gibi Java'da.)

a->i->{for(byte c[],j=0;j<3;System.out.print(new String(c)))java.util.Arrays.sort(c=i.replaceAll("[^a-z];[^A-Z];[^0-9]".split(";")[a[j++]],"").getBytes());}

@ 28 bayt @cliffroot sayesinde kaydedildi .

Açıklama:

Burada dene.

a->i->{          // Method with integer-array and String parameters and no return-type
  for(byte c[],  //  Temp byte-array
      j=0;j<3;   //  Loop from 0 to 3 (exclusive)
      System.out.print(new String(c)))
                 //    After every iteration: print the byte-array as String
    java.util.Arrays.sort(
                 //   Sort the byte-array
      c=         //    After we've replaced the byte-array with
        i.replaceAll("[^a-z];[^A-Z];[^0-9]".split(";")[a[j++]],"").getBytes());}
                 //    all bytes of the uppercase letters, lowercase letters, or digits,
                 //    depending on the next number in the input-array