各国在一维世界上拥有一系列领土。每个国家/地区均由数字唯一标识。可以通过以下列表来表示领土的所有权：

1 1 2 2 1 3 3 2 4

我们将一个国家的最边缘地区定义为最靠近任一边缘的两个地区。如果上述列表的索引为零，则该国家/地区1的最边缘地区位于0和4。

如果一个国家的两个最边缘区域之间的子列表包含另一个国家的所有领土，则该国家将包围另一个国家。在上面的示例中，国家/地区2最边缘地区之间的子列表为：

2 2 1 3 3 2

而且我们看到国家的所有领土3都在国家的最边缘地区之间2，因此国家2包围国家3。

一个只有一个要素的国家永远不会包围另一个要素。

挑战

以整数列表作为输入（任何格式），如果任何国家被另一个国家包围，则输出真实值，否则输出虚假值。

您可以假设输入列表是非空的，仅包含正整数，并且不会“跳过”任何数字：例如，1 2 1 5将是无效的输入。

测试用例

+----------------------+--------+
|        Input         | Output |
+----------------------+--------+
| 1                    | False  |
| 2 1 3 2              | True   |
| 2 1 2 1 2            | True   |
| 1 2 3 1 2 3          | False  |
| 1 3 1 2 2 3 2 3      | True   |
| 1 2 2 1 3 2 3 3 4    | False  |
| 1 2 3 4 5 6 7 8 9 10 | False  |
+----------------------+--------+

Pyth，7个字节

n{Q_{_Q

在测试用例上运行代码。

n      Check whether the following are not equal:
 {Q     The unique elements in order of first appearance
 _{_Q   The unique elements in order of last appearance
         (done by reversing, taking unique elts, then reversing again)

避免周围环境的唯一方法是，按照这些国家/地区的最右边领土的顺序对这些国家/地区的最左边领土进行排序。如果按此顺序交换两个国家，则一个国家的领土比另一个国家更左，更右，因此被其包围。

为了按最左边的区域顺序获得唯一的国家/地区，我们只需进行重复数据删除，即可保留此顺序。对最右边的区域执行相同的操作，方法是反转，重复数据删除然后再次反转。如果这些结果不同，那么一个国家就会被包围。

视网膜，61 60字节

比我想要的更长的时间...

(\b(\d+)\b.* (?!\2 )(\d+) .*\b\2\b)(?!.* \3\b)(?<!\b\3 .*\1)

打印至少包围另一个国家的国家数。

在线尝试。

这是一个非常简单的实现规范的：我们寻找的模式A...B...A，使得B显示任何前或比赛结束后。

Python，64位元组

lambda l,S=sorted:S(l,key=l.index)!=S(l,key=l[::-1].index)[::-1]

避免周围环境的唯一方法是，按照这些国家/地区的最右边领土的顺序对这些国家/地区的最左边领土进行排序。如果按此顺序交换两个国家，则一个国家的领土比另一个国家更左，更右，因此被其包围。

该功能检查按最左外观和最右外观对区域进行排序是否得出相同的结果。不幸的是，Python列表与并不rindex相似rfind，因此我们反转列表，然后反转排序后的输出。

具有辅助功能的相同长度（64）：

g=lambda l:sorted(l,key=l.index)
lambda l:g(l)[::-1]!=g(l[::-1])

C＃，113个字节

public bool V(int[] n){var u1=n.Distinct();var u2=n.Reverse().Distinct().Reverse();return !u1.SequenceEqual(u2);}

取消高尔夫：

public bool ContainsSurroundedCountry(int[] numbers)
{
    int[] uniqueLeftmost = numbers.Distinct().ToArray();
    int[] uniqueRightmost = numbers.Reverse().Distinct().Reverse().ToArray();

    return !uniqueLeftmost.SequenceEqual(uniqueRightmost);
}

使用简洁的LINQ方法。

CJam（14 13字节）

{__&\W%_&W%#}

在线演示

感谢MartinBüttner节省了一个字符。

Japt，12个字节

Uâ ¬¦Uw â ¬w

在线尝试！

感谢@xnor找出算法。输入数组自动存储在U，âuniqify，w反向和¦is中!=。¬与空字符串（[1,2,3] => "123"）连接；这是必需的，因为JavaScript的比较会将两个数组视为不相等，除非它们是同一对象。例如（JS代码，而不是Japt）：

var a = [1], b = [1]; alert(a==b); // false
var a = [1], b = a;   alert(a==b); // true

如果不是这种情况，我们可以通过不加入每个数组来删除两个字节：

Uâ ¦Uw â w

ES6，76个 75 65 64字节

 a=>(f=r=>a.filter((x,i)=>a.indexOf(x,r&&i+1)==(r|i))+a)()!=f(-1)

@xnor的答案的直接端口。

编辑：替换a.lastIndexOf(x)==i为保存1个字节a.indexOf(x,i+1)<0。

编辑：由于@ user81655，节省了10个字节。

编辑：替换r||i为保存1个字节r|i。

05AB1E，4 个字节

ÙIÚÊ

在线尝试或验证所有测试用例。

@xnor的Pyth答案端口。

说明：

Ù       # Uniquified
 IÚ     # Reversed uniquified on the input again
   Ê    # Check if the two lists are not equal

Java，281个字符

class K{public static void main(String[]a){System.out.println(!k(a[0]).equals(new StringBuffer(k(new StringBuffer(a[0]).reverse().toString())).reverse().toString()));}static String k(String k){for(char i=49;i<58;i++){k=k.replaceFirst(""+i,""+(i-9)).replaceAll(""+i,"");}return k;}}

Python 3，90个字节

该函数将输入作为Python列表。遗憾的是，Python列表不直接支持从末尾开始进行搜索，就像字符串与一样rindex()，但是很好。

def t(c):i,I=c.index,c[::-1].index;return any(i(n)<i(m)and I(n)<I(m)for m in c for n in c)