ผู้เล่นเกมกระดานแบบดั้งเดิมไปวัดทักษะของพวกเขาในระบบของอันดับ :

• ผู้เล่นใหม่สำหรับเกมนี้มีอันดับที่kyū 30 (เขียน30k) และความคืบหน้านับเป็นkyūที่ 1 (เขียน1k) สิ่งเหล่านี้ถือเป็นอันดับของนักเรียน
• ผู้เล่นสามารถเลื่อนอันดับจากอันดับ 1 kyūถึงอันดับ 1 แดน (เขียน1d) และจากนั้นความคืบหน้านับขึ้นถึงอันดับ 7 แดน (เขียน7d) เหล่านี้เป็นหลักอันดับ
• ที่ผ่านมาผู้เล่นที่มีความสามารถพิเศษ7dอาจเลื่อนอันดับแดนมืออาชีพที่ 1 1pและความคืบหน้านับได้ถึงอันดับที่ 9 ของอาชีพแดน (เขียน9p) นี่คืออันดับสูงสุด

ในระยะสั้น: 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9pการจัดอันดับจะได้รับคำสั่ง

งาน

ได้รับสองสายในหมู่ { 30k, ... , 1k, 1d, ... , 7d, 1p, ... , 9p} เป็น input การส่งออกที่สูงขึ้นการจัดอันดับของทั้งสอง (ถ้ามันเท่ากันก็แค่เอาท์พุททั้งคู่)

(ตามปกติI / O นั้นยืดหยุ่น - คำตอบของคุณอาจเป็นฟังก์ชั่นหรือโปรแกรมเต็มอ่านอินพุตในรูปแบบที่สมเหตุสมผลและสร้างผลลัพธ์ในรูปแบบที่เหมาะสม)

นี่คือcode-golf : วัตถุประสงค์คือเพื่อลดจำนวนไบต์ของรหัสของคุณ

กรณีทดสอบ

(รูปแบบ: 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 ไบต์

(a)(b)ใช้เวลาสองสตริงในไวยากรณ์ความดีความชอบ

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

ลองออนไลน์!

อย่างไร?

ฟังก์ชั่นผู้ช่วยg ()แปลสตริงอินพุตsเป็นคะแนน

1) เรามองหาs [1]ลงในสตริง"_dp" สิ่งนี้ให้:

• 1สำหรับอันดับแดน"xd"
• 2สำหรับอันดับแดนมืออาชีพ"xp"
• -1สำหรับkyūอันดับ"xk"หรือ"xxk"เพราะs [1]เป็น"k"หรือหลัก

2) เราคิวบ์ผลลัพธ์นี้ซึ่งเหลือ1และ-1ไม่เปลี่ยนแปลง แต่ให้8สำหรับอันดับด่านมืออาชีพ

3) เราคูณด้วยส่วนทศนิยมของอันดับ

เยลลี่ขนาด 14 ไบต์

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

ลิงก์ monadic ยอมรับรายการของสตริง * (ตามที่อธิบาย) ซึ่งให้อันดับสูงสุดที่พบ

^{* ใช้ได้กับตัวเลขอื่นที่ไม่ใช่สอง}

ลองออนไลน์! หรือดูการทดสอบในตัว

อย่างไร?

เรียงลำดับตามฟังก์ชั่นคีย์และส่งคืนค่าสูงสุด (เช่นค่าสูงสุด)

ตัวอักษร ,และมีลำดับ ,และตามลำดับ ในไบนารีมีการตั้งค่าแปดบิตในขณะที่คนอื่นไม่ได้ดังนั้น bitwise OR-ing กับ 8 เราได้รับ 107, 108 และ 120 ตามลำดับตอนนี้อยู่ในลำดับที่จำเป็นในการเรียงลำดับชั้นเรียนที่พวกเขาระบุd p 107 100 112 $k$$d$$p$$107$$100$$112$$107$

