Geleneksel masa oyunu oyuncular bir kendi beceri ölçmek git sıralarında sistemine :

• Oyunda yeni olan oyuncular 30. kyū (yazılı 30k) ve 1. kyū (yazılı ) olarak geri sayım yaparlar1k . Bunlar öğrenci rütbeleri olarak kabul edilir .
• Bir oyuncu, 1. kyū ila 1. dan rütbesine (yazılı 1d) terfi edebilir ve daha sonra 7. dan rütbesine (yazılı ) kadar sayma ilerleyebilir . Bunlar usta rütbeler.7d
• İstisnai olarak yetenekli oyuncular 7d, ilk profesyonel dans rütbesine terfi edebilir 1pve 9. profesyonel dans rütbesine kadar sayılan ilerleme (yazılı ). Bu en yüksek rütbe.9p

Kısacası: rütbe emri verildi 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p.

Görev

Arasında iki dizeyi göz önüne alındığında { 30k, ..., 1k, 1d, ..., 7d, 1p, ..., 9p} girdi olarak, çıkış yüksek ikisinin rütbesi. (Eşitlerse, her iki girişi de basmanız yeterlidir.)

(Her zamanki gibi, G / Ç esnektir - cevabınız, herhangi bir makul şekilde girdi okuyan ve makul bir biçimde çıktı üreten bir işlev veya tam bir program olabilir.)

Bu kod golf : Amaç, kodunuzun bayt sayısını en aza indirmektir.

Test durumları

(Biçim:. 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 bayt

Küme sözdizimi iki dize alır (a)(b).

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

Çevrimiçi deneyin!

Nasıl?

Yardımcı fonksiyon g () giriş dizgisini s bir skora çevirir .

1) s [1] 'i "_dp" dizgisine bakarız . Bu verir:

• 1 Bir için Dan rank "xd"
• Profesyonel bir rütbe için 2 "xp"
• "Xk" veya "xxk" kyk rütbesi için -1 ; s [1] ya "k" ya da bir rakam olduğundan

2) 1 ve -1 değerlerini değiştirmeyen ancak profesyonel bir rütbe için 8 veren bu sonucu küplendiriyoruz .

3) Sıralamanın ondalık kısmı ile çarpıyoruz.

Jöle , 14 bayt

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

Bulunan en yüksek rütbeyi veren bir dizge listesi * (tanımlandığı gibi) kabul eden bir monadik bağlantı.

^{* Ayrıca ikiden farklı sayılarla çalışır.}

Çevrimiçi deneyin! Veya bir test odasına bakın .

Nasıl?

Bir tuş işlevine göre sıralar ve en sağa döndürür (örneğin maksimum).

Harfler , d ve s sıra sayılarını sahip 107 , 100 ve 112 , sırasıyla. İkili 107'de sekiz bit ayarlanmış, diğerleri ise bitmiyor, bu nedenle bit 8'le VEYA sırasıyla sırasıyla 107, 108 ve 120 elde ediyoruz - bunlar şimdi tanımladıkları sınıfları sıralamak için gereken sıraya göre.$k$$d$$p$$107$$100$$112$$107$

Amatör rütbeleri biz dize bitmesi halinde negating dizede verilen sayı ile bizim sınıf tanımlayıcı birleştirerek, bizim anahtar işlevi tamamlamak için böylece azalan sırada olan (örn -> iken -> ). Kodda bu, sınıf tanımlayıcısının kaydedilmesini ve çarpım için eksi birin üstelik depolanmasını gerektirir - - bu 16 bayttır.$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

Bunu geliştirmek için eksi iki yerine kullanabiliriz ve öğeleri tek bir çarpma ile elde edilebilecek şekilde çoğaltabiliriz.

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)

Anahtar fonksiyonun eylem tablosu ...

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

Jöle ,  11  10 bayt

^{Arnauld tarafından çizim tahtasına geri dönmek için ilham verdi!}

