Memasukkan:

• Array yang berisi tiga bilangan bulat: 0, 1dan 2dalam urutan apapun (yaitu [2, 0, 1])
• Dan string dengan panjang> = 2 hanya berisi huruf alfabet (baik huruf kecil dan besar) dan digit (yaitu a1B2c3)

Keluaran:

Berdasarkan array kami mengurutkan dan menampilkan string.
Bagaimana cara kerjanya?

• Array menunjukkan urutan diutamakan dari a-z, A-Zdan 0-9, yang pertama 0; makhluk kedua 1; dan yang ketiga 2.
• Karakter individu dari string kemudian dapat dipesan berdasarkan itu.

Contoh:

• Array: [2, 0, 1]
• Tali: a1B2c3

Berdasarkan array, kita tahu prioritas pesanan kita 0-9a-zA-Z.
Berdasarkan itu, kita dapat mengkonversi dan output string: 123acB.

Aturan tantangan:

• Untuk array, Anda dapat memilih untuk menggunakan input 0-diindeks atau 1-diindeks, demikian [3, 1, 2]juga input yang valid jika Anda lebih suka menggunakan array 1-diindeks.
• String (input dan output) hanya berisi karakter yang valid: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.
• Jika bahasa Anda tidak mendukung array (atau jika Anda memilih untuk), Anda bebas untuk menggunakan string bukan array untuk parameter pertama (yaitu 012, [0,1,2], dll).

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat, program lengkap. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.
• Juga, silakan tambahkan penjelasan jika perlu.

Kasus uji:

[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 byte

Kode:

v²žK26ôyèÃ{?

Penjelasan:

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.

Menggunakan pengkodean CP-1252 . Cobalah online! .

Python 2, 67 66 byte

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

Uji di Ideone .

JavaScript (ES6), 87 byte

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

Jika array input memberi urutan, alih-alih diutamakan, dari tiga rentang (ini hanya membuat perbedaan untuk [1, 2, 0]dan [2, 1, 0]yang efeknya ditukar) maka ini akan bekerja untuk 80 byte:

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

Saya salah membaca pertanyaan dan masih mendapatkan 7 suara positif dengan ini. Jangan ragu untuk menghapus upvotes Anda dan berikan ke @CharlieWynn sebagai gantinya, yang datang dengan koreksi terbaik untuk pendekatan saya.

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

Jelly , 13 byte

2_ịØWs26¤Ff@€

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

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 byte

s@RSz@L[GrG1`UT

Suite uji.

       [          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

Terima kasih kepada @FryAmTheEggman untuk byte dan @Jakube untuk yang lain!

Javascript es6 77 byte

(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 byte

Golf:

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 @

Tidak Disatukan:

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 @

Biola

APLX , 19 byte

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

⎕a⎕A⎕D digit atas bawah

(... )[a]atur ulang menurut larik a

∊ meratakan

(... )⍋smenurut bahwa "abjad", memberikan indeks yang akan memilah-string yang s

s[... ]gunakan itu untuk menyusun ulang s

Python 2, 121 Bytes

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 byte

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

Untuk setiap nilai dalam daftar pertama, dapatkan regex yang sesuai dan terapkan ke string input. Hasilnya adalah daftar daftar simbol yang cocok dengan regex. Kemudian mengurutkan masing-masing dan menggabungkan hasilnya menjadi satu daftar dan mengubahnya menjadi string.

Anda dapat melihatnya online di sini: https://ideone.com/dqAkxg

Retina , 43 39 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1. Linefeed tambahan sangat penting.

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

Input diharapkan menjadi urutan pengurutan sebagai daftar berbasis nol tanpa pembatas pada baris pertama, dan string yang akan diurutkan pada baris kedua, misalnya

120
fOo42BaR

Cobalah online!

Penjelasan

Saya akan menggunakan contoh input di atas untuk memandu Anda melalui kode:

120
fOo42BaR

Tahap 1: Substitusi

2=`.
!$&"

Regex itu sendiri adil .(cocok dengan karakter non-linefeed apa pun), yang dikelilingi dengan !...". Namun, itu 2=adalah batas yang memberitahu Retina untuk menerapkan substitusi hanya pada pertandingan kedua regex. Jadi kami mendapatkan ini:

1!2"0
fOo42BaR

Tahap 2: Transliterasi

T04`¶d`#^@%

Tahap transliterasi hanya melakukan substitusi karakter-demi-karakter. Ini ¶mewakili umpan baris dan ddiperluas ke 0123456789(meskipun kami dapat mengabaikan semua digit setelah 2). Itu berarti, transliterasi ini sesuai dengan pemetaan berikut:

¶012
#^@%

Di 04depan adalah dua batas, yang bersama-sama menunjukkan bahwa hanya empat karakter pertama dari set ini yang harus ditransliterasi. Itu adalah digit di baris pertama, serta baris yang memisahkan kedua baris, jadi kita dapatkan ini:

@!%"^#fOo42BaR

Di bagian depan string sekarang kita punya tiga pasang karakter ini:

@!
%"
^#

Perhatikan bahwa karakter kedua dari pasangan hanya dalam urutan ASCII normal (dan akan selalu sama). Kami akan menggunakan ini nanti untuk mengurutkan grup karakter di input utama ke dalam urutan yang diperlukan.

Karakter pertama sedikit lebih menarik: signifikansinya adalah yang %datang sebelum digit pada tabel ASCII, @datang sebelum huruf besar (tetapi setelah angka), dan ^datang sebelum huruf kecil (tetapi setelah huruf besar). Ini akan membantu kami mengelompokkan penanda posisi (yaitu karakter kedua di setiap pasangan) dengan set karakter yang tepat.

Tahap 3: Sortir

O`\W?.

Ini adalah semacam tahapan sederhana. Ini cocok dengan dua karakter jika yang pertama bukan karakter kata (dengan demikian cocok dengan ketiga pasangan yang baru saja saya bicarakan) atau satu karakter sebaliknya (cocok dengan masing-masing karakter dari input utama secara individual), dan mengurutkan string tersebut. Ini memiliki dua tujuan: itu membawa karakter dalam setiap kelompok dalam urutan yang benar (dan karena penyortiran stabil, urutan ini tidak akan kacau di tahap berikutnya), dan karena %@^spidol, itu memasukkan pasangan dalam posisi yang tepat:

%"24@!BOR^#afo

Tahap 4: Sortir

O`.\w+

Tahap ini mengurutkan semua kecocokan dari .\w+regex yang, karena keserakahan, cocok dengan satu penanda posisi (yaitu salah satu dari !"#) bersama dengan semua karakter kata setelahnya. Yaitu, ini mengurutkan tiga string ini, yang urutannya ditentukan hanya oleh karakter marker:

"24! BOR #afo

Sementara ini mengacak di sekitar penanda tersebut (sambil meninggalkan tiga penanda lainnya di tempat), yang paling penting itu membawa angka dan huruf dalam urutan yang benar:

%!BOR@"24^#afo

Tahap 5: Substitusi

\W

Yang tersisa hanyalah sedikit pembersihan, tempat kami menghapus semua penanda dengan mencocokkannya dan menggantinya dengan apa pun.

JavaScript (ES6), 65

Catatan: pesanan ASCII 'alami' adalah 0-9, AZ, az, yang merupakan kebalikan dari OP 0,1,2. Begitu

• memesan string menambahkan karakter yang tidak valid untuk memisahkan menjalankan
• membaginya dalam 3 segmen - masing-masing menandai karakter yang tidak valid
• dapatkan segmen satu per satu dalam urutan yang diminta
• berkumpul kembali

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 byte

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

Contoh penggunaan: "cD12ab" # [2,0,1]-> "12abcD".

Bagaimana itu bekerja:

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

Sunting: @Christian Sievers menemukan bug. Terima kasih! Diperbaiki untuk 1 byte tambahan.

Stax , 15 byte

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

Jalankan dan debug secara online

Pengiriman 15 byte ini dikemas ke dalam varian set karakter CP437. Representasi ascii yang sesuai membutuhkan waktu 18 byte:

EVlVd+26/s@:fs{[Io

Cukup yakin itu bisa dipangkas lebih lanjut.

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+bisa juga VLA|(, yang dibiarkan berputar 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZoleh sepuluh elemen. Seluruh kode juga bisa VlVd+26/,e@:f,{[Io, yang membaca tumpukan input dua kali alih-alih membaca semuanya pada awal hingga tumpukan utama, dan menggunakan format input yang berbeda (lebih tradisional), seperti yang ditunjukkan dalam ini .

Dyalog APL , 22 byte

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

(819⌶⎕A) lipat huruf besar ke kecil

(… )⎕A⎕D[a]Digit atas yang lebih rendah disusun ulang menurut larik a

∊ meratakan

s⍋⍨untuk string s , dapatkan indeks yang akan mengurutkan s menurut yang "alfabet"

s[... ]gunakan itu untuk menyusun ulang s

PowerShell v2 +, 107 byte

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

Saya sedang mengeksplorasi algoritma menggunakan regex, tetapi sejauh ini semuanya tampak lebih panjang.

Mengambil input sebagai array eksplisit $n(lihat contoh di bawah) dan string $syang langsung dilemparkan ke array char. Kami kemudian membangun tiga elemen dari array dinamis baru, masing-masingnya dienkapsulasi dengan -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

Yang pertama kita ambil $sdan jalankan Sort-Object. Untungnya, karena kita sudah menjadikannya sebagai char-array, ini merupakan penyortiran case-sensitive. Itu akan disimpan kembali ke $sdan kemudian disalurkan ke Where-Objectdengan klausa lebih besar dari 97(yaitu, huruf kecil ASCII a-z). Yang kedua adalah untukA-Z dan yang ketiga untuk 0-9.

Jadi kita sekarang memiliki array string, di mana setiap string terdiri dari satu dari tiga tipe karakter dan diurutkan. Kami mengirisnya dengan [$n]lalu-join hasilnya bersama-sama untuk membentuk string hasil akhir kami. Yang tersisa pada pipa dan pencetakan tersirat.

Uji Kasus

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 byte

Porting dari jawaban @Dennis.

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

Solusi 58 byte alternatif yang saya sukai lebih baik, terinspirasi oleh @Neil dan sedikit dimodifikasi dari jawabannya.

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

Coba salah satu versi online! (versi komentar-keluar adalah solusi alternatif)

Kode mesin x86 32-bit, 70 byte

Dalam hex:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

Prosedur ini mengharapkan urutan penyortiran kelas karakter menjadi string 3-char (0..2) NULL ESIdan string untuk diurutkanEDI . Penyortiran dilakukan di tempat menggunakan versi penyortiran gelembung yang sangat sub-optimal (berdasarkan kinerja).

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 byte

(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))))))))

Sedikit lebih pendek dari Jawa ...

Clojure, 77 byte

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

Tidak sesingkat yang re-seqberbasis, dan saya tidak tahu bagaimana mengekspresikan " (apply str(mapcat sort(map(...))))" itu dalam ruang yang lebih sedikit.group-bymembuat hash-peta yang dapat digunakan sebagai fungsi, ketika ditanya dengan ingeger antara 0 dan 2 mengembalikan grup yang sesuai, ini memerintahkan tiga kelas karakter yang berbeda.

Ini akan lebih ringkas daripada re-seqsolusinya jika ada lebih banyak kelas karakter untuk ditangani karena ini hanya membutuhkan 5 karakter tambahan / grup 57 1,daripada 8 untuk ekspresi seperti #"[a-z]".

Python 2, 140 117 101 100 99 byte

Semua orang berkata, "Ewww!". Setidaknya itu bisa dibaca ... batuk bukan batuk

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]

Cobalah online

R , 101 byte

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

Membuat vektor dengan az, AZ dan 0-9 dalam urutan yang diberikan dan menata ulang karakter dari string input agar sesuai dengan pemesanan ini.

Cobalah online!

J, 40 byte

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

Java 8, 221 212 193 156 byte

Tentu saja saya harus mencoba menjawab tantangan saya sendiri. :) (Dan seperti biasa di Jawa.)

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 byte disimpan berkat @cliffroot .

Penjelasan:

Coba di sini.

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