อันดับมือสมัครเล่นอยู่ในลำดับถัดลงมาดังนั้นเพื่อให้ฟังก์ชั่นหลักของเราสมบูรณ์เราสามารถเชื่อมโยงตัวระบุคลาสของเรากับหมายเลขที่กำหนดในสตริงโดยลบถ้าสตริงสิ้นสุดใน (เช่น-> ขณะที่-> ) ในรหัสนี้ต้องเก็บ class-identifier และ exponentiating ลบหนึ่งสำหรับการคูณ - - ซึ่งคือไบต์$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

เพื่อปรับปรุงตามนี้เราสามารถใช้ลบสองแทนและคูณองค์ประกอบเข้าด้วยกันซึ่งอาจทำได้ด้วยการคูณเดียว

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)

ตารางการทำงานของคีย์ - ฟังก์ชัน ...

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

เยลลี่ ,  11  10 ไบต์

^{แรงบันดาลใจให้กลับไปที่กระดานวาดภาพโดย Arnauld!}

⁾kNyv9FµÞṪ

ลิงก์ monadic ยอมรับรายการของสตริง * (ตามที่อธิบาย) ซึ่งให้อันดับสูงสุดที่พบ

• ใช้ได้กับตัวเลขอื่นที่ไม่ใช่สอง

ลองออนไลน์! หรือดูการทดสอบในตัว

อย่างไร?

เรียงลำดับตามฟังก์ชั่นคีย์และส่งคืนค่าสูงสุด (เช่นค่าสูงสุด)

ฟังก์ชั่นที่สำคัญที่สุดเปลี่ยนkใด ๆให้กลายเป็นNโดยใช้อะตอม dyadic yแปลด้วยรายการตัวละครสองตัว⁾kN(รหัส Jelly สำหรับ['k','N']) จากนั้นประเมินสตริงเป็น monad ที่มีอาร์กิวเมนต์เก้า (โดยใช้รหัสv9)

ในเยลลี่:

• N เป็นอะตอมแบบ monadic ซึ่งขัดแย้งกับอินพุต

  • ดังนั้นรหัส9 30Nไม่ได้ใช้เก้าและผลลัพธ์ในจำนวนเต็ม-30

• d เป็น dyadic atom ที่ให้ผลลัพธ์ของ Python divmod ของสองค่า - คู่ของผลลัพธ์ของการหารจำนวนเต็มและโมดูโล

  • ดังนั้นโค้ดจะ9 7dส่งผลให้จับคู่กับซึ่งก็คือ$\lfloor \frac 7 9 \rfloor$$7 \pmod 9$[0,7]

• p เป็นอะตอม dyadic ซึ่งดำเนินการผลิตภัณฑ์คาร์ทีเซียนซึ่งรวมถึงช่วง 1 ดัชนีดัชนีโดยนัยของอินพุต

  • ดังนั้นรหัส9 p3ผลผลิตผลิตภัณฑ์คาร์ทีเซียนของ[1,2,3]และ[1,2,3,4,5,6,7,8,9]ซึ่งเป็น[[1,1],[1,2],...,[1,9],[2,1],[2,2],...,[2,9],[3,1],[3,2],...,[3,9]]

เมื่อการประเมินผลดังกล่าวได้รับการดำเนินการโดยใช้สตริงที่จะเปรียบเทียบเราจะต้องสามารถเปรียบเทียบผลลัพธ์; เนื่องจาก ints ไม่สามารถเทียบเคียงได้กับรายการที่เราจำเป็นต้องห่อค่าเมื่อตะกี้ในรายการ แต่เนื่องจากการสั่งซื้อจะยังคงทำงานหลังจากที่pรายการจะแบน (เช่น[[1,1],[1,2],...]-> [1,1,1,2]) เราสามารถใช้อะตอม monadic ไบต์เดียวที่Fใช้กับการประเมินทั้งหมด

ตารางของอินพุตไปยังคีย์ - ค่าของพวกเขามีดังนี้:

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]

ความเห็นเกี่ยวกับรหัส:

⁾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 ไบต์

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

ลองออนไลน์!