⁾kNyv9FµÞṪ

Bulunan en yüksek rütbeyi veren bir dizge listesi * (tanımlandığı gibi) kabul eden bir monadik bağlantı.

• Ayrıca ikiden farklı sayılarla çalışır.

Çevrimiçi deneyin! Veya bir test odasına bakın .

Nasıl?

Bir tuş işlevine göre sıralar ve en sağa döndürür (örneğin maksimum).

Anahtar işlevi ilk bir değişikliği k bir olma N diyadik atomu ile yiki karakter listesi, tercüme ⁾kN(Jelly kodu ['k','N']) ve daha sonra (kod kullanılarak dokuz bir bağımsız değişken ile, bir monadın olarak dizge değerlendirir v9).

Jelly'te:

• N girişini olumsuzlaştıran monadik bir atomdur

  • bu yüzden kod 9 30Naslında dokuz'u kullanmaz ve tamsayıyla sonuçlanır.-30

• d İki değerli bir Python divmodunun sonucunu veren diyalitik bir atomdur - tamsayı bölme ve modulo sonuçlarının çifti

  • bu yüzden kod ⌊ 7 ile9 7d sonuçlanır.ile eşleştirilmiş$\lfloor \frac 7 9 \rfloor$ hangisi$7 \pmod 9$[0,7]

• p Girişlerin örtük 1-indeksli aralık-ifikasyonunu içeren, Kartezyen bir ürün gerçekleştiren dyadik bir atomdur.

  • bu yüzden kod 9 p3Kartezyen ürününü verir [1,2,3]ve [1,2,3,4,5,6,7,8,9]hangisi[[1,1],[1,2],...,[1,9],[2,1],[2,2],...,[2,9],[3,1],[3,2],...,[3,9]]

Bu tür değerlendirmeler karşılaştırılacak dizeler kullanılarak yapıldıktan sonra sonuçları karşılaştırabilmemiz gerekir; ints listeleriyle karşılaştırılabilir olmadığından, negatif değerleri bir listeye sarmamız gerekir, ancak plisteler düzleştirildikten sonra sipariş hala işe yarayacağından (örneğin [[1,1],[1,2],...]-> [1,1,1,2]) Ftüm değerlendirmelere uygulanan tek baytlık monadik atomu kullanabiliriz.

Anahtar-değerlerinin giriş tablosu aşağıdaki gibidir:

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]

Kod yorumu:

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

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

Çevrimiçi deneyin!

(-2 Luis Mendo sayesinde bayt)
(başka -3 bayt yerine v&X>ile >Luis MENDO cevabı göre bu kez)
(kullanarak -2 bayt &)sözdizimi)

Açıklama:

• Son karakterden 'k' harfini çıkarın (sırasıyla 'd', 'k', 'p' için n = -7, 0, 5 verir).

• Hesaplama v = n ^ 2 + 6n-1 (sırasıyla 7, -1, 54 verir).

