Introdução

Briscola é um dos jogos de cartas mais populares da Itália. É um jogo de cartas complicado, como o Bridge. Briscola é bem conhecida por seu sistema de pontos bizarro. Neste desafio, com duas cartas, você produzirá se a primeira marca mais, menos ou o mesmo número de pontos que a segunda no sistema de pontos de Briscola.

Desafio

Briscola é jogado com um baralho de cartas italianas. Há quarenta cartas em um baralho, de 1 a 10 em cada um dos quatro naipes: copos, espadas, tacos e moedas. Nós estaremos ignorando os processos para este desafio. Os cartões 2 - 7 são os cartões numéricos e os cartões 8, 9 e 10 são os cartões de face. A classificação das cartas, da maior para a menor, é:

 +------------------------+-------------+
 |     Cards, by Rank     | Point Value |
 +------------------------+-------------+
 | Ace (1)                |     11      |
 | Three (3)              |     10      |
 | King (10)              |      4      |
 | Knight (9)             |      3      |
 | Jack (8)               |      2      |
 | Numeric Cards (2, 4-7) |      0      |
 +------------------------+-------------+

Obrigado a Orphevs pela boa mesa! :)

Sua tarefa é criar um programa ou função completa que aceite dois números de 1 a 10, representando as fileiras da placa, e produza (ou retorne) se o valor em pontos da primeira placa é maior que, menor que ou igual ao valor em pontos da placa. segundo cartão. Notas Adicionais:

• Seu programa pode gerar três valores para indicar menor que, maior que e igual a, no entanto, deve gerar o mesmo valor para cada condição a cada vez.
• Seu programa pode usar quaisquer padrões de IO .
• As brechas padrão não são permitidas.
• É permitida uma função completa ou um programa.

• Esta questão é código-golfe , portanto, a menor contagem de bytes vence.

• Aqui estão algumas entradas e saídas de amostra:

   1, 4 => mais que (ás marca 11 pontos, 4 marca 0 pontos, o primeiro é mais que o segundo.
   8, 3 => menor que (8 pontos 2, 3 pontos 10, o primeiro é menor que o segundo.
   5, 2 => igual (5 e 2 pontuam 0)

Se você tiver alguma dúvida, não hesite em perguntar. Boa sorte!

Geléia , 12 11 bytes

“®µ½¤¢‘iⱮIṠ

Experimente online!

• -1 byte usando o método de Luis Mendo .

Saídas 0para igual, -1para maior que e 1para menos que. Usa o índice da página de código “®µ½¤¢‘que é avaliado [8, 9, 10, 3, 1].

Recebe entrada como um par de cartões. Use 1,2como exemplo.

“®µ½¤¢‘iⱮIṠ
“®µ½¤¢‘       [8,9,10,3,1]
       i      index of 
        Ɱ     each element in the input -> 5,0
         I    Finds the forward difference: 0-5 = -5.
          Ṡ   Sign -> -1.
                When ranks are equal, Ṡ returns 0 and when the rank of the second
                card is higher, Ṡ returns 1.

MATL , 12 bytes

[DEXIl]&mdZS

Entrada é uma matriz de dois números. A saída é e -1, respectivamente, para mais que , igual ou menor que .01

Experimente online!

Explicação

Considere a entrada [1 4]como um exemplo.

[DEXIl]    % Push [8 9 10 3 1]
           % STACK: [8 9 10 3 1] 
&m         % Implicit input. Index (1-based) of membership, 0 if not member
           % STACK: [5 0]
d          % Consecutive difference
           % STACK: -5
ZS         % Sign. Implicit display
           % STACK: -1

JavaScript (ES6), 42 bytes

Assume as duas fileiras em currying sintaxe (a)(b). Retorna 1 para mais que , -1 para menos que ou 0 para igual .

a=>b=>Math.sign((s="05040000123")[a]-s[b])

Experimente online!

Usando uma fórmula, 48 bytes

Definitivamente, é mais longo do que usar uma tabela de pesquisa, mas também um pouco mais interessante.

Mesmo formato de E / S.

a=>b=>Math.sign((g=n=>(1<<n&1802)*6%13)(a)-g(b))

Experimente online!

Quão?

Como muitos cartões têm o valor , primeiro queremos mascará-los. Dado um número de cartão , calculamos:$0$$n$

p = 2 N  e 

  n (card)   | 2**n | AND 1802
-------------+------+----------
  1 (Ace)    |    2 |      2
  2          |    4 |      0
  3 (Three)  |    8 |      8
  4          |   16 |      0
  5          |   32 |      0
  6          |   64 |      0
  7          |  128 |      0
  8 (Jack)   |  256 |    256
  9 (Knight) |  512 |    512
 10 (King)   | 1024 |   1024

Agora, queremos transformar os demais valores diferentes de zero, de forma que possam ser classificados na ordem correta. Nós usamos:

    p (card)   |   6p | MOD 13
---------------+------+--------
    2 (Ace)    |   12 |   12
    8 (Three)  |   48 |    9
  256 (Jack)   | 1536 |    2     --> Ace > Three > King > Knight > Jack
  512 (Knight) | 3072 |    4
 1024 (King)   | 6144 |    8

Japonês , 25 21 16 bytes

• 1 => mais que
• -1 => menor que
• 0 => igual

£"78920"bXÉÃr- g

Experimente online!

Japonês -g , 13 bytes

Saídas -1para >, 1para <e 0para ===.

m!b#ù991ìD)rn

Experimente ou execute vários testes (a segunda linha replica a funcionalidade do -gsinalizador para permitir que os sinalizadores sejam usados ​​para processar várias entradas)

Explicação

                   :Implicit input of 2 integer array
m                  :Map
   #ù991           :  249991
        ìD         :  Convert to array of base-13 digits = [8,9,10,3,1]
 !b                :  Get the index of the current element in that
          )        :End map
           rn      :Reduce by subtraction
                   :Implicitly output the sign of the result

R , 35 bytes

rank(c(6,0,5,1:4*0,1:3)[scan()])[1]

Experimente online!

• -6 Bytes graças à sugestão @JayCe de mudar para o programa completo em vez da função

O programa retorna 2para 'greater than', 1por 'less than', 1.5para'equal'

Explicação:

      c(6,0,5,1:4*0,1:3)[v]          # extract the score of each card in v (got from scan());
                                     # cards in v are used as indexes in the cards rank 
                                     # vector, which is based on briscola scores vector 
                                     # c(11,0,10,0,0,0,0,2,3,4) but divided by 2 and rounded 
                                     # to integer preserving the original order

rank(                      )[1]      # rank returns : c(1,  2)   if v[1] < v[2]
                                     #                c(2,  1)   if v[1] > v[2]
                                     #                c(1.5,1.5) if v[1] == v[2]
                                     # and we select the first value

Java 8, 69 66 bytes

a->b->Math.signum("05040000123".charAt(a)-"05040000123".charAt(b))

Lambda usando parâmetros na sintaxe de curry, porta da resposta JavaScript de Arnauld .

Devoluções 0.0 igual , 1.0para maior do que , e -1.0para menos de . Experimente online aqui .

Agradecimentos a Kevin Cruijssen por jogar 3 bytes.

MarioLANG , 578 548 530 bytes

 )                    <
 ====================="
                   >-[!)
                   "==#)
                >-[!)) )
                "==#=) +
         >-----[!))) + +
         "======#==  + +
     >--[!)))   ++++              -(- <
     "===#===================    ====="
  >-[!)))+++++                    >) [!)+:
; "==#=======================     "===#===
>[!                      )))[!((>[!)[!):
"=#==========================#====#==#===
!;((                         <       >)-:
#============================"       "===

Experimente online!

Explicação:

• O primeiro, grande castelo, lê um número de cartão como entrada e calcula seu valor equivalente em pontos até ler a 0(sem entrada). Isso supõe que haverá apenas dois valores estritamente positivos como entrada.
• Observe que, na verdade, não defino os valores de pontos adequados, pois eles não são necessários; apenas defina como valor de ponto um número entre eles [1-5]para ajudar a calcular qual cartão tem mais valores de pontos.
• O segundo castelo pequeno apenas compara os dois valores de pontos calculados.
• Retorna 1se o valor do primeiro ponto for maior que o segundo, -1se o valor do segundo ponto for maior que o primeiro e 0se os valores do ponto forem iguais.

Python 2 , 41 bytes

Saídas 1 para mais que, -1 para menos que, 0 para igual.

lambda a,b:cmp(s[a],s[b])
s="05040000123"

Experimente online!

C (gcc) , 57 bytes

Retorna o usual [-1..1] para <, = e>, respectivamente.

char*s="-FAEAAAABCD";f(a,b){a=s[a];b=s[b];b=(a>b)-(a<b);}

Experimente online!

05AB1E , 14 bytes

ε78920S>sk}`.S

Retorna 1, -1ou 0por mais de; Menor que; ou igual, respectivamente.

Experimente online ou verifique todos os casos de teste .

Explicação:

ε              # Loop over the input-array
 78920S>       #  Convert 78920 to a list of digits, and increase each by 1,
               #  resulting in [8,9,10,3,1]
        sk     #  Index this list with the input-number (-1 if not found)
               #   i.e. [1,4] → [4,-1]
          }    # Stop the loop
`              # Put all items of the now mapped list separated onto the stack
 .S            # Take the signum (1 if a>b; -1 if a<b; 0 if a==b)
               #  i.e. 4 and -1 → 1

PHP , 51 45 bytes

<?=($m=_5040000123)[$argv[1]]<=>$m[$argv[2]];

Experimente online!

Para executá-lo:

php -n <filename> <card1> <card2>

Exemplo:

php -n briscola_score.php 3 1

Nota: Este código usa o operador de espaçonave do PHP 7 . Portanto, não funcionará em nenhuma versão do PHP antes do 7.

Resultado:

• 1 = mais que ( card1 > card2)
• 0 = igual ( card1 == card2)
• -1 = menor que ( card1 < card2)

Quão?

Igual à abordagem usada em muitas outras respostas, mas em PHP. Cria um mapa de valores para cartões e compara os valores dos cartões. A posição do valor no mapa é igual ao número do cartão.

Javascript ES2016 +, 73 caracteres

Não é o mais curto, mas espero interessante devido à matemática e estouro :)

(x,y)=>Math.sign((x&8?x:(16-(x**40|0)%7)^16)-(y&8?y:(16-(y**40|0)%7)^16))

E a outra versão com 74 caracteres, infelizmente:

(x,y)=>eval('(x>y)-(x<y)'.replace(/\w/g,'($&&8?$&:(16-($&**40|0)%7)^16)'))

Teste

Abra o console do navegador antes de executar

f=(x,y)=>Math.sign((x&8?x:(16-(x**40|0)%7)^16)-(y&8?y:(16-(y**40|0)%7)^16))
console.table(Array(11).fill().map((x,i)=>Array(11).fill().map((x,j)=>f(i,j))))