I giocatori del tradizionale gioco da tavolo Go misurano le loro abilità in un sistema di gradi :

• I giocatori nuovi al gioco sono classificati al 30 ° kyū (scritto 30k) e i progressi contano fino al 1 ° kyū (scritto 1k). Questi sono considerati i ranghi degli studenti .
• Un giocatore può promuovere dal 1 ° kyū al 1 ° livello dan (scritto 1d), e quindi progredire contando fino al 7 ° grado dan (scritto 7d). Questi sono i ranghi principali .
• I giocatori eccezionalmente qualificati del passato 7dpossono fare promozione fino al 1 ° livello dan professionale 1p e i progressi contando fino al 9 ° grado dan professionale (scritto 9p). Questo è il grado più alto.

In breve: i ranghi sono ordinati 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p.

Compito

Date due stringhe tra { 30k, ..., 1k, 1d, ..., 7d, 1p, ..., 9p} come input, output il più alto rango dei due. (Se sono uguali, è sufficiente emettere uno dei due input.)

(Come sempre, l' I / O è flessibile : la tua risposta può essere una funzione o un programma completo, che legge gli input in modo ragionevole e produce output in modo ragionevole.)

Questo è code-golf : l'obiettivo è ridurre al minimo il numero di byte del codice.

Casi test

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

Accetta le due stringhe nella sintassi del curry (a)(b).

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

Provalo online!

Come?

La funzione helper g () traduce la stringa di input s in un punteggio.

1) Cerchiamo s [1] nella stringa "_dp" . Questo da:

• 1 per un grado dan "xd"
• 2 per un grado dan professionista "xp"
• -1 per un rango kyū "xk" o "xxk" perché s [1] è "k" o una cifra

2) Cubiamo questo risultato, che lascia invariati 1 e -1 ma dà 8 per un rango dan professionale .

3) Moltiplichiamo per la parte decimale del rango.

Gelatina , 14 byte

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

Un collegamento monadico che accetta un elenco di stringhe * (come descritto) che fornisce il rango più alto trovato.

^{* Funziona anche con numeri diversi da due.}

Provalo online! O vedi una suite di test .

Come?

Ordina per funzione chiave e restituisce il valore più a destra (ovvero un massimo).

Le lettere , e hanno rispettivamente gli ordinali , e . Nel binario sono impostati gli otto bit mentre gli altri no, quindi OR-ing bit a bit con 8 otteniamo 107, 108 e 120 rispettivamente - questi sono ora nell'ordine richiesto per ordinare le classi che identificano.d p 107 100 112 $k$$d$$p$$107$$100$$112$$107$

I ranghi amatoriali sono in ordine decrescente, quindi per completare la nostra funzione chiave potremmo concatenare il nostro identificatore di classe con il numero indicato nella stringa, annullando se la stringa finisce in (es. -> while -> ). Nel codice questo richiede la memorizzazione dell'identificatore di classe e l'esponente meno uno per la moltiplicazione - che è di byte.$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

Per migliorare, possiamo invece usare meno due e moltiplicare gli elementi insieme, il che può essere ottenuto con una singola moltiplicazione.

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)

Tabella dell'azione della funzione chiave ...

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

Gelatina ,  11  10 byte

^{Ispirato a tornare al tavolo da disegno di Arnauld!}

⁾kNyv9FµÞṪ

Un collegamento monadico che accetta un elenco di stringhe * (come descritto) che fornisce il rango più alto trovato.

• Funziona anche con numeri diversi da due.

Provalo online! O vedi una suite di test .

Come?

Ordina per funzione chiave e restituisce il valore più a destra (ovvero un massimo).

La funzione chiave prima cambia qualsiasi k per diventare una N usando l'atomo diadico y, traduce, con l'elenco di due caratteri ⁾kN(codice Jelly per ['k','N']) e quindi valuta la stringa come monade con un argomento di nove (usando il codice v9).

In gelatina:

• N è un atomo monadico che nega il suo input

  • quindi il codice 9 30Nnon utilizza effettivamente i nove e risulta nell'intero-30

• d è un atomo diadico che produce il risultato di un divmod Python di due valori: la coppia dei risultati di divisione intera e modulo

  • quindi il codice 9 7drisulta in associato a che è$\lfloor \frac 7 9 \rfloor$$7 \pmod 9$[0,7]

