Pemain game papan tradisional Go mengukur keterampilan mereka dalam sistem peringkat :

• Pemain baru dalam game ini peringkat ke-30 kyu (tertulis 30k) dan maju menghitung mundur ke 1 kyu (tertulis 1k). Ini dianggap peringkat siswa .
• Seorang pemain dapat mempromosikan dari 1 kyu ke 1 Dan peringkat (ditulis 1d), dan kemudian kemajuan menghitung sampai ke-7 Dan peringkat (ditulis 7d). Ini adalah peringkat utama .
• Pemain yang sangat terampil masa lalu 7ddapat mempromosikan ke peringkat dan profesional 1 1p, dan kemajuan penghitungan hingga peringkat profesional Dan ke 9 (tertulis 9p). Ini adalah peringkat tertinggi.

Singkatnya: peringkat diperintahkan 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p.

Tugas

Mengingat dua string antara { 30k, ..., 1k, 1d, ..., 7d, 1p, ..., 9p} sebagai input, output yang lebih tinggi pangkat dua. (Jika keduanya sama, cukup output salah satu input.)

(Seperti biasa, I / O fleksibel - jawaban Anda bisa berupa fungsi atau program penuh, membaca input dengan cara yang masuk akal dan menghasilkan output dengan cara yang masuk akal.)

Ini adalah kode-golf : tujuannya adalah untuk meminimalkan jumlah byte kode Anda.

Uji kasus

(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

JavaScript (ES7), 58 byte

Membawa dua string dalam sintaks currying (a)(b).

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

Cobalah online!

Bagaimana?

Fungsi helper g () menerjemahkan string input s menjadi skor.

1) Kami mencari s [1] ke dalam string "_dp" . Ini memberi:

• 1 untuk dan peringkat "xd"
• 2 untuk peringkat profesional dan "xp"
• -1 untuk peringkat kyū "xk" atau "xxk" karena s [1] adalah "k" atau digit

2) Kami cube hasil ini, yang berarti 1 dan -1 tidak berubah tetapi memberikan 8 untuk peringkat Dan profesional .

3) Kami mengalikan bagian desimal dari peringkat.

Jelly , 14 byte

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

Tautan monadik yang menerima daftar string * (seperti yang dijelaskan) yang menghasilkan peringkat tertinggi ditemukan.

^{* Juga berfungsi dengan angka selain dua.}

Cobalah online! Atau lihat test-suite .

Bagaimana?

Urutkan oleh fungsi kunci dan mengembalikan paling kanan (yaitu maksimum).

Huruf , , dan masing-masing memiliki tata cara , , dan . Dalam biner, memiliki delapan bit yang ditetapkan sementara yang lain tidak, maka dengan bitwise ATAU dengan 8 kita mendapatkan 107, 108, dan 120 masing-masing - ini sekarang dalam urutan yang diperlukan untuk mengurutkan kelas yang mereka identifikasi.d p 107 100 112 $k$$d$$p$$107$$100$$112$$107$

Peringkat amatir berada dalam urutan menurun sehingga untuk melengkapi fungsi kunci kami, kami dapat menggabungkan pengidentifikasi kelas kami dengan angka yang diberikan dalam string, meniadakan jika string berakhir dengan (misalnya -> saat -> ). Dalam kode ini diperlukan penyimpanan pengenal kelas dan eksponensial minus satu untuk perkalian - - yang byte.$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

Untuk memperbaiki ini, kita dapat menggunakan minus dua sebagai gantinya dan melipatgandakan elemen bersama-sama, yang dapat dicapai dengan satu perkalian.

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)

Tabel tindakan fungsi-kunci ...

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

Jelly ,  11  10 byte

^{Terinspirasi untuk kembali ke papan gambar oleh Arnauld!}

⁾kNyv9FµÞṪ

Tautan monadik yang menerima daftar string * (seperti yang dijelaskan) yang menghasilkan peringkat tertinggi ditemukan.

• Juga berfungsi dengan angka selain dua.

Cobalah online! Atau lihat test-suite .

Bagaimana?

Urutkan oleh fungsi kunci dan mengembalikan paling kanan (yaitu maksimum).

Fungsi kunci pertama-tama mengubah setiap k menjadi N menggunakan atom diad y, menerjemahkan, dengan daftar dua karakter ⁾kN(kode Jelly untuk ['k','N']) dan kemudian mengevaluasi string sebagai monad dengan argumen sembilan (dengan menggunakan kode v9).

Dalam Jelly:

• N adalah atom monadik yang meniadakan inputnya

  • jadi kode 9 30Ntersebut tidak benar-benar menggunakan sembilan dan menghasilkan bilangan bulat-30

