कौन सा गो रैंक अधिक है?

53

पारंपरिक बोर्ड गेम के खिलाड़ी रैंक की एक प्रणाली में अपने कौशल को मापते हैं :

  • खेल के लिए नए खिलाड़ियों को 30 वें ky to (लिखित 30k) और 1 ky 1st (लिखित ) के लिए नीचे गिनती प्रगति में रखा गया है । इन्हें छात्र रैंक माना जाता है ।1k
  • एक खिलाड़ी पहली कियॉ से 1 डैन रैंक (लिखित 1d) तक का प्रचार कर सकता है , और फिर 7 वें डैन रैंक (लिखित ) तक गिनती की प्रगति कर सकता है । ये मास्टर रैंक हैं।7d
  • असाधारण रूप से कुशल खिलाड़ी पिछले पेशेवर डैन रैंक7d को बढ़ावा दे सकते हैं , और 9 वें पेशेवर डैन रैंक (लिखित ) तक गिनती की प्रगति कर सकते हैं । यह सर्वोच्च रैंक है। 1p9p

संक्षेप में: रैंक का आदेश दिया जाता है 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
code-golf  string  go 
— लिन
स्रोत
क्या इनपुट के लिए अग्रणी शून्य की आवश्यकता हो सकती है? Ie 04k
— उभयलिंगी
6
नहीं; जब मैं I / O विधियों के बारे में लचीला हूं , तो मुझे डर है कि मैं खुद इनपुट स्ट्रिंग्स में किसी भी भिन्नता की अनुमति नहीं दूंगा - मुझे लगता है कि वे "दिलचस्प" के रूप में एक आदर्श स्तर हैं। (मैं या तो अनुमति नहीं दूंगा 4 kया 4Kतो।)
— लिन
2
क्या हमें (int, string) जोड़े के रूप में इनपुट लेने की अनुमति है?
— Mnemonic
9
नहीं; फिर से, चुनौती की भावना है सटीक पाठ स्ट्रिंग्स में हेरफेर करने 30k, 29k, 1k, 1dवगैरह, तो मैं किसी भी अधिक अंतर अनुमति नहीं दी जाएगी।
— लिन

जवाबों:

36

जावास्क्रिप्ट (ईएस 7), 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 के लिए एक पेशेवर दान रैंक "xp"
  • -1 एक के लिए क्यु रैंक "xk" या "xxk" क्योंकि रों [1] है या तो "K" या अंक के

2) हम इस परिणाम को क्यूब करते हैं, जो 1 और -1 को अपरिवर्तित छोड़ देता है लेकिन एक पेशेवर डैन रैंक के लिए 8 देता है ।

3) हम रैंक के दशमलव भाग से गुणा करते हैं।

— Arnauld
स्रोत
चतुर के रूप में नहीं, लेकिन -3:a=>b=>(g=s=>parseInt(s)*~{d:~1,p:~8}[s[1]])(a)>g(b)?a:b
— फायरफली
2
@FireFly धन्यवाद लेकिन एक समान जवाब पहले से ही प्रस्तुत किया गया था और मैं इसे एक अपरिवर्तित रहने देना चाहूंगा।
— अरनुलद
12

जेली , 14 बाइट्स

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

एक मोनाडिक लिंक स्ट्रिंग्स की एक सूची को स्वीकार करता है * (जैसा कि वर्णित है) जो उच्चतम रैंक पाया जाता है।

* दो के अलावा अन्य संख्याओं के साथ भी काम करता है।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें ।

कैसे?

कुंजी फ़ंक्शन द्वारा सॉर्ट करता है और सबसे दाएं (यानी अधिकतम) रिटर्न करता है।

पत्र , , और ऑर्डिनल्स है , , और क्रमशः। बाइनरी में आठ बिट सेट होते हैं जबकि अन्य नहीं होते हैं, इसलिए 8 के साथ बिटवाइज़ OR-ing हम क्रमशः 107, 108, और 120 प्राप्त करते हैं - ये अब उन वर्गों को क्रमबद्ध करने के लिए आवश्यक हैं जिन्हें वे पहचानते हैं।kp 107 100 112 107dp107100112107

