Người chơi của trò chơi bảng truyền thống Đi đo kỹ năng của họ trong một hệ thống các cấp bậc :

• Người chơi mới vào trò chơi được xếp hạng 30 kyū (viết 30k) và tiến tới đếm ngược đến 1st kyū (viết 1k). Đây được coi là hàng ngũ sinh viên .
• Một người chơi có thể thúc đẩy từ ngày 1 Kyu để 1st dan rank (bằng văn bản 1d), và sau đó tiến bộ đếm lên đến 7 dan rank (bằng văn bản 7d). Đây là hàng ngũ bậc thầy .
• Những người chơi có kỹ năng đặc biệt trong quá khứ 7dcó thể thăng hạng thứ hạng dan chuyên nghiệp đầu tiên 1p, và tiến bộ lên tới thứ hạng dan chuyên nghiệp thứ 9 (viết 9p). Đây là thứ hạng cao nhất.

Tóm lại: hàng ngũ được ra lệnh 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p.

Bài tập, nhiệm vụ

Với hai chuỗi số { 30k, ..., 1k, 1d, ..., 7d, 1p, ..., 9p} như là đầu vào, đầu ra cao hơn cấp bậc của cả hai. (Nếu chúng bằng nhau, chỉ cần xuất một trong hai đầu vào.)

(Như thường lệ, I / O rất linh hoạt - câu trả lời của bạn có thể là một chức năng hoặc một chương trình đầy đủ, đọc đầu vào theo bất kỳ cách hợp lý nào và tạo ra đầu ra theo bất kỳ cách hợp lý nào.)

Đây là môn đánh gôn : mục tiêu là để giảm thiểu số byte của mã của bạn.

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

(Định dạng : input1 input2 output.)

29k 9k    9k
21k 27k   21k
6d 1p     1p
5d 17k    5d
1k 1d     1d
1d 1d     1d
1d 2d     2d
9p 1d     9p
2d 30k    2d
1p 1k     1p
1d 1p     1p
1p 2d     1p
7p 8p     8p
30k 30k   30k

JavaScript (ES7), 58 byte

Lấy hai chuỗi trong cú pháp currying (a)(b).

a=>b=>(g=s=>parseInt(s)*'_dp'.search(s[1])**3)(a)>g(b)?a:b

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

Làm sao?

Hàm trợ giúp g () dịch chuỗi đầu vào s thành một điểm.

1) Chúng tôi tìm s [1] vào chuỗi "_dp" . Điều này mang lại:

• 1 cho thứ hạng dan "xd"
• 2 cho một hạng dan chuyên nghiệp "xp"
• -1 cho thứ hạng kyū "xk" hoặc "xxk" vì s [1] là "k" hoặc là một chữ số

2) Chúng tôi lập phương cho kết quả này, giữ nguyên 1 và -1 nhưng cho 8 điểm xếp hạng dan chuyên nghiệp .

3) Chúng tôi nhân với phần thập phân của thứ hạng.

Thạch , 14 byte

OṪ|8-2*×ṖV$µÞṪ

Một liên kết đơn âm chấp nhận một danh sách các chuỗi * (như được mô tả) mang lại thứ hạng cao nhất được tìm thấy.

^{* Cũng hoạt động với các số khác hai.}

Hãy thử trực tuyến! Hoặc xem một bộ thử nghiệm .

Làm sao?

Sắp xếp theo một chức năng chính và trả về ngoài cùng bên phải (tức là tối đa).

Các chữ cái , và có các thứ tự , và . Trong nhị phân có tám bit được đặt trong khi các bit khác thì không, do đó, bit OR-ing với 8 chúng ta nhận được 107, 108 và 120 tương ứng - những thứ này hiện theo thứ tự cần thiết để sắp xếp các lớp mà chúng xác định.d p 107 100 112 $k$$d$$p$$107$$100$$112$$107$

Các cấp bậc nghiệp dư theo thứ tự giảm dần để hoàn thành chức năng chính của chúng tôi, chúng tôi có thể nối mã định danh lớp của chúng tôi với số được đưa ra trong chuỗi, phủ định nếu chuỗi kết thúc bằng (ví dụ -> while -> ). Trong mã này yêu cầu lưu trữ định danh lớp và lũy thừa trừ đi một cho phép nhân - - là byte.$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

Để cải thiện điều này, chúng ta có thể sử dụng trừ hai thay vào đó và nhân các phần tử lại với nhau, có thể đạt được bằng một phép nhân.

OṪ|8-2*×ṖV$µÞṪ - Link: list of lists of characters
           µÞ  - sort by (Þ) the monadic link to the left (µ):
