Nachträgliche Array-Sortierung

26

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 , 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
Kevin Cruijssen
quelle
Wäre "123"ein gültiges Format für den ersten Parameter?
Mego
@ Mego Ja, warum nicht. Der Hauptteil der Herausforderung bleibt davon unberührt. Ich habe meine Frage bearbeitet, um die Änderung widerzuspiegeln. Fühlen Sie sich frei zu verwenden 123, 012, [0,1,2], [0, 1, 2], 0;1;2oder was immer Sie bevorzugen.
Kevin Cruijssen

Antworten:

5

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

Adnan
quelle
Dies können jetzt 10 Bytes sein, indem Sie das ²und using anstelle von entfernen 26.
Kevin Cruijssen
8

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 .

Dennis
quelle
7

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``
Neil
quelle
3
Oh, sehr interessante Lösung! Ich dachte an eine andere ES6-Antwort, um Array.sortden optionalen Funktionsparameter zu verwenden, aber das ist viel besser.
Charredgrass
1
Ich mag diese Lösung wirklich, aber ich denke, dass sie Test 2, 3 und wahrscheinlich andere nicht besteht. Ich vermute, Sie sollen jedes der drei Segmente sortieren?
Charlie Wynn
@CharlieWynn Entschuldigung, ich muss die Frage falsch verstanden haben. (Es ist ein häufiger Fehler von mir.)
Neil
@Neil, ich glaube nicht, dass die Frage es sehr klar machte, das Array zu sortieren, bemerkte nur, dass die Testfälle diese Funktion zu haben schienen.
Charlie Wynn
@CharlieWynn Die meisten Testfälle schienen ohnehin schon nach unteren / oberen / numerischen Teilen sortiert zu sein ...
Neil
5

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.
Dennis
quelle
5

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!

Türknauf
quelle
Sie können 'UTanstelle von verwenden s'MT.
Jakube
@Jakube Ich verwende ein Backtick, kein einziges Anführungszeichen. Ist 'UTaber ein Fehler und `UTführt nicht zur selben Zeichenfolge.
Türklinke
Ja, ich meinte einen Backtick. Aber ein Backtick ist in den Kommentaren schwer zu schreiben. Ja, es wird eine andere Zeichenfolge generiert, aber es sollte keine Rolle spielen. Die generierte Zeichenfolge enthält alle Ziffern und keine Buchstaben.
Jakube
@ Jakube Oh, ich verstehe. Das ist schlau; Vielen Dank!
Türklinke
5

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"
Charlie Wynn
quelle
Stola @ Neil sehr ordentlich Regex Array Idee
Charlie Wynn
Durch Hinzufügen von ?s zu jedem regulären Ausdruck wird sichergestellt, dass die Übereinstimmung Ergebnisse zurückgibt (meist leere Zeichenfolgen, die jedoch trotzdem verschwinden), wodurch (||[])insgesamt 3 Byte gespart werden.
Neil
@Neil wunderbar, danke .. Ich war mir nicht sicher, warum Sie die in Ihrem hatten: P
Charlie Wynn
4

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

t-clausen.dk
quelle
3

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

Adam
quelle
Schade, dass Dyalog APL kein ⎕a hat und die Übersetzung von Groß- zu Kleinbuchstaben eine Menge Bytes in Anspruch nimmt :-) Nicht, dass ich nicht vorschlage, dass Dyalog APL ⎕a enthält, da seine Nützlichkeit ziemlich eingeschränkt wäre zu Code-Golf-Herausforderungen, soweit ich das beurteilen kann.
Lstefano
@lstefano gefällt mir nicht ⎕a, da es sich um einen Quad-Namen handelt, bei dem die Groß- und Kleinschreibung beachtet wird. Viel besser (zum Golfen und im Allgemeinen), wofür ich Lobbying betreibe; Groß- und Kleinschreibung auf Charakterdaten zu bekommen und zu klappen, genau wie in K. Dann haben wir ⌊⎕Astatt ⎕a.
Adám
2

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],[]))
Jeremy
quelle
2

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

Cliffroot
quelle
2

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.

Martin Ender
quelle
2

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+')'))
})

edc65
quelle
2

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.

nimi
quelle
Was ist mit Zeichen, die mehr als einmal vorkommen?
Christian Sievers
@ChristianSievers: Du hast recht, das ist ein Fehler. Fest. Danke!
Nimi
2

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 .

Weijun Zhou
quelle
1

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

Adam
quelle
mmm .... 819⌶ existiert nur in der Unicode-Version von Dyalog APL. Daher würde ich vermuten, dass die Byteanzahl mit 2 multipliziert werden sollte, da die Eingabe effektiv aus Unicode-Einstiegspunkten besteht. Ist mein Verständnis der Byteanzahl für APL-Übermittlungen falsch?
Lstefano
@lstefano Die Unicode-Edition kann klassische Arbeitsbereiche laden, oder?
Adám
Das ist hinterhältig ;-)
lstefano
1

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
AdmBorkBork
quelle
1

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)

Wert Tinte
quelle
1

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
meden
quelle
1

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

Lord Yuuma
quelle
1

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]".

NikoNyrh
quelle
1

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

mbomb007
quelle
1

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!

Robert Hacken
quelle
0

J, 40 Bytes

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

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
Kevin Cruijssen
quelle
1
Sie können Ihre regulären Ausdrücke durch ersetzen [^a-z] [^A-Z] [^0-9]und getBytes()stattdessentoCharArray()
cliffroot
@ Cliffroot Danke. Ich bin ziemlich schlecht in Regexes, aber nicht mit der ^(nicht) war ziemlich dumm ..;)
Kevin Cruijssen
1
replaceAllString c(int[]a,String z){String r[]={"[^a-z]","[^A-Z]","[^0-9]"},o="";for(byte c[],i=0;i<3;){c=z.replaceAll(r[a[i++]],"").getBytes();java.util.Arrays.sort(c);o+=new String(c);}return o;}
Entfernt sich