Hearts est un jeu de cartes pour 4 joueurs. Chaque tour est joué par le joueur qui a joué la carte la plus haute de la couleur principale. À la fin de chaque main, les joueurs encourent un score de pénalité en fonction des cartes de pénalité qu'ils ont prises; la tâche consiste à déterminer les scores selon les règles de Microsoft Hearts .

Contribution

L'entrée est 4 listes (ou chaîne délimitée, tableau, etc.) montrant les cartes de pénalité prises par chacun des 4 joueurs. Les cartes de pénalité sont

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

que nous représenterons comme

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

respectivement.

Sortie

La sortie correspond aux 4 points de pénalité encourus par les 4 joueurs (liste, chaîne, tableau, etc.). La notation est la suivante:

• Chaque cœur ( ♥représenté par des nombres entiers 1à 13inclus) encourt 1 point
• La reine de pique ( Q♠, représentée par 0) gagne 13 points
• Exception: si un joueur a pris toutes les cartes de pénalité (appelées tirer sur la lune), il encourt 0 point, tandis que tous les autres joueurs encourent 26 points.

Cas de test

[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

Le code le plus court en octets gagne.

CJam, 22 20 octets

Merci à jimmy23013 pour avoir économisé 2 octets.

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

Un bloc sans nom (fonction), qui prend en entrée une liste de 4 listes et renvoie la liste des scores.

Essayez-le en ligne!

Explication

{      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.

R, 85 77 74 octets

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

Fonction sans nom qui prend une liste R en entrée. Fonctionne en comptant le nombre d'éléments >0et en ajoute 13 si un élément de chaque vecteur est <1(c.-à-d. La reine de pique) et le stocke sous z.

Si un élément de zis est >25, return 26-z, else return z.

Essayez-le sur R-fiddle

C ++ 14, 158 octets

En tant que Lambda sans nom:

[](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;}

Nécessite un vector<vector<int>>et retournevector<int>

Non golfé:

[](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;
}

Quelques tests pour vous:

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

Python 2, 75 72 71 octets

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

Prend l'entrée comme [2, 8, 7, 1], [3, 4], [], [9, 5, 6, 0, 10, 11, 12, 13]

PHP, 113 octets

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

La fonction prend un tableau de tableaux, renvoie un tableau de valeurs.

Émerveillez l'autre mappage de tableau en PHP: boucles avec des éléments référencés. Waaay plus court que array_map.

Haskell, 62 59 56 octets

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

Usage:

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

05AB1E ,26 22 21 octets

Les espaces de fin doivent être supprimés de l'entrée afin d'être interprétés comme un tableau. La fin a été inspirée des autres réponses lors de l'utilisation de (26-x) lorsqu'un joueur a rassemblé toutes les cartes de pénalité.

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

Essayez-le en ligne!

Il semble toujours assez jouable au golf, avec des constantes dupliquées et des instructions conditionnelles.

Ancienne version, 26 octets

(Un octet pour chaque point dans la valeur de pénalité maximale)

J'ai décidé de le garder car sa longueur correspond le mieux à ce défi à mon avis :).

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

Essayez-le en ligne!

Python 3, 101 octets

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]

Code complet:

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]

JavaScript (ES6), 82 80 77 72 70 69 67 octets

Sauvegardé 2 octets grâce à @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], [], []]));

Panne

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

Pip , 28 octets

27 octets de code, +1 pour l' -pindicateur.

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

Prend l'entrée sur la ligne de commande sous la forme d'une chaîne représentant une liste imbriquée, comme "[[2 8 7 1] [3 4] [] [9 5 6 0 10 11 12 13]]"(guillemets non nécessaires sur TIO). Essayez-le en ligne!

Rubis, 59 octets

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

Ou bien,

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

Si une seule main a des cartes, nous voulons que les mains vides obtiennent une valeur de 26 et la main avec des cartes une valeur de 0. Je le fais en appelant minles mains - cela revient nilpour un tableau vide, puis Je l'ai ||en 26. Dans d'autres cas, je compte le nombre de cartes dans une main, puis j'en ajoute 12 à la Reine de pique.

Scala, 93 octets

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

Usage:

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

Explication:

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

Je pourrais utiliser au %toSet 26lieu de % contains 26parce que Set« de applyla méthode est containset ne pas obtenir-à-index comme Seq» s