İlk golf sopamda, herhangi bir hata için özür dilerim ...

bağlam

Kaya tırmanışında ( özellikle bouldering ), V / Vermin (ABD) tırmanma sınıfları 'VB' de (en kolay not) başlar ve ardından 'V0', 'V0 +', 'V1', 'V2', 'V3' , 'V4', 'V5' vb. 'V17' ye kadar (en zor not).

Görev

Bir tırmanma dereceleri listesi / dizisi olarak gireceksiniz ve en kolaydan en zoruna kadar olan sınıfların bir listesini / dizisini döndürmek veya yazdırmak zorundasınız.

Giriş boşsa, boş bir veri yapısı döndürün; Aksi halde giriş her zaman geçerli olacaktır.

Test durumları

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

Bu bir kod golf mücadelesi.

Python 2 , 58 54 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Test durumları

Firefox için:

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

Chrome veya Kenar için (+4 bayt):

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

Nasıl?

Sözlükbilimsel olarak karşılaştırılabilir dizgelere yol açan 3 ardışık dönüşüm uygularız.

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"

Kabuğu , 5 bayt

ÖiÖm±

Çevrimiçi deneyin! Sonuçlar satır başına bir tane basılır, ancak dahili olarak bu, dizelerin listesini alan ve döndüren bir işlevdir.

açıklama

Bu şaşırtıcı bir şekilde Martin Retina'nın cevabına benzer . Öncelikle Öm±“eşleştirme sırasını basamak basamaktır” anlamına gelir. Bu koyar VB, V0ve V0+, doğru sırayla onlar karşılaştırılır beri [0,0], [0,1]ve [0,1,0]. Sonra Öi, "tamsayı değerine göre sırala" anlamına geliyoruz . Bir dize verildiğinde, iiçinde bir tam sayı olarak bulunan ilk basamak sırasını veya bulunmazsa 0 değerini döndürür. Yukarıdaki üç dizenin tümü 0 olarak eşlenir ve sıralama kararlıdır, bu nedenle çıktıda doğru sırada olacaktır.

Retina , 14 bayt

B
!
O`
!
B
O#`

Çevrimiçi deneyin!

açıklama

B
!

Değiştir Bile !böylece sınıflarda koyar lexicographic sırası VB(daha sonra veya V!tüm sayısal sınıflarda önünde).

O`

Tüm giriş satırlarını sözlüksel olarak sıralayın. Bu doğru sonucu vermez, ancak V! < V0 < V0+doğru şekilde sipariş eder .

!
B

Geri V!dönüş VB.

O#`

Satırları sayısal olarak sıralayın. Retina, sıralama anahtarını belirlemek için dizedeki ilk ondalık sayıyı arar. Sayı (örneğin gibi VB) yoksa, değeri olarak ayarlar 0. Hepsi araçları VB, V0ve V0+aynı tür anahtarı var. Ancak Retina'nın sıralaması kararlıdır ve onları zaten doğru sıraya koyduk.

V , 3 bayt

Úún

Çevrimiçi deneyin!

O nasıl çalışır?

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

Bu komut ise neredeyse her satırda beri, geçerli bir çözüm olamaz (AKA, sayılarla sıralanabilir VBdeğişti kararı olmadan,) başında yer alacaktır. Ancak, yalnızca sayılara baktığından, V0ve arasında ayrım yapamaz V0+. Vim sabit bir sıralama kullandığından, hangisi önce gelirse, sıralamadan sonra ilk kalacaktır. Yani...

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

C #, 121 83 82 83 bayt

TheLethalCoder ve LiefdeWen sayesinde 39 bayt kaydedildi

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

Çevrimiçi deneyin!

Bytecount içerir using System.Linq.

Nasıl?

• Bir dizge dizisini girdi olarak alır.
• Giriş eşitse VB, değeri -1, eşitse VB0+, değeri 0 olarak ayarlayın.
• Girdiyi, sonra gelen sayı değerine göre sıralayın V.

Biraz kesmek olabilir, ama işe yarıyor! :)

Ruby , 52 42 41 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır:

Sorunu tersine çevirin, tam olarak sıralanmış listeyi oluşturun, sonra da girdilerimizle kesişim elde edin.

1 byte kaydettiğin için teşekkürler Lynn.

Pyth , 16 bayt

Python Limanı OP tarafından cevaplandı .

o|hx"B00+"tN+3st

Test paketi .

05AB1E , 17 13 8 bayt

Σþï}„VB†

Çevrimiçi deneyin!

Jöle , 9 bayt

Ḋv-.F+LµÞ

Karakter listelerini alan ve sıralı listeyi döndüren tek parça bir bağlantı.

Çevrimiçi deneyin! (altbilgi sonucu güzel biçimlendirir)

Nasıl?

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

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

Çevrimiçi deneyin!

Burada işleri başlatmak, benim Python 3ümün çözümü ... Özür dilerim, bunu kongreye karşı çok kısa bir sürede yayınladım, şimdi yeniden gönderiyorum ...

Python 3 , 69 67 bayt

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

Çevrimiçi deneyin!

Swift 3 , 102 bayt

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

Bu bir fonksiyondur. Buna şöyle diyebilirsiniz:

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

Çevrimiçi deneyin!

Bu nasıl çalışıyor?

