Mein erster Code Golfpost, entschuldige mich für etwaige Fehler ...

Kontext

Beim Klettern ( speziell beim Bouldern ) beginnen die Kletternoten für V / Vermin (USA) bei "VB" (die einfachste Note) und gehen dann auf "V0", "V0 +", "V1", "V2", "V3". , 'V4', 'V5' usw. bis 'V17' (die härteste Note).

Aufgabe

Sie nehmen als Eingabe eine Liste / ein Array von Kletternoten und müssen eine Liste / ein Array der Noten, sortiert von der einfachsten bis zur schwierigsten, zurückgeben oder ausdrucken.

Wenn die Eingabe leer ist, geben Sie eine leere Datenstruktur zurück. Andernfalls ist die Eingabe immer gültig.

Testfälle

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']

Dies ist eine Code-Golf- Herausforderung.

Python 2 , 58 54 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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 Byte

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

Testfälle

Für 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'])))

Für Chrome oder Edge (+4 Byte):

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'])))

Wie?

Wir wenden 3 aufeinanderfolgende Transformationen an, die zu lexikografisch vergleichbaren Zeichenfolgen führen.

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"

Schale , 5 Bytes

ÖiÖm±

Probieren Sie es online! Die Ergebnisse werden zeilenweise gedruckt, aber intern ist dies eine Funktion, die eine Liste von Zeichenfolgen aufnimmt und zurückgibt.

Erläuterung

Dies ist überraschend ähnlich zu Martins Retina-Antwort . Zuerst tun wir das Öm±, was "Reihenfolge durch Mapping ist eine Ziffer" bedeutet. Dies stellt VB, V0und V0+in der richtigen Reihenfolge, da sie verglichen [0,0], [0,1]und [0,1,0]. Als nächstes tun wir das Öi, was "Reihenfolge nach ganzzahligem Wert" bedeutet. Gibt bei einer gegebenen Zeichenfolge idie erste darin vorkommende Ziffernfolge als Ganzzahl oder 0 zurück, wenn keine gefunden wird. Die drei obigen Zeichenfolgen sind alle auf 0 abgebildet und die Sortierung ist stabil, sodass sie in der Ausgabe in der richtigen Reihenfolge angezeigt werden.

Retina , 14 Bytes

B
!
O`
!
B
O#`

Probieren Sie es online!

Erläuterung

B
!

Ersetzen Sie Bdurch, !damit die lexikografische Reihenfolge der Noten VB(oder dann V!) vor allen numerischen Noten steht.

O`

Sortieren Sie alle Eingabezeilen lexikografisch. Dies gibt nicht das richtige Ergebnis, aber die Reihenfolge ist V! < V0 < V0+korrekt.

!
B

Biegen Sie V!zurück in VB.

O#`

Sortieren Sie die Zeilen numerisch. Retina sucht einfach nach der ersten Dezimalzahl in einer Zeichenfolge, um den Sortierschlüssel zu bestimmen. Wenn es keine Zahl gibt (z. B. für VB), wird der Wert auf festgelegt 0. Das bedeutet , dass alle VB, V0und V0+haben den gleichen Sortierschlüssel. Aber Retinas Sortierung ist stabil und wir haben sie bereits in die richtige relative Reihenfolge gebracht.

V , 3 Bytes

Úún

Probieren Sie es online!

Wie funktioniert es?

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

Dieser Befehl ist fast eine gültige Lösung, da jede Zeile, die nicht nach Zahlen sortiert werden kann (AKA, VB), am Anfang platziert wird, ohne dass die Reihenfolge geändert wird. Da es sich jedoch nur um Zahlen handelt, kann es nicht zwischen V0und unterscheiden V0+. Da Vim eine stabile Sortierung verwendet, bleibt die zuerst eingegebene Sortierung nach der Sortierung erhalten. So...

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

C #, 121 83 82 83 Bytes

Gespeichert 39 Bytes dank TheLethalCoder und LiefdeWen

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

Probieren Sie es online!

Bytecount enthält using System.Linq.

Wie?

• Ruft ein Array von Zeichenfolgen als Eingabe ab.
• Wenn die Eingabe gleich ist VB, setzen Sie den Wert auf -1, wenn sie gleich ist VB0+, setzen Sie den Wert auf 0.
• Ordnen Sie die Eingabe basierend auf dem Zahlenwert, der nach dem kommt V.

Könnte ein bisschen hacken, aber es funktioniert! :)

Ruby , 52 42 41 Bytes

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

Probieren Sie es online!

Wie es funktioniert:

Drehen Sie das Problem um, erstellen Sie die vollständige sortierte Liste und ermitteln Sie den Schnittpunkt mit unserer Eingabe.

Vielen Dank an Lynn für das Speichern von 1 Byte.

Pyth , 16 Bytes

Port of Python Antwort von OP.

o|hx"B00+"tN+3st

Testsuite .

05AB1E , 17 13 8 Bytes

Σþï}„VB†

Probieren Sie es online!

Gelee , 9 Bytes

Ḋv-.F+LµÞ

Ein monadischer Link, der eine Liste von Zeichenlisten erstellt und die sortierte Liste zurückgibt.

Probieren Sie es online! (die Fußzeile formatiert das Ergebnis schön)

Wie?

Ḋ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 Bytes

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

Probieren Sie es online!

Zum Auftakt hier ist meine Python 3-Lösung ... Entschuldigung, habe dies zu früh gegen die Konvention gepostet und poste es jetzt erneut ...

Python 3 , 69 67 Bytes

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

Probieren Sie es online!

Schnelle 3 , 102 Bytes

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

Dies ist eine Funktion. Sie können es als solches bezeichnen:

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

Probieren Sie es online!

Wie funktioniert das?

