O desafio é criar um programa que classifique uma lista de palavras, apenas que as palavras precisem estar na ordem de um determinado alfabeto aleatório.

Seu programa aceitará uma sequência de palavras separadas por vírgula e um novo alfabeto.
Seu programa produzirá cada palavra da mesma maneira na nova ordem classificada.

Exemplo:

Entrada:

home,oval,cat,egg,network,green bcdfghijklmnpqrstvwxzaeiouy

Resultado:

cat,green,home,network,egg,oval

Este é um código de golfe , então o vencedor é a pessoa com o programa mais curto.

Este é o meu primeiro desafio, portanto, qualquer melhoria na pergunta / desafio é apreciada.

CJam, 26 19 17 bytes

rr:A;',/{Af#}$',*

Experimente online.

Caso de teste

$ cjam sort.cjam <<< 'home,oval,cat,egg,network,green bcdfghjklmnpqrstvwxzaeiouy'
cat,green,home,network,egg,oval

Como funciona

rr                    " Read two whitespace-separated tokens from STDIN. ";
  :A;                 " Save the second token (the alphabet) in A.       ";
     ',/              " Split the remaining token at commas.             ";
        {Af#}$        " Sort by the chunks' characters' indexes in A.    ";
               ',*    " Join, separating by commas.                      ";

Bash + coreutils, 37 bytes

tr ,$2 \\na-z<<<$1|sort|tr \\na-z ,$2

Resultado:

$ ./alphasort.sh home,oval,cat,egg,network,green bcdfghijklmnpqrstvwxyzaeiouy
cat,green,home,network,egg,oval, $ 

Pitão , 19 caracteres

j\,o_mx_zdNchczd\,

Teste:

$ pyth -c "j\,o_mx_zdNchczd\," <<< 'home,oval,cat,egg,network,green bcdfghjklmnpqrstvwxzaeiouy'
cat,green,home,network,egg,oval

Explicação:

                            Implicit: d=" "
                            Implicit: z=input()
j\,                         ",".join(
   o                                 order_by(lambda N:
    _                                                  rev(
     m                                                     map(lambda d:
      x_zd                                                              rev(z).index(d),
      N                                                                 N),
    chczd\,                                            z.split(" "[0].split(",")

Essencialmente, ele classifica os pedaços, com uma chave da lista de índices dos caracteres na sequência, e os une por vírgulas. Os negócios de reversão são mais curtos do que dividir a corda novamente.

Ruby, 53 50 bytes

a,b=$*
$><<a.split(?,).sort_by{|w|w.tr b,'a-z'}*?,

Estou usando o Ruby trpara substituir o alfabeto personalizado a-zantes de classificar. A entrada é via argumento da linha de comando.

Python, 131

w,a=input().split()
print(",".join(sorted(w.split(","),key=lambda s:"".join(["abcdefghijklmnopqrstuvwxyz"[a.find(c)]for c in s]))))

Deve haver muito espaço para melhorias.

JavaScript (E6) 102 119

Classifique com uma função de mapeamento 'M' com base no alfabeto na variável 'a'
Com E / S usando pop-up (prompt + alerta)

x=prompt().split(/[ ,]/),
a=x.pop(),
M=w=>[10+a.search(c)for(c of w)]+'',
alert(x.sort((a,b)=>M(a)>M(b)))

Como uma função (testável) com 1 parâmetro de sequência, retornando uma matriz de sequências (92)

F=x=>(
  M=w=>[10+a.search(c)for(c of w)],
  x=x.split(/[ ,]/),
  a=x.pop(),
  x.sort((a,b)=>M(a)>M(b))
)

Teste no console do FireFox / FireBug

F('home,oval,cat,egg,network,green zyxwvtsrqpnmlkjhgfdcbaeiou')

Resultado

["network", "home", "green", "cat", "egg", "oval"]

Clojure, 115 bytes

#(apply str(butlast(interleave(sort-by(fn[w](apply str(map(zipmap(sort %2)%2)w)))(re-seq #"[a-z]+"%))(repeat \,))))

Uau, isso começou bem, (sort-by(fn[w](mapv(zipmap(sort %2)%2)w)))mas então percebi vecque não são classificados da mesma maneira que as strings, e intercalar essas vírgulas também requer uma quantidade significativa de código.