전통적인 보드 게임의 플레이어는 순위 시스템 에서 자신의 기술을 측정합니다 .

• 게임을 처음 시작한 플레이어는 30 번째 큐 (쓰기 30k) 및 진행률 이 1 번째 큐 (쓰기 ) 로 카운트 다운 됩니다 . 이들은 학생 순위 로 간주됩니다 .1k
• 플레이어는 1 일부터 촉진 할 수있다 규 1에 단의 순위 (작성 1d) 한 다음 진행 카운트 업 7에 단의 (기록 순위 7d). 이들은 마스터 순위입니다.
• 과거에 유능한 선수들은 7d1 차 프로 댄 랭크로 승격 될 수 있으며 1p, 9 위의 프로 댄 댄 랭크 까지 기록 됩니다 (필기 ). 이것은 최고 순위입니다.9p

한마디로 : 순위가 주문 30k < 29k < ··· < 1k < 1d < 2d < ··· < 7d < 1p < 2p < ··· < 9p됩니다.

태스크

두 문자열 중 주어진 { 30k..., 1k, 1d, ... 7d, 1p, ... 9p}를 입력으로, 출력 높은 두개의 랭크. (동일하면 두 입력 중 하나만 출력하십시오.)

(일반적으로 I / O는 유연 합니다. 귀하의 답변은 기능이나 전체 프로그램 일 수 있으며, 합리적인 방식으로 입력을 읽고 합리적인 방식으로 출력을 생성합니다.)

이것은 코드 골프입니다 . 목표는 코드의 바이트 수를 최소화하는 것입니다.

테스트 사례

(형식 : 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

자바 스크립트 (ES7), 58 바이트

카레 구문에서 두 문자열을 사용합니다 (a)(b).

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

온라인으로 사용해보십시오!

어떻게?

헬퍼 함수 g () 는 입력 문자열 s 를 점수로 변환합니다 .

1) 문자열 "_dp" 에서 s [1] 을 찾습니다 . 이것은 다음을 제공합니다.

• 댄 랭크 "xd"에 대해 1
• 2 A에 대한 전문 단의 순위 "XP"
• -1 A의 규의 순위 "XK" 혹은 "xxk" 때문에 S [1] 인 하나 "K" 또는 숫자

2) 우리는이 결과를 입방체로 만들어 1 과 -1을 변경하지 않고 전문적인 댄 등급에 8 을 줍니다 .

3) 순위의 소수를 곱합니다.

젤리 , 14 바이트

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

발견 된 최고 순위를 산출하는 문자열 * (설명한대로)를 허용하는 모나드 링크.

^{* 2 이외의 숫자와도 작동합니다.}

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

키 함수를 기준으로 정렬하여 가장 오른쪽 (즉, 최대)을 반환합니다.

문자 , 및 는 각각 서수 , 및 갖습니다 . 바이너리 에는 8 비트 세트가 있고 다른 비트에는 8 비트 세트가 없으므로 비트 OR은 각각 107, 108 및 120을 얻습니다. 이제는 식별하는 클래스를 정렬하는 데 필요한 순서입니다.D (P) 107 100 112 $k$$d$$p$$107$$100$$112$$107$

아마추어 순위는 우리가 문자열이 끝나는 경우 부정, 문자열에 주어진 번호로 우리의 클래스 식별자를 연결할 수있는 우리의 핵심 기능을 수행 할 수 있도록 내림차순에있는 (예 -> 동안 -> ). - 코드에서 이러한 클래스 식별자를 저장하고, 승산 제곱 승 뺀 요구 - 인 바이트.$k$'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ$16$

이를 개선하기 위해 우리는 마이너스 2를 대신 사용하고 단일 곱셈으로 달성 할 수있는 요소를 곱할 수 있습니다.

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)

키 기능 동작 표 ...

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

젤리 ,  11  10 바이트

^{Arnauld가 드로잉 보드로 돌아 가기 위해 영감을 받았습니다!}

⁾kNyv9FµÞṪ

발견 된 최고 순위를 산출하는 문자열 * (설명한대로)를 허용하는 모나드 링크.

• 2 이외의 숫자와도 작동합니다.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

키 함수를 기준으로 정렬하여 가장 오른쪽 (즉, 최대)을 반환합니다.

키 함수는 먼저 dyadic atom을 사용하여 임의의 k 를 N 이되도록 변경 y하고 두 문자 목록 ⁾kN( ['k','N'])을 사용하여 변환 한 다음 문자열을 인수가 9 인 모나드로 평가합니다 (code 사용 v9).

젤리에서 :

