Mã bài golf đầu tiên của tôi, xin lỗi cho bất kỳ sai lầm ...

Bối cảnh

Trong leo núi ( cụ thể là đá cuội ), các lớp leo núi V / Vermin (Hoa Kỳ) bắt đầu ở 'VB' (lớp dễ nhất), sau đó đi 'V0', 'V0 +', 'V1', 'V2', 'V3' , 'V4', 'V5', v.v. lên đến 'V17' (loại khó nhất).

Bài tập

Bạn sẽ lấy đầu vào là một danh sách / mảng các hạng leo núi và bạn phải trả lại hoặc in một danh sách / mảng các lớp được sắp xếp từ dễ nhất đến khó nhất.

Nếu đầu vào trống, trả về cấu trúc dữ liệu trống; nếu không, đầu vào sẽ luôn luôn là một hợp lệ.

Các trường hợp thử nghiệm

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

Đây là một thách thức mã golf .

Python 2 , 58 54 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Các trường hợp thử nghiệm

Đối với 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'])))

Đối với Chrome hoặc 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'])))

Làm sao?

Chúng tôi áp dụng 3 phép biến đổi liên tiếp dẫn đến các chuỗi so sánh từ vựng.

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 byte

ÖiÖm±

Hãy thử trực tuyến! Kết quả được in một dòng trên mỗi dòng, nhưng bên trong đây là hàm lấy và trả về danh sách các chuỗi.

Giải trình

Điều này đáng ngạc nhiên tương tự như câu trả lời Retina của Martin . Đầu tiên chúng ta làm Öm±, có nghĩa là "thứ tự bằng cách ánh xạ là chữ số". Điều này đặt VB, V0và V0+theo đúng thứ tự, vì chúng được so sánh như [0,0], [0,1]và [0,1,0]. Tiếp theo chúng tôi làm Öi, có nghĩa là "thứ tự theo giá trị số nguyên". Cho một chuỗi, itrả về chuỗi chữ số đầu tiên xuất hiện trong đó dưới dạng một số nguyên hoặc 0 nếu không tìm thấy một chuỗi . Ba chuỗi ở trên đều được ánh xạ tới 0 và sắp xếp ổn định, vì vậy chúng sẽ theo đúng thứ tự trong đầu ra.

Võng mạc , 14 byte

B
!
O`
!
B
O#`

Hãy thử trực tuyến!

Giải trình

B
!

Thay thế Bbằng !thứ tự từ điển của các lớp đặt VB(hoặc sau đó V!) trước tất cả các cấp số.

O`

Sắp xếp tất cả các dòng đầu vào theo từ vựng. Điều này không cho kết quả đúng nhưng nó có thứ tự V! < V0 < V0+chính xác.

!
B

Quay V!trở lại vào VB.

O#`

Sắp xếp các dòng số. Retina chỉ cần tìm số thập phân đầu tiên trong một chuỗi để xác định khóa sắp xếp của nó. Nếu không có số (chẳng hạn như for VB), nó đặt giá trị thành 0. Điều đó có nghĩa là tất cả VB, V0và V0+có cùng một khóa sắp xếp. Nhưng loại của Retina ổn định và chúng tôi đã sắp xếp chúng theo đúng thứ tự tương đối.

V , 3 byte

Úún

Hãy thử trực tuyến!

Làm thế nào nó hoạt động?

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

Lệnh này gần như là một giải pháp hợp lệ, vì mọi dòng không thể được sắp xếp theo số (AKA, VB) sẽ được đặt ở đầu, mà không thay đổi thứ tự. Tuy nhiên, vì nó chỉ nhìn vào các con số, nên nó không thể phân biệt giữa V0và V0+. Vì Vim sử dụng một loại ổn định, nên cái nào đến trước sẽ vẫn là đầu tiên sau khi sắp xếp nó. Vì thế...

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

C #, 121 83 82 83 byte

