Ieri ho posto questa domanda sulle mescolanze di riffle. Sembra che la domanda di ieri sia stata un po 'troppo difficile, quindi questa domanda è un compito correlato ma molto più semplice.

Oggi ti viene chiesto di determinare se una permutazione è in realtà un riordino del riffle. La nostra definizione di riffle shuffle è adattata dalla nostra ultima domanda:

La prima parte dello shuffle è la divisione. Nella divisione dividere il mazzo di carte in due. Le due sottosezioni devono essere continue, reciprocamente esclusive ed esaustive. Nel mondo reale vuoi rendere la tua partizione il più vicino possibile, tuttavia in questa sfida questa non è una considerazione, tutte le partizioni incluse quelle che sono degenerate (una partizione è vuota) sono della stessa considerazione.

Dopo che sono state partizionate, le carte vengono congiunte in modo tale che le carte mantengano il loro ordine relativo all'interno della partizione di cui fanno parte . Ad esempio, se la carta A è prima della carta B nel mazzo e le carte A e B si trovano nella stessa partizione, la carta A deve trovarsi prima della carta B nel risultato finale, anche se il numero di carte tra loro è aumentato. Se A e B si trovano in partizioni diverse, possono essere in qualsiasi ordine, indipendentemente dal loro ordine di partenza, nel risultato finale.

Ogni shuffle di riffle può quindi essere visto come una permutazione del mazzo di carte originale. Ad esempio la permutazione

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

è un riffle shuffle. Se dividi il mazzo in questo modo

1, 2 | 3

vediamo che ogni carta in 1,3,2ha lo stesso ordine relativo ad ogni altra carta nella sua partizione. 2è ancora dopo 1.

D'altra parte la seguente permutazione non è un riordino di riffle.

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

Possiamo vederlo perché per tutte e due le partizioni (non banali)

1, 2 | 3
1 | 2, 3 

c'è una coppia di carte che non mantiene i relativi ordini. Nella prima partizione 1e 2modifica il loro ordine, mentre nella seconda partizione 2e 3modifica il loro ordine.

Compito

Data una permutazione tramite qualsiasi metodo ragionevole, determinare se rappresenta un shuffle riffle valido. Dovresti generare due valori costanti distinti uno per "Sì, questo è un riordino del riffle" e uno per "No, questo non è un riordino del riffle".

Questo è code-golf, quindi le risposte verranno classificate in byte con meno byte migliori.

Casi test

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 byte

Accetta l'input come una matrice di numeri interi. Restituisce un valore booleano.

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

Casi test

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

Come?

L'array di input A è un shuffle riffle valido se è composto da al massimo due distinte sequenze interlacciate di numeri interi consecutivi.

Le regole della sfida specificano che ci viene data una permutazione di [1 ... N] . Quindi non è necessario verificare ulteriormente che l'unione ordinata di queste sequenze si traduca effettivamente in tale intervallo.

Usiamo un contatore x inizializzato su A [0] e un contatore y inizialmente non definito.

Per ogni voce z in A , a partire dalla seconda:

• Controlliamo se z è uguale a x + 1 oppure y + 1 . Se sì, incrementiamo il contatore corrispondente.
• Altrimenti: se y non è ancora definito, lo inizializziamo su z .
• Altrimenti: falliamo il test.

Haskell , 41 byte

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

Provalo online!

Verifica se l'elenco concatenato a se stesso contiene i numeri 0..n-1in ordine di sottosequenza.

Haskell , 43 byte

sprende un elenco di numeri interi come negli esempi OP e restituisce a Bool.

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

Provalo online!

Come funziona

• La lista di comprensione cerca ogni elemento xdi pa sua volta e controlla se può essere il primo elemento della seconda partizione del riordino. Quindi orrestituisce Truese uno dei controlli fosse True.
• La comprensione fa questo partizionando (con filter) pin elementi più piccoli e più grandi di (o uguali a) x, concatenando e controllando se l'elenco risultante è [1..length p], cioè gli elementi in ordine.
• Il controllo per verificare se l'elenco risultante [1..length p]viene eseguito verificando se il risultato è strettamente più piccolo dell'elenco infinito [1..] == [1,2,3,etc.], che fornisce lo stesso risultato per qualsiasi permutazione.

Gelatina , 13 6 byte

ỤIṢḊRẠ

Provalo online!

Versione alternativa, sfida post-date, 5 byte

Ụ>ƝSỊ

Provalo online!

Come funziona

Ụ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 byte

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

Provalo online!

Prende l'elenco 0-indicizzato e le uscite tramite il codice di uscita.

Brachylog , 9 byte

o~cĊ⟨⊆⊇⟩?

Provalo online!

Il predicato ha esito positivo se l'input rappresenta un riordino del riffle e fallisce in caso contrario, il che significa tra l'altro che se il predicato viene eseguito mentre verrà stampato il successo dell'intero programma e verrà stampato l' true.errore false.. L'input viene considerato come un elenco di qualsiasi tipo di elemento e lo interpreta come rappresentante una permutazione di se stesso ordinata.

   Ċ         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.

Sento che c'è qualcosa nello spirito di ⊆ᵐcui dovrebbe funzionare al posto del costrutto "sandwich" a quattro byte ⟨⊆⊇⟩.

Python 2 , 75 60 47 byte

grazie a Dennis per -13 byte

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

Provalo online!

L'uscita è tramite il codice di uscita.

Rubino , 35 byte

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

Provalo online!

Come?

• l & [*1..a] | lapplica un'intersezione e quindi un'unione: prima prendi gli elementi di lquello che sono <=ae poi aggiungi gli elementi rimanenti lsenza cambiare l'ordine. Se a è il numero che stiamo cercando, questa operazione è uguale all'ordinamento l.

Pulito , 56 55 byte

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

Provalo online!

Pyth, 5 byte

}SQy+

Suite di test

}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 l'elenco di input raddoppiato contiene una versione ordinata di se stesso come sottosequenza.

Grazie a Erik Outgolfer per 1 byte sfrutta al meglio l'input implicito +QQanziché *2Q.

Pyth , 9 byte

!t-.+xLQS

Suite di test.

Salvato 3 byte grazie a isaacg .

Pyth , 14 byte

}SQm.nS.Tcd2./

Provalo qui! oppure Verifica tutti i casi di test.

Uscite Truee rispettivamente Falseper riffle-shuffle e non-riffle-shuffle.

Come?

} SQm.nS.Tcd2./ ~ Programma completo. Legge input da STDIN e output su STDOUT.

            ./ ~ Restituisce tutte le divisioni dell'input in sottostringhe disgiunte (partizione).
   m ~ Mappa sopra quanto sopra usando una variabile d.
         cd2 ~ Taglia d in elenchi di due elementi.
       .T ~ Trasposizione giustificata, ignorando le assenze.
      S ~ Sort (lessicograficamente).
    .n ~ Appiattimento profondo.
} ~ Controlla se quanto sopra contiene ...
 SQ ~ L'ingresso ordinato.

Buccia , 7 byte

±§#OoṖD

Suite di test!

Perl, 28 byte

Include +1pera

Input su STDIN, 1 basato

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

Utilizza l'algoritmo di xnor

C (gcc) , 61 byte

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

Provalo online!