传统棋盘游戏Go的玩家使用等级系统衡量他们的技能：

• 新加入该游戏的玩家排名第30kyū（书面30k），并递减至第1kyū（书面1k）。这些被认为是学生等级。
• 玩家可以从第1推动圭以1 丹等级（书面1d），然后进度上数到第七丹等级（书面7d）。这些是大师级的队伍。
• 过去非常熟练的运动员7d可以晋升为第一职业丹等级 1p，并逐步增长到第九职业丹等级（书面9p）。这是最高等级。

简而言之：等级是有序的30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p。

任务

鉴于中两个字符串{ 30k，... 1k，1d...， 7d，1p，... 9p}作为输入，输出更高的两个级别。（如果它们相等，则只需输出其中一个输入。）

（通常，I / O是灵活的，您的答案可以是函数或完整程序，可以以任何合理的方式读取输入并以任何合理的方式产生输出。）

这是代码高尔夫球：目的是最大程度地减少代码的字节数。

测试用例

（格式：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个字节

采用currying语法的两个字符串(a)(b)。

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

在线尝试！

怎么样？

辅助函数g（）将输入字符串s转换为乐谱。

1）我们在字符串“ _dp”中寻找s [1]。这给出：

• 1对于丹排名“XD”
• 2代表专业dan等级“ xp”
• 对于kyū等级“ xk”或“ xxk”，为-1，因为s [1]是“ k”或数字

2）我们对这个结果求立方，保留1和-1不变，但给出8的专业丹等级。

3）我们乘以等级的小数部分。

果冻，14 字节

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

单子链接接受一个字符串列表*（如上所述），该列表可产生最高的排名。

^{*也适用于非两个数字。}

在线尝试！或见一个测试套件。

怎么样？

按键函数排序并返回最右边（即最大值）。

字母，，和具有序数，，和分别。在二进制它设置了8位，而其他二进制位则没有，所以分别与8进行按位或运算，我们分别得到107、108和120-现在，它们按照对它们标识的类进行排序的顺序。ð p 107 100 112 $k$$d$$p$$107$$100$$112$$107$

业余人员的排名是降序排列的，因此要完成我们的关键功能，我们可以将类标识符与字符串中给定的数字连接起来，否定字符串是否以结尾（例如-> while- > ）。在代码这需要存储所述类标识符和幂减去乘法一个- -这是个字节。$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µÞṪ

单子链接接受一个字符串列表*（如上所述），该列表可产生最高的排名。

• 也适用于除两个以外的数字。

在线尝试！或见一个测试套件。

怎么样？

按键函数排序并返回最右边（即最大值）。

关键函数首先使用二元原子将任何k更改为Ny，并使用两个字符的列表进行翻译⁾kN（用于的Jelly代码['k','N']），然后将该字符串评估为参数为9的monad（通过使用代码v9）。

在果冻中：

• N 是一元原子，它否定其输入

  • 所以代码9 30N实际上并没有使用9并导致整数-30

• d 是二元原子，它产生两个值的python divmod的结果-整数除法和取模的结果对

  • 因此代码9 7d导致配对这是$\lfloor \frac 7 9 \rfloor$$7 \pmod 9$[0,7]

• p 是执行笛卡尔乘积的二进位原子，包括其输入的隐式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]]

一旦使用要比较的字符串进行了这种评估，我们就需要能够比较结果。由于int与列表不具有可比性，因此我们需要将取反的值包装在列表中，但是由于在将p列表展平后（例如[[1,1],[1,2],...]-> [1,1,1,2]），排序仍然可以进行，因此我们可以将单字节单子原子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

在线尝试！

（感谢Luis Mendo，为-2个字节）
（根据Luis Mendo的回答，这次将另一个-3字节替换v&X>为>，）
（-2个字节，使用&)语法）

说明：

• 从最后一个字符中减去“ k”（分别为“ d”，“ k”和“ p”赋予n = -7、0、5）。

• 计算v = n ^ 2 + 6n-1（分别给出7，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和您偶尔可读的函数名！）

（Amphibologic和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个字节

这与我的其他Jelly答案完全不同，因此我将其单独发布。

将输入作为两个（或更多）字符串的列表。

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

朱莉娅0.7 100 93字节

这不是最有效的方法，（与@sundar的Julia 0.6答案相反），但这很好，因为它是纯数字形式的。也使用调度（尽管遗憾的是只有一次）

!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

红宝石，52 46字节

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

直截了当地的xnor的答案。

在线尝试！

编辑：-6字节，通过意识到我可以使用Proc

C＃（Visual C＃编译器），136135字节

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

扩充内容：

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 '...'。从标准输入接收输入，在一行上用空格分隔。

执行几次替换，使比较“更轻松”。正则表达式替换实质上等于用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

爪哇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-only

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

在线尝试！

朱0.6，75个 71 65字节

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

在线尝试！

（-4字节，在0.6中解析自动将其检测为Int）

（-6个字节，(search("_dp",s[2])-1)^3)根据Arnauld的JS答案使用，而不是((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）（专业的）dan排名字母b）一元的排名c）kyū字母（如果适用）。由于这是反向排序，因此专业dan等级p在dan等级d和kyū等级之前进行排序，1因为kyū字母保留在末尾，所以以kyrank开头。k在行内，由于一元字符串的长度，（专业）dan行按降序排序，但是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))

接受字符串可迭代的未命名函数，该函数按Go等级返回最大值。就像我的果冻答案一样工作（只是使用以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删除。因此，新手获得的分数为负，dans获得的排名为10，而pros获得的排名为10。使用WhateverStar可以使我们闭包，并max具有比较器功能。

05AB1E，12 个字节

Σ'pK°.Vyþ*}θ

.V（评估为05AB1E代码）受到@Arnauld在Jelly答案中的类似方法的启发。

输入两个（或多个）有效字符串的列表。

在线尝试或验证所有测试用例。

说明：

Σ           # 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-only在这个答案上所做的工作，使答案降到了250b左右。

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（字符代码105）。然后，我们将此距离用作分数（dan = 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，先减小1，然后乘幂3，再乘以输入字符串的整数部分。

因此，例如，第二个字符的位置的1p这是p在!!dp为3，减少一个和动力至3这将是所有8的所以整数部分*p行列将由8相乘这意味着1p = 8，2p = 16，...， 9p = 72。

对于所有*d等级，整数部分将乘以1（或根本不乘）。这意味着1d = 1，...，7d = 7。

并为所有*k和**k行列，在第二个字符的位置!!dp将等于false它等于0（无显式的），由一个减少，并且搭载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