Les joueurs du jeu de société traditionnel Go mesurent leurs compétences dans un système de classement :

• Les nouveaux joueurs sont classés au 30e kyū (écrit 30k) et les progrès décomptés au 1er kyū (écrit 1k). Ceux-ci sont considérés comme les rangs des étudiants .
• Un joueur peut passer du 1er kyū au 1er rang dan (écrit 1d), puis progresser jusqu'à compter le 7e rang dan (écrit 7d). Ce sont les rangs maîtres .
• Les joueurs ayant des qualifications exceptionnelles 7dpeuvent se qualifier pour le 1er rang dan professionnel 1p et les progrès comptant jusqu’au 9e rang dan professionnel (écrit 9p). C'est le plus haut rang.

En bref: les rangs sont ordonnés 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p.

Tâche

Compte tenu de deux cordes entre { 30k..., 1k, 1d, ..., 7d, 1p, ..., 9p} comme entrée, sortie le plus élevé le rang des deux. (S'ils sont égaux, indiquez simplement l'une des entrées.)

(Comme d'habitude, les E / S sont flexibles - votre réponse peut être une fonction ou un programme complet, en lisant l'entrée de n'importe quelle manière raisonnable et en produisant une sortie de n'importe quelle manière raisonnable.)

C'est du code-golf : l'objectif est de minimiser le nombre d'octets de votre code.

Cas de test

(Format:. 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 octets

Prend les deux chaînes dans la syntaxe de currying (a)(b).

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

Essayez-le en ligne!

Comment?

La fonction d'assistance g () traduit la chaîne d'entrée s en partition.

1) Nous cherchons s [1] dans la chaîne "_dp" . Cela donne:

• 1 pour un rang dan "xd"
• 2 pour un grade de dan professionnel "xp"
• -1 pour un rang de kyū "xk" ou "xxk" car s [1] est "k" ou un chiffre

2) Nous cubons ce résultat, ce qui laisse 1 et -1 inchangés mais donne 8 pour un rang de dan professionnel .

3) On multiplie par la partie décimale du rang.

Gelée , 14 octets

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

Un lien monadique acceptant une liste de chaînes * (telle que décrite) qui donne le rang le plus élevé trouvé.

^{* Fonctionne également avec des nombres autres que deux.}

Essayez-le en ligne! Ou voir une suite de tests .

Comment?

Trie par une fonction clé et retourne le plus à droite (c'est-à-dire un maximum).

Les lettres , et ont les ordinaux , et respectivement. Dans le fichier binaire les huit bits sont définis alors que les autres ne le sont pas. Ainsi, nous obtenons respectivement 107, 108 et 120, nous obtenons respectivement 107, 108 et 120. Ils sont donc dans l’ordre requis pour trier les classes qu’ils identifient.d p 107 100 112 $k$$d$$p$$107$$100$$112$$107$

Les rangs amateurs sont dans un ordre décroissant. Ainsi, pour compléter notre fonction de clé, nous pourrions concaténer notre identificateur de classe avec le numéro indiqué dans la chaîne, en inversant le fait que la chaîne se termine par (par exemple -> while -> ). Dans le code, cela nécessite de stocker l'identifiant de classe et d'exponentiantes moins un pour la multiplication - - qui est de octets.$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

Pour améliorer cela, nous pouvons utiliser moins deux et multiplier les éléments ensemble, ce qui peut être obtenu avec une seule multiplication.

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)

Tableau des actions de la fonction-clé ...

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ée ,  11 à  10 octets

^{Inspiré pour revenir à la planche à dessin par Arnauld!}

⁾kNyv9FµÞṪ

Un lien monadique acceptant une liste de chaînes * (telle que décrite) qui donne le rang le plus élevé trouvé.

• Fonctionne également avec des nombres autres que deux.

Essayez-le en ligne! Ou voir une suite de tests .

Comment?