• Bu v değerini gerçek sıra numarası ile çarpın (böylece k seviyeleri negatif ürünler alır, d seviyeleri 7'den 49'a, p seviyeleri 54'den ve üstüne).

• Her iki giriş dizesi için de ürünleri karşılaştırın.

• Daha büyük ürüne karşılık gelen girdi dizesini alın

Alternatif, daha basit yöntem::

23 bayt

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

Her zamanki gibi, özellikle golf-y gibi bir şey değil, doğrudan bir uygulama. "(#)" İşlevi dizge olarak iki aşamayı alır ve daha büyük olanı döndürür. Yalnızca soruda belirtilen biçimde çalışır.

(Ben de kullanarak bir sürümü denedim comparingve maximumBybu 3 bayt daha uzun oldu - ama size baseve zaman zaman insan tarafından okunabilir işlev isimleri kahretsin !)

(Amphibological ve Lynn tarafından uygulanan öneriler)

Python 2 , 54 bayt

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

Çevrimiçi deneyin!

Arnauld'un metodunu kullanarak . Haritalama int(x,27)%9-3sadece son harfine bağlıdır x, çünkü tüm rakamlar sonuncusu katına katkısı vardır 9. Alır:

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

Bu, üs 26'da yorumlandığında çarpanın 1pyenmesi 7diçin en yüksek dans rütbesi için zar zor yeterlidir .

Bunu, bu formun kaba ifadelerini ve birkaç diğerini buldum.

Python 2,64 bayt

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

Çevrimiçi deneyin!

R , 73 bayt

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

Çevrimiçi deneyin!

• Ben kullanmak zorunda as.doubleyerine strtoiikinci boşluk / noktalarını nasıl olmadığından ve yerine başka bir geçerli karakterin düşünemedimd
• -1 bayt kullanılarak rankyerine ordersadece iki eleman olduğunda eşit olduğu için,

Jöle , 13 bayt

Bu benim diğer Jelly cevabımdan oldukça farklı , bu yüzden ayrı olarak gönderiyorum.

Girdiyi iki (veya daha fazla) dizenin listesi olarak alır.

“kNdHp0”yVµÞṪ

Çevrimiçi deneyin!

Yorumlananlar

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

En etkili yol bu değil (kontrast @ sundar'ın Julia 0.6 cevabı ) ama güzel çünkü tamamen sayısal. Ayrıca gönderme kullanır (ne yazık ki yalnızca bir kez)

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

Çok benzer kod 0.6 çalışır çevrimiçi Deneyin

Nasıl:

İşin püf noktası, !(z)işlevin içinde.

UTF-8 değerini eşler:

• için knegatif bir sayıya, bu yüzden geriye sıralar
• için dpozitif bir sayıya
• için pdaha büyük bir pozitif sayıya

Gosterildigi gibi:

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

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

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

Test sonuçları

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 bayt

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

Çevrimiçi deneyin!

İfade gcd(fromEnum c)28-3 , karakteri çarpanla eşleştirir

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

Fikir, karakter değerlerini almak [107,100,112]ve seçmekti.28 ortaklaşa gittikçe artan büyük etkenlere sahip olmayı , kolaylaştı ancak birincisi, asıl olanıydı. Bu yöntem, açıkça bir eşleme yazmak için 2 bayttan tasarruf sağlar .

Dahili readssayı ve rütbe ayırmak için kullanılır.

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

(Aslında, Sara J'den doğrudan ayrılma 63 bayt vererek bir bayt daha kısadır .)

Daha büyük adım olan adım, çözümümde can sıkıcı sayıda bayt atıyor. Düşüş sırasına göre rütbeleri yinelemek ve birincisini oluşturan ilk yaklaşımı denemek gibi diğer yaklaşımları denedim [a,b], ancak daha uzun sürdü .

MATL , 28 27 bayt

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

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

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

Jöle , 16 bayt

İki dizenin bir listesi olarak girdi alır.

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

Çevrimiçi deneyin! (tüm test durumları)

Nasıl?

$c$$m$

Hangi verir:

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

Yorumlananlar

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

Alternatif formül

16 byte için şunları da kullanabiliriz:

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

Çevrimiçi deneyin!

JavaScript (ES6), 55 54 bayt

@Shaggy sayesinde -1 bayt

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

Çevrimiçi Deneyin!

açıklama

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 bayt

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

Xnor'ın cevabının basit limanı.

Çevrimiçi deneyin!

EDIT: -6 bayt bir Proc kullanmış olabilir fark ederek

C # (Visual C # Derleyici) , 136 135 bayt

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

Çevrimiçi deneyin!

TheLethalCoder sayesinde -1 Bayt

bunların açıklaması:

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 bayt

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

Olarak çalıştır perl -pae '...'. Tek satırda boşlukla ayrılmış, stdin'den girdi alır.

Karşılaştırmayı "kolaylaştırmak" için birkaç değişiklik yapar. Regexp sübstitüsyonları esasen ptakip eden bir sıfır ile ve könde gelen bir negatif işaret ile değiştirilmeyi gerektirir. Böylece 10kolur -10(böylece sıralama tersine çevrilir) ve 3polur 30(böylece pher şeyin üstünde olur ). O zaman sadece basit bir sayısal karşılaştırma.

İçin DomHastings sayesinde $`/ $'8 bayt kazıttı öneri.

R , 65 62 bayt

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

Çevrimiçi deneyin!

Bu, önceki R cevaplarından biraz daha kısa gelir ve R'nin istatistik işlevselliğini iyi kullanır :-)

Robin Ryder'ın yerine kullanmak için önerisi sayesinde -3 baytordered factor

Stdin'den girdi alır (TIO bağlantısı test kolaylığı için biraz yeniden yapılandırılsa da). Giriş bir içine alıyor Kastlari sipariş factor sonra maksimum alır her rütbedeki.

Çıktı şöyle görünür:

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

Java 8, 128 122 121 bayt

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 bayt sayesinde -SaraJ .

Çevrimiçi deneyin. (Eşlenen değerleri görmek için TIO bağlantılarındaki çıktının altına bakın.)

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

-5 bytes@Laikoni
-2 bytessayesinde @ ASCII-only sayesinde

Python 2,61 bayt

Arnauld'un algoritmasını kullanır.

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

Çevrimiçi deneyin!

Önceki cevap, 73 bayt

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

Çevrimiçi deneyin!

Julia 0.6 , 75 71 65 bayt

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

Çevrimiçi deneyin!

(-4 bayt, 0.6 otomatik ayrıştırma Int olarak algılar)

(-6 bayt (search("_dp",s[2])-1)^3), yerine Arnauld'un JS cevabını kullan ((c=cmp(s[end],'k'))^2*6+4c-1))

Retina 0.8.2 , 29 bayt

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

Çevrimiçi deneyin! Herhangi bir sayıdaki sırayı kabul eder ve en yüksek çıktıları verir. Açıklama:

O`

Satırları sırala ...

$

... belirtilen anahtarı kullanarak ...

^

... ters sırada.

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

Anahtar, girdi satırından aşağıdaki gibi yaratılır: a) (profesyonel) dan rütbe mektubu b) unary'deki rütbe c) kyū harfi (uygunsa). Bu ters tür profesyonel dan sıralaması olduğundan pdan rütbe önce sıralar dve ile başlar kyu rütbe 1kyu mektup sonunda bırakılır çünkü. kSıralar içerisinde (profesyonel) danlar, sıradışı dizenin uzunluğu nedeniyle azalan sıralamada sıralanırlar, ancak kyū sıraları için izler artan sırayla sıralamalarına neden olur.

1G`

Şimdi en büyük rütbe olan ilk satırı seç.

J, 39 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Go rank tarafından en fazla döndüren dizgelerin yinelenebilirliğini kabul eden adsız bir işlev. Jelly cevabına çok benziyor (baytları kurtarmak için sadece taban 26'da bir tamsayı olarak değerlendirilen tüm dizeyi kullanır).

Çevrimiçi deneyin!

C (gcc) , 95 bayt

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

Çevrimiçi deneyin!

Perl 6 , 35 bayt

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

Çevrimiçi deneyin!

Tüm bu arama ve küp işlerine oldukça farklı bir yaklaşım. Esasen string değiştirme: ...k -> -..., p -> 0, dsilindi. Böylece yeniler eksi bir puan alır, dans rütbesini alır ve artılar * 10 alır. WhateverStar'ı kullanmak bizi kapatır ve maxkarşılaştırıcı işlevi alır.

05AB1E , 12 bayt

Σ'pK°.Vyþ*}θ

.V(05AB1E kodu olarak değerlendir), @Arnauld'un Jelly cevabındaki benzer yaklaşımından ilham aldı .

Geçerli dizelerin ikisinin (veya daha fazlasının) listesi olarak girin.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

• kbir liste ve bir öğe açar ve listedeki öğenin indeksini iter. Yığın bir liste içermediğinden, "30k"ile "1k"her zaman sonuçlanır -1. Onların sayıları ile çarpılır, aralık$[-30,-1]$.
• dsayının negatif olmadığını kontrol eder ( >= 0). Bu herkes için truthy olduğundan, "1d"aracılığıyla "7d"her zaman sonuçlanır 1. Onların sayıları ile çarpılır, aralık$[1,7]$.
• Çıkarma pve kullanma °gücü 10 kullanacaktır$a$ Eğer $a$ geçerli bir numara $a$aynı kalmak. Öyleyse$a$olduğu "2k"ya "2d"da kalacak, "2k"ya da "2d"kullandıktan sonra °, ancak "2"(biz kaldırdık beri p) ile °olacaktır 100. Onların sayısının çarpımına, "1p"içinden "9p"liste olacak$[10, 200, 3000, 40000, 500000, 6000000, 70000000, 800000000, 9000000000]$.

Buradaki tüm haritalanmış değerleri görün.

Scala , 307 61 54 bayt

Kevin Crujissen ve ASCII'ye sadece bu cevaptaki çalışmaları için teşekkür ederim , bu onu düşürdü ~ 250b.

61b cevabını sipariş fonksiyonu için bazı algoritma optimizasyonu.

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

Burada test senaryoları: Çevrimiçi deneyin!

Eski 61 baytlık cevap

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

İşin püf noktası rank letterve i(char kodu 105) arasındaki mesafeyi hesaplamaktır . Daha sonra bu mesafeyi bir puan olarak kullanırız ( dan = 5, kyu = 2, pro = 7). Ardından, puanlama işlevini kullanarak giriş sırasındaki maksimum değeri alırız.

Online olarak da deneyin!

PHP , 100 98 bayt

(İşlev bildirimini değiştirerek -2 bayt)

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

Çalıştırmak için:

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

Örnek:

php -n go_rank.php 1p 7d

Veya çevrimiçi deneyin!

PHP (7.4), 74 bayt

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

Çevrimiçi deneyin!

Nasıl?

Arnauld'un yaklaşımına benzer , ancak PHP'de. Her rütbeyi sayısal bir değere dönüştürmek ve karşılaştırmak ve daha yüksek bir değer elde etmek için bir işlev kullanıyorum.

Sıra değeri, giriş dizesinin ikinci karakter konumundan gelir !!dp, bir ile azaltılır ve daha sonra 3'e kadar düşürülür ve giriş dizesinin tamsayı kısmı ile çarpılır.

Yani, örneğin, ikinci karakterin konumudur arasında 1phangi piçinde !!dpbirer azalır ve motorlu 3'e hepsi 8. Yani tamsayı parçası olacak, is 3 *pBunun anlamı 8. ile çarpılacak sıralarında 1p = 8, 2p = 16, ...,9p = 72 .

Tüm *daşamalar için, tamsayı kısmı 1 ile çarpılacaktır (veya sadece çarpma yok). Bu demektir 1d = 1..., 7d = 7.

Ve için *kve **ksıralarında, ikinci karakter pozisyonu !!dpeşit olacaktır false3 ile bir kişi tarafından azaltılır ve güç, 0 (açık) eşit olan, tam sayı kısmı -1 ile çarpılır olacağı anlamına gelir. Bu demektir 30k = -30..., 1k = -1.

Bu benim ilk golf denemem, ne kadar kötü olduğundan emin değil!

Excel VBA, 129 bayt

Menzil içinde giriş alan A1:A2ve konsola çıkan bir anonim VBE Acil pencere işlevi .

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

Açıklama

[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