शौकिया रैंक अवरोही क्रम में हैं ताकि हमारे प्रमुख कार्य को पूरा करने के लिए हम अपनी कक्षा-पहचानकर्ता को स्ट्रिंग में दिए गए संख्या के साथ संक्षिप्त कर सकें, अगर स्ट्रिंग में समाप्त होती है (जैसे -> जबकि -> )। कोड में इसके लिए गुणक के लिए वर्ग-पहचानकर्ता और घातांक एक को जमा करने की आवश्यकता होती है - - जो बाइट्स है।16k'7k'[107,-7]7p[120,7]OṪ|©8-*×ṖV$®,µÞṪ16

इस पर सुधार करने के लिए हम इसके बजाय माइनस दो का उपयोग कर सकते हैं और तत्वों को एक साथ गुणा कर सकते हैं, जो एकल गुणन के साथ प्राप्त किया जा सकता है।

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
— जोनाथन एलन
स्रोत
बहुत अच्छी विधि!
— अरनुलद
मुझे समझ में नहीं आता कि 14 यूनिकोड चार्ट 14 बाइट्स में कैसे अनुवाद करते हैं। 2^8=256, जो ASCII, afaik है। क्या आपको यूनिकोड वर्ण धारण करने के लिए एक से अधिक बाइट की आवश्यकता नहीं है?
— पोस्ट सेल्फ
@PostSelf बाईटेकोड 14 बाइट्स है, यूनिकोड वर्ण केवल सिंगल बाइट्स का प्रतिनिधित्व करते हैं - हेडर में "बाइट्स" के लिंक में कोडपेज देखें।
— जोनाथन एलन
1
@JonathanAllan आह, मैं देख रहा हूँ, धन्यवाद!
— सेल्फ
12

जेली ,  11  10 बाइट्स

अरनौलद द्वारा ड्राइंग बोर्ड पर वापस जाने के लिए प्रेरित किया गया!

⁾kNyv9FµÞṪ

एक मोनाडिक लिंक स्ट्रिंग्स की एक सूची को स्वीकार करता है * (जैसा कि वर्णित है) जो उच्चतम रैंक पाया जाता है।

  • इसके अलावा दो के अलावा अन्य संख्याओं के साथ काम करता है।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें ।

कैसे?

कुंजी फ़ंक्शन द्वारा सॉर्ट करता है और सबसे दाएं (यानी अधिकतम) रिटर्न करता है।

प्रमुख फ़ंक्शन पहले किसी भी k को बदलकर डाइएडमिक परमाणु , ट्रांसलेट, टू-कैरेक्टर लिस्ट (जेली कोड फॉर ) का उपयोग करके एन हो जाता है और फिर स्ट्रिंग को नौ के तर्क के साथ एक मोनाड के रूप में मूल्यांकन करता है (कोड का उपयोग करके )।y⁾kN['k','N']v9

जेली में:

  • N एक राक्षसी परमाणु है जो इसके इनपुट को नकारता है

    • इसलिए कोड 9 30Nवास्तव में नौ का उपयोग नहीं करता है और पूर्णांक में परिणाम देता है-30

  • d एक डायडिक परमाणु है जो दो मानों के पायथन डिमॉड के परिणाम देता है - पूर्णांक विभाजन और मोडुलो के परिणामों की जोड़ी

    • तो कोड 9 7dपरिणाम में साथ जोड़ा जाता है जो कि है⌊79⌋7(mod9)[0,7]

  • p एक डाईएडिक परमाणु है जो कार्टेशियन उत्पाद करता है, जिसमें इसके इनपुट के निहित 1-अनुक्रमित रेंज-इफिकेशन शामिल हैं

    • इसलिए कोड 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]]

