La tarea

Las agencias de calificación crediticia asignan calificaciones a los bonos de acuerdo con la solvencia crediticia del emisor, y las agencias de calificación crediticia "Tres Grandes" utilizan un sistema de calificación escalonada similar (aunque no idéntico) . Estos tienen un orden claro y lógico: usando los niveles de S&P, AAA> AA +> AA> AA-> A +> ...> BBB> B> ...> C. Moody's usa un sistema similar, pero nombra sus niveles de manera diferente ( Aaa> Aa1> Aa2> ...> Baa1> ...> C).

Su tarea es diseñar un programa que tome como entrada una lista de cadenas que representan niveles de calificación de bonos y generará la misma lista, ordenada en orden descendente desde el nivel más alto (AAA / Aaa) hasta el nivel más bajo (C).

De entrada y salida

Puede elegir el formato de la entrada (lista, una por argumento, archivo CSV). Puede suponer que cada elemento de la lista de entrada es una cadena de calificación válida y que todas las cadenas de calificación de una lista provienen de la misma agencia de calificación . Además, puede suponer que ninguna de las clasificaciones de estilo NA funky como "NR" o "WR" se incluirán, esto es estrictamente de "Aaa / AAA" a "C". Puede haber clasificaciones duplicadas en la lista de entrada y, si se encuentran, no deben eliminarse.

También puede elegir el formato de salida que sea apropiado para su idioma, con la única restricción de que debería generar alguna codificación de texto estándar como UTF-8 o ASCII.

Reglas y puntaje

Este es el código de golf, por lo que el conteo de bytes más bajo gana, las lagunas estándar no se permiten. Especifique cuál es el formato de entrada y salida.

Programa de ejemplo y casos de prueba

El siguiente programa Python de ejemplo se puede usar como un ejemplo estándar del orden correcto. Las listas Moodyy SPson los ordenamientos a utilizar.

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

Casos de prueba

En caso de que el formato del caso de prueba de estilo python sea inconveniente, lo he generado como cadenas de entrada delimitadas por espacios (agrupadas en pares de dos líneas de entrada seguidas de salida):

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 : Menciono los "Tres Grandes", pero solo especifico Moody's y S&P aquí; la razón es que el tercero, Fitch, usa el mismo sistema que S&P cuando no tiene en cuenta las clasificaciones de estilo NA, por lo que incluiría a Fitch ser redundante

Pyth, 16 bytes

o+Xs}RGrN0N\z\,Q

Ordenamos lexicográficamente por una clave usando el enfoque de @ Neil. Entrada y salida son como listas; Esto no muta la lista.

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.

Probarlo aquí . Los casos de prueba son todas las calificaciones de bonos de cada esquema de calificación, con un duplicado incluido.

ES6, 71 65 bytes

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

Al insertar un zdespués de las letras y el sufijo a ,solo tenemos que ordenar las cadenas léxicamente.

Editar: guardado 6 bytes gracias a @ user81655.

Bash + GNU utilidades, 45

Se debe crédito a @Neil por el enfoque .

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

En mi orden de clasificación local, los números se clasifican antes que las letras y se -clasifican antes +. Entonces, estos caracteres se transliteran en el rango del alfabeto para que se ordenen en el orden correcto.

Pruébalo en línea.