Ingresso:

• Un array contenente tre interi: 0, 1e 2in qualsiasi ordine (ie [2, 0, 1])
• E una stringa di lunghezza> = 2 contenente solo lettere alfabetiche (sia minuscole che maiuscole) e cifre (es. a1B2c3)

Produzione:

In base alla matrice, ordiniamo e produciamo la stringa.
Come funziona?

• La matrice indica la precedenza dell'ordine di a-z, A-Ze 0-9, il primo essere 0; secondo essere 1; e terzo essere 2.
• I singoli caratteri della stringa possono quindi essere ordinati in base a quello.

Esempio:

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

In base all'array, sappiamo che la precedenza del nostro ordine è 0-9a-zA-Z.
Sulla base di questo, siamo in grado di convertire e uscita la stringa: 123acB.

Regole della sfida:

• Per l'array puoi scegliere di utilizzare input 0-indexed o 1-indexed, quindi [3, 1, 2]è anche un input valido se preferisci usare array 1-indexed.
• La stringa (input e output) contiene solo caratteri validi: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.
• Se la tua lingua non supporta gli array (o se scegli di farlo), sei libero di usare le stringhe invece degli array per il primo parametro (ad es 012. [0,1,2], Ecc.).

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

[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

Codice:

v²žK26ôyèÃ{?

Spiegazione:

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.

Utilizza la codifica CP-1252 . Provalo online! .

Python 2, 67 66 byte

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

Provalo su Ideone .

JavaScript (ES6), 87 byte

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

Se l'array di input fornisse l'ordine, anziché la precedenza, dei tre intervalli (questo fa solo la differenza [1, 2, 0]e i [2, 1, 0]cui effetti vengono scambiati), questo avrebbe funzionato per 80 byte:

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

Ho letto male la domanda e ho ancora ottenuto 7 voti. Sentiti libero di rimuovere i tuoi voti e consegnarli a @CharlieWynn, che ha trovato la migliore correzione per il mio approccio.

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

Gelatina , 13 byte

2_ịØWs26¤Ff@€

Provalo online! o verifica tutti i casi di test .

Come funziona

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 di test.

       [          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

Grazie a @FryAmTheEggman per un byte e @Jakube per un altro!

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

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 @

Violino

APLX , 19 byte

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

⎕a⎕A⎕D cifre superiori inferiori

(... )[a]riordinare secondo l'array a

∊ appiattire

(... )⍋ssecondo questo "alfabeto", indica gli indici che ordinerebbero la stringa s

s[... ]usalo per riordinare s

Python 2, 121 byte

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

Per ogni valore nel primo elenco, ottiene regex appropriato e lo applica alla stringa di input. Il risultato è un elenco di elenchi di simboli che corrispondono alla regex. Quindi ordina ciascuno e concatena il risultato in un elenco e trasformalo in stringa.

Puoi vederlo online qui: https://ideone.com/dqAkxg

Retina , 43 39 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1. L'alimentazione di linea finale è significativa.

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

Si prevede che l'input sia l'ordinamento come elenco a base zero senza delimitatori sulla prima riga e la stringa da ordinare sulla seconda riga, ad es.

120
fOo42BaR

Provalo online!

Spiegazione

Userò l'esempio di input sopra per guidarti attraverso il codice:

120
fOo42BaR

Fase 1: sostituzione

2=`.
!$&"

La stessa regex è semplicemente .(corrisponde a qualsiasi carattere non linefeed), che è circondata da !...". Tuttavia, 2=c'è un limite che dice a Retina di applicare la sostituzione solo alla seconda partita della regex. Quindi otteniamo questo:

1!2"0
fOo42BaR

Fase 2: traslitterazione

T04`¶d`#^@%

Una fase di traslitterazione fa semplicemente una sostituzione carattere per carattere. Il ¶rappresenta un avanzamento e dsi espande a 0123456789(anche se si può ignorare tutte le cifre dopo 2). Ciò significa che questa traslitterazione corrisponde alla seguente mappatura:

¶012
#^@%

La 04parte anteriore presenta due limiti, che insieme indicano che solo i primi quattro caratteri di questo set devono essere traslitterati. Queste sono le cifre sulla prima riga, così come l'alimentazione di linea che separa le due righe, quindi otteniamo questo:

@!%"^#fOo42BaR

Nella parte anteriore della stringa ora abbiamo tre coppie di questi personaggi:

@!
%"
^#

Nota che i secondi caratteri delle coppie sono semplicemente nel loro normale ordine ASCII (e saranno sempre gli stessi). Li useremo in seguito per ordinare i gruppi di caratteri nell'input principale nell'ordine richiesto.

I primi caratteri sono un po 'più interessanti: il loro significato è quello che %precede le cifre nella tabella ASCII, che @precede le lettere maiuscole (ma dopo le cifre) e che ^precede le lettere minuscole (ma dopo le lettere maiuscole). Questo ci aiuterà a raggruppare gli indicatori di posizione (cioè il secondo carattere in ciascuna coppia) con il giusto set di caratteri.

Fase 3: ordinamento

O`\W?.

Questa è una fase di ordinamento semplice. Corrisponde a due caratteri se il primo non è un carattere di parola (corrispondente quindi a tutte e tre le coppie di cui ho appena parlato) o a un singolo carattere altrimenti (corrispondente a ciascun carattere dell'input principale singolarmente) e ordina tali stringhe. Questo ha due scopi: porta i personaggi all'interno di ciascun gruppo nell'ordine corretto (e poiché l'ordinamento è stabile, questo ordine non verrà incasinato nella fase successiva) e, a causa dei %@^marcatori, inserisce le coppie nella posizioni giuste:

%"24@!BOR^#afo

Fase 4: ordinamento

O`.\w+

Questa fase ordina tutte le partite della .\w+regex che, a causa dell'avidità, corrispondono a un indicatore di posizione (cioè uno di !"#) insieme a tutti i caratteri delle parole dopo di esso. Cioè, ordina queste tre stringhe, il cui ordine è determinato esclusivamente dal carattere marcatore:

"24! BOR #afo

Mentre questo si mescola attorno a quei marcatori (lasciando gli altri tre marcatori in posizione), soprattutto porta le cifre e le lettere nell'ordine corretto:

%!BOR@"24^#afo

Fase 5: sostituzione

\W

Tutto ciò che rimane è un po 'di pulizia, in cui rimuoviamo tutti i marker abbinandoli e sostituendoli con nulla.

JavaScript (ES6), 65

Nota: l'ordine ASCII "naturale" è 0-9, AZ, az, ovvero l'opposto dell'OP 0,1,2. Così

• ordina la stringa aggiungendo caratteri non validi per esecuzioni separate
• dividerlo in 3 segmenents - i caratteri non validi segnano ciascuno
• ottenere segmenti uno per uno nell'ordine richiesto
• Rimontare

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]

Esempio di utilizzo: "cD12ab" # [2,0,1]-> "12abcD".

Come funziona:

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

Modifica: @Christian Sievers ha trovato un bug. Grazie! Risolto per 1 byte aggiuntivo.

Stax , 15 byte

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

Eseguilo ed esegui il debug online

Questo invio di 15 byte è racchiuso in una variante del set di caratteri CP437. La rappresentazione ASCII corrispondente richiede 18 byte:

EVlVd+26/s@:fs{[Io

Abbastanza sicuro, tuttavia, può essere ulteriormente ridotto.

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+può anche essere VLA|(, che a sinistra ruota 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZdi dieci elemenet. Può anche essere l'intero codice VlVd+26/,e@:f,{[Io, che legge lo stack di input due volte invece di leggerli tutti all'inizio dello stack principale e utilizza un formato di input diverso (più tradizionale), come mostrato in questo .

Dyalog APL , 22 byte

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

(819⌶⎕A) piega l'alfabeto maiuscolo in minuscolo

(... )⎕A⎕D[a]le cifre superiori inferiori sono state riordinate secondo l'array a

∊ appiattire

s⍋⍨per la stringa s , ottieni gli indici che ordinerebbero s in base a tale "alfabeto"

s[... ]usalo per riordinare s

PowerShell v2 +, 107 byte

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

Sto esplorando algoritmi usando regex, ma finora sembrano tutti più lunghi.

Accetta input come array esplicito $n(vedere gli esempi seguenti) e stringa $sche viene immediatamente trasmessa a un array di caratteri. Stiamo quindi costruendo tre elementi di un nuovo array dinamico, ciascuno incapsulato con un -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

Il primo lo prendiamo $se lo esaminiamo Sort-Object. Per fortuna, dal momento che l'abbiamo già lanciato come char-array, è un ordinamento sensibile al maiuscolo / minuscolo. Ciò viene nuovamente salvato in $se quindi reindirizzato a Where-Objectcon una clausola maggiore di 97(ovvero, ASCII minuscola a-z). Il secondo è per A-Ze il terzo per 0-9.

Quindi ora abbiamo una matrice di stringhe, in cui ogni stringa è composta da uno dei tre tipi di caratteri ed è ordinata. Lo dividiamo con [$n]e poi -joinil risultato insieme per formare la nostra stringa di output finale. Rimane sulla pipeline e la stampa è implicita.

Casi test

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

Rubino, 56 byte

Portato dalla risposta di @Dennis.

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

Una soluzione alternativa di 58 byte che mi piace di più, ispirata a @Neil e modificata leggermente dalla sua risposta.

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

Prova una delle versioni online! (la versione commentata è la soluzione alternativa)

Codice macchina x86 a 32 bit, 70 byte

In esadecimale:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

Questa procedura prevede che l'ordinamento della classe di caratteri sia una stringa con terminazione NULL a 3 caratteri (0..2) ESIe la stringa da ordinare EDI. L'ordinamento viene eseguito sul posto utilizzando una versione estremamente non ottimale (dal punto di vista delle prestazioni) dell'ordinamento a bolle.

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

Leggermente più corto di Java ...

Clojure, 77 byte

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

Non abbastanza breve come quello di re-seqbase, e non sono riuscito a capire come " (apply str(mapcat sort(map(...))))" esprimerlo in meno spazio. group-bycrea una mappa hash che può essere usata come funzione, quando interrogata con un ingeger tra 0 e 2 restituisce il gruppo corrispondente, ordina le tre diverse classi di caratteri.

Questo sarebbe più compatto della re-seqsoluzione se ci fossero più classi di caratteri da gestire in quanto ciò richiede solo 5 caratteri / gruppo extra come 57 1,invece di 8 per espressioni simili #"[a-z]".

Python 2, 140 117 101 100 99 byte

Tutti dicono "Ewww!". Almeno è leggibile ... tosse non proprio tosse

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]

Provalo online

R , 101 byte

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

Crea un vettore con az, AZ e 0-9 nell'ordine dato e riordina i caratteri della stringa di input in modo che corrispondano a questo ordinamento.

Provalo online!

J, 40 byte

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

Java 8, 221 212 193 156 byte

Ovviamente dovrei provare a rispondere anche alla mia sfida. :) (E come al solito in Java.)

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 salvati grazie a @cliffroot .

Spiegazione:

Provalo qui.

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