La tâche

Les agences de notation attribuent des notes aux obligations en fonction de la solvabilité de l'émetteur, et les agences de notation de crédit «Big Three» utilisent un système de notation à plusieurs niveaux similaire (mais pas identique) . Ceux-ci ont un ordre clair et logique - en utilisant les niveaux S&P, AAA> AA +> AA> AA-> A +> ...> BBB> B> ...> C.Moody's utilise un système similaire, mais nomme leurs niveaux différemment ( Aaa> Aa1> Aa2> ...> Baa1> ...> C).

Votre tâche consiste à concevoir un programme qui prend en entrée une liste de chaînes représentant les niveaux de notation des obligations et génère la même liste, triée par ordre décroissant du niveau le plus élevé (AAA / Aaa) au niveau le plus bas (C).

Entrée sortie

Vous pouvez choisir le format de l'entrée (liste, un par argument, fichier CSV). Vous pouvez supposer que chaque élément de la liste d'entrée est une chaîne de notation valide et que toutes les chaînes de notation d'une liste proviennent de la même agence de notation . De plus, vous pouvez supposer qu'aucune des notes funky de style NA telles que "NR" ou "WR" ne sera incluse - c'est strictement de "Aaa / AAA" à "C". Il peut y avoir des évaluations en double dans la liste de saisie, et si elles sont trouvées, elles ne doivent pas être supprimées.

Vous pouvez également choisir le format de sortie en fonction de votre langue, la seule restriction étant qu'il doit produire un codage de texte standard comme UTF-8 ou ASCII.

Règles et notation

C'est le golf de code, donc le nombre d'octets le plus bas gagne, les failles standard interdites. Veuillez spécifier le format d'entrée et de sortie.

Exemple de programme et de cas de test

L'exemple de programme Python ci-dessous peut être utilisé comme un exemple standard de l'ordre de tri correct. Les listes Moodyet SPles commandes à utiliser.

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

Cas de test

Dans le cas où la mise en forme du scénario de test de style python n'est pas pratique, je l'ai sortie sous forme de chaînes d'entrée délimitées par l'espace (regroupées en paires de deux lignes, entrées et sorties):

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

Remarque : je mentionne les "Big Three" mais spécifie uniquement Moody's et S&P ici - la raison en est que le troisième, Fitch, utilise le même système que S&P lorsque vous ne tenez pas compte des notes de style NA, donc l'inclusion de Fitch serait être redondant.

Pyth, 16 octets

o+Xs}RGrN0N\z\,Q

Nous trions lexicographiquement par clé en utilisant l'approche de @ Neil. L'entrée et la sortie sont des listes; cela ne modifie pas la liste.

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.

Essayez-le ici . Les cas de test sont tous des notations d'obligations de chaque système de notation, avec un double ajouté.

ES6, 71 65 octets

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

En insérant un zaprès les lettres et en suffixant un, ,il suffit de trier les chaînes lexicalement.

Edit: 6 octets enregistrés grâce à @ user81655.

Utilitaires Bash + GNU, 45

Nous remercions @Neil pour cette approche .

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

Dans mon ordre de tri local, les chiffres sont triés avant les lettres et -triés avant +. Ces caractères sont donc translittérés dans la gamme alphabétique afin d'être triés dans le bon ordre.

Essayez-le en ligne.