Ontem, fiz essa pergunta sobre embaralhamento de rifles. Parece que a pergunta de ontem foi um pouco difícil, então essa é uma tarefa relacionada, mas muito mais fácil.

Hoje, você é solicitado a determinar se uma permutação é de fato uma reprodução aleatória. Nossa definição de riffle shuffle é adaptada de nossa última pergunta:

A primeira parte do shuffle é a divisão. Na partição dividida, o baralho de cartas em dois. As duas subseções devem ser contínuas, mutuamente exclusivas e exaustivas. No mundo real, deseja tornar sua partição o mais próxima possível, no entanto, neste desafio, isso não é uma consideração, todas as partições, incluindo as que são degeneradas (uma partição está vazia), são de igual consideração.

Depois de terem sido particionados, os cartões são unidos de maneira que os cartões mantenham sua ordem relativa na partição da qual são membros . Por exemplo, se o cartão A estiver antes do cartão B no baralho e os cartões A e B estiverem na mesma partição, o cartão A deverá estar antes do cartão B no resultado final, mesmo que o número de cartões entre eles tenha aumentado. Se A e B estiverem em partições diferentes, eles poderão estar em qualquer ordem, independentemente da ordem inicial, no resultado final.

Cada baralhamento de rifles pode ser visto como uma permutação do baralho de cartas original. Por exemplo, a permutação

1,2,3 -> 1,3,2

é uma reprodução aleatória. Se você dividir o baralho assim

1, 2 | 3

vemos que cada cartão 1,3,2tem a mesma ordem relativa a todos os outros cartões em sua partição. 2ainda está depois 1.

Por outro lado, a permutação a seguir não é uma reprodução aleatória.

1,2,3 -> 3,2,1

Podemos ver isso porque para todas as duas partições (não triviais)

1, 2 | 3
1 | 2, 3 

há um par de cartas que não mantêm suas ordens relativas. Na primeira partição 1e 2altere sua ordem, enquanto na segunda partição 2e 3altere sua ordem.

Tarefa

Dada uma permutação por qualquer método razoável, determine se ele representa um embaralhamento válido da espingarda. Você deve gerar dois valores constantes distintos, um para "Sim, este é um shuffle aleatório" e um para "Não, este não é um aleatório aleatório".

Isso é código-golfe, então as respostas serão pontuadas em bytes, com menos bytes sendo melhores.

Casos de teste

1,3,2 -> True
3,2,1 -> False
3,1,2,4 -> True
2,3,4,1 -> True
4,3,2,1 -> False
1,2,3,4,5 -> True
1,2,5,4,3 -> False
5,1,4,2,3 -> False
3,1,4,2,5 -> True
2,3,6,1,4,5 -> False

JavaScript (ES6), 47 bytes

Recebe a entrada como uma matriz de números inteiros. Retorna um booleano.

([x,...a],y)=>a.every(z=>z+~x?y?z==++y:y=z:++x)

Casos de teste

let f =

([x,...a],y)=>a.every(z=>z+~x?y?z==++y:y=z:++x)

;[
  [1,3,2      ],  // -> True
  [3,2,1      ],  // -> False
  [3,1,2,4    ],  // -> True
  [2,3,4,1    ],  // -> True
  [4,3,2,1    ],  // -> False
  [1,2,3,4,5  ],  // -> True
  [1,2,5,4,3  ],  // -> False
  [3,1,4,2,5  ],  // -> True
  [2,3,6,1,4,5]   // -> False
]
.forEach(a => console.log(JSON.stringify(a) + ' -> ' + f(a)))

Quão?

A matriz de entrada A é uma ordem aleatória de rifles válida se consistir em no máximo duas seqüências entrelaçadas distintas de números inteiros consecutivos.

As regras de desafio especificam que recebemos uma permutação de [1 ... N] . Portanto, não precisamos verificar adicionalmente se a união classificada dessas seqüências realmente resulta em um intervalo desse tipo.

Usamos um contador x inicializado para A [0] e um contador y inicialmente indefinido.

Para cada entrada z em A , começando com a segunda:

• Verificamos se z é igual a x + 1 ou y + 1 . Se sim, incrementamos o contador correspondente.
• Senão: se y ainda estiver indefinido, inicializamos para z .
• Senão: fazemos o teste falhar.

Haskell , 41 bytes

n%h=n+0^(n-h)^2
f l=elem(foldl(%)0$l++l)l

Experimente online!

Verifica se a lista concatenada para si mesma contém os números 0..n-1em ordem como uma subsequência.

Haskell , 43 bytes

spega uma lista de números inteiros como nos exemplos de OP e retorna a Bool.

s p=or[f(<x)p++f(>=x)p<[1..]|x<-p]
f=filter

Experimente online!

Como funciona

