Los jugadores del tradicional juego de mesa Go miden su habilidad en un sistema de rangos :

• Los jugadores nuevos en el juego se clasifican en el 30 ° kyū (escrito 30k) y el progreso cuenta atrás hasta el 1 ° kyū (escrito 1k). Estos se consideran las filas de los estudiantes .
• Un jugador puede ascender desde el primer kyū al primer rango de dan (escrito 1d), y luego progresar contando hasta el séptimo rango de dan (escrito 7d). Estos son los rangos maestros .
• Los jugadores excepcionalmente hábiles del pasado 7dpueden ascender al primer rango profesional de dan 1p y progresar contando hasta el noveno rango profesional de dan (escrito 9p). Este es el rango más alto.

En resumen: los rangos están ordenados 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p.

Tarea

Dadas dos cadenas entre { 30k, ..., 1k, 1d, ..., 7d, 1p, ..., 9p} como entrada, salida de la más alta categoría de los dos. (Si son iguales, simplemente envíe cualquiera de las entradas).

(Como de costumbre, la E / S es flexible : su respuesta puede ser una función o un programa completo, leer entradas de cualquier manera razonable y producir salidas de cualquier manera razonable).

Este es el código de golf : el objetivo es minimizar el recuento de bytes de su código.

Casos de prueba

(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

Toma las dos cadenas en sintaxis curry (a)(b).

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

Pruébalo en línea!

¿Cómo?

La función auxiliar g () traduce la cadena de entrada s en una partitura.

1) Buscamos s [1] en la cadena "_dp" . Esto da:

• 1 para un rango dan "xd"
• 2 para un rango profesional dan "xp"
• -1 para un rango kyū "xk" o "xxk" porque s [1] es "k" o un dígito

2) Cubicamos este resultado, que deja 1 y -1 sin cambios pero da 8 para un rango profesional de dan .

3) Multiplicamos por la parte decimal del rango.

Jalea , 14 bytes

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

Un enlace monádico que acepta una lista de cadenas * (como se describe) que produce el rango más alto encontrado.

^{* También funciona con números que no sean dos.}

Pruébalo en línea! O ver un conjunto de pruebas .

¿Cómo?

Ordena por una función clave y devuelve el extremo derecho (es decir, un máximo).

Las letras , y tienen ordinales , y respectivamente. En el binario tiene el conjunto de ocho bits, mientras que los demás no lo tienen, por lo tanto, OR-bit con 8 obtenemos 107, 108 y 120 respectivamente, estos están ahora en el orden requerido para ordenar las clases que identifican.d p 107 100 112 $k$$d$$p$$107$$100$$112$$107$

Los rangos de aficionados están en orden descendente, por lo que para completar nuestra función clave podríamos concatenar nuestro identificador de clase con el número dado en la cadena, negando si la cadena termina en (por ejemplo, -> while -> ). En el código, esto requiere almacenar el identificador de clase y exponer menos uno para la multiplicación , que es de bytes.$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

Para mejorar esto, podemos usar menos dos y multiplicar los elementos juntos, lo que se puede lograr con una sola multiplicación.

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)

Tabla de la acción de la función clave ...

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

Jalea ,  11  10 bytes

^{¡Inspirado para volver al tablero de dibujo por Arnauld!}

⁾kNyv9FµÞṪ

Un enlace monádico que acepta una lista de cadenas * (como se describe) que produce el rango más alto encontrado.

• También funciona con números que no sean dos.

Pruébalo en línea! O ver un conjunto de pruebas .

¿Cómo?

Ordena por una función clave y devuelve el extremo derecho (es decir, un máximo).

La función clave primero cambia cualquier k para convertirse en una N usando el átomo diádico y, traducir, con la lista de dos caracteres ⁾kN(código Jelly para ['k','N']) y luego evalúa la cadena como una mónada con un argumento de nueve (mediante el uso del código v9).

En gelatina:

• N es un átomo monádico que niega su entrada

  • entonces el código 9 30Nno usa realmente el nueve y da como resultado el entero-30

• d es un átomo diádico que produce el resultado de un divmod de Python de dos valores: el par de resultados de división entera y módulo

  • entonces el código 9 7dresulta en emparejado con que es$\lfloor \frac 7 9 \rfloor$$7 \pmod 9$[0,7]

• p es un átomo diádico que realiza un producto cartesiano, que incluye la identificación de rango implícita 1 indexada de sus entradas

  • entonces el código 9 p3produce el producto cartesiano de [1,2,3]y [1,2,3,4,5,6,7,8,9]que es[[1,1],[1,2],...,[1,9],[2,1],[2,2],...,[2,9],[3,1],[3,2],...,[3,9]]

Una vez que se hayan realizado dichas evaluaciones utilizando las cadenas que se van a comparar, debemos poder comparar los resultados; dado que los ints no son comparables con las listas, necesitamos ajustar los valores negados en una lista, pero dado que el orden aún funcionaría después de que las plistas se aplanan (por ejemplo, [[1,1],[1,2],...]-> [1,1,1,2]) podemos usar el átomo monádico de un solo byte Faplicado a todas las evaluaciones.

Una tabla de las entradas a su valor-clave es la siguiente:

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]

Comentario de 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

Pruébalo en línea!

(-2 bytes gracias a Luis Mendo)
(reemplazando otro -3 bytes v&X>con >, esta vez basado en la respuesta de Luis Mendo)
(-2 bytes usando la &)sintaxis)

Explicación:

• Reste 'k' del último carácter (da n = -7, 0, 5 para 'd', 'k', 'p' respectivamente).

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

• Multiplique ese valor v por el número de rango real (para que los niveles k obtengan productos negativos, los niveles d vayan de 7 a 49, los niveles p de 54 y más).

• Haga eso para ambas cadenas de entrada, compare los productos

• Obtenga la cadena de entrada correspondiente al producto mayor

Método alternativo y más directo:

23 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Como de costumbre para mí, solo una implementación directa en lugar de cualquier cosa particularmente golf-y. La función "(#)" toma dos rangos como cadenas y devuelve el más grande. Funciona solo con exactamente el formato especificado en la pregunta.

(También probé una versión usando comparingy, maximumBypero eso terminó siendo 3 bytes más, ¡maldito sea usted basey sus nombres de funciones legibles de vez en cuando!)

(Sugerencias aplicadas por Amphibological y Lynn)

Python 2 , 54 bytes

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

Pruébalo en línea!

Usando el método de Arnauld . El mapeo int(x,27)%9-3solo depende de la última letra de x, ya que todos los dígitos, excepto el último, contribuyen con un múltiplo de 9. Se necesita:

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

Esto es apenas un margen suficiente para que el multiplicador 1ppueda vencer 7d, el rango dan más alto, cuando se interpreta en la base 26.

Encontré esto mediante expresiones de fuerza bruta de esta forma y algunas otras.

Python 2 , 64 bytes

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

Pruébalo en línea!

R , 73 bytes

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

Pruébalo en línea!

• Tuve que usar en as.doublelugar de, strtoiya que este último no maneja espacios / puntos y no podía pensar en otro personaje válido para reemplazard
• -1 byte usando en ranklugar de order, ya que son iguales cuando solo hay dos elementos

Jalea , 13 bytes

Esto es bastante diferente de mi otra respuesta de Jelly , así que estoy publicando esto por separado.

Toma la entrada como una lista de dos (o más) cadenas.

“kNdHp0”yVµÞṪ

Pruébalo en línea!

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

