L'obiettivo

Le agenzie di rating del credito assegnano i rating alle obbligazioni in base alla solvibilità dell'emittente e le agenzie di rating del credito "Big Three" utilizzano un sistema di rating a livelli simile (anche se non identico) . Questi hanno un ordine chiaro e logico: usando i livelli S&P, AAA> AA +> AA> AA-> A +> ...> BBB> B> ...> C. Moody's utilizza un sistema simile, ma nomina i loro livelli in modo diverso ( Aaa> Aa1> Aa2> ...> Baa1> ...> C).

Il tuo compito è quello di progettare un programma che prende come input un elenco di stringhe che rappresentano livelli di rating obbligazionari e genera lo stesso elenco, ordinati in ordine decrescente dal livello più alto (AAA / Aaa) al livello più basso (C).

Input Output

È possibile scegliere il formato dell'input (elenco, uno per argomento, file CSV). Si può presumere che ogni elemento nell'elenco di input sia una stringa di valutazione valida e che tutte le stringhe di valutazione in un elenco provengano dalla stessa agenzia di classificazione . Inoltre, puoi presumere che nessuna delle classiche classificazioni in stile NA come "NR" o "WR" sarà inclusa - questo è strettamente da "Aaa / AAA" a "C". Potrebbero essere presenti valutazioni duplicate nell'elenco di input e, se rilevate, non devono essere rimosse.

Puoi anche scegliere il formato dell'output come appropriato per la tua lingua, con l'unica limitazione che dovrebbe essere in uscita una codifica di testo standard come UTF-8 o ASCII.

Regole e punteggio

Questo è il golf del codice, quindi vince il conteggio di byte più basso, le scappatoie standard non sono consentite. Si prega di specificare quale sia il formato di input e output.

Esempio di programma e casi di test

Il seguente programma Python di esempio può essere usato come esempio standard del corretto ordinamento. Gli elenchi Moodye SPgli ordini da utilizzare.

Moody = ['Aaa', 'Aa1', 'Aa2', 'Aa3', 'A1', 'A2', 'A3',
         'Baa1', 'Baa2', 'Baa3', 'Ba1', 'Ba2', 'Ba3',
         'B1', 'B2', 'B3', 'Caa', 'Ca', 'C']

SP = ['AAA', 'AA+', 'AA', 'AA-', 'A+', 'A', 'A-',
      'BBB+', 'BBB', 'BBB-', 'BB+', 'BB', 'BB-',
      'B+', 'B', 'B-', 'CCC', 'CC', 'C']

test_cases = [
    (['Aa2', 'Aaa', 'Aa1'], ['Aaa', 'Aa1', 'Aa2']),
    (['AA', 'AA-', 'AA+'], ['AA+', 'AA', 'AA-']),
    (['Baa1', 'Ba1', 'A1', 'B1', 'Aaa', 'C', 'Caa', 'Aa1'],
     ['Aaa', 'Aa1', 'A1', 'Baa1', 'Ba1', 'B1', 'Caa', 'C']),
    (['BBB+', 'BB+', 'A+', 'B+', 'AAA', 'C', 'CCC', 'AA+'],
     ['AAA', 'AA+', 'A+', 'BBB+', 'BB+', 'B+', 'CCC', 'C']),
    (['B3', 'B1', 'B2'], ['B1', 'B2', 'B3']),
    (['B-', 'B+', 'B'], ['B+', 'B', 'B-']),
    (['B3', 'Caa', 'Aa1', 'Caa', 'Ca', 'B3'],
     ['Aa1', 'B3', 'B3', 'Caa', 'Caa', 'Ca']),
    (['B-', 'CCC', 'AA+', 'CCC', 'CC', 'B-'],
     ['AA+', 'B-', 'B-', 'CCC', 'CCC', 'CC'])
]

mdy_sort = lambda x: Moody.index(x)
sp_sort = lambda x: SP.index(x)

for l_in, l_out in test_cases:
    sort_key = mdy_sort if set(l_in).issubset(set(Moody)) else sp_sort
    assert sorted(l_in, key=sort_key) == l_out

Casi test

Nel caso in cui la formattazione del test case in stile Python sia scomoda, l'ho emesso come stringhe di input delimitate da spazi (raggruppate in coppie di input a due righe seguite da output):

Aa2 Aaa Aa1
Aaa Aa1 Aa2

AA AA- AA+
AA+ AA AA-

Baa1 Ba1 A1 B1 Aaa C Caa Aa1
Aaa Aa1 A1 Baa1 Ba1 B1 Caa C

BBB+ BB+ A+ B+ AAA C CCC AA+
AAA AA+ A+ BBB+ BB+ B+ CCC C

B3 B1 B2
B1 B2 B3

B- B+ B
B+ B B-

B3 Caa Aa1 Caa Ca B3
Aa1 B3 B3 Caa Caa Ca

B- CCC AA+ CCC CC B-
AA+ B- B- CCC CCC CC

Nota : menziono i "Big Three", ma qui specifica solo Moody's e S&P - il motivo è che il terzo, Fitch, utilizza lo stesso sistema di S&P quando non si tiene conto delle classificazioni in stile NA, quindi includendo Fitch essere ridondanti.

Pyth, 16 byte

o+Xs}RGrN0N\z\,Q

Ordiniamo lessicograficamente per chiave usando l'approccio di @ Neil. Input e output sono come liste; questo non muta l'elenco.

o+Xs}RGrN0N\z\,Q       Implicit: Q = input list
                        lambda N  (N is a bond rating)
       rN0               Convert N to lowercase
    }RG                  Map is-in G, the lowercase alphabet.
   s                     Sum the list of bools; the number of letters in N.
  X       N\z            Insert "z" at that position in N.
 +           \,          Append "," to the end.
                         This works because "," is between "+" and "-" lexicographically.
o              Q       Sort Q, using that lambda as a key.

Provalo qui . I casi di test sono tutti i rating obbligazionari di ogni schema di rating, con un duplicato inserito.

ES6, 71 65 byte

a=>a.sort((b,c)=>r(b)>r(c)||-1,r=s=>s.replace(/[^A-z]*$/,"z$&,"))

Inserendo un zdopo le lettere e il suffisso a ,non ci resta che ordinare le stringhe in modo lessicale.

Modifica: salvato 6 byte grazie a @ user81655.

Utilità Bash + GNU, 45

Il merito è di @Neil per l'approccio .

sed s/$/e/|tr +-3 d-l|sort|tr -d e|tr d-l +-3

Nel mio ordinamento locale, i numeri vengono ordinati prima delle lettere e ordinati -prima +. Quindi questi caratteri sono traslitterati nell'intervallo alfabetico in modo da essere ordinati nel giusto ordine.

Provalo online.