Escreva um código para determinar quem ganha um truque de quatro cartas em um jogo de espadas . Menos bytes ganha.

A entrada é uma sequência que lista as quatro cartas jogadas em sequência como TH QC JH 2H(Dez de Copas, Rainha de Paus, Valete de Copas, Dois de Copas). Uma carta é dada por dois caracteres: um naipe CDHSe um valor de 23456789TJQKA. Você está garantido que a entrada é válida e os cartões são distintos.

Você deve gerar um número 1, 2, 3 ou 4 para o vencedor do truque. No exemplo TH QC JH 2H, o valete de copas vence o truque, então você deve imprimir 3.

Sua entrada e saída devem ser exatamente como descritas, exceto as novas linhas finais são opcionais.

Aqui estão as regras do Spades para ganhar um truque. A carta vencedora é a mais alta das quatro, com algumas ressalvas. Espadas é o trunfo , então qualquer pá supera qualquer outra que não seja pá. O naipe da primeira carta jogada é o naipe principal e somente as cartas desse naipe ou espadas são elegíveis para vencer o truque. As cartas do mesmo naipe são comparadas por seus valores, que são dados em ordem crescente como 23456789TJQKA.

Casos de teste:

TH QC JH 2H
3
KC 5S QS 9C
3
QD 2D TD 5D
1
9S 5D AD QS
4
3D 4C 3H JH
1
9S 4S TS JS
4
5H 9H 2C AD
2
5S 4C 3H QD
1
2H 2S KH AH
2

Pitão, 28 27 25 bytes

J"KTAZ"hxcz)eo_XN+@z1JJcz

Experimente on-line: Demonstração ou Conjunto de Testes (os 4 primeiros caracteres são a construção do conjunto de testes)

Obrigado a @isaacg por um truque, que salvou 2 caracteres.

A idéia principal é modificar os caracteres de cada mão de maneira que a mão vencedora tenha o valor máximo.

Os valores das mãos 23456789TJQKAjá estão quase ordenados. Eu só tenho que substituir Tcom A, Kcom Te Acom Z, resultando em 23456789AJQSZ.

A ordem dos ternos CDHSnão é muito importante. S, o naipe mais poderoso, que já é o valor máximo. Importante é atribuir ao naipe de primeira mão o segundo valor mais poderoso. Então, eu traduzo esse processo para K.

Todas as mãos também devem ser lidas ao contrário, pois o naipe é mais poderoso que o valor.

                           implicit: z = input string
J"KTAZ"                    J = "KTAZ"
             o         cz  orders the hands N of split(z) by:
              _              the reversed of 
               XN+@z1JJ      N, where the values z[1]+J are replaced by J
            e              last element (winning hand)
        xcz)               index of the winning hand in split(z)
       h                   + 1

CJam, 34 33 bytes

lS/_{)2$0='S+\#\"TQKA"_$er+}$W>#)

Algoritmo

A lógica é simples. Tenho uma classificação personalizada, na qual priorizo ​​primeiro o segundo caractere que representa o naipe. Nisso, Spades obtém a maior prioridade e depois o primeiro conjunto lançado. Descanse todos são -1. Então eu classifico o primeiro caractere com a troca de Tcom Ae Qcom Kpara ter uma classificação lexical.

Explicação do código

Primeiro, vamos ver qual é a ordem lexical dos valores de face dos cartões:

"23456789TJQKA"$

23456789AJKQT

Portanto, todos os números estão na posição correta. Jtambém está na posição correta. Precisamos trocar Ke Qe Je Aobter ordem lexical.

lS/_{)2$0='S+\#\"TQKA"_$er+}$W>#)
lS/                                 "Read an input line and split on spaces";
   _{                      }$       "Copy the array and sort it using this custom logic";
     )                              "Take off the last character of each hand.";
      2$0=                          "Get the suit of the first hand";
          'S+                       "Add Spades suit to it";
             \#                     "Get the index of the current hand suit.
                                     1 for Spades, 0 for first hand suit, -1 otherwise";
               \                    "Put face value of this hand on top of stack";
                "TQKA"              "Put string TQKA on stack";
                      _$            "Copy and sort. This essentially reverses the string
                                     TQKA to form AKQT. This is 1 byte shorter than _W%";
                        er+         "Swap T with A and K with Q and add to the
                                     suit index calculated previously";
                                    "After the above tuple, sorting will automatically
                                     convert the tuple to string and sort lexically";
                             W>     "Get the array containing only the last element";
                               #)   "Get the index of this hand in original set and
                                     increment to convert it to 1 based";

Experimente online aqui

JavaScript (ES6), 112

