Gemäß dieser Frage wird ein Superb Shuffle ™ ️ als ein vollständiges Kartenspiel (einschließlich Joker) definiert, das diesen Regeln folgt:

• Es sind keine zwei Karten (außer Joker) derselben Farbe nebeneinander.
• Keine Karte (außer Joker) grenzt an eine Karte mit demselben Wert.
• Keine Karte (außer Joker) grenzt an einen benachbarten Wert (einen höheren oder einen niedrigeren in dieser Reihenfolge, A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K,). A. Beachten Sie, dass Ass weder einer 2 noch einem König benachbart sein kann.
• Die Joker können sich in jeder Position befinden.

Die Karten werden als Wert (A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K) ausgedrückt, gefolgt von einer Farbe (C, D, H, S). Zum Beispiel ist 'AS' das Pik-Ass. Die Joker werden durch einen einzigen Buchstaben J dargestellt.

• Schreiben Sie einen Code, um anzugeben, ob ein Kartenarray ein Superb Shuffle ™ ist oder nicht.
• Verwenden Sie eine beliebige Sprache.
• Versuchen Sie dies in der kleinsten Anzahl von Bytes.

Testfälle:

1: Dies ist Superb ™ ️

[
  "AS", "5D", "9H", "KC", "2D", "6H", "10C", "QS", "3H", "7C", "9S", 
  "KD", "4C", "6S", "10D", "AC", "3S", "7D", "JH", "J", "4D", "8H", 
  "QC", "AD", "5H", "9C", "JS", "2H", "6C", "8S", "QD", "3C", "5S", 
  "9D", "KH", "2S", "6D", "10H", "J", "3D", "7H", "JC", "KS", "4H", 
  "8C", "10S", "AH", "5C", "7S", "JD", "2C", "4S", "8D", "QH"
]

# true

2: Das ist alles sortiert

[
  "AS", "2S", "3S", "4S", "5S", "6S", "7S", "8S", "9S", "10S", "JS", "QS", "KS", 
  "AD", "2D", "3D", "4D", "5D", "6D", "7D", "8D", "9D", "10D", "JD", "QD", "KD", 
  "AH", "2H", "3H", "4H", "5H", "6H", "7H", "8H", "9H", "10H", "JH", "QH", "KH", 
  "AC", "2C", "3C", "4C", "5C", "6C", "7C", "8C", "9C", "10C", "JC", "QC", "KC", 
  "J", "J"
]

# false

3: Asse zusammen

[
  "AC", "AS", "AD", "AH", "5D", "9H", "KC", "2D", "6H", "10C", "QS",
  "9S", "KD", "4C", "6S", "10D", "3S", "7D", "JH", "J", "4D", "8H", 
  "QC", "5H", "9C", "JS", "2H", "6C", "8S", "QD", "3C", "5S", "3H", 
  "9D", "KH", "2S", "6D", "10H", "J", "3D", "7H", "JC", "KS", "4H", 
  "8C", "10S", "5C", "7S", "JD", "2C", "4S", "8D", "7C", "QH"
]

# false

4: Verrückte 8er

[
  "AS", "5D", "9H", "KC", "2D", "6H", "10C", "QS", "3H", "7C", "9S", 
  "KD", "4C", "6S", "10D", "AC", "3S", "7D", "JH", "J", "4D", "AH",
  "QC", "AD", "5H", "9C", "JS", "2H", "6C", "QD", "3C", "5S", "10S", 
  "9D", "KH", "2S", "6D", "10H", "J", "3D", "7H", "JC", "KS", "4H", 
  "5C", "7S", "JD", "2C", "4S","QH", "8D", "8S", "8C", "8H"
]

# false

5: Auch hervorragend

[
  "AS", "6H", "9S", "AC", "4D", "9C", "QD", "2S", "7H", "10S", "2C", 
  "5D", "10C", "KD", "3S", "8H", "JS", "3C", "6D", "JC", "AH", "4S", 
  "9H", "QS", "4C", "7D", "QC", "2H", "5S", "10H", "KS", "5C", "8D", 
  "KC", "3H", "6S", "JH", "AD", "6C", "9D", "J", "4H", "7S", "QH", 
  "2D", "7C", "10D", "J", "5H", "8S", "KH", "3D", "8C", "JD"
]

# true

6: Ass um 2

[
  "AS", "2S", "6H", "9S", "AC", "4D", "9C", "QD",  "7H", "10S", "2C", 
  "5D", "10C", "KD", "3S", "8H", "JS", "3C", "6D", "JC", "AH", "4S", 
  "9H", "QS", "4C", "7D", "QC", "2H", "5S", "10H", "KS", "5C", "8D", 
  "KC", "3H", "6S", "JH", "AD", "6C", "9D", "J", "4H", "7S", "QH", 
  "2D", "7C", "10D", "J", "5H", "8S", "KH", "3D", "8C", "JD"
]

# false

7: Ass von König