• p è un atomo diadico che esegue un prodotto cartesiano, che include l'identificazione implicita della gamma indicizzata 1 dei suoi input

  • quindi il codice 9 p3produce il prodotto cartesiano di [1,2,3]e [1,2,3,4,5,6,7,8,9]che è[[1,1],[1,2],...,[1,9],[2,1],[2,2],...,[2,9],[3,1],[3,2],...,[3,9]]

Una volta che tali valutazioni sono state eseguite utilizzando le stringhe da confrontare, dobbiamo essere in grado di confrontare i risultati; poiché gli ints non sono confrontabili con gli elenchi, è necessario racchiudere i valori negati in un elenco, ma poiché l'ordinamento continuerebbe a funzionare anche dopo che gli pelenchi sono stati appiattiti (ad es. [[1,1],[1,2],...]-> [1,1,1,2]) è possibile utilizzare l'atomo monadico a byte singolo Fapplicato a tutte le valutazioni.

Una tabella degli input per il loro valore-chiave è la seguente:

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]

Commento sul codice:

⁾kNyv9FµÞṪ - Link: list of lists of characters
       µÞ  - sort by (Þ) the monadic link to the left (µ):
⁾kN        -   two-char list = ['k', 'N']
   y       -   translate the current string (change 'k's to 'N's)
     9     -   literal nine
    v      -   evaluate (the left) as Jelly code with the input as given on the right (9)
      F    -   flatten the result
         Ṫ - tail (get the rightmost, and hence (a) maximum)

MATL , 30 28 25 23 byte

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

Provalo online!

(-2 byte grazie Luis Mendo)
(altri -3 byte sostituzione v&X>con >, questa volta basata sulla risposta Luis Mendo)
(-2 byte utilizzando &)sintassi)

Spiegazione:

• Sottrai 'k' dall'ultimo carattere (dà n = -7, 0, 5 per 'd', 'k', 'p' rispettivamente).

• Calcola v = n ^ 2 + 6n-1 (indica 7, -1, 54 rispettivamente).

• Moltiplica quel valore v per il numero di rango effettivo (quindi i livelli k ottengono prodotti negativi, i livelli d vanno da 7 a 49, i livelli p da 54 e superiori).

• Fallo per entrambe le stringhe di input, confronta i prodotti

• Ottieni la stringa di input corrispondente al prodotto maggiore

Metodo alternativo, più semplice:

23 byte

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

Provalo online!

,              % Do this twice (once for each input):
0&)            % Split the input into number, last letter
U              % str2num i.e. Convert '21' to 21
wo             % Bring the letter out and change it to numeric (its ASCII code)
'dpk'          % Push the array 'dpk'
1L6^           % Push [1 2 1j] and raise to ^6, giving [1 64 -1]
XE             % Find the letter in 'dpk', replace it with its corresponding 
               %  number from the second array (d=1, p=64, k=-1)
*              % Multiply the number part by this
w              % Switch to bring out the other input to top
]              % End loop
               % Stack has [second input's value, first input's value]
<              % Is second input < first input? 1 or 0
G              % Retrieve the corresponding input: 1 for 1st input,
               %  0 for last (2nd) input

Haskell , 73 71 byte

r(x,"k")=0-x
r(x,"d")=x
r(x,"p")=x+7
p=r.head.reads
a#b|p a<p b=b|0<1=a

Provalo online!

Come al solito per me, solo un'implementazione diretta piuttosto che qualcosa di particolarmente golf-y. La funzione "(#)" prende due ranghi come stringhe e restituisce quella più grande. Funziona solo con il formato specificato nella domanda.

(Ho anche provato una versione usando comparinge maximumByma alla fine sono 3 byte in più - dannazione a te basee ai tuoi nomi delle funzioni leggibili di tanto in tanto umani!)

(Suggerimenti applicati da Anfibologico e Lynn)

Python 2 , 54 byte

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

Provalo online!

Usando il metodo di Arnauld . La mappatura int(x,27)%9-3dipende solo dall'ultima lettera di x, poiché tutte le cifre tranne l'ultima contribuiscono a un multiplo di 9. Ci vuole:

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

Questo è appena un margine sufficiente per il moltiplicatore 1pda battere 7d, il grado dan più alto, quando interpretato nella base 26.

L'ho trovato esprimendo forzatamente questa forma e alcuni altri.

Python 2 , 64 byte

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

Provalo online!

R , 73 byte

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

Provalo online!

