Eingang:

• Ein Array mit drei ganzen Zahlen: 0, 1und 2in beliebiger Reihenfolge (dh [2, 0, 1])
• Und eine Zeichenfolge mit einer Länge> = 2, die nur alphabetische Buchstaben (sowohl Groß- als auch Kleinbuchstaben) und Ziffern (dh a1B2c3) enthält.

Ausgabe:

Basierend auf dem Array sortieren wir den String und geben ihn aus.
Wie funktioniert das?

• Die Anordnung gibt die Reihenfolge der Priorität a-z, A-Zund 0-9, wobei die ersten 0; zweites Wesen 1; und drittes Wesen 2.
• Darauf aufbauend können dann die einzelnen Zeichen des Strings geordnet werden.

Beispiel:

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

Aufgrund des Arrays wissen wir, dass unsere Reihenfolge Vorrang hat 0-9a-zA-Z.
Auf dieser Basis können wir die Zeichenfolge konvertieren und Ausgang: 123acB.

Herausforderungsregeln:

• Für das Array können Sie zwischen einer 0-indizierten und einer 1-indizierten Eingabe wählen. Dies [3, 1, 2]ist auch eine gültige Eingabe, wenn Sie 1-indizierte Arrays bevorzugen.
• Die Zeichenfolge (Eingang und Ausgang) enthält nur gültige Zeichen: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.
• Wenn Ihre Sprache Arrays nicht unterstützt (oder wenn Sie wählen), können Sie Strings anstelle von Arrays für den ersten Parameter (dh 012, [0,1,2]usw.).

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methode mit den richtigen Parametern und vollständige Programme verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