Digitalize a lista e retorne a posição do valor mais alto encontrado.

Execute o snippet para testar (no Firefox)

F=t=>t.split(' ').map((c,i)=>(n='23456789TJQKA'.search(c[0])+(c[1]>'H'?40:c[1]==t[1]&&20))>m&&(m=n,r=i+1),m=0)|r

C.innerHTML=['TH QC JH 2H','KC 5S QS 9C','QD 2D TD 5D','9S 5D AD QS','3D 4C 3H JH','9S 4S TS JS','5H 9H 2C AD','5S 4C 3H QD'].map(h=>h+' -> '+F(h)).join('\n')

<pre id=C></pre>

Perl, 73 bytes

#!perl -pl
/\B./;s/$&/P/g;y/TKA/IRT/;$_=reverse;@a=sort split;/$a[-1]/;$_=4-"@-"/3

Experimente- me .

Converte os nomes das cartas para que a ordem do valor do jogo siga a ordem alfabética, depois escolhe a mais alta por classificação e a procura na string original para a posição.

Ruby, 59 + 2 = 61

Com sinalizadores de linha de comando na, execute

p (1..4).max_by{|i|$F[i-1].tr($_[1]+'SJQKA','a-z').reverse}

J, 47 bytes

1+[:(i.>./)_3+/\16!@-]i.~'SXAKQJT9876543'1}~1&{

Uso:

   (1+[:(i.>./)_3+/\16!@-]i.~'SXAKQJT9876543'1}~1&{) 'TH QC 9S 8S'
3

Método:

• Para cada caractere de entrada, atribuímos um valor com base em sua posição na 'S[second char of input]AKQJT9876543'string. Caracteres não encontrados obtêm o valor last position + 1implicitamente. Caracteres adicionais têm muito menos valor ( value=(16-position)!).
• Calcule a soma dos três trigêmeos de entrada e um dupleto (por exemplo, TH_ QC_ 9S_e 8S).
• Escolha o índice baseado em 1 do valor máximo.

(J infelizmente não é possível comparar caracteres ou seqüências de caracteres diretamente. Ele só pode verificar sua igualdade, o que descartou outras abordagens para esse desafio.)

Experimente online aqui.

C #, 237

using System;namespace S{class P{static void Main(string[] a){var V="23456789TJQKA";int x=0;int y=0;var z=a[0][1];for(int i=0;i<4;i++){int q=V.IndexOf(a[i][0])+2;var w=a[i][1];q*=w==z?1:w=='S'?9:0;if(q>y){x=i;y=q;}}Console.Write(x+1);}}}

Como funciona: itere cada mão para calcular o "valor" do cartão. Armazene o índice mais alto. O valor de uma carta é determinado como a classificação da carta multiplicada por 0 se não for uma pá ou o naipe de abertura, 1 se for a naipe de abertura e 9 se for uma pá, mas não o naipe de abertura. (9 escolhido b / c 2 * 9 = 18> A = 14 e 9 é um único caractere)

Pitão, 36 33 bytes

KczdhxKeo,x,ehK\SeNXhN"TKA""AYZ"K

Uma abordagem bastante direta, usa a classificação com uma função de tecla personalizada e, em seguida, localiza o índice do valor mais alto.

Pitão, 31 bytes

hxczdeo}\SNo}@z1Zox"TJQKA"hNScz

Experimente aqui.

Como funciona:

A maneira correta de ler este procedimento é voltar à frente. O procedimento classifica o cartão desejado até o final da lista, depois o puxa e encontra seu índice na lista original.

• cz: Isso gera a lista de sequências de cartas. c, chop, normalmente é uma função binária (arity 2), mas quando chamada em apenas uma entrada, serve como .split()método de string.

• S: Aplica o comportamento normal de classificação, que classifica cartões numerados mais baixos antes dos cartões mais altos.

• ox"TJQKA"hN: Solicita os cartões pelo índice ( x) na sequência "TJQKA"da primeira letra do cartão ( hN). Para cartões com números, a primeira letra não é encontrada, fornecendo o resultado -1. Como a função de classificação de Pyth é estável, a ordem dos cartões numerados não é afetada.

• o}@z1Z: Em seguida, ordenamos se o naipe da primeira carta jogada ( @z1) está na carta em questão. Como está Trueatrasado False, isso envia cartas do naipe principal para trás.

• o}\SN: É o mesmo que o tipo anterior, mas classifica se a carta Sestá no cartão, enviando espadas para trás.

• hxczde: Extrai a última carta classificada desta maneira ( e), encontra seu índice na lista de cartas ( xczd) e aumenta em 1 ( h), fornecendo a localização desejada para o jogador.