Mon premier post code golf, toutes mes excuses pour toute erreur ...

Le contexte

En escalade ( particulièrement en bloc ), les notes d’escalade V / Vermin (USA) commencent à «VB» (la note la plus facile), puis «V0», «V0 +», «V1», «V2», «V3» , 'V4', 'V5' etc. jusqu'à 'V17' (la classe la plus difficile).

Tâche

Vous prendrez en entrée une liste / un tableau de notes en montée et vous devrez retourner ou imprimer une liste / un tableau des notes triées du plus facile au plus difficile.

Si l'entrée est vide, retourne une structure de données vide. sinon, l'entrée sera toujours valide.

Cas de test

Input | Output
[] |  []
['V1'] |  ['V1']
['V7', 'V12', 'V1'] | ['V1', 'V7', 'V12']
['V13', 'V14', 'VB', 'V0'] |  ['VB', 'V0', 'V13', 'V14']
['V0+', 'V0', 'V16', 'V2', 'VB', 'V6'] | ['VB', 'V0', 'V0+', 'V2', 'V6', 'V16']

Ceci est un défi de code-golf .

Python 2 , 58 54 octets

lambda x:sorted(x,key=lambda y,B10=0:eval(y[1:]+'10'))

Essayez-le en ligne!

Comment ça marche

y         y[1:]+'10'   eval(y[1:]+'10')
=======================================
VB        B10          0  (a variable we defined)
V0        010          8  (an octal literal)
V0+       0+10         10
V1        110          110
V2        210          210
...       ...          ...
V17       1710         1710

JavaScript (ES6) / Firefox, 53 octets

a=>a.sort((a,b)=>(g=s=>parseInt(s,32)%334+s)(a)>g(b))

Cas de test

Pour Firefox:

let f =

a=>a.sort((a,b)=>(g=s=>parseInt(s,32)%334+s)(a)>g(b))

console.log(JSON.stringify(f([])))
console.log(JSON.stringify(f(['V1'])))
console.log(JSON.stringify(f(['V7', 'V12', 'V1'])))
console.log(JSON.stringify(f(['V13', 'V14', 'VB', 'V0'])))
console.log(JSON.stringify(f(['V0+', 'V0', 'V16', 'V2', 'VB', 'V6'])))

Pour Chrome ou Edge (+4 octets):

let f =

a=>a.sort((a,b)=>(g=s=>parseInt(s,32)%334+s)(a)>g(b)||-1)

console.log(JSON.stringify(f([])))
console.log(JSON.stringify(f(['V1'])))
console.log(JSON.stringify(f(['V7', 'V12', 'V1'])))
console.log(JSON.stringify(f(['V13', 'V14', 'VB', 'V0'])))
console.log(JSON.stringify(f(['V0+', 'V0', 'V16', 'V2', 'VB', 'V6'])))

Comment?

Nous appliquons 3 transformations successives qui conduisent à des chaînes comparables lexicographiquement.

s     | Base32 -> dec. | MOD 334 | +s
------+----------------+---------+---------
"VB"  |           1003 |       1 | "1VB"
"V0"  |            992 |     324 | "324V0"
"V0+" |            992 |     324 | "324V0+"
"V1"  |            993 |     325 | "325V1"
"V2"  |            994 |     326 | "326V2"
"V3"  |            995 |     327 | "327V3"
"V4"  |            996 |     328 | "328V4"
"V5"  |            997 |     329 | "329V5"
"V6"  |            998 |     330 | "330V6"
"V7"  |            999 |     331 | "331V7"
"V8"  |           1000 |     332 | "332V8"
"V9"  |           1001 |     333 | "333V9"
"V10" |          31776 |      46 | "46V10"
"V11" |          31777 |      47 | "47V11"
"V12" |          31778 |      48 | "48V12"
"V13" |          31779 |      49 | "49V13"
"V14" |          31780 |      50 | "50V14"
"V15" |          31781 |      51 | "51V15"
"V16" |          31782 |      52 | "52V16"
"V17" |          31783 |      53 | "53V17"

