Einführung

Briscola ist eines der beliebtesten Kartenspiele Italiens. Es ist ein Trickspiel wie Bridge. Briscola ist bekannt für sein bizarres Punktesystem. Bei dieser Herausforderung geben Sie bei zwei Karten aus, ob die erste mehr, weniger oder die gleiche Anzahl von Punkten wie die zweite im Punktesystem von Briscola erzielt.

Herausforderung

Briscola wird mit einem Kartenspiel italienischer Spielkarten gespielt. Es gibt vierzig Karten in einem Deck, 1-10 in jeder der vier Farben: Tassen, Schwerter, Keulen und Münzen. Wir werden die Anzüge für diese Herausforderung ignorieren. Die Karten 2 - 7 sind die numerischen Karten und die Karten 8, 9 und 10 sind die Bildkarten. Die Rangfolge der Karten vom höchsten zum niedrigsten ist:

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

Danke an Orphevs für den schönen Tisch! :) :)

Ihre Aufgabe ist es, ein vollständiges Programm oder eine Funktion zu erstellen, die zwei Zahlen 1-10 akzeptiert, die Kartenränge darstellen, und ausgibt (oder zurückgibt), ob der Punktwert der ersten Karte größer, kleiner oder gleich dem Punktwert der Karte ist zweite Karte. Zusätzliche Bemerkungen:

• Ihr Programm kann drei beliebige Werte ausgeben, um kleiner als, größer als und gleich anzuzeigen. Es muss jedoch jedes Mal für jede Bedingung den gleichen Wert ausgeben.
• Ihr Programm verwendet möglicherweise alle E / A-Standardeinstellungen .
• Standardlücken sind nicht zulässig.
• Es ist entweder eine Vollfunktion oder ein Programm zulässig.

• Diese Frage ist Code-Golf , also gewinnt die niedrigste Byte-Anzahl.

• Hier sind einige Beispiele für Ein- und Ausgänge:

   1, 4 => mehr als (Ass erzielt 11 Punkte, 4 Punkte 0 Punkte, erster ist mehr als zweiter.
   8, 3 => kleiner als (8 Punkte 2, 3 Punkte 10, erstens ist kleiner als zweitens.
   5, 2 => gleich (5 und 2 beide erzielen 0)

Wenn Sie Fragen haben, zögern Sie nicht zu fragen. Viel Glück!

Gelee , 12 11 Bytes

“®µ½¤¢‘iⱮIṠ

Probieren Sie es online aus!

• -1 Byte nach der Methode von Luis Mendo .

Ausgaben 0für gleich, -1für größer als und 1für kleiner als. Verwendet den Codepage-Index, “®µ½¤¢‘der ausgewertet wird [8, 9, 10, 3, 1].

Nimmt die Eingabe als Kartenpaar entgegen. Verwenden Sie 1,2als Beispiel.

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

Die Eingabe besteht aus zwei Zahlen. Die Ausgabe ist -1, 0und die 1jeweils für mehr als , gleich zu oder weniger als .

Probieren Sie es online aus!

Erläuterung

Betrachten Sie die Eingabe [1 4]als Beispiel.

[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

Nimmt die beiden Ränge in der Curry-Syntax ein (a)(b). Gibt 1 für mehr als , -1 für weniger als oder 0 für gleich zurück .

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

Probieren Sie es online aus!

Mit einer Formel 48 Bytes

Dies ist definitiv länger als die Verwendung einer Nachschlagetabelle, aber auch etwas interessanter.

Gleiches E / A-Format.

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

Probieren Sie es online aus!

Wie?

$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

Wir wollen nun die verbleibenden Werte ungleich Null so transformieren, dass sie in der richtigen Reihenfolge sortiert werden können. Wir gebrauchen:

    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 => mehr als
• -1 => kleiner als
• 0 => gleich

£"78920"bXÉÃr- g

Probieren Sie es online aus!

Japt -g , 13 Bytes

Ausgänge -1für >, 1für <und 0für ===.

m!b#ù991ìD)rn

Probieren Sie es aus oder führen Sie mehrere Tests durch (In der zweiten Zeile wird die Funktionalität des -gFlags repliziert , damit die Flags zur Verarbeitung mehrerer Eingaben verwendet werden können.)

Erläuterung

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

Probieren Sie es online aus!

• -6 Bytes dank @ JayCe-Vorschlag, anstelle der Funktion zum vollständigen Programm zu wechseln

Das Programm gibt 2für 'greater than', 1für 'less than', 1.5für zurück'equal'

Erklärung:

      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 nimmt Parameter in der Curry-Syntax, Port der JavaScript- Antwort von Arnauld .

Gibt 0.0 gleich zurück , 1.0für größer als und -1.0für kleiner als . Probieren Sie es hier online aus .

Vielen Dank an Kevin Cruijssen für das Golfen von 3 Bytes.

MarioLANG , 578 548 530 Bytes

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

Probieren Sie es online aus!

Erläuterung:

• Die erste große Burg liest eine Kartennummer als Eingabe und berechnet ihren äquivalenten Punktwert, bis sie a liest 0(keine Eingabe). Dies setzt voraus, dass nur zwei streng positive Werte als Eingabe vorliegen.
• Beachten Sie, dass ich nicht die richtigen Punktwerte einstelle, da diese nicht benötigt werden. Ich setze nur eine Zahl dazwischen als Punktwert [1-5], um zu berechnen, welche Karte die meisten Punktwerte hat.
• Die zweite kleine Burg vergleicht nur die beiden berechneten Punktwerte.
• Es wird zurückgegeben, 1wenn der erste Punktwert größer als der zweite ist, -1wenn der zweite Punktwert größer als der erste ist und 0wenn die Punktwerte gleich sind.

Python 2 , 41 Bytes

Gibt 1 für mehr als, -1 für weniger als, 0 für gleich aus.

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

Probieren Sie es online aus!

C (gcc) , 57 Bytes

Gibt das übliche [-1..1] für <, = bzw.> zurück.

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

Probieren Sie es online aus!

05AB1E , 14 Bytes

ε78920S>sk}`.S

Returns 1, -1oder 0für mehr als; weniger als; bzw. gleich.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Probieren Sie es online aus!

Um es auszuführen:

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

Beispiel:

php -n briscola_score.php 3 1

Hinweis: Dieser Code verwendet den Raumschiffoperator von PHP 7 . Es funktioniert also auf keiner PHP-Version vor 7.

Ausgabe:

• 1 = mehr als ( card1 > card2)
• 0 = gleich ( card1 == card2)
• -1 = kleiner als ( card1 < card2)

Wie?

Entspricht dem Ansatz, der in vielen anderen Antworten verwendet wird, jedoch in PHP. Erstellt eine Wertekarte für Karten und vergleicht die Kartenwerte daraus. Die Position des Werts auf der Karte entspricht der Kartennummer.

Javascript ES2016 +, 73 Zeichen

Nicht die kürzeste, aber ich hoffe interessant wegen Mathe und Überlauf :)

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

Und die andere Version mit 74 Zeichen leider:

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

Prüfung

Öffnen Sie die Browserkonsole, bevor Sie sie ausführen

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