एक बार जब हम परिणामों की तुलना करने में सक्षम होने की आवश्यकता के लिए स्ट्रिंग्स का उपयोग करके इस तरह के मूल्यांकन किए गए हैं; चूँकि ints सूचियों के साथ तुलनीय नहीं हैं, इसलिए हमें एक सूची में नकारात्‍मक मानों को लपेटने की आवश्‍यकता होती है, लेकिन चूंकि pसूची चपटी होने के बाद भी ऑर्डर देना काम करेगा (उदाहरण [[1,1],[1,2],...]-> [1,1,1,2]) हम Fसभी मूल्‍यांकन के लिए लागू एकल-बाइट monadic परमाणु का उपयोग कर सकते हैं ।

उनके कुंजी-मूल्य के इनपुट की तालिका निम्नानुसार है:

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)
— जोनाथन एलन
स्रोत
मुझे पता था कि यह होना ही था। :) लेकिन मैं वैसे भी संतुष्ट हूँ जब तकरीबन 90 मिनटों तक आप आउट हो गए। : पी
— अरनुलद
मैं अभी भी एक छोटे से एवेन्यू की खोज नहीं कर रहा हूं, जो शुरू में मेरे दिमाग में आया था!
— जोनाथन एलन
यह एक बहुत साफ जवाब है!
— लिन
10

MATL , 30 28 25 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

(-2 लुइस Mendo के लिए धन्यवाद बाइट्स)
(एक और -3 बाइट्स की जगह v&X>के साथ >इस बार लुइस Mendo के उत्तर के आधार पर,)
(-2 का उपयोग कर बाइट्स &)वाक्य रचना)

स्पष्टीकरण:

  • अंतिम वर्ण से 'k' को घटाएं (n = -7, 0, 5 को 'd', 'k', 'p' क्रमशः)।

  • गणना v = n ^ 2 + 6n-1 (क्रमशः 7, -1, 54 देता है)।

  • वास्तविक रैंक संख्या के आधार पर उस मान को गुणा करें (ताकि 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
— सुन्दर
स्रोत
1
तो अब हमारे पास अरनुल्ड का एल्गोरिथ्म और सूंदर बहुपद विधि है। लवली। +1
— डेविड कॉनराड
9

हास्केल , 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और आपके कभी-कभी मानव पठनीय फ़ंक्शन नामों को धिक्कार है !)

(एम्फ़िबोलॉजिकल एंड लिन द्वारा लागू सुझाव)

— घन
स्रोत
आप को बदलने के द्वारा 1 बाइट बचा सकते हैं Trueकरने के लिए 1<2।
— उभयलिंगी
1
(-x)हो सकता है 0-x।
— लिन
आप अंतिम पैटर्न मैच को r(x,_)=x+7भी बदल सकते हैं !
— लिन
आप अंतिम पैटर्न मैच को बदलना भूल गए, यह 69 होना चाहिए ( 0-x`-x` भी हो सकता है)
— ASCII-only
8

पायथन 2 , 54 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अर्नुल्ड की विधि का उपयोग करना । मैपिंग int(x,27)%9-3केवल xसभी अंकों के अंतिम अक्षर पर निर्भर करता है , लेकिन अंतिम में कई का योगदान होता है 9। यह:

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

यह गुणक के लिए मुश्किल से पर्याप्त अंतर 1pहै हरा करने के लिए 7d, उच्चतम डैन रैंक, जब आधार 26 में व्याख्या की गई थी।

मैंने इसे इस रूप और कुछ अन्य लोगों की क्रूरतापूर्ण अभिव्यक्तियों द्वारा पाया।

पायथन 2 , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— XNOR
स्रोत
6

आर , 73 बाइट्स

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

इसे ऑनलाइन आज़माएं!

  • मुझे as.doubleइसके बजाय उपयोग करना था strtoiक्योंकि बाद वाले स्थान / बिंदुओं को नहीं संभालते हैं और मैं प्रतिस्थापित करने के लिए किसी अन्य वैध चरित्र के बारे में नहीं सोच सकताd
  • -1 बाइट का उपयोग rankकरने के बजाय order, क्योंकि वे समान होते हैं जब केवल दो तत्व होते हैं