No es la forma más eficiente (contraste con la respuesta de Julia 0.6 de sundar ), pero es agradable porque es puramente numérico. También usa despacho (aunque lamentablemente solo una 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 muy similar funciona en 0.6 Pruébelo en línea

Cómo:

El truco está en la !(z)función.

Mapea el valor UTF-8:

• para ken un número negativo, por lo que se ordena al revés
• para den un número positivo
• para pen un número positivo mayor

Como se muestra:

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

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

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

Resultados de la prueba

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

Pruébalo en línea!

La expresión gcd(fromEnum c)28-3asigna el carácter a un multiplicador

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

La idea era tomar los valores de sus personajes [107,100,112]y elegir 28tener factores cada vez más grandes en común con ellos, de manera fácil, pero el primero era primo. Este método ahorra 2 bytes al escribir explícitamente una asignación .

El incorporado readsse utiliza para separar el número y el rango.

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

(En realidad, la división directa de Sara J es un byte más corto, dando 63 bytes ).

El paso de tomar el más grande toma un molesto número de bytes en mi solución. Intenté otros enfoques, como iterar sobre los rangos en orden decreciente y tomar el primero del que es un elemento [a,b], pero resultaron más largos.

MATL , 28 27 bytes

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

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

Jalea , 16 bytes

Toma la entrada como una lista de dos cadenas.

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

Pruébalo en línea! (todos los casos de prueba)

¿Cómo?

$c$$m$

Lo que da:

 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

Para 16 bytes también, podemos usar:

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

Pruébalo en línea!

JavaScript (ES6), 55 54 bytes

-1 byte gracias a @Shaggy

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

Pruébalo en línea!

Explicación

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

Puerto directo de la respuesta de xnor.

Pruébalo en línea!

EDITAR: -6 bytes al darse cuenta de que podría haber usado un Proc

C # (compilador de 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;}

Pruébalo en línea!

-1 Byte gracias a TheLethalCoder

Expansión:

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

Corre como perl -pae '...'. Toma datos de stdin, separados por espacios en una línea.

Realiza un par de sustituciones para hacer la comparación "más fácil". Las sustituciones regexp esencialmente equivalen a reemplazar pcon un cero final y kcon un signo negativo inicial. Entonces se 10kconvierte -10(así se invierte el orden) y se 3pconvierte 30(así que pestá por encima de todo lo demás). Entonces es solo una simple comparación numérica.

Gracias a DomHastings por la sugerencia $`/ $', que redujo 8 bytes.

R , 65 62 bytes

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

Pruébalo en línea!

Esto es un poco más corto que las respuestas anteriores de R, y hace un buen uso de la funcionalidad de estadísticas de R :-)

-3 bytes gracias a la sugerencia de Robin Ryder de usar en ordered lugar de factor

Toma información de stdin (aunque el enlace TIO se reestructura ligeramente para facilitar la prueba). Convierte los rangos de entrada en un orden factor de todos los rangos, luego toma el máximo.

La salida se ve así:

[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 gracias a @SaraJ .

Pruébalo en línea. (Consulte la parte inferior de la salida en los enlaces TIO para ver los valores asignados).

Explicación:

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

Pruébalo en línea!

-5 bytesgracias a @Laikoni
-2 bytesgracias a @ ASCII-only

Python 2 , 61 bytes

Utiliza el algoritmo de Arnauld.

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

Pruébalo en línea!

Respuesta anterior, 73 bytes

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

Pruébalo en línea!

Julia 0.6 , 75 71 65 bytes

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

Pruébalo en línea!

(-4 bytes, analizar en 0.6 auto lo detecta como Int)

(-6 bytes, uso (search("_dp",s[2])-1)^3)basado en la respuesta JS de Arnauld, en lugar de ((c=cmp(s[end],'k'))^2*6+4c-1))

Retina 0.8.2 , 29 bytes

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

Pruébalo en línea! Acepta cualquier número de rangos y genera el más alto. Explicación:

O`

Ordenar las líneas ...

$

... utilizando la clave especificada ...

^

... en orden inverso.

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

La clave se crea a partir de la línea de entrada de la siguiente manera: a) la letra de rango dan (profesional) b) el rango en unario c) la letra kyū (cuando corresponda). Dado que este es un orden inverso, el rango profesional de dan se clasifica pantes que el rango dan dy el rango kyū que comienza 1porque la letra kyū se deja al final. Dentro de los rangos, los rangos (profesionales) dan se clasifican en orden descendente debido a la longitud de la cadena unaria, sin embargo, el seguimiento kde los rangos kyū hace que se clasifiquen en orden ascendente.