[
  "AS", "KH", "2S", "6H", "9S", "AC", "4D", "9C", "QD",  "7H", "10S", 
  "2C", "5D", "10C", "KD", "3S", "8H", "JS", "3C", "6D", "JC", "AH", 
  "4S", "9H", "QS", "4C", "7D", "QC", "2H", "5S", "10H", "KS", "5C",  
  "8D", "KC", "3H", "6S", "JH", "AD", "6C", "9D", "J", "4H", "7S", 
  "QH", "2D", "7C", "10D", "J", "5H", "8S", "3D", "8C", "JD"
]

# false

8: Joker zusammen

[
  "AS", "5D", "9H", "KC", "2D", "6H", "10C", "QS", "3H", "7C", "9S",
  "KD", "4C", "6S", "10D", "AC", "3S", "7D", "JH", "J", "J", "4D",
  "8H", "QC", "AD", "5H", "9C", "JS", "2H", "6C", "8S", "QD", "3C",
  "5S", "9D", "KH", "2S", "6D", "10H", "3D", "7H", "JC", "KS", "4H",
  "8C", "10S", "AH", "5C", "7S", "JD", "2C", "4S", "8D", "QH"
]

# true

9: Angrenzende Farbe / Wert durch Joker getrennt

[
  "AS", "6H", "9S", "AC", "4D", "J", "4H", "2S", "7H", "10S", "2C",
  "5D", "10C", "KD", "3S", "8H", "JS", "3C", "6D", "JC", "AH", "4S",
  "9H", "QS", "4C", "7D", "QC", "2H", "5S", "10H", "KS", "5C", "8D",
  "KC", "3H", "6S", "JH", "AD", "6C", "9D", "J", "QD", "7S", "QH",
  "2D", "7C", "10D", "8C", "5H", "8S", "KH", "3D", "9C", "JD"
]

# true 

JavaScript (ES7), 88 Byte

Gibt true für Superb ™ ️ oder false für Ugly ™ ️ zurück.

a=>a.every(r=s=([a,b,c])=>!s|!b|!((r-(r='34567891JQKA'.search(a)))**2%13<2|s==(s=c||b)))

Probieren Sie es online aus!

Wie?

Jede Karte ist in 3 Zeichen a , b und c aufgeteilt , von denen einige undefiniert sein können .

Der Rang wird durch die Position von a in der Zeichenfolge "34567891JQKA" angegeben ( '2' ergibt -1 ). Die Farbe wird durch b für alle Karten außer 10 gegeben, für die wir stattdessen c testen müssen , und für Joker , die eine undefinierte Farbe haben.

Wir verfolgen den vorherigen Rang in r und den vorherigen Anzug in s .

Wir verwenden den Ausdruck , um ungültige aufeinanderfolgende Ränge zu erkennen. Das gibt:$(r - new\_rank)^2 \bmod 13$

• $0$ wenn beide Ränge gleich sind
• $1$ wenn der absolute Unterschied zwischen den Rängen$1$
• $1$ wenn wir ein Ass gefolgt von einer Zwei oder einer Zwei gefolgt von einem Ass haben , weil die quadratische Differenz beträgt und wir .$144$$144 \equiv 1 \pmod{13}$
• in allen anderen Fällen eine ganze Zahl größer als$1$

Wir vergleichen einfach den neuen Anzug mit s , um identische aufeinanderfolgende Anzüge zu erkennen.

Wir verwenden den Ausdruck ! S | ! b, um festzustellen, dass entweder die vorherige oder die aktuelle Karte ein Joker ist. In diesem Fall werden die Ergebnisse der anderen Tests verworfen.

Retina 0,8,2 , 68 Bytes

.*,(.*)
$1,$&
J\b
--
10
T
\b\w
$&$&
T`Ao`2-9TJQKA`\b.
(\w).{2,4}\1.*

Probieren Sie es online aus! Link enthält Testfälle. Die Ergebnisse 0sind hervorragend, 1wenn nicht. Erläuterung:

.*,(.*)
$1,$&

Kopieren Sie die letzte Karte an den Anfang, um das Umwickeln zu simulieren.

J\b
--

Ersetzen Sie die Joker durch zweistellige Platzhalter. Dies reicht aus, um sicherzustellen, dass die umgebenden Karten nicht miteinander übereinstimmen.

10
T

Und ersetzen Sie das 10s durch Zehner.

\b\w
$&$&

Dupliziere den Rang jeder Karte.

T`Ao`2-9TJQKA`\b.

Berechnen Sie den benachbarten Rang.

(\w).{2,4}\1.*

Suchen Sie nach benachbarten Karten mit derselben Farbe oder demselben oder benachbartem Rang.

Java 10, 246 210 205 178 170 Bytes

d->{var r=1>0;int p=-1,P=p,q,u;for(var c:d)r&=p<0|(u=(p-(p=(q=c.length())<2?-1:"A234567891JQK".indexOf(c.charAt(0))))%12)<-1|u>1&P!=(P=q<2?p:c.charAt(q>2?2:1));return r;}