Trie par une fonction clé et retourne le plus à droite (c'est-à-dire un maximum).

La fonction key modifie d'abord tout k pour qu'il devienne un N en utilisant l'atome dyadique y, le traduise avec la liste à deux caractères ⁾kN(code de gelée pour ['k','N']), puis évalue la chaîne en tant que monade avec un argument de neuf (en utilisant le code v9).

En gelée:

• N est un atome monadique qui annule son entrée

  • de sorte que le code 9 30Nn'utilise pas réellement le neuf et donne le nombre entier-30

• d est un atome dyadique qui donne le résultat d'un divmod en Python de deux valeurs - la paire des résultats de la division entière et du modulo

  • de sorte que les codes de 9 7drésultats dans jumelé à$\lfloor \frac 7 9 \rfloor$ qui est$7 \pmod 9$[0,7]

• p est un atome dyadique qui produit un produit cartésien, qui inclut la télémétrie implicite 1 de ses entrées

  • de sorte que le code 9 p3donne le produit cartésien de [1,2,3]et [1,2,3,4,5,6,7,8,9]qui est[[1,1],[1,2],...,[1,9],[2,1],[2,2],...,[2,9],[3,1],[3,2],...,[3,9]]

Une fois que de telles évaluations ont été effectuées à l'aide des chaînes à comparer, nous devons pouvoir comparer les résultats. comme ints ne sont pas comparables aux listes, nous devons envelopper les valeurs négatives dans une liste, mais puisque l'ordre continuera de fonctionner une fois les plistes aplanies (par exemple [[1,1],[1,2],...]-> [1,1,1,2]), nous pouvons utiliser l'atome monadique à un octet Fappliqué à toutes les évaluations.

Un tableau des entrées de leur valeur-clé est le suivant:

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]

Commentaire du code:

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

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

Essayez-le en ligne!

(-2 octets grâce à Luis Mendo)
(encore 3 octets remplaçant v&X>par >, cette fois sur la base de la réponse de Luis Mendo)
(-2 octets en utilisant la &)syntaxe)

Explication:

• Soustrayez 'k' du dernier caractère (donne n = -7, 0, 5 pour 'd', 'k', 'p' respectivement).

• Calculez v = n ^ 2 + 6n-1 (donne 7, -1, 54 respectivement).

• Multipliez cette valeur v par le nombre de rang actuel (ainsi, k niveaux donnent des produits négatifs, d niveaux vont de 7 à 49, p niveaux de 54 et plus).

• Faites-le pour les deux chaînes d'entrée, comparez les produits

• Obtenir la chaîne d'entrée correspondant au produit le plus important

Méthode alternative, plus simple:

23 octets

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Comme d'habitude pour moi, juste une implémentation directe plutôt que quelque chose de particulièrement golf-y. La fonction "(#)" prend deux rangs en tant que chaînes et renvoie le plus grand. Fonctionne uniquement avec le format spécifié dans la question.