Bu temelde @Arnauld'un şaşırtıcı Javascript cevabının limanıdır , ancak Swift için optimize edilmiştir.

Değerlerin her birini aşağıdaki tabloda gösterildiği gibi sözlüksel olarak düzenlenebilir Dizgilere eşler:

İlk Dize -> Sonuç

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

Kod Açıklaması

• String((Int($0,radix:32) ?? 992)%334)- Her String'i base-32 Number ile Ondalık arasında dönüştürür. Değerin "V0 +" olması Int(_:radix:)durumunda , çağrı nil döndürür ve "V0", 992 değerini alırız. Ayrıca sonucu alırız mod 334ve sonunda String'e dönüştürürüz.

• +$0- Geçerli değeri yukarıda oluşturulan String'e ekler. Mesela, eğer String ise V9, yukarıdaki fonksiyon geri döner 333ve V9sonuçta sonuçta ekledik 333V9.

• var r={...}- rBir isimsiz kapatmaya bir değişken bildirir , çünkü iki kez kullanıldığından beri çok fazla bayt tasarrufu sağlar.

• func f(l:[String])- fParametreli bir işlevi l, Dizelerin listesini tanımlar .

• print(l.sorted(by:{r($0)<r($1)}))- Verilen listeyi sıralamanın sonucunu yazdırır, anahtar ryukarıda tanımlanan değişkendir .

PowerShell , 45 bayt

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

Çevrimiçi deneyin!

Tam argüman listesini sıralı düzende oluşturmak için GB'nin Ruby yanıtıyla aynı işlemi kullanır , ardından -ingiriş listesi olanları seçer .

Google Sayfaları, 142 bayt

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

Giriş, A1her girişin virgülle ayrılmış olduğu bir dizedir .
Çıktı, formülün hücresi artı altındaki n-1hücrelerin bulunduğu ngirdi sayısıdır A1.

Uzun, dağınık bir formül bu yüzden açalım.

• If(A1="","",~)boş girişi düzeltir. Bu olmadan, boş bir giriş #VALUE!hata döndürür çünkü Splitişlev boş girişlerde çalışmaz.
• Transpose(Split(A1,","))A1virgüllere böler ve onu bir sütuna dönüştürür çünkü Sortişlev yalnızca sütunlarda çalışır.
• Transpose(IfError(Find(),Value()+9)) bu parçalara ayrılıyor:
  • Find(Split(A1,","),"VBV0V0+")bu dizgideki her parametreyi bulmaya çalışır. Bu ilk üçü yalnızca dizge olarak sıralanması gereken dizilerdir, bu yüzden Findsıralama düzenini almak için kullanırız .
  • Value(Mid(Split(A1,","),2,3))+9notun sayısal değerini alır. Bu sadece V1 ve üstü için önemlidir; +9Sonunda beri V1 V0 + sonra gelir sağlamaktır Finddeğer olacaktır 5. Teknik olarak, o zaman, sadece +5gereklidir, ancak doğru bir şekilde sıralandığından emin olmak için fazladan bayt harcamam gerekmiyor.
  • IfError(Find(~),Value(~))Finddizge bulunursa değeri döndürür (yani, derece VB, V0 veya V0 +). Bulunamıyorsa, notun sayısal değerini artı dokuz döndürür.
  • Transpose(IfError(~))onu tekrar bir sütuna dönüştürür, böylece Sortkullanabilir.
• Sort(Transpose(Split(~)),Transpose(IfError(Find(~),Value(~)+9)),1) artan özel sıralama düzenini kullanarak ayrık girişi sıralayarak hepsini sarar.
• ArrayFormula(~)tüm şeyi sarar, böylece sonuçları yalnızca bir dizideki ilk değeri döndürmek yerine bir dizi olarak döndürür. Bu, bir hücrede bulunan formülün altındaki hücreleri de doldurmasına neden olan şeydir.

Bash + coreutils, 21

tr B .|sort -V|tr . B

GNU sort'ın -Vürüm sıralama modu neredeyse istediğimizi yapar. Bİçin bir geçin .ve işimiz bitti.

Çevrimiçi deneyin .

Haskell , 90 84 83 61 bayt

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

Çevrimiçi deneyin!

ftırmanma derecelerini kıyaslanabilecek dizgelere dönüştüren bir fonksiyondur. Dönüştürür Eğer VBo yüksek önceliği alır böylece boş bir dize olması için, daha sonra yerini V1ile Xüç uzun önceliğini düşürmek için vardır dizeleri V10- V17. Kalanlar için hiçbir şey yapmıyoruz.

Kullandığımız listesini sıralamak için Data.Lists'ın sortOn(Lynn önerdiği gibi) bir nokta-serbest fonksiyonu oluşturmak için işlevini.

R , 45 bayt

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

Bu nasıl çalışıyor?

• Doğru sıralı sınıf vektörünü 'l' a atayın;
  • 'Sep = ""' argümanı yapmamak için 'paste' yerine 'paste0' kullanın;
• Karışık, sıralanmamış sınıflarda girdi vektörünüzde 'l' eşleşmesine göre 'l' dizini.

Python2, 77 bayt

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

Jöle , 17 11 bayt

fØD
ṢÇÞÇV$Þ

Çevrimiçi deneyin!

TXR Lisp : 45 bayt

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

Koşmak:

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 bayt

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

Çevrimiçi deneyin!