Probieren Sie es online aus.

Erläuterung:

d->{                   // Method with String-array parameter and boolean return-type
  var r=1>0;           //  Result-boolean, starting at true
  int p=-1,            //  Previous value, starting at -1
      P=p,             //  Previous suit, starting at -1
      q,u;             //  Temp integers
  for(var c:d)         //  Loop over the cards of the input-deck:
    r&=p<0             //   Validate whether the previous value is -1
       |(u=(p-         //   Or if the difference between the previous and current value,
          (p=          //   where the current value is:
                       //   (and replace the previous with the current value for the next
                       //   iteration at the same time)
             (q=c.length())<2?
                       //    Is it a Joker:
               -1      //     Use -1
              :        //    Else:
               "A234567891JQK".indexOf(c.charAt(0))
                       //     Use 0-12 depending on the order
        ))%12)         //   (Modulo-12 for 'A' and 'K')
              <-1|u>1  //   is more than 2
       &P!=            //   And the previous and current suits are not equal,
           (P=         //   where the current suit is:
                       //   (and replace the previous with the current suit for the next
                       //   iteration at the same time)
              q<2?     //    Is it a Joker:
               p       //     Use -1
              :        //    Else:
               c.charAt(q>2?2:1));
                       //     Use the suit-character
                       //     where the `q>2?2:1` is for cards of value 10
  return r;}           //  Return if all validations inside the loop have succeeded

Python 2 , 108 Bytes

lambda l:all('J'in(a,b)or(q(a[0])-q(b[0])+1)%13>2<a[-1]!=b[-1]for a,b in zip(l,l[1:]))
q='234567891JQK'.find

Probieren Sie es online aus!

Python 3 , 109 Bytes

lambda l:all([(q(a[0])-q(b[0])+1)%13*(A!=B)>2for(*a,A),(*b,B)in zip(l,l[1:])if a>[]<b])
q='234567891JQK'.find

Probieren Sie es online aus!

Python 3 gewinnt Bytes durch iterierbares Entpacken, verliert jedoch Bytes, indem es sich weigert, Vergleiche unterschiedlich typisierter Elemente miteinander zu verketten. Das Auspacken muss beide 'J'und verarbeiten '10S', was bedeutet, dass entweder der erste oder der letzte Wert extrahiert werden kann, jedoch nicht beide.

Ruby , 123 Bytes

->a{a.each_cons(2).all?{|a,b|a==?J||b==?J||(s="A234567891JQK".chars).zip(s.rotate).all?{|f|((a.chars|b.chars)-[?0]-f)[2]}}}

Probieren Sie es online aus!

Erläuterung:

Ohne zu sehr ins Detail zu gehen:

• Teilen Sie jedes Paar in einzelne Zeichen auf
• Entfernen Sie gegebenenfalls '0'
• Entfernen Sie doppelte Zeichen
• Versuchen Sie, Paare benachbarter Werte zu entfernen

Wenn nach der Behandlung noch 3 Zeichen übrig sind, ist das Paar gut.

Python 3, 130 125 Bytes

5 Bytes dank Chas Brown gespart

v="A234567891JQK".find;s=lambda d:len(d)<2or("J"in d[:2]or 1<abs(v(d[0][0])-v(d[1][0]))<12and d[0][-1]!=d[1][-1])and s(d[1:])

Mein erster Beitrag hier, also könnte dies wahrscheinlich etwas weiter unten gespielt werden.

Erläuterung

Rekursives Lambda; prüft, ob die ersten beiden Karten der aktuellen Liste unterschiedliche Farben haben, unterschiedliche Ränge haben und sich um mehr als 1 (aber weniger als 12, um Ace-King zu berücksichtigen) unterscheiden oder ob eine der beiden Karten a ist Joker, in diesem Fall ist es in Ordnung, verbraucht dann das erste Element der Liste und rekursiert.

Ruby , 119 Bytes

f=->s,c=20,d=?Z{a,*b=s;a ?(x=a[-1];x==?J||(e=((i="A234567891JQK".index(a[0]))-c)%13;e>1&&e<12)&&x!=d)&&f[b,i||20,x]:!p}

Probieren Sie es online aus!

Rekursive Version.
Es geht durch das Array und vergleicht die aktuelle Karte mit der letzten Karte. Der Rang wird in der Zeichenfolge "A234567891JQK" gesucht und Joker werden übersprungen. Es beginnt mit einer Dummy-Vorgängerkarte "20Z", die jeden Nachbarn akzeptiert.

Python 2 , 122 Bytes

lambda a:all((12>abs(R(c[0])-R(d[0]))>1and c[-1]!=d[-1])or'J'in c[-1]+d[-1]for c,d in zip(a,a[1:]))
R='A234567891JQK'.find

Probieren Sie es online aus!