दिल का एक हाथ स्कोर

Question

दिल 4 खिलाड़ियों के लिए एक ट्रिक-टेकिंग कार्ड गेम है। प्रत्येक चाल उस खिलाड़ी द्वारा ली जाती है जिसने अग्रणी सूट का उच्चतम कार्ड खेला था। प्रत्येक हाथ के अंत में, खिलाड़ी अपने द्वारा लिए गए पेनल्टी कार्ड के आधार पर पेनल्टी स्कोर प्राप्त करते हैं; कार्य Microsoft हार्ट्स नियमों के तहत स्कोर निर्धारित करना है।

इनपुट

इनपुट 4 सूचियों (या सीमांकित स्ट्रिंग, सरणी, आदि) में से प्रत्येक 4 खिलाड़ियों द्वारा लिए गए पेनल्टी कार्ड दिखा रहा है। पेनल्टी कार्ड हैं

2♥, 3♥, 4♥, 5♥, 6♥, 7♥, 8♥, 9♥, 10♥, J♥, Q♥, K♥, A♥, Q♠

जिसका हम प्रतिनिधित्व करेंगे

2,  3,  4,   5,  6,  7,  8,  9,  10,  11, 12,  13,  1,  0

क्रमशः।

उत्पादन

आउटपुट 4 खिलाड़ियों (सूची, स्ट्रिंग, सरणी आदि) द्वारा किए गए 4 दंड बिंदु हैं। स्कोरिंग इस प्रकार है:

• प्रत्येक दिल ( समावेशी ♥द्वारा पूर्णांकों द्वारा दर्शाया गया है ) 1 बिंदु 1को 13सम्मिलित करता है
• हुकुम की रानी ( Q♠, द्वारा प्रस्तुत 0) 13 अंक लगाती है
• अपवाद: यदि किसी खिलाड़ी ने सभी पेनल्टी कार्ड (जिसे चाँद की शूटिंग कहा जाता है) लिया है, तो उसे 0 अंक मिलते हैं, जबकि अन्य सभी खिलाड़ियों को 26 अंक मिलते हैं।

परीक्षण के मामलों

[2, 8, 7, 1], [3, 4], [], [9, 5, 6, 0, 10, 11, 12, 13]     -->  4,  2,  0, 20
[0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], [], [], [1]   --> 25,  0,  0,  1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0], [], [], [] -->  0, 26, 26, 26

बाइट्स में सबसे छोटा कोड जीतता है।

Answer 1

CJam, 22 20 बाइट्स

2 बाइट बचाने के लिए jimmy23013 का धन्यवाद।

{{XD?}f%1fb_26&1bf^}

एक अनाम ब्लॉक (फ़ंक्शन), जो इनपुट के रूप में 4 सूचियों की सूची लेता है और स्कोर की सूची देता है।

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

व्याख्या

{      e# For each card...
  XD?  e#   Choose 1 if it's positive and 13 if it's zero.
}f%
1fb    e# Sum each hand.
_26&   e# Get the set intersection of the scores with 26. This gives [26]
       e# if someone shot the moon, and [] otherwise.
1b     e# Treat as base-1 digits, which gives 26 if someone shot the moon
       e# and zero otherwise.
f^     e# XOR each result with this number. This swaps zeros and 26s when 
       e# someone shot the moon and does nothing otherwise.

Comments

_26&1b। -2 बाइट्स।

— jimmy23013

@ jimmy23013 Ahhhh, 1b... मैं एक छोटी तरह से चालू करने के लिए खोजने की कोशिश कर रहा था [26]में 26और []में 0लेकिन किसी भी तरह है कि मेरे पास नहीं होती है। धन्यवाद :)

— मार्टिन एंडर

Answer 2

आर, 85 77 74 बाइट्स

function(x,z=sapply(x,function(x)sum(x>0)+any(x<1)*13))abs(z-any(z>25)*26)

फ़ंक्शन जो इनपुट के रूप में एक आर-सूची लेता है। तत्वों की संख्या की गिनती करके काम करता है >0और 13 को जोड़ता है यदि प्रत्येक वेक्टर के भीतर कोई भी तत्व <1(यानी हुकुम की रानी) है और स्टोर करें z।

यदि कोई भी तत्व zहै >25, तो वापस लौटें 26-z, और वापस लौटें z।

आर-फिडल पर इसे आज़माएं

Comments

चाहेंगे 26-zकाम करते हैं?

— u54112

@lastresort हां बिल्कुल। /

— फेसपालम

Answer 3

सी ++ 14, 158 बाइट्स

अनाम लैम्ब्डा के रूप में:

[](auto c){typename decltype(c)::value_type r;int b=0;for(auto d:c){int q=0;for(auto i:d)q+=i?1:13;r.push_back(q);b+=q==26;}if(b)for(int&x:r)x=26-x;return r;}

एक vector<vector<int>>और रिटर्न की आवश्यकता हैvector<int>

Ungolfed:

[](auto c){
 typename decltype(c)::value_type r;   //result vector
 int b=0;                              //flag if one has all cards
 for(auto d:c){                        //over all decks
  int q=0;                             //count points
  for(auto i:d) q+=i?1:13;             //+13 for queen, +1 else
  r.push_back(q);                      //add to result
  b+=q==26;                            //possibly activate flag
 }
 if(b) for(int&x:r) x=26-x;            //if flag is set, mirror the results
 return r;
}

आपके लिए कुछ परीक्षण:

 auto r = std::vector<std::vector<int>>{{2,8,7,1},{3,4},{},{9,5,6,0,10,11,12,13}};
 auto s = std::vector<std::vector<int>>{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0},{},{},{}};
 auto t = std::vector<std::vector<int>>{{},{2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0},{},{1}};

Answer 4

पायथन 2, 75 72 71 बाइट्स

i=[len(a)+12*(0in a)for a in input()]
print[[x,26-x][26in i]for x in i]

के रूप में इनपुट लेता है [2, 8, 7, 1], [3, 4], [], [9, 5, 6, 0, 10, 11, 12, 13]

Comments

क्या आप [0,12] [0in] के बजाय 12 * [0in a] का उपयोग करके 3 वर्णों को सहेज सकते हैं?

— कॉस्टैंटिनो

@ कॉस्टैंटिनो मुझे लगता है कि आपका मतलब है 12*(0in a)।

— mbomb007

print[[x,26-x][26in i]for x in i]एक बाइट कम है

— मृत्युंजय

Answer 5

PHP, 113 बाइट्स

function h($a){foreach($a as&$b)$b=count($b)+12*in_array(0,$b);if(max($a)>25)foreach($a as&$n)$n=26-$n;return$a;}

फ़ंक्शन सरणी का एक सरणी लेता है, मानों की एक सरणी देता है।

---

PHP में अन्य ऐरे मैपिंग को अचंभित करें: संदर्भित आइटम के साथ लूप। वाया से छोटा array_map।

Answer 6

हास्केल, 62 59 56 बाइट्स

f x|all(<26)x=x|0<1=map(26-)x
f.map(sum.map((13^).(0^)))

उपयोग:

> f.map(sum.map((13^).(0^))) $ [[0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], [], [], [1]]
[25,0,0,1]

Comments

मुझे लगता है कि आप के fरूप में लिख सकते हैं f n=13^0^n।

— xnor

@xnor मुझे लगता है कि आप सही हैं। 3 बाइट बचाता है।

— Angs

मुझे लगता f x|all(<26)x=x|0<1=map(26-)xहै कि लैम्ब्डा फ़ंक्शन के स्थान पर इसे परिभाषित करना और इसका उपयोग करना कुछ बाइट्स को बचाता है।

— 12

@Zgarb तुम सही हो, मैं कहूँगा कि एक और 3 बाइट्स है।

— Angs

Answer 7

05AB1E ,26 22 21 बाइट्स

अनुगामी व्हाट्सएप को इनपुट से हटाया जाना चाहिए ताकि यह एक सरणी के रूप में व्याख्या की जाए। जब एक खिलाड़ी ने सभी पेनल्टी कार्ड इकट्ठे किए थे, तब उपयोग (26-x) का उपयोग करते हुए अंत अन्य उत्तरों से प्रेरित था।

vy0å12*yg+})D26©åi(®+

v                    For each array
 y                   Push array on the stack
  0å                 Generate a boolean array indicating whether the queen of spades is at the same index in the original array
    12*              Multiply by 12 the value of the queen of spades
       yg+           Add the length of the array; the queen of spades gets her last point from this part
          }          End for
           )         Push an array of all evaluated scores
            D26©å    1 if there is a 26, 0 otherwise
                 i   If there is a 26
                  (®+ Mirror the array: for each element yield 26-element
                      Implicit end if
                      Implicitly print the score array

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

यह अभी भी बहुत सुंदर दिखता है, डुप्लिकेट स्थिरांक और सशर्त बयानों के साथ।

पूर्व संस्करण, 26 बाइट्स

(अधिकतम जुर्माना मूल्य में प्रत्येक बिंदु के लिए एक बाइट)

मैंने इसे बनाए रखने का निर्णय लिया क्योंकि इसकी लंबाई मेरी राय में इस चुनौती को सबसे उपयुक्त मानती है :)।

