Which Go rank is higher?

Question

Players of the traditional board game Go measure their skill in a system of ranks:

• Players new to the game are ranked 30th kyū (written 30k) and progress counting down to 1st kyū (written 1k). These are considered the student ranks.
• A player may promote from 1st kyū to 1st dan rank (written 1d), and then progress counting up to 7th dan rank (written 7d). These are the master ranks.
• Exceptionally skilled players past 7d may promote to the 1st professional dan rank 1p, and progress counting up to 9th professional dan rank (written 9p). This is the highest rank.

In short: ranks are ordered 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p.

Task

Given two strings among {30k, …, 1k, 1d, …, 7d, 1p, …, 9p} as input, output the higher rank of the two. (If they are equal, simply output either input.)

(As usual, I/O is flexible — your answer may be a function or a full program, reading input in any reasonable fashion and producing output in any reasonable fashion.)

This is code-golf: the objective is to minimize your code's byte count.

Test cases

(Format: 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

Answer 1

R, 83 bytes

function(v,k=-1,d=1,p=10)v[1+do.call("<",as.list(parse(t=gsub('(\\D)','*\\1',v))))]

Try it online!

Inspired by this answer by Zahiro Mor and digEmAll's comments on the answer. OP has not replied to comments so I am posting it separately, adding my own do.call twist to it to save additional bytes.

do.call takes arguments to the function as a list, which we do not need to eval before passing - a parse is sufficient. Still, as.list costs a lot of bytes...

Still not as golfy as digEmAll's chartr answer!

Answer 2

[R], 87 [bytes]

update:

using JayCe's golfing: f=function(v,k=-1,d=1,p=10)v[eval(parse(t=paste(gsub('(\\D)','*\\1',v),collapse='<')))+1]

[R], 150 [bytes]

a long answer I find interesting could save a lot of bytes if not sticking to the eval method. inputs are s1 and s2:

f=function(s)eval(parse(t=sub("\\D+",paste0("*",c(-1,1,8)[match(tail(el(strsplit(s,"")),1), c("k","d","p"))]),s)));c(s1,s2)[as.numeric(f(s1)<f(s2))+1]

Answer 3

JavaScript (Node.js), 53 bytes

a=>b=>(s=([d,q])=>-d+q|{p:8*d,d,k:-d}[q])(a)>s(b)?a:b

Try it online!

Optimized from tsh's comment in https://codegolf.stackexchange.com/a/168183/

Answer 4

Pyth, 15 bytes

Also uses Arnauld's method.

eo*^x"_dp"eN3.v

Try it here!

Answer 5

Jelly, 20 bytes

6ị⁾kpiị“¡µ£‘’×ṖV$µÞṪ

Try it online!

Answer 6

Kotlin, 256 bytes

{f:String,s:String->{val e={s:String->if(s.length==2)"0$s"
else s}
val d=e(f)
val n=e(s)
val r=when(d[2]){'k'->if(n[2]=='k')if(d<n)f
else s
else s
'd'->if(n[2]=='d')if(d<n)s
else f
else if(n[2]=='k')f
else s
else->if(n[2]=='p')if(d<n)s
else f
else f}
r}()}

Try it online!

Answer 7

Go, 168 bytes

import(."strings"
."strconv")
func g(s string)int{i:=IndexByte("_dp", s[1])
j,_:=Atoi(s[:len(s)-1])
return i*i*i*j}
func f(a,b string)string{if g(a)>g(b){b=a}
return b}

Translation of Arnaud's idea. Had to be done for the sake of the language name.