Su desafío es ordenar una cadena, pero en lugar de hacerlo por el orden alfabético normal (abc..xyz), ordenará las cadenas por un alfabeto específico.

Usted debe escribir un programa o función que toma dos entradas: Un alfabeto A y una cadena S . Ambos solo contendrán letras minúsculas en inglés, y ambos contendrán al menos un carácter.

Debe mover las letras en S para que la letra que aparece primero en A aparezca primero, luego la letra que aparezca segunda en A , etc. Puede haber algunas letras en S que no aparecen en A , estas deben dejarse al final y No se mueven uno con respecto al otro.

Casos de prueba:

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

¡Pocos bytes ganan!

05AB1E , 4 bytes

Rvy†

Pruébalo en línea!

Explicación

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 gracias a ngn!

-1 byte gracias a mypetlion

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

Pruébalo en línea!

Toma una cadena como el alfabeto y una lista de caracteres como la cadena y ordena la lista en su lugar.

Esto %27garantiza que si el carácter no está en el alfabeto, el índice devuelto lo coloca después del resto del alfabeto.

Haskell, 42 bytes

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

Pruébalo en línea!

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){$_}//∞}}

Intentalo

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

Intentalo

Expandido:

-> \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 enormes gracias a Laikoni .

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

Pruébalo en línea!

La primera línea es una expresión que toma dos argumentos: S y A .

Stax , 6 bytes

{xrINo

Ejecutar y depurarlo

Esto ordena por un bloque que hace esto.

• Invierte el alfabeto.
• Obtenga el índice de cada personaje en el alfabeto invertido. Falta rendimiento -1.
• Negar el índice.

Python 2 , 38 bytes

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

a debe ser una cadena, s una lista de cadenas de longitud 1. f ordena s en su lugar.

Pruébalo en línea!

Versión alternativa, cadena de E / S, 48 bytes

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

Pruébalo en línea!

Cómo funciona

s.sort(None,a[::-1],1)es la abreviatura s.sort(cmp=None,key=a[::-1],reverse=1).

De los documentos :

El reverso es un valor booleano. Si se establece en True, los elementos de la lista se ordenan como si se invirtiera cada comparación.

J , 5 bytes

]/:i.

Verbo diádico, tomando el alfabeto a su izquierda y la cuerda a clasificar a la derecha.

i. encuentra las indecesiones de los caracteres de la cadena en el alfabeto, la longitud del alfabeto si no se encuentra.

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

/: ordena su grupo izquierdo de acuerdo con el orden especificado en el derecho.

] el argumento correcto (la cadena)

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

Pruébalo en línea!

Python 2 , 35 50 bytes

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

Pruébalo en línea!

Toma ay scomo cuerdas; devuelve una lista de cadenas de singelton.

Nota: ¡Ay! Ganó 15 bytes para arreglar ...

K (ngn / k) , 9 bytes

{y@>-x?y}

Pruébalo en línea!

{... }es una función con argumentos xyy

x?yencuentra para cada elemento en yel índice de su primera aparición en x; si no se encuentra un elemento x, se considera su índice 0N(-2 ⁶³ )

-niega todos los índices excepto que mantiene el 0N-s intacto, porque 2 ⁶³ 2-2 ⁶³ (mod 2 ⁶⁴ )

> devuelve una permutación de tipo descendente

y@índices ycon eso

Carbón , 13 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 θ              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

Jalea , 4 bytes

fⱮ;ḟ

Un enlace diádico que acepta la cadena a la izquierda y el alfabeto a la derecha (como listas de caracteres) y devuelve el resultado (también como una lista de caracteres).

Pruébalo en línea!

¿Cómo?

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) , ^{SBCS de} 5 bytes

Función de prefijo tácito anónimo, tomando [string,ordering]como argumento.

⍋⍨/⌷⊃

Pruébalo en línea!

... / Reducir con la siguiente función:

  ... a ⍨ saber, la versión de argumentos invertidos de la siguiente función:

  ⍋ califique la cadena derecha de acuerdo con el orden izquierdo (las letras que faltan van al final)

⌷ usar eso para indexar en ...

⊃ el primer elemento del argumento (es decir, la cadena)

JavaScript (SpiderMonkey), 50 bytes

Toma entrada en la sintaxis de curry (a)(s), donde a es una cadena y s es una matriz de caracteres. Devuelve una matriz de caracteres.

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

Pruébalo en línea!

¿Cómo?

Definimos la función auxiliar g () como:

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

que devuelve:

• 1 si c no pertenece al alfabeto
• un valor flotante en [-Inf, 0) basado en la posición de c en el alfabeto de lo contrario (-Inf, -1, -1/2, -1/3, etc.)

Ordenamos s [] calculando g (b) - g (c) para cada par de caracteres (b, c) pasados ​​a la devolución de llamada de sort () .

Debido a que la implementación de sort () en SpiderMonkey es estable, todos los caracteres de s [] que no pertenecen al alfabeto simplemente se mueven al final en orden de aparición y se dejan sin cambios cuando se comparan entre sí.

JavaScript (ES6), 61 bytes

Toma entrada en la sintaxis de curry (a)(s), donde a y s son matrices de caracteres. Devuelve una cadena.

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

Pruébalo en línea!

R , 69 62 58 bytes

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

Pruébalo en línea!

La entrada y la salida son vectores de caracteres individuales.

Explicación:

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

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

Pruébalo en línea!

La entrada es la primera cadena, seguida de un valor nulo, seguido de la segunda cadena. Una versión que utiliza una nueva línea como separador agrega 24 bytes:

Brain-Flak , 142 bytes

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

Pruébalo en línea!

Explicación

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

Todos los espacios en blanco _{(espacios y líneas nuevas)} en el código anterior son solo para _facilitar la lectura y deben eliminarse.

El diccionario se pasa Dy tiene longitud d, la cadena se pasa Sy tiene longitud s. iy odebe ser omitido

Pruébalo en línea!

Pyth ,  9  5 bytes

ox+vz

Pruébalo aquí!

ox + vz Programa completo. Formato de entrada: "S" \ n "A".
o Ordenar los caracteres de S por (variable: N) ...
 x ... índice de N en ...
  + 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;}

Pruébalo en línea.

Explicación:

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 con -pF43 bytes

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

Pruébalo en línea!

Prólogo (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).

Pruébalo en línea! Ejemplo de uso:

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

Limpiar , 61 bytes

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

Pruébalo en línea!

Define la función $ :: [Char] [Char] -> [Char].

Como era de esperar, esta es literalmente la respuesta Haskell de nimi, pero más larga.

Jalea , 7 bytes

i@oİ$¥Þ

Pruébalo en línea!

APL + WIN, 12 bytes

Solicita la entrada de pantalla de S y luego A:

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

Pruébalo en línea! Cortesía de Dyalog Classic.

PynTree , 13 bytes

§yz:ṡzCæf+yxx

Pruébalo en línea!

Port of Jo King's Python answer.

Explicación

§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