Ihre Herausforderung besteht darin, eine Zeichenfolge zu sortieren. Statt nach der normalen alphabetischen Reihenfolge (abc..xyz) sortieren Sie Zeichenfolgen nach einem bestimmten Alphabet.

Sie müssen ein Programm oder eine Funktion schreiben , die zwei Eingänge nehmen: Ein Alphabet A und einen String S . Beide enthalten nur englische Kleinbuchstaben und beide enthalten mindestens ein Zeichen.

Sie müssen Buchstaben in S so verschieben, dass der Buchstabe, der zuerst in A erscheint, zuerst erscheint, dann der Buchstabe, der an zweiter Stelle in A erscheint usw. In S können einige Buchstaben vorkommen , die in A nicht vorkommen . Diese müssen am Ende und links bleiben nicht relativ zueinander bewegt.

Testfälle:

A       S               Result
axd     haxuizzxaxduxha aaaxxxxdhuizzuh
a       xyz             xyz
abc     dcba            abcd
il      nmiuplliu       iillnmupu
asdf    qwerty          qwerty

Wenigste Bytes gewinnt!

05AB1E , 4 Bytes

Rvy†

Probieren Sie es online!

Erläuterung

R     # Reverse the alphabet
 vy   # For each letter ...
   †  # Push S with the current letter filtered to the front

Python 3 , 50 47 46 44 Bytes

-3 Bytes dank ngn!

-1 Byte dank mypetlion

lambda a,s:s.sort(key=lambda c:a.find(c)%27)

Probieren Sie es online!

Übernimmt eine Zeichenfolge als Alphabet und eine Liste von Zeichen als Zeichenfolge und sortiert die Liste an der richtigen Stelle.

Die %27stellt sicher , dass , wenn das Zeichen nicht im Alphabet, kehrte der Index legt es nach dem Rest des Alphabets.

Haskell, 42 Bytes

a#s=[c|c<-a,d<-s,c==d]++[c|c<-s,all(/=c)a]

Probieren Sie es online!

a#s=                     -- take alphabet a and string s
        c<-a             -- for all c in a
             d<-s        --   for all d in s
    [c|       c==d]             keep c if c equals d
   ++                    -- append
    [c|c<-s        ]     --   all c of s
         ,all(/=c)a      --   that are not in a 

Perl 6 ,  55  43 Bytes

