定义

一种载体，一含有Ñ元件据说 majorize或 支配的矢量b与Ñ 元件当且仅当对于所有的值ķ使得1≤ ķ ≤ Ñ，的第一个元素的总和一个^↓通过ķ的第i个元素一个^↓是更大等于或等于b ^↓的第一个到第k个元素的和 ，其中v ^↓表示按降序排序的向量v。

那是，

                          a_1 >= b_1
                    a_1 + a_2 >= b_1 + b_2
              a_1 + a_2 + a_3 >= b_1 + b_2 + b_3
                              ...
      a_1 + a_2 + ... + a_n-1 >= b_1 + b_2 + ... + b_n-1
a_1 + a_2 + ... + a_n-1 + a_n >= b_1 + b_2 + ... + b_n-1 + b_n

其中a和b降序排列。

出于此挑战的目的，我们将略微化一般化：我们将说，如果上述所有不等式都为真而未对a和b进行排序，则列表是另一个的未分类的一般化。（当然，这在数学上是无用的，但是使挑战更加有趣。）

挑战

给定两个不同的列表的输入一个和b到255（含）范围为0的整数，长度的两个列表Ñ ≥1时，输出所述第一列表中是否未排序-majorizes第二（一 > b），第二unsorted-主化第一个（b > a），或两者都不选。

您可以选择要求提供两个列表的长度作为输入。输出必须始终是三个不同值之一，但这些值本身可以是您想要的任何值（请指定哪些值代表a > b，b > a，并且在您的答案中都不代表）。

a > b的测试用例：

[255] [254]
[3,2,1] [3,1,2]
[6,1,5,2,7] [2,5,4,3,7]

b > a的测试用例：

[9,1] [10,0]
[6,5,4] [7,6,5]
[0,1,1,2,1,2] [0,1,2,1,2,1]

没有主化的测试用例：

[200,100] [150,250]
[3,1,4] [2,3,3]
[9,9,9,9,9,0] [8,8,8,8,8,9]

果冻，10 8 6 字节

2字节感谢@orlp。

2个字节感谢@Dennis。

_+\ṠQS

在线尝试！

1对于a>b，-1对于a<b，0不进行主化。

_+\ṠQS

_       Difference (vectorized)
 +\     Cumulative sum.
   Ṡ    Sign of every difference
    Q   Deduplicate
     S  Sum

如果同时存在1和-1存在（一些累积总和更大，一些更小），那么将产生最后一步0。

ngn / apl，11个字节

{+/∪×+\⍺-⍵}

基于@Leaky Nun的答案中的方法。

给定两个列表A和B，按元素查找每个值之间的差，或令C = A-B。然后，找到C的累加和并取每个的符号。唯一符号值的总和将成为结果。如果A > B，则结果为1；如果A < B，则结果为-1；如果不存在多数，则结果为0。

在线尝试。

朱莉娅，30个字节

a^b=sum(sign(cumsum(a-b))∪0)

感谢@Dennis，节省了4个字节！

Python 3.5，85个字节：

lambda*e:[all(sum(g[:k])>=sum(h[:k])for k in range(1,-~len(h)))for g,h in[e,e[::-1]]]

匿名lambda函数。返回[True,False]如果a>b，[False,True]如果b>a，或[False,False]如果这两个时间都不是真实的。我希望这可以。

在线试用！（爱迪生）

切达，118个 114字节

n->[n.map(i->i[0]-i[1]).map((j,k,l)->l.slice(0,k+1).sum).map(i->i>0?1:i<0?-1:0)].map(j->j has 1?j has-1?0:1:-1)[0]

基本上我的果冻答案的端口。

函数内部的作用域被破坏导致无法定义函数内部变量的事实意味着我需要[xxx].map(i->yyy)[0]代替var a=xxx;yyy。

将转置数组作为输入。

n->[n
.map(i->i[0]-i[1])                     Difference (vectorized)
.map((j,k,l)->l.slice(0,k+1).sum)      Cumulative sum.
.map(i->i>0?1:i<0?-1:0)]               Sign of every difference
.map(j->j has 1?j has-1?0:1:-1)[0]     Deduplicate and Sum

Python 2，73个字节

a,=b,=r={0}
for x,y in zip(*input()):a+=x;b+=y;r|={cmp(a,b)}
print sum(r)

在Ideone上进行测试。

Ruby，72个 59字节

返回1了a>b，-1对a<b，0对两者都不是。

在他们的Python答案中窃@Dennis的总和--13个字节

在线尝试！

->a,b{x=y=0;a.zip(b).map{|i,j|(x+=i)<=>y+=j}.uniq.inject:+}

Python 2，59个字节

t=r=0
for x,y in zip(*input()):t+=x-y;r|=cmp(t,0)%3
print r

输出：

• 1 对于 a>b
• 2 对于 b>a
• 3 都没有

遍历列表，跟踪连续t的差异之和。该数字s跟踪哪些符号被视为两位数字r：右位为正，左位为负。这是通过发生的cmp(t,0)%3，

• t>0 →交通+1→交通1
• t==0→交通0 →交通0
• t<0 →交通-1→交通2

取的or和的当前值r用来更新2位or，零值无效。

Javascript（使用外部库-Enumerable）（123字节）

(a,b)=>(z=(c,d)=>_.Range(1,c.length).All(x=>_.From(c).Take(x).Sum()>=_.From(d).Take(x).Sum()))(a,b)==z(b,a)?0:(z(a,b)?1:-1)

链接到lib：https : //github.com/mvegh1/Enumerable

代码说明：传入向量a和b，创建全局函数z。z将以创建一个从1开始的整数数组开始，并计算a.length。.All将验证属于a的每个成员的谓词为真。该谓词表示将a作为可枚举加载，对该可枚举进行计数，等于我们对该范围的当前迭代值，然后将其相加。检查> =数组“ b”中的逻辑是否相同。因此，我们按（a，b）的顺序调用z，并将其与（b，a）的顺序进行比较...如果相等，则返回0表示没有大数。否则，如果（a，b）为true，则返回1，否则返回-1