Sortieren Sie die Kletterqualitäten

33

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.

code-golf  array-manipulation  sorting 
— Chris_Rands
quelle
Veröffentlichen Sie dies das nächste Mal in der Sandbox , um Feedback zu erhalten, bevor Sie es veröffentlichen. Zweitens sollten Sie Ihre eigene Herausforderung wirklich beantworten?
— Ian H.
Werden in der Eingabe doppelte Noten angezeigt?
— Mr. Xcoder
@ Mr.Xcoder Keine Duplikate
— Chris_Rands
7
Willkommen bei PPCG! Ziemlich klar und nett für eine erste Frage. (y)
— offiziell
3
Sehr schöne erste Frage! Die Antworten sind so unterschiedlich und kreativ. :)
— Lynn

Antworten:

23

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
— Lynn
quelle
Die Portierung auf ES6 scheint Arnauld nicht zu übertreffen: Es a=>a.sort((a,b,B10=0)=>(g=s=>eval(s.slice(1)+10))(a)>g(b))sind 58 Byte.
— Lynn
1
a=>a.sort((a,b)=>(g=s=>eval(s.slice(B10=1)+10))(a)-g(b))ist 2 Bytes kürzer, aber das ist noch zu lang.
— Arnauld
@ GB Ich denke, es war gültig, aber jetzt ist es definitiv gültig.
— Lynn
Warum '10' und nicht etwas kürzeres verwenden? Zum Beispiel '2' speichert 2 Bytes.
— GB
1
@GB Der Trick besteht darin, die Übersetzung von der Oktalnotation "010" auf 8 als Dezimalzahl für "V0" auszulösen. Mit 2 erhalten Sie "02" = 2, was gleichbedeutend mit "0 + 2" ist.
— Arnauld
15

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:

Code-Snippet anzeigen

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

Code-Snippet anzeigen

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"
— Arnauld
quelle
Haben Sie sich die Idee zu Base Conversion / Modulo ausgedacht? Brillant!
— Kamoroso94
1
@ kamoroso94 FWIW, hier ist der Code , den ich geschrieben habe, um die Basis und das Modulo zu finden. Es gibt einige andere mögliche Antworten (mit m <1000).
— Arnauld
Ich habe a=>a.sort((a,b)=>(g=s=>parseInt(s,32)%334+s)(a)>g(b))Chrome ausprobiert . Es gibt keine richtige Antwort. f(["VB","V0","V0+","V1","V2","V3","V4","V5","V6","V7","V8","V9","V10","V11","V12","V13","V14","V15","V16","V17"])Ich bin mir nicht sicher, warum. Die kantenkompatible Version funktioniert gut mit Chrom.
— Ra8
1
@ Ra8 Ah ja. Es scheint auch für Chrome instabil zu sein. Das Zurückgeben eines Booleschen Werts von einem sort () - Rückruf ist nur ein Hack, der in Firefox funktioniert, aber wir sollten wirklich einen vorzeichenbehafteten Wert zurückgeben. Vielen Dank für Ihre Rückmeldung!
— Arnauld
12

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.

— Zgarb
quelle
11

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.

— Martin Ender
quelle
6

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
— DJMcMayhem
quelle
2
Wie passend, dass V diese Herausforderung gut meistert: P
— Business Cat
5

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! :)

— Ian H.
quelle
— LiefdeWen
@LiefdeWen Sie haben nicht die Notwendigkeit , ToArray()eine IOrderedEnumerablesollte in Ordnung sein.
— TheLethalCoder
Entschuldigung, versehentlich System.Linq-Referenz entfernt, behoben
— LiefdeWen
@TheLethalCoder Du hast wie immer Recht, 84 Bytes
— LiefdeWen
@LiefdeWen .Remove(0,1)für zusätzliche -1 Byte :)
— Ian H.
4

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.

— GB
quelle
Klug! ->x{[?B,0,"0+",*1..17].map{|a|"V#{a}"}&x}Speichert ein Byte.
— Lynn
2

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, ...
— Jonathan Allan
quelle
2

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!

— Chris_Rands
quelle
5
Es wird davon abgeraten, Ihre eigene Herausforderung sofort zu beantworten. Geben Sie einigen anderen Personen Zeit, um zu antworten, mindestens 48 Stunden, wahrscheinlich länger.
— TheLethalCoder
@TheLethalCoder Ach ja, bei Stack Overflow wird ein solches Verhalten empfohlen! Soll ich meine Antwort löschen?
— Chris_Rands
@Chris_Rands Ja, ich empfehle Ihnen, es zu löschen.
— Mr. Xcoder
9
@Downvoter: Ein neues Mitglied für etwas abzustimmen, von dem sie nicht wussten, dass es nicht cool ist; viel besser, einfach darauf hinzuweisen, dass sie es nicht sollten, wie es Lethal tat.
— Shaggy
Beachten Sie jedoch, dass Sie dies gerne tun können, wenn jemand Ihre Lösung nicht veröffentlicht. Nach dem Warten natürlich
— TheLethalCoder
1

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.

— Mr. Xcoder
quelle
1

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.

Ergebnis

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.
— Ingenieur Toast
quelle
Ich denke, dies ist das erste Mal, dass ich Google Sheets verwendet habe. Ein großes Lob an Sie und +1!
— Heather
1

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.

— Weizen-Assistent
quelle
Das ist nur so g=sortOn f, was auch drin ist Data.List.
— Lynn
1
Außerdem f(_:'1':a)='X':aspeichert 4 Byte!
— Lynn
1
@Lynn Der erste Vorschlag funktioniert, der zweite jedoch nicht. [a]Ansonsten V1muss das Muster angepasst werden. Dies ist das Problem, das ich zu umgehen versuche.
— Weizen-Zauberer
1

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.
— Mendizale
quelle
0

Python2, 77 Bytes

sorted(input(),key=lambda s:float(s[1:].replace("B","-1").replace("+",".5")))
— Setop
quelle
Ich denke das zählt als Schnipsel! Da Sie weder das Ergebnis drucken, noch ist dies eine Funktionsdefinition. Sie können ein Lambda daraus machen oder das Ergebnis ausdrucken.
— offiziell
1
@officialaimm netter versuch aber funktioniert nicht wenn v0 + vor v0 steht.
— Setop
0

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")
— Kaz
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.