Entrada:

• Uma matriz contendo três números inteiros: 0, 1e 2em qualquer ordem (isto é, [2, 0, 1])
• E uma sequência de comprimento> = 2 contendo apenas letras alfabéticas (maiúsculas e minúsculas) e dígitos (ie a1B2c3)

Saída:

Com base na matriz, classificamos e produzimos a string.
Como é que isso funciona?

• A matriz indica a ordem de precedência a-z, A-Ze0-9 , sendo o primeiro 0; segundo ser 1; e terceiro ser 2.
• Os caracteres individuais da sequência podem ser ordenados com base nisso.

Exemplo:

• Matriz: [2, 0, 1]
• Corda: a1B2c3

Com base na matriz, sabemos que nossa precedência de pedidos é 0-9a-zA-Z.
Com base nisso, podemos converter e gerar a string:123acB .

Regras do desafio:

• Para a matriz, você pode optar por usar a entrada indexada em 0 ou 1, portanto, [3, 1, 2] também é uma entrada válida se você preferir usar matrizes indexadas em 1.
• A sequência (entrada e saída) contém apenas caracteres válidos: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 .
• Se o seu idioma não suporta matrizes (ou se você optar por), você é livre para usar cordas em vez de matrizes para o primeiro parâmetro (ou seja 012, [0,1,2], etc.).

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados, programas completos. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Casos de teste:

[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èÃ{?

Explicação:

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.

Usa a codificação CP-1252 . Experimente online! .

Python 2, 67 66 bytes

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

Teste em Ideone .

JavaScript (ES6), 87 bytes

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

Se a matriz de entrada deu a ordem, e não a precedência, dos três intervalos (isso só faz diferença para [1, 2, 0]e[2, 1, 0] cujos efeitos são trocados), isso funcionaria por 80 bytes:

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

Eu interpretei mal a pergunta e ainda recebi 7 votos positivos com isso. Sinta-se à vontade para remover seus votos e entregá-los a @CharlieWynn, que apresentou a melhor correção para minha abordagem.

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

Gelatina , 13 bytes

2_ịØWs26¤Ff@€

Experimente online! ou verifique todos os casos de teste .

Como 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.

Pitão, 17 16 15 bytes

s@RSz@L[GrG1`UT

Suíte de teste.

       [          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

Obrigado a @FryAmTheEggman por um byte e @Jakube por outro!

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

Golfe:

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 bytes

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

⎕a⎕A⎕D dígitos superiores inferiores

(… )[a]Reordenar de acordo com a matriz a

∊ aplainar

(… De )⍋sacordo com esse "alfabeto", forneça os índices que classificariam a string s

s[… ]Use isso 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 na primeira lista, obtém a expressão regular apropriada e aplica-a à sequência de entrada. O resultado é uma lista de listas de símbolos que correspondem ao regex. Em seguida, classifique cada um e concatene o resultado em uma lista e transforme-o em string.

Você pode vê-lo online aqui: https://ideone.com/dqAkxg

Retina , 43 39 bytes

A contagem de bytes assume a codificação ISO 8859-1. O avanço de linha à direita é significativo.

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

Espera-se que a entrada seja a ordem de classificação como uma lista baseada em zero, sem delimitadores na primeira linha, e a sequência a ser classificada na segunda linha, por exemplo,

120
fOo42BaR

Experimente online!

Explicação

Usarei o exemplo de entrada acima para orientá-lo no código:

120
fOo42BaR

Etapa 1: Substituição

2=`.
!$&"

A própria expressão regular é apenas .(corresponde a qualquer caractere que não seja de avanço de linha), que é cercada por !...". No entanto, 2=é um limite que diz à Retina para aplicar a substituição apenas na segunda correspondência da regex. Então, nós entendemos isso:

1!2"0
fOo42BaR

Etapa 2: Transliteração

T04`¶d`#^@%

Um estágio de transliteração simplesmente substitui caractere por caractere. O ¶representa um avanço de linha e se dexpande para 0123456789(embora possamos ignorar todos os dígitos depois 2). Isso significa que essa transliteração corresponde ao seguinte mapeamento:

¶012
#^@%

Na 04frente, existem dois limites, que juntos indicam que apenas os quatro primeiros caracteres deste conjunto devem ser transliterados. Por acaso são os dígitos na primeira linha, bem como o avanço de linha que separa as duas linhas, então obtemos o seguinte:

@!%"^#fOo42BaR

Na frente da string, agora temos três pares desses caracteres:

@!
%"
^#

Observe que os segundos caracteres dos pares estão simplesmente em sua ordem ASCII normal (e sempre serão os mesmos). Nós os usaremos posteriormente para classificar os grupos de caracteres na entrada principal na ordem necessária.

Os primeiros caracteres são um pouco mais interessantes: seu significado é que %vem antes dos dígitos na tabela ASCII, @vem antes das letras maiúsculas (mas depois dos dígitos) e^ vem antes das letras minúsculas (mas depois das letras maiúsculas). Isso nos ajudará a agrupar os marcadores de posição (ou seja, o segundo caractere em cada par) com o conjunto correto de caracteres.

Etapa 3: classificação

O`\W?.

Este é um estágio de classificação simples. Ele corresponde a dois caracteres se o primeiro não for um caractere de palavra (correspondendo aos três pares de que acabei de falar) ou um único caractere (correspondendo a cada caractere da entrada principal individualmente) e classifica essas sequências. Isso tem dois propósitos: coloca os caracteres dentro de cada grupo na ordem correta (e, como a classificação é estável, essa ordem não será alterada na próxima etapa) e, devido aos %@^marcadores, insere os pares no posições corretas:

%"24@!BOR^#afo

Etapa 4: Classificar

O`.\w+

Este estágio classifica todas as correspondências da .\w+expressão regular que, devido à ganância, corresponde a um marcador de posição (ou seja, um de !"#) junto com todos os caracteres de palavra após ela. Ou seja, ele classifica essas três cadeias, cuja ordem é determinada apenas pelo caractere marcador:

"24! BOR #afo

Enquanto isso embaralha esses marcadores (deixando os outros três marcadores no lugar), o mais importante é que os dígitos e as letras estão na ordem correta:

%!BOR@"24^#afo

Etapa 5: Substituição

\W

Tudo o que resta é uma pequena limpeza, onde removemos todos os marcadores combinando-os e substituindo-os por nada.

JavaScript (ES6), 65

Nota: a ordem ASCII 'natural' é de 0 a 9, AZ, az, exatamente o oposto do OP 0,1,2. tão

• ordene a sequência adicionando caracteres inválidos para separar execuções
• divida-o em 3 segmentos - caracteres inválidos marcam cada
• obter segmentos um por um na ordem solicitada
• remontar

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]

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

Como 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

Edit: @ Christian Sievers encontrou um bug. Obrigado! Corrigido por 1 byte adicional.

Stax , 15 bytes

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

Execute e depure on-line

Esse envio de 15 bytes é compactado em uma variante do conjunto de caracteres CP437. A representação ascii correspondente leva 18 bytes:

EVlVd+26/s@:fs{[Io

Tenho certeza de que ele pode ser reduzido ainda mais.

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+também pode ser VLA|(, que à esquerda gira o 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZdez por elemenets. O código inteiro também pode ser VlVd+26/,e@:f,{[Io, que lê a pilha de entrada duas vezes em vez de lê-las todas no início da pilha principal e usa um formato de entrada diferente (mais tradicional), como mostrado neste .

Dyalog APL , 22 bytes

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

(819⌶⎕A) dobre o alfabeto maiúsculo para minúsculo

(… )⎕A⎕D[a]Dígitos superiores inferiores reordenados de acordo com a matriz a

∊ aplainar

s⍋⍨para a string s , obtenha os índices que classificariam s de acordo com o "alfabeto"

s[… ]Use isso 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]

Estou explorando algoritmos usando regex, mas até agora todos parecem mais longos.

Recebe entrada como matriz explícita $n(veja exemplos abaixo) e sequência $sque é imediatamente convertida em uma matriz de caracteres. Estamos construindo três elementos de uma nova matriz dinâmica, cada um deles encapsulado com um -join:
- (($s=$s|sort)|?{$_-ge97})
-($s|?{$_-in65..96})
-($s|?{$_-lt58})

O primeiro pegamos $se executamos Sort-Object. Felizmente, como já o definimos como um array de caracteres, é uma classificação que diferencia maiúsculas de minúsculas. Isso é salvo novamente e, em $sseguida, canalizado para a Where-Objectcom uma cláusula maior que 97(ou seja, letras minúsculas ASCII a-z). O segundo é para A-Ze o terceiro para 0-9.

Portanto, agora temos uma matriz de cadeias, em que cada cadeia é composta por um dos três tipos de caracteres e é classificada. Nós cortamos isso com[$n] e depois -joino resultado juntos para formar nossa string de saída final. Isso fica no pipeline e a impressão está implícita.

Casos de teste

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 da resposta @Dennis.

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

Uma solução alternativa de 58 bytes que eu mais gosto, inspirada no @Neil e modificada ligeiramente em sua resposta.

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

Experimente qualquer uma das versões online! (a versão comentada é a solução alternativa)

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

Em hexadecimal:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

Este procedimento espera que a ordem de classificação da classe de caracteres seja uma sequência terminada em NULL de 3 caracteres (0..2) ESIe a sequência a ser classificada EDI. A classificação é feita no local usando uma versão extremamente subótima (em termos de desempenho) da classificação de bolhas.

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

Um pouco menor que o Java ...

Clojure, 77 bytes

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

Não é tão curto quanto o re-seqbaseado, e eu não conseguia descobrir como expressar isso " (apply str(mapcat sort(map(...))))" em menos espaço.group-bycria um mapa de hash que pode ser usado como uma função; quando consultado com um ingeger entre 0 e 2, retorna o grupo correspondente; isso ordena as três classes diferentes de caracteres.

Isso seria mais compacto do que a re-seqsolução se houvesse mais classes de caracteres para manipular, pois isso leva apenas 5 caracteres / grupo extras, em 57 1,vez de 8, como expressões #"[a-z]".

Python 2, 140 117 101 100 99 bytes

Todo mundo diz: "Ewww!". Pelo menos é legível ... tosse não é realmente 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]

Experimente online

R , 101 bytes

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

Cria um vetor com az, AZ e 0-9 em uma determinada ordem e reordena os caracteres da sequência de entrada para corresponder a essa ordem.

Experimente online!

J, 40 bytes

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

Java 8, 221 212 193 156 bytes

É claro que eu deveria tentar responder também ao meu próprio desafio. :) (E como sempre em 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 salvos graças a @cliffroot .

Explicação:

Experimente aqui.

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