Гравці традиційної настільної гри Go вимірюють свою майстерність у системі рангів :

• Гравці нові до гри ранжуються 30 кю (написано 30k) і прогрес відлік до 1 - го кю (письмового 1k). Вони вважаються студентськими званнями.
• Гравець може підвищити з 1-го кю до 1 - го рангового дану (письмово 1d), а потім прогресувати підрахунок до 7 - го рангового дан (написано 7d). Це майстерські чини.
• Винятково кваліфіковані гравці минулого 7dможуть підвищитись до 1 -го рангу професійних танців 1p та підрахунку прогресу до 9 -го рангу професійного дан (письмово 9p). Це найвищий ранг.

Коротше кажучи: чини впорядковані 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p.

Завдання

З огляду на два рядки з { 30k, ..., 1k, 1d..., 7d, 1p..., 9p} в якості вхідних даних, виведіть вище ранг два. (Якщо вони рівні, просто виведіть або введіть.)

(Як завжди, введення / виведення є гнучким - ваша відповідь може бути функцією або повноцінною програмою, читаючи введення будь-яким розумним способом і виробляючи вихід у будь-який розумний спосіб.)

Це код-гольф : мета - мінімізувати кількість байтів вашого коду.

Тестові кейси

(Формат:. 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) Шукаємо s [1] в рядок "_dp" . Це дає:

• 1 за рейтинг дан "xd"
• 2 за професійний рейтинг дан "xp"
• -1 для kyū рангу "xk" або "xxk", оскільки s [1] або "k", або цифра

2) Ми кубуємо цей результат, який залишає 1 і -1 незмінними, але дає 8 для професійного рангового дан .

3) Помножимо на десяткову частину рангу.

Желе , 14 байт

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

Монадична посилання, що приймає список рядків * (як описано), що дає найвищий знайдений ранг.

^{* Також працює з номерами, відмінними від двох.}

Спробуйте в Інтернеті! Або подивіться тестовий набір .

Як?

Сортує за ключовою функцією та повертає найправіший (тобто максимум).

Літери , та мають порядкові параметри , та відповідно. У двійковій є вісім бітових наборів, а в інших немає, отже, бітовим АБО-іншим з 8 ми отримуємо відповідно 107, 108 і 120 - це в порядку, необхідному для сортування класів, які вони ідентифікують.d p 107 100 112 $k$$d$$p$$107$$100$$112$$107$

Аматорські звання знаходяться в порядку зменшення, тому для завершення нашої ключової функції ми могли б з'єднати наш ідентифікатор класу з номером, вказаним у рядку, заперечуючи, якщо рядок закінчується на (наприклад -> в той час -> ). У коді для цього потрібно зберігати ідентифікатор класу та експонувати значення мінус один для множення - - це байт.$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 байт

^{Натхненний повернутися до креслярської дошки Арнольда!}

⁾kNyv9FµÞṪ

Монадична посилання, що приймає список рядків * (як описано), що дає найвищий знайдений ранг.

• Також працює з номерами, відмінними від двох.

Спробуйте в Інтернеті! Або подивіться тестовий набір .

Як?

Сортує за ключовою функцією та повертає найправіший (тобто максимум).

Ключова функція спочатку змінює будь-яку k, щоб стати N за допомогою діатомового атома y, перекладати зі списком з двома символами ⁾kN(код Jelly для ['k','N']), а потім оцінює рядок як монаду з аргументом дев'яти (за допомогою коду v9).

У желе:

• N є монадичним атомом, який заперечує його вхід

  • тому код 9 30Nнасправді не використовує дев'ятку і призводить до цілого числа-30

• d являє собою діадичний атом, який дає результат дігмоту Python з двох значень - пари результатів цілого поділу та модуля

  • тому код 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]]

Після проведення таких оцінок за допомогою рядків для порівняння нам потрібно мати можливість порівняти результати; оскільки ints не можна порівняти зі списками, нам потрібно зафіксувати заперечені значення у списку, але оскільки впорядкування все-таки працюватиме після 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

Спробуйте в Інтернеті!

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

Спробуйте в Інтернеті!

Як зазвичай для мене, просто пряма реалізація, а не щось особливо гольф-у. Функція "(#)" приймає два рядки як рядки і повертає більшу. Працює лише з точно вказаним у запитанні форматом.

(Я також спробував версію , використовуючи comparingі , maximumByале це закінчилося тим , що було 3 байта більше - проклятий вам base! І ваші зчитувальні імена функцій іноді людини)

(Прикладні пропозиції Амфібологічних та Лінн)

Python 2 , 54 байти

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

Спробуйте в Інтернеті!

Використовуючи метод Арнольда . Відображення 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 байт

Це не найефективніший спосіб, (протилежна відповідь Юлії 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")]

(Насправді пряме розщеплення від Сара Дж на один байт коротше, що дає 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.

Спробуйте в Інтернеті!

EDIT: -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

Пояснення:

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 байти завдяки пропозиції Робіна Райдера використовувати 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 байт

Використовує алгоритм Арнальда.

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), замість цього використовуйте на основі відповіді 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

Ключ створюється з рядка введення таким чином: а) літера (професійна) dan rank b) ранг в уніар c) літера kyū (де це можливо). Оскільки це зворотний сорт, професійний ранг дан pсортує перед рангом дан dі кю ранг, який починається з того, 1що літеру кю залишається в кінці. У рядах (професійні) дан чини сортуються у порядку зменшення через довжину одинарної струни, однак трейлінг kдля кю-рангів змушує їх сортувати у порядку зростання.

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

Пітон , 59 байт

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

Неназвана функція, яка приймає ітерабельні рядки, які повертають максимальний показник за рангом Go. Працює подібно до моєї відповіді 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. Використання WickerStar отримує нам закриття та 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 байт

Величезне спасибі Кевіну Кружиссену та лише ASCII за їх роботу над цією відповіддю, яка знизила його ~ 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(char-кодом 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;

Спробуйте в Інтернеті!

Як?

Схожий на підхід Арнольда , але в 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