introduzione

Briscola è uno dei giochi di carte più popolari in Italia. È un gioco di carte divertente come Bridge. Briscola è ben nota per il suo bizzarro sistema di punti. In questa sfida, date due carte, otterrai se il primo segna più, meno o lo stesso numero di punti del secondo nel sistema a punti di Briscola.

Sfida

Briscola si gioca con un mazzo di carte da gioco italiane. Ci sono quaranta carte in un mazzo, 1-10 in ciascuno dei quattro semi: coppe, spade, fiori e monete. Ignoreremo i semi per questa sfida. Le carte 2 - 7 sono le carte numeriche e le carte 8, 9 e 10 sono le figure. La classifica delle carte, dalla più alta alla più bassa, sono:

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

Grazie a Orphevs per il bel tavolo! :)

Il tuo compito è quello di creare un programma o una funzione completi che accetta due numeri 1-10 che rappresentano i ranghi delle carte e restituisce (o restituisce) se il valore in punti della prima carta è maggiore di, minore di o uguale al valore in punti del seconda carta. Note aggiuntive:

• Il programma può generare tre valori qualsiasi per indicare minore di, maggiore di e uguale a, tuttavia, deve emettere lo stesso valore per ogni condizione ogni volta.
• Il programma può utilizzare qualsiasi impostazione predefinita IO .
• Le scappatoie standard non sono ammesse.
• È consentita una funzione completa o un programma.

• Questa domanda è code-golf , quindi vince il conteggio di byte più basso.

• Ecco alcuni input e output di esempio:

   1, 4 => più di (l'asso segna 11 punti, 4 segna 0 punti, il primo è più del secondo.
   8, 3 => minore di (8 punteggi 2, 3 punteggi 10, il primo è inferiore al secondo.
   5, 2 => uguale (5 e 2 segnano entrambi 0)

Se avete domande, non esitate a chiedere. In bocca al lupo!

Gelatina , 12 11 byte

“®µ½¤¢‘iⱮIṠ

Provalo online!

• -1 byte usando il metodo di Luis Mendo .

Uscite 0per uguale, -1per maggiore di e 1per minore di. Utilizza l'indice della tabella codici “®µ½¤¢‘che valuta [8, 9, 10, 3, 1].

Accetta input come una coppia di carte. Usa 1,2come esempio.

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

[DEXIl]&mdZS

L'input è un array di due numeri. L'output è e -1, rispettivamente, per più di , uguale o minore di .01

Provalo online!

Spiegazione

Considera l'input [1 4]come esempio.

[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 byte

Prende i due gradi nella sintassi del curry (a)(b). Restituisce 1 per più di , -1 per meno di o 0 per uguale .

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

Provalo online!

Utilizzando una formula, 48 byte

Questo è sicuramente più lungo rispetto all'utilizzo di una tabella di ricerca, ma anche un po 'più interessante.

Stesso formato I / O.

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

Provalo online!

Come?

Poiché molte carte hanno un valore pari a , vogliamo prima mascherarle. Dato un rango di carta , calcoliamo:$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

Vogliamo ora trasformare i rimanenti valori diversi da zero in modo tale che possano essere ordinati nell'ordine corretto. Noi usiamo:

    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 byte

• 1 => più di
• -1 => inferiore a
• 0 => uguale

£"78920"bXÉÃr- g

Provalo online!

Japt -g , 13 byte

Uscite -1per >, 1per <e 0per ===.

m!b#ù991ìD)rn

Provalo o esegui più test (la seconda riga replica la funzionalità del -gflag per consentire ai flag di essere utilizzati per elaborare più input)

Spiegazione

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

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

Provalo online!

• -6 byte grazie al suggerimento di @JayCe per passare al programma completo anziché alla funzione

Il programma ritorna 2per 'greater than', 1per 'less than', 1.5per'equal'

Spiegazione :

      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 byte

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

Lambda prendendo i parametri nella sintassi del curry, porta della risposta JavaScript di Arnauld .

Restituisce 0.0 uguale , 1.0per maggiore di e -1.0per minore di . Provalo online qui .

Grazie a Kevin Cruijssen per il golf 3 byte.

MarioLANG , 578 548 530 byte

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

Provalo online!

Spiegazione:

• Il primo grande castello legge un numero di carta come input e calcola il suo valore in punti equivalente fino a quando non legge un 0(nessun input). Questo suppone che ci saranno solo due valori strettamente positivi come input.
• Si noti che in realtà non ho impostato i valori dei punti corretti in quanto non sono necessari, ho semplicemente impostato come valore del punto un numero tra [1-5]per aiutare a calcolare quale carta ha il maggior numero di punti.
• Il secondo, piccolo castello confronta solo i due valori dei punti calcolati.
• Restituisce 1se il primo valore del punto è maggiore del secondo, -1se il secondo valore del punto è maggiore del primo e 0se i valori del punto sono uguali.

Python 2 , 41 byte

Emette 1 per più di, -1 per meno di, 0 per uguale.

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

Provalo online!

C (gcc) , 57 byte

Restituisce il solito [-1..1] per <, = e>, rispettivamente.

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

Provalo online!

05AB1E , 14 byte

ε78920S>sk}`.S

Resi 1, -1o 0per più di; meno di; o uguale rispettivamente.

Provalo online o verifica tutti i casi di test .

Spiegazione:

ε              # 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 byte

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

Provalo online!

Per eseguirlo:

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

Esempio:

php -n briscola_score.php 3 1

Nota: questo codice utilizza l'operatore dell'astronave di PHP 7 . Quindi non funzionerà su nessuna versione di PHP prima del 7.

Produzione:

• 1 = più di ( card1 > card2)
• 0 = uguale ( card1 == card2)
• -1 = meno di ( card1 < card2)

Come?

Come l'approccio utilizzato in molte altre risposte, ma in PHP. Crea una mappa dei valori per le carte e confronta i valori delle carte da essa. La posizione del valore nella mappa è uguale al numero della carta.

Javascript ES2016 +, 73 caratteri

Non il più breve, ma spero interessante a causa di matematica e overflow :)

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

E l'altra versione con 74 caratteri, purtroppo:

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

Test

Aprire la console del browser prima di eseguire

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