従来のボードゲームGoのプレイヤーは、ランクシステムでスキルを測定します。

• ゲームを初めてプレイするプレイヤーは30位にランクされ（書き込み30k）、1位にカウントダウンされます（書き込み1k）。これらは、学生のランクと見なされます。
• プレイヤーは、第1 段から第1 段（昇順）に昇格し、その後、第7 段（昇順）までカウントを進めます。これらはマスターランクです。1d7d
• 過去に非常に熟練したプレイヤー7dは、1番目のプロダンランク 1pに昇格し、9番目のプロダンランクまでカウントアップします（記述）。これが最高ランクです。9p

つまり、ランクが順序付けられ30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9pます。

仕事

うち2つの文字列を与えられた{ 30k、...、 1k、1d、...、 7d、1p、...、9p}を入力とし、出力が高い両者のランク。（それらが等しい場合、単にどちらかの入力を出力します。）

（通常、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バイト

カリー化構文の2つの文字列を受け取ります(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のためのプロのダンランク「XP」
• -1ためキュッランク「XK」又は「xxk」ための[1]のいずれかである「K」または数字

2）この結果を3乗します。1と-1は変更されませんが、プロのダンランクには8が与えられます。

3）ランクの小数部分を掛けます。

ゼリー、14 バイト

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

見つかった最高ランクを生成する文字列のリスト（説明どおり）を受け入れるモナドリンク。

^{* 2以外の数字でも機能します。}

オンラインでお試しください！または、テストスイートを参照してください。

どうやって？

キー関数でソートし、右端（つまり最大）を返します。

文字の、、および序有する、、及び夫々 。バイナリには8ビットが設定されていますが、他のビットには設定されていないため、ビットごとにORを実行してそれぞれ107、108、および120を取得します。D P 107 100 112 $k$$d$$p$$107$$100$$112$$107$

アマチュアランクは、私たちが文字列で終わる場合否定する、文字列で指定された番号で私たちのクラス識別子を連結でき、当社の主要な機能を完了するので、降順である（例えば- > しばらく- > ）。-コードでは、これはクラス識別子を格納し、乗算のための累乗から1を引い必要-であるバイト。$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

これを改善するには、代わりにマイナス2を使用し、要素を乗算します。これは、1回の乗算で達成できます。

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µÞṪ

見つかった最高ランクを生成する文字列のリスト（説明どおり）を受け入れるモナドリンク。

• 2以外の数値でも機能します。

オンラインでお試しください！または、テストスイートを参照してください。

どうやって？

キー関数でソートし、右端（つまり最大）を返します。

キー関数は、最初に2文字のリスト（のゼリーコード）を使用して、2 進アトムを使用してkをNyに変換して変換し、次に⁾kN（コードを使用して['k','N']）引数が9のモナドとして文字列を評価しますv9。

ゼリーで：

• N 入力を否定する単項アトム

  • したがって、コード9 30Nは実際には9を使用せず、整数になります-30

• d Pythonの2つの値の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、すべての評価に適用されるシングルバイトモナドアトムを使用できます。

Key-Valueへの入力の表は次のとおりです。

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>られたもう1つのバイト>）
（&)構文を使用して2バイト）

説明：

• 最後の文字から「k」を引きます（「d」、「k」、「p」にそれぞれn = -7、0、5を指定します）。

• 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

オンラインでお試しください！

私にとっていつものように、特にゴルフっぽいものではなく、単純な実装です。「（＃）」関数は文字列として2つのランクを取り、大きいランクを返します。質問で指定された形式でのみ機能します。

（私も使用してバージョンを試したcomparingし、maximumByそれは長く3バイトになってしまった-あなた畜生base！とあなた時折人間が読める関数名を）

（Amphibological and Lynnによる提案を適用）

Python 2、54バイト

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

オンラインでお試しください！

Arnauldのmethodを使用します。マッピングint(x,27)%9-3は最後の文字のみに依存します、最後のx数字以外のすべての数字がの倍数に貢献するので9。それはとります：

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

これは、基数26で解釈した場合、最高のダンランクである1pビートの乗数に十分なマージンです7d。