Husk , 5 octets

ÖiÖm±

Essayez-le en ligne! Les résultats sont imprimés un par ligne, mais en interne, il s’agit d’une fonction qui prend et retourne une liste de chaînes.

Explication

Ceci est étonnamment similaire à la réponse de Martin à la rétine . Nous commençons par le faire Öm±, ce qui signifie "ordre par mappage est numérique" Cela met VB, V0et V0+dans le bon ordre, car ils sont comparés comme [0,0], [0,1]et [0,1,0]. Ensuite nous le faisons Öi, ce qui signifie "ordre par valeur entière". Étant donné une chaîne, irenvoie la première séquence de chiffres apparaissant dans celle-ci sous la forme d'un entier ou de 0 si aucun n'est trouvé. Les trois chaînes ci-dessus sont toutes mappées sur 0 et le tri est stable. Elles seront donc dans le bon ordre dans la sortie.

Rétine , 14 octets

B
!
O`
!
B
O#`

Essayez-le en ligne!

Explication

B
!

Remplacez Bpar !afin que l'ordre lexicographique des notes soit placé VB(ou alors V!) devant toutes les notes numériques.

O`

Triez toutes les lignes d'entrée lexicographiquement. Cela ne donne pas le bon résultat mais ordonne V! < V0 < V0+correctement.

!
B

Retourner V!dans VB.

O#`

Triez les lignes numériquement. Retina cherche simplement le premier nombre décimal d'une chaîne pour déterminer sa clé de tri. S'il n'y a pas de nombre (comme pour VB), la valeur est définie sur 0. Cela signifie tous VB,V0 et V0+ont la même clé de tri. Mais la sorte de Retina est stable et nous les avons déjà placées dans le bon ordre relatif.

V , 3 octets

Úún

Essayez-le en ligne!

Comment ça marche?

ú   # Sort on...
 n  #   the first decimal number on the line

Cette commande est presque une solution valide, car chaque ligne qui ne peut pas être triée par numéros (AKA, VB) sera placée au début, sans que l'ordre ne soit modifié. Cependant, comme il ne s'agit que de chiffres, il ne peut pas distinguer entre V0et V0+. Puisque Vim utilise une sorte stable, celle qui est arrivée en premier restera la première après le tri. Alors...

Ú   # Sort lexicographically (will place 'V0' before 'V0+')
 ú  # Sort by...
  n #   The first number on the line

C #, 121 83 82 83 octets

Sauvegardé 39 octets grâce à TheLethalCoder et LiefdeWen

a=>a.OrderBy(x=>x[1]>65?-1:x=="V0+"?0.5:int.Parse(x.Remove(0,1)))

Essayez-le en ligne!

Le décompte comprend using System.Linq.

Comment?

• Obtient un tableau de chaînes en entrée.
• Si l'entrée est égale à VB, définissez la valeur sur -1, si elle est égale à VB0+, définissez la valeur sur 0.
• Commandez les entrées en fonction du nombre qui vient après le V.

Peut-être un peu un bidouillage, mais ça marche! :)

Ruby , 52 42 41 octets

->x{[?B,0,"0+",*1..17].map{|a|"V#{a}"}&x}

Essayez-le en ligne!

Comment ça marche:

Tournez le problème, créez la liste complète triée, puis obtenez l'intersection avec notre entrée.

Merci Lynn d'avoir sauvegardé 1 octet.

Pyth , 16 octets

Port de Python répond par OP.

o|hx"B00+"tN+3st

Suite de test .

05AB1E , 17 13 8 octets

Σþï}„VB†

Essayez-le en ligne!

Gelée , 9 octets

Ḋv-.F+LµÞ

Un lien monadique prenant une liste de listes de caractères et renvoyant la liste triée.

Essayez-le en ligne! (le pied de page formate bien le résultat)

Comment?

Ḋv-.F+LµÞ - Link: list of lists of characters
       µÞ - sort by key:
Ḋ         -   dequeue (remove the 'V' from the item)
  -.      -   literal -0.5
 v        -   evaluate as Jelly code with argument -0.5
          -   ...this means `VB` and `V0+` become -0.5
          -      (to binary and addition respectively)
          -      while others become their literal numbers
    F     -   flatten
     +L   -   add the length of the item
          -   ...'VB', 'V0', 'V0+', 'V1', 'V2'... -> 1.5, 2, 2.5, 3, 4, ...

Haskell , 55 octets

f l=['V':x|x<-"B":"0":"0+":map show[1..17],_:y<-l,x==y]

Essayez-le en ligne!

Pour commencer, voici ma solution Python 3 ... Apologies, posté trop tôt contre la convention, maintenant en train de republier ...

Python 3 , 69 67 octets

lambda l:sorted(l,key=lambda x:'B00+'.find(x[1:])+1or int(x[1:])+3)

Essayez-le en ligne!

Swift 3 , 102 octets

var r={String((Int($0,radix:32) ?? 992)%334)+$0};func f(l:[String]){print(l.sorted(by:{r($0)<r($1)}))}

Ceci est une fonction. Vous pouvez l'appeler comme tel:

f(l:["V0","VB","V13","V0+"])

Essayez-le en ligne!

Comment cela marche-t-il?

Ceci est fondamentalement un port de la réponse Javascript incroyable par @Arnauld , mais optimisé pour Swift.

Il mappe chacune des valeurs sur des chaînes ordonnées lexicographiquement, comme indiqué dans le tableau ci-dessous:

Chaîne initiale -> Résultat

V1 -> 325V1
V10 -> 46V10
V11 -> 47V11
V12 -> 48V12
V13 -> 49V13
V14 -> 50V14
V15 -> 51V15
V16 -> 52V16
V17 -> 53V17
V2 -> 326V2
V3 -> 327V3
V4 -> 328V4
V5 -> 329V5
V6 -> 330V6
V7 -> 331V7
V8 -> 332V8
V9 -> 333V9
V0 + -> 324V0 +
V0 -> 324V0
VB -> 1VB

Explication du code

• String((Int($0,radix:32) ?? 992)%334)- Convertit chaque chaîne d'un nombre base 32 en nombre décimal. Dans le cas où la valeur est "V0 +", l'appel à Int(_:radix:)retournera nil et nous prenons la valeur de "V0", 992. Nous prenons également le résultat de mod 334et finalement le convertissons en String.

• +$0- Ajoute la valeur actuelle à la chaîne créée ci-dessus. Par exemple, si la chaîne est V9, la fonction ci-dessus retourne 333et nous ajoutons V9, résultant 333V9.

• var r={...}- Déclare une variable rà une fermeture anonyme, car cela économise beaucoup d'octets puisqu'il est utilisé deux fois.

• func f(l:[String])- Définit une fonction favec un paramètre l, une liste de chaînes.

• print(l.sorted(by:{r($0)<r($1)}))- Imprime le résultat du tri de la liste donnée, la clé étant la variable rdéfinie ci-dessus.

PowerShell , 45 octets

param($a)'B',0,'0+'+1..17|%{"V$_"}|?{$_-in$a}

Essayez-le en ligne!

Utilise le même processus que la réponse Ruby de GB pour construire la liste d'arguments complète dans un ordre trié, puis sélectionne ceux qui constituent -inla liste d'entrée.

Google Sheets, 142 octets

=ArrayFormula(If(A1="","",Sort(Transpose(Split(A1,",")),Transpose(IfError(Find(Split(A1,","),"VBV0V0+"),Value(Mid(Split(A1,","),2,3))+9)),1)))

L'entrée est une chaîne A1avec chaque entrée séparée par une virgule.
La sortie est la cellule de la formule plus les n-1cellules en dessous, où nest le nombre d'entrées A1.

C'est une longue formule en désordre, alors décompresons-la.

