শব্দ পোকার, কে জিতবে?

Question

ইনপুটটি দুটি পাঁচ অক্ষরের শব্দ হবে। এগুলি আসলে অভিধানের শব্দ হতে হবে না, প্রতিটি প্রতিটি পাঁচটি অক্ষর, সমস্ত ছোট হাতের বা সমস্ত বড় হাতের অক্ষর, আপনার পছন্দ। ইনপুট শব্দগুলিতে কেবল এজেড উপস্থিত হবে এবং এগুলি সর্বদা 5 টি অক্ষরের দৈর্ঘ্যে থাকবে।

আপনার প্রোগ্রামটি তাদের উভয়কেই স্কোর করতে হবে যেন তারা পোকার হাত এবং উচ্চতর হাতের আউটপুট। অবশ্যই স্যুটগুলি এখানে প্রয়োগ হবে না, কেবল র‌্যাঙ্কিংয়ের ফলে কোনও ফ্লাশ নেই।

সাধারণ জুজু র‌্যাঙ্কিং সিস্টেমটি চলে: '1 জোড়', '2 জোড়া', 'একধরণের 3', 'সোজা', 'পূর্ণ বাড়ি', 'এক ধরণের 4', 'এক ধরণের 5' এবং অবশ্যই হাত (বা এই ক্ষেত্রে শব্দ) মূল্যহীন হতে পারে সম্ভাবনা আছে।

সম্পর্কের ক্ষেত্রে, ক এর নিকটবর্তী বর্ণগুলি উচ্চতর হিসাবে বিবেচনা করা হয়, সুতরাং আসরের একটি জুটি একজোড়া বিএসকে মারধর করে। কিছু ক্ষেত্রে উভয় হাতই অভিন্ন হতে পারে তবে ভিন্ন ক্রমে (বা না) সে ক্ষেত্রে আউটপুট হয় হাত বা এটির একটি রিসর্ট সংস্করণ।

এই বাহ্যিক পৃষ্ঠায় কীভাবে বিজয়ী চিহ্নিত করতে হয় এবং বিশেষত নির্দিষ্ট র‌্যাঙ্কিংয়ের মধ্যে সম্পর্কগুলিকে সম্বোধন করা যায় সে সম্পর্কিত তথ্য রয়েছে, যদি আপনি কীভাবে পোকার হ্যান্ড স্কোর করবেন না তার সাথে পরিচিত না হন।

স্ট্রেটের ক্ষেত্রে : বর্ণগুলি বর্ণমালার সাথে সংলগ্ন হতে হবে এবং চারপাশে মোড়ানোর অনুমতি নেই। সুতরাং 'ডিফগ' কোনও ক্রমে সোজা, 'জাইজাব' নয় not

একক হাত কীভাবে স্কোর করা যায় তার উদাহরণ:

word   | scored as
---------------------
ccccc  | 5 of a kind     <-- highest ranking
woooo  | 4 of a kind
opopo  | full house
vurst  | straight
vovvu  | 3 of a kind
ppoww  | 2 pairs
upper  | 1 pair
kjsdf  | high card only (in this case D) <-- lowest ranking

সুতরাং প্রোগ্রামটি আসলে এর মতো ফলাফল আনবে:

input        |  output
-----------------------
voviu,kjsdf  |  voviu     because a pair beats nothing 
opoqo,upper  |  opoqo     because 3 of a kind beats a pair
woooo,ggegg  |  ggegg     because 4 Gs beats 4 Os
queue,hopup  |  queue     because 2 pairs beats 1 pair
lodpl,ddkop  |  ddkop     because pair DD beats pair LL
huhyg,hijht  |  huhyg     both have pair HH, but G beats I
ddffh,ccyyz  |  ccyyz     both have 2 pairs, but CC(yyz) beats DD(ffh)
okaok,nkunk  |  nkunk     KK ties with KK, but NN beats OO
abcdf,bcdef  |  bcdef     because it is a straight
qtery,retyq  |  qtery     identical! so doesnt matter
abedc,vyxwz  |  abedc     because it is a "higher" straight
hhhij,hijkl  |  hijkl     because straight beats 3 of a kind
aaabb,zzzzz  |  zzzzz     because nothing beats 5 of a kind

ইনপুট এবং আউটপুট উভয় ক্ষেত্রে অক্ষরের ক্রমটি অপ্রাসঙ্গিক, সুতরাং আপনার আউটপুটে ক্রমটি ইনপুটটির চেয়ে আলাদা হতে পারে, তবে একই অক্ষরের জায় উপস্থিত থাকতে হবে।

আউটপুটে অবশ্যই পাঁচটি অক্ষর থাকতে হবে - আর বেশি নয়, কমও নয়।