O              -   ordinals
 Ṫ             -   tail
   8           -   literal eight
  |            -   bitwise OR
    -2         -   literal minus two
      *        -   exponentiate
          $    -   last two links as a monad (of the current list of characters):
        Ṗ      -     pop (get all but rightmost character)
         V     -     evaluate as Jelly code (gets the number)
       ×       -   muliply
             Ṫ - tail (get the rightmost)

Bảng hành động của chức năng chính ...

in    ṖV$  OṪ   OṪ|8       OṪ|8-2*×ṖV$
30k   30   107  107       -4867778304876400901747340308643840 = ((-2)^107)*30
29k   29   107  107       -4705519028047187538355762298355712 = ((-2)^107)*29
...
 2k    2   107  107        -324518553658426726783156020576256 = ((-2)^107)*2
 1k    1   107  107        -162259276829213363391578010288128 = ((-2)^107)*1
 1d    1   100  108         324518553658426726783156020576256 = ((-2)^108)*1
 2d    2   100  108         649037107316853453566312041152512 = ((-2)^108)*2
 ...
 8d    8   100  108        2596148429267413814265248164610048 = ((-2)^108)*8
 9d    9   100  108        2920666982925840541048404185186304 = ((-2)^108)*9
 1p    1   112  120     1329227995784915872903807060280344576 = ((-2)^120)*1
 2p    2   112  120     2658455991569831745807614120560689152 = ((-2)^120)*2
 ...
 8p    8   112  120    10633823966279326983230456482242756608 = ((-2)^120)*8
 9p    9   112  120    11963051962064242856134263542523101184 = ((-2)^120)*9

Thạch ,  11  10 byte

^{Lấy cảm hứng để trở lại bảng vẽ của Arnauld!}

⁾kNyv9FµÞṪ

Một liên kết đơn âm chấp nhận một danh sách các chuỗi * (như được mô tả) mang lại thứ hạng cao nhất được tìm thấy.

• Cũng hoạt động với các số khác hai.

Hãy thử trực tuyến! Hoặc xem một bộ thử nghiệm .

Làm sao?

Sắp xếp theo một chức năng chính và trả về ngoài cùng bên phải (tức là tối đa).

Hàm khóa trước tiên thay đổi bất kỳ k nào để trở thành N bằng cách sử dụng nguyên tử dyadic y, dịch, với danh sách hai ký tự ⁾kN(mã Jelly cho ['k','N']) và sau đó đánh giá chuỗi là một đơn nguyên với một đối số là chín (bằng cách sử dụng mã v9).

Trong Jelly:

• N là một nguyên tử đơn nguyên phủ nhận đầu vào của nó

  • vì vậy mã 9 30Nkhông thực sự sử dụng chín và kết quả là số nguyên-30

• d là một nguyên tử dyadic mang lại kết quả của một divmod Python gồm hai giá trị - cặp kết quả của phép chia số nguyên và modulo

  • vì vậy mã 9 7dkết quả là được ghép nối với , đó là$\lfloor \frac 7 9 \rfloor$$7 \pmod 9$[0,7]

• p là một nguyên tử dyadic thực hiện một sản phẩm của Cartesian, bao gồm ẩn ý định phạm vi 1 chỉ mục của các đầu vào của nó

  • do đó, mã 9 p3sản lượng các sản phẩm Descartes của [1,2,3]và [1,2,3,4,5,6,7,8,9]đó là[[1,1],[1,2],...,[1,9],[2,1],[2,2],...,[2,9],[3,1],[3,2],...,[3,9]]

Một khi các đánh giá như vậy đã được thực hiện bằng cách sử dụng các chuỗi để so sánh, chúng ta cần có thể so sánh các kết quả; vì int không thể so sánh với danh sách, chúng ta cần bọc các giá trị phủ định trong danh sách, nhưng vì thứ tự vẫn hoạt động sau khi pdanh sách được làm phẳng (ví dụ [[1,1],[1,2],...]-> [1,1,1,2]), chúng ta có thể sử dụng nguyên tử đơn byte Fđược áp dụng cho tất cả các đánh giá.

Một bảng các đầu vào cho giá trị khóa của chúng như sau:

in    ⁾kNy    ⁾kNyv9F
30k   30N     [-30]
29k   29N     [-29]   
...
 2k    2N     [-2]
 1k    1N     [-1]
 1d    1d     [0,1]
 2d    2d     [0,2]
 ...
 6d    6d     [0,6]
 7d    7d     [0,7]                                 
 1p    1p     [1,1,1,2,...,1,9]
 2p    2p     [1,1,1,2,...,1,9,2,1,...,2,9]
 ...
 8p    8p     [1,1,1,2,...,1,9,2,1,...,7,9,8,1,...,8,9]
 9p    9p     [1,1,1,2,...,1,9,2,1,...,7,9,8,1,...,8,9,9,1,...,9,9]

Mã bình luận:

⁾kNyv9FµÞṪ - Link: list of lists of characters
       µÞ  - sort by (Þ) the monadic link to the left (µ):
⁾kN        -   two-char list = ['k', 'N']
   y       -   translate the current string (change 'k's to 'N's)
     9     -   literal nine
    v      -   evaluate (the left) as Jelly code with the input as given on the right (9)
      F    -   flatten the result
         Ṫ - tail (get the rightmost, and hence (a) maximum)

MATL , 30 28 25 23 byte

,0&)Uw'k'-tUw6*+qw*w]<G

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

(-2 byte nhờ Luis Mendo)
(một -3 byte khác thay thế v&X>bằng >, lần này dựa trên câu trả lời của Luis Mendo)
(-2 byte sử dụng &)cú pháp)

Giải trình:

• Trừ 'k' từ ký tự cuối cùng (lần lượt cho n = -7, 0, 5 cho 'd', 'k', 'p').

• Tính v = n ^ 2 + 6n-1 (lần lượt cho 7, -1, 54).

• Nhân giá trị đó v với số thứ hạng thực tế (vì vậy cấp k nhận được sản phẩm âm, cấp d đi từ 7 đến 49, cấp p từ 54 trở lên).

• Làm điều đó cho cả hai chuỗi đầu vào, so sánh các sản phẩm

• Lấy chuỗi đầu vào tương ứng với sản phẩm lớn hơn

Phương pháp thay thế, đơn giản hơn ::

23 byte

,0&)Uwo'dpk'1L6^XE*w]<G

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

,              % Do this twice (once for each input):
0&)            % Split the input into number, last letter
U              % str2num i.e. Convert '21' to 21
wo             % Bring the letter out and change it to numeric (its ASCII code)
'dpk'          % Push the array 'dpk'
1L6^           % Push [1 2 1j] and raise to ^6, giving [1 64 -1]
XE             % Find the letter in 'dpk', replace it with its corresponding 
               %  number from the second array (d=1, p=64, k=-1)
*              % Multiply the number part by this
w              % Switch to bring out the other input to top
]              % End loop
               % Stack has [second input's value, first input's value]
<              % Is second input < first input? 1 or 0
G              % Retrieve the corresponding input: 1 for 1st input,
               %  0 for last (2nd) input

Haskell , 73 71 byte

r(x,"k")=0-x
r(x,"d")=x
r(x,"p")=x+7
p=r.head.reads
a#b|p a<p b=b|0<1=a

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

Như thường lệ đối với tôi, chỉ là một triển khai thẳng tiến chứ không phải bất cứ thứ gì đặc biệt là golf-y. Hàm "(#)" nhận hai cấp dưới dạng chuỗi và trả về chuỗi lớn hơn. Chỉ hoạt động với chính xác định dạng được chỉ định trong câu hỏi.

(Tôi cũng đã thử một phiên bản bằng cách sử dụng comparingvà maximumBycuối cùng dài hơn 3 byte - chết tiệt bạn basevà tên hàm đôi khi có thể đọc được của con người!)

(Đề xuất áp dụng bởi lưỡng cư và Lynn)

Python 2 , 54 byte

lambda s:max(s,key=lambda x:(int(x,27)%9-3)*int(x,26))

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

Sử dụng phương pháp của Arnauld . Ánh xạ int(x,27)%9-3chỉ phụ thuộc vào chữ cái cuối cùng x, vì tất cả các chữ số nhưng chữ số cuối cùng đóng góp bội số của 9. Phải mất:

'k' -> -1
'p' -> 1
'd' -> 4

Đây chỉ là biên độ vừa đủ cho hệ số nhân 1pđể đánh bại 7d, thứ hạng dan cao nhất, khi được giải thích trong cơ sở 26.

Tôi đã tìm thấy điều này bằng các biểu thức cưỡng bức của hình thức này và một vài biểu hiện khác.

Python 2 , 64 byte

lambda s:max(s,key=lambda x:(ord(x[-1])|8,int(x,36)^-('k'in x)))

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

R , 73 byte

function(v)v[rank(as.double(chartr('dp','.0',sub('(.+)k','-\\1',v))))][2]

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

