하트 는 4 인용 속임수 카드 게임입니다. 각각의 트릭은 최고 소송에서 가장 높은 카드를 사용한 플레이어가 수행합니다. 각 핸드의 끝에서, 플레이어는 자신이 선택한 페널티 카드에 따라 페널티 점수를받습니다. 이 작업은 Microsoft Hearts 규칙에 따라 점수를 결정하는 것 입니다.

입력

입력은 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를 13포함 하여 정수 로 표시 )는 1 포인트를 발생시킵니다
• 스페이드의 여왕 ( 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

바이트 단위의 최단 코드가 이깁니다.

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.

R, 85 77 74 바이트

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

R- 목록을 입력으로 사용하는 명명되지 않은 기능. 요소 수를 계산하여 작동 >0하며 각 벡터 내의 요소가 <1(즉, 스페이드의 여왕) 이면 13을 더하고 로 저장합니다 z.

in의 요소가 z있으면 >25을 반환하고 26-z, 그렇지 않으면을 반환 z합니다.

R 바이올린에서 사용해보십시오

C ++ 14, 158 바이트

명명되지 않은 Lambda로 :

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

언 골프 드 :

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

파이썬 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]

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.

하스켈, 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]

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

(최대 페널티 값에서 각 포인트 당 1 바이트)

내 의견으로는 길이 가이 도전에 가장 잘 맞아 유지하기로 결정했습니다. :).

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

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

파이썬 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]

자바 스크립트 (ES6), 82 80 77 72 70 69 67 바이트

@Neil 덕분에 2 바이트 절약

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

핍 , 28 바이트

27 바이트의 코드, -p플래그의 경우 +1

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

명령 줄에서 입력을 "[[2 8 7 1] [3 4] [] [9 5 6 0 10 11 12 13]]"TIO에서는 필요하지 않은 중첩 목록을 나타내는 문자열로 사용합니다 . 온라인으로 사용해보십시오!

루비, 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)}}

한 손은 카드를 가지고 있다면, 우리는 호출하여 내가 이렇게 0의 값을 얻기 위해 (26)의 값 및 카드와 손을 얻기 위해 빈 손을 원하는 min이 수익을 - 손에 nil하늘의 배열을 위해, 그리고 나는 ||다른 경우에는 26으로, 나는 손에 카드의 수를 계산 한 후 스페이드의 여왕 (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 26SetapplycontainsSeq 의