• Ho dovuto usare as.doubleinvece che strtoidal momento che quest'ultimo non gestisce spazi / punti e non riuscivo a pensare a un altro personaggio valido da sostituired
• -1 byte usando rankinvece di order, poiché sono uguali quando ci sono solo due elementi

Gelatina , 13 byte

Questo è abbastanza diverso dall'altra mia risposta di Jelly , quindi sto pubblicando questo separatamente.

Accetta l'input come un elenco di due (o più) stringhe.

“kNdHp0”yVµÞṪ

Provalo online!

Commentate

“kNdHp0”yVµÞṪ
“kNdHp0”       - literal string
        y      - translate each rank character into a Jelly instruction/symbol:
                   'k' -> 'N' = negate
                   'd' -> 'H' = halve
                   'p' -> '0' = a literal zero
         V     - evaluate as Jelly code
                 examples:
                   '21k' -> '21N' -> -21
                   '7d'  -> '7H'  -> 3.5  (*)
                   '3p'  -> '30'  -> 30
          µÞ   - sort the input using all of the above
            Ṫ  - return the second entry

(*) we don't really need to halve these values, but we do want to get rid of 'd'

Julia 0,7 100 93 byte

Non è il modo più efficiente (contrasto della risposta Julia 0.6 di sundar ) ma è bello perché è puramente numerico. Utilizza anche la spedizione (anche se purtroppo solo una volta)

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

Il codice molto simile funziona in 0.6 Provalo online

Come:

Il trucco è tutto nella !(z)funzione.

Mappa il valore UTF-8:

• per kun numero negativo, quindi ordina al contrario
• per dun numero positivo
• per pun numero positivo più grande

Come mostrato:

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

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

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

Risultati del test

julia> @testset "Check it" begin
               @test "29k" | "9k" == "9k"
               @test "21k" | "27k" == "21k"
               @test "6d" | "1p" == "1p"
               @test "5d" | "17k" == "5d"
               @test "1k" | "1d" == "1d"
               @test "1d" | "1d" == "1d"
               @test "1d" | "2d" == "2d"
               @test "9p" | "1d" == "9p"
               @test "2d" | "30k" == "2d"
               @test "1p" | "1k" == "1p"
               @test "1d" | "1p" == "1p"
               @test "1p" | "2d" == "1p"
               @test "7p" | "8p" == "8p"
               @test "30k" | "30k" == "30k"
       end
Test Summary: | Pass  Total
Check it      |   14     14
Test.DefaultTestSet("Check it", Any[], 14, false)

Haskell , 64 byte

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

Provalo online!

L'espressione gcd(fromEnum c)28-3associa il personaggio a un moltiplicatore

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

L'idea era di prendere i loro valori di carattere [107,100,112]e scegliere 28di avere fattori sempre più grandi in comune con loro, reso facile ma il primo 107 era il primo. Questo metodo consente di risparmiare 2 byte sulla scrittura esplicita di una mappatura .

Il built-in readsviene utilizzato per separare il numero e il grado.

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

(In realtà, la divisione diretta da Sara J è più corta di un byte, dando 63 byte .)

Il passo più grande richiede un numero fastidioso di byte nella mia soluzione. Ho provato altri approcci come iterare i ranghi in ordine decrescente e prendere il primo di cui è un elemento [a,b], ma si sono rivelati più lunghi.

MATL , 28 27 byte

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

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

Prende l'input come un elenco di due stringhe.

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

Provalo online! (tutti i casi di test)

Come?

$c$$m$

Che dà:

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

Commentate

OṪ²²%90’’×ṖV$µÞṪ
OṪ²²%90’’        - process the rank character        takes a string, e.g. '28k'
O                - get ASCII codes                   --> [50, 56, 107]
 Ṫ               - pop                               --> 107
  ²²             - square twice                      --> 131079601
    %90          - modulo 90                         --> 1
       ’’        - decrement twice                   --> -1
          ṖV$    - process the decimal part
          Ṗ      - remove the last character         --> '28'
           V     - evaluate as Jelly code            --> 28 (integer)
         ×       - multiply                          --> -28
             µÞ  - sort input using all of the above
               Ṫ - return the second entry

Formula alternativa

Anche per 16 byte, possiamo usare:

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

Provalo online!

JavaScript (ES6), 55 54 byte

-1 byte grazie a @Shaggy

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

Provalo online!

Spiegazione

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

Rubino , 52 46 byte

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

Porta semplice della risposta di xnor.

Provalo online!

EDIT: -6 byte realizzando che avrei potuto usare un Proc