• A compreensão da lista tenta cada elemento xde psua vez e verifica se ele pode ser o primeiro elemento da segunda partição do shuffle. Em seguida, orretorna Truese alguma das verificações foi True.
• A compreensão faz isso particionando (com filter) pem elementos menores e maiores que (ou iguais a) x, concatenando e verificando se a lista resultante é [1..length p], ou seja, os elementos em ordem.
• A verificação para saber se a lista resultante [1..length p]é feita é verificando se o resultado é estritamente menor que a lista infinita [1..] == [1,2,3,etc.], o que fornece o mesmo resultado para qualquer permutação.

Geléia , 13 6 bytes

ỤIṢḊRẠ

Experimente online!

Versão alternativa, desafio pós-datas, 5 bytes

Ụ>ƝSỊ

Experimente online!

Como funciona

ỤIṢḊRẠ  Main link. Argument: A (permutation of [1, ..., n])

Ụ       Grade up; sort the indices of A by their respective values.
        For shuffles, the result is the concatenation of up to two increasing
        sequences of indices.
 I      Compute the forward differences.
        In a shuffle, only one difference may be negative.
  Ṣ     Sort the differences.
   Ḋ    Dequeue; remove the first (smallest) difference.
    R   Range; map each k to [1, ..., k].
        This yields an empty array for non-positive values of k.
     Ạ  All; check if all resulting ranges are non-empty.

Python 2 , 39 bytes

l=input()
n=0
for x in l*2:n+=n==x
l[n]

Experimente online!

Pega a lista indexada em 0 e sai pelo código de saída.

Braquilog , 9 bytes

o~cĊ⟨⊆⊇⟩?

Experimente online!

O predicado será bem-sucedido se a entrada representar uma reprodução aleatória e falhar se não ocorrer, o que significa, entre outras coisas, que se o predicado for executado como um programa inteiro, o sucesso será impresso true.e a falha será impressa false.. A entrada é tomada como uma lista de qualquer tipo de item e a interpreta como representando uma permutação de si mesma classificada.

   Ċ         Some length-two list
 ~c          which concatenated
o            is the input sorted
    ⟨        satisfies the condition that its first element
     ⊆       is an ordered not-necessarily-contiguous sublist
        ?    of the input
      ⊇      which is an ordered superlist of
       ⟩     the list's second element.

Sinto que há algo no espírito ⊆ᵐque deve funcionar no lugar da construção "sanduíche" de quatro bytes ⟨⊆⊇⟩.

Python 2 , 75 60 47 bytes

graças a Dennis por -13 bytes

x={0}
for v in input():x=x-{v-1}|{v}
len(x)<3>q

Experimente online!

A saída é via código de saída.

Ruby , 35 bytes

->l{l.any?{|a|l&[*1..a]|l==l.sort}}

Experimente online!

Quão?

• l & [*1..a] | laplica uma interseção e depois uma união: primeiro obtenha os elementos lque são <=ae, em seguida, adicione os elementos restantes lsem alterar a ordem. Se a é o número que estamos procurando, essa operação é igual à classificação l.

Limpo , 56 55 bytes

import StdEnv
?l=any(\e=sortBy(\a b=a<e&&b>=e)l<[1..])l

Experimente online!

Pitão, 5 bytes

}SQy+

Suíte de teste

}SQy+

    +QQ  concatenated two copies of the (implicit) input
   y     all subsequences of it
}        contain an element equaling
 SQ      the input list sorted 

Verifica se a lista de entrada dobrada contém uma versão classificada de si mesma como uma subsequência.

Graças a Erik, o Outgolfer, por 1 byte, aproveitando melhor as entradas implícitas em +QQvez de *2Q.

Pitão , 9 bytes

!t-.+xLQS

Suíte de teste.

Economizou 3 bytes graças a isaacg .

Pitão , 14 bytes

}SQm.nS.Tcd2./

Experimente aqui!ou Verifique todos os casos de teste.

Saídas True e Falsepara reprodução aleatória e reprodução aleatória, respectivamente.

Quão?

} SQm.nS.Tcd2./ ~ Programa completo. Lê a entrada de STDIN e as saídas para STDOUT.

            ./ ~ Retorne todas as divisões da entrada em substrings separados (partição).
   m ~ Mapeie acima, usando uma variável d.
         cd2 ~ Pique d em listas de dois elementos.
       Transposição justificada, ignorando ausências.
      S ~ Classificar (lexicograficamente).
    .n ~ Achatar profundamente.
} ~ Verifique se o acima contém ...
 SQ ~ A entrada classificada.

Casca , 7 bytes

±§#OoṖD

Suíte de teste!

Perl, 28 bytes

Inclui +1paraa

Entrada em STDIN, 1 baseada

perl -aE '$.+=$_==$.for@F,@F;say$.>@F' <<< "3 1 2 4"

Usa o algoritmo do xnor

C (gcc) , 61 bytes

a,b,B;f(int*A){for(a=b=B=1;*A;A++)a-*A?B*=*A>b,b=*A:++a;b=B;}

Experimente online!