— digEmAll
स्रोत
मैंने इसके Lस्थान पर उपयोग करने की कोशिश की .लेकिन यह या तो काम नहीं कर रहा है ... आपको बताएंगे कि क्या मुझे कुछ और मिल सकता है।
— JayCe
1K पर बधाई!
— Giuseppe
6

जेली , 13 बाइट्स

यह मेरे अन्य जेली उत्तर से काफी अलग है , इसलिए मैं इसे अलग से पोस्ट कर रहा हूं।

इनपुट को दो (या अधिक) स्ट्रिंग्स की सूची के रूप में लेता है।

“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'
— Arnauld
स्रोत
अरे यार, मैंने इस तरह की विधि के बारे में सोचा था कि मैंने जो रास्ता तय किया उससे पहले ... मुझे वास्तव में इसे आज़माना चाहिए था!
— जोनाथन एलन
... अब मेरे पास 11 है
— जोनाथन एलन
5

जूलिया 0.7 100 93 बाइट्स

यह सबसे कुशल तरीका नहीं है, (इसके विपरीत @ sundar का जूलिया 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)
— लिंडन व्हाइट
स्रोत
यह बहुत साफ है। और मैं नहीं जानता .~[a,b]था कि संभव था! Btw, मुझे लगता है कि आप संग्रह (r) को बदल सकते हैं [r...]और कुछ बाइट्स बचा सकते हैं।
— सूंदर
अच्छा है, और फिर मैं कुछ और बचाने के Int[r...]बजाय बेंत मार सकता हूं Int([r...])। धन्यवाद
— लिंडन व्हाइट
वैसे, कोड काफी काम करता है के रूप में (प्रतिस्थापित करने के बाद है argmaxके साथ indmaxजूलिया 0.6 पर और साथ)। आप इसे ऑनलाइन आज़मा सकते हैं ! यदि आप चाहें तो लिंक करें
— सूंदर
धन्यवाद, मेरे अन्य हालिया जूलिया ०.ed उत्तर को इस से बचने से बहुत अधिक नुकसान उठाना पड़ा।
— लिंडन व्हाइट
हाँ, चीजें जूलिया भूमि में एक अधिक क्रियात्मक दिशा की ओर बढ़ती दिख रही हैं, जिसमें आवश्यक कीवर्ड आर्ग, स्टैडलिब चालें जो कि आयात, आवश्यक व्हाट्सएप, आदि आवश्यक हैं। Btw, क्या आपका मतलब 0.7 उत्तर का प्रयास है कि आपने 0.6 उत्तर पोस्ट करना समाप्त कर दिया है? मैंने आपके उपयोगकर्ता पृष्ठ के चारों ओर एक नज़र डाली, लेकिन कोई भी जूलिया 0.7 उत्तर नहीं मिला।
— सूंदर
5

हास्केल , 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करने के लिए था, जो आसान था लेकिन पहले वाला 107 प्रमुख था। यह विधि एक मैपिंग को स्पष्ट रूप से लिखने पर 2 बाइट्स बचाती है ।

बिल्ट-इन readsका उपयोग नंबर और रैंक को अलग करने के लिए किया जाता है।

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

(वास्तव में, सारा जे से प्रत्यक्ष बंटवारा एक बाइट छोटा है, जो 63 बाइट्स देता है ।)

टेक-ऑफ-द-बिग-स्टेप मेरे समाधान में एक कष्टप्रद संख्या बाइट्स लेता है। मैंने अन्य दृष्टिकोणों की कोशिश की जैसे कि घटते क्रम में रैंकों पर पुनरावृत्ति करना और पहला तत्व जो कि एक तत्व है [a,b], ले रहा है , लेकिन वे लंबे समय तक निकले।

— XNOR
स्रोत
3

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)
— लुइस मेंडो
स्रोत
3

जेली , 16 बाइट्स

इनपुट को दो तारों की सूची के रूप में लेता है।

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

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले)

कैसे?

निम्न वर्ण के साथ रैंक वर्ण का ASCII कोड गुणक बदल जाता है:एमcm

m=(c4mod90)−2