সাধারণ কোডগলফ বিধি প্রযোজ্য। সংক্ষিপ্ততম কোড জিতেছে।

Answer 1

জাভাস্ক্রিপ্ট ( 224 218 213 বাইট)

s=>t=>(v=s=>(o={},l=n=0,z=3.5,[...s].sort().map(c=>(n+=o[c]=-~o[c],z*=!l|l+1==(l=c.charCodeAt()))),[n+z,Object.keys(o).sort((a,b)=>o[b]-o[a]||(o[b]>o[a]?1:-1))]),w=v(s),x=v(t),w[0]>x[0]||w[0]==x[0]&&w[1]<x[1]?s:t)

Ungolfed:

s=>t=>(
  v=s=>(
    o={},
    l=n=0,
    z=3.5,
    [...s].sort().map(c=>(
      n+=o[c]=-~o[c],
      z*=!l|l+1==(l=c.charCodeAt())
    )),
    [n+z,Object.keys(o).sort((a,b)=>o[b]-o[a]||(o[b]>o[a]?1:-1))]
  ),
  w=v(s),x=v(t),
  w[0]>x[0] || w[0]==x[0] && w[1]<x[1] ? s : t
)

map()রান করার পরে , n + zএকটি হাতের স্থান নির্ধারণ করে:

(আপনি কেন বুঝতে পেরেছেন যে আমি কেন z৩.৫ এ আঞ্চলিক সূচনা করেছি ।)

একটি টাই ক্ষেত্রে, Object.keys(o).sort()উচ্চ র‌্যাঙ্কিং হাত নির্ধারণ করতে ব্যবহৃত হয়।

স্নিপেট:

f=

s=>t=>(v=s=>(o={},l=n=0,z=3.5,[...s].sort().map(c=>(n+=o[c]=-~o[c],z*=!l|l+1==(l=c.charCodeAt()))),[n+z,Object.keys(o).sort((a,b)=>o[b]-o[a]||(o[b]>o[a]?1:-1))]),w=v(s),x=v(t),w[0]>x[0]||w[0]==x[0]&&w[1]<x[1]?s:t)

console.log(/voviu/.test(f('voviu')('kjsdf')))       //because a pair beats nothing 
console.log(/opoqo/.test(f('opoqo')('upper')))       //because 3 of a kind beats a pair
console.log(/ggegg/.test(f('woooo')('ggegg')))       //because 4 Gs beats 4 Os
console.log(/queue/.test(f('queue')('hopup')))       //because 2 pairs beats 1 pair
console.log(/ddkop/.test(f('lodpl')('ddkop')))       //because pair DD beats pair LL
console.log(/huhyg/.test(f('huhyg')('hijht')))       //both have pair HH, but G beats I
console.log(/ccyyz/.test(f('ddffh')('ccyyz')))       //both have 2 pairs, but CC(yyz) beats DD(ffh)
console.log(/nkunk/.test(f('okaok')('nkunk')))       //KK ties with KK, but NN beats OO
console.log(/bcdef/.test(f('abcdf')('bcdef')))       //because it is a straight
console.log(/qtery|retyq/.test(f('qtery')('retyq'))) //identical! so doesnt matter
console.log(/abedc/.test(f('abedc')('vyxwz')))       //because it is a "higher" straight
console.log(/hijkl/.test(f('hhhij')('hijkl')))       //because straight beats 3 of a kind
console.log(/zzzzz/.test(f('aaabb')('zzzzz')))       //because nothing beats 5 of a kind

Answer 2

জেলি ,  28 27 29  27 বাইট

+2 এবং তারপরে -2 একটি বাগ ঠিক করুন, তারপরে পুনরায় গল্ফ করুন।

FI=1ȦḤW
OµNĠLÞṚịµL€+Ç,N
ÇÞṪ

একটি হাতের লিঙ্ক "হাত" এর তালিকা নিয়ে এবং বিজয়ীদের (একজনের) প্রত্যাবর্তন করে।

সর্ব-বড় হাতের বা সমস্ত ছোট হাতের ইনপুট জন্য কাজ করে।
(... তবে মিশ্র নয়, এর জন্য Œlবা এর সাথে চূড়ান্ত লাইনটি প্রিপেন্ড করুন Œu)।

এটি অনলাইন চেষ্টা করুন! অথবা পরীক্ষার স্যুটটি দেখুন ।

কিভাবে?

FI=1ȦḤW - Link 1, straight offset: grouped and reverse sorted hand ordinals
        -                     e.g. [[-101],[-100],[-99],[-98],[-97]]
