昨天我问这个约洗牌洗牌的问题。似乎昨天的问题有点太难了，所以这个问题是相关但容易得多的任务。

今天，您被要求确定排列是否实际上是浅滩混洗。我们对浅滩混洗的定义是根据我们上一个问题改编的：

洗牌的第一部分是鸿沟。在分隔分区中，一副纸牌一分为二。这两个小节必须是连续的，互斥的和详尽的。在现实世界中，要使您的分区尽可能地接近，但是在此挑战中，这不是要考虑的问题，所有退化的分区（一个分区为空）都是同等考虑的。

分区后，将卡拼接在一起，以使卡在它们所属的分区内保持其相对顺序。例如，如果卡片A在卡组中的卡片B之前，并且卡片A和B在同一分区中，则在最终结果中，卡片A必须在卡片B之前，即使它们之间的卡片数量增加了。如果A和B在不同的分区中，则它们在最终结果中可以采用任何顺序，而不管它们的开始顺序如何。

然后，可以将每个浅滩混洗视为原始纸牌的排列。例如排列

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

是浅滩洗牌。如果你像这样分割甲板

1, 2 | 3

我们看到其中的每张卡1,3,2与其分区中的每张其他卡具有相同的相对顺序。 2仍在1。

另一方面，以下排列不是浅滩混洗。

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

我们可以看到这一点，因为对于所有两个（非平凡的）分区

1, 2 | 3
1 | 2, 3 

有一对卡不保持其相对顺序。在第一个分区1，并2改变他们的排序，而在第二个分区2，并3改变它们的顺序。

任务

通过任何合理的方法给定排列，确定它是否代表有效的浅滩混洗。您应该输出两个不同的常数值，一个用于“是，这是浅滩混洗”，另一个用于“不，这不是浅滩混洗”。

这是代码高尔夫球，因此答案将以字节计分，而字节数越少越好。

测试用例

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个字节

将输入作为整数数组。返回一个布尔值。

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

测试用例

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

怎么样？

如果输入数组A最多包含两个连续整数的不同隔行扫描序列，则它是有效的浅滩混洗。

挑战规则规定，我们只能给一个排列的[1 ... N] 。因此，我们无需额外检查这些序列的排序并集实际上是否在这样的范围内。

我们使用一个计数器X初始化为A [0]和计数器ÿ最初未定义。

对于每个条目ž在一，从第二之一：

• 我们检查z是否等于x + 1或y + 1。如果是，我们增加相应的计数器。
• 否则：如果y仍未定义，则将其初始化为z。
• 否则：我们使测试失败。

Haskell，41个字节

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

在线尝试！

检查连接到其自身的列表是否按0..n-1顺序包含数字作为子序列。

Haskell，43个字节

s如OP示例中所示，获取整数列表，并返回Bool。

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

在线尝试！

怎么运行的

• 列表推导依次尝试的每个元素x，p并检查它是否可以是shuffle的第二个分区的第一个元素。然后or返回True是否有任何支票True。
• 理解是通过将（with filter）p划分为小于和大于（或等于）的元素x，然后进行级联，并检查结果列表是否为[1..length p]，即元素顺序。
• 通过查看[1..length p]结果是否严格小于无限列表来检查结果列表是否完成，[1..] == [1,2,3,etc.]对于任何排列都给出相同的结果。

果冻，13 6个字节

ỤIṢḊRẠ

在线尝试！

替代版本，日期挑战，5个字节

Ụ>ƝSỊ

在线尝试！

怎么运行的

Ụ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个字节

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

在线尝试！

接受列表0索引并通过退出代码输出。

Brachylog，9个字节

o~cĊ⟨⊆⊇⟩?

在线尝试！

如果输入表示浅滩混洗，则谓词成功；如果输入不代表浅析浅洗，则谓词失败；这意味着，如果谓词作为整个程序运行，则将打印成功，而将打印true.失败false.。输入被视为任何种类的项目的列表，并将其解释为代表其自身排序的排列。

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

我觉得⊆ᵐ应该有一种精神可以代替四字节的“三明治”结构⟨⊆⊇⟩。

Python 2中，75个 60 47字节

感谢Dennis的-13个字节

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

在线尝试！

通过退出代码输出。

Ruby，35个字节

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

在线尝试！

怎么样？

• l & [*1..a] | l适用路口，然后一个联盟：首先获取的元素l是<=a，然后添加其余的元素l不改变顺序。如果a是我们要寻找的数字，则此操作与sorting相同l。

干净，56 55字节

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

在线尝试！

Pyth，5个字节

}SQy+

测试套件

}SQy+

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

检查加倍的输入列表是否包含自身的排序版本作为子序列。

多亏了Erik，Outgolfer占用了1个字节，从而更好地利用了+QQ而不是的隐式输入*2Q。

Pyth，9个字节

!t-.+xLQS

测试套件。

由于isaacg节省了3个字节。

Pyth，14个字节

}SQm.nS.Tcd2./

在这里尝试！或验证所有测试用例。

输出True和False分别洗牌洗牌和非洗牌洗牌。

怎么样？

} SQm.nS.Tcd2./〜完整程序。从STDIN读取输入，并输出到STDOUT。

            ./〜将输入的所有划分返回不相交的子字符串（分区）。
   m〜使用变量d映射到上面。
         cd2〜将d砍成两个元素的列表。
       .T〜有理调换，忽略缺席。
      S〜排序（按字典顺序）。
    .n〜展平。
}〜检查上面是否包含...
 SQ〜排序的输入。

外壳，7个字节

±§#OoṖD

测试套件！

Perl，28个字节

包括+1用于a

在STDIN上输入，基于1

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

使用xnor的算法

C（gcc），61字节

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

在线尝试！