Quando criança, eu costumava jogar muito o jogo de cartas " golfe " . Seu desafio, se você aceitar, é calcular a pontuação de uma mão de golfe. Como existem mais de 9000 variações neste jogo de cartas ¹ , seguiremos as regras que eu lembro de jogar.

Regras do jogo)

• Você termina uma rodada com 6 cartas e deseja o mínimo de pontos possível.

• Coringas não são usados.

• Ases e 2s valem -1 e -2 pontos, respectivamente.

• Valetes e Reis valem 0 pontos.

• Cartões de 3 a 10 valem o valor nominal. No entanto, eles são cancelados quando você os emparelha. Por exemplo, um 5 vale 5 pontos, mas dois 5s valem zero. Três 5s valem 5 pontos (já que os 2 primeiros estão emparelhados, mas o 3º não.) E quatro 5s valem 0 (já que são 2 pares).

• As rainhas valem 15 pontos. As rainhas não podem ser canceladas, por exemplo, duas rainhas valem 30 pontos.

Regras (do desafio)

A entrada será uma matriz de números inteiros ou 6 inteiros individuais. Qualquer que você preferir. 1 representa um ás, 2-10 representa 2-10 e Valete, Dama e Rei representam 11, 12 e 13. O resultado é a pontuação da mão de acordo com as regras acima. Você pode assumir com segurança que todas as entradas são válidas, por exemplo, nenhum número aparece mais de 4 vezes e todos os números estão no intervalo [1, 13]. A entrada e a saída podem estar em qualquer formato razoável.

Teste de E / S:

[11, 10, 3, 1, 2, 2]    --> 8
[4, 5, 5, 3, 8, 7]      --> 22
[2, 2, 2, 2, 1, 1]      --> -10 (The lowest score possible)
[12, 12, 12, 12, 10, 9] --> 79 (The highest score possible)
[9, 9, 9, 9, 11, 1]     --> -1
[8, 8, 8, 8, 11, 13]    --> 0
[10, 9, 3, 7, 12, 2]    --> 42
[1, 2, 3, 4, 5, 6]      --> 15
[10, 9, 2, 3, 4, 1]     --> 23
[10, 3, 12, 3, 7, 12]   --> 47

Menor resposta em bytes ganha!

^Na verdade, não, mas há muitas variações.

Pitão, 28 27 25 bytes

s+*L%/Qd2}3Tm?<d3_d*15q12

Experimente online. Suíte de teste.

Explicação

• Primeiro, o Pyth anexa automaticamente algumas variáveis. O código é agora s+*L%/Qd2}3Tm?<d3_d*15q12dQ.
• }3Tgera a lista [3, 4, 5, 6, 7, 8, 9, 10].
• Multiplique cada número nessa lista ( *L) pela contagem desse número na entrada ( /Qd), módulo 2 ( %… 2). O resultado é 0 para números emparelhados e o próprio número para números não emparelhados.
• Mapa sobre os números de entrada ( m… Q):
  • Se o número for menor que 3 ( ?<d3), negue-o ( _d).
  • Caso contrário, verifique se é 12 ( q12d) e multiplique o booleano por 15 ( *15). O resultado é 15 para rainhas e 0 para qualquer outra coisa.
• Concatene as listas ( +). A lista resultante agora contém as pontuações dos números não emparelhados (a primeira parte) e os cartões especiais A, 2, Q (a segunda parte), com alguns zeros extras.
• Por fim, pegue a soma do resultado ( s).

Solução alternativa de 25 bytes

-+s*L%/Qd2}3T*15/Q12s<#3Q

Isso funciona de maneira semelhante à primeira, mas conta as rainhas separadamente e nega os ases e duplas com um filtro.

Python 2, 72 70 bytes

f=lambda x,*T:[x*(-1)**T.count(x),~x%2*15,-x][(x-3)/8]+(T>()and f(*T))

A certa altura, desejei que o Python 0**0 == 0fosse tratado pela primeira vez para que eu pudesse fazê-lo (-condition)**num. Ligue como f(11, 10, 3, 1, 2, 2).

