Os jogadores do tradicional jogo de tabuleiro Go medem suas habilidades em um sistema de classificações :

• Jogadores novos no jogo são classificados em 30º kyū (por escrito 30k) e o progresso é regressivo até o 1º kyū (por escrito 1k). Estes são considerados as fileiras dos estudantes .
• Um jogador pode promover do 1º kyū ao 1º dan rank (escrito 1d) e, em seguida, progredir contando até o 7º dan rank (escrito 7d). Estas são as fileiras principais .
• O passado de jogadores excepcionalmente habilidosos 7dpode ser promovido para a 1ª posição profissional 1p e o progresso contando até a 9ª posição profissional (escrita 9p). Esta é a classificação mais alta.

Em resumo: as classificações são ordenadas 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p.

Tarefa

Dadas duas cordas entre { 30k, ..., 1k, 1d, ..., 7d, 1p, ..., 9p} como entrada, saída da maior classificação dos dois. (Se eles são iguais, basta gerar uma das entradas.)

(Como de costume, a E / S é flexível - sua resposta pode ser uma função ou um programa completo, lendo entradas de qualquer maneira razoável e produzindo saídas de qualquer maneira razoável.)

Este é o código-golfe : o objetivo é minimizar a contagem de bytes do seu código.

Casos de teste

(Formato:. 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 bytes

Pega as duas strings na sintaxe de currying (a)(b).

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

Experimente online!

Quão?

A função auxiliar g () converte a sequência de entrada s em uma pontuação.

1) Procuramos s [1] na string "_dp" . Isto dá:

• 1 para uma classificação dan "xd"
• 2 para um ranking profissional de dan "xp"
• -1 para uma classificação kyū "xk" ou "xxk" porque s [1] é "k" ou um dígito

2) Cubamos esse resultado, que deixa 1 e -1 inalterados, mas fornece 8 para uma classificação profissional e dan .

3) Nós multiplicamos pela parte decimal da classificação.

Gelatina , 14 bytes

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

Um link monádico que aceita uma lista de cadeias * (conforme descrito) que produz a classificação mais alta encontrada.

^{* Também funciona com números diferentes de dois.}

Experimente online! Ou veja uma suíte de testes .

Quão?

Classifica por uma função de tecla e retorna a mais à direita (ou seja, um máximo).

As letras , e têm os ordinais , e respectivamente. No binário , o conjunto de oito bits é definido, enquanto os outros não, portanto, OR bit a bit com 8, obtemos 107, 108 e 120 respectivamente - agora estão na ordem necessária para classificar as classes que identificam.d p 107 100 112 $k$$d$$p$$107$$100$$112$$107$

As fileiras amadoras estão em ordem decrescente, para concluir nossa função de chave, poderíamos concatenar nosso identificador de classe com o número fornecido na string, negando se a string termina em (por exemplo, -> while -> ). No código, isso exige o armazenamento do identificador de classe e a exponenciação menos um para a multiplicação - que é de bytes.$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

Para melhorar isso, podemos usar menos dois e multiplicar os elementos juntos, o que pode ser alcançado com uma única multiplicação.

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)

Tabela de ação da função de tecla ...

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

Geléia ,  11  10 bytes

^{Inspirado a voltar à prancheta de desenho de Arnauld!}

⁾kNyv9FµÞṪ

Um link monádico que aceita uma lista de cadeias * (conforme descrito) que produz a classificação mais alta encontrada.

• Também funciona com números diferentes de dois.

Experimente online! Ou veja uma suíte de testes .

Quão?

Classifica por uma função de tecla e retorna a mais à direita (ou seja, um máximo).

A função da tecla primeiro altera qualquer k para se tornar um N usando o átomo diádico y, converte, com a lista de dois caracteres ⁾kN(código Jelly para ['k','N']) e depois avalia a string como uma mônada com um argumento de nove (pelo uso do código v9).

Em Jelly:

• N é um átomo monádico que nega sua entrada

  • então o código 9 30Nnão usa os nove e resulta no número inteiro-30