• Tôi đã phải sử dụng as.doublethay vì strtoivì cái sau không xử lý khoảng trắng / điểm và tôi không thể nghĩ ra một ký tự hợp lệ khác để thay thếd
• -1 byte sử dụng rankthay vì order, vì chúng bằng nhau khi chỉ có hai phần tử

Thạch , 13 byte

Điều này khá khác biệt với câu trả lời Jelly khác của tôi , vì vậy tôi đang đăng bài này một cách riêng biệt.

Đưa đầu vào dưới dạng danh sách hai (hoặc nhiều) chuỗi.

“kNdHp0”yVµÞṪ

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

Đã bình luận

“kNdHp0”yVµÞṪ
“kNdHp0”       - literal string
        y      - translate each rank character into a Jelly instruction/symbol:
                   'k' -> 'N' = negate
                   'd' -> 'H' = halve
                   'p' -> '0' = a literal zero
         V     - evaluate as Jelly code
                 examples:
                   '21k' -> '21N' -> -21
                   '7d'  -> '7H'  -> 3.5  (*)
                   '3p'  -> '30'  -> 30
          µÞ   - sort the input using all of the above
            Ṫ  - return the second entry

(*) we don't really need to halve these values, but we do want to get rid of 'd'

Julia 0,7 100 93 byte

Đó không phải là cách hiệu quả nhất, ( câu trả lời của câu trả lời Julia 0 của sundar ) nhưng nó rất hay vì nó hoàn toàn là số. Cũng sử dụng công văn (mặc dù đáng buồn chỉ một lần)

!z=(-z%2+.9)z*z
s(x,y,z)=(10x+y)*!z
s(x,z)=x*!z
~r=s(Int[r...]...)
a|b=[a,b][argmax(.~[a,b])]

Mã rất giống nhau hoạt động trong 0,6 Hãy thử trực tuyến

Làm sao:

Các mẹo là tất cả trong !(z)chức năng.

Nó ánh xạ giá trị UTF-8:

• cho kvào một số âm, vì vậy nó sắp xếp ngược
• cho dvào một số dương
• cho pvào một số dương lớn hơn

Như được hiển thị:

julia> !(Int('k'))
-1144.8999999999996

julia> !(Int('d'))
9000.0

julia> !(Int('p'))
11289.6

Kết quả kiểm tra

julia> @testset "Check it" begin
               @test "29k" | "9k" == "9k"
               @test "21k" | "27k" == "21k"
               @test "6d" | "1p" == "1p"
               @test "5d" | "17k" == "5d"
               @test "1k" | "1d" == "1d"
               @test "1d" | "1d" == "1d"
               @test "1d" | "2d" == "2d"
               @test "9p" | "1d" == "9p"
               @test "2d" | "30k" == "2d"
               @test "1p" | "1k" == "1p"
               @test "1d" | "1p" == "1p"
               @test "1p" | "2d" == "1p"
               @test "7p" | "8p" == "8p"
               @test "30k" | "30k" == "30k"
       end
Test Summary: | Pass  Total
Check it      |   14     14
Test.DefaultTestSet("Check it", Any[], 14, false)

Haskell , 64 byte

r[(n,[c])]=n*(gcd(fromEnum c)28-3)
g=r.reads
a%b|g a>g b=a|1>0=b

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

Biểu thức gcd(fromEnum c)28-3ánh xạ ký tự thành một số nhân

k -> -2
d -> 1
p -> 25

Ý tưởng là lấy các giá trị nhân vật của họ [107,100,112]và chọn 28có các yếu tố ngày càng lớn với họ, làm cho dễ dàng nhưng 107 đầu tiên là chính. Phương pháp này tiết kiệm 2 byte bằng cách viết rõ ràng một ánh xạ .

Tích hợp readsđược sử dụng để phân tách số lượng và thứ hạng.

Prelude> reads "25k" :: [(Int, String)]
[(25,"k")]

(Trên thực tế, phần tách trực tiếp từ Sara J ngắn hơn một byte, cho 63 byte .)

Bước thực hiện lớn hơn chiếm một số byte khó chịu trong giải pháp của tôi. Tôi đã thử các cách tiếp cận khác như lặp lại các cấp bậc theo thứ tự giảm dần và thực hiện phương pháp đầu tiên là một yếu tố của [a,b], nhưng chúng lại xuất hiện lâu hơn.

MATL , 28 27 byte

,w'kdp'X{'*-1 . *8'YbYXU]>G

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