(-2 ขอบคุณไบต์หลุยส์เมนโด)
(อีก -3 ไบต์แทนที่v&X>ด้วย>คราวนี้ตามคำตอบของหลุยส์เมนโด)
(-2 ไบต์ใช้&)ไวยากรณ์)

คำอธิบาย:

• ลบ 'k' จากอักขระตัวสุดท้าย (ให้ n = -7, 0, 5 สำหรับ 'd', 'k', 'p' ตามลำดับ)

• คำนวณ v = n ^ 2 + 6n-1 (ให้ 7, -1, 54 ตามลำดับ)

• คูณค่านั้น v ด้วยหมายเลขอันดับที่แท้จริง (เพื่อให้ระดับ k ได้รับผลิตภัณฑ์เชิงลบระดับ d ไปจาก 7 ถึง 49, p ระดับจาก 54 ขึ้นไป)

• ทำเช่นนั้นสำหรับสตริงอินพุตทั้งสองเปรียบเทียบผลิตภัณฑ์

• รับสายป้อนข้อมูลที่สอดคล้องกับผลิตภัณฑ์ที่มากขึ้น

วิธีอื่นตรงไปตรงมามากขึ้น::

23 ไบต์

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

ลองออนไลน์!

,              % 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 ไบต์

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

ลองออนไลน์!

ตามปกติสำหรับฉันเพียงดำเนินการตรงไปข้างหน้ามากกว่าสิ่งใดโดยเฉพาะอย่างยิ่ง Golf-y ฟังก์ชั่น "(#)" รับสองแถวเป็นสตริงและส่งคืนที่ใหญ่กว่า ใช้ได้กับรูปแบบที่ระบุในคำถามเท่านั้น

(ฉันเคยลองรุ่นที่ใช้comparingแล้วmaximumByแต่มันกลับมีความยาว 3 ไบต์ - ด่าว่าคุณbaseและชื่อฟังก์ชั่นที่มนุษย์อ่านได้ในบางครั้ง!)

(คำแนะนำประยุกต์โดยสัตว์ครึ่งบกครึ่งน้ำและ Lynn)

Python 2 , 54 ไบต์

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

ลองออนไลน์!

โดยใช้วิธีการ Arnauld ของ การแมปint(x,27)%9-3ขึ้นอยู่กับตัวอักษรตัวสุดท้ายของxเนื่องจากตัวเลขทั้งหมด แต่ตัวสุดท้ายนั้นมีหลาย9ตัว ใช้เวลา:

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

นี่คืออัตรากำไรแทบจะไม่พอสำหรับตัวคูณสำหรับ1pที่จะชนะ7dยศแดนที่สูงที่สุดเมื่อตีความในฐาน 26

ฉันพบสิ่งนี้ด้วยการแสดงออกที่โหดร้ายของแบบฟอร์มนี้และอีกสองสามคน

Python 2 , 64 ไบต์

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

ลองออนไลน์!

R , 73 ไบต์

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

ลองออนไลน์!

• ฉันต้องใช้as.doubleแทนstrtoiเนื่องจากตัวหลังไม่ได้จัดการช่องว่าง / จุดและฉันไม่สามารถนึกถึงตัวละครที่ถูกต้องตัวอื่นที่จะมาแทนที่d
• -1 ไบต์ใช้rankแทนorderเนื่องจากมีค่าเท่ากันเมื่อมีเพียงสององค์ประกอบ

เยลลี่ขนาด 13 ไบต์

นี่ค่อนข้างแตกต่างจากคำตอบอื่น ๆของฉันดังนั้นฉันโพสต์นี้แยกต่างหาก

รับอินพุตเป็นรายการของสองสตริง (หรือมากกว่า)

“kNdHp0”yVµÞṪ

ลองออนไลน์!

แสดงความคิดเห็น

“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 ไบต์

มันไม่ใช่วิธีที่มีประสิทธิภาพมากที่สุด (ตรงกันข้ามกับคำตอบของJulia 0.6 คำตอบ @ sundar ) แต่ก็ดีเพราะมันเป็นตัวเลขล้วนๆ ใช้การจัดส่งด้วย (แต่น่าเสียดายเพียงครั้งเดียวเท่านั้น)

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