[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

Code:

v²žK26ôyèÃ{?

Erläuterung:

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.

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

Python 2, 67 66 Bytes

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

Teste es auf Ideone .

JavaScript (ES6), 87 Byte

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

Wenn das Eingabearray die Reihenfolge der drei Bereiche anstelle der Rangfolge angegeben hätte (dies macht nur einen Unterschied für [1, 2, 0]und [2, 1, 0]deren Effekte werden vertauscht), hätte dies für 80 Bytes funktioniert:

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

Ich habe die Frage falsch verstanden und trotzdem 7 positive Stimmen erhalten. Zögern Sie nicht, Ihre Upvotes zu entfernen und geben Sie sie stattdessen an @CharlieWynn weiter, der die beste Korrektur für meinen Ansatz gefunden hat.

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

Jelly , 13 Bytes

2_ịØWs26¤Ff@€

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Testsuite.

       [          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

Vielen Dank an @FryAmTheEggman für ein Byte und @Jakube für ein anderes!

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

Golf gespielt:

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 @

Geige

APLX , 19 Bytes

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

⎕a⎕A⎕D untere obere Ziffern

(… )[a]Nach Array neu anordnen a

∊ ebnen

(... )⍋snach diesem „Alphabet“, geben die Indizes , die Zeichenfolge sortieren würde s

s[... ]benutze das, um s nachzubestellen

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

Ruft für jeden Wert in der ersten Liste den entsprechenden regulären Ausdruck ab und wendet ihn auf die Eingabezeichenfolge an. Das Ergebnis ist eine Liste von Symbollisten, die dem regulären Ausdruck entsprechen. Sortieren Sie dann jeden Eintrag, verknüpfen Sie das Ergebnis zu einer Liste und transformieren Sie es in einen String.

Sie können es hier online sehen: https://ideone.com/dqAkxg

Retina , 43 39 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus. Der Zeilenvorschub am Ende ist signifikant.

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

Als Eingabe wird die Sortierreihenfolge als nullbasierte Liste ohne Begrenzer in der ersten Zeile und die zu sortierende Zeichenfolge in der zweiten Zeile erwartet, z

120
fOo42BaR

Probieren Sie es online!

Erläuterung

Ich werde das obige Eingabebeispiel verwenden, um Sie durch den Code zu führen:

120
fOo42BaR

Stufe 1: Substitution

2=`.
!$&"

Die Regex selbst ist einfach .(entspricht jedem Nicht-Zeilenvorschub-Zeichen), mit dem umgeben !...". Dies 2=ist jedoch eine Einschränkung , die Retina anweist, die Auswechslung nur auf das zweite Match der Regex anzuwenden. Also bekommen wir das:

1!2"0
fOo42BaR

Stufe 2: Transliteration

T04`¶d`#^@%

Eine Transliterationsstufe führt einfach eine zeichenweise Substitution durch. Das ¶stellt einen Zeilenumbruch dar und derweitert sich zu 0123456789(obwohl wir danach alle Ziffern ignorieren können 2). Das heißt, diese Transliteration entspricht dem folgenden Mapping:

¶012
#^@%

Die 04an der Vorderseite sind zwei Grenzen, die zusammen zeigen , dass nur die ersten vier Zeichen aus dieser Menge transkribiert werden sollen. Das sind zufällig die Ziffern in der ersten Zeile sowie der Zeilenvorschub, der die beiden Zeilen trennt.

@!%"^#fOo42BaR

Am Anfang der Zeichenfolge befinden sich nun drei Paare dieser Zeichen:

@!
%"
^#

Beachten Sie, dass die zweiten Zeichen der Paare einfach in ihrer normalen ASCII-Reihenfolge sind (und immer gleich sein werden). Wir werden diese später verwenden, um die Zeichengruppen in der Haupteingabe in der erforderlichen Reihenfolge zu sortieren.

Die ersten Zeichen sind etwas interessanter: Ihre Bedeutung liegt %vor den Ziffern in der ASCII-Tabelle, @vor den Großbuchstaben (aber nach den Ziffern) und ^vor den Kleinbuchstaben (aber nach den Großbuchstaben). Dies hilft uns, die Positionsmarkierungen (dh das zweite Zeichen in jedem Paar) mit dem richtigen Zeichensatz zu gruppieren.

Stufe 3: Sortieren

O`\W?.

Dies ist eine einfache Sortierstufe. Es stimmt mit zwei Zeichen überein, wenn das erste kein Wortzeichen ist (und damit mit allen drei Paaren, über die ich gerade gesprochen habe) oder mit einem einzelnen Zeichen (und stimmt mit jedem Zeichen der Haupteingabe einzeln überein), und sortiert diese Zeichenfolgen. Dies hat zwei Zwecke: Es bringt die Zeichen in jeder Gruppe in die richtige Reihenfolge (und da die Sortierung stabil ist, wird diese Reihenfolge in der nächsten Stufe nicht durcheinander gebracht) und %@^es fügt aufgrund der Markierungen die Paare in das Feld ein richtige positionen:

%"24@!BOR^#afo

Stufe 4: Sortieren

O`.\w+

Diese Stufe sortiert alle Übereinstimmungen des .\w+regulären Ausdrucks, die aufgrund von Gier mit einer Positionsmarkierung (dh einer von !"#) zusammen mit allen Wortzeichen danach übereinstimmen . Das heißt, es werden diese drei Zeichenfolgen sortiert, deren Reihenfolge ausschließlich durch das Markierungszeichen bestimmt wird:

"24! BOR #afo

Während dies um diese Marker schlurft (während die anderen drei Marker an Ort und Stelle bleiben), bringt es vor allem die Ziffern und Buchstaben in die richtige Reihenfolge:

%!BOR@"24^#afo

Stufe 5: Substitution

\W

Alles, was übrig bleibt, ist eine kleine Bereinigung, bei der wir alle Markierungen entfernen, indem wir sie abgleichen und durch nichts ersetzen.

JavaScript (ES6), 65

Hinweis: Die 'natürliche' ASCII-Reihenfolge ist 0-9, AZ, az, das ist genau das Gegenteil von OP 0,1,2. So

• Ordnen Sie die Zeichenfolge so an, dass ungültige Zeichen zu separaten Läufen hinzugefügt werden
• Teilen Sie es in 3 Segmente auf - ungültige Zeichen markieren jedes
• Segmente werden nacheinander in der gewünschten Reihenfolge abgerufen
• wieder zusammenbauen

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]

Anwendungsbeispiel: "cD12ab" # [2,0,1]-> "12abcD".

Wie es funktioniert:

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 hat einen Fehler gefunden. Vielen Dank! Behoben für 1 zusätzliches Byte.

Stax , 15 Bytes

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

Führen Sie es online aus und debuggen Sie es

Diese 15-Byte-Übermittlung ist in eine Variante des CP437-Zeichensatzes gepackt . Die entsprechende ASCII-Darstellung benötigt 18 Byte:

EVlVd+26/s@:fs{[Io

Ziemlich sicher, dass es weiter reduziert werden kann.

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+kann auch sein VLA|(, welches links das 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZum zehn elemenets dreht . Es kann auch der gesamte Code sein VlVd+26/,e@:f,{[Io, der den Eingabestapel zweimal liest, anstatt sie alle zu Beginn des Hauptstapels zu lesen, und ein anderes (traditionelleres) Eingabeformat verwendet, wie in dieser Abbildung gezeigt .

Dyalog APL , 22 Bytes

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

(819⌶⎕A) falten Sie das Großbuchstaben in Kleinbuchstaben

(… )⎕A⎕D[a]Untere obere Ziffern neu sortiert nach Array a

∊ ebnen

s⍋⍨für den String s erhalten Sie die Indizes, die s nach diesem "Alphabet" sortieren würden

s[... ]benutze das, um s nachzubestellen

PowerShell v2 +, 107 Byte

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

Ich erforsche Algorithmen mit Regex, aber bisher scheinen sie alle länger zu sein.

Übernimmt Eingaben als explizites Array $n(siehe Beispiele unten) und als String, $sder sofort in ein char-Array umgewandelt wird. Wir sind dann die Konstruktion drei Elemente eines neuen dynamischen Arrays, von denen jeder mit einem gekapselten -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

Das erste nehmen wir $sund laufen es durch Sort-Object. Zum Glück wird bei der Sortierung zwischen Groß- und Kleinschreibung unterschieden, da wir sie bereits als Zeichen-Array umgewandelt haben. Das wird in a gespeichert $sund dann Where-Objectmit einer Klausel größer als 97(dh ASCII-Kleinbuchstaben a-z) weitergeleitet. Der zweite ist für A-Zund der dritte für 0-9.

Somit haben wir jetzt ein Array von Zeichenfolgen, wobei jede Zeichenfolge aus einem der drei Zeichentypen besteht und sortiert ist. Wir schneiden das mit [$n]und dann-join das Ergebnis zusammen, um unsere endgültige Ausgabezeichenfolge zu bilden. Das bleibt in der Pipeline und das Drucken ist implizit.

Testfälle

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

Portiert von @Dennis Antwort.

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

Eine alternative 58-Byte-Lösung, die mir besser gefällt, die von @Neil inspiriert und leicht von seiner Antwort abgeändert wurde.

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

Probieren Sie eine der beiden Versionen online aus! (Auskommentierte Version ist die alternative Lösung)

32-Bit-x86-Computercode, 70 Byte

In hex:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

Diese Prozedur erwartet, dass die Sortierreihenfolge ESIder Zeichenklassen eine nullterminierte Zeichenfolge mit drei Zeichen (0..2) ist und dass die Zeichenfolge sortiert wird EDI. Die Sortierung erfolgt vor Ort unter Verwendung einer extrem suboptimalen (leistungsbezogenen) Version der Blasensortierung.

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

Etwas kürzer als Java ...

Clojure, 77 Bytes

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

Nicht ganz so kurz wie die re-seqBasis, und ich konnte nicht herausfinden, wie ich das " (apply str(mapcat sort(map(...))))" in weniger Raum ausdrücken kann.group-byErstellt eine Hash-Map, die als Funktion verwendet werden kann. Wenn sie mit einem Ingeger zwischen 0 und 2 abgefragt wird, gibt sie die entsprechende Gruppe zurück. Dies ordnet die drei verschiedenen Klassen von Zeichen an.

Dies wäre kompakter als die re-seqLösung, wenn mehr Zeichenklassen zu handhaben wären, da dies nur 5 zusätzliche Zeichen / Gruppen wie 57 1,anstelle von 8 für den Ausdruck wie benötigt #"[a-z]".

Python 2, 140 117 101 100 99 Bytes

Alle sagen "Ewww!". Zumindest ist es lesbar ... Husten nicht wirklich Husten

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]

Probieren Sie es online aus

R 101 Bytes

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

Erstellt einen Vektor mit az, AZ und 0-9 in der angegebenen Reihenfolge und ordnet die Zeichen der Eingabezeichenfolge entsprechend dieser Reihenfolge neu an.

Probieren Sie es online!

J, 40 Bytes

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

Java 8, 221 212 193 156 Bytes

Ich sollte natürlich auch versuchen, meine eigene Herausforderung zu beantworten. :) (Und wie üblich 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 Bytes gespart dank @cliffroot .

Erläuterung:

Probieren Sie es hier aus.

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