Wkład:

• Tablica zawierająca trzy liczby całkowite: 0, 1i 2w dowolnej kolejności (tj [2, 0, 1])
• I ciąg długości> = 2 zawierający tylko litery alfabetu (zarówno małe, jak i wielkie litery) oraz cyfry (tj. a1B2c3)

Wydajność:

W oparciu o tablicę sortujemy i wyprowadzamy ciąg.
Jak to działa?

• Tablica wskazuje pierwszeństwo kolejności a-z, A-Za 0-9pierwsza istota 0; druga istota 1; i trzecia istota 2.
• Na tej podstawie można uporządkować poszczególne znaki ciągu.

Przykład:

• Szyk: [2, 0, 1]
• Strunowy: a1B2c3

W oparciu o tablicę wiemy, że naszym priorytetem jest kolejność 0-9a-zA-Z.
Na tej podstawie możemy konwertować i wyjście ciąg: 123acB.

Zasady konkursu:

• W przypadku tablicy można użyć danych wejściowych o indeksie 0 lub 1, więc [3, 1, 2]jest to również prawidłowe dane wejściowe, jeśli wolisz używać tablic o indeksie 1.
• Ciąg (zarówno wejście i wyjście) zawiera tylko prawidłowe znaki: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.
• Jeśli język nie obsługuje macierze (lub jeśli zdecydujesz się), jesteś wolny, aby korzystać z ciągów zamiast tablic dla pierwszego parametru (czyli 012, [0,1,2]etc.).

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