• d adalah atom diad yang menghasilkan hasil divmod Python dari dua nilai - pasangan hasil pembagian integer dan modulo

  • sehingga kode 9 7dmenghasilkan dipasangkan dengan yang merupakan$\lfloor \frac 7 9 \rfloor$$7 \pmod 9$[0,7]

• p adalah atom dyadic yang melakukan produk Cartesian, yang mencakup kisaran terindikasi 1-indeksasi inputnya

  • jadi kode 9 p3menghasilkan produk Cartesian [1,2,3]dan [1,2,3,4,5,6,7,8,9]yang mana[[1,1],[1,2],...,[1,9],[2,1],[2,2],...,[2,9],[3,1],[3,2],...,[3,9]]

Setelah evaluasi tersebut dilakukan dengan menggunakan string untuk dibandingkan, kita harus dapat membandingkan hasilnya; karena int tidak dapat dibandingkan dengan daftar, kita perlu membungkus nilai yang dinegasikan dalam daftar, tetapi karena pemesanan masih akan berfungsi setelah pdaftar diratakan (misalnya [[1,1],[1,2],...]-> [1,1,1,2]) kita dapat menggunakan atom monadik bita-tunggal yang Fditerapkan untuk semua evaluasi.

Tabel input ke nilai kunci mereka adalah sebagai berikut:

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]

Komentar kode:

⁾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

Cobalah online!

(-2 byte terima kasih kepada Luis Mendo)
(lain -3 byte mengganti v&X>dengan >, kali ini berdasarkan jawaban Luis Mendo ini)
(-2 byte menggunakan &)sintaks)

Penjelasan:

• Kurangi 'k' dari karakter terakhir (beri n = -7, 0, 5 untuk 'd', 'k', 'p' masing-masing).

• Hitung v = n ^ 2 + 6n-1 (masing-masing memberi 7, -1, 54).

• Lipat gandakan nilai v dengan angka peringkat aktual (sehingga level k mendapatkan produk negatif, level d berubah dari 7 menjadi 49, level p dari 54 ke atas).

• Lakukan itu untuk kedua input string, bandingkan produk

• Dapatkan string input yang sesuai dengan produk yang lebih besar

Alternatif, metode yang lebih mudah:

23 byte

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

Cobalah online!

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

Cobalah online!

Seperti biasa bagi saya, implementasi lurus ke depan daripada apa pun khususnya golf-y. Fungsi "(#)" mengambil dua peringkat sebagai string dan mengembalikan yang lebih besar. Hanya berfungsi dengan format yang ditentukan dalam pertanyaan.

(Saya juga sudah mencoba versi menggunakan comparingdan maximumBytapi itu akhirnya menjadi 3 byte lebih lama - sialan Anda basedan nama fungsi yang kadang-kadang dapat dibaca manusia!)

(Saran terapan oleh Amfibologis dan Lynn)

Python 2 , 54 byte

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

Cobalah online!

Menggunakan metode Arnauld . Pemetaan int(x,27)%9-3hanya tergantung pada huruf terakhir x, karena semua digit tetapi yang terakhir berkontribusi kelipatan 9. Dibutuhkan:

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

Ini adalah margin yang nyaris tidak cukup 1puntuk dikalahkan oleh pengali 7d, peringkat tertinggi, ketika ditafsirkan dalam basis 26.

Saya menemukan ini dengan ekspresi kasar dari bentuk ini dan beberapa lainnya.

Python 2 , 64 byte

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

Cobalah online!

R , 73 byte

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

Cobalah online!

• Saya harus menggunakan as.doublealih-alih strtoikarena yang terakhir tidak menangani spasi / poin dan saya tidak bisa memikirkan karakter lain yang valid untuk digantid
• -1 byte menggunakan rankalih-alih order, karena mereka sama ketika hanya ada dua elemen

Jelly , 13 byte

Ini sangat berbeda dari jawaban Jelly saya yang lain , jadi saya memposting ini secara terpisah.

Mengambil input sebagai daftar dua (atau lebih) string.

“kNdHp0”yVµÞṪ

Cobalah online!

Berkomentar

“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