F       - flatten                  [-101,-100,-99,-98,-97]
 I      - increments               [1,1,1,1]
  =1    - equal 1? (vectorises)    [1,1,1,1]
    Ȧ   - any and all?             1
     Ḥ  - double                   2
      W - wrap in a list           [2]
        -   The purpose of this is so that when "a" from Link 2 represents a straight we
        -   get [2], whereas for any other hand we get [0]. Adding the [2] to [1,1,1,1,1]
        -   (the lengths of a straight's groups) yields [3,1,1,1,1], placing it between
        -   three of a kind, [3,1,1], and a full house, [3,2], as required.

OµNĠLÞṚịµL€+Ç,N - Link 2, hand rank key function: list of characters       e.g. "huhyg"
O               - cast to ordinals                                [104,117,104,121,103]
 µ              - monadic chain separation, call that o
  N             - negate (to give them a reverse-sort order) [-104,-117,-104,-121,-103]
   Ġ            - group indices by value                            [[4],[2],[1,3],[5]]
     Þ          - sort by key function:
    L           -   length                                          [[4],[2],[5],[1,3]]
      Ṛ         - reverse                                           [[1,3],[5],[2],[4]]
       ị        - index into o                       [[-104,-104],[-103],[-117],[-121]]
        µ       - monadic chain separation (call that a)
         L€     - length of €ach                                              [2,1,1,1]
            Ç   - call last link (2) as a monad -> [isStraight? * 2]                [0]
           +    - addition (vectorises)                                       [2,1,1,1]
              N - negate o                                [[104,104],[103],[117],[121]]
             ,  - pair                        [[2,1,1,1],[[104,104],[103],[117],[121]]]
                -   now sorting by this will first be comparing the hand class, and if
                -   and only if they match comparing the card values in the required order.

ÇÞḢ - Main link: list of lists of characters (list of hands)
 Þ  - sort by key function:
Ç   -   last link (2) as a monad
  Ṫ - tail (best or an equal-best hand)

Comments

আমি জেএস 0.o এ যা করছি তার সাথে তুলনা করে সংক্ষিপ্তভাবে সংক্ষিপ্ত হয়ে যাচ্ছি

— স্টিফেন

@ স্টেফেনস পিপিসিগিতে আপনাকে স্বাগতম, যেখানে আপনি কিছু অ-গল্ফিং ভাষায় কিছু তৈরি করেন এবং তারপরে কেউ জেলি, 05 এবি 1 ই, পাইথ, সিজেম ইত্যাদিতে এমন কিছু তৈরি করেন যা আপনার ভাষার নামের চেয়ে খাটো: I: P

— HyperNeutrino

@ স্টেফেনস - জেএসের জেএসের সাথে প্রতিযোগিতা করা উচিত। গল্ফিংয়ের ভাষাগুলি অন্য ভাষাগুলিতে ভালভাবে চিন্তাভাবনা সমাধান জমা দিতে আপনাকে বিরত রাখবেন না!

— জোনাথন অ্যালান

@ জোনাথান অ্যালান এটি a 25 টি অক্ষরে সমাধান করতে পারে এমন সমস্যাটিকে ওভারটাইকিং এবং অ্যাবস্ট্রাক্ট করতে খুব বেশি প্রচেষ্টা করা থেকে বিরত রাখে, আমি যে ফ্রিডলটিতে কাজ করছিলাম তা এখানে - আমি সমস্ত বয়লারপ্লেট লিখেছিলাম এবং

— স্টিফেন

এটি দুর্দান্ত। আমি মনে করি এটি আপনার সরল [3,1,1,1,1] হিসাবে স্থানের কারণেই?

— অক্টোপাস

Answer 3

জাভাস্ক্রিপ্ট ( 250 247 232 বাইট)

S=d=>(x={},l=99,h=s=0,[...d].map(v=>x[v]=-~x[v]),Object.keys(x).map(v=>(c=91-v.charCodeAt(),t=x[v],s+=1e4**t,c<x[t]?0:x[t]=c,g=(h=c>h?c:h)-(l=c<l?c:l))),[5,4,3,2,1].map(v=>s+=0|x[v]**v),s+(s<5e7&&g<5?1e13:0)),C=a=>b=>(S(a)>S(b)?a:b)

জেএসফিডেলে অবহেলিত কোড ও পরীক্ষার মামলা: https://jsfiddle.net/CookieJon/8yq8ow1b/

@ রিকহিচকককে ধন্যবাদ দিয়ে কিছু বাইট সংরক্ষণ করা হয়েছে। @ স্টেফেনস এবং @ আরনাউল্ড

Comments

এটিই আমি তৈরি করার চেষ্টা করছিলাম তবে কীভাবে তৈরি করা যায় তার কোনও ধারণা ছিল না।

— স্টিফেন

না আমি শুরু করার আগে পর্যন্ত! :-)

— বম্পি