,                % Do twice
  w              %   Swap. Takes implicit input
  'kdp'          %   Push this string
  X{             %   Split chars: gives cell array {'k', 'd', 'p'}
  '*-1 . *8'     %   Push this string
  Yb             %   Split at whitespace: gives cell array {'*-1', '.', '*8'}
  YX             %   Regexprep: replaces 'k' by '*-1', 'd' by '.', 'p' by '*8'
  U              %   Convert to number: evaluates string
]                % End
>                % Greater than? Gives a result r which is 0 or 1
G                % Push r-th input (modularly: 0 is last, 1 is first)

Thạch , 16 byte

Lấy đầu vào là một danh sách của hai chuỗi.

OṪ²²%90’’×ṖV$µÞṪ

Hãy thử trực tuyến! (tất cả các trường hợp thử nghiệm)

Làm sao?

$c$$m$

Cung cấp cho:

 char. | ASCII | **4       | mod 90 | -2
-------+-------+-----------+--------+----
  'k'  |   107 | 131079601 |      1 | -1
  'd'  |   100 | 100000000 |     10 |  8
  'p'  |   112 | 157351936 |     76 | 74

Đã bình luận

OṪ²²%90’’×ṖV$µÞṪ
OṪ²²%90’’        - process the rank character        takes a string, e.g. '28k'
O                - get ASCII codes                   --> [50, 56, 107]
 Ṫ               - pop                               --> 107
  ²²             - square twice                      --> 131079601
    %90          - modulo 90                         --> 1
       ’’        - decrement twice                   --> -1
          ṖV$    - process the decimal part
          Ṗ      - remove the last character         --> '28'
           V     - evaluate as Jelly code            --> 28 (integer)
         ×       - multiply                          --> -28
             µÞ  - sort input using all of the above
               Ṫ - return the second entry

Công thức thay thế

Đối với 16 byte là tốt, chúng ta có thể sử dụng:

OṪ’*9%64’×ṖV$µÞṪ

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

JavaScript (ES6), 55 54 byte

-1 byte nhờ @Shaggy

a=>b=>(s=x=>parseInt(x)*~-{p:9,d:2}[x[1]])(a)>s(b)?a:b

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

Giải trình

a=>b=>
  (s=x=>                 // Function s(x), that converts x to a "score", where a higher
                         // rank gets a higher score by
    parseInt(x)*         //   taking the integer part of x and multiplying it by
    ~-{p:9,d:2}[x[1]])  //   ~-9 (8) if it is a professional rank, ~-2 (1) if it is a dan
                         //   rank and ~-undefined (-1) if it is a kyū rank by looking up
                         //   the second character of the string
  (a)>s(b)               // Compare s(a) and s(b)
    ?a:b                 //   and return the one with the biggest score

Ruby , 52 46 byte

->s{s.max_by{|x|(5-x[-1].ord*5%8)*x.to_i(26)}}

Cổng đơn giản của câu trả lời của xnor.

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

EDIT: -6 byte bằng cách nhận ra tôi có thể đã sử dụng Proc

C # (Trình biên dịch Visual C #) , 136 135 byte

a=>b=>{string c=a.PadLeft(3,'0'),d=b.PadLeft(3,'0');int x=c[2]-d[2];return(x==0?c.CompareTo(d)*(c[2]=='k'?-1:0)>0:x==5|x>9|x==-7)?a:b;}

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

-1 Byte nhờ TheLethalCoder

Mở rộng:

static void Main()
{
    System.Func<string, System.Func<string, string>> f =
        a => b =>
        {
            string c = a.PadLeft(3, '0'),
                d = b.PadLeft(3, '0');      //Pad the input with leading '0' to be 3 characters long
            int x = c[2] - d[2];            //Calculate the difference of the letter characer (the character at index 2) as integer
            return                          //return ...
                (x == 0 ?                   //if the letter of the inputs is the same...
                c.CompareTo(d)              //  compare the padded strings resulting in a positive number if the first input is greater or a negative number if the first input is lower 
                    * (                     //  multiply the result by...
                    c[2] == 'k' ? -1 : 0    //  if the letter is 'k' then -1 else 0
                    ) > 0                   //  check if the result is greater than 0
                :                           //else (the letters are not the same)
                x == 5 | x > 9 | x == -7    //  check if the letter difference was 5 (input p and k) or 12 (> 9, input p and d) or -7 (input d and k)
                ) ? a : b;                  //  then return the first input else return the second input.
        }
    ;

    System.Console.WriteLine(f("29k")("9k"));
    System.Console.WriteLine(f("21k")("27k"));
    System.Console.WriteLine(f("6d")("1p"));
    System.Console.WriteLine(f("5d")("7k"));
    System.Console.WriteLine(f("1k")("1d"));
    System.Console.WriteLine(f("1d")("1d"));
    System.Console.WriteLine(f("1d")("2d"));
    System.Console.WriteLine(f("9p")("1d"));
    System.Console.WriteLine(f("2d")("30k"));
    System.Console.WriteLine(f("1p")("1k"));
    System.Console.WriteLine(f("1d")("1p"));
    System.Console.WriteLine(f("1p")("2d"));
    System.Console.WriteLine(f("7p")("8p"));
    System.Console.WriteLine(f("30k")("30k"));
}