जो देता है:

 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 बाइट्स के लिए, हम उपयोग कर सकते हैं:

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

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत
3

जावास्क्रिप्ट (ईएस 6), 55 54 बाइट्स

-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
— हरमन एल
स्रोत
यह काम 54 के लिए लगता है।
— शैगी
@ अपने समाधान के लिए विफल रहता है f("2d")("1d"), लेकिन इसे ठीक करने के d:1साथ बदल d:2रहा है।
— हरमन एल
1
यह गोल्फ की कोशिश करो, लेकिन अभी भी 54 बाइट्स ... बहुत दुख की बात है
— 8
3

रूबी , 52 46 बाइट्स

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

Xnor के उत्तर का सीधा पोर्ट।

इसे ऑनलाइन आज़माएं!

संपादित करें: -6 बाइट्स का एहसास करके मैं एक प्रोक का इस्तेमाल कर सकता था

— Amphibological
स्रोत
केवल आपके द्वारा किए गए बदलाव पर टिप्पणी करने के बारे में था :) आपको यहां कोड की नकल नहीं करनी है, बस हेडर का उपयोग करें
— कॉनर ओ'ब्रायन
3

सी # (विजुअल सी # कंपाइलर) , 136 135 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-1 बाइट थेल्कोडर की बदौलत

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
स्रोत
1
आप बाइट को करीने से बचा सकते हैं a=>b=>।
— TheLethalCoder
ओह, तुम भी शाब्दिक आकर्षण के बजाय ints का उपयोग करने में सक्षम होना चाहिए। जब से मैं गोल्फ गया हूँ, तब से ये मेरे पास आते रहेंगे ...
— TheLethalCoder
@ TheLethalCoder: की PadLeftआवश्यकता है charऔर 107इसके बजाय का उपयोग कर 'k'कोई फर्क नहीं पड़ता।
— raznagul
ओह, मुझे लगा कि रूपांतरण निहित था ... एक कोशिश के लायक है
— TheLethalCoder
3

पर्ल, 46 38 बाइट्स

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

के रूप में चलाएँ perl -pae '...'। स्टड से इनपुट लेता है, एक लाइन पर स्पेस-अलग होता है।

तुलना "आसान" करने के लिए प्रतिस्थापन के एक जोड़े को निष्पादित करता है। Regexp प्रतिस्थापन अनिवार्य रूप से pएक अनुगामी शून्य के kसाथ और एक प्रमुख नकारात्मक संकेत के साथ प्रतिस्थापित करता है । तो 10kबन जाता है -10(इसलिए क्रम उलट जाता है) और 3pबन जाता है 30(इसलिए कि pसब कुछ ऊपर है)। तब यह केवल एक सरल संख्यात्मक तुलना है।

$`/ $'सुझाव के लिए DOMHastings का धन्यवाद , जिसने 8 बाइट का मुंडन किया ।

— सिल्वियो मायोलो
स्रोत
1
वास्तव में अच्छा समाधान, मैं कुछ भी बहुत सुंदर के साथ नहीं आया था! आप 8 बाइट बचा सकते हैं, पर मेल करके / /और `` $ `` `का उपयोग करके और $': इसे ऑनलाइन आज़माएं!
— डोम हेस्टिंग्स
3

आर , 65 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह पिछले R उत्तरों की तुलना में थोड़ा छोटा है, और R की सांख्यिकी कार्यक्षमता का अच्छा उपयोग करता है :-)

के बजाय उपयोग करने के लिए रॉबिन राइडर के सुझाव के लिए -3 बाइट्स धन्यवादordered factor

स्टडिन से इनपुट लेता है (हालांकि परीक्षण की आसानी के लिए टीआईओ लिंक थोड़ा सा पुनर्गठन करता है)। डाले इनपुट एक में शुमार आदेश दिया factor सभी रैंकों की है, तो अधिकतम लेता है।

आउटपुट जैसा दिखता है:

[1] MAX_RANK
46 Levels: 30k < 29k < 28k < 27k < 26k < 25k < 24k < 23k < 22k < ... < 9p
— ग्यूसेप
स्रोत
1
फैक्टर (..., ओ = टी) के बजाय 62 बाइट्स का आदेश दिया गया है
— रॉबिन राइडर
@RobinRyder धन्यवाद! मैंने डॉक्स पृष्ठ के लिए पढ़ा factorऔर पूरी तरह से याद किया ordered।
— गिउसेप्पे
3

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

-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
— केविन क्रूज़सेन
स्रोत
1
— सारा जे
@ महाराज धन्यवाद! :) मुझे एक छोटा विकल्प खोजने में परेशानी हुई, लेकिन मुझे यकीन था कि कुछ होना चाहिए। बहुत मज़ेदार था मुझे तीन वैकल्पिक 128-बायर्स मिले, लेकिन कोई भी छोटा नहीं था ..
— केविन क्रूज़सेन
3

हास्केल , 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
-2 bytes@ ASCII- को ही @Laikoni को धन्यवाद

— सारा जे
स्रोत
1
(read$init k)हो सकता है read(init k)। एक सहायक फ़ंक्शन उपयोग करने से छोटा है case of: इसे ऑनलाइन आज़माएं!
— लकोनी
@ लायकोनी धन्यवाद!
— सारा जे
1
— ASCII- केवल 10
@ ASCII- केवल नाइस, धन्यवाद!
— सारा जे
1
@SaraJ आपने लिंक अपडेट नहीं किया है: P
— ASCII-only
2

जूलिया 0.6 , 75 71 65 बाइट्स

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

इसे ऑनलाइन आज़माएं!

(-4 बाइट्स, 0.6 ऑटो में पार्स इंट के रूप में इसका पता लगाता है)

(-6 बाइट्स, (search("_dp",s[2])-1)^3)अरनुल्द के जेएस जवाब के आधार पर उपयोग करें , इसके बजाय ((c=cmp(s[end],'k'))^2*6+4c-1))

— सुन्दर
स्रोत
2

रेटिना 0.8.2 , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं! किसी भी रैंक को स्वीकार करता है और सबसे ज्यादा आउटपुट देता है। स्पष्टीकरण:

O`

पंक्तियों को क्रमित करें ...

$

... निर्दिष्ट कुंजी का उपयोग कर ...

^

... उल्टे क्रम में।

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

कुंजी इनपुट लाइन से निम्नानुसार बनाई गई है: ए) (पेशेवर) डैन रैंक पत्र बी) अनारी सी में रैंक) किय पत्र (जहां लागू हो)। चूंकि यह एक रिवर्स सॉर्ट है, इसलिए pडैन रैंक dऔर ky rank रैंक से पहले पेशेवर डैन रैंक सॉर्ट होता है, जो शुरू होता है 1क्योंकि ky sort अक्षर अंत में छोड़ दिया जाता है। रैंकों के भीतर (प्रोफेशनल) डैन रैंकेड्स एकरिंग स्ट्रिंग की लंबाई के कारण अवरोही क्रम में सॉर्ट करता है, हालांकि kkys रैंक्स के लिए अनुगामी उन्हें आरोही क्रम में सॉर्ट करने का कारण बनता है।

1G`

पहली पंक्ति का चयन करें, जो अब सबसे बड़ी रैंक है।

— नील
स्रोत
2

जे, 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
— जोनाह
स्रोत
2

पायथन , 59 बाइट्स

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

एक अनाम फ़ंक्शन स्ट्रिंग्स के चलने योग्य को स्वीकार करता है जो गो रैंक द्वारा एक अधिकतम रिटर्न देता है। मेरे जेली उत्तर की तरह बहुत काम करता है (बस बाइट्स को बचाने के लिए बेस 26 में पूर्णांक के रूप में मूल्यांकन किए गए पूरे स्ट्रिंग का उपयोग करता है)।

इसे ऑनलाइन आज़माएं!

— जोनाथन एलन
स्रोत
2

