Spieler des traditionellen Brettspiels Go messen ihre Fähigkeiten in einem Rangsystem :

• Spieler, die neu im Spiel sind, werden als 30. kyū (geschrieben 30k) eingestuft und der Fortschritt wird bis zum 1. kyū (geschrieben 1k) heruntergezählt . Diese werden als Schülerränge betrachtet .
• Ein Spieler kann vom 1. Kyū zum 1. Dan Rang (geschrieben 1d) aufsteigen und dann bis zum 7. Dan Rang (geschrieben 7d) weiterkommen . Dies sind die Meisterränge .
• Außergewöhnlich qualifizierte Spieler 7dkönnen in den ersten professionellen Dan-Rang aufsteigen 1p und Fortschritte bis zum neunten professionellen Dan- Rang (schriftlich 9p) zählen. Dies ist der höchste Rang.

Kurzum: Ränge werden bestellt 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p.

Aufgabe

Gegeben seien zwei Strings unter { 30k, ..., 1k, 1d, ..., 7d, 1p, ..., 9p} als Eingabe, Ausgabe der höheren Rang der beiden. (Wenn sie gleich sind, geben Sie einfach einen der beiden Eingänge aus.)

(Wie üblich ist I / O flexibel - Ihre Antwort kann eine Funktion oder ein vollständiges Programm sein, das Eingaben in angemessener Weise liest und Ausgaben in angemessener Weise erzeugt.)

Das ist Code-Golf : Das Ziel ist es, die Byte-Anzahl Ihres Codes zu minimieren.

Testfälle

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

Übernimmt die beiden Zeichenfolgen in der Currying-Syntax (a)(b).

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

Probieren Sie es online!

Wie?

Die Hilfsfunktion g () übersetzt die Eingabezeichenfolge s in eine Punktzahl.

1) Wir suchen nach s [1] in der Zeichenfolge "_dp" . Das gibt:

• 1 für einen Dan Rang "xd"
• 2 für einen professionellen Dan Rang "xp"
• -1 für einen Kyū Rang „xk“ oder „XXK“ da s [1] ist entweder „k“ oder eine Ziffer

2) Wir würfeln dieses Ergebnis, was 1 und -1 unverändert lässt, aber 8 für einen professionellen Dan- Rang ergibt .

3) Wir multiplizieren mit dem Dezimalteil des Ranges.

Jelly , 14 Bytes

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

Ein monadischer Link, der eine Liste von Zeichenfolgen * (wie beschrieben) akzeptiert, die den höchsten gefundenen Rang ergibt.

^{* Funktioniert auch mit anderen Zahlen als zwei.}

Probieren Sie es online! Oder sehen Sie sich eine Testsuite an .

Wie?

Sortiert nach einer Tastenfunktion und gibt das am weitesten rechts stehende (dh ein Maximum) zurück.

Die Buchstaben , d und p haben die Ordnungszahlen 107 , 100 bzw. 112 . In der Binärdatei 107 sind die acht Bits gesetzt, während die anderen nicht gesetzt sind. Bei einer bitweisen ODER-Verknüpfung mit 8 erhalten wir 107, 108 und 120 - diese sind jetzt in der Reihenfolge, in der die von ihnen identifizierten Klassen sortiert werden müssen.$k$$d$$p$$107$$100$$112$$107$

Die Amateur-Ränge sind in absteigender Reihenfolge, sodass wir zur Vervollständigung unserer Schlüsselfunktion unseren Klassenbezeichner mit der in der Zeichenfolge angegebenen Nummer verketten und negieren können, wenn die Zeichenfolge mit endet (z. B. -> while -> ). Im Code muss dazu der Klassenbezeichner gespeichert und minus eins für die Multiplikation - das sind 16 Bytes - potenziert werden.$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

Um dies zu verbessern, können wir stattdessen minus zwei verwenden und die Elemente miteinander multiplizieren, was mit einer einzigen Multiplikation erreicht werden kann.

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)

Tabelle der Tastenfunktion ...

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

Jelly ,  11 bis  10 Bytes

^{Inspiriert von Arnauld, zum Zeichenbrett zurückzukehren!}

⁾kNyv9FµÞṪ

Ein monadischer Link, der eine Liste von Zeichenfolgen * (wie beschrieben) akzeptiert, die den höchsten gefundenen Rang ergibt.

• Funktioniert auch mit anderen Zahlen als zwei.

Probieren Sie es online! Oder sehen Sie sich eine Testsuite an .

Wie?

Sortiert nach einer Tastenfunktion und gibt das am weitesten rechts stehende (dh ein Maximum) zurück.

Die Schlüsselfunktion wandelt k zunächst mit dem dyadischen Atom in ein N um y, übersetzt es mit der zweistelligen Liste ⁾kN(Jelly-Code für ['k','N']) und wertet die Zeichenfolge dann als Monade mit einem Argument von neun aus (unter Verwendung des Codes v9).

In Gelee:

• N ist ein monadisches Atom, das seine Eingabe negiert

  • Der Code verwendet 9 30Nalso nicht die Neun und ergibt die Ganzzahl-30

• d ist ein dyadisches Atom, das das Ergebnis eines Python-Divmods mit zwei Werten ergibt - das Ergebnispaar aus ganzzahliger Division und Modulo

  • der Code 9 7dergibt also gepaart mit$\lfloor \frac 7 9 \rfloor$ welches ist$7 \pmod 9$[0,7]

• p ist ein dyadisches Atom, das ein kartesisches Produkt ausführt, das eine implizite 1-indizierte Bereichseinstufung seiner Eingaben enthält

  • Der Code 9 p3liefert also das kartesische Produkt von [1,2,3]und [1,2,3,4,5,6,7,8,9]welches ist[[1,1],[1,2],...,[1,9],[2,1],[2,2],...,[2,9],[3,1],[3,2],...,[3,9]]

Sobald solche Bewertungen unter Verwendung der zu vergleichenden Zeichenfolgen durchgeführt wurden, müssen wir in der Lage sein, die Ergebnisse zu vergleichen. da ints nicht mit listen vergleichbar sind, müssen wir die negierten werte in eine liste einschließen, aber da die ordnung nach dem pabflachen der listen immer noch funktionieren würde (zb [[1,1],[1,2],...]-> [1,1,1,2]), können wir das monadische einzelbyte-atom verwenden, Fdas auf alle auswertungen angewendet wird.

Eine Tabelle der Eingaben zu ihrem Schlüsselwert sieht wie folgt aus:

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]

Code-Kommentar:

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

MATL , 30 28 25 23 Bytes

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

Probieren Sie es online!

(-2 Bytes dank Luis Mendo)
(weitere -3 Bytes ersetzt v&X>mit >, diesmal auf Basis von Luis Mendo Antwort)
(-2 Bytes mit &)Syntax)

Erläuterung:

• Subtrahiere 'k' vom letzten Zeichen (ergibt n = -7, 0, 5 für 'd', 'k', 'p').

• Berechnen Sie v = n ^ 2 + 6n-1 (ergibt 7, -1, 54).

• Multiplizieren Sie diesen Wert v mit der tatsächlichen Rangnummer (so dass k Niveaus negative Produkte erhalten, d Niveaus von 7 bis 49, p Niveaus von 54 und höher).

• Vergleichen Sie die Produkte für beide Eingabezeichenfolgen

• Rufen Sie die Eingabezeichenfolge ab, die dem größeren Produkt entspricht

Alternative, einfachere Methode:

23 Bytes

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

Probieren Sie es online!

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

Haskell , 73 71 Bytes

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

Probieren Sie es online!

Wie für mich üblich, nur eine unkomplizierte Implementierung, anstatt etwas besonders Golf-y. Die Funktion "(#)" nimmt zwei Ränge als Zeichenketten und gibt den größeren zurück. Funktioniert nur mit genau dem in der Frage angegebenen Format.

(Ich habe auch versucht, eine Version mit comparingund zu verwenden, maximumByaber das endete damit, dass sie 3 Bytes länger war - verdammt, Sie baseund Ihre gelegentlich von Menschen lesbaren Funktionsnamen!)

(Angewandte Vorschläge von Amphibological und Lynn)

Python 2 , 54 Bytes

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

Probieren Sie es online!

Nach Arnauld . Die Zuordnung int(x,27)%9-3hängt nur vom letzten Buchstaben von ab x, da alle Ziffern bis auf die letzte ein Vielfaches von beisteuern 9. Es braucht:

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

Dies ist kaum genug Spielraum für den Multiplikator 1p, um 7dden höchsten Dan-Rang zu schlagen , wenn er in Basis 26 interpretiert wird.

Ich fand dies, indem ich Ausdrücke dieser und einiger anderer Formen brachial erzwang.

Python 2 , 64 Bytes

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

Probieren Sie es online!

R , 73 Bytes

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

Probieren Sie es online!

• Ich musste as.doublestattdessen verwenden, strtoida letzteres keine Leerzeichen / Punkte behandelt und ich mir kein anderes gültiges Zeichen zum Ersetzen vorstellen konnted
• -1 Byte verwenden rankstatt order, da sie gleich sind, wenn nur zwei Elemente vorhanden sind

Jelly , 13 Bytes

Dies ist ganz anders als meine andere Jelly-Antwort , daher poste ich dies separat.

Übernimmt die Eingabe als Liste von zwei (oder mehr) Zeichenfolgen.

“kNdHp0”yVµÞṪ

Probieren Sie es online!

Kommentiert

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

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

Julia 0,7 100 93 Bytes

Dies ist nicht der effizienteste Weg ( Antwort Julia 0.6 von contrast @ sundar ), aber es ist schön, weil es rein numerisch ist. Verwendet auch Versand (wenn auch leider nur einmal)

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

Sehr ähnlicher Code funktioniert in 0.6. Versuchen Sie es online

Wie:

Der Trick liegt in der !(z)Funktion.

Es ordnet den UTF-8-Wert zu:

• für kin eine negative Zahl, also rückwärts sortiert
• für din eine positive Zahl
• für pin eine größere positive Zahl

Wie gezeigt:

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

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

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

Testergebnisse

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

Haskell , 64 Bytes

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

Probieren Sie es online!

Der Ausdruck gcd(fromEnum c)28-3ordnet das Zeichen einem Multiplikator zu

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

Die Idee war, ihre Charakterwerte zu übernehmen [107,100,112] und zu wählen 28, dass immer größere Faktoren mit ihnen gemeinsam sind, die leicht gemacht wurden, aber der erste war der Primus. Diese Methode spart 2 Bytes beim expliziten Schreiben eines Mappings .

Das eingebaute reads wird verwendet, um die Nummer und Rang zu trennen.

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

(Eigentlich die direkte Aufteilung von Sara J um ein Byte kürzer und ergibt 63 Bytes .)

Der "Take-the-Large-One" -Schritt nimmt in meiner Lösung eine nervige Anzahl von Bytes in Anspruch. Ich habe andere Ansätze ausprobiert, wie das Durchlaufen von Rängen in absteigender Reihenfolge und das Aufnehmen des ersten Elements [a,b], aber sie sind länger ausgefallen.

MATL , 28 27 Bytes

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

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

Gelee , 16 Bytes

Übernimmt die Eingabe als Liste von zwei Zeichenfolgen.

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

Probieren Sie es online! (alle Testfälle)

Wie?

$c$$m$

Welches gibt:

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

Kommentiert

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

Alternative Formel

Auch für 16 Bytes können wir verwenden:

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

Probieren Sie es online!

JavaScript (ES6), 55 54 Byte

-1 Byte dank @Shaggy

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

Probieren Sie es online!

Erläuterung

a=>b=>
  (s=x=>                 // Function s(x), that converts x to a "score", where a higher
                         // rank gets a higher score by
    parseInt(x)*         //   taking the integer part of x and multiplying it by
    ~-{p:9,d:2}[x[1]])  //   ~-9 (8) if it is a professional rank, ~-2 (1) if it is a dan
                         //   rank and ~-undefined (-1) if it is a kyū rank by looking up
                         //   the second character of the string
  (a)>s(b)               // Compare s(a) and s(b)
    ?a:b                 //   and return the one with the biggest score

Ruby , 52 46 Bytes

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

Einfache Antwort von xnor.

Probieren Sie es online!

BEARBEITEN: -6 Bytes durch die Erkenntnis, dass ich einen Proc hätte verwenden können

C # (Visual C # -Compiler) , 136 bis 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;}

Probieren Sie es online!

-1 Byte dank TheLethalCoder

Erweiterung:

static void Main()
{
    System.Func<string, System.Func<string, string>> f =
        a => b =>
        {
            string c = a.PadLeft(3, '0'),
                d = b.PadLeft(3, '0');      //Pad the input with leading '0' to be 3 characters long
            int x = c[2] - d[2];            //Calculate the difference of the letter characer (the character at index 2) as integer
            return                          //return ...
                (x == 0 ?                   //if the letter of the inputs is the same...
                c.CompareTo(d)              //  compare the padded strings resulting in a positive number if the first input is greater or a negative number if the first input is lower 
                    * (                     //  multiply the result by...
                    c[2] == 'k' ? -1 : 0    //  if the letter is 'k' then -1 else 0
                    ) > 0                   //  check if the result is greater than 0
                :                           //else (the letters are not the same)
                x == 5 | x > 9 | x == -7    //  check if the letter difference was 5 (input p and k) or 12 (> 9, input p and d) or -7 (input d and k)
                ) ? a : b;                  //  then return the first input else return the second input.
        }
    ;

    System.Console.WriteLine(f("29k")("9k"));
    System.Console.WriteLine(f("21k")("27k"));
    System.Console.WriteLine(f("6d")("1p"));
    System.Console.WriteLine(f("5d")("7k"));
    System.Console.WriteLine(f("1k")("1d"));
    System.Console.WriteLine(f("1d")("1d"));
    System.Console.WriteLine(f("1d")("2d"));
    System.Console.WriteLine(f("9p")("1d"));
    System.Console.WriteLine(f("2d")("30k"));
    System.Console.WriteLine(f("1p")("1k"));
    System.Console.WriteLine(f("1d")("1p"));
    System.Console.WriteLine(f("1p")("2d"));
    System.Console.WriteLine(f("7p")("8p"));
    System.Console.WriteLine(f("30k")("30k"));
}

Perl, 46 38 Bytes

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

Führen Sie so perl -pae '...'. Nimmt Eingaben von stdin entgegen, die in einer Zeile durch Leerzeichen getrennt sind.

Führt einige Ersetzungen durch, um den Vergleich "einfacher" zu machen. Die regulären Ausdrücke werden im Wesentlichen durch peine nachgestellte Null und kein führendes negatives Vorzeichen ersetzt. So 10kwird -10(so wird die Reihenfolge umgekehrt) und 3pwird 30(so psteht das über allem anderen). Dann ist es nur ein einfacher numerischer Vergleich.

Vielen Dank an DomHastings für den $`/ $'Vorschlag, der 8 Bytes gespart hat .

R , 65 62 Bytes

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

Probieren Sie es online!

Dies ist etwas kürzer als die vorherigen R-Antworten und nutzt die Statistikfunktionalität von R :-)

-3 Bytes dank des Vorschlags von Robin Ryder , ordered anstelle von zu verwenden factor

Übernimmt die Eingabe von stdin (obwohl sich der TIO-Link zum leichteren Testen leicht umstrukturiert). Wandelt die Eingabe-Ränge in eine geordnete um factor von allen Rängen und nimmt dann die max.

Die Ausgabe sieht folgendermaßen aus:

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

Java 8, 128 122 121 Bytes

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

-6 Bytes dank @SaraJ .

Probieren Sie es online aus. (Die zugeordneten Werte finden Sie im unteren Bereich der Ausgabe in den TIO-Links.)

Erläuterung:

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

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

Haskell , 75 70 68 Bytes

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

Probieren Sie es online!

-5 bytesdanke an @Laikoni
-2 bytesdanke an @ ASCII-only

Python 2 , 61 Bytes

Verwendet Arnauld's Algorithmus.

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

Probieren Sie es online!

Vorherige Antwort 73 Bytes

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

Probieren Sie es online!

Julia 0,6 , 75 71 65 Bytes

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

Probieren Sie es online!

(-4 Bytes, Parsen in 0.6 erkennt es automatisch als Int)

(-6 Bytes, Verwendung (search("_dp",s[2])-1)^3)basierend auf der JS-Antwort von Arnauld anstelle von ((c=cmp(s[end],'k'))^2*6+4c-1))

Retina 0.8.2 , 29 Bytes

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

Probieren Sie es online! Akzeptiert eine beliebige Anzahl von Rängen und gibt die höchsten aus. Erläuterung:

O`

Sortiere die Zeilen ...

$

... mit dem angegebenen Schlüssel ...

^

... in umgekehrter Reihenfolge.

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

Der Schlüssel wird wie folgt aus der Eingabezeile erzeugt: a) der (professionelle) Dan-Rang-Buchstabe b) der Rang in Unary c) der Kyū-Buchstabe (falls zutreffend). Da dies eine umgekehrte Sortierung ist, wird der professionelle Dan-Rang pvor dem Dan-Rang dund dem Kyū-Rang sortiert, der mit beginnt, 1da der Kyū-Buchstabe am Ende übrig bleibt. Innerhalb der Ränge werden die (professionellen) Dan-Ränge aufgrund der Länge der unären Zeichenfolge in absteigender Reihenfolge sortiert, jedoch werden sie durch das Nachziehen kder Kyū-Ränge in aufsteigender Reihenfolge sortiert.

1G`

Wählen Sie die erste Zeile aus, die jetzt den höchsten Rang hat.

J, 39 Bytes

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

Probieren Sie es online!

Erläuterung

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

Python , 59 Bytes

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

Eine unbenannte Funktion, die eine Iteration von Zeichenfolgen akzeptiert und nach Go-Rang eine maximale zurückgibt. Funktioniert ähnlich wie meine Jelly-Antwort (verwendet nur die gesamte Zeichenfolge, die als Ganzzahl in Basis 26 ausgewertet wird, um Bytes zu sparen).

Probieren Sie es online!

C (gcc) 95 Bytes

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

Probieren Sie es online!

Perl 6 , 35 Bytes

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

Probieren Sie es online!

Ein etwas anderer Ansatz für all diese Such-und-Würfel-Dinge. Im Wesentlichen string Ersatz: ...k -> -..., p -> 0, dgelöscht. So bekommen Neulinge eine Minusnote, Dans bekommen ihren Rang und Profis bekommen Rang * 10. Die Verwendung des WhateverStar verschafft uns einen Abschluss und maxübernimmt eine Komparatorfunktion.

05AB1E , 12 Bytes

Σ'pK°.Vyþ*}θ

.V(als 05AB1E-Code auswerten) ist von @Arnauld 's ähnlichem Ansatz in seiner Jelly-Antwort inspiriert .

Eingabe als Liste von zwei (oder mehr) gültigen Zeichenfolgen.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Sehen Sie hier alle zugeordneten Werte.

Scala , 307 61 54 Bytes

Vielen Dank an Kevin Crujissen und ASCII-only für die Arbeit an dieser Antwort, die es geschafft hat ~ 250b runter zu kommen.

Einige Algorithmusoptimierungen für die Bestellfunktion von 61b-Antworten.

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

Testfälle hier: Online ausprobieren!

Alte 61 Bytes antworten

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

Der Trick besteht darin, den Abstand zwischen rank letterund i(Zeichencode 105) zu berechnen . Dann verwenden wir diese Distanz als Punktzahl ( dan = 5, kyu = 2, pro = 7), die wir mit der Rangzahl multiplizieren. Dann nehmen wir das Maximum des Eingabearrays mit der Scoring-Funktion.

Probieren Sie es auch online aus!

PHP , 100 98 Bytes

(-2 Bytes durch Änderung der Funktionsdeklaration)

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

Um es auszuführen:

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

Beispiel:

php -n go_rank.php 1p 7d

Oder versuchen Sie es online!

PHP (7.4), 74 Bytes

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

Probieren Sie es online!

Wie?

Ähnlich wie bei Arnauld , aber in PHP. Ich verwende eine Funktion, um jeden Rang in einen numerischen Wert umzuwandeln und den mit dem höheren Wert zu vergleichen und auszugeben.

Der Rangwert ergibt sich aus der zweiten Zeichenposition der Eingabezeichenfolge in !!dp, wird um eins verringert und dann auf 3 hochgesetzt und mit dem ganzzahligen Teil der Eingabezeichenfolge multipliziert.

So zum Beispiel, Position des zweiten Zeichens von 1pdenen pin !!dp3 ist , vermindert um eine und angetriebene bis 3 es 8.en So ganzzahlige Teil aller seine *pReihe wird durch 8 multipliziert Dies bedeutet 1p = 8, 2p = 16, ..., 9p = 72.

Für alle *dRänge wird der ganzzahlige Teil mit 1 multipliziert (oder einfach ohne Multiplikation). Das heißt 1d = 1, ..., 7d = 7.

Und für alle *kund **kRänge ist die Position des zweiten Zeichens in !!dpgleich, falsewas gleich 0 ist (nicht explizit), reduziert um eins und mit 3 versorgt, was bedeutet, dass der ganzzahlige Teil mit -1 multipliziert wird. Das heißt 30k = -30, ..., 1k = -1.

Dies ist mein erster Golfversuch, ich bin mir nicht sicher, wie schlimm er ist!

Excel VBA, 129 Bytes

Eine anonyme VBE-Direktfensterfunktion, die Eingaben in den Bereich A1:A2und Ausgaben an die Konsole überträgt.

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

Erklärung

[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