1G`

Seleccione la primera línea, que ahora es el rango más alto.

J, 39 bytes

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

Pruébalo en línea!

explicación

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

Una función sin nombre que acepta un iterable de cadenas que devuelve una máxima por rango Go. Funciona de manera similar a mi respuesta Jelly (solo usa toda la cadena evaluada como un entero en la base 26 para guardar bytes).

Pruébalo en línea!

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

Pruébalo en línea!

Perl 6 , 35 bytes

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

Pruébalo en línea!

Un enfoque bastante diferente a todas estas cosas de búsqueda y cubos. Esencialmente sustitución de cadenas: ...k -> -..., p -> 0, deliminado. Por lo tanto, los novatos obtienen un puntaje negativo, los dans obtienen su rango y los profesionales obtienen el rango * 10. El uso de WhateverStar nos da un cierre y maxtoma una función de comparación.

05AB1E , 12 bytes

Σ'pK°.Vyþ*}θ

.V(evaluar como código 05AB1E) está inspirado en el enfoque similar de @Arnauld en su respuesta de Jelly .

Ingrese como una lista de dos (o más) de las cadenas válidas.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Ver todos los valores mapeados aquí.

Scala , 307 61 54 bytes

Muchas gracias a Kevin Crujissen y ASCII-only por su trabajo en esta respuesta, eso lo consiguió ~ 250b.

Algún algoritmo de optimización para ordenar la función de respuesta 61b.

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

Pruebe casos aquí: ¡ Pruébelo en línea!

Antigua respuesta de 61 bytes

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

El truco es calcular la distancia entre rank lettery i(código char 105). Luego usamos esta distancia como una puntuación ( dan = 5, kyu = 2, pro = 7) que multiplicamos por el número de rango. Luego tomamos el máximo en la matriz de entrada usando la función de puntuación.

¡Pruébalo en línea también!

PHP , 100 98 bytes

(-2 bytes cambiando la declaración de la función)

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

Para ejecutarlo:

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

Ejemplo:

php -n go_rank.php 1p 7d

O Pruébelo en línea!

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;

Pruébalo en línea!

¿Cómo?

Similar al enfoque de Arnauld , pero en PHP. Estoy usando una función para convertir cada rango a un valor numérico y comparar y generar el que tenga un valor más alto.

El valor de rango proviene de la posición del segundo carácter de la cadena de entrada !!dp, se reduce en uno y luego se potencia a 3 y se multiplica por la parte entera de la cadena de entrada.

Así, por ejemplo, la posición del segundo carácter de 1plo que es pen !!dpes 3, reduce en uno y alimentado a 3 será 8. Así que parte entera de todas las *pfilas se multiplica por 8. Este medio de 1p = 8, 2p = 16, ..., 9p = 72.

Para todos los *drangos, la parte entera se multiplicará por 1 (o simplemente sin multiplicación). Esto significa 1d = 1, ..., 7d = 7.

Y para todos *ky **krangos, la posición del segundo carácter !!dpserá falseigual a 0 (no explícito), reducido por uno y potenciado por 3, significa que la parte entera se multiplicará por -1. Esto significa 30k = -30, ..., 1k = -1.

Este es mi primer intento de golf, ¡no estoy seguro de lo malo que es!

Excel VBA, 129 bytes

Una función de ventana VBE Inmediata anónima que toma entrada en rango A1:A2y salidas a la consola.

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

Explicación

[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