s=0,h=0=> s=h=0আমি বিশ্বাস করি

— স্টিফেন

অনেক চুল টানানোর পরে এখন স্থির। যে হাতটি একইরকম এবং টাইম ব্রেকার নির্ধারণ করা 1 ম এবং দ্বিতীয় বৃহত্তম গ্রুপগুলির মধ্যে সর্বনিম্ন অক্ষরগুলি হত্যাকারী (33 বাইট বা তার পক্ষে কেবল এটিই ছিল !?) :-(

— বম্পি

x[v]=x[v]?++x[v]:1x[v]=(x[v]|0)+13 বাইট সংরক্ষণ করতে পারে ।

— রিক হিচকক

Answer 4

পাইথন 2.7, 242 223 বাইট

from collections import*
s=sorted
f=lambda x,y:s(map(lambda h:(lambda (r,n):((3,1.5)if len(r)==5 and ord(r[0])+4==ord(r[4])else n,[-ord(d) for d in r],h))(zip(*s(Counter(h).items(),key=lambda z:(-z[1],z[0])))),(x,y)))[1][2]

জাভাস্ক্রিপ্ট উদাহরণগুলির মত মৌলিক ধারণায় একই রকম (স্ট্রেটের ব্যতিক্রম সহ হাতের শক্তি অনুসারে সাজান; তারপরে পদমর্যাদায়); তবে collections.Counterদুর্ভাগ্যক্রমে সদ্ব্যবহার .most_commonকরা, যথেষ্ট পছন্দসই আচরণ নেই; সুতরাং একটি কাস্টম বাছাই কী যুক্ত করতে হবে।

সম্পাদনা করুন: 19 বাইট নিচে ট্রিম করতে আরও কিছু কোড গল্ফ করছে।

আন-গল্ফ কোড

from collections import Counter

def convertHand(h):
    # first get item counts, appropriately ordered; e.g. cbabc -> (('b',2), ('c',2),('a',1))
    sortedPairs = sorted(Counter(h).items(),key=lambda x:(-x[1],x[0]))

    # 'unzip' the tuples to get (('b','c','a'), (2,2,1))
    ranks, numberFound = zip(*sortedPairs) 

    if len(ranks)==5:
        # no pairs; is it a straight? well, since they are in increasing order...
        if ord(ranks[0])+4 == ord(ranks[4]):
            # replace numberFound with something that will sort above 3 of a kind but below full house
            numberFound = (3,1.5)

    # invert the values of the ranks, so they are in decreasing, rather then increasing order
    ranks = [-ord(r) for r in ranks]

    # arrange tuples so we can sort by numberFound, and then ranks; and keep a reference to the hand
    return (numberFound, ranks, h)

# put it all together...
def f(x,y):
    hands = [convertHand(h) for h in (x,y)]
    rankedHands = sorted(hands)
    return rankedHands[1][2]

Answer 5

গণিত, 635 বাইট

H[x_]:=Block[{t},T=Sort@ToCharacterCode[x];L=Last/@Tally@T;t=0;S=Count;If[S[L,2]==1,t=1];If[S[L,2]==2,t=2];If[S[L,3]==1,t=3];If[S[Differences@T,1]==4,t=4];If[S[L,2]==1&&S[L,3]==1,t=5];If[S[L,4]==1,t=6];If[S[L,5]==1,t=7];t];F[K_,v_]:=First@Flatten@Cases[Tally@K,{_,v}];B=ToCharacterCode;(Z=Sort@B@#1;Y=Sort@B@#2;a=H[#1];b=H[#2];If[a>b,P@#1,If[a<b,P@#2]]If[a==b&&a==0,If[Z[[1]]<Y[[1]],P@#1,P@#2]];If[a==b&&(a==1||a==2),If[F[Z,2]<F[Y,2],P@#1,If[F[Z,2]==F[Y,2],If[F[Z,1]<F[Y,1],P@#1,P@#2],P@#2]]];If[a==b&&(a==3||a==5),If[F[Z,3]<F[Y,3],P@#1,P@#2]];If[a==b&&a==6,If[F[Z,4]<F[Y,4],P@#1,P@#2]];If[a==b&&(a==7||a==4),If[Tr@Z<Tr@Y,P@#1,P@#2]])&

।
।
ইনপুট ফর্ম

["abcde", "kkekk"]

Comments

অনলাইনে এটি পরীক্ষা করার কোনও উপায় আছে কি?

— অক্টোপাস

স্যান্ডবক্স.ওপেন.ওয়লফ্রামক্লাউড / অ্যাপ্লিকেশন / সিবিএল + ভি দিয়ে পেস্ট কোডের শেষে ইনপুট যুক্ত করে শিফট + এন্টার দিয়ে চালান

— J42161217