• N 입력을 무효화하는 모나 딕 원자

  • 따라서 코드 9 30N는 실제로 9를 사용하지 않고 정수가됩니다.-30

• d 정수 이진수와 모듈로 결과의 쌍인 두 값의 파이썬 divmod의 결과를 산출하는 2 차원 원자

  • 그래서 코드 9 7d결과 페어링 인$\lfloor \frac 7 9 \rfloor$$7 \pmod 9$[0,7]

• p 입력의 암시 적 1- 인덱스 범위 화를 포함하는 데카르트 곱을 수행하는 2 차원 원자입니다.

  • 그래서 코드 9 p3의 직교 생성물을 수득 [1,2,3]하고 [1,2,3,4,5,6,7,8,9]이는 인[[1,1],[1,2],...,[1,9],[2,1],[2,2],...,[2,9],[3,1],[3,2],...,[3,9]]

문자열을 사용하여 이러한 평가를 수행 한 후에는 결과를 비교할 수 있어야합니다. int는리스트와 비교할 수 없기 때문에 부정 된 값을리스트에 랩핑해야하지만 p리스트가 전개 된 후에도 순서가 계속 작동하므로 (예 : [[1,1],[1,2],...]-> [1,1,1,2]) F모든 평가에 적용된 1 바이트 모 나마 원자를 사용할 수 있습니다 .

키-값에 대한 입력 테이블은 다음과 같습니다.

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]

코드 주석 :

⁾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 바이트

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

온라인으로 사용해보십시오!

(-2 루이스 Mendo 덕분 바이트)
(다른 바이트 -3 교체 v&X>로를 >루이스 Mendo의 대답에 기초하여,이 시간)
(사용 -2 바이트 &)구문)

설명:

• 마지막 문자에서 'k'를 뺍니다 ( 'd', 'k', 'p'에 대해 각각 n = -7, 0, 5를 부여).

• v = n ^ 2 + 6n-1을 계산합니다 (각각 7, -1, 54).

• 그 값 v에 실제 순위 수를 곱하십시오 (k 레벨은 음의 곱을 얻음, d 레벨은 7에서 49로, p 레벨은 54 이상으로).

• 두 입력 문자열에 대해 제품을 비교하십시오.

• 더 큰 제품에 해당하는 입력 문자열을 가져옵니다.

대체적이고 더 간단한 방법 :

23 바이트

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

온라인으로 사용해보십시오!

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

하스켈 , 73 71 바이트

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

온라인으로 사용해보십시오!

나에게 평소와 같이, 특히 골프와 같은 것보다는 단순한 구현입니다. "(#)"함수는 두 순위를 문자열로 사용하여 더 큰 순위를 반환합니다. 질문에 지정된 형식으로 만 작동합니다.

(나는 또한 사용하여 버전 해봤 comparing및 maximumBy하지만 3 바이트 이상 었죠 - 빌어 먹을 base!하고 때때로 사람이 읽을 수있는 기능 이름)

(Amphibological 및 Lynn의 적용 제안)

파이썬 2 , 54 바이트

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

온라인으로 사용해보십시오!

사용 Arnauld의 방법을 . 매핑 int(x,27)%9-3은 마지막 문자에만 의존합니다. 마지막 x숫자를 제외한 모든 숫자는의 배수를 나타 내기 때문입니다 9. 소요됩니다 :

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

이것은 밑수 26에서 해석 될 때 승수 1p를 이길 수 있는 충분한 마진입니다 7d.

나는이 형태와 다른 몇 가지의 무차별 강제 표현으로 이것을 발견했습니다.

파이썬 2 , 64 바이트

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

온라인으로 사용해보십시오!

R , 73 바이트

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

온라인으로 사용해보십시오!

• 후자는 공백 / 포인트를 처리하지 않으므로 as.double대신 사용할 strtoi다른 유효한 문자를 생각할 수 없으므로 대신 사용해야 했습니다.d
• 두 개의 요소 만있는 경우 동일하므로 rank대신 -1 바이트 사용order

젤리 , 13 바이트

이것은 다른 Jelly 답변 과 는 매우 다르 므로 별도로 게시하고 있습니다.

입력을 두 개 이상의 문자열 목록으로 취합니다.

“kNdHp0”yVµÞṪ

온라인으로 사용해보십시오!

댓글

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

줄리아 0.7 (100) 93 바이트

가장 효율적인 방법은 아니지만 (@sundar의 Julia 0.6 답변 과 대조적 이지만) 순수한 숫자이기 때문에 좋습니다. 파견도 사용합니다 (슬프게도 한 번만)

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

매우 유사한 코드 0.6에서 작동 온라인 체험

어떻게:

트릭은 모두 !(z)기능에 있습니다.

UTF-8 값을 맵핑합니다.

• 대한 k음수로, 그래서 거꾸로 정렬
• 대한 d양수로
• 에 대한 p더 큰 양수로

보여진 바와 같이:

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

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

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

시험 결과

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)

하스켈 , 64 바이트

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

온라인으로 사용해보십시오!

표현식 gcd(fromEnum c)28-3은 문자를 승수에 매핑합니다

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

아이디어는 그들의 캐릭터 가치를 취하고 그들 [107,100,112]과 28공통되는 점점 더 큰 요소를 갖도록 선택 하는 것이 었습니다. 이 메소드는 명시 적으로 맵핑을 작성하는 것 보다 2 바이트를 절약 합니다 .

내장 reads은 숫자와 순위를 구분하는 데 사용됩니다.

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

( 사라 J 의 직접 분할 은 1 바이트 더 짧아서 63 바이트를 제공 합니다 .)

테이크 더 1 단계는 내 솔루션에서 성가신 바이트 수를 차지합니다. 나는 순위를 내림차순으로 반복하고의 첫 번째 요소를 취하는 것과 같은 다른 접근법을 시도했지만 [a,b]더 길어졌습니다.

MATL , 28 27 바이트

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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

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

젤리 , 16 바이트

두 문자열의 목록으로 입력을받습니다.

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

온라인으로 사용해보십시오! (모든 테스트 사례)

어떻게?

순위 문자 의 ASCII 코드 는 다음 공식 을 사용하여 승수 으로 변환됩니다 .$c$$m$

다음을 제공합니다.

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

댓글

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

대체 공식

16 바이트에도 다음을 사용할 수 있습니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 55 54 바이트

@Shaggy 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

설명

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

루비 , 52 46 바이트

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

xnor의 대답의 간단한 포트.

온라인으로 사용해보십시오!

편집 : 내가 Proc를 사용할 수 있음을 인식하여 -6 바이트

C # (Visual C # 컴파일러) , 136135 바이트

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

온라인으로 사용해보십시오!

TheLethalCoder 덕분에 -1 바이트

확장 :

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

펄, 46 38 바이트

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

로 실행하십시오 perl -pae '...'. 한 줄에 공백으로 구분 된 stdin에서 입력을받습니다.

비교를 "쉽게"하기 위해 몇 가지 대체를 수행합니다. 정규식 대체는 본질적 p으로 후행 0과 k선행 음수 부호 로 대체 됩니다 . 그래서 10k이된다 -10(그래서 순서가 반전)과 3p이된다 30(그래서 p다른 모든 이상). 그런 다음 간단한 숫자 비교입니다.

8 바이트 를 줄인 $`/ $'제안에 대한 DomHastings 덕분에 .

R , 65 62 바이트

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

온라인으로 사용해보십시오!

이것은 이전 R 답변보다 약간 짧으며 R의 통계 기능을 잘 활용합니다 :-)

Robin Ryder 의 제안 대신 -3 바이트 사용ordered factor

stdin에서 입력을받습니다 (TIO 링크는 약간의 테스트를 위해 약간 재구성되지만). 입력 순위를 모든 순위 의 순서대로 캐스트 factor한 다음 최대 값을 가져옵니다.

출력은 다음과 같습니다.

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

자바 (8) 128 122 121 바이트

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(".$",""));}

@SaraJ 덕분에 -6 바이트 .

온라인으로 사용해보십시오. 매핑 된 값을 보려면 TIO 링크의 출력 하단을 참조하십시오.

설명:

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

하스켈 , 75 70 68 바이트

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

온라인으로 사용해보십시오!

-5 bytes@ASCII 전용 덕분에 @Laikoni
-2 bytes덕분에

파이썬 2 , 61 바이트

Arnauld의 알고리즘을 사용합니다.

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

온라인으로 사용해보십시오!

이전 답변, 73 바이트

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

온라인으로 사용해보십시오!

줄리아 0.6 , 75 71 65 바이트

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

온라인으로 사용해보십시오!

(-4 바이트, 0.6에서 구문 분석하면 Int로 감지 함)

(-6 바이트 (search("_dp",s[2])-1)^3), 대신 Arnauld의 JS 답변을 기반으로 사용 ((c=cmp(s[end],'k'))^2*6+4c-1))

레티 나 0.8.2 , 29 바이트

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

온라인으로 사용해보십시오! 임의의 수의 순위를 허용하고 가장 높은 순위를 출력합니다. 설명:

O`

줄을 정렬 ...

$

... 지정된 키를 사용하여 ...

^

... 역순으로.

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