• d é um átomo diádico que produz o resultado de um divmod Python de dois valores - o par dos resultados da divisão inteira e do módulo

  • então o código 9 7dresulta em emparelhado com que é$\lfloor \frac 7 9 \rfloor$$7 \pmod 9$[0,7]

• p é um átomo diádico que executa um produto cartesiano, que inclui a faixa implícita de 1-indexação implícita de suas entradas

  • portanto, o código 9 p3produz o produto cartesiano de [1,2,3]e [1,2,3,4,5,6,7,8,9]que é[[1,1],[1,2],...,[1,9],[2,1],[2,2],...,[2,9],[3,1],[3,2],...,[3,9]]

Depois que essas avaliações forem realizadas usando as seqüências de caracteres a serem comparadas, precisamos poder comparar os resultados; como ints não são comparáveis ​​com listas, precisamos agrupar os valores negados em uma lista, mas como a ordem ainda funcionaria após o pachatamento das listas (por exemplo, [[1,1],[1,2],...]-> [1,1,1,2]), podemos usar o átomo monádico de byte único Faplicado a todas as avaliações.

Uma tabela das entradas para seu valor-chave é a seguinte:

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]

Comentário do código:

⁾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 bytes

,0&)Uw'k'-tUw6*+qw*w]<G

Experimente online!

(-2 bytes graças a Luis Mendo)
(outros -3 bytes substituídos v&X>por >, desta vez com base na resposta de Luis Mendo)
(-2 bytes usando &)sintaxe)

Explicação:

• Subtraia 'k' do último caractere (fornece n = -7, 0, 5 para 'd', 'k', 'p' respectivamente).

• Calcule v = n ^ 2 + 6n-1 (dá 7, -1, 54 respectivamente).

• Multiplique esse valor v pelo número de classificação real (para que os níveis de k obtenham produtos negativos, os níveis de d vão de 7 a 49, os níveis de p de 54 e acima).

• Faça isso para as duas cadeias de entrada, compare os produtos

• Obter a sequência de entrada correspondente ao produto maior

Método alternativo e mais direto:

23 bytes

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

Experimente 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 bytes

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

Experimente online!

Como de costume, para mim, apenas uma implementação direta, em vez de algo particularmente interessante. A função "(#)" assume duas fileiras como seqüências de caracteres e retorna a maior. Funciona apenas com exatamente o formato especificado na pergunta.

(Eu também tentei uma versão usando comparinge maximumBy, mas que acabou sendo 3 bytes mais - caramba, você base! E seus nomes de função legíveis ocasionalmente humanos)

(Sugestões aplicadas por Amphibological e Lynn)

Python 2 , 54 bytes

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

Experimente online!

Usando o método de Arnauld . O mapeamento int(x,27)%9-3depende apenas da última letra de x, pois todos os dígitos, exceto o último, contribuem com um múltiplo de 9. Leva:

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

Essa margem é quase insuficiente para o multiplicador 1pvencer 7d, a classificação mais alta e dan, quando interpretada na base 26.

Achei isso forçando expressões brutais desta forma e de algumas outras.

Python 2 , 64 bytes

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

Experimente online!

R , 73 bytes

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

Experimente online!

• Eu tive que usar em as.doublevez de, strtoiuma vez que o último não lida com espaços / pontos e não consegui pensar em outro caractere válido para substituird
• -1 byte usando em rankvez de order, pois são iguais quando existem apenas dois elementos

Gelatina , 13 bytes

Isso é bem diferente da minha outra resposta Jelly , por isso estou publicando isso separadamente.

Recebe entrada como uma lista de duas (ou mais) seqüências de caracteres.

“kNdHp0”yVµÞṪ

Experimente online!

Comentado

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

Não é a maneira mais eficiente ( resposta Julia 0,6 da contraste @ sundar ), mas é agradável porque é puramente numérica. Também usa despacho (embora infelizmente apenas uma vez)

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

Código muito semelhante funciona em 0,6 Experimente online

Como:

O truque está na !(z)função.

Ele mapeia o valor UTF-8:

• para kem um número negativo, por isso é ordenado ao contrário
• para dem um número positivo
• para pem um número positivo maior

Como mostrado:

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

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

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

Resultado dos testes

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 bytes