[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 bajtów

Kod:

v²žK26ôyèÃ{?

Wyjaśnienie:

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.

Wykorzystuje kodowanie CP-1252 . Wypróbuj online! .

Python 2, 67 66 bajtów

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

Przetestuj na Ideone .

JavaScript (ES6), 87 bajtów

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

Jeśli tablica wejściowa podała kolejność, a nie pierwszeństwo, trzech zakresów (robi to różnicę [1, 2, 0]i [2, 1, 0]których efekty są zamieniane), działałoby to dla 80 bajtów:

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

Źle odczytałem pytanie i nadal otrzymałem 7 pozytywnych opinii. Usuń swoje opinie i daj je @CharlieWynn, który zaproponował najlepszą korektę mojego podejścia.

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

Galaretka , 13 bajtów

2_ịØWs26¤Ff@€

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

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 bajtów

s@RSz@L[GrG1`UT

Zestaw testowy.

       [          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

Dzięki @FryAmTheEggman za bajt i @Jakube za kolejny!

JavaScript es6 77 bajtów

(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 bajtów

Gra w golfa:

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 @

Nie golfowany:

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 @

Skrzypce

APLX , 19 bajtów

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

⎕a⎕A⎕D dolne górne cyfry

(… )[a]Zmienić kolejność zgodnie z tablicą a

∊ spłaszczyć

(… )⍋sZgodnie z tym „alfabetem” podaj wskaźniki, które posortowałyby ciąg s

s[… ]Użyj tego, aby zmienić kolejność s

Python 2, 121 bajtów

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 bajty

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

Dla każdej wartości z pierwszej listy pobiera odpowiednie wyrażenie regularne i stosuje ją do ciągu wejściowego. Wynikiem jest lista list symboli pasujących do wyrażenia regularnego. Następnie posortuj każdy z nich i połączy wynik w jedną listę i przekształć go w ciąg znaków.

Możesz to zobaczyć online tutaj: https://ideone.com/dqAkxg

Retina , 43 39 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1. Końcowe podawanie linii jest znaczące.

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

Oczekuje się, że dane wejściowe będą porządkiem sortowania jako lista liczona od zera bez ograniczników w pierwszym wierszu, a ciąg znaków do sortowania w drugim wierszu, np.

120
fOo42BaR

Wypróbuj online!

Wyjaśnienie

Użyję powyższego przykładu wprowadzania, aby przeprowadzić cię przez kod:

120
fOo42BaR

Etap 1: Zmiana

2=`.
!$&"

Sam regex jest po prostu .(pasuje do dowolnego znaku nieciągłego), który jest otoczony !...". Jednak 2=jest granica mówiąc Retina, aby zastosować zmiany tylko w drugim meczu regex. Otrzymujemy to:

1!2"0
fOo42BaR

Etap 2: Transliteracja

T04`¶d`#^@%

Etap transliteracji po prostu zastępuje znak po znaku. ¶Reprezentuje wysuw i drozszerza się do 0123456789(chociaż możemy ignorować wszystkie cyfry po 2). Oznacza to, że transliteracja odpowiada następującemu mapowaniu:

¶012
#^@%

Z 04przodu są dwie granice, które razem wskazują, że tylko pierwsze cztery znaki z tego zestawu powinny być transliterowane. Tak się składa, że ​​są to cyfry w pierwszym wierszu, a także linia oddzielająca dwie linie, więc otrzymujemy:

@!%"^#fOo42BaR

Z przodu sznurka mamy teraz trzy pary tych postaci:

@!
%"
^#

Zauważ, że drugie znaki par są po prostu w normalnej kolejności ASCII (i zawsze będą takie same). Użyjemy ich później, aby posortować grupy znaków na głównym wejściu w wymaganej kolejności.

Pierwsze znaki są nieco bardziej interesujące: ich znaczenie jest takie, że %występuje przed cyframi w tabeli ASCII, przed dużymi @literami (ale po cyfrach) i ^przed małymi literami (ale po wielkich literach). Pomoże nam to zgrupować znaczniki pozycji (tj. Drugi znak w każdej parze) z odpowiednim zestawem znaków.

Etap 3: Sortuj

O`\W?.

To prosty etap sortowania. Dopasowuje dwa znaki, jeśli pierwszy nie jest znakiem słownym (dopasowując w ten sposób wszystkie trzy pary, o których właśnie mówiłem) lub pojedynczy znak w przeciwnym razie (dopasowuje każdy znak z głównego wejścia indywidualnie) i sortuje te ciągi. Ma to dwa cele: wprowadza znaki w każdej grupie we właściwej kolejności (a ponieważ sortowanie jest stabilne, kolejność ta nie zostanie zmieniona w następnym etapie), a ze względu na %@^znaczniki wstawia pary w odpowiednie pozycje:

%"24@!BOR^#afo

Etap 4: Sortuj

O`.\w+

Ten etap sortuje wszystkie dopasowania .\w+wyrażenia regularnego, które z powodu chciwości dopasowują jeden znacznik pozycji (tj. Jeden !"#) wraz ze wszystkimi znakami po nim. Oznacza to, że sortuje te trzy ciągi, których kolejność zależy wyłącznie od znaku znacznika:

„24! BOR #afo

Chociaż tasuje to wokół tych znaczników (pozostawiając pozostałe trzy znaczniki na miejscu), co najważniejsze, wprowadza cyfry i litery we właściwej kolejności:

%!BOR@"24^#afo

Etap 5: Zmiana

\W

Pozostało tylko trochę oczyszczenia, w którym usuwamy wszystkie markery, dopasowując je i zastępując niczym.

JavaScript (ES6), 65

Uwaga: „naturalna” kolejność ASCII to 0–9, AZ, az, co jest dokładnie odwrotnością OP 0,1,2. Więc

• uporządkuj ciąg dodając niepoprawne znaki do oddzielnych przebiegów
• podziel go na 3 segmenty - każdy znak oznacza nieprawidłowe znaki
• uzyskaj segmenty jeden po drugim w żądanej kolejności
• złożyć ponownie

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 bajty

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

Przykład użycia: "cD12ab" # [2,0,1]-> "12abcD".

Jak to działa:

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

Edycja: @Christian Sievers znalazł błąd. Dzięki! Naprawiono dla 1 dodatkowego bajtu.

Stax , 15 bajtów

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

Uruchom i debuguj online

To 15-bajtowe przesyłanie jest pakowane w wariant zestawu znaków CP437. Odpowiednia reprezentacja ascii zajmuje 18 bajtów:

EVlVd+26/s@:fs{[Io

Jestem pewien, że można go jeszcze bardziej przyciąć.

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+może również być VLA|(, który w lewo obraca 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZo dziesięć elementów. Może być również cały kod VlVd+26/,e@:f,{[Io, który odczytuje stos wejściowy dwa razy zamiast odczytywać je wszystkie na początku do głównego stosu i używa innego (bardziej tradycyjnego) formatu wejściowego, jak pokazano w tym .

Dyalog APL , 22 bajty

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

(819⌶⎕A) złóż wielkie litery na małe

(… )⎕A⎕D[a]Dolne górne cyfry uporządkowane zgodnie z tablicą a

∊ spłaszczyć

s⍋⍨na łańcuch s , uzyskać indeksy że porządek y Zgodnie z tym „alfabet”

s[… ]Użyj tego, aby zmienić kolejność s

PowerShell v2 +, 107 bajtów

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

Badam algorytmy za pomocą wyrażenia regularnego, ale jak dotąd wszystkie wydają się dłuższe.

Pobiera dane wejściowe jako jawną tablicę $n(patrz przykłady poniżej) i ciąg znaków, $sktóry jest natychmiast przesyłany do tablicy znaków . Następnie konstruujemy trzy elementy nowej dynamicznej tablicy, z których każdy jest zamknięty w -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

Najpierw bierzemy to $si przeprowadzamy Sort-Object. Na szczęście, ponieważ już umieściliśmy go jako tablicę znaków, sortowanie jest rozróżniane z uwzględnieniem wielkości liter. To jest ponownie zapisywane, $sa następnie przesyłane strumieniowo do Where-Objectklauzuli większej niż 97(tj. Małe litery ASCII a-z). Drugi jest za, A-Za trzeci za 0-9.

Tak więc mamy teraz tablicę ciągów, gdzie każdy ciąg składa się z jednego z trzech typów znaków i jest sortowany. Kroimy to razem, [$n]a następnie -joinwynik razem, aby utworzyć nasz końcowy ciąg wyjściowy. Pozostaje to w przygotowaniu, a drukowanie jest niejawne.

Przypadki testowe

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

Rubinowy, 56 bajtów

Przeniesione z odpowiedzi @Dennis.

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

Alternatywne 58 bajtowe rozwiązanie, które bardziej mi się podoba, zainspirowane przez @Neil i nieznacznie zmodyfikowane od jego odpowiedzi.

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

Wypróbuj dowolną wersję online! (wersja skomentowana to alternatywne rozwiązanie)

32-bitowy kod maszynowy x86, 70 bajtów

W hex:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

Ta procedura oczekuje, że kolejność sortowania klas znaków będzie łańcuchem zakończonym znakiem NULL o długości 3 znaków (0..2) ESIi łańcuchem do sortowania EDI. Sortowanie odbywa się na miejscu przy użyciu wyjątkowo nieoptymalnej (pod względem wydajności) wersji sortowania bąbelkowego.

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 bajtów

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

Nieco krótszy niż Java ...

Clojure, 77 bajtów

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

Nie tak krótki jak re-seqbazowy i nie mogłem wymyślić, jak wyrazić to „ (apply str(mapcat sort(map(...))))” na mniejszej przestrzeni. group-bytworzy mapę skrótów, która może być używana jako funkcja, po zapytaniu o liczbę całkowitą od 0 do 2 zwraca odpowiednią grupę, porządkuje trzy różne klasy znaków.

Byłoby to bardziej zwarte niż re-seqrozwiązanie, gdyby było więcej klas znaków do obsługi, ponieważ zajmuje to tylko 5 dodatkowych znaków / grup 57 1,zamiast 8 zamiast wyrażeń podobnych #"[a-z]".

Python 2, 140 117 101 100 99 bajtów

Wszyscy mówią „Ewww!”. Przynajmniej jest to czytelne ... kaszel, a nie kaszel

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]

Wypróbuj online

R , 101 bajtów

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

Tworzy wektor z az, AZ i 0-9 w podanej kolejności i zmienia kolejność znaków ciągu wejściowego, aby dopasować to uporządkowanie.

Wypróbuj online!

J, 40 bajtów

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

Java 8, 221 212 193 156 bajtów

Oczywiście powinienem również spróbować odpowiedzieć na moje własne wyzwanie. :) (I jak zwykle w Javie.)

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 bajtów zapisanych dzięki @cliffroot .

Wyjaśnienie:

Wypróbuj tutaj.

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