• If(A1="","",~)corrige l'entrée nulle. Sans cela, une entrée vide renvoie un#VALUE! erreur car la Splitfonction ne fonctionne pas sur des entrées vides.
• Transpose(Split(A1,","))se sépare A1à la virgule et le transpose dans une colonne car leSort fonction ne fonctionne que sur des colonnes.
• Transpose(IfError(Find(),Value()+9)) est brise en ces morceaux:
  • Find(Split(A1,","),"VBV0V0+")essaie de trouver chaque paramètre dans cette chaîne. Ces trois premiers sont les seuls qui doivent être triés comme des chaînes de caractères afin que nous utilisionsFind pour obtenir leur ordre de tri.
  • Value(Mid(Split(A1,","),2,3))+9obtient la valeur numérique de la note. Cela ne concerne que la V1 et les versions ultérieures, ce qui leur permet de trier très bien numériquement. Le +9but ultime est de s’assurer que V1 vient après V0 + puisque sa Findvaleur serait 5. Techniquement, alors, seulement+5 faut, mais cela ne me coûte pas plus d’octets pour faire en sorte que le tri soit plus sûr.
  • IfError(Find(~),Value(~)) renvoie le Find valeur si la chaîne a été trouvée (c'est-à-dire que la note est VB, V0 ou V0 +). S'il ne peut pas être trouvé, il retourne la valeur numérique de la note plus neuf.
  • Transpose(IfError(~))à nouveau le transforme en une colonne afin de Sortpouvoir l'utiliser.
• Sort(Transpose(Split(~)),Transpose(IfError(Find(~),Value(~)+9)),1) le tout en triant l'entrée fractionnée en utilisant l'ordre de tri personnalisé croissant.
• ArrayFormula(~)encapsule tout le contenu pour qu'il renvoie les résultats sous forme de tableau au lieu de simplement renvoyer la première valeur de ce tableau. C'est la raison pour laquelle la formule d'une cellule remplit également les cellules situées en dessous.

Bash + coreutils, 21

tr B .|sort -V|tr . B

sortLe -Vmode de tri par ersion de GNU fait presque ce que nous voulons. Commutez le Bpour un .et nous avons terminé.

Essayez-le en ligne .

Haskell , 90 84 83 61 octets

import Data.List
f"VB"=[]
f(_:'1':[a])='X':[a]
f x=x
sortOn f

Essayez-le en ligne!

fest une fonction qui convertit les notes d’escalade en chaînes pouvant être comparées. Si VBla chaîne convertie pour obtenir la priorité la plus élevée, elle est remplacée V1par des Xchaînes de trois longues pour réduire la priorité de V10-V17 . Pour le reste, nous ne faisons rien.

Pour trier la liste, nous utilisons Data.Listsla sortOnfonction (suggérée par Lynn) pour créer une fonction sans point.

R , 45 octets

l=paste0('V',c('B','0','0+',1:17));l[l%in%x]

Comment cela marche-t-il?

• Attribuez le vecteur de notes correctement ordonné à 'l';
  • Utilisez 'paste0' au lieu de 'paste' pour éviter de créer un argument 'sep = ""';
• Indexez 'l' en fonction des correspondances de 'l' dans votre vecteur d'entrée de notes mélangées non triées.

Python2, 77 octets

sorted(input(),key=lambda s:float(s[1:].replace("B","-1").replace("+",".5")))

Gelée , 17 à 11 octets

fØD
ṢÇÞÇV$Þ

Essayez-le en ligne!

TXR Lisp : 45 octets

(op sort @1 :(ret`@(mod(toint @1 32)334)@1`))

Courir:

1> (op sort @1 :(ret`@(mod(toint @1 32)334)@1`))
#<interpreted fun: lambda (#:arg-01-0168 . #:rest-0167)>
2> [*1 ()]
nil
3> [*1 (list "V0+" "V0" "V16" "V2" "VB" "V6")]
("VB" "V0" "V0+" "V2" "V6" "V16")

Perl 5 , 56 + 1 (-a) = 57 octets

map{$i=$_;s/V//;$a[/B/?0:/^0/?length:$_+2]=$i}@F;say"@a"

Essayez-le en ligne!