รหัสที่คล้ายกันมากใช้งานได้ใน 0.6 ลองออนไลน์

วิธี:

เคล็ดลับอยู่ใน!(z)ฟังก์ชั่น

มันจับคู่ค่า UTF-8:

• สำหรับkเป็นจำนวนลบจึงเรียงลำดับไปข้างหลัง
• สำหรับdเป็นจำนวนบวก
• สำหรับpจำนวนบวกที่มากขึ้น

ตามที่ปรากฏ:

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

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

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

ผลการทดสอบ

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 ไบต์

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

ลองออนไลน์!

นิพจน์จะgcd(fromEnum c)28-3จับคู่อักขระกับตัวคูณ

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

ความคิดคือการใช้ค่าตัวละครของพวกเขา[107,100,112]และเลือกที่28จะมีปัจจัยขนาดใหญ่มากขึ้นเหมือนกันกับพวกเขาทำง่าย แต่คนแรก 107 เป็นนายก วิธีการนี้จะช่วยประหยัด 2 ไบต์กว่าอย่างชัดเจนเขียนออกการทำแผนที่

บิวด์อินreadsใช้เพื่อแยกหมายเลขและอันดับ

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

(ที่จริงแล้วการแยกโดยตรงจาก Sara Jนั้นสั้นกว่าหนึ่งไบต์ให้63 ไบต์ )

ขั้นตอนที่ใหญ่กว่าใช้จำนวนไบต์ที่น่ารำคาญในโซลูชันของฉัน ฉันพยายามใช้วิธีการอื่น ๆ เช่นการทำซ้ำในช่วงการจัดอันดับในการลดการสั่งซื้อและการเป็นคนแรกที่องค์ประกอบของ[a,b]แต่พวกเขาก็เปิดออกอีกต่อไป

MATL , 28 27 ไบต์

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

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

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

เยลลี่ขนาด 16 ไบต์

รับอินพุตเป็นรายการของสองสตริง

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

ลองออนไลน์! (กรณีทดสอบทั้งหมด)

อย่างไร?

$c$$m$

ซึ่งจะช่วยให้:

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

แสดงความคิดเห็น

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

สูตรทางเลือก

สำหรับ 16 ไบต์เช่นกันเราสามารถใช้:

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

ลองออนไลน์!

JavaScript (ES6), 55 54 ไบต์

-1 ไบต์ขอบคุณ @Shaggy

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

ลองออนไลน์!

คำอธิบาย

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 ไบต์

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

พอร์ตที่ตรงไปตรงมาของคำตอบของ xnor

ลองออนไลน์!

แก้ไข: -6 ไบต์โดยตระหนักว่าฉันสามารถใช้ Proc

C # (คอมไพเลอร์ Visual C #) , 136 135 ไบต์

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;}

ลองออนไลน์!

-1 ไบต์ขอบคุณ TheLethalCoder

Expanation:

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 ไบต์

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

perl -pae '...'ทำงานเป็น รับอินพุตจาก stdin คั่นด้วยช่องว่างบนหนึ่งบรรทัด

ดำเนินการแทนที่สองครั้งเพื่อทำการเปรียบเทียบ "ง่ายขึ้น" การแทนที่ regexp นั้นจำเป็นต้องแทนที่pด้วยศูนย์ต่อท้ายและkด้วยเครื่องหมายลบชั้นนำ ดังนั้น10kจะกลายเป็น-10(ดังนั้นการสั่งซื้อจะถูกย้อนกลับ) และ3pกลายเป็น30(เพื่อให้pเหนือสิ่งอื่นใด) จากนั้นเป็นการเปรียบเทียบเชิงตัวเลขอย่างง่าย