->\A,\S{[~] S.comb.sort:{%(A.comb.antipairs){$_}//∞}}

Versuch es

->\A,\S{[~] S.comb.sort:{A.index($_)//∞}}

Versuch es

Erweitert:

-> \A, \S {
  [~]  # reduce using &infix:«~» (shorter than `.join`)

    S.comb.sort: # split into character list and sort by:

      {  # bare block lambda with implicit parameter $_

        A.index( $_ ) # get the position

        //  # if it is undefined (not in `A`)
        ∞   # return Inf instead (so it comes at end of result)
      }
}

Haskell , 40 34 Bytes

-6 Bytes riesig dank Laikoni .

foldr(\c->r(==c)<>r(/=c))
r=filter

Probieren Sie es online!

Die erste Zeile ist ein Ausdruck der zwei Argumente nimmt: S und A .

Stax , 6 Bytes

{xrINo

Führen Sie es aus und debuggen Sie es

Dies wird nach einem Block sortiert, der dies tut.

• Kehre das Alphabet um.
• Holen Sie sich den Index jedes Zeichens im umgekehrten Alphabet. Fehlende Erträge -1.
• Negiere den Index.

Python 2 , 38 Bytes

def f(a,s):s.sort(None,a[::-1].find,1)

a muss eine Zeichenfolge sein, s eine Liste von Zeichenfolgen der Länge 1. f sortiert s an der richtigen Stelle.

Probieren Sie es online!

Alternative Version, Zeichenfolgen-E / A, 48 Byte

lambda a,s:`sorted(s,None,a[::-1].find,1)`[2::5]

Probieren Sie es online!

Wie es funktioniert

s.sort(None,a[::-1],1)ist eine Abkürzung für s.sort(cmp=None,key=a[::-1],reverse=1).

Aus den Dokumenten :

reverse ist ein boolescher Wert. Wenn auf gesetzt True, werden die Listenelemente so sortiert, als ob jeder Vergleich umgekehrt wäre.

J , 5 Bytes

]/:i.

Dyadisches Verb, wobei das Alphabet links und die zu sortierende Zeichenfolge rechts steht.

i. Findet die Unregelmäßigkeiten der Zeichen des Strings im Alphabet, die Länge des Alphabets, falls nicht gefunden.

   'axd' i. 'haxuizzxaxduxha'
3 0 1 3 3 3 3 1 0 1 2 3 1 3 0

/: sortiert das linke Agrument in der Reihenfolge, in der es auf der rechten Seite angegeben ist.

] das richtige Argument (der String)

  'haxuizzxaxduxha' /: 3 0 1 3 3 3 3 1 0 1 2 3 1 3 0
aaaxxxxdhuizzuh

Probieren Sie es online!

Python 2 , 35-50 Bytes

lambda a,s:sorted(s,key=lambda c:-a[::-1].find(c))

Probieren Sie es online!

Takes aund sals Streicher; Gibt eine Liste von Singelton-Strings zurück.

Hinweis: Autsch! Gewonnen 15 Bytes zu beheben ...

K (ngn / k) , 9 Bytes

{y@>-x?y}

Probieren Sie es online!

{... }ist eine Funktion mit Argumenten xundy

x?yfindet für jedes Element im yIndex sein erstes Vorkommen in x; Wird ein Element in nicht gefunden x, wird sein Index berücksichtigt 0N(-2 ⁶³ ).

-negiert alle Indizes, außer dass das 0N-s intakt bleibt, weil 2 ⁶³ 63-2 ⁶³ (mod 2 ⁶⁴ )

> Gibt eine absteigende Permutation zurück

y@Indizes ydamit

Kohle , 13 Bytes

Ｆθ×ι№ηιΦη¬№θι

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

 θ              First input
Ｆ               Loop over characters
     η          Second input
      ι         Current character
    №           Count matches
   ι            Current character
  ×             Repeat
                Implicitly print
        η       Second input
       Φ        Filter
           θ    First input
            ι   Current character
          №     Count matches
         ¬      Logical not
                Implicitly print non-matching characters

Gelee , 4 Bytes

fⱮ;ḟ

Ein dyadischer Link, der die Zeichenfolge links und das Alphabet rechts (als Liste von Zeichen) akzeptiert und das Ergebnis (auch als Liste von Zeichen) zurückgibt.

Probieren Sie es online!

Wie?

fⱮ;ḟ - Link: string; alphabet                                    e.g. smallnotxl; xl
 Ɱ   - map (for each character in the alphabet):                      1=x; 2=l
f    -   filter keep (keep occurrences of this character from string)   x    lll -> xlll
   ḟ - filter discard (discard all alphabet characters from string)   smanot
  ;  - concatenate                                                    xlllsmanot

APL (Dyalog Unicode) , 5 Byte ^SBCS

Anonyme implizite Präfixfunktion [string,ordering]als Argument.

⍋⍨/⌷⊃

Probieren Sie es online!

… / Reduzieren Sie um folgende Funktion:

  … ⍨ Und zwar die Version der folgenden Funktion mit umgekehrten Argumenten:

  ⍋ bewerte die rechte Saite in der linken Reihenfolge (fehlende Buchstaben stehen am Ende)

⌷ Verwenden Sie das, um zu indizieren ...

⊃ das erste Element des Arguments (dh die Zeichenfolge)

JavaScript (SpiderMonkey), 50 Byte

Nimmt Eingaben in der aktuellen Syntax vor (a)(s), wobei a eine Zeichenfolge und s ein Array von Zeichen ist. Gibt ein Array von Zeichen zurück.

a=>s=>s.sort((b,c)=>(g=c=>-1/a.search(c))(b)-g(c))

Probieren Sie es online!

Wie?

Wir definieren die Hilfsfunktion g () als:

c => -1 / a.search(c)

was zurückgibt:

• 1, wenn c nicht zum Alphabet gehört
• ein Gleitkommawert in [-Inf, 0), der ansonsten auf der Position von c im Alphabet basiert (-Inf, -1, -1/2, -1/3 usw.)

Wir sortieren s [], indem wir g (b) - g (c) für jedes Zeichenpaar (b, c) berechnen , das an den Rückruf von sort () übergeben wird .

Da die Implementierung von sort () in SpiderMonkey stabil ist, werden alle Zeichen von s [] , die nicht zum Alphabet gehören, einfach in der Reihenfolge ihres Erscheinens am Ende verschoben und beim Vergleich unverändert gelassen.

JavaScript (ES6), 61 Byte

Nimmt Eingaben in der aktuellen Syntax vor (a)(s), wobei sowohl a als auch s Arrays von Zeichen sind. Gibt eine Zeichenfolge zurück.

a=>s=>a.map(C=>s=s.filter(c=>c!=C||!(o+=c)),o='')&&o+s.join``

Probieren Sie es online!

R , 69 62 58 Bytes

function(a,s)c(rep(a,rowSums(outer(a,s,"=="))),s[!s%in%a])

Probieren Sie es online!

Ein- und Ausgabe sind Vektoren einzelner Zeichen.

Erläuterung:

function(a,s)c(                              ,           ) #combine:
                   a,                                      #[each char in a
               rep(                                        #each repeated
                     rowSums(               )              #the number of
                             outer(a,s,"==")               #occurrence in s]
                                              s            #with s
                                               [ s%in%a]   #all chars in a
                                                !          #omitted

Brain-Flak (BrainHack) , 118 Bytes

{({}(<>))<>}{}<>{<>([[]()]<{<>(({})<({}<>[({}<>)]){(<()>)}{}{}>)<>}<>({}<{({}<>)<>}<>>)>[]){({}()<(({}))>)}{}{}<>{}}<>

Probieren Sie es online!

Die Eingabe ist die erste Zeichenfolge, gefolgt von einer Null, gefolgt von der zweiten Zeichenfolge. Eine Version, die eine neue Zeile als Trennzeichen verwendet, fügt stattdessen 24 Bytes hinzu:

Brain-Flak , 142 Bytes

(()){{}(({}(<>))[(()()()()()){}]<>)}{}<>{<>([[]()]<{<>(({})<({}<>[({}<>)]){(<()>)}{}{}>)<>}<>({}<{({}<>)<>}<>>)>[]){({}()<(({}))>)}{}{}<>{}}<>

Probieren Sie es online!

Erläuterung

# Move A to other stack reversed
# Zeroes are pushed under each character for later.
# (This is the only part that needs to change in order to use newline as separator.)
{({}(<>))<>}{}<>

# For each character in A, starting at the end:
{

  # Track current length of S.
  <>([[]()]<

    # For each character in S:
    {

      # While keeping character from A
      <>(({})<

        # Move character from S to second stack and push difference
        ({}<>[({}<>)])

        # Delete character if equal
        {(<()>)}{}{}

      >)

    <>}

    # Move S back to first stack while maintaining character from A
    <>({}<{({}<>)<>}<>>)

  # Push difference between old and new lengths of S
  >[])

  # Insert character from A at beginning of S that many times
  {({}()<(({}))>)}{}{}

<>{}}<>

C (gcc) 97 Bytes

f(D,d,S,s,i,o)char*D,*S;{
  while(d--){
    for(i=o=s;i--;)S[i]-D[d]?S[--o]=S[i]:0;
    while(o--)S[o]=D[d];
  }
}

Alle Leerzeichen _{(Leerzeichen und Zeilenumbrüche)} im obigen Code dienen nur der Lesbarkeit und sollten entfernt werden.

Das Wörterbuch wird übergeben D und hat Länge d, die Zeichenfolge wird übergeben Sund hat Länge s. iund osollte weggelassen werden.

Probieren Sie es online!

Pyth ,  9  5 Bytes

ox+vz

Probieren Sie es hier aus!

ox + vz Volles Programm. Eingabeformat: "S" \ n "A".
o Sortiere die Zeichen von S nach (Variable: N) ...
 x ... Ns Index in ...
  + vz ... A + N

Java 8, 98 Bytes

a->s->{for(int i=a.length;i-->0;s=s.replaceAll("[^"+a[i]+"]","")+s.replaceAll(a[i],""));return s;}

Probieren Sie es online aus.

Erläuterung:

a->s->{       // Method with String-array and String parameters, and String return-type
  for(int i=a.length;i-->0;
              //  Loop backwards over the alphabet
    s=        //   Replace the current `s` with:
      s.replaceAll("[^"+a[i]+"]","") 
              //    All the current characters of `a` in `s`
      +s.replaceAll(a[i],""));
              //    Concatted with everything else
  return s;}  //  Return the modified `s`

Perl 5 mit -pF43 Bytes

$_=<>;print$F[0]x s/@{[shift@F]}//g while@F

Probieren Sie es online!

Prolog (SWI) , 136 Bytes

X/_/[X|_].
X/Y/[Z|R]:-Y\=Z,X/Y/R.
i(_,X,[],[X]).
i(A,X,[Y|R],[X,Y|R]):-X/Y/A.
i(A,X,[Y|R],[Y|S]):-i(A,X,R,S).
A*S*T:-foldl(i(A),S,[],T).

Probieren Sie es online! Anwendungsbeispiel:

[i,l]*[n,m,i,u,p,l,l,i,u]*S.
S = [i, i, l, l, n, m, u, p, u]

Sauber , 61 Bytes

import StdEnv
$a s=[c\\c<-a,k<-s|k==c]++[c\\c<-s|all((<>)c)a]

Probieren Sie es online!

Definiert die Funktion $ :: [Char] [Char] -> [Char].

Es überrascht nicht, dass dies buchstäblich Nimis Haskell-Antwort ist, jedoch länger.

Gelee , 7 Bytes

i@oİ$¥Þ

Probieren Sie es online!

APL + WIN, 12 Bytes

Fordert zur Eingabe des Bildschirms von S und dann von A auf:

s[(,⎕)⍋s←,⎕]

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

PynTree , 13 Bytes

§yz:ṡzCæf+yxx

Probieren Sie es online!

Port of Jo Kings Python Antwort.

Erläuterung

§yz:ṡzCæf+yxx  Anonymous lambda
§              lambda  ,
 y                    y
  z                     z
   :                     :
    ṡ                     sorted( ,lambda x:
     z                           z
      C                                     (          )( )
       æf                                    (   ).find
         +                                     +
          y                                   y
           x                                    x
            x                                            x