Ini bukan cara yang paling efisien, (kontras @ sundar's Julia 0,6 jawaban ) tetapi itu bagus karena ini murni numerik. Juga menggunakan pengiriman (meskipun sayangnya hanya sekali)

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

Kode yang sangat mirip berfungsi di 0,6 Cobalah secara online

Bagaimana:

Caranya ada pada !(z)fungsi.

Ini memetakan nilai UTF-8:

• untuk kmenjadi angka negatif, jadi itu mundur
• untuk dmenjadi angka positif
• untuk pmenjadi angka positif yang lebih besar

Seperti yang ditunjukkan:

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

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

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

Hasil tes

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

Cobalah online!

Ekspresi gcd(fromEnum c)28-3memetakan karakter ke pengganda

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

Idenya adalah untuk mengambil nilai karakter mereka [107,100,112]dan memilih 28untuk memiliki faktor yang semakin besar yang sama dengan mereka, dipermudah tetapi yang pertama menjadi prima. Metode ini menghemat 2 byte daripada menulis pemetaan secara eksplisit .

Built-in readsdigunakan untuk memisahkan jumlah dan peringkat.

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

(Sebenarnya, pemisahan langsung dari Sara J adalah satu byte lebih pendek, memberikan 63 byte .)

Langkah take-the-large-one mengambil jumlah byte yang mengganggu dalam solusi saya. Saya mencoba pendekatan lain seperti iterasi dari peringkat dalam urutan menurun dan mengambil yang pertama adalah unsur [a,b], tetapi ternyata lebih lama.

MATL , 28 27 byte

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

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

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

Jelly , 16 byte

Mengambil input sebagai daftar dua string.

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

Cobalah online! (semua kasus uji)

Bagaimana?

Kode ASCII dari karakter peringkat dikonversi ke pengali dengan rumus berikut:$c$$m$

Pemberian yang mana:

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

Berkomentar

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

Formula alternatif

Untuk 16 byte juga, kita dapat menggunakan:

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

Cobalah online!

JavaScript (ES6), 55 54 byte

-1 byte terima kasih kepada @Shaggy

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

Cobalah secara Online!

Penjelasan

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

Port langsung dari jawaban xnor.

Cobalah online!

EDIT: -6 byte dengan menyadari saya bisa menggunakan Proc

C # (Visual C # Compiler) , 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;}

Cobalah online!

-1 Byte terima kasih kepada TheLethalCoder

Perluasan:

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[$`<=$']

Jalankan sebagai perl -pae '...'. Mengambil input dari stdin, dipisahkan spasi pada satu baris.

Lakukan beberapa pergantian untuk membuat perbandingan "lebih mudah". Substitusi substitusi pada dasarnya sama dengan mengganti pdengan nol tambahan dan kdengan tanda negatif utama. Jadi 10kmenjadi -10(jadi urutannya terbalik) dan 3pmenjadi 30(sehingga di patas segalanya). Maka itu hanya perbandingan angka sederhana.

Berkat DomHastings untuk $`/ $'saran, yang mencukur 8 byte.

R , 65 62 byte

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

Cobalah online!

Ini datang sedikit lebih pendek dari jawaban R sebelumnya, dan memanfaatkan fungsi statistik R dengan baik :-)

-3 byte berkat Robin Ryder saran 's untuk menggunakan ordered bukan factor

Mengambil input dari stdin (meskipun tautan TIO sedikit merestrukturisasi untuk kemudahan pengujian). Pemain jajaran masukan ke dalam sebuah memerintahkan factor semua jajaran, kemudian mengambil maks.

Outputnya seperti:

[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 terima kasih kepada @SaraJ .

Cobalah online. (Lihat bagian bawah output di TIO-link untuk melihat nilai yang dipetakan.)

Penjelasan:

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

Cobalah online!

-5 bytesterima kasih kepada @Laikoni
-2 bytesberkat @ ASCII saja

Python 2 , 61 byte

Menggunakan algoritma Arnauld.

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

Cobalah online!

Jawaban sebelumnya, 73 byte

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

Cobalah online!

Julia 0,6 , 75 71 65 byte

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

Cobalah online!

(-4 byte, parsing dalam 0,6 otomatis mendeteksi sebagai Int)

(-6 byte, gunakan (search("_dp",s[2])-1)^3)berdasarkan jawaban JS Arnauld, bukan ((c=cmp(s[end],'k'))^2*6+4c-1))

Retina 0.8.2 , 29 byte

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

Cobalah online! Menerima sejumlah peringkat dan menghasilkan yang tertinggi. Penjelasan:

O`

Sortir garis ...

$

... menggunakan kunci yang ditentukan ...

^

... dalam urutan terbalik.

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

Kunci dibuat dari baris input sebagai berikut: a) huruf (profesional) dan pangkat b) pangkat di unary c) huruf kyu (di mana berlaku). Karena ini adalah jenis terbalik, peringkat profesional dan pmengurutkan sebelum peringkat ddan peringkat kyū yang dimulai dengan 1karena huruf kyū dibiarkan di akhir. Di dalam peringkat tersebut, peringkat (profesional) dan mengurutkan dalam urutan menurun karena panjangnya string unary, namun jejak kuntuk peringkat kyū menyebabkan mereka mengurutkan dalam urutan naik.

1G`

Pilih baris pertama, yang sekarang peringkat terbesar.

J, 39 byte

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

Cobalah online!

penjelasan

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

Fungsi tanpa nama yang menerima iterable dari string yang mengembalikan yang maksimal oleh peringkat Go. Berfungsi seperti jawaban Jelly saya (hanya menggunakan seluruh string yang dievaluasi sebagai integer di basis 26 untuk menghemat byte).

Cobalah online!

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

Cobalah online!

Perl 6 , 35 byte

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

Cobalah online!

Pendekatan yang agak berbeda untuk semua hal pencarian dan kubus ini. Pada dasarnya string pengganti: ...k -> -..., p -> 0, ddihapus. Dengan demikian pemula mendapat skor minus, dans mendapatkan peringkat mereka dan pro mendapatkan peringkat * 10. Menggunakan What'sStar membuat kami dapat melakukan penutupan, dan maxmengambil fungsi pembanding.

05AB1E , 12 byte

Σ'pK°.Vyþ*}θ

.V(mengevaluasi sebagai kode 05AB1E) terinspirasi oleh pendekatan serupa @Arnauld dalam jawabannya Jelly .

Masukan sebagai daftar dua (atau lebih) dari string yang valid.

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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

• kmuncul daftar dan item, dan mendorong indeks item dalam daftar. Karena stack tidak mengandung daftar, "30k"through "1k"akan selalu menghasilkan -1. Dikalikan dengan jumlah mereka, itu akan menjadi kisaran .$[-30,-1]$
• dmemeriksa apakah suatu nomor adalah non-negatif ( >= 0). Karena ini adalah kebenaran untuk semua, "1d"melalui "7d"akan selalu menghasilkan 1. Dikalikan dengan jumlah mereka, itu akan menjadi kisaran .$[1,7]$
• Menghapus pdan menggunakan °akan menggunakan 10 pangkat jika adalah angka yang benar, jika tidak tetap sama. Jadi jika adalah atau , ia akan tetap atau setelah menggunakan , tetapi (karena kami telah menghapus ) dengan akan menjadi . Dikalikan dengan jumlah mereka, melalui akan daftar .$a$$a$$a$$a$[ 10 , 200 , 3000 , 40000 , 500000 , 6000000 , 70000000 , 800000000 , 9000000000 ]"2k""2d""2k""2d"°"2"p°100"1p""9p"$[10, 200, 3000, 40000, 500000, 6000000, 70000000, 800000000, 9000000000]$

Lihat semua nilai yang dipetakan di sini.

Scala , 307 61 54 byte

Terima kasih banyak kepada Kevin Crujissen dan ASCII - hanya untuk pekerjaan mereka pada jawaban ini, yang membuatnya turun ~ 250b.

Beberapa optimasi algoritme untuk fungsi pemesanan jawaban 61b.

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

Uji kasus di sini: Coba online!

Jawaban lama 61 byte

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

Caranya adalah dengan menghitung jarak antara rank letterdan i(kode char 105). Kemudian kita menggunakan jarak ini sebagai skor ( dan = 5, kyu = 2, pro = 7) yang kita kalikan dengan jumlah peringkat. Kemudian kita mengambil maksimum pada input array menggunakan fungsi penilaian.

Coba juga online!

PHP , 100 98 byte

(-2 byte dengan mengubah deklarasi fungsi)

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

Untuk menjalankannya:

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

Contoh:

php -n go_rank.php 1p 7d

Atau Coba online!

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;

Cobalah online!

Bagaimana?

Mirip dengan pendekatan Arnauld , tetapi dalam PHP. Saya menggunakan fungsi untuk mengonversi setiap peringkat ke nilai numerik dan membandingkan serta menampilkan yang dengan nilai lebih tinggi.

Nilai peringkat berasal dari posisi karakter string kedua input !!dp, dikurangi satu dan kemudian ditenagai menjadi 3 dan dikalikan dengan bagian integer dari string input.

Jadi misalnya, posisi karakter kedua 1pyang pdi !!dpadalah 3, berkurang satu dan bertenaga untuk 3 akan 8. Jadi bilangan bulat bagian dari semua *pjajaran akan dikalikan dengan 8. cara ini 1p = 8, 2p = 16, ..., 9p = 72.

Untuk semua *dperingkat, bagian integer akan dikalikan dengan 1 (atau tidak ada perkalian). Ini berarti 1d = 1, ..., 7d = 7.

Dan untuk semua *kdan **kperingkat, posisi karakter kedua di !!dpakan sama dengan falseyang sama dengan 0 (tidak eksplisit), dikurangi satu dan didukung oleh 3, berarti bagian integer akan dikalikan dengan -1. Ini berarti 30k = -30, ..., 1k = -1.

Ini adalah usaha golf pertama saya, tidak yakin seberapa buruk itu!

Excel VBA, 129 byte

Fungsi jendela VBE Segera anonim yang mengambil input jangkauan A1:A2dan keluaran ke konsol.

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

Penjelasan

[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