Đã lưu 39 byte nhờ TheLethalCoder và LiefdeWen

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

Hãy thử trực tuyến!

Bytecount bao gồm using System.Linq.

Làm sao?

• Nhận được một chuỗi các chuỗi như đầu vào.
• Nếu đầu vào bằng VB, đặt giá trị thành -1, nếu bằng VB0+, đặt giá trị thành 0.
• Sắp xếp đầu vào dựa trên giá trị số đi sau V.

Có thể là một chút của một hack, nhưng nó hoạt động! :)

Ruby , 52 42 41 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

Xoay quanh vấn đề, tạo danh sách được sắp xếp đầy đủ, sau đó nhận giao điểm với đầu vào của chúng tôi.

Cảm ơn Lynn đã tiết kiệm 1 byte.

Bình thường , 16 byte

Cổng Python trả lời bởi OP.

o|hx"B00+"tN+3st

Bộ thử nghiệm .

05AB1E , 17 13 8 byte

Σþï}„VB†

Hãy thử trực tuyến!

Thạch , 9 byte

Ḋv-.F+LµÞ

Một liên kết đơn âm lấy danh sách các danh sách các ký tự và trả về danh sách đã sắp xếp.

Hãy thử trực tuyến! (chân trang định dạng kết quả độc đáo)

Làm sao?

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

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

Hãy thử trực tuyến!

Để bắt đầu mọi thứ ở đây là giải pháp Python 3 của tôi ... Xin lỗi, đã đăng bài này quá sớm so với quy ước, bây giờ đăng lại ...

Python 3 , 69 67 byte

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

Hãy thử trực tuyến!

Swift 3 , 102 byte

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

Đây là một chức năng. Bạn có thể gọi nó như vậy:

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

Hãy thử trực tuyến!

Cái này hoạt động ra sao?

Đây về cơ bản là một cổng của câu trả lời Javascript tuyệt vời của @Arnauld , nhưng được tối ưu hóa cho Swift.

Nó ánh xạ từng giá trị thành các Chuỗi theo thứ tự từ vựng như trong bảng dưới đây:

Chuỗi ban đầu -> Kết quả

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
Động cơ V6 -> 330V6
V7 -> 331V7
V8 -> 332V8
V9 -> 333V9
V0 + -> 324V0 +
V0 -> 324V0
VB -> 1VB

Giải thích mã

• String((Int($0,radix:32) ?? 992)%334)- Chuyển đổi từng chuỗi từ số cơ bản-32 thành số thập phân. Trong trường hợp giá trị là "V0 +", lệnh gọi Int(_:radix:)sẽ trả về nil và chúng tôi lấy giá trị của "V0", 992. Chúng tôi cũng lấy kết quả của mod 334và cuối cùng chuyển đổi nó thành Chuỗi.

• +$0- Thêm giá trị hiện tại vào Chuỗi được tạo ở trên. Chẳng hạn, nếu String là V9, hàm trên trả về 333và chúng ta thêm vào V9, kết quả là 333V9.

• var r={...}- Khai báo một biến rthành một bao đóng ẩn danh, bởi vì nó tiết kiệm rất nhiều byte vì nó được sử dụng hai lần.

• func f(l:[String])- Xác định hàm fvới tham số l, danh sách Chuỗi.

• print(l.sorted(by:{r($0)<r($1)}))- In kết quả sắp xếp danh sách đã cho, với khóa là biến rđược xác định ở trên.

PowerShell , 45 byte

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

Hãy thử trực tuyến!

Sử dụng quy trình tương tự như câu trả lời Ruby của GB để xây dựng danh sách đối số đầy đủ theo thứ tự được sắp xếp, sau đó chọn ra những -indanh sách đầu vào.

Google Sheets, 142 byte

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

Đầu vào là một chuỗi A1với mỗi mục được phân tách bằng dấu phẩy.
Đầu ra là ô của công thức cộng với các n-1ô bên dưới nó có nsố lượng mục nhập A1.

