Golfe Golfe!

Este é o meu primeiro desafio, por favor, seja gentil! O desafio é escrever um programa que produza a pontuação correta para um layout no jogo de cartas "Golf".

O jogo de cartas Golf tem muitas variações. As regras da casa que eu uso seguem as regras padrão do Six-Card Golf fornecidas por Pagat, com uma pequena diferença. Já existe um desafio semelhante aqui, mas acho que este é mais interessante porque exige que você leve em consideração a orientação dos cartões.

Cada jogador tem um layout de cartões 2x3. No final de cada rodada, todas as cartas são viradas para cima e pontuadas da seguinte forma:

• Cada ás conta 1 ponto.
• Cada dois conta menos dois pontos.
• Cada cartão numérico de 3 a 10 pontua o valor nominal.
• Cada Valete ou Rainha ganha 10 pontos.
• Cada rei marca zero pontos.
• Um par de cartas iguais na mesma coluna obtém zero ponto na coluna (mesmo que as cartas iguais sejam dois).
• Um conjunto de três cartas iguais na mesma linha obtém zero ponto na linha (mesmo que as cartas iguais sejam dois).

Entrada

A entrada pode ser uma string ou matriz de qualquer tipo.

Resultado

Um número inteiro representando a pontuação da mão Golf.

Exemplos

Esses exemplos usam a notação, A23456789TJQKmas você não precisa usá-la em sua resposta.

Layout
AK3
J23

Score
9
-----------------------    
Layout
25Q
25J

Score
20
-----------------------        
Layout
T82
T8A

Score
-1
-----------------------        
Layout
QQQ
234

Score
5
-----------------------        
Layout
TJQ
QTJ

Score
60
-----------------------
Layout
888
382

Score
1
-----------------------
Layout
888
888

Score
0

Isso é código de golfe, então a resposta mais curta em bytes vence!

Geléia , 9 bytes

n/aEÐḟẎḞS

Experimente online!

-1 graças a Jonathan Allan .

[[A, B, C], [D, E, F]]AF$(1,-2,3,4,5,6,7,8,9,10,10.1,10.2,0)$$A,2,3,4,5,6,7,8,9,T,J,Q,K$

Haskell , 107 103 98 bytes

f m=sum[min 10k|r<-m,o<-m,any(/=r!!0)r,(j,x)<-zip o r,j/=x,(k,c)<-zip[-2..]"2 KA 3456789TJQ",c==x]

Experimente online!

Aproveita o fato de haver apenas duas linhas. Nós repetimos a iteração sobre as linhas que seguem uma linha re outra o. Quando eles estão na mesma linha o resultado será sempre zero (devido ao matching "colunas") de modo que só irá considerar as duas iterações em que re oreferem-se a linhas distintas. Eu zerar as linhas verificando primeiro se alguma entrada na linha não é igual à primeira. Se a linha for toda igual, isso será falso e a lista estará vazia, com uma soma de 0. Caso contrário, eu fecho esta linha com a outra e repito sobre os pares que não são iguais (isso zera as colunas iguais de maneira semelhante) maneira). Finalmente, indexo uma lista de classificações de cartas começando com -2 preenchimento com espaços, conforme necessário, para mapear cada classificação para sua pontuação. Eu só tenho que usarmin 10 fixar esse índice para fazer valetes e rainhas custa 10 em vez de 11 e 12.

EDIT: obrigado a @xnor por descolar 4 bytes! Eu não sabia que você poderia colocar identificadores diretamente após números literais, isso é muito legal!

EDIT2: Agradecemos novamente a @xnor por mais 5 bytes! Ótima idéia para percorrer as linhas assim

Carvão , 50 bytes

Ｆ²⊞υＳ≔⁰ζＦ⭆υΦι∧⊙ι¬⁼λν⊙υ¬⁼λ§νμ≡ι2≧⁻²ζA≦⊕ζKω≧⁺∨ΣιχζＩζ

Experimente online! Link é a versão detalhada do código. Explicação:

Ｆ²⊞υＳ

Leia o layout em uma matriz.

≔⁰ζ

Inicialize a pontuação para zero.

Ｆ⭆υΦι∧⊙ι¬⁼λν⊙υ¬⁼λ§νμ

Filtre a entrada, removendo caracteres que sejam iguais a todos os caracteres em sua linha ou coluna.

≡ι

Alterne cada caractere restante.

2≧⁻²ζ

2pontuações -2.

A≦⊕ζ

Apontuações 1. (Esses 4 bytes podem ser removidos se forem 1usados ​​para indicar 1, mas IMHO é um abuso do formato de entrada.)

Kω

Não faça nada por K.

≧⁺∨Σιχζ

Caso contrário, os dígitos pontuam seu valor e as outras letras 10.

Ｉζ

Transmitir a soma para string para impressão implícita.

J , ³⁹ 28 bytes

[:+/@,]<.@*]+:&(1=#@~.)"1/|:

Experimente online!

Agradecemos a Erik the Outgolfer e Jonathan Allen pela idéia de codificação de entrada.

explicação

Uma solução muito "J". Vou explicar pelo exemplo ...

Vamos dar a entrada:

AK3
J23

e aplique esta codificação:

┌─┬──┬─┬─┬─┬─┬─┬─┬─┬──┬────┬────┬─┐
│A│2 │3│4│5│6│7│8│9│T │J   │Q   │K│
├─┼──┼─┼─┼─┼─┼─┼─┼─┼──┼────┼────┼─┤
│1│_2│3│4│5│6│7│8│9│10│10.1│10.2│0│
└─┴──┴─┴─┴─┴─┴─┴─┴─┴──┴────┴────┴─┘

que produz:

   1  0 3
10.1 _2 3

Vejamos a primeira parte da solução, delineando alguns detalhes para começar:

] (...)"1/ |:

Isso diz que pegue a entrada ]e sua transposição |:e crie uma "tabela de multiplicação" de todas as combinações, exceto que, em vez da multiplicação, aplicaremos o verbo entre parênteses. O "1especificador de classificação garante que tomemos todas as combinações de linhas de ambos os argumentos, mas como as linhas da transposição são as colunas da matriz original, isso significa que usaremos todas as combinações de linhas e colunas. Ou seja, estaremos fazendo:

  Rows                            Cols
┌─────────┐                     ┌──────┐
│1 0 3    │                     │1 10.1│
├─────────┤  "times" table      ├──────┤
│10.1 _2 3│                     │0 _2  │
└─────────┘                     ├──────┤
                                │3 3   │
                                └──────┘

which produces:

┌───────────────────────┬─────────────────────┬────────────────────┐
│┌─────┬────┬──────┐    │┌─────┬────┬────┐    │┌─────┬────┬───┐    │
││1 0 3│verb│1 10.1│    ││1 0 3│verb│0 _2│    ││1 0 3│verb│3 3│    │
│└─────┴────┴──────┘    │└─────┴────┴────┘    │└─────┴────┴───┘    │
├───────────────────────┼─────────────────────┼────────────────────┤
│┌─────────┬────┬──────┐│┌─────────┬────┬────┐│┌─────────┬────┬───┐│
││10.1 _2 3│verb│1 10.1│││10.1 _2 3│verb│0 _2│││10.1 _2 3│verb│3 3││
│└─────────┴────┴──────┘│└─────────┴────┴────┘│└─────────┴────┴───┘│
└───────────────────────┴─────────────────────┴────────────────────┘

Agora verb, aplicamos a cada um desses combos +:&(1=#@~.)e esse verbo retornará false se "qualquer argumento consistir em um único item repetido" e true, caso contrário. Isso é feito pegando o nub, ou uniq ~., perguntando se seu comprimento é um 1=#e pegando o nem do resultado +:.

Ou seja, isso retornará uma máscara booleana com a mesma forma que a matriz de entrada, mas com zeros para qualquer item em uma linha ou coluna de todos os itens iguais.

1 1 0
1 1 0

Agora, simplesmente mutliply a matriz original por esta máscara e tomar a palavra ]<.@*:

1   0 0
10 _2 0

e achatar e somar o resultado disso: +/@,

9

JavaScript (ES6),  97 95  93 bytes

Recebe a entrada como uma matriz de 2 matrizes de 3 caracteres.

a=>a.map((r,i)=>r.map((c,j)=>t-=c!=a[i^1][j]&r!=c+[,c,c]?{K:[],2:2,A:-1}[c]||-c||~9:0),t=0)|t

Experimente online!

Comentado

a =>                        // a[] = input
  a.map((r, i) =>           // for each row r[] at position i:
    r.map((c, j) =>         //   for each card c at position j in r[]:
      t -=                  //     update t:
        c != a[i ^ 1][j] &  //       if c is not equal to the sibling card in the other row
        r != c + [, c, c] ? //       and r is not made of 3 times the same card:
          { K: [],          //         add 0 point for a King (but [] is truthy)
            2: 2,           //         subtract 2 points for a Two
            A: -1           //         add 1 point for an Ace
          }[c]              //
          || -c             //         or add the face value
          || ~9             //         or add 10 points (Jack or Queen)
        :                   //       else:
          0                 //         add nothing
    ),                      //   end of inner map()
    t = 0                   //   start with t = 0
  ) | t                     // end of outer map; return t

Japonês , 22 bytes

c xÈf *YgUïUÕ me_â Ê>1

Tente

PHP , 145 109 bytes

Depois de usar a A23456789TJQKcodificação padrão para entradas e não obter um bom resultado, passei a usar essa codificação semelhante a outras respostas:

A |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |  T |    J |    Q | K
1 | -2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 10.1 | 10.2 | 0

A entrada é uma matriz bidimensional neste formato: [[1,0,3],[10.1,-2,3]]. Basicamente, verifica se a linha (usando mine max) e a coluna de cada cartão não contêm valores iguais e, em seguida, adiciona o valor do cartão à pontuação total e, no final, imprime a parte inteira da pontuação total.

function($a){for(;$x++<2;)for($i=3;$i--;)min($r=$a[$x-1])-max($r)&&$r[$i]-$a[$x%2][$i]&&$s+=$r[$i];echo$s^0;}

Experimente online! (Nota: o TIO para PHP está quebrado no momento, devido a uma atualização incorreta da versão, mas deve voltar OK)

Python 3 , 79 bytes

lambda d:sum([({*a}!={x}!={y})*int(x)for a,b in(d,d[::-1])for x,y in zip(a,b)])

Experimente online!

$1,-2,3,4,5,6,7,8,9,10,10.1,10.2,0$

Python 3 , 118 bytes

Formato de entrada mais legível

lambda d:sum([({*a}!={x}!={y})*[10,10,10,1,0,-2,int(x,36)]['TJQAK2'.find(x)]for a,b in(d,d[::-1])for x,y in zip(a,b)])

Experimente online!

Kotlin , 159 bytes

O Lambda aceita 1.3456789TJQ0 como entrada. O código externo usa A23456789TJQK como entrada, converte o ás, dois e rei para que a matemática funcione e exibe as cartas e a pontuação.

{d:List<String>->Int
var s=0
for(r in 0..1)for(c in 0..2)if((d[r][0]!=d[r][1]||d[r][1]!=d[r][2])&&d[0][c]!=d[1][c]){
val n=d[r][c]-'0'
s+=if(n>9)
10
else
n}
s}

Experimente online!