(J'ai aussi essayé une version en utilisant comparinget maximumBymais cela a fini par prendre 3 octets de plus - bon sang baseet vos noms de fonctions parfois lisibles par des humains!)

(Suggestions appliquées par Amphibological et Lynn)

Python 2 , 54 octets

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

Essayez-le en ligne!

Utiliser la méthode d'Arnauld . Le mappage int(x,27)%9-3ne dépend que de la dernière lettre de x, car tous les chiffres sauf le dernier contribuent à un multiple de 9. Ça prend:

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

C'est à peine assez de marge pour que le multiplicateur 1pà battre 7d, le plus haut rang dan, lorsqu'il est interprété en base 26.

J'ai trouvé cela en forçant brutalement des expressions de cette forme et de quelques autres.

Python 2 , 64 octets

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

Essayez-le en ligne!

R , 73 octets

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

Essayez-le en ligne!

• Je devais utiliser as.doubleau lieu de, strtoicar ce dernier ne gère pas les espaces / points et je ne pouvais pas penser à un autre caractère valide pour remplacerd
• -1 octet utilisant rankau lieu de order, car ils sont égaux quand il n'y a que deux éléments

Gelée , 13 octets

Ceci est assez différent de mon autre réponse de Jelly , alors je poste ceci séparément.

Prend l'entrée sous la forme d'une liste de deux (ou plus) chaînes.

“kNdHp0”yVµÞṪ

Essayez-le en ligne!

Commenté

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

Ce n’est pas le moyen le plus efficace (réponse Julia 0.6 de contrast @ sundar ), mais c’est bien parce que cela est purement numérique. Utilise aussi le dispatch (malheureusement, une seule fois)

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

Un code très similaire fonctionne dans 0.6 Essayez-le en ligne

Comment:

L'astuce est tout dans la !(z)fonction.

Il mappe la valeur UTF-8:

• pour ken un nombre négatif, donc il trie à l'envers
• pour den un nombre positif
• pour pdans un plus grand nombre positif

Comme montré:

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

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

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

Résultats de 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 octets

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

Essayez-le en ligne!

L'expression gcd(fromEnum c)28-3mappe le personnage à un multiplicateur

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

L'idée était de prendre leurs valeurs de caractère [107,100,112]et de choisir 28d'avoir de plus en plus de points communs avec eux, ce qui était facile, mais le premier était primordial. Cette méthode enregistre 2 octets sur l' écriture explicite d'un mappage .

L'intégré readsest utilisé pour séparer le nombre et le rang.

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

(En réalité, la division directe de Sara J est un octet plus court, ce qui donne 63 octets .)

Le pas en avant prend un nombre d'octets gênant dans ma solution. J'ai essayé d'autres approches, comme parcourir les rangs par ordre décroissant et prendre la première [a,b], mais elles ont été plus longues.

MATL , 28 27 octets

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

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

Gelée , 16 octets

Prend la saisie sous forme de liste de deux chaînes.

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

Essayez-le en ligne! (tous les cas de test)

Comment?

$c$$m$

Qui donne:

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

Commenté

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

Autre formule

Pour 16 octets également, nous pouvons utiliser:

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

Essayez-le en ligne!

JavaScript (ES6), 55 54 octets

-1 octet grâce à @Shaggy

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

Essayez-le en ligne!

Explication

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 octets

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

Port direct de la réponse de xnor.

Essayez-le en ligne!

EDIT: -6 octets en réalisant que j'aurais pu utiliser un Proc

C # (compilateur Visual C #) , 136 135 octets

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

Essayez-le en ligne!

-1 octet grâce à 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 octets

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

Courir en tant que perl -pae '...'. Prend les entrées de stdin, séparées par des espaces sur une ligne.

Effectue quelques substitutions pour rendre la comparaison "plus facile". Les substitutions d'expressions rationnelles consistent essentiellement à remplacer ppar un zéro final et kpar un signe négatif. Ainsi 10kdevient -10(donc l'ordre est inversé) et 3pdevient 30(c'est donc au- pdessus de tout le reste). Ensuite, il ne s'agit que d'une simple comparaison numérique.

Merci à DomHastings pour la $`/ $'suggestion qui a supprimé 8 octets.

R , 65 62 octets

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

Essayez-le en ligne!

Ceci est un peu plus court que les réponses précédentes et fait bon usage des fonctionnalités de statistiques de R :-)

-3 octets grâce à la suggestion de Robin Ryder d’utiliser à la ordered place de factor

Prise en compte de stdin (bien que le lien TIO se restructure légèrement pour faciliter les tests). Transmet les rangs d'entrée dans un ordre factor de tous les rangs, puis prend le maximum.

La sortie ressemble à:

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

Java 8, 128 122 121 octets

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 octets grâce à @SaraJ .

Essayez-le en ligne. (Voir le bas de la sortie dans les liens TIO pour voir les valeurs mappées.)

Explication:

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 octets

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

Essayez-le en ligne!

-5 bytesgrâce à @Laikoni
-2 bytesgrâce à @ ASCII uniquement

Python 2 , 61 octets

Utilise l'algorithme d'Arnauld.

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

Essayez-le en ligne!

Réponse précédente, 73 octets

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

Essayez-le en ligne!

Julia 0.6 , 75 71 65 octets

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

Essayez-le en ligne!

(-4 octets, l'analyse en 0.6 détecte automatiquement comme Int)

(-6 octets, utiliser en (search("_dp",s[2])-1)^3)fonction de la réponse JS d'Arnauld au lieu de ((c=cmp(s[end],'k'))^2*6+4c-1))

Retina 0.8.2 , 29 octets

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

Essayez-le en ligne! Accepte un nombre quelconque de rangs et génère le plus élevé. Explication:

O`

Triez les lignes ...

$

... en utilisant la clé spécifiée ...

^

... dans le sens inverse.

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

La clé est créée à partir de la ligne de saisie de la manière suivante: a) la lettre (professionnel) dan rank b) le rang unaire c) la lettre kyū (le cas échéant). Comme il s’agit d’un tri inverse, le rang de dan professionnel est trié pavant le rang de dan det le rang de kyū qui commence par 1parce que la lettre kyū est laissée à la fin. Au sein des rangs, les rangs dan (professionnels) sont classés par ordre décroissant en raison de la longueur de la chaîne unaire. Cependant, la traînée kpour les rangs kyū les amène à être triés par ordre croissant.

