De acordo com esta pergunta, um Superb Shuffle ™ ️ é definido como um baralho completo de cartas (incluindo coringas) que segue este conjunto de regras:

• Não há duas cartas (exceto Jokers) do mesmo naipe adjacentes.
• Nenhum cartão (exceto Jokers) é adjacente a um mesmo valor.
• Nenhuma carta (exceto Jokers) é adjacente a um valor adjacente (um mais alto ou outro mais baixo nesta ordem, A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A. Observe que o Ace não pode ser adjacente a um 2 ou a um rei).
• Os curingas podem estar em qualquer posição.

As cartas são expressas como um valor (A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K), seguido por um naipe (C, D, H, S). Por exemplo, 'AS' é o ás de espadas. Os Jokers são representados por uma única letra J.

• Escreva um código para indicar se um conjunto de cartões é um Superb Shuffle ™ ️ ou não.
• Use qualquer idioma que desejar.
• Tente fazer isso no menor número de bytes.

Casos de teste:

1: Este é o 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: Tudo isso está classificado

[
  "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: 8 loucos

[
  "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: Também 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: Ás 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: Ás por rei

[
  "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: Naipe / valor adjacente separado por Jokers

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

Retorna verdadeiro para Superb ™ ️ ou 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)))

Experimente online!

Quão?

Cada cartão é dividida em 3 personagens a , b e c , alguns dos quais podem ser indefinido .

A classificação é dada pela posição de a na sequência "34567891JQKA" ( '2' fornece -1 ). O naipe é dado por b para todas as cartas, exceto as 10, para as quais precisamos testar c e Jokers que têm um naipe indefinido .

Nós acompanhamos o ranking anterior em reo naipe anterior em s .

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

• $0$
• $1$$1$
• $1$$144$$144 \equiv 1 \pmod{13}$
• $1$

Simplesmente comparamos o novo processo com s para detectar processos consecutivos idênticos.

Usamos a expressão ! S | ! b para detectar que o cartão anterior ou o atual é um Coringa ; nesse caso, os resultados dos outros testes são descartados.

Retina 0.8.2 , 68 bytes

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

Experimente online! O link inclui casos de teste. Saídas 0se excelente, 1se não. Explicação:

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

Copie o último cartão para o início para simular o contorno.

J\b
--

Substitua os curingas por espaços reservados de dois caracteres, o que é suficiente para garantir que as cartas ao redor não sejam correspondidas.

10
T

E substitua os 10por dezenas.

\b\w
$&$&

Duplique a classificação de cada carta.

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

Calcule a classificação adjacente.

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

Procure por cartas adjacentes do mesmo naipe ou do mesmo valor ou na posição adjacente.

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

Experimente online.

Explicação:

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

Experimente online!

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

Experimente online!

O Python 3 ganha bytes com descompactação iterável, mas perde bytes ao recusar encadear comparações de itens de tipos diferentes. A descompactação precisa lidar com ambos 'J'e '10S', o que significa que pode extrair o primeiro valor ou o último valor, mas não os dois.

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

Experimente online!

Explicação:

Sem entrar muito em detalhes:

• dividir cada par em caracteres únicos
• remova '0' se houver
• remover caracteres duplicados
• tente remover pares de valores adjacentes

Se após o tratamento restarem 3 caracteres, o par será bom.

Python 3, 130 125 bytes

5 bytes salvos graças 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:])

Meu primeiro post aqui, então isso provavelmente poderia ser um pouco mais complicado.

Explicação

Lambda recursiva; verifica se as duas primeiras cartas da lista atual têm naipes diferentes, são diferentes e se diferem em mais de 1 (mas menos de 12, para representar Ace-King) ou se uma das duas cartas é um Joker, nesse caso, tudo bem, então consome o primeiro elemento da lista e se repete.

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}

Experimente online!

Versão recursiva.
Ele percorre a matriz e compara o cartão atual com o último cartão. A classificação é pesquisada na cadeia "A234567891JQK" e os coringas são ignorados. Começa com um cartão fictício anterior "20Z" que aceita qualquer vizinho.

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

Experimente online!