Entrada:

• Una matriz que contiene tres enteros: 0, 1y 2en cualquier orden (es decir [2, 0, 1])
• Y una cadena de longitud> = 2 que solo contiene letras alfabéticas (tanto mayúsculas como minúsculas) y dígitos (es decir a1B2c3)

Salida:

Según la matriz, clasificamos y damos salida a la cadena.
¿Como funciona esto?

• La matriz indica la precedencia de orden de a-z, A-Zy 0-9, el primer ser 0; segundo ser 1; y tercer ser 2.
• Los caracteres individuales de la cadena se pueden ordenar en función de eso.

Ejemplo:

• Formación: [2, 0, 1]
• Cuerda: a1B2c3

Según la matriz, sabemos que nuestra orden de precedencia es 0-9a-zA-Z.
En base a esto, podemos convertir y salida de la cadena: 123acB.

Reglas de desafío:

• Para la matriz, puede elegir usar una entrada indexada 0 o 1 indexada, por [3, 1, 2]lo que también es una entrada válida si prefiere usar matrices indexadas 1.
• La cadena (tanto de entrada como de salida) sólo contiene caracteres válidos: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.
• Si su idioma no es compatible con matrices (o si decide), usted es libre de utilizar cadenas en lugar de matrices para el primer parámetro (es decir 012, [0,1,2], etc.).

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

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

Código:

v²žK26ôyèÃ{?

Explicación:

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.

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Python 2, 67 66 bytes

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

Pruébalo en Ideone .

JavaScript (ES6), 87 bytes

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

Si la matriz de entrada dio el orden, en lugar de la precedencia, de los tres rangos (esto solo hace una diferencia [1, 2, 0]y [2, 1, 0]cuyos efectos se intercambian), entonces esto habría funcionado durante 80 bytes:

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

Leí mal la pregunta y todavía obtuve 7 votos a favor con esto. Siéntase libre de eliminar sus votos a favor y dárselos a @CharlieWynn, quien obtuvo la mejor corrección para mi enfoque.

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

Jalea , 13 bytes

2_ịØWs26¤Ff@€

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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 bytes

s@RSz@L[GrG1`UT

Banco de pruebas.

       [          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

¡Gracias a @FryAmTheEggman por un byte y @Jakube por otro!

Javascript es6 77 bytes

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

Golfizado:

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 @

Sin golf:

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 @

Violín

APLX , 19 bytes

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

⎕a⎕A⎕D dígitos superiores inferiores

(... )[a]reordenar según la matriz a

∊ aplanar

(... de )⍋sacuerdo con ese "alfabeto", dé los índices que ordenarían la cadena s

s[... ]usa eso para reordenar 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 bytes

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

Para cada valor en la primera lista, obtiene la expresión regular apropiada y la aplica a la cadena de entrada. El resultado es una lista de listas de símbolos que coinciden con la expresión regular. Luego ordena cada uno y concatena el resultado en una lista y transfórmalo en una cadena.

Puede verlo en línea aquí: https://ideone.com/dqAkxg

Retina , 43 39 bytes

El recuento de bytes asume la codificación ISO 8859-1. El avance de línea final es significativo.

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

Se espera que la entrada sea el orden de clasificación como una lista basada en cero sin delimitadores en la primera línea, y la cadena que se ordenará en la segunda línea, por ejemplo

120
fOo42BaR

Pruébalo en línea!

Explicación

Usaré el ejemplo de entrada anterior para guiarte por el código:

120
fOo42BaR

Etapa 1: sustitución

2=`.
!$&"

La expresión regular en sí es justa .(coincide con cualquier carácter sin salto de línea), que está rodeada por !...". Sin embargo, 2=existe un límite que le dice a Retina que aplique la sustitución solo al segundo partido de la expresión regular. Entonces obtenemos esto:

1!2"0
fOo42BaR

Etapa 2: transliteración

T04`¶d`#^@%

Una etapa de transliteración simplemente realiza una sustitución de carácter por carácter. El ¶representa un salto de línea y se dexpande a 0123456789(aunque podemos ignorar todos los dígitos después 2). Eso significa que esta transliteración corresponde a la siguiente asignación:

¶012
#^@%

En 04la parte delantera hay dos límites, que juntos indican que solo los primeros cuatro caracteres de este conjunto deben transcribirse. Esos son los dígitos en la primera línea, así como el salto de línea que separa las dos líneas, así que obtenemos esto:

@!%"^#fOo42BaR

Al frente de la cadena ahora tenemos tres pares de estos caracteres:

@!
%"
^#

Tenga en cuenta que los segundos caracteres de los pares están simplemente en su orden ASCII normal (y siempre serán los mismos). Los usaremos más adelante para ordenar los grupos de caracteres en la entrada principal en el orden requerido.

Los primeros caracteres son un poco más interesantes: su importancia es que %viene antes de los dígitos en la tabla ASCII, @viene antes de las letras mayúsculas (pero después de los dígitos) y ^viene antes de las letras minúsculas (pero después de las letras mayúsculas). Esto nos ayudará a agrupar los marcadores de posición (es decir, el segundo carácter de cada par) con el conjunto correcto de caracteres.

Etapa 3: Ordenar

O`\W?.

Esta es una etapa de clasificación simple. Coincide con dos caracteres si el primero no es un carácter de palabra (por lo tanto, coincide con los tres pares de los que acabo de hablar) o un solo carácter de lo contrario (coincide con cada carácter de la entrada principal individualmente), y clasifica esas cadenas. Esto tiene dos propósitos: trae los caracteres dentro de cada grupo en el orden correcto (y dado que la clasificación es estable, este orden no se desordenará en la siguiente etapa), y debido a los %@^marcadores, inserta los pares en el posiciones correctas:

%"24@!BOR^#afo

Etapa 4: Ordenar

O`.\w+

Esta etapa clasifica todas las coincidencias de la .\w+expresión regular que, debido a la codicia, coincide con un marcador de posición (es decir, uno de !"#) junto con todos los caracteres de palabras después de él. Es decir, clasifica estas tres cadenas, cuyo orden está determinado únicamente por el carácter marcador:

"24! BOR #afo

Si bien esto se baraja alrededor de esos marcadores (dejando los otros tres marcadores en su lugar), lo más importante es que trae los dígitos y las letras en el orden correcto:

%!BOR@"24^#afo

Etapa 5: sustitución

\W

Todo lo que queda es una pequeña limpieza, donde eliminamos todos los marcadores uniéndolos y reemplazándolos por nada.

JavaScript (ES6), 65

Nota: el orden ASCII 'natural' es 0-9, AZ, az, que es justo lo opuesto al OP 0,1,2. Asi que

• ordenar la cadena agregando caracteres no válidos para separar las ejecuciones
• dividirlo en 3 segmentos: los caracteres no válidos marcan cada uno
• obtener segmentos uno por uno en el orden solicitado
• reensamblar

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 bytes

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

Ejemplo de uso: "cD12ab" # [2,0,1]-> "12abcD".

Cómo funciona:

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

Editar: @Christian Sievers encontró un error. ¡Gracias! Corregido por 1 byte adicional.

Stax , 15 bytes

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

Ejecútelo y depúrelo en línea

Este envío de 15 bytes está empaquetado en una variante del juego de caracteres CP437. La representación ascii correspondiente toma 18 bytes:

EVlVd+26/s@:fs{[Io

Sin embargo, estoy bastante seguro de que se puede recortar aún más.

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+también puede ser VLA|(, que a la izquierda gira el 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZpor diez elemenets. El código completo también puede ser VlVd+26/,e@:f,{[Io, que lee la pila de entrada dos veces en lugar de leerlos todos al principio en la pila principal, y utiliza un formato de entrada diferente (más tradicional), como se muestra en este .

Dyalog APL , 22 bytes

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

(819⌶⎕A) doblar el alfabeto en mayúsculas a minúsculas

(… )⎕A⎕D[a]Dígitos superiores inferiores reordenados de acuerdo con la matriz a

∊ aplanar

s⍋⍨para la cadena s , obtenga los índices que ordenarían s según ese "alfabeto"

s[... ]usa eso para reordenar s

PowerShell v2 +, 107 bytes

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

Estoy explorando algoritmos usando expresiones regulares, pero hasta ahora todos parecen más largos.

Toma la entrada como una matriz explícita $n(ver ejemplos a continuación) y una cadena $sque se convierte inmediatamente en una matriz de caracteres. Luego estamos construyendo tres elementos de una nueva matriz dinámica, cada uno de ellos encapsulado con un -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

El primero lo tomamos $sy lo ejecutamos Sort-Object. Afortunadamente, dado que ya lo hemos lanzado como una matriz de caracteres, es una clasificación entre mayúsculas y minúsculas. Eso se vuelve a guardar $sy luego se canaliza a a Where-Objectcon una cláusula mayor que 97(es decir, ASCII en minúscula a-z). El segundo es para A-Zy el tercero para 0-9.

Por lo tanto, ahora tenemos una serie de cadenas, donde cada cadena se compone de uno de los tres tipos de caracteres y se ordena. Cortamos eso con [$n]y luego -joinel resultado juntos para formar nuestra cadena de salida final. Eso queda en la tubería y la impresión está implícita.

Casos de prueba

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 bytes

Portado de @Dennis respuesta.

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

Una solución alternativa de 58 bytes que me gusta más, inspirada en @Neil y modificada ligeramente de su respuesta.

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

¡Pruebe cualquiera de las versiones en línea! (La versión comentada es la solución alternativa)

Código de máquina x86 de 32 bits, 70 bytes

En hexadecimal:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

Este procedimiento espera que el orden de clasificación de la clase de caracteres sea una cadena terminada en NULL de 3 caracteres (0..2) ESIy la cadena para clasificar EDI. La clasificación se realiza in situ utilizando una versión extremadamente subóptima (en cuanto al rendimiento) de la clasificación de burbujas.

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 bytes

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

Ligeramente más corto que Java ...

Clojure, 77 bytes

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

No es tan corto como el de re-seqbase, y no pude encontrar la forma de expresar eso " (apply str(mapcat sort(map(...))))" en menos espacio. group-bycrea un mapa hash que puede usarse como una función, cuando se consulta con un ingeger entre 0 y 2 devuelve el grupo correspondiente, esto ordena las tres clases diferentes de caracteres.

Esto sería más compacto que la re-seqsolución si hubiera más clases de caracteres para manejar, ya que esto solo requiere 5 caracteres / grupo adicionales como en 57 1,lugar de 8 para expresiones como #"[a-z]".

Python 2, 140 117 101 100 99 bytes

Todos dicen: "¡Ewww!". Al menos es legible ... la tos no es realmente tos

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]

Pruébalo en línea

R , 101 bytes

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

Crea un vector con az, AZ y 0-9 en un orden determinado y reordena los caracteres de la cadena de entrada para que coincida con este orden.

Pruébalo en línea!

J, 40 bytes

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

Java 8, 221 212 193 156 bytes

Por supuesto, también debería intentar responder a mi propio desafío. :) (Y como es habitual en 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 bytes guardados gracias a @cliffroot .

Explicación:

Pruébalo aquí

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