Contribution:

• Un tableau contenant trois entiers: 0, 1et 2dans un ordre quelconque ( par exemple [2, 0, 1])
• Et une chaîne de longueur> = 2 contenant uniquement des lettres alphabétiques (à la fois minuscules et majuscules) et des chiffres (c'est-à-dire a1B2c3)

Sortie:

Sur la base du tableau, nous trions et sortons la chaîne.
Comment cela marche-t-il?

• Le tableau indique l'ordre de priorité de a-z, A-Zet 0-9, le premier étant 0; deuxième être 1; et troisième être 2.
• Les caractères individuels de la chaîne peuvent ensuite être classés en fonction de cela.

Exemple:

• Tableau: [2, 0, 1]
• Chaîne: a1B2c3

Sur la base du tableau, nous savons que notre priorité de commande est 0-9a-zA-Z.
Sur cette base, nous pouvons convertir et afficher la chaîne: 123acB.

Règles du défi:

• Pour le tableau, vous pouvez choisir d'utiliser une entrée indexée 0 ou 1 indexée. Il en [3, 1, 2]va de même pour une entrée valide si vous préférez utiliser des tableaux indexés 1.
• La chaîne (entrée et sortie) ne contient que des caractères valides: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.
• Si votre langue ne prend pas en charge les tableaux (ou si vous le souhaitez), vous êtes libre d'utiliser des chaînes au lieu des tableaux pour le premier paramètre (c'est 012-à- dire [0,1,2], etc.).

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés, des programmes complets. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de 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 octets

Code:

v²žK26ôyèÃ{?

Explication:

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.

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Python 2, 67 66 octets

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

Testez-le sur Ideone .

JavaScript (ES6), 87 octets

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

Si le tableau d'entrée a donné l'ordre, plutôt que la priorité, des trois plages (cela ne fait qu'une différence pour [1, 2, 0]et [2, 1, 0]dont les effets sont échangés), cela aurait fonctionné pour 80 octets:

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

J'ai mal lu la question et j'ai quand même reçu 7 votes positifs. N'hésitez pas à supprimer vos votes positifs et à les donner à @CharlieWynn à la place, qui a proposé la meilleure correction à mon approche.

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

Gelée , 13 octets

2_ịØWs26¤Ff@€

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça marche

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 octets

s@RSz@L[GrG1`UT

Suite de tests.

       [          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

Merci à @FryAmTheEggman pour un octet et @Jakube pour un autre!

Javascript es6 77 octets

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

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 @

Non 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 @

Violon

APLX , 19 octets

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

⎕a⎕A⎕D chiffres supérieurs inférieurs

(… )[a]Réorganiser selon le tableau a

∊ aplatir

(… )⍋sSelon cet "alphabet", donnez les indices qui trieraient la chaîne s

s[… L' ]utiliser pour réorganiser s

Python 2, 121 octets

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 octets

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

Pour chaque valeur de la première liste, obtient l'expression régulière appropriée et l'applique à la chaîne d'entrée. Le résultat est une liste de listes de symboles qui correspondent à l'expression régulière. Triez ensuite chacun et concatène le résultat en une seule liste et transformez-le en chaîne.

Vous pouvez le voir en ligne ici: https://ideone.com/dqAkxg

Rétine , 43 39 octets

Le nombre d'octets suppose un codage ISO 8859-1. Le saut de ligne arrière est important.

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

L'entrée devrait être l'ordre de tri sous la forme d'une liste de base zéro sans délimiteurs sur la première ligne, et la chaîne à trier sur la deuxième ligne, par exemple

120
fOo42BaR

Essayez-le en ligne!

Explication

Je vais utiliser l'exemple d'entrée ci-dessus pour vous guider dans le code:

120
fOo42BaR

Étape 1: substitution

2=`.
!$&"

Le regex lui-même est juste .(correspond à tout caractère non saut de ligne), qui est entouré de !...". Cependant, l' 2=est une limite indiquant Retina d'appliquer la substitution seulement au deuxième match de la regex. Nous obtenons donc ceci:

1!2"0
fOo42BaR

Étape 2: translittération

T04`¶d`#^@%

Une étape de translittération effectue simplement une substitution caractère par caractère. Le ¶représente un saut de ligne et se ddéveloppe en 0123456789(bien que nous puissions ignorer tous les chiffres après 2). Cela signifie que cette translittération correspond au mappage suivant:

¶012
#^@%

À 04l'avant sont deux limites, qui ensemble indiquent que seuls les quatre premiers caractères de cet ensemble doivent être translittérés. Il se trouve que ce sont les chiffres sur la première ligne, ainsi que le saut de ligne séparant les deux lignes, nous obtenons donc ceci:

@!%"^#fOo42BaR

Au début de la chaîne, nous avons maintenant trois paires de ces caractères:

@!
%"
^#

Notez que les seconds caractères des paires sont simplement dans leur ordre ASCII normal (et seront toujours les mêmes). Nous les utiliserons plus tard pour trier les groupes de caractères dans l'entrée principale dans l'ordre requis.

Les premiers caractères sont un peu plus intéressants: leur signification est celle qui %précède les chiffres du tableau ASCII, @qui précède les lettres majuscules (mais après les chiffres) et ^qui précède les lettres minuscules (mais après les lettres majuscules). Cela nous aidera à regrouper les marqueurs de position (c'est-à-dire le deuxième caractère de chaque paire) avec le bon ensemble de caractères.

Étape 3: trier

O`\W?.

Il s'agit d'une étape de tri simple. Il correspond à deux caractères si le premier n'est pas un caractère de mot (correspondant ainsi aux trois paires dont je viens de parler) ou à un seul caractère sinon (correspondant à chaque caractère de l'entrée principale individuellement), et trie ces chaînes. Cela a deux objectifs: il ramène les personnages de chaque groupe dans le bon ordre (et comme le tri est stable, cet ordre ne sera pas gâché à l'étape suivante), et en raison des %@^marqueurs, il insère les paires dans le bonnes positions:

%"24@!BOR^#afo

Étape 4: trier

O`.\w+

Cette étape trie toutes les correspondances de l' .\w+expression rationnelle qui, en raison de la cupidité, correspond à un marqueur de position (c'est-à-dire l'un des !"#) avec tous les caractères de mot après. Autrement dit, il trie ces trois chaînes, dont l'ordre est déterminé uniquement par le caractère marqueur:

"24! BOR #afo

Bien que cela mélange ces marqueurs (tout en laissant les trois autres marqueurs en place), plus important encore, il apporte les chiffres et les lettres dans le bon ordre:

%!BOR@"24^#afo

Étape 5: Substitution

\W

Tout ce qui reste est un petit nettoyage, où nous supprimons tous les marqueurs en les faisant correspondre et en les remplaçant par rien.

JavaScript (ES6), 65

Remarque: l'ordre ASCII «naturel» est 0-9, AZ, az, ce qui est juste l'opposé de l'OP 0,1,2. Alors

• commander la chaîne en ajoutant des caractères non valides à des exécutions distinctes
• le diviser en 3 segments - les caractères invalides marquent chacun
• obtenir les segments un par un dans l'ordre demandé
• remonter

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 octets

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

Exemple d'utilisation: "cD12ab" # [2,0,1]-> "12abcD".

Comment ça marche:

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 a trouvé un bug. Merci! Correction d'un octet supplémentaire.

Stax , 15 octets

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

Exécutez-le et déboguez-le en ligne

Cette soumission de 15 octets est regroupée dans une variante du jeu de caractères CP437. La représentation ascii correspondante prend 18 octets:

EVlVd+26/s@:fs{[Io

Je suis sûr que cela peut être encore réduit.

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+peut également être VLA|(, qui tourne à gauche le 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZpar dix elemenets. Le code entier peut également être VlVd+26/,e@:f,{[Io, qui lit la pile d'entrée deux fois au lieu de les lire toutes au début dans la pile principale, et utilise un format d'entrée différent (plus traditionnel), comme indiqué dans ce document .

Dyalog APL , 22 octets

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

(819⌶⎕A) plier l'alphabet majuscule en minuscule

(… )⎕A⎕D[a]Chiffres supérieurs inférieurs réorganisés selon le tableau a

∊ aplatir

s⍋⍨pour la chaîne s , obtenez les indices qui trieraient s selon cet "alphabet"

s[… L' ]utiliser pour réorganiser s

PowerShell v2 +, 107 octets

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

J'explore des algorithmes utilisant des expressions rationnelles, mais jusqu'à présent, ils semblent tous plus longs.

Prend l'entrée comme un tableau explicite $n(voir les exemples ci-dessous) et une chaîne $squi est immédiatement convertie en un tableau de caractères. Nous construisons ensuite trois éléments d'un nouveau tableau dynamique, chacun d'eux encapsulé avec un -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

Le premier que nous prenons $set le parcourons Sort-Object. Heureusement, puisque nous l'avons déjà converti en tableau de caractères, c'est un tri sensible à la casse. Cela est réenregistré dans $spuis redirigé vers un Where-Objectavec une clause supérieure à 97(c'est-à-dire ASCII en minuscules a-z). Le deuxième est pour A-Zet le troisième pour 0-9.

Ainsi, nous avons maintenant un tableau de chaînes, où chaque chaîne est composée d'un des trois types de caractères et est triée. Nous découpons cela avec [$n]puis -joinle résultat ensemble pour former notre chaîne de sortie finale. Cela reste sur le pipeline et l'impression est implicite.

Cas de 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

Rubis, 56 octets

Porté à partir de la réponse @Dennis.

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

Une solution alternative de 58 octets que j'aime mieux, inspirée de @Neil et légèrement modifiée de sa réponse.

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

Essayez l'une des versions en ligne! (la version commentée est la solution alternative)

Code machine x86 32 bits, 70 octets

En hex:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

Cette procédure s'attend à ce que l'ordre de tri des classes de caractères soit une chaîne terminée par NULL de 3 caractères (0..2) ESIet la chaîne à trier EDI. Le tri est effectué sur place à l'aide d'une version extrêmement sous-optimale (en termes de performances) du tri à bulles.

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 octets

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

Légèrement plus court que Java ...

Clojure, 77 octets

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

Pas aussi court que celui re-seqbasé, et je n'arrivais pas à comprendre comment exprimer cela " (apply str(mapcat sort(map(...))))" dans moins d'espace. group-bycrée une table de hachage qui peut être utilisée en tant que fonction, lorsqu'elle est interrogée avec un ingeger entre 0 et 2, elle renvoie le groupe correspondant, cela ordonne les trois classes de caractères différentes.

Ce serait plus compact que la re-seqsolution s'il y avait plus de classes de caractères à gérer car cela ne prend que 5 caractères / groupe supplémentaires 57 1,au lieu de 8 pour l'expression comme #"[a-z]".

Python 2, 140 117 101 100 99 octets

Tout le monde dit "Ewww!". Au moins c'est lisible ... toux pas vraiment toux

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]

Essayez-le en ligne

R , 101 octets

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

Crée un vecteur avec az, AZ et 0-9 dans l'ordre donné et réorganise les caractères de la chaîne d'entrée pour correspondre à cet ordre.

Essayez-le en ligne!

J, 40 octets

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

Java 8, 221 212 193 156 octets

Je devrais bien sûr essayer de répondre à mon propre défi également. :) (Et comme d'habitude 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 octets enregistrés grâce à @cliffroot .

Explication:

Essayez-le ici.

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