Votre défi consiste à trier une chaîne, mais plutôt que par ordre alphabétique normal (abc..xyz), vous trierez les chaînes par alphabet spécifié.

Vous devez écrire un programme ou une fonction qui prend deux entrées: un alphabet A et une chaîne S . Les deux ne contiendront que des lettres anglaises en minuscules et les deux contiendront au moins un caractère.

Vous devez déplacer les lettres en S pour que la lettre qui apparaît en premier en A apparaisse en premier, puis la lettre qui apparaît en second en A , etc. Il peut y avoir des lettres en S qui n'apparaissent pas en A , celles-ci doivent être laissées à la fin et pas déplacé les uns par rapport aux autres.

Cas de test:

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

Le moins d'octets gagne!

05AB1E , 4 octets

Rvy†

Essayez-le en ligne!

Explication

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

Python 3 , 50 47 46 44 octets

-3 octets grâce à ngn!

-1 octet grâce à mypetlion

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

Essayez-le en ligne!

Prend une chaîne comme alphabet et une liste de caractères comme chaîne et trie la liste en place.

Le %27garantit que si le caractère n'est pas dans l'alphabet, l'index renvoyé le place après le reste de l'alphabet.

Haskell, 42 octets

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

Essayez-le en ligne!

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 octets

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

Essayez-le

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

Essayez-le

Étendu:

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

-6 octets énormes merci à Laikoni .

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

Essayez-le en ligne!

La première ligne est une expression qui prend deux arguments: S et A .

Stax , 6 octets

{xrINo

Exécuter et déboguer

Cela trie par un bloc qui fait cela.

• Inversez l'alphabet.
• Obtenez l'index de chaque caractère dans l'alphabet inversé. Rendements manquants -1.
• Niez l'index.

Python 2 , 38 octets

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

a doit être une chaîne, s une liste de chaînes de longueur 1. f trie s en place.

Essayez-le en ligne!

Version alternative, chaîne d'E / S, 48 octets

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

Essayez-le en ligne!

Comment ça marche

s.sort(None,a[::-1],1)est un raccourci pour s.sort(cmp=None,key=a[::-1],reverse=1).

De la documentation :

reverse est une valeur booléenne. S'il est défini sur True, les éléments de la liste sont triés comme si chaque comparaison était inversée.

J , 5 octets

]/:i.

Verbe dyadique, prenant l'alphabet à gauche et la chaîne à trier à droite.

i. trouve les indéces des caractères de la chaîne dans l'alphabet, la longueur de l'alphabet si elle n'est pas trouvée.

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

/: trie son agrément gauche selon l'ordre spécifié dans celui de droite.

] l'argument droit (la chaîne)

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

Essayez-le en ligne!

Python 2 , 35 50 octets

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

Essayez-le en ligne!

Prend aet scomme cordes; renvoie une liste de chaînes singelton.

Remarque: Ouch! A gagné 15 octets pour corriger ...

K (ngn / k) , 9 octets

{y@>-x?y}

Essayez-le en ligne!

{... }est une fonction avec des arguments xety

x?ytrouve pour chaque élément dans yl'index de sa première occurrence dans x; si un élément n'est pas trouvé dans x, son indice est pris en compte 0N(-2 ⁶³ )

-annule tous les indices sauf qu'il garde les 0N-s intacts, car 2 ⁶³ ≡-2 ⁶³ (mod 2 ⁶⁴ )

> renvoie une permutation de tri décroissant

y@index yavec cela

Fusain , 13 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

 θ              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

Gelée , 4 octets

fⱮ;ḟ

Un lien dyadique acceptant la chaîne à gauche et l'alphabet à droite (sous forme de listes de caractères) et renvoyant le résultat (également sous forme de liste de caractères).

Essayez-le en ligne!

Comment?

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 octets ^SBCS

Fonction de préfixe tacite anonyme, prenant [string,ordering]comme argument.

⍋⍨/⌷⊃

Essayez-le en ligne!

… / Réduisez de la fonction suivante:

  … À ⍨ savoir la version à arguments inversés de la fonction suivante:

  ⍋ noter la chaîne de droite selon l'ordre de gauche (les lettres manquantes vont à la fin)

⌷ utiliser cela pour indexer dans ...

⊃ le premier élément de l'argument (c'est-à-dire la chaîne)

JavaScript (SpiderMonkey), 50 octets

Prend des entrées dans la syntaxe de curry (a)(s), où a est une chaîne et s est un tableau de caractères. Renvoie un tableau de caractères.

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

Essayez-le en ligne!

Comment?

Nous définissons la fonction d'aide g () comme:

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

qui renvoie:

• 1 si c n'appartient pas à l'alphabet
• une valeur flottante dans [-Inf, 0) basée sur la position de c dans l'alphabet sinon (-Inf, -1, -1/2, -1/3, etc.)

Nous trions s [] en calculant g (b) - g (c) pour chaque paire de caractères (b, c) passée au rappel de sort () .

Étant donné que l'implémentation de sort () dans SpiderMonkey est stable, tous les caractères de s [] qui n'appartiennent pas à l'alphabet sont simplement déplacés à la fin dans l'ordre d'apparition et sont laissés inchangés lorsqu'ils sont comparés les uns aux autres.

JavaScript (ES6), 61 octets

Prend une entrée dans la syntaxe de curry (a)(s), où a et s sont des tableaux de caractères. Renvoie une chaîne.

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

Essayez-le en ligne!

R , 69 62 58 octets

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

Essayez-le en ligne!

L'entrée et la sortie sont des vecteurs de caractères individuels.

Explication:

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 octets

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

Essayez-le en ligne!

L'entrée est la première chaîne, suivie d'une valeur nulle, suivie de la deuxième chaîne. Une version qui utilise une nouvelle ligne comme séparateur ajoute à la place 24 octets:

Brain-Flak , 142 octets

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

Essayez-le en ligne!

Explication

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

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];
  }
}

Tous les espaces _{(espaces et sauts de ligne)} dans le code ci-dessus sont uniquement à des fins de lisibilité et doivent être supprimés.

Le dictionnaire est passé Det a une longueur d, la chaîne est passée Set a une longueur s. iet odoit être omis.

Essayez-le en ligne!

Pyth ,  9  5 octets

ox+vz

Essayez-le ici!

programme complet ox + vz. Format d'entrée: "S" \ n "A".
o Trier les caractères de S par (variable: N) ...
 x ... Index de N dans ...
  + vz ... A + N

Java 8, 98 octets

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

Essayez-le en ligne.

Explication:

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 avec -pF, 43 octets

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

Essayez-le en ligne!

Prolog (SWI) , 136 octets

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

Essayez-le en ligne! Exemple d'utilisation:

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

Nettoyer , 61 octets

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

Essayez-le en ligne!

Définit la fonction $ :: [Char] [Char] -> [Char].

Sans surprise, c'est la réponse Haskell de nimi mais plus longtemps.

Gelée , 7 octets

i@oİ$¥Þ

Essayez-le en ligne!

APL + WIN, 12 octets

Invite à saisir à l'écran S puis A:

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

Essayez-le en ligne! Gracieuseté de Dyalog Classic

PynTree , 13 octets

§yz:ṡzCæf+yxx

Essayez-le en ligne!

Réponse de Python du port de Jo King.

Explication

§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