Introducción

Briscola es uno de los juegos de cartas más populares de Italia. Es un juego de cartas con trucos, como Bridge. Briscola es bien conocida por su extraño sistema de puntos. En este desafío, con dos cartas, obtendrá si la primera obtiene más, menos o el mismo número de puntos que la segunda en el sistema de puntos de Briscola.

Desafío

Briscola se juega con una baraja de naipes italianos. Hay cuarenta cartas en una baraja, 1-10 en cada uno de los cuatro palos: tazas, espadas, garrotes y monedas. Ignoraremos los trajes para este desafío. Las tarjetas 2 - 7 son las tarjetas numéricas, y las tarjetas 8, 9 y 10 son las tarjetas faciales. La clasificación de las tarjetas, de mayor a menor, son:

 +------------------------+-------------+
 |     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      |
 +------------------------+-------------+

Gracias a Orphevs por la buena mesa! :)

Su tarea es crear un programa o función completa que acepte dos números del 1 al 10 que representen los rangos de las tarjetas, y genere (o devuelva) si el valor en puntos de la primera tarjeta es mayor, menor o igual que el valor en puntos del segunda tarjeta Notas adicionales:

• Su programa puede generar cualquiera de los tres valores para indicar menor, mayor que e igual a, sin embargo, debe generar el mismo valor para cada condición cada vez.
• Su programa puede utilizar cualquier defecto IO .
• Las lagunas estándar no están permitidas.
• Se permite una función completa o un programa.

• Esta pregunta es code-golf , por lo que gana el conteo de bytes más bajo.

• Aquí hay algunas entradas y salidas de muestra:

   1, 4 => más que (el as obtiene 11 puntos, 4 obtiene 0 puntos, el primero es más que el segundo.
   8, 3 => menor que (8 puntajes 2, 3 puntajes 10, el primero es menor que el segundo.
   5, 2 => igual (5 y 2 ambos puntúan 0)

Si tiene alguna pregunta, no dude en preguntar. ¡Buena suerte!

Jalea , 12 11 bytes

“®µ½¤¢‘iⱮIṠ

Pruébalo en línea!

• -1 byte utilizando el método de Luis Mendo .

Salidas 0para igual, -1para mayor que y 1para menor que. Utiliza el índice de página de códigos “®µ½¤¢‘que evalúa [8, 9, 10, 3, 1].

Toma entrada como un par de cartas. Úselo 1,2como ejemplo.

“®µ½¤¢‘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

La entrada es una matriz de dos números. La salida es -1, 0y 1respectivamente para más de , igual o menor que .

Pruébalo en línea!

Explicación

Considere la entrada [1 4]como un ejemplo.

[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

Toma las dos filas en sintaxis curry (a)(b). Devuelve 1 para más de , -1 para menos de o 0 para igual .

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

Pruébalo en línea!

Usando una fórmula, 48 bytes

Esto es definitivamente más largo que usar una tabla de búsqueda, pero también un poco más interesante.

Mismo formato de E / S.

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

Pruébalo en línea!

¿Cómo?

$0$$n$

  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

Ahora queremos transformar los valores restantes distintos de cero de tal manera que se puedan ordenar en el orden correcto. 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

Japt , 25 21 16 bytes

• 1 => más de
• -1 => menos de
• 0 => igual

£"78920"bXÉÃr- g

Pruébalo en línea!

Japt -g , 13 bytes

Salidas -1para >, 1para <y 0para ===.

m!b#ù991ìD)rn

Pruébelo o ejecute varias pruebas (la segunda línea replica la funcionalidad del -gindicador para permitir que los indicadores se utilicen para procesar múltiples entradas)

Explicación

                   :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]

Pruébalo en línea!

• -6 Bytes gracias a la sugerencia de @JayCe para cambiar al programa completo en lugar de la función

El programa devuelve 2para 'greater than', 1para 'less than', 1.5para'equal'

Explicación

      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 toma parámetros en la sintaxis curry, puerto de la respuesta JavaScript de Arnauld .

Devuelve 0.0 igual , 1.0para mayor que y -1.0para menor que . Pruébelo en línea aquí .

Gracias a Kevin Cruijssen por jugar al golf 3 bytes.

MarioLANG , 578 548 530 bytes

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

Pruébalo en línea!

Explicación:

• El primer castillo grande lee un número de tarjeta como entrada y calcula su valor de punto equivalente hasta que lee un 0(sin entrada). Esto supone que solo habrá dos valores estrictamente positivos como entrada.
• Tenga en cuenta que en realidad no establezco los valores de puntos adecuados, ya que no son necesarios, solo establezco como valor de punto un número intermedio [1-5]para ayudar a calcular qué tarjeta tiene la mayor cantidad de puntos.
• El segundo castillo pequeño solo compara los dos valores de puntos calculados.
• Devuelve 1si el primer valor de punto es mayor que el segundo, -1si el segundo valor de punto es mayor que el primero y 0si los valores de punto son iguales.

Python 2 , 41 bytes

Salidas 1 para más de, -1 para menos de, 0 para igual.

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

Pruébalo en línea!

C (gcc) , 57 bytes

Devuelve el [-1..1] habitual para <, = y>, ​​respectivamente.

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

Pruébalo en línea!

05AB1E , 14 bytes

ε78920S>sk}`.S

Devoluciones 1, -1o 0por más de; menos que; o igual respectivamente.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ε              # 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]];

Pruébalo en línea!

Para ejecutarlo:

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

Ejemplo:

php -n briscola_score.php 3 1

Nota: Este código usa el operador de nave espacial PHP 7 . Por lo tanto, no funcionará en ninguna versión de PHP anterior a la 7.

Salida:

• 1 = más que ( card1 > card2)
• 0 = igual ( card1 == card2)
• -1 = menos que ( card1 < card2)

¿Cómo?

Igual que el enfoque utilizado en muchas otras respuestas, pero en PHP. Crea un mapa de valores para tarjetas y compara los valores de las tarjetas a partir de ellas. La posición del valor en el mapa es la misma que el número de tarjeta.

Javascript ES2016 +, 73 caracteres

No es el más corto, pero espero que sea interesante debido a las matemáticas y el desbordamiento :)

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

Y la otra versión con 74 caracteres, desafortunadamente:

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

Prueba

Abra la consola del navegador antes de ejecutar

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))))