Đó là một công thức dài, lộn xộn, vì vậy hãy giải nén nó.

• If(A1="","",~)sửa lỗi đầu vào null. Không có cái này, một đầu vào trống sẽ trả về một #VALUE!lỗi vì Splithàm không hoạt động trên các đầu vào trống.
• Transpose(Split(A1,","))chia tách A1tại dấu phẩy và chuyển nó thành một cột vì Sorthàm chỉ hoạt động trên các cột.
• Transpose(IfError(Find(),Value()+9)) được chia thành các phần:
  • Find(Split(A1,","),"VBV0V0+")cố gắng tìm từng tham số trong chuỗi đó. Ba cái đầu tiên này là những cái duy nhất phải được sắp xếp dưới dạng chuỗi để chúng tôi sử dụng Findđể có được thứ tự sắp xếp của chúng.
  • Value(Mid(Split(A1,","),2,3))+9được giá trị bằng số của lớp. Điều này chỉ quan trọng đối với V1 và cao hơn để họ sắp xếp số lượng tốt. Các +9cuối cùng là đảm bảo V1 đưa ra sau khi V0 + từ trước đến nay Findgiá trị sẽ 5. Về mặt kỹ thuật, sau đó, chỉ +5được yêu cầu nhưng nó không tốn thêm byte để đảm bảo tăng gấp đôi chắc chắn rằng nó sắp xếp chính xác.
  • IfError(Find(~),Value(~))trả về Findgiá trị nếu chuỗi được tìm thấy (nghĩa là lớp là VB, V0 hoặc V0 +). Nếu không thể tìm thấy, nó sẽ trả về giá trị số của cấp cộng với chín.
  • Transpose(IfError(~))một lần nữa biến nó thành một cột để Sortcó thể sử dụng nó.
• Sort(Transpose(Split(~)),Transpose(IfError(Find(~),Value(~)+9)),1) kết thúc tất cả bằng cách sắp xếp đầu vào tách bằng cách sử dụng thứ tự sắp xếp tùy chỉnh tăng dần.
• ArrayFormula(~)bao bọc toàn bộ để nó trả về kết quả dưới dạng một mảng thay vì chỉ trả về giá trị đầu tiên trong mảng đó. Đây là nguyên nhân khiến công thức trong một ô cũng điền vào các ô bên dưới nó.

Bash + coreutils, 21

tr B .|sort -V|tr . B

Chế độ sắp xếp phân tán sortcủa GNU-V hầu như làm những gì chúng ta muốn. Chuyển đổi Bcho a .và chúng ta đã hoàn thành.

Hãy thử trực tuyến .

Haskell , 90 84 83 61 byte

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

Hãy thử trực tuyến!

flà một chức năng chuyển đổi các lớp leo lên chuỗi có thể được so sánh. Nếu chuyển đổi VBthành chuỗi trống để nó có mức ưu tiên cao nhất, thì nó sẽ thay thế V1bằng Xchuỗi dài ba để hạ mức ưu tiên của V10- V17. Đối với phần còn lại, chúng tôi không làm gì cả.

Để sắp xếp danh sách chúng tôi sử dụng Data.Lists's sortOnfunction (theo đề nghị của Lynn) để tạo một hàm point-miễn phí.

R , 45 byte

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

Cái này hoạt động ra sao?

• Chỉ định vectơ được sắp xếp chính xác của các lớp cho 'l';
  • Sử dụng 'paste0' thay vì 'paste' để tránh tạo đối số 'sep = ""';
• Chỉ mục 'l' dựa trên kết quả khớp 'l' trong vectơ đầu vào của các lớp hỗn hợp, chưa sắp xếp.

Python2, 77 byte

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

Thạch , 17 11 byte

fØD
ṢÇÞÇV$Þ

Hãy thử trực tuyến!

TXR Lisp : 45 byte

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

Chạy:

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 byte

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

Hãy thử trực tuyến!