私は、この形式と他のいくつかの強引な表現でこれを見つけました。

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
• 要素が2つしかない場合は等しいため、のrank代わりに-1バイトを使用order

ゼリー、13バイト

これは、他のJellyの回答とはまったく異なるので、個別に投稿しています。

入力を2つ（またはそれ以上）の文字列のリストとして受け取ります。

“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の回答と対照的です）が、純粋に数値であるため便利です。ディスパッチも使用します（残念ながら1回のみ）

!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値をマップします。

• for 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からの直接分割は1バイト短く、63バイトになります。）

私の解決策では、1つのステップを踏むと、煩わしいバイト数がかかります。降順でのランクの繰り返しや、の要素である最初のアプローチをとるなど、他のアプローチを試しました[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バイト

入力を2つの文字列のリストとして受け取ります。

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

オンラインでお試しください！（すべてのテストケース）

どうやって？

ランク文字のASCIIコードは、次の式で乗数mに変換されます。$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バイト

@Shaggyのおかげで-1バイト

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の答えの簡単な移植版。

オンラインでお試しください！

編集：Procを使用できたことに気付くことで-6バイト

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

オンラインでお試しください！

TheLethalCoderのおかげで-1バイト

説明：

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 '...'ます。1行でスペースで区切って、stdinから入力を取得します。

いくつかの置換を実行して、比較をより簡単にします。正規表現の置換は、基本的に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の統計機能をうまく利用しています:-)

Robin Ryderの 代わりに使用する提案のおかげで-3バイトordered factor

標準入力から入力を取得します（ただし、テストを容易にするために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(".$",""));}

@SaraJのおかげで-6バイト。

オンラインでお試しください。（マッピングされた値を確認するには、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])))

オンラインでお試しください！

ジュリア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)）

Retina 0.8.2、29バイト

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

オンラインでお試しください！任意の数のランクを受け入れ、最高を出力します。説明：

O`

行を並べ替え...

$

...指定されたキーを使用しています...

^

...逆順。

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

キーは、次のように入力行から作成されます。a）（プロの）ダンランク文字b）単項のランクc）キュウ文字（該当する場合）。これは逆ソートであるため、プロのダンランクは、ダンランクと、キュウレターが最後に残っているために始まるキュウランクのp前にソートされます。ランク内では、（プロの）ダンランクは単項文字列の長さのために降順でソートされますが、キュウランクの末尾により昇順でソートされます。d1k

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削除されました。したがって、初心者はマイナスのスコアを、ダンはランクを、プロはランクを取得します* 10。WhateverStarを使用すると、クロージャが得られmax、コンパレータ機能が使用されます。

05AB1E、12 バイト

Σ'pK°.Vyþ*}θ

.V（05AB1Eコードとして評価）は、@ ArnauldのJelly answerでの同様のアプローチに触発されています。

2つ（またはそれ以上）の有効な文字列のリストとして入力します。

オンラインそれを試してみたり、すべてのテストケースを確認してください。

説明：

Σ           # 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のおかげで、この答えを作成してくれてありがとう。

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

秘trickは、rank letterand i（char code 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にあります。関数を使用して各ランクを数値に変換し、より高い値のランクを比較して出力しています。

ランク値は、の入力文字列の2番目の文字位置から取得!!dpされます。

例えば、第二の文字の位置そう1pであるpには!!dp、それはすべての8だから、整数一部となる3に1とパワード減少、3で*pランクがこれは、8で乗算され1p = 8、2p = 16、...、 9p = 72。

すべての*dランクで、整数部分に1が乗算されます（または単に乗算されません）。これは1d = 1、...、7d = 7。

そしてすべてのため*kと**kランク、の2番目の文字の位置!!dpに等しくなるfalse1つ減少及び3によって電力供給、（明示的な）0に等しいが、整数部分は-1で乗算されることを意味します。これは30k = -30、...、1k = -1。

これは私の初めてのゴルフの試みであり、どれほど悪いのかわかりません！

Excel VBA、129バイト

範囲内の入力を取得A1:A2し、コンソールに出力する匿名VBEイミディエイトウィンドウ関数。

[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