C # (compilatore Visual C #) , 136 135 byte

a=>b=>{string c=a.PadLeft(3,'0'),d=b.PadLeft(3,'0');int x=c[2]-d[2];return(x==0?c.CompareTo(d)*(c[2]=='k'?-1:0)>0:x==5|x>9|x==-7)?a:b;}

Provalo online!

-1 Byte grazie a 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 byte

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

Esegui come perl -pae '...'. Prende input da stdin, separato da spazio su una riga.

Esegue un paio di sostituzioni per rendere il confronto "più semplice". Le sostituzioni regexp equivalgono essenzialmente alla sostituzione pcon uno zero finale e kun segno negativo iniziale. Così 10kdiventa -10(quindi l'ordine è invertito) e 3pdiventa 30(in modo che psia al di sopra di ogni altra cosa). Quindi è solo un semplice confronto numerico.

Grazie a DomHastings per il $`/ $'suggerimento, che si è rasato 8 byte.

R , 65 62 byte

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

Provalo online!

Questo è un po 'più breve delle precedenti risposte R e fa buon uso della funzionalità statistica di R :-)

-3 byte grazie al suggerimento di Robin Ryder di usare al ordered posto di factor

Prende input dallo stdin (anche se il collegamento TIO si ristruttura leggermente per facilitare i test). Lancia i gradi di input in un ordine factor di tutti i gradi, quindi prende il massimo.

L'output è simile a:

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

Java 8, 128 122 121 byte

a->b->g(a)<g(b)?b:a;float g(String s){return("kdp".indexOf(s.charAt(s.length()-1))-.9f)*new Byte(s.replaceAll(".$",""));}

-6 byte grazie a @SaraJ .

Provalo online. (Vedi il fondo dell'output nei link TIO per vedere i valori mappati.)

Spiegazione:

a->b->                       // Method with two String parameters and String return-type
  g(a)<g(b)?                 //  If the mapped value of `a` is smaller than `b :
   b                         //   Return input `b` as result
  :                          //  Else:
   a;                        //   Return input `a` as result

float g(String s){           // Separated method with String parameter and float return-type
                             // (This method maps all possible Strings to a value)
 return("kdp".indexOf(       //   Take the (0-based) index in the String "kdp"
    s.charAt(s.length()-1))  //   of the last character
    -.9f)                    //   After we've subtracted 0.9
  *(                         //  And multiply it with:
    new Byte(                //   Convert the String to an integer
     s.replaceAll(".$",""));}//   After we've removed the trailing character

Haskell , 75 70 68 byte

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

Provalo online!

-5 bytesgrazie a @Laikoni
-2 bytesgrazie solo a @ ASCII

Python 2 , 61 byte

Utilizza l'algoritmo di Arnauld.

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

Provalo online!

Risposta precedente, 73 byte

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

Provalo online!

Julia 0.6 , 75 71 65 byte

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

Provalo online!

(-4 byte, l'analisi in 0.6 lo rileva automaticamente come Int)

(-6 byte, utilizzare in (search("_dp",s[2])-1)^3)base alla risposta JS di Arnauld, anziché ((c=cmp(s[end],'k'))^2*6+4c-1))

Retina 0.8.2 , 29 byte

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

Provalo online! Accetta qualsiasi numero di ranghi e genera il massimo. Spiegazione:

O`

Ordina le linee ...

$

... usando la chiave specificata ...

^

... in ordine inverso.

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

La chiave viene creata dalla riga di input come segue: a) la lettera di rango (professionale) dan b) il rango in unario c) la lettera di kyū (ove applicabile). Poiché si tratta di un ordinamento inverso, il rango dan professionale pordina prima del rango dan de del rango kyū che inizia 1perché la lettera kyū viene lasciata alla fine. All'interno dei ranghi, il dan (professionale) si classifica in ordine decrescente a causa della lunghezza della stringa unaria, tuttavia il trailing kper i ranghi kyū li induce a ordinare in ordine crescente.

1G`

Seleziona la prima riga, che ora è il grado più alto.

J, 39 byte

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

Provalo online!

spiegazione

[`]@.(<&(".@}: ((* _1&^) + ] * 0 = 2&|) a. i. {:))    entire phrase
[`]@.(<&(       assign a rank number            ))
      <&                                              "less than" of the ranks of the left and right args
                                                      ie, return 1 if right arg rank is bigger
[`]@.                                                 if so, return right arg.  otherwise left
                                                      breaking down the rank number part now...
        (       assign a rank number            )
        (".@}: ((* _1&^) + ] * 0 = 2&|) a. i. {:)
        (".@}:                                  )     everything but last char, convert to number
        (                               a. i. {:)     index within ascii alphabet of the last char
                                                      these become the left and right args to what follows...
        (      ((* _1&^) + ] * 0 = 2&|)         )
        (      (           ] * 0 = 2&|)         )     the right arg * "is the right arg even?"
                                                      because only 'k' is odd (107), this will be 0 for 'k'
                                                      and will be 100 for 'd' and 112 for 'p'
        (      ((* _1&^)              )         )     left arg (number of go rank) times _1 raised
                                                      to the ascii index.  this will swap the sign
                                                      for k only, hence producing a valid rank function

Python , 59 byte

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

Una funzione senza nome che accetta un iterabile di stringhe che restituisce una massima per il rango Go. Funziona in modo molto simile alla mia risposta Jelly (utilizza solo l'intera stringa valutata come numero intero nella base 26 per salvare i byte).

Provalo online!

C (gcc) , 95 byte

#define _(s)(strtol(s,&u,10)+(*u^15)*8)*(-(*u&2)+1)
f(s,t,u)char*s,*t,*u;{puts(_(s)>_(t)?s:t);}

Provalo online!

Perl 6 , 35 byte

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

Provalo online!

Un approccio piuttosto diverso a tutte queste cose di ricerca e cubo. Essenzialmente sostituzione di stringa: ...k -> -..., p -> 0, dcancellato. Quindi i neofiti ottengono un punteggio negativo, i dans ottengono il loro rango e i professionisti ottengono il rango * 10. L'uso di qualunque cosa ci fa chiudere e maxprende una funzione di confronto.

05AB1E , 12 byte

Σ'pK°.Vyþ*}θ

.V(valuta come codice 05AB1E) è ispirato dall'approccio simile di @Arnauld nella sua risposta Jelly .

Immettere come elenco di due (o più) stringhe valide.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedi tutti i valori mappati qui.

Scala , 307 61 54 byte

Un grande ringraziamento a Kevin Crujissen e ASCII-only per il loro lavoro su questa risposta, che ha fatto scendere ~ 250b.

Qualche ottimizzazione dell'algoritmo per la funzione di ordinazione della risposta 61b.

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

Casi di prova qui: provalo online!

Risposta di 61 byte precedenti

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

Il trucco è calcolare la distanza tra rank lettere i(codice carattere 105). Quindi usiamo questa distanza come punteggio ( dan = 5, kyu = 2, pro = 7) che moltiplichiamo per il numero di rango. Quindi prendiamo il massimo sull'array di input usando la funzione di punteggio.

Provalo anche online!

PHP , 100 98 byte

(-2 byte modificando la dichiarazione di funzione)

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

Per eseguirlo:

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

Esempio:

php -n go_rank.php 1p 7d

Oppure provalo online!

PHP (7.4), 74 byte

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

Provalo online!

Come?

Simile all'approccio di Arnauld , ma in PHP. Sto usando una funzione per convertire ogni rango in un valore numerico e confrontare e produrre quello con valore più alto.

Il valore di rango deriva dalla posizione del secondo carattere della stringa di input in !!dp, ridotta di uno e quindi potenziata a 3 e moltiplicata per la parte intera della stringa di input.

Così, per esempio, la posizione del secondo carattere 1pche è pin !!dpè 3, diminuito di uno e dimensionato per 3 sarà così 8. parte intera di tutti i *pranghi sarà moltiplicato per 8. Questi mezzi 1p = 8, 2p = 16..., 9p = 72.

Per tutti i *dgradi, la parte intera verrà moltiplicata per 1 (o semplicemente nessuna moltiplicazione). Questo significa 1d = 1, ..., 7d = 7.

E per tutti *ke **kgradi, la posizione del secondo carattere in !!dpsarà uguale alla falsequale è uguale a 0 (nessun esplicito), ridotta di uno e potenziata di 3, significa che la parte intera verrà moltiplicata per -1. Questo significa 30k = -30, ..., 1k = -1.

Questo è il mio primo tentativo di golf in assoluto, non sono sicuro di quanto sia brutto!

Excel VBA, 129 byte

Una funzione di finestra VBE immediata anonima che accetta input nel range A1:A2e output alla 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))]

spiegazione

[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