La sfida è quella di creare un programma che ordina un elenco di parole, solo che le parole devono essere nell'ordine di un dato alfabeto casuale.

Il tuo programma accetterà una stringa di parole separate da virgola e un nuovo alfabeto.
Il tuo programma produrrà ogni parola allo stesso modo nel nuovo ordine ordinato.

Esempio:

Ingresso:

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

Produzione:

cat,green,home,network,egg,oval

Questo è un codice-golf , quindi il vincitore è la persona con il programma più corto.

Questa è la mia prima sfida, quindi ogni miglioramento alla domanda / sfida è apprezzato.

CJam, 26 19 17 byte

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

Provalo online.

Caso di prova

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

Come funziona

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 byte

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

Produzione:

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

Pyth , 19 personaggi

j\,o_mx_zdNchczd\,

Test:

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

Spiegazione:

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

In sostanza, ordina i blocchi, con una chiave dell'elenco di indici dei caratteri nella stringa, quindi li unisce in virgole. Le attività di inversione sono più brevi della divisione della stringa di nuovo.

Rubino, 53 50 byte

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

Sto usando Ruby trper sostituire l'alfabeto personalizzato con a-zprima dell'ordinamento. L'input avviene tramite argomento della riga di comando.

Python, 131

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

Dovrebbe esserci ampio margine di miglioramento.

JavaScript (E6) 102 119

Ordinamento con una funzione di mappatura "M" basata sull'alfabeto nella variabile "a"
Con IO tramite popup (prompt + avviso)

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

Come funzione (testabile) con 1 parametro stringa, che restituisce un array di stringhe (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))
)

Test nella console FireFox / FireBug

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

Produzione

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

Clojure, 115 byte

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

Wow, questo è iniziato bene, (sort-by(fn[w](mapv(zipmap(sort %2)%2)w)))ma poi ho capito vecche non sono stati ordinati allo stesso modo delle stringhe e anche l'interleaving di quelle virgole richiede una quantità significativa di codice.