Quel rang de Go est plus élevé?

53

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 : 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
Lynn
la source
Les entrées peuvent-elles nécessiter des zéros non significatifs? C'est-à-dire 04k
Amphibologique le
6
Non; Bien que je sois flexible en ce qui concerne les méthodes d' E / S , j'ai bien peur de ne permettre aucune variation dans les chaînes d'entrée elles-mêmes. Je pense qu'elles constituent un niveau parfait d '"intéressant" en l'état. (Je ne permettrai pas 4 kou environ 4K, soit.)
Lynn
2
Sommes-nous autorisés à prendre les entrées sous forme de paires (int, string)?
Mnémonique
9
Non; à nouveau, l'esprit du défi est de manipuler les chaînes de texte exact 30k, 29k, 1k, 1det ainsi de suite, donc je ne permettrai pas que toute variation là.
Lynn

Réponses:

36

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.

Arnauld
la source
Pas aussi malin, mais -3:a=>b=>(g=s=>parseInt(s)*~{d:~1,p:~8}[s[1]])(a)>g(b)?a:b
FireFly
2
@FireFly Merci. Mais une réponse similaire avait déjà été soumise et je ferais mieux de laisser celle-ci inchangée.
Arnauld
12

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 107kdp107100112107

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.16k'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
Jonathan Allan
la source
Très belle méthode!
Arnauld
Je ne comprends pas comment 14 caractères Unicode sont traduits en 14 octets. 2^8=256, qui est ASCII, autant que je sache. Vous n'avez pas besoin de plus d'un octet pour contenir des caractères Unicode, alors?
Post Self
@PostSelf le bytecode est de 14 octets, les caractères unicode ne représentent que des octets - voir la page de code dans le lien vers "octets" dans l'en-tête.
Jonathan Allan
1
@ JonathanAllan Ah, je vois, merci!
Post Self
12

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é à779 qui est7(mod9)[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)
Jonathan Allan
la source
Je savais que ça devait arriver. :) Mais je suis quand même satisfait de t'avoir égratigné pendant environ 90 minutes. : p
Arnauld
Je me sens toujours un peu bête de ne pas avoir exploré une avenue qui m’était venue à l’esprit au tout début!
Jonathan Allan
C'est une réponse très soignée!
Lynn
10

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

sundar - Rétablir Monica
la source
1
Nous avons donc maintenant l'algorithme d'Arnauld et la méthode polynomiale sundaire. Charmant. +1
David Conrad
9

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)

Cubique
la source
Vous pouvez enregistrer 1 octet en changeant Trueà 1<2.
Amphibologique
1
(-x)peut être 0-x.
Lynn
vous pouvez aussi changer le motif final r(x,_)=x+7!
Lynn
Vous avez oublié de changer le motif final, il devrait être 69 ( 0-xpeut également être `-x`)
ASCII uniquement
8

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!

Xnor
la source
6

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
digEmAll
la source
J'ai essayé d'utiliser Là la place de .mais ça ne marche pas non plus ... je vous ferai savoir si je peux trouver autre chose.
JayCe
Félicitations pour 1K!
Giuseppe
6

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'
Arnauld
la source
Oh mec, j'ai pensé à ce genre de méthode avant de suivre la voie que j'avais choisie ... J'aurais vraiment dû l'essayer!
Jonathan Allan
... maintenant j'ai 11
Jonathan Allan
5

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)
Lyndon White
la source
C'est plutôt chouette. Et je ne savais pas que .~[a,b]c'était possible! Au fait, je pense que vous pouvez remplacer collect (r) par [r...]et sauvegarder quelques octets.
dimanche
Bien, et alors je peux Int[r...]plutôt Int([r...])économiser que quelques économies supplémentaires. Merci
Lyndon White
Soit dit en passant, le code fonctionne à peu près tel quel (après avoir été remplacé argmaxpar indmax) sur Julia 0.6. Vous pouvez inclure un Essayez-le en ligne! lien si vous souhaitez.
dimanche - Réintégrer Monica
Merci, mes autres réponses julia 0.7 récentes ont beaucoup moins évité les déprédations que celle-ci.
Lyndon White
Ouais, les choses semblent évoluer vers une direction plus verbeuse en terre Julia avec des arguments de mots clés obligatoires, des déplacements stdlib nécessitant des importations, des espaces blancs nécessaires, etc. J'ai jeté un coup d'œil autour de votre page utilisateur, mais je n'ai trouvé aucune réponse pour Julia 0.7.
dimanche - Réintégrer Monica
5

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.