1G`

Sélectionnez la première ligne, qui est maintenant le plus grand rang.

J, 39 octets

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

Essayez-le en ligne!

explication

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

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

Une fonction non nommée acceptant un itérable de chaînes qui retourne un maximum par Go. Fonctionne beaucoup comme ma réponse Jelly (utilise simplement la chaîne entière évaluée comme un entier en base 26 pour économiser des octets).

Essayez-le en ligne!

C (gcc) , 95 octets

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

Essayez-le en ligne!

Perl 6 , 35 octets

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

Essayez-le en ligne!

Une approche assez différente de tous ces éléments de recherche et de cube. Essentiellement remplacement de chaîne: ...k -> -..., p -> 0, dsupprimé. Ainsi, les débutants obtiennent un score négatif, dans obtiennent leur rang et les pros obtiennent le rang * 10. L'utilisation de WhateverStar nous procure une fermeture et maxune fonction de comparaison.

05AB1E , 12 octets

Σ'pK°.Vyþ*}θ

.V(évalué en tant que code 05AB1E) est inspiré par l' approche similaire de @Arnauld dans sa réponse sur Jelly .

Entrez une liste de deux (ou plus) des chaînes valides.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Voir toutes les valeurs mappées ici.

Scala , 307 61 54 octets

Un grand merci à Kevin Crujissen et à ASCII uniquement pour leur travail sur cette réponse, qui nous a permis de gagner environ 250 milliards de dollars.

Certaines optimisations d’algorithmes pour la fonction de commande de la réponse 61b.

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

Cas de test ici: Essayez-le en ligne!

Vieux 61 octets de réponse

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

L'astuce consiste à calculer la distance entre rank letteret i(code de caractère 105). Ensuite, nous utilisons cette distance comme un score ( dan = 5, kyu = 2, pro = 7) que nous multiplions par le nombre de rang. Ensuite, nous prenons le maximum sur le tableau d’entrée en utilisant la fonction de scoring.

Essayez-le aussi en ligne!

PHP , 100 98 octets

(-2 octets en changeant la déclaration de fonction)

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

Pour l'exécuter:

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

Exemple:

php -n go_rank.php 1p 7d

Ou essayez-le en ligne!

PHP (7.4), 74 octets

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

Essayez-le en ligne!

Comment?

Similaire à l'approche d' Arnauld , mais en PHP. J'utilise une fonction pour convertir chaque rang en valeur numérique et comparer et afficher celui avec la valeur la plus élevée.

La valeur de rang provient de la position du deuxième caractère de la chaîne d'entrée dans !!dp, réduite de un, puis alimentée à 3 et multipliée par la partie entière de la chaîne d'entrée.

Ainsi , par exemple, la position du second caractère de ce 1pqui est pen !!dpvaut 3, et réduit par une tension de 3 , il sera 8. Donc , une partie de nombre entier de tous les *prangs sera multiplié par 8. Ce moyen 1p = 8, 2p = 16, ..., 9p = 72.

Pour tous les *drangs, la partie entière sera multipliée par 1 (ou simplement aucune multiplication). Ce moyen 1d = 1, ..., 7d = 7.

Et pour tous *ket tous les **krangs, la position du deuxième caractère dans !!dpsera égale à falsece qui est égal à 0 (non explicite), réduite de un et alimentée par 3, signifie que la partie entière sera multipliée par -1. Ce moyen 30k = -30, ..., 1k = -1.

C'est ma première tentative de golf, je ne sais pas à quel point c'est mauvais!

Excel VBA, 129 octets

Une fonction de fenêtre VBE Immediate anonyme qui prend les entrées dans la plage A1:A2et les envoie à la 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))]

Explication

[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