introduction

Briscola est l'un des jeux de cartes les plus populaires d'Italie. C'est un jeu de cartes astucieux, comme Bridge. Briscola est bien connue pour son système de points bizarre. Dans ce défi, compte tenu de deux cartes, vous obtiendrez si la première marque plus, moins ou le même nombre de points que la seconde dans le système de points de Briscola.

Défi

Briscola se joue avec un jeu de cartes à jouer italiennes. Il y a quarante cartes dans un jeu, 1-10 dans chacune des quatre couleurs: coupes, épées, massues et pièces. Nous ignorerons les combinaisons pour ce défi. Les cartes 2 à 7 sont les cartes numériques et les cartes 8, 9 et 10 sont les cartes face. Le classement des cartes, du plus haut au plus bas, est le suivant:

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

Merci à Orphevs pour la belle table! :)

Votre tâche consiste à créer un programme ou une fonction complète qui accepte deux nombres de 1 à 10 représentant les rangs des cartes et affiche (ou renvoie) si la valeur en points de la première carte est supérieure, inférieure ou égale à la valeur en points de la deuxième carte. Notes complémentaires:

• Votre programme peut générer trois valeurs quelconques pour indiquer inférieur à, supérieur à et égal à, cependant, il doit générer la même valeur pour chaque condition à chaque fois.
• Votre programme peut utiliser tous les paramètres par défaut IO .
• Les failles standard ne sont pas autorisées.
• Une fonction complète ou un programme est autorisé.

• Cette question est code-golf , donc le nombre d'octets le plus bas l'emporte.

• Voici quelques exemples d'entrées et de sorties:

   1, 4 => plus que (l'as réussit 11 points, 4 marque 0 points, le premier est plus que le second.
   8, 3 => moins de (8 scores 2, 3 scores 10, le premier est inférieur au second.
   5, 2 => égal (5 et 2 marquent tous les deux 0)

Si vous avez des questions, n'hésitez pas à demander. Bonne chance!

Gelée , 12 11 octets

“®µ½¤¢‘iⱮIṠ

Essayez-le en ligne!

• -1 octet en utilisant la méthode de Luis Mendo .

Sorties 0pour égal, -1pour supérieur et 1inférieur à. Utilise l'index de page de code “®µ½¤¢‘qui est évalué [8, 9, 10, 3, 1].

Prend l'entrée comme une paire de cartes. À utiliser 1,2comme exemple.

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

[DEXIl]&mdZS

L'entrée est un tableau de deux nombres. La sortie est -1, 0et 1respectivement pour plus , égale à ou inférieure .

Essayez-le en ligne!

Explication

Considérez la saisie [1 4]comme exemple.

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

Prend les deux rangs dans la syntaxe de curry (a)(b). Renvoie 1 pour plus de , -1 pour moins de ou 0 pour égal .

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

Essayez-le en ligne!

Utilisation d'une formule, 48 octets

C'est certainement plus long que d'utiliser une table de recherche, mais aussi un peu plus intéressant.

Même format d'E / S.

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

Essayez-le en ligne!

Comment?

$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

Nous voulons maintenant transformer les valeurs non nulles restantes de manière à ce qu'elles puissent être triées dans le bon ordre. Nous utilisons:

    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 octets

• 1 => plus de
• -1 => moins de
• 0 => égal

£"78920"bXÉÃr- g

Essayez-le en ligne!

Japt -g , 13 octets

Sorties -1pour >, 1pour <et 0pour ===.

m!b#ù991ìD)rn

Essayez-le ou exécutez plusieurs tests (la deuxième ligne reproduit la fonctionnalité de l' -gindicateur pour permettre aux indicateurs d'être utilisés pour traiter plusieurs entrées)

Explication

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

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

Essayez-le en ligne!

• -6 octets grâce à la suggestion de @JayCe de passer au programme complet au lieu de la fonction

Le programme revient 2pour 'greater than', 1pour 'less than', 1.5pour'equal'

Explication:

      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 octets

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

Lambda prenant des paramètres dans la syntaxe de curry, port de la réponse JavaScript d' Arnauld .

Retours 0.0 égaux , 1.0pour plus que , et -1.0pour moins . Essayez-le en ligne ici .

Merci à Kevin Cruijssen d' avoir joué au golf 3 octets.

MarioLANG , 578 548 530 octets

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

Essayez-le en ligne!

Explication:

• Le premier, grand château lit un numéro de carte en entrée et calcule sa valeur équivalente en points jusqu'à ce qu'il lise un 0(pas d'entrée). Cela suppose qu'il n'y aura que deux valeurs strictement positives en entrée.
• Notez que je ne définit pas réellement les valeurs en points appropriées car elles ne sont pas nécessaires, je définis simplement comme valeur en points un nombre entre [1-5]pour aider à calculer quelle carte a le plus de valeurs en points.
• Le deuxième petit château compare simplement les deux valeurs de points calculées.
• Elle renvoie 1si la première valeur ponctuelle est supérieure à la seconde, -1si la deuxième valeur ponctuelle est supérieure à la première et 0si les valeurs ponctuelles sont identiques.

Python 2 , 41 octets

Sorties 1 pour plus de, -1 pour moins de, 0 pour égal.

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

Essayez-le en ligne!

C (gcc) , 57 octets

Renvoie l'habituel [-1..1] pour <, = et>, respectivement.

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

Essayez-le en ligne!

05AB1E , 14 octets

ε78920S>sk}`.S

Retours 1,-1 ou 0pour plus de; moins que; ou égaux respectivement.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Essayez-le en ligne!

Pour l'exécuter:

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

Exemple:

php -n briscola_score.php 3 1

Remarque: Ce code utilise l'opérateur de vaisseau spatial de PHP 7 . Cela ne fonctionnera donc sur aucune version PHP avant 7.

Production:

• 1 = plus de ( card1 > card2)
• 0 = égal ( card1 == card2)
• -1 = moins de ( card1 < card2)

Comment?

Identique à l'approche utilisée dans de nombreuses autres réponses, mais en PHP. Crée une carte de valeurs pour les cartes et en compare les valeurs. La position de la valeur sur la carte est la même que le numéro de la carte.

Javascript ES2016 +, 73 caractères

Pas le plus court, mais j'espère intéressant en raison des mathématiques et du débordement :)

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

Et l'autre version avec 74 caractères, malheureusement:

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

Tester

Ouvrez la console du navigateur avant d'exécuter

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