El desafío es hacer un programa que clasifique una lista de palabras, solo que las palabras deben estar en el orden de un alfabeto dado al azar.

Su programa aceptará una cadena de palabras separadas por comas y un nuevo alfabeto.
Su programa mostrará cada palabra de la misma manera en el nuevo orden ordenado.

Ejemplo:

Entrada:

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

Salida:

cat,green,home,network,egg,oval

Este es un código de golf , por lo que el ganador es la persona con el programa más corto.

Este es mi primer desafío, por lo que cualquier mejora en la pregunta / desafío es apreciada.

CJam, 26 19 17 bytes

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

Pruébalo en línea.

Caso de prueba

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

Cómo 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

Salida:

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

Pyth , 19 caracteres

j\,o_mx_zdNchczd\,

Prueba:

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

Explicación:

                            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(",")

Básicamente, ordena los fragmentos, con una clave de la lista de índices de los caracteres en la cadena, luego los une en comas. El negocio de reversión es más corto que dividir la cadena nuevamente.

Ruby, 53 50 bytes

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

Estoy usando Ruby trpara reemplazar el alfabeto personalizado con a-zantes de ordenar. La entrada es a través del argumento de la línea de comandos.

Python, 131

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

Debe haber mucho espacio para mejorar.

JavaScript (E6) 102 119

Ordenar con una función de mapeo 'M' basada en el alfabeto en la variable 'a'
Con IO usando popup (prompt + alert)

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 una función (comprobable) con 1 parámetro de cadena, que devuelve una matriz de cadena (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))
)

Prueba en la consola FireFox / FireBug

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

Salida

["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 \,))))

Wow, esto comenzó bien, (sort-by(fn[w](mapv(zipmap(sort %2)%2)w)))pero luego me di cuenta de vecque no se ordena de la misma manera que las cadenas, e intercalar esas comas también requiere una cantidad significativa de código.