Xnor
la source
3

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)
Luis Mendo
la source
3

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?

cm

m=(c4mod90)-2

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:

m=((c-1)9mod64)-1
OṪ’*9%64’×ṖV$µÞṪ

Essayez-le en ligne!

Arnauld
la source
3

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
Herman L
la source
Cela semble fonctionner pour 54.
Shaggy
@Shaggy échoue pour votre solution f("2d")("1d"), mais la remplace d:1par la d:2fixe.
Herman L
1
Essayez de golf, mais encore 54 octets ... si triste
tsh
3

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

Amphibologique
la source
était sur le point de commenter le changement que vous venez de faire :) vous n'êtes pas obligé de dupliquer le code ici, utilisez
Conor O'Brien
3

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"));
}
raznagul
la source
1
Vous pouvez enregistrer un octet avec Currying, par exemple a=>b=>.
TheLethalCoder
Oh, vous devriez aussi pouvoir utiliser ints au lieu des caractères littéraux. Ça fait longtemps que je n'ai pas
joué au golf,
@TheLethalCoder: PadLeftrequiert charet utiliser 107au lieu de 'k'ne fait aucune différence.
Raznagul
Oh, je pensais que la conversion était implicite ... cela valait la peine d'essayer
TheLethalCoder
3

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.

Silvio Mayolo
la source
1
Très bonne solution, je n'ai rien trouvé d'aussi élégant! Vous pouvez économiser 8 octets en faisant correspondre / /et en utilisant `` $ `` `et $': Essayez-le en ligne!
Dom Hastings
3

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
Giuseppe
la source
1
62 octets avec ordonné (...) au lieu de facteur (..., o = T)
Robin Ryder
@RobinRyder merci! J'ai lu la page de documentation pour factoret complètement raté ordered.
Giuseppe
3

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
Kevin Cruijssen
la source
1
122 octets
Sara J
@SaraJ Merci! :) J'ai eu du mal à trouver une alternative plus courte, mais j'étais sûre qu'il devrait y en avoir. Était assez drôle, j'ai trouvé trois 128 alternatives, mais aucune plus courte ..
Kevin Cruijssen
3

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

Sara J
la source
1
(read$init k)peut être read(init k). Une fonction auxiliaire est plus courte que l’utilisation case of: essayez-la en ligne!
Laikoni
@Laikoni Merci!
Sara J
1
68?
ASCII uniquement le
@ Nice uniquement, merci!
Sara J
1
@SaraJ vous n'avez pas mis à jour le lien: P
ASCII uniquement
2

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!

M. Xcoder
la source
2

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

sundar - Rétablir Monica
la source
2

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.

Neil
la source
2

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
Jonas
la source
2

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!

Jonathan Allan
la source
2

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!

ErikF
la source
Bonne utilisation des déclarations de fonctions de style ancien.
SIGSTACKFAULT
2

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.

Phil H
la source
2

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,sept]
  • p°uneuneuneune"2k""2d""2k""2d"°"2"p°100"1p""9p"[dix,200,3000,40000,500000,6000000,70000000,800000000,9000000000].

Voir toutes les valeurs mappées ici.

Kevin Cruijssen
la source
2

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!

V. Courtois
la source
2
@ V. Courtois vous pouvez ajouter du texte dans l'en-tête
ASCII uniquement
1
Comme @ ASCII-only mentionné, vous pouvez le créer dans l'en-tête avec un var f: Function1[String, Function1[String, String]]=. 247 octets .
Kevin Cruijssen
2
203
ASCII uniquement
2
86
ASCII uniquement
2
64
ASCII uniquement
2

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!

Nuit2
la source
1

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
Taylor Scott
la source