Versão anterior de 72 bytes:

f=lambda x,*T:[~x%2*15,x*(-1)**(x<3or T.count(x))][x<11]+(T>()and f(*T))

> <> , 63 57 56 + 2 = 65 59 58 bytes

Os números de entrada devem estar na pilha no início do programa, portanto, +2 bytes para o -vsinalizador. Experimente online!

</!?lp6$+1g6:
3\0
?\::6g2%*{+}1+:b=
;\~16g-26g2*-c6gf*+n

Como todos os valores não utilizados no campo de código são inicializados 0, ele pode ser usado para determinar quantos de cada valor estão presentes na pilha, obtendo o valor em [value,6], incrementando-o e colocando-o novamente no campo de código. O total é então calculado como:

T = 0 + {for x in 3 to 10, x*([x,6]%2)} - [1,6] - 2*[2,6] + 15*[12,6]

Editar: tirou 6 bytes de golfe reestruturando a entrada e alternando as etapas de cálculo. Versão anterior:

:6g1+$6pl0=?\
/-*2g62-g610/
c ;n$\
6:b=?/>::6g2%*{+}1+!
\gf*+3/

Edit 2: economizou 1 byte, graças ao Sp3000

MATL , 27 26 bytes

3:10=s2\7M*G12=15*Gt3<*_vs

A entrada é uma matriz de colunas, ou seja, os valores são separados por ponto e vírgula.

Experimente online! ou verifique todos os casos de teste (isso adiciona um loop para receber todas as entradas e é substituído Gpor 1$0Gpara enviar por entrada mais recente).

Explicação

3:10=    % Take input implicitly. Compare with range [3 4 ... 10], with broadcast
s        % Sum of each column: how may threes, fours, ... tens there are
2\       % Modulo 2
7M       % Push [3 4 ... 10] again
*        % Element-wise multiply (the sum of this array is the score of 3...10)
G        % Push input again
12=      % Compare with 12, element-wise
15*      % Multiply by 15 (this is the score of 12)
G        % Push input again
t3<      % Duplicate. True for entries 1 or 2
*_       % Multiply and negate (the sum of this array is the score of 1, 2)
v        % Concatenate all stack concents into a vertical array
s        % Sum of array. Implicitly display

Pitão - 37 36 35

Isso parece muito grande, mas FGITW.

J<#h;K-QS2++*15/K12sm*d%/Jd2{J_s@S2

Conjunto de Teste .

JavaScript (ES6), 63 bytes

a=>a.map(e=>r+=e<3?-e:e>10?e-12?0:15:(m[e]^=1)?e:-e,r=0,m=[])|r

Ou se você preferir,

a=>a.map(e=>r-=e<3?e:e>10?e-12?0:-15:(m[e]^=1)?-e:e,r=0,m=[])|r

Perl 5 , 74 +1 ( -a) = 75 bytes

map$s+=/12/?15:$_<3?-$_:$_<11?$k{$_}?-delete$k{$_}:($k{$_}=$_):0,@F;say $s

Experimente online!

Perl 5.10.0 + -n, 115 64 60 56 bytes

$p+=$_-12?$_>2?$_<11?++$l[$_]%2?$_:-$_:0:-$_:15}{say$p

Experimente online!

Explicação:

Adicionando o -nloop ao seu redor:

# Used variables:
# $_: input (auto)
# $p: points
# $l[n]: number of occurences of n (for 3-10)
while (<>) { # for every input
    $p += $_ - 12 ? # if the input is not 12 (queen) ...
        $_ > 2 ? # then: if it's > 2 (not ace or 2) ...
            $_ < 11 ? # then: if < 11 (3-10) ...
                ++$l[$_] % 2 ? # then: if it's an odd occurence (1st, 3rd, 5th, ...)
                    $_ # add it
                    : -$_ # else subtract it
            : 0 # no points for other stuff (J, K)
        : -$_ # negative points for ace and 2
    : 15 # 15 points for queen
}
{ # after input:
    say $p # output points
}