Seu desafio é classificar uma string, mas, em vez da ordem alfabética normal (abc..xyz), você classificará as strings por um alfabeto especificado.

Você deve escrever um programa ou função que leva duas entradas: Um alfabeto A e uma seqüência S . Ambos conterão apenas letras minúsculas em inglês e ambos conterão pelo menos um caractere.

Você deve mover as letras em S para que a letra que aparece primeiro em A apareça primeiro e, em seguida, a letra que apareça em segundo em A , etc. Pode haver algumas letras em S que não apareçam em A , que devem ser deixadas no final e não se moveu em relação um ao outro.

Casos de teste:

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

Menos bytes ganha!

05AB1E , 4 bytes

Rvy†

Experimente online!

Explicação

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 graças a ngn!

-1 byte graças a mypetlion

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

Experimente online!

Pega uma sequência como o alfabeto e uma lista de caracteres como uma sequência e classifica a lista no lugar.

Os %27garante que se o personagem não está no alfabeto, o índice voltou a coloca após o resto do alfabeto.

Haskell, 42 bytes

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

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

Tente

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

Tente

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 enorme graças a Laikoni .

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

Experimente online!

A primeira linha é uma expressão que leva dois argumentos: S e A .

Stax , 6 bytes

{xrINo

Execute e depure

Isso classifica por um bloco que faz isso.

• Inverta o alfabeto.
• Obtenha o índice de cada caractere no alfabeto invertido. Rendimentos ausentes -1.
• Negue o índice.

Python 2 , 38 bytes

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

a deve ser uma string, s uma lista de strings de comprimento 1. f classifica s no lugar.

Experimente online!

Versão alternativa, E / S de sequência, 48 bytes

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

Experimente online!

Como funciona

s.sort(None,a[::-1],1)é uma abreviação de s.sort(cmp=None,key=a[::-1],reverse=1).

Dos documentos :

reverse é um valor booleano. Se definido como True, os elementos da lista serão classificados como se cada comparação fosse revertida.

J , 5 bytes

]/:i.

Verbo diádico, levando o alfabeto à esquerda e a sequência a ser classificada à direita.

i. localiza os indeces dos caracteres da string no alfabeto, o comprimento do alfabeto, se não for encontrado.

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

/: classifica o agrument esquerdo de acordo com a ordem especificada no direito.

] o argumento certo (a string)

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

Experimente online!

Python 2 , 35 50 bytes

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

Experimente online!

Toma aes como cordas; retorna uma lista de strings singelton.

Nota: Ai! Ganhou 15 bytes para corrigir ...

K (ngn / k) , 9 bytes

{y@>-x?y}

Experimente online!

{... }é uma função com argumentos xey

x?ylocaliza para cada elemento no yíndice de sua primeira ocorrência emx ; se um elemento não for encontrado em x, seu índice será considerado 0N(-2 ⁶³ )

-nega todos os índices, exceto que mantém o 0N-s intacto, porque 2 ⁶³ ≡-2 ⁶³ (mod 2 ⁶⁴ )

> retorna uma permutação decrescente de classificação

y@índices ycom isso

Carvão vegetal , 13 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

 θ              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

Gelatina , 4 bytes

fⱮ;ḟ

Um link diádico que aceita a sequência à esquerda e o alfabeto à direita (como lista de caracteres) e retorna o resultado (também como uma lista de caracteres).

Experimente online!

Quão?

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

Função de prefixo tácito anônimo, tomando [string,ordering]como argumento.

⍋⍨/⌷⊃

Experimente online!

… / Reduza pela seguinte função:

  … ⍨ Ou seja, a versão de argumentos reversos da seguinte função:

  ⍋ classifique a corda certa de acordo com a ordem à esquerda (as letras ausentes vão no final)

⌷ use isso para indexar em…

⊃ o primeiro elemento do argumento (ou seja, a string)

JavaScript (SpiderMonkey), 50 bytes

Recebe entrada na sintaxe de curry (a)(s), em que a é uma string e s é uma matriz de caracteres. Retorna uma matriz de caracteres.

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

Experimente online!

Quão?

Definimos a função auxiliar g () como:

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

que retorna:

• 1 se c não pertencer ao alfabeto
• um valor flutuante em [-Inf, 0) com base na posição de c no alfabeto; caso contrário (-Inf, -1, -1/2, -1/3, etc.)

Classificamos s [] calculando g (b) - g (c) para cada par de caracteres (b, c) passados ​​para o retorno de chamada de sort () .

Como a implementação de sort () no SpiderMonkey é estável, todos os caracteres de s [] que não pertencem ao alfabeto são simplesmente movidos no final em ordem de aparência e permanecem inalterados quando comparados entre si.

JavaScript (ES6), 61 bytes

Recebe entrada na sintaxe de curry (a)(s), onde a e s são matrizes de caracteres. Retorna uma string.

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

Experimente online!

R , 69 62 58 bytes

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

Experimente online!

Entrada e saída são vetores de caracteres individuais.

Explicação:

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

Flacidez Cerebral (BrainHack) , 118 bytes

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

Experimente online!

Entrada é a primeira sequência, seguida por um nulo, seguida pela segunda sequência. Uma versão que usa uma nova linha como separador adiciona 24 bytes:

Flacidez Cerebral , 142 bytes

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

Experimente online!

Explicação

# 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 os espaços em branco _{(espaços e novas linhas)} no código acima são apenas para facilitar a leitura e devem ser removidos.

O dicionário é passado De tem comprimento d, a string é passada Se tem comprimento s. ie odeve ser omitido.

Experimente online!

Pitão ,  9  5 bytes

ox+vz

Experimente aqui!

ox + vz Programa completo. Formato de entrada: "S" \ n "A".
o Classifique os caracteres de S por (variável: N) ...
 x ... índice de N em ...
  + 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;}

Experimente online.

Explicação:

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 com -pF, 43 bytes

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

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

Experimente online! Exemplo de uso:

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

Limpo , 61 bytes

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

Experimente online!

Define a função $ :: [Char] [Char] -> [Char].

Sem surpresa, esta é literalmente a resposta Haskell de nimi, mas mais longa.

Geléia , 7 bytes

i@oİ$¥Þ

Experimente online!

APL + WIN, 12 bytes

Solicita a entrada na tela de S e A:

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

Experimente online! Cortesia de Dyalog Classic

PynTree , 13 bytes

§yz:ṡzCæf+yxx

Experimente online!

Resposta Python do porto de Jo King.

Explicação

§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