vyD0å12*sg+})D26©QDOi_®*ë\

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

Answer 8

पायथन 3, 101 बाइट्स

def s(a):r=[sum([(1,13)[c==0]for c in h])for h in a];s=(r,[(26,0)[s==26]for s in r]);return s[26in r]

पूर्ण कोड:

def score(hands):
    result = [sum([(1, 13)[card == 0] for card in hand]) for hand in hands]
    results = (result, [(26, 0)[score == 26] for score in result])
    return results[26 in result]

Comments

12*(c<1)+12 बाइट्स से छोटा है (1,13)[c==0]। 26*(s>25)3 बाइट्स से छोटा है (26,0)[s==26]।

— Mego

Answer 9

जावास्क्रिप्ट (ईएस 6), 82 80 77 72 70 69 67 बाइट्स

2 बाइट्स @Neil की बदौलत सहेजे गए

f = 
s=>s.map(c=>c.map(t=>r+=t?1:13,r=0)|(b|=r>25,r),b=0).map(c=>b*26^c)

console.log(f.toString().length)
console.log(f([[2, 8, 7, 1], [3, 4], [], [9, 5, 6, 0, 10, 11, 12, 13]]));
console.log(f([[0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], [], [], [1] ]));
console.log(f([[0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], [], [1], [] ]));
console.log(f([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0], [], [], []]));
console.log(f([[],[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0], [], []]));

टूट - फूट

s=>s.map(                              // for each hand
 c=>c.map(                             // for each card
  t=>r+=t?1:13,                        // add value of card
 r=0)|(
  b=b|r>25,r                           // set flag if any hand scores 26 points
 ),
 b=0)
.map(c=>b?                             // for every card if a hand scored 26
  c?0:26                               // set every 0 hand to 26 and the 26 hand to 0
:c)                                    // otherwise do nothing

Comments

c=>b*26^c2 बाइट्स बचाता है।

— नील

Answer 10

पिप , 28 बाइट्स

-pध्वज के लिए कोड के 27 बाइट्स, +1 ।

Y{$+1+12*!*a}M Va26Ny?26-yy

कमांड लाइन पर एक नेस्टेड सूची का प्रतिनिधित्व करने वाले स्ट्रिंग के रूप में इनपुट लेता है, जैसे "[[2 8 7 1] [3 4] [] [9 5 6 0 10 11 12 13]]"(टीआईओ पर आवश्यक उद्धरण नहीं)। इसे ऑनलाइन आज़माएं!

Answer 11

रूबी, 59 बाइट्स

->a{a.map{|h|a.max.size>13?h.min||26:h.size+12*h.count(0)}}

या, वैकल्पिक रूप से,

->a{a.map{|h|a.count([])>2?h.min||26:h.size+12*h.count(0)}}

यदि केवल एक हाथ में कोई कार्ड है, तो हम चाहते हैं कि खाली हाथ 26 का मान प्राप्त करें, और कार्ड के साथ हाथ 0. मान प्राप्त करने के लिए। मैं minहाथों पर कॉल करके ऐसा करता हूं - यह nilखाली सरणी के लिए देता है , और फिर मैं ||इसे 26 में करता हूं । अन्य मामलों में, मैं एक हाथ में कार्डों की संख्या गिनता हूं और फिर क्वीन ऑफ स्पेड्स में 12 जोड़ देता हूं।

Answer 12

स्काला, 93 बाइट्स

a=>{val% =a.map(_.map{case 0=>13;case _=>1}sum)
if(%toSet 26)%map{case 0=>26;case _=>0}else%}

उपयोग:

val f:(Seq[Seq[Int]]=>Seq[Int])=...
f(Seq(Seq(2, 8, 7, 1), Seq(3, 4), Seq(), Seq(9, 5, 6, 0, 10, 11, 12, 13)))

स्पष्टीकरण:

a=>{           //define an anonymou function with a parameter a
  val% =         //define % as...
    a.map(         //map each element of a...
      _.map{         //to each of the card
        case 0=>13     //replaced with its value
        case _=>1
      }
      sum            //and the sum of the values
    )
  if(            //if
    %toSet 26      //one player has all cards
  )
    %map{          //return % with...
      case 0=>26     //each 0 replaced with 26
      case _=>0      //and everything else (aka the 26) replaced 0
    }
  else           //else
    %              //return %
}

मैं %toSet 26इसके बजाय उपयोग कर सकता हूं % contains 26क्योंकि Set's applyविधि है containsऔर Seq' s की तरह नहीं मिलता है