Perl, 46 38 byte

s/p/0/g;s/\w*k/-$&/g;/ /;$_=@F[$`<=$']

Chạy như perl -pae '...'. Lấy đầu vào từ stdin, phân tách không gian trên một dòng.

Thực hiện một vài thay thế để làm cho so sánh "dễ dàng hơn". Các thay thế regrec về cơ bản là số tiền thay thế pbằng một số 0 ở cuối và kvới một dấu hiệu tiêu cực hàng đầu. Vì vậy, 10ktrở thành -10(vì vậy thứ tự được đảo ngược) và 3ptrở thành 30(vì vậy đó plà trên tất cả mọi thứ khác). Sau đó, nó chỉ là một so sánh số đơn giản.

Cảm ơn DomHastings cho $`/ $'gợi ý, đã loại bỏ 8 byte.

R , 65 62 byte

`+`=paste0;max(ordered(scan(,""),c(30:1+"k",1:7+"d",1:9+"p")))

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

Điều này xuất hiện ngắn hơn một chút so với các câu trả lời R trước đó và sử dụng tốt chức năng thống kê của R :-)

-3 byte nhờ đề xuất của Robin Ryder để sử dụng ordered thay vì factor

Lấy đầu vào từ stdin (mặc dù liên kết TIO cấu trúc lại một chút để dễ kiểm tra). Xếp hạng đầu vào thành một thứ tự factor của tất cả các cấp, sau đó lấy tối đa.

Đầu ra trông như:

[1] MAX_RANK
46 Levels: 30k < 29k < 28k < 27k < 26k < 25k < 24k < 23k < 22k < ... < 9p

Java 8, 128 122 121 byte

a->b->g(a)<g(b)?b:a;float g(String s){return("kdp".indexOf(s.charAt(s.length()-1))-.9f)*new Byte(s.replaceAll(".$",""));}

-6 byte nhờ @SaraJ .

Hãy thử trực tuyến. (Xem phần dưới cùng của đầu ra trong các liên kết TIO để xem các giá trị được ánh xạ.)

Giải trình:

a->b->                       // Method with two String parameters and String return-type
  g(a)<g(b)?                 //  If the mapped value of `a` is smaller than `b :
   b                         //   Return input `b` as result
  :                          //  Else:
   a;                        //   Return input `a` as result

float g(String s){           // Separated method with String parameter and float return-type
                             // (This method maps all possible Strings to a value)
 return("kdp".indexOf(       //   Take the (0-based) index in the String "kdp"
    s.charAt(s.length()-1))  //   of the last character
    -.9f)                    //   After we've subtracted 0.9
  *(                         //  And multiply it with:
    new Byte(                //   Convert the String to an integer
     s.replaceAll(".$",""));}//   After we've removed the trailing character

Haskell , 75 70 68 byte

g k=read(init k)*(abs(fromEnum(last k)*2-209)-8)
a?b|g a>g b=a|1>0=b

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

-5 bytescảm ơn @Laikoni chỉ
-2 bytesnhờ @ ASCII

Python 2 , 61 byte

Sử dụng thuật toán của Arnauld.

lambda c:max(c,key=lambda i:'_dp'.find(i[-1])**3*int(i[:-1]))

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

Câu trả lời trước, 73 byte

lambda c:max(c,key=lambda i:('dp'.find(i[-1]),int('-'*('k'in i)+i[:-1])))

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

Julia 0,6 , 75 71 65 byte

S->S[indmax((s->parse(s[1:end-1])*(search("_dp",s[2])-1)^3).(S))]

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

(-4 byte, phân tích cú pháp trong 0,6 tự động phát hiện nó là Int)

(-6 byte, sử dụng (search("_dp",s[2])-1)^3)dựa trên câu trả lời JS của Arnauld, thay vì ((c=cmp(s[end],'k'))^2*6+4c-1))