Dies ist im Grunde eine Portierung der erstaunlichen Javascript-Antwort von @Arnauld , die jedoch für Swift optimiert ist.

Es ordnet jeden der Werte lexikografisch sortierbaren Zeichenfolgen zu, wie in der folgenden Tabelle gezeigt:

Anfangszeichenfolge -> Ergebnis

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

Code Erklärung

• String((Int($0,radix:32) ?? 992)%334)- Konvertiert jeden String von einer Basis-32-Zahl in eine Dezimalzahl. Wenn der Wert "V0 +" ist, gibt der Aufruf Int(_:radix:)von "nil" zurück und wir nehmen den Wert von "V0", 992. Zusätzlich nehmen wir das Ergebnis von mod 334und konvertieren es schließlich in "String".

• +$0- Fügt den aktuellen Wert zum oben erstellten String hinzu. Wenn zum Beispiel der String ist V9, gibt die obige Funktion zurück 333und wir addieren V9, was dazu führt 333V9.

• var r={...}- Deklariert eine Variable rfür einen anonymen Abschluss, da sie viele Bytes spart, da sie zweimal verwendet wird.

• func f(l:[String])- Definiert eine Funktion fmit einem Parameter l, einer Liste von Strings.

• print(l.sorted(by:{r($0)<r($1)}))- Gibt das Ergebnis der Sortierung der angegebenen Liste aus, wobei der Schlüssel die roben definierte Variable ist.

PowerShell , 45 Byte

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

Probieren Sie es online!

Verwendet den gleichen Prozess wie die Ruby-Antwort von GB, um die vollständige Argumentliste in sortierter Reihenfolge zu erstellen, und wählt dann diejenigen aus, die -indie Eingabeliste darstellen.

Google Sheets, 142 Bytes

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

Die Eingabe ist eine Zeichenfolge, A1bei der jeder Eintrag durch ein Komma getrennt ist.
Ausgabe ist die Zelle der Formel plus die n-1Zellen darunter, in denen ndie Anzahl der Einträge angegeben ist A1.

Es ist eine lange, chaotische Formel, also packen wir sie aus.

• If(A1="","",~)behebt die Null-Eingabe Ohne dies gibt eine leere Eingabe a zurück#VALUE! Fehler zurück, da die SplitFunktion bei leeren Eingaben nicht funktioniert.
• Transpose(Split(A1,",")) spaltet A1 das Komma und transponiert es in eine Spalte, da die SortFunktion nur für Spalten funktioniert.
• Transpose(IfError(Find(),Value()+9)) ist bricht in diese Stücke:
  • Find(Split(A1,","),"VBV0V0+")versucht, jeden Parameter in dieser Zeichenfolge zu finden. Diese ersten drei sind die einzigen, die als Zeichenfolgen sortiert werden müssen, damit wir sie verwendenFind ihre Sortierreihenfolge ermitteln können.
  • Value(Mid(Split(A1,","),2,3))+9Ruft den numerischen Wert der Note ab. Dies ist nur für V1 und höher von Bedeutung, sodass die Sortierung numerisch einwandfrei ist. Am +9Ende ist sicherzustellen, dass V1 nach V0 + kommt, da sein FindWert wäre 5. Also nur technisch+5 erforderlich, aber es kostet mich keine weiteren Bytes, um sicherzustellen, dass es richtig sortiert ist.
  • IfError(Find(~),Value(~)) gibt das zurück Find Wert zurück, wenn die Zeichenfolge gefunden wurde (dh die Note ist VB, V0 oder V0 +). Wird es nicht gefunden, wird der numerische Wert der Note plus neun zurückgegeben.
  • Transpose(IfError(~))verwandelt es wieder in eine Spalte, damit Sortes verwendet werden kann.
• Sort(Transpose(Split(~)),Transpose(IfError(Find(~),Value(~)+9)),1) Fassen Sie alles zusammen, indem Sie die geteilten Eingaben in aufsteigender Reihenfolge sortieren.
• ArrayFormula(~)Bricht das Ganze so um, dass es die Ergebnisse als Array zurückgibt, anstatt nur den ersten Wert in diesem Array zurückzugeben. Dies bewirkt, dass die Formel in einer Zelle auch die Zellen darunter füllt.

Bash + Coreutils, 21

tr B .|sort -V|tr . B

Der GNU sort- -VVersionssortiermodus macht fast das, was wir wollen. Schalten Sie die Bfür ein .und wir sind fertig.

Probieren Sie es online aus .

Haskell , 90 84 83 61 Bytes

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

Probieren Sie es online!

fist eine Funktion, die Kletternoten in vergleichbare Saiten umwandelt. Wenn konvertiert wird VB, um die leere Zeichenfolge zu sein, sodass sie die höchste Priorität erhält, wird sie V1durch XZeichenfolgen ersetzt, die drei Zeichenfolgen lang sind, um die Priorität von zu verringernV10 - zuV17 . Für den Rest machen wir nichts.

So sortieren Sie die Liste verwenden wir Data.Lists‚s - sortOnFunktion (wie von Lynn vorgeschlagen) einen Punkt freie Funktion zu erstellen.

R , 45 Bytes

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

Wie funktioniert das?

• Ordnen Sie den korrekt geordneten Notenvektor 'l' zu;
  • Verwenden Sie 'paste0' anstelle von 'paste', um ein Argument 'sep = ""' zu vermeiden.
• Index 'l' basierend auf Übereinstimmungen von 'l' in Ihrem Eingabevektor mit gemischten, unsortierten Noten.

Python2, 77 Bytes

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

Jelly , 17 11 Bytes

fØD
ṢÇÞÇV$Þ

Probieren Sie es online!

TXR Lisp : 45 Bytes

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

Lauf:

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 Bytes

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

Probieren Sie es online!