Игроки традиционной настольной игры 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 байт

Принимает две строки в синтаксисе карри (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 для профессионального данов ранга «хр»
• -1 для ранга кю "xk" или "xxk", потому что s [1] является либо "k", либо цифрой

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

3) Умножаем на десятичную часть ранга.

Желе , 14 байт

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

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

^{* Также работает с номерами, отличными от двух.}

Попробуйте онлайн! Или посмотрите тестовый набор .

Как?

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

Буквы , d и p имеют порядковые номера 107 , 100 и 112 соответственно. В двоичном коде 107 установлено восемь битов, в то время как остальные нет, следовательно, побитовое ИЛИ с 8 мы получаем 107, 108 и 120 соответственно - теперь они находятся в порядке, необходимом для сортировки классов, которые они идентифицируют.$k$$d$$p$$107$$100$$112$$107$

Любительские ранги расположены в порядке убывания, поэтому для завершения нашей ключевой функции мы могли бы объединить наш идентификатор класса с номером, указанным в строке, с отрицанием, если строка заканчивается на (например, -> while -> ). В коде это требует хранения идентификатора класса и возведения в степень минус один для умножения - что составляет 16 байтов.$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]]

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

Это не самый эффективный способ (контраст @ sundar's 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иметь все более и более общие с ними факторы, что было легко, но первый из них был основным. Этот метод экономит 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 #) , 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

Expanation:

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 байта благодаря предложению Робина Райдера использовать 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(".$",""));}

-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

Ключ создается из строки ввода следующим образом: а) (профессиональная) буква ранга дана б) ранг в унарной букве в) буква кю (где применимо). Поскольку это обратная сортировка, профессиональный дан ранг 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

Python , 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. Использование WhwhatStar дает нам замыкание и 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-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;

Попробуйте онлайн!

Как?

Аналогично подходу Арно , но в 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, равному 0 (без явного), уменьшенному на единицу и усиленному на 3, что означает, что целая часть будет умножена на -1. Это означает 30k = -30, ..., 1k = -1.

Это моя первая попытка игры в гольф, не знаю, насколько она плоха!

Excel VBA, 129 байт

Анонимная VBE Immediate оконная функция, которая принимает входной сигнал в диапазоне 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))]

Explaination

[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