पर्ल 6 , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इस सभी खोज-और-घन सामान के लिए एक अलग दृष्टिकोण। अनिवार्य रूप से स्ट्रिंग प्रतिस्थापन: ...k -> -..., p -> 0, dनष्ट कर दिया। इस प्रकार newbies को माइनस स्कोर मिलता है, डैन्स को उनकी रैंक मिलती है और पेशेवरों को रैंक * 10 मिलता है। जो भी स्टाटर का उपयोग करता है वह हमें बंद कर देता है, और maxएक तुलनित्र कार्य करता है।

— फिल एच
स्रोत
2

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°aaaa"2k""2d""2k""2d"°"2"p°100"1p""9p"[10,200,3000,40000,500000,6000000,70000000,800000000,9000000000]।

यहां सभी मैप किए गए मान देखें।

— केविन क्रूज़सेन
स्रोत
2

स्काला , 307 61 54 बाइट्स

केविन क्रुजिसन और एएससीआईआई के लिए केवल इस जवाब पर अपने काम के लिए महान धन्यवाद , कि यह ~ 250 बी नीचे हो गया।

61 बी उत्तर के फ़ंक्शन के लिए कुछ एल्गोरिथ्म अनुकूलन।

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) के बीच की दूरी की गणना करना है । फिर हम इस दूरी का उपयोग एक स्कोर ( डैन = 5, केयू = 2, प्रो = 7) के रूप में करते हैं जिसे हम रैंक संख्या से गुणा करते हैं। फिर हम स्कोरिंग फ़ंक्शन का उपयोग करके इनपुट सरणी पर अधिकतम लेते हैं।

इसे भी ऑनलाइन आज़माएं!

— वी। कोर्टीस
स्रोत
2
@ V.Courtois आप हेडर में टाइपिंग जोड़ सकते हैं
— ASCII-only
1
जैसा कि @ ASCII- केवल उल्लेख किया गया है, आप इसे हेडर में a से बना सकते हैं var f: Function1[String, Function1[String, String]]=। 247 बाइट्स ।
— केविन क्रूज़सेन
2
203
— ASCII- केवल
2
86
— एएससीआईआई-केवल
2
64
— एएससीआईआई-केवल
2

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 में। मैं प्रत्येक रैंक को एक संख्यात्मक मान में बदलने और उच्च मूल्य के साथ तुलना करने और आउटपुट करने के लिए एक फ़ंक्शन का उपयोग कर रहा हूं।

रैंक वैल्यू इनपुट स्ट्रिंग के दूसरे कैरेक्टर पोजिशन से आती है !!dp, जिसे एक से घटाया जाता है और फिर 3 से संचालित किया जाता है और इनपुट स्ट्रिंग के पूर्णांक भाग से गुणा किया जाता है।

उदाहरण के लिए, दूसरा चरित्र की स्थिति का 1pजो है pमें !!dpहै 3 एक करके कम किया और 3 के लिए संचालित यह हो जाएगा 8. सभी की तो पूर्णांक हिस्सा है, *pरैंकों इसका मतलब यह है 8. से गुणा किया जाएगा 1p = 8, 2p = 16, ..., 9p = 72।

सभी *dरैंकों के लिए, पूर्णांक भाग 1 से गुणा किया जाएगा (या बस कोई गुणन नहीं)। इसका मतलब है 1d = 1, ..., 7d = 7।

और सभी *kऔर **kरैंकों के लिए, दूसरे वर्ण की स्थिति !!dpसमान होगी falseजो 0 के बराबर है (कोई स्पष्ट नहीं), एक से कम और 3 द्वारा संचालित, इसका मतलब है कि पूर्णांक भाग -1 से गुणा किया जाएगा। इसका मतलब है 30k = -30, ..., 1k = -1।

यह मेरा पहला गोल्फ प्रयास है, यकीन नहीं होता कि यह कितना बुरा है!

— Night2
स्रोत
1

एक्सेल VBA, 129 बाइट्स

एक अनाम VBE तत्काल विंडो फ़ंक्शन जो रेंज में इनपुट लेता है A1:A2और कंसोल को आउटपुट करता है।

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

explaination

[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
— टेलर स्कॉट
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.