ขอบคุณ DomHastings สำหรับคำแนะนำ$`/ $'ซึ่งได้ตัดออกไป 8 ไบต์

R , 65 62 ไบต์

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

ลองออนไลน์!

สิ่งนี้สั้นกว่าคำตอบ R ก่อนหน้าเล็กน้อยและใช้ประโยชน์จากฟังก์ชันสถิติของ R :-)

-3 ไบต์ขอบคุณคำแนะนำของRobin Ryderที่จะใช้ ordered แทน factor

รับอินพุตจาก stdin (แม้ว่าลิงก์ TIO จะจัดโครงสร้างใหม่เล็กน้อยเพื่อความสะดวกในการทดสอบ) แบ่งลำดับอินพุตเป็นลำดับ factorของทุกลำดับจากนั้นนำค่าสูงสุด

ผลลัพธ์ดูเหมือนว่า:

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

Java 8, 128 122 121 ไบต์

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 ไบต์ขอบคุณที่@SaraJ

ลองออนไลน์ (ดูที่ด้านล่างของเอาต์พุตในลิงก์ TIO เพื่อดูค่าที่แมป)

คำอธิบาย:

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 ไบต์

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

ลองออนไลน์!

-5 bytesขอบคุณ @Laikoni
-2 bytesขอบคุณ @ ASCII เท่านั้น

Python 2 , 61 ไบต์

ใช้อัลกอริทึมของ Arnauld

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

ลองออนไลน์!

คำตอบก่อนหน้า 73 ไบต์

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

ลองออนไลน์!

Julia 0.6 , 75 71 65 ไบต์

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

ลองออนไลน์!

(-4 bytes, แจงใน 0.6 auto ตรวจพบว่าเป็น Int)

(-6 ไบต์ใช้(search("_dp",s[2])-1)^3)ตามคำตอบ JS ของ Arnauld แทน((c=cmp(s[end],'k'))^2*6+4c-1))

เรติน่า 0.8.2 , 29 ไบต์

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

ลองออนไลน์! ยอมรับอันดับใด ๆ และส่งออกสูงสุด คำอธิบาย:

O`

จัดเรียงเส้น ...

$

... โดยใช้คีย์ที่ระบุ ...

^

... ในลำดับย้อนกลับ

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

กุญแจถูกสร้างขึ้นจากบรรทัดอินพุตดังต่อไปนี้: a) ตัวอักษร (มืออาชีพ) และตัวอักษรอันดับข) อันดับในแบบยูนารีค) ตัวอักษรkyū (ถ้ามี) เนื่องจากนี่เป็นการเรียงลำดับแบบย้อนกลับอันดับมืออาชีพแดนpจะเรียงลำดับก่อนอันดับแดนdและอันดับkyūซึ่งเริ่มต้นด้วย1เนื่องจากจดหมายkyūถูกทิ้งไว้ที่ท้าย ภายในอันดับที่ (มืออาชีพ) และอันดับการจัดเรียงจากมากไปน้อยเนื่องจากความยาวของสตริงที่แตกต่างกันอย่างไรก็ตามการลากkสำหรับตำแหน่งkyūทำให้พวกเขาเรียงตามลำดับจากน้อยไปมาก