Võng mạc 0.8.2 , 29 byte

O$^`.+((k)|(.))
$3$&$*1$2
1G`

Hãy thử trực tuyến! Chấp nhận bất kỳ số lượng xếp hạng và đầu ra cao nhất. Giải trình:

O`

Sắp xếp các dòng ...

$

... sử dụng khóa được chỉ định ...

^

... theo thứ tự ngược lại.

.+((k)|(.))
$3$&$*1$2

Khóa được tạo từ dòng đầu vào như sau: a) chữ cái xếp hạng (chuyên nghiệp) dan b) thứ hạng trong unary c) chữ kyū (nếu có). Vì đây là một loại đảo ngược, thứ hạng dan chuyên nghiệp psắp xếp trước thứ hạng dan và thứ hạng dkyū bắt đầu bằng 1chữ cái kyū được để lại ở cuối. Trong các cấp bậc, cấp bậc (chuyên nghiệp) được sắp xếp theo thứ tự giảm dần do độ dài của chuỗi đơn nguyên, tuy nhiên, theo sau kcác cấp bậc kyū khiến chúng sắp xếp theo thứ tự tăng dần.

1G`

Chọn dòng đầu tiên, hiện là thứ hạng lớn nhất.

J, 39 byte

[`]@.(<&(".@}:((*_1&^)+]*0=2&|)a.i.{:))

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

giải trình

[`]@.(<&(".@}: ((* _1&^) + ] * 0 = 2&|) a. i. {:))    entire phrase
[`]@.(<&(       assign a rank number            ))
      <&                                              "less than" of the ranks of the left and right args
                                                      ie, return 1 if right arg rank is bigger
[`]@.                                                 if so, return right arg.  otherwise left
                                                      breaking down the rank number part now...
        (       assign a rank number            )
        (".@}: ((* _1&^) + ] * 0 = 2&|) a. i. {:)
        (".@}:                                  )     everything but last char, convert to number
        (                               a. i. {:)     index within ascii alphabet of the last char
                                                      these become the left and right args to what follows...
        (      ((* _1&^) + ] * 0 = 2&|)         )
        (      (           ] * 0 = 2&|)         )     the right arg * "is the right arg even?"
                                                      because only 'k' is odd (107), this will be 0 for 'k'
                                                      and will be 100 for 'd' and 112 for 'p'
        (      ((* _1&^)              )         )     left arg (number of go rank) times _1 raised
                                                      to the ascii index.  this will swap the sign
                                                      for k only, hence producing a valid rank function

Python , 59 byte

lambda s:max(s,key=lambda x:(-2)**(ord(x[-1])|8)*int(x,26))

Một hàm không tên chấp nhận một chuỗi lặp có thể trả về một chuỗi tối đa theo thứ hạng Go. Hoạt động giống như câu trả lời Jelly của tôi (chỉ sử dụng toàn bộ chuỗi được đánh giá là số nguyên trong cơ sở 26 để lưu byte).

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

C (gcc) , 95 byte

#define _(s)(strtol(s,&u,10)+(*u^15)*8)*(-(*u&2)+1)
f(s,t,u)char*s,*t,*u;{puts(_(s)>_(t)?s:t);}

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

Perl 6 , 35 byte

*.max: {{+TR/pd/0 /}(S/(.+)k/-$0/)}

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

Một cách tiếp cận khá khác nhau cho tất cả các công cụ tìm kiếm và khối này. Về cơ bản chuỗi thay thế: ...k -> -..., p -> 0, dxóa. Do đó, người mới nhận được điểm trừ, dans có được thứ hạng của họ và thuận có được thứ hạng * 10. Sử dụng Anystar giúp chúng ta đóng cửa và maxcó chức năng so sánh.

05AB1E , 12 byte

Σ'pK°.Vyþ*}θ

.V(đánh giá là mã 05AB1E) được lấy cảm hứng từ cách tiếp cận tương tự của @Arnauld trong câu trả lời Jelly của anh ấy .

Nhập dưới dạng danh sách hai (hoặc nhiều hơn) của các chuỗi hợp lệ.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Σ           # Sort the (implicit) input-list by:
 'pK       '#  Remove "p"
    °       #  Take 10 to the power this string
            #  (if the string is not a valid number, the string remains unchanged)
     .V     #  Evaluate the string as 05AB1E code
       yþ*  #  Multiply it with just the digits of the string
}θ          # After the sort: pop and push the last element
            # (which is output implicitly as result)

• k"30k""1k"-1$[-30,-1]$
• d>= 0"1d""7d"1$[1,7]$
• p°$a$$a$$a$$a$"2k""2d""2k""2d"°"2"p°100"1p""9p"$[10, 200, 3000, 40000, 500000, 6000000, 70000000, 800000000, 9000000000]$.

Xem tất cả các giá trị được ánh xạ ở đây.

Scala , 307 61 54 byte

Rất cảm ơn Kevin Crujissen và ASCII - chỉ vì công trình của họ cho câu trả lời này, đã giảm xuống ~ 250b.

Một số tối ưu hóa thuật toán cho chức năng đặt hàng của câu trả lời 61b.

l=>l.maxBy(s=>s.init.toInt*(math.abs(s.last*2-209)-8))

Các trường hợp thử nghiệm ở đây: Hãy thử trực tuyến!

Câu trả lời cũ 61 byte

l=>l.maxBy(s=>(s.init.toInt+s.last)*(math.abs(s.last-105)-3))

Bí quyết là tính khoảng cách giữa rank lettervà i(mã char 105). Sau đó, chúng tôi sử dụng khoảng cách này như một điểm số ( dan = 5, kyu = 2, pro = 7) mà chúng tôi nhân với số thứ hạng. Sau đó, chúng tôi lấy tối đa trên mảng đầu vào bằng cách sử dụng chức năng chấm điểm.

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

PHP , 100 98 byte

(-2 byte bằng cách thay đổi khai báo hàm)

<?function f($v){return(strpos('!!dp',$v[1])-1)**3*$v;};list(,$a,$b)=$argv;echo f($a)>f($b)?$a:$b;

Để chạy nó:

php -n <filename> <rank1> <rank2>

Thí dụ:

php -n go_rank.php 1p 7d

Hoặc dùng thử trực tuyến!

PHP (7.4), 74 byte

$g=fn($v)=>(strpos(__dp,$v[1])-1)**3*$v;$f=fn($a,$b)=>$g($a)>$g($b)?$a:$b;

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

Làm sao?

Tương tự như cách tiếp cận của Arnauld , nhưng trong PHP. Tôi đang sử dụng một hàm để chuyển đổi từng thứ hạng thành một giá trị số và so sánh và xuất ra thứ hạng có giá trị cao hơn.

Giá trị xếp hạng xuất phát từ vị trí ký tự thứ hai của chuỗi đầu vào !!dp, giảm đi một và sau đó được cấp nguồn thành 3 và nhân với phần nguyên của chuỗi đầu vào.

Vì vậy, ví dụ, vị trí của nhân vật thứ hai của 1pđó là ptrong !!dplà 3, giảm một và trợ tới 3 nó sẽ là 8. phần Vậy nguyên của tất cả các *pcấp bậc sẽ được nhân với 8. Điều này có nghĩa 1p = 8, 2p = 16, ..., 9p = 72.

Đối với tất cả các *dcấp bậc, phần nguyên sẽ được nhân với 1 (hoặc đơn giản là không nhân). Điều này có nghĩa 1d = 1, ..., 7d = 7.

Và đối với tất cả *kvà **kcấp bậc, vị trí của ký tự thứ hai !!dpsẽ bằng false0 (không rõ ràng), giảm đi một và được cung cấp bởi 3, có nghĩa là phần nguyên sẽ được nhân với -1. Điều này có nghĩa 30k = -30, ..., 1k = -1.

Đây là lần thử golf đầu tiên của tôi, không chắc nó tệ đến mức nào!

VBA Excel, 129 byte

Một chức năng cửa sổ tức thời VBE ẩn danh nhận đầu vào trong phạm vi A1:A2và đầu ra cho bàn điều khiển.

[B:B]="=SUBSTITUTE(A1,""p"",10)":[C1:C2]="=LEFT(B1,LEN(B1)-1)*-1^IFERROR(FIND(""k"",B1)>0,0)":?[INDEX(A:A,MATCH(MAX(C:C),C:C,0))]

Giải thích

[B:B]="=SUBSTITUTE(A1,""p"",10)"                            ''  Convert inputs to numerics 
                                                            ''  by appending 10 to rank if 
                                                            ''  is a professional dan rank
                                                            ''
[C1:C2]="=LEFT(B1,LEN(B1)-1)*-1^IFERROR(FIND(""k"",B1)>0,0)"''  Remove rightmost char; If 
                                                            ''  the rank is kyū, then mult
                                                            ''  by -1
                                                            ''
?[INDEX(A:A,MATCH(MAX(C:C),C:C,0))]                         ''  Find the max, return the 
                                                            ''  corresponding input