A tarefa

As agências de classificação de crédito atribuem classificações aos títulos de acordo com a capacidade de crédito do emissor, e as "Três Grandes" agências de classificação de crédito usam um sistema de classificação em camadas semelhante (embora não idêntico) . Eles têm uma ordem lógica e clara - usando as camadas S&P, AAA> AA +> AA> AA-> A +> ...> BBB> B> ...> C. A Moody's usa um sistema semelhante, mas nomeia suas camadas de maneira diferente ( Aaa> Aa1> Aa2> ...> Baa1> ...> C).

Sua tarefa é projetar um programa que tenha como entrada uma lista de cadeias que representam as camadas de classificação de títulos e produza a mesma lista, classificadas em ordem decrescente da camada mais alta (AAA / Aaa) até a camada mais baixa (C).

Entrada / Saída

Você pode escolher o formato da entrada (lista, uma por argumento, arquivo CSV). Você pode assumir que todos os itens da lista de entrada são uma sequência de classificação válida e que todas as sequências de classificação em uma lista vieram da mesma agência de classificação . Além disso, você pode assumir que nenhuma das classificações descoladas do estilo NA, como "NR" ou "WR", será incluída - isso é estritamente de "Aaa / AAA" a "C". Pode haver classificações duplicadas na lista de entrada e, se encontradas, não devem ser removidas.

Você também pode escolher o formato da saída conforme apropriado para o seu idioma, com a única restrição de que ela deve gerar alguma codificação de texto padrão como UTF-8 ou ASCII.

Regras e pontuação

Isso é código de golfe, portanto, a contagem de bytes mais baixa vence, as brechas padrão não são permitidas. Especifique qual é o formato de entrada e saída.

Exemplo de programa e casos de teste

O exemplo de programa Python abaixo pode ser usado como um exemplo padrão da ordem de classificação correta. As listas Moodye SPsão os pedidos a serem usados.

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 teste

Caso a formatação do caso de teste no estilo python seja inconveniente, eu a produzi como seqüências de entrada delimitadas por espaço (agrupadas na entrada de pares de duas linhas seguida pela saída):

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 : Mencionei os "Três Grandes", mas apenas especifique Moody's e S&P aqui - o motivo é que o terceiro, Fitch, usa o mesmo sistema que S&P quando você não leva em conta as classificações no estilo NA, portanto, incluindo a Fitch seja redundante.

Pitão, 16 bytes

o+Xs}RGrN0N\z\,Q

Classificamos lexicograficamente por uma chave usando a abordagem de @ Neil. Entrada e saída são como listas; isso não altera a 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.

Experimente aqui . Os casos de teste são todas as classificações de títulos de cada esquema de classificação, com uma duplicata lançada.

ES6, 71 65 bytes

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

Ao inserir a zapós as letras e com o sufixo a ,, basta classificar as strings lexicamente.

Editar: salvou 6 bytes graças a @ user81655.

Utilitários Bash + GNU, 45

O crédito é devido a @ Neil pela abordagem .

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

Na minha ordem de classificação por localidade, os números são classificados antes das letras e são -classificados antes +. Portanto, esses caracteres são transliterados no intervalo do alfabeto, para que sejam classificados na ordem correta.

Experimente online.