1G`

เลือกบรรทัดแรกซึ่งตอนนี้เป็นอันดับที่ยิ่งใหญ่ที่สุด

J, 39 ไบต์

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

ลองออนไลน์!

คำอธิบาย

[`]@.(<&(".@}: ((* _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 ไบต์

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

ฟังก์ชั่นที่ไม่มีชื่อยอมรับการทำซ้ำของสตริงซึ่งจะส่งกลับสูงสุดโดยอันดับไป ทำงานคล้ายกับคำตอบ Jelly ของฉัน (เพียงใช้สตริงทั้งหมดที่ประเมินเป็นจำนวนเต็มในฐาน 26 เพื่อบันทึกไบต์)

ลองออนไลน์!

C (gcc) , 95 ไบต์

#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);}

ลองออนไลน์!

Perl 6 , 35 ไบต์

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

ลองออนไลน์!

วิธีที่แตกต่างกันมากสำหรับสิ่งที่ค้นหาและลูกบาศก์นี้ โดยเฉพาะอย่างยิ่งการเปลี่ยนสตริง: ...k -> -..., p -> 0, dลบ ดังนั้นผู้เล่นใหม่จะได้คะแนนลบ, ได้อันดับของพวกเขาและข้อดีจะได้อันดับ * 10 การใช้ AnythingStar ทำให้เราปิดและmaxใช้ฟังก์ชันการเปรียบเทียบ

05AB1E , 12 ไบต์

Σ'pK°.Vyþ*}θ

.V(ประเมินรหัส 05AB1E) เป็นแรงบันดาลใจ@Arnauld 's วิธีการที่คล้ายกันในคำตอบของเขาวุ้น

อินพุตเป็นรายการของสอง (หรือมากกว่า) ของสตริงที่ถูกต้อง

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

Σ           # 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]$.

ดูค่าที่แมปทั้งหมดที่นี่

Scala , 307 61 54 ไบต์

ต้องขอบคุณKevin CrujissenและASCII เท่านั้นสำหรับงานของพวกเขาในคำตอบนี้

การปรับอัลกอริทึมบางอย่างสำหรับการสั่งซื้อฟังก์ชั่น 61b คำตอบ

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

กรณีทดสอบที่นี่: ลองออนไลน์!

คำตอบเก่า 61 ไบต์

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

เคล็ดลับคือการคำนวณระยะทางระหว่างrank letterและi(รหัส char 105) จากนั้นเราใช้ระยะทางนี้เป็นคะแนน ( แดน = 5, kyu = 2, pro = 7) ที่เราคูณด้วยหมายเลขอันดับ จากนั้นเราจะใช้ประโยชน์สูงสุดจากอินพุตอาเรย์โดยใช้ฟังก์ชั่นการให้คะแนน

ลองออนไลน์ด้วย!

PHP , 100 98 ไบต์

(-2 ไบต์โดยเปลี่ยนการประกาศฟังก์ชัน)

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

วิธีเรียกใช้:

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

ตัวอย่าง:

php -n go_rank.php 1p 7d

หรือลองออนไลน์!

PHP (7.4), 74 ไบต์

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

ลองออนไลน์!

อย่างไร?

คล้ายกับแนวทางของ Arnauldแต่ใน PHP ฉันใช้ฟังก์ชั่นในการแปลงแต่ละอันดับเป็นค่าตัวเลขและเปรียบเทียบและส่งออกรายการที่มีค่าสูงกว่า

ค่าอันดับมาจากตำแหน่งอักขระที่สองของอินพุตสตริง!!dpลดลงหนึ่งแล้วขับเคลื่อนไปที่ 3 และคูณด้วยส่วนจำนวนเต็มของสตริงอินพุต

ดังนั้นสำหรับตัวอย่างเช่นตำแหน่งของตัวละครที่สองของ1pซึ่งเป็นpใน!!dp3 ลดลงโดยหนึ่งและขับเคลื่อน 3 ก็จะเป็นส่วนหนึ่ง 8. ดังนั้นจำนวนเต็มของทุก*pตำแหน่งจะถูกคูณด้วย 8 ซึ่งหมายความว่า1p = 8, 2p = 16, ... 9p = 72,

สำหรับการ*dจัดอันดับทั้งหมดส่วนจำนวนเต็มจะถูกคูณด้วย 1 (หรือไม่มีการคูณ) หมายความว่า1d = 1... , 7d = 7.

และสำหรับทุกคน*kและ**kอันดับตำแหน่งของตัวละครที่สอง!!dpจะเท่ากับfalse0 (ไม่ชัดเจน) ลดลงหนึ่งและขับเคลื่อนด้วย 3 หมายความว่าส่วนจำนวนเต็มจะถูกคูณด้วย -1 หมายความว่า30k = -30... , 1k = -1.

นี่เป็นครั้งแรกที่ฉันพยายามตีกอล์ฟ แต่ไม่แน่ใจว่ามันแย่ขนาดไหน

Excel VBA ขนาด 129 ไบต์

VBE แบบไม่ระบุชื่อฟังก์ชันหน้าต่างแบบทันทีที่รับอินพุตในช่วงA1:A2และเอาต์พุตไปยังคอนโซล

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

ชี้แจง

[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