r[(n,[c])]=n*(gcd(fromEnum c)28-3)
g=r.reads
a%b|g a>g b=a|1>0=b

Experimente online!

A expressão gcd(fromEnum c)28-3mapeia o caractere para um multiplicador

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

A idéia era pegar os valores de seus personagens [107,100,112]e optar 28por ter fatores cada vez maiores em comum com eles, facilitados, mas o primeiro deles sendo o principal. Esse método economiza 2 bytes ao escrever explicitamente um mapeamento .

O built-in readsé usado para separar o número e a classificação.

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

(Na verdade, a divisão direta de Sara J é um byte mais curto, fornecendo 63 bytes .)

A etapa "pegue o maior" leva um número irritante de bytes na minha solução. Tentei outras abordagens, como iterar sobre as fileiras em ordem decrescente e pegar a primeira que é um elemento [a,b], mas elas ficaram mais tempo.

MATL , 28 27 bytes

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

Experimente online! Ou verifique todos os casos de teste .

Explicação

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

Gelatina , 16 bytes

Recebe a entrada como uma lista de duas strings.

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

Experimente online! (todos os casos de teste)

Quão?

$c$$m$

Que dá:

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

Comentado

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

Fórmula alternativa

Também para 16 bytes, podemos usar:

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

Experimente online!

JavaScript (ES6), 55 54 bytes

-1 byte graças a @Shaggy

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

Experimente Online!

Explicação

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 bytes

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

Porta direta da resposta do xnor.

Experimente online!

EDIT: -6 bytes, percebendo que eu poderia ter usado um Proc

C # (Compilador Visual C #) , 136 135 bytes

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

Experimente online!

-1 Byte graças a TheLethalCoder

Expansão:

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 bytes

s/p/0/g;s/\w*k/-$&/g;/ /;$_=@F[$`<=$']

Executar como perl -pae '...'. Obtém a entrada de stdin, separada por espaço em uma linha.

Executa algumas substituições para tornar a comparação "mais fácil". As substituições regexp equivalem essencialmente à substituição ppor um zero à direita e kpor um sinal negativo inicial. Assim 10kse torna -10(então a ordem é invertida) e 3pse torna 30(de modo que pestá acima de tudo o resto). Então é apenas uma comparação numérica simples.

Obrigado ao DomHastings pela sugestão $`/ $', que reduziu 8 bytes.

R , 65 bytes 62

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

Experimente online!

Isso é um pouco menor do que as respostas anteriores do R e faz bom uso da funcionalidade de estatísticas do R :-)

-3 bytes, graças à sugestão de Robin Ryder para usar em ordered vez de factor

Recebe informações do stdin (embora o link TIO se reestruture levemente para facilitar o teste). Lança as classificações de entrada em uma ordem factor de todas as classificações e, em seguida, obtém o máximo.

A saída se parece com:

[1] MAX_RANK
46 Levels: 30k < 29k < 28k < 27k < 26k < 25k < 24k < 23k < 22k < ... < 9p

Java 8, 128 122 121 bytes

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 bytes graças a @SaraJ .

Experimente online. (Veja a parte inferior da saída nos links TIO para ver os valores mapeados.)

Explicação:

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 bytes

g k=read(init k)*(abs(fromEnum(last k)*2-209)-8)
a?b|g a>g b=a|1>0=b

Experimente online!

-5 bytesgraças a @Laikoni
-2 bytesgraças a @ ASCII-only

Python 2 , 61 bytes

Usa o algoritmo de Arnauld.

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

Experimente online!

Resposta anterior, 73 bytes

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

Experimente online!

Julia 0.6 , 75 71 65 bytes

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

Experimente online!

(-4 bytes, a análise em 0,6 detecta automaticamente como Int)

(-6 bytes, use com (search("_dp",s[2])-1)^3)base na resposta JS de Arnauld, em vez de ((c=cmp(s[end],'k'))^2*6+4c-1))

Retina 0.8.2 , 29 bytes

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

Experimente online! Aceita qualquer número de classificações e gera o mais alto. Explicação:

O`

Classifique as linhas ...

$

... usando a chave especificada ...

^

... Em ordem inversa.

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

A chave é criada a partir da linha de entrada da seguinte forma: a) a letra (profissional) e a classificação b) a classificação em unário c) a letra kyū (quando aplicável). Como essa é uma classificação inversa, a classificação profissional de dan classifica-se pantes da classificação de dan de a classificação de kyū, que começa 1porque a letra de kyū é deixada no final. Dentro das fileiras, as fileiras (profissionais) e dan são classificadas em ordem decrescente devido ao comprimento da sequência unária, no entanto, a kbusca pelas fileiras de kyū as classifica em ordem crescente.

1G`

Selecione a primeira linha, que agora é a melhor classificação.

J, 39 bytes

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

Experimente online!

explicação

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

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

Uma função sem nome que aceita um iterável de seqüências de caracteres que retorna um máximo por classificação Go. Funciona como minha resposta Jelly (apenas usa toda a cadeia avaliada como um número inteiro na base 26 para salvar bytes).

Experimente online!

C (gcc) , 95 bytes

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

Experimente online!

Perl 6 , 35 bytes

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

Experimente online!

Uma abordagem bastante diferente para todo esse material de pesquisa e cubo. Essencialmente substituição string: ...k -> -..., p -> 0, dexcluído. Assim, os novatos obtêm uma pontuação negativa, os dans obtêm sua classificação e os profissionais obtêm uma classificação * 10. Usar o WhateverStar nos leva a um fechamento e maxassume uma função de comparador.

05AB1E , 12 bytes

Σ'pK°.Vyþ*}θ

.V(avalie como código 05AB1E) é inspirado na abordagem semelhante de @Arnauld em sua resposta Jelly .

Insira como uma lista de duas (ou mais) das seqüências válidas.

Experimente online ou verifique todos os casos de teste .

Explicação:

Σ           # 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]$.

Veja todos os valores mapeados aqui.

Scala , 307 61 54 bytes

Muito obrigado a Kevin Crujissen e ASCII, apenas por seu trabalho nessa resposta, que diminuiu em ~ 250b.

Alguma otimização de algoritmo para ordenar a função da resposta 61b.

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

Casos de teste aqui: Experimente online!

Resposta antiga de 61 bytes

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

O truque é calcular a distância entre rank lettere i(código de char 105). Então usamos essa distância como uma pontuação ( dan = 5, kyu = 2, pro = 7) que multiplicamos pelo número da classificação. Então, tomamos o máximo em array de entrada usando a função de pontuação.

Experimente online também!

PHP , 100 98 bytes

(-2 bytes alterando a declaração da função)

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

Para executá-lo:

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

Exemplo:

php -n go_rank.php 1p 7d

Ou Experimente online!

PHP (7.4), 74 bytes

$g=fn($v)=>(strpos(__dp,$v[1])-1)**3*$v;$f=fn($a,$b)=>$g($a)>$g($b)?$a:$b;

Experimente online!

Quão?

Semelhante à abordagem de Arnauld , mas em PHP. Estou usando uma função para converter cada classificação em um valor numérico e comparar e gerar uma com valor mais alto.

O valor do ranking vem da posição do segundo caractere da string de entrada em !!dp, reduzida por um e depois alimentada para 3 e multiplicada pela parte inteira da string de entrada.

Assim, por exemplo, a posição do segundo carácter da 1pqual é pem !!dpé 3, reduzido em um e alimentado a 3 será 8. Assim, parte número inteiro de todos os *ppostos será multiplicado por 8. Estes meios 1p = 8, 2p = 16, ..., 9p = 72.

Para todas as *dclassificações, a parte inteira será multiplicada por 1 (ou simplesmente sem multiplicação). Isso significa 1d = 1, ..., 7d = 7.

E para todos *ke **kclassificações, a posição do segundo caractere !!dpserá falseigual a 0 (sem explícito), reduzida por um e alimentada por 3, significa que a parte inteira será multiplicada por -1. Isso significa 30k = -30, ..., 1k = -1.

Esta é a minha primeira tentativa de golfe, não tenho certeza do quão ruim é!

Excel VBA, 129 bytes

Uma função de janela imediata VBE anônima que recebe entrada no intervalo A1:A2e sai para o console.

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

Explicação

[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