De acuerdo con esta pregunta, Superb Shuffle ™ ️ se define como un mazo completo de cartas (incluidos los comodines) que sigue este conjunto de reglas:

• No hay dos cartas (excepto Jokers) del mismo palo adyacentes.
• Ninguna carta (excepto Jokers) es adyacente a uno del mismo valor.
• Ninguna carta (excepto Jokers) es adyacente a uno de un valor adyacente (uno más alto o uno más bajo en este orden, A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A. Observe que Ace no puede ser adyacente a un 2 o un Rey).
• Los comodines pueden estar en cualquier posición.

Las cartas se expresan como un valor (A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K), seguidas de un palo (C, D, H, S). Por ejemplo, 'AS' es el as de espadas. Los comodines están representados por una sola letra J.

• Escriba algún código para indicar si un conjunto de tarjetas es un Superb Shuffle ™ ️ o no.
• Usa el idioma que quieras.
• Intente hacerlo en el menor número de bytes.

Casos de prueba:

1: Esto es 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: todo esto está ordenado

[
  "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: Ases juntos

[
  "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: Crazy 8's

[
  "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: también excelente

[
  "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: As por 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: As por rey

[
  "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: Jokers juntos

[
  "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: Traje / valor adyacente separado por comodines

[
  "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 bytes

Devuelve verdadero para Superb ™ ️ o falso para Ugly ™ ️.

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

Pruébalo en línea!

¿Cómo?

Cada tarjeta se divide en 3 caracteres a , b y c , algunos de los cuales podrían ser indefinido .

El rango viene dado por la posición de a en la cadena "34567891JQKA" ( '2' da -1 ). El palo viene dado por b para todas las cartas menos 10, para lo cual necesitamos probar c en su lugar, y Jokers que tienen un palo indefinido .

Llevamos un registro del rango anterior en r y el palo anterior en s .

$(r - new\_rank)^2 \bmod 13$

• $0$
• $1$$1$
• $1$$144$$144 \equiv 1 \pmod{13}$
• un número entero mayor que en todos los demás casos$1$

Simplemente comparamos el nuevo traje con s para detectar trajes idénticos consecutivos.

Usamos la expresión ! S | ! b para detectar que la carta anterior o la actual es un Joker , en cuyo caso se descartan los resultados de las otras pruebas.

Retina 0.8.2 , 68 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Salidas 0si es excelente, 1si no. Explicación:

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

Copie la última tarjeta al principio para simular la envoltura.

J\b
--

Reemplaza los comodines con marcadores de posición de dos caracteres, lo cual es suficiente para asegurarte de que las cartas circundantes no coincidan entre sí.

10
T

Y reemplaza la 10s con decenas.

\b\w
$&$&

Duplica el rango de cada carta.

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

Calcule el rango adyacente.

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

Busque cartas adyacentes del mismo palo o rango igual o adyacente.

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;}

Pruébalo en línea.

Explicación:

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

Pruébalo en línea!

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

Pruébalo en línea!

Python 3 gana bytes con el desempaquetado iterable, pero pierde bytes al negarse a encadenar comparaciones de elementos de tipo diferente. El desempaquetado necesita manejar ambos 'J'y '10S', lo que significa que puede extraer el primer valor o el último valor, pero no ambos.

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

Pruébalo en línea!

Explicación:

Sin entrar demasiado en detalles:

• dividir cada par en caracteres individuales
• eliminar '0' si alguno
• eliminar caracteres duplicados
• intenta eliminar pares de valores adyacentes

Si después del tratamiento quedan 3 caracteres, la pareja es buena.

Python 3, 130 125 bytes

5 bytes guardados gracias a Chas Brown

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

Mi primera publicación aquí, por lo que probablemente esto se podría reducir un poco más.

Explicación

Lambda recursiva; comprueba si las dos primeras cartas de la lista actual son de palos diferentes, tienen rangos diferentes y sus rangos difieren en más de 1 (pero menos de 12, para tener en cuenta el As-Rey), o si una de las dos cartas es un Joker, en cuyo caso está bien, luego consume el primer elemento de la lista y vuelve a aparecer.

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}

Pruébalo en línea!

Versión recursiva
Recorre la matriz y compara la tarjeta actual con la última tarjeta. El rango se busca en la cadena "A234567891JQK" y se omiten los comodines. Comienza con una tarjeta ficticia anterior "20Z" que aceptará a cualquier vecino.

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

Pruébalo en línea!