키는 다음과 같이 입력 행에서 작성됩니다. a) (전문적인) 단 순위 문자 b) 단항의 순위 c) 큐 문자 (적용 가능한 경우). 이것이 역순이기 때문에, 전문 단 순위 p는 단 순위 d와 우선 순위로 시작 1합니다. 큐 문자는 끝 부분에 남아 있기 때문입니다. 랭크 내에서 (전문적인) 댄 랭크는 단항 스트링의 길이로 인해 내림차순으로 정렬되지만 k, 큐 랭크 의 후행 은 오름차순으로 정렬됩니다.

1G`

가장 높은 순위 인 첫 번째 줄을 선택하십시오.

J, 39 바이트

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

온라인으로 사용해보십시오!

설명

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

파이썬 , 59 바이트

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

이름이 지정되지 않은 함수는 반복 가능한 문자열을 허용하며 Go 순위에 따라 최대 1을 반환합니다. 내 Jelly 답변 과 매우 유사합니다 (기본 26의 정수로 평가 된 전체 문자열을 사용하여 바이트를 저장합니다).

온라인으로 사용해보십시오!

C (gcc) , 95 바이트

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

온라인으로 사용해보십시오!

펄 6 , 35 바이트

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

온라인으로 사용해보십시오!

이 모든 검색 및 큐브 항목에 대해 다소 다른 접근 방식입니다. 기본적으로 문자열 교체 : ...k -> -..., p -> 0, d삭제. 따라서 초보자는 마이너스 점수를 얻으며 dans는 순위를 얻고 프로는 순위를 얻습니다. WhateverStar를 사용하면 클로저 max가되고 비교기 기능이 사용됩니다.

05AB1E , 12 바이트

Σ'pK°.Vyþ*}θ

.V(05AB1E 코드로 평가)는 @Arnauld 의 젤리 답변과 유사한 접근 방식에서 영감을 얻었습니다 .

유효한 문자열 중 두 개 이상의 목록으로 입력하십시오.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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

여기에서 모든 매핑 된 값을보십시오.

스칼라 , 307 61 54 바이트

이 답변에 대한 작업에 대한 Kevin Crujissen 과 ASCII 전용 덕분에 ~ 250b가 줄었습니다.

61b 답변의 주문 기능에 대한 일부 알고리즘 최적화.

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

테스트 사례 : 온라인으로 사용해보십시오!

이전 61 바이트 답변

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

트릭 사이의 거리를 계산하는 것이다 rank letter과 i(문자 코드 105). 그런 다음이 거리를 순위 번호에 곱한 점수 ( dan = 5, kyu = 2, pro = 7)로 사용합니다. 그런 다음 스코어링 기능을 사용하여 입력 배열에서 최대 값을 가져옵니다.

온라인으로 시도하십시오!

PHP , 100 98 바이트

(함수 선언을 변경하여 2 바이트)

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

그것을 실행하려면 :

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

예:

php -n go_rank.php 1p 7d

또는 온라인으로 사용해보십시오!

PHP (7.4), 74 바이트

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

온라인으로 사용해보십시오!

어떻게?

유사 Arnauld의 접근 하지만, PHP한다. 각 순위를 숫자 값으로 변환하고 더 높은 값을 가진 순위를 비교하고 출력하는 함수를 사용하고 있습니다.

순위 값은의 입력 문자열의 두 번째 문자 위치에서오고 !!dp1 씩 감소한 다음 3으로 구동되고 입력 문자열의 정수 부분을 곱합니다.

그래서 예를 들어, 두 번째 문자의 위치로 1p되는 것이다 p에서 !!dp1 씩 감소하고 모든 항 그래서 정수 부분이 될 것이고 3 전동 3 *p계급이 수단 (8)에 의해 승산한다 1p = 8, 2p = 16, ... 9p = 72.

모든 *d순위에 대해 정수 부분에 1을 곱합니다 (또는 단순히 곱하지 않음). 이것은 1d = 1...,을 의미 7d = 7합니다.

그리고 모두 *k와 **k순위에서 제 캐릭터의 위치 !!dp와 동일 할 것 false(3)에 의해 1 씩 감소하고 구동 0 (명시적인)과 동등한 정수부 -1을 곱한 것을 의미한다. 이것은 30k = -30...,을 의미 1k = -1합니다.

이것은 나의 첫 번째 골프 시도이며, 그것이 얼마나 나쁜지 확실하지 않습니다!

Excel VBA, 129 바이트

범위 내 A1:A2에서 입력을 받아 콘솔로 출력 하는 익명의 VBE 즉시 창 기능 .

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

설명

[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