获取列表的平均值（例如[2,6,7]）

• 获取列表的长度： [2,6,7] -> 3
• 汇总列表中的数字：2 + 6 + 7 = 15。
• 将总和除以他们的计数：15 / 3 = 5。

您应该比较两个正整数N和M列表的平均值，如果N的平均值较高，则返回一个值；如果M的平均值较高，则返回另一个值；如果出现平局，则返回另一个值。

I / O规则

允许所有标准的输入和输出方法。

输入值

您可以将输入作为两个单独的列表，一个嵌套列表或您认为适合该任务的任何其他内容。请指定格式。

输出量

提供的值必须是唯一的，并且必须至少包含一个非空白字符。此外，它们在运行之间必须保持一致（N的单个值，M的单个值，Tie的单个值）。请在您的答案中注明。值可以是非空字符串，布尔值，整数或任何您认为合适的值。

眼镜

• 列表的长度不一定相等。

• 您可以确保列表为非空。

测试用例

我选择了和值N wins，这是不言而喻的。M winsTie

N，M->输出（平均值）

[7]，[6]-> N胜（N有7，M有6）
[4,5]，[4,4]-> N胜（N为4.5，M为4）
[2,3,4]，[4,5,6]-> M胜（N有3，M有5）
[4,1,3]，[7,3,2,1,1,2]->并列（均为2.666 ...）
[100,390,1]，[89,82,89]-> N胜（N有163.666 ...，M有86.666 ...）
[92,892]，[892,92]->领带（列表基本相同） 
[10,182]，[12,78,203,91]->并列（均为96）

默认漏洞适用。鼓励解释！这是代码高尔夫球，因此以字节为单位的最短代码胜出！

实际上，5个字节

♂æi-s

在线尝试！

1对N > M，0对N = M，-1对N < M。

说明：

♂æi-s Takes input in format [N, M]
♂æ    Map average
  i   Dump to stack in reverse
   -  Subtract
    s Get sign

Mathematica，15个字节

Order@@Mean/@#&

在线尝试！

Function期望有两个列表。Mean/@#接受输入中每个列表的算术平均值，然后将这些平均值传递给Order，-1如果第一个列表获胜，0有平局以及1第二个列表获胜，则返回。

JavaScript（ES6），52 50字节

（由于@Shaggy，节省了2个字节。）

这是两个50字节的解决方案：

f=(N,M,a=eval(N.join`+`)/N.length)=>M?(a-f(M))/0:a

(N,M,A=a=>eval(a.join`+`)/a.length)=>(A(N)-A(M))/0

对于N，返回Infinity；对于M，返回-Infinity；对于平局，返回NaN。

由于递归，第一个解决方案可能需要一些解释：

在第一次调用该函数时，a被初始化为N数组的平均值：

a=eval(N.join`+`)/N.length

M 此时具有一个值，因此条件表达式的第一部分称为：

M ? (a-f(M))/0 : a  ----------    

该函数的这个表达式中调用，此时代M对N。

在第二次调用该函数时，a将其初始化为上次调用中的N- 的平均值M。

由于在此函数调用期间没有第二个参数，因此将触发条件表达式的第二部分，该部分返回平均值：

M ? (a-f(M))/0 : a  --

现在，我们可以更好地理解该表达式：

(a - f(M)) / 0

它的：

(the average of N  minus  the average of M) divided by 0

平均值之间的差异将为正数，负数或0。

将差除以0会得到Infinity，-Infinity或NaN－根据需要提供三个不同的值。

测试用例：

f=(N,M,a=eval(N.join`+`)/N.length)=>M?(a-f(M))/0:a

console.log(f([7], [6]                 )) // N wins  (N has 7, M has 6 )
console.log(f([4,5], [4,4]             )) // N wins  (N has 4.5, M has 4)
console.log(f([2,3,4], [4,5,6]         )) // M wins  (N has 3, M has 5)
console.log(f([4,1,3], [7,3,2,1,1,2]   )) // Tie     (both have 2.666...)
console.log(f([100,390,1], [89,82,89]  )) // N wins  (N has 163.666..., M has 86.666...)
console.log(f([92,892], [892,92]       )) // Tie     (lists are basically identical) 
console.log(f([10,182], [12,78,203,91] )) // Tie     (both have 96)

Mathematica，21个字节

Sign[Mean@#-Mean@#2]&

1代表#胜利，-1代表#2胜利，0代表并列。

MATL，8字节

许多修饰符（Y和Z）。我找不到缩短它的方法。sum / number_of_elements是三个字节。这可能是一种更好的方法-ZS，但是我找不到。

YmiYm-ZS

在线尝试！

           % Take first input implicitly
Ym         % Mean of that input
  i        % Grab second input
   Ym      % Mean of that input
     -     % Subtract
      ZS   % Sign

1如果第一个输入较大，0如果它们并列，-1第二个输入较大，则返回。

05AB1E，9个字节

如果M获胜则为1，如果获胜则为-1，N并列为0。

vyOyg/}.S

在线尝试！

说明

v           # for each y in list of lists
 yO         # sum y
   yg       # get length of y
     /      # divide
      }     # end loop
       .S   # compare

朱莉娅，27字节

(x,y)->cmp(mean(x),mean(y))

在线尝试！

1如果第一个均值较大，-1第二个均值较大，并且0它们相等，则返回。

Python 2，43个字节

lambda p:cmp(*[sum(l)*1./len(l)for l in p])

在线尝试！

八度，27字节

@(x,y)sign(mean(x)-mean(y))

在线尝试！

取两个向量x.y作为输入，取mean两个向量中的一个，并从另一个中减去一个。得到这个信号，得到1，0并得到-1三种不同的选择。

Python 2，49字节

lambda N,M:cmp(1.*sum(N)/len(N),1.*sum(M)/len(M))

在线尝试

APL（Dyalog），11个字节

提示输入两个列表。1如果左边的平均值较高，则打印；如果它们的平均值相同，¯1则打印0；如果右边的平均值较高，则打印。

×-/(+/÷≢)¨⎕

在线尝试！

⎕ 提示

(…… )¨ 对每个应用以下默认功能：

 +/ 总和

 ÷ 除以

 ≢ 理货

-/ 在它们之间插入（并评估）负号

× 信号

Javascript，81 66 58 56字节

Luke节省了15个字节

贾斯汀·马林纳（Justin Mariner）节省了2个字节

n=>m=>Math.sign((a=b=>eval(b.join`+`)/b.length)(m)-a(n))

并列为0，M为1，N为-1。使用currying语法调用，例如。f([7])([6])

PHP，68字节

<?foreach($_GET as$v)$r[]=array_sum($v)/count($v);echo$r[0]<=>$r[1];

在线尝试！

PHP，69字节

<?=($s=array_sum)($a=$_GET[0])/count($a)<=>$s($b=$_GET[1])/count($b);

在线尝试！

宇宙飞船操作员 -1小于1，领带0，大于1

Haskell，65 43字节

感谢nimi，节省了22个字节！

a x=sum x/sum[1|_<-x] 
x#y=compare(a x)$a y

必须有一个更好的方法。。。但是类型转换使我感到困惑。

用法

(#) [7] [6]

返回GT第一个参数是否获胜，LT第二个参数是否获胜以及EQ是否平局。

在线尝试！

J，10个字节

*@-&(+/%#)

左边给出一个列表，右边给出一个列表。如果左平均值较小，则返回_1，如果左平均值较大，则返回1，如果相等则返回0。

• (+/%#) 是用于计算列表平均值的标准J叉子
• &提供了二叉叉的变体。它将右侧（在这种情况下为平均动词）应用于两个自变量，然后将它们传递到左侧的动词（在本例中为...）
• *@- 减去后跟“符号”：因此从左边减去右边的平均值，我们得到结果的符号-_1、1或0

Pyth，10 8 7 6个字节

感谢@isaacg节省了一个字节

._-F.O

输入被视为嵌套列表[N, M]。输出-1if N < M，1if N > M和0if相等。

在线试用

TI-Basic，25 21 13 12 10字节

-2个字节，感谢lirtosiast

:tanh(ᴇ9mean(L₁-mean(L₂

果冻，7 个字节

S÷Lµ€IṠ

一个monadic链路接受两个列表的列表，N,M它返回：
[-1]对于N;
[1]为M; 和
[0]领带。
作为一个完整的程序将打印结果（单个项目清单打印的内容而已，所以-1，1或0）。

在线尝试！

怎么样？

S÷Lµ€IṠ - Link: list of lists, [N,M]
   µ€   - perform the chain to the left for €ach (of N, M)
S       -   sum
  L     -   length
 ÷      -   divide (yields the average)
     I  - incremental differences (yields [avg(M) - avg(N)])
      Ṡ - sign (yields: [1] if avg(M)>avg(N); [-1] if avg(N)>avg(M); or [0] if equal)

Perl 6，25个字节

{sign [-] .map:{.sum/$_}}

在线尝试！

有一个参数，一个由两个元素组成的数字列表。返回1如果第一个列表中有更大的平均值，-1如果第二列表确实，和0如果平均值相等。

JavaScript（ES6），60个字节

a=>(b=(c=a.map(d=>eval(d.join`+`)/d.length))[0])-c[1])?b>0:0

输出0为Tie，true为N而false为M。

JavaScript（ES6），60 54字节

-6个字节，感谢@Luke和@Neil

(i,[x,y]=i.map(v=>eval(v.join`+`)/v.length))=>y-x&&x>y

将输入作为2元素数组[N, M]。输出true，0或false用于N，Tie或M分别。

说明

(i,                 // input array: [N, M]
    [x,y] =         // destructure assignment: set x and y to...
    i.map(v=>       // the input values mapped as...
        eval(v.join`+`) // the sum, by joining the array with +
        / v.length      // divided by the length
    )
) => y-x && x>y     // return 0 for tie, or the result of avg(N) > avg(M)

测试片段

输入数字，以空格/逗号分隔。

f=
(i,[x,y]=i.map(v=>eval(v.join`+`)/v.length))=>y-x&&x>y

<div oninput="O.value=f([N.value,M.value].map(x=>x.split(/[ ,]+/)))">N <input id=N> M <input id=M></div>
Out: <input id=O disabled>

点，13字节

{$CM$+*a/#*a}

此功能需要一个列表列表。返回1如果第一平均较大，-1如果第二比较大，0如果打成平手。在这里运行所有测试用例。

背景

该解决方案大量使用了Pip的两个元运算符：

• $，折叠。使用二进制运算符并将其应用于列表的元素之间。例如，+是加法，但$+求和列表。请注意，$将二进制运算符转换为一元运算符。
• *，地图。采取一元运算符并将其应用于列表的每个元素。例如，#给出列表的长度，但是#*给出列表项的长度（列表）。
• 可以将这两个元运算符组合在一起：$+*将折叠/加号映射到列表上，对列表的每个元素求和。

了解Pip的另一件事是，默认情况下，许多运算符在列表中逐项工作。例如，[1 2 3] * 5给出[5 10 15]; [1 2 3] * [2 3 4]给[2 6 12]; 并[[1 2] [3 4]] * [5 6]给[[5 10] [18 24]]。

说明

我们将使用以下示例输入[[2 3 4] [2 3 4 6]]：

• {...}
  定义一个功能。（第一个）参数绑定到局部变量a。
• #*a
  映射#到函数的参数，获取子列表的长度。结果：[3 4]
• a/#*a
  子列表（的元素）除以a它们各自的长度。结果：[[0.667 1 1.333] [0.5 0.75 1 1.5]]
• $+*a/#*a
  映射$+（加倍折叠）到该结果，对子列表求和。结果：[3 3.75]
• $CM$+*a/#*a
  折上CM，给出-1，0或1取决于其两个操作数（例如Python cmp）的比较。结果：（-1因为3小于3.75）。

您还可以通过编写包含identity函数的表达式在Pip中定义函数_。例如，_*_是一个将其参数平方的函数-的语法糖{a*a}和更少的字节。但是，当前版本的解释器中存在一个错误，阻止_与元*运算符一起使用。固定后，此解决方案可以为11个字节：$CM$+*_/#*_。

C（gcc），91 98 个字节

u,v,j;f(x,y,a,b)int*a,*b;{for(u=v=0;x--;u+=a[x])for(j=0;j<y;)v+=b[j++];j=u*y-v;x=j>0?2:!j;}

C的位置错误，并且可能是不需要除法的唯一答案。至少显示的代码没有滑块。

返回为0,1,2 M>N，M=N，M<N分别。需要输入为length of M，length of N，M，N。

Brachylog，8个字节

⟨+/l⟩ᵐ-ṡ

在线尝试！

输出1如果第一个列表中有更大的平均值，-1是第二个列表中有更大的平均水平，0如果他们被捆绑。

说明

     ᵐ        Map:
⟨   ⟩           Fork:
 +                Sum…
  /               …divided by…
   l              …length
       -      Subtract
        ṡ     Sign

Java，105个字节

s->s.stream().map(l->l.stream().reduce((i,j)->i+j).get()/l.size()).reduce((i,j)->Math.signum(i-j)).get();

根据允许的输入，采用嵌套列表的Lambda。

流式处理列表列表，将其均转换为平均值，然后返回差异的符号。1如果第一个列表较大，-1则第二个列表较大，0为平局。

R 38 34字节

function(a,b)sign(mean(a)-mean(b))

以两个数值向量为输入的函数。如果第一个列表平均值较高，则返回1；如果相同，则返回0；如果第二个列表平均值较高，则返回-1。

MATL，6个字节

别那么刻薄！*

!-ssZS

输入堆栈顺序：

M
N

输出：

 1 = N wins  
-1 = M wins  
 0 = tie

在线尝试！

!-ssZS
========
!           % transpose M
 -          % N - M^T using elementwise subtraction and implicit expansion
  s         % sum columns of the result
   s        % sum the resulting row vector
    ZS      % sign of the sum

_{*这个答案是毫无顾忌的，可怜的，毫无防备的数字。}

Java（OpenJDK 8），76 62字节

a->b->Math.signum(a.average().orElse(0)-b.average().orElse(0))

在线尝试！

由于输入可以是任何东西，因此我决定将IntStreams作为输入。您可以从标准中获得这样的输入int[]用Arrays.stream(array)。

输出1为“ N胜”，-1 “ M赢”和0平局。

节省

• 来自@Zircon和@Xanderhall的见解的-14个字节！

Dyalog APL，14个字节

×(-/(+/÷≢)¨∘⊢)

1如果左边更大，¯1如果右边更大，则0平局。

怎么样？

¨∘⊢ 对于每个列表

+/÷≢计算平均值（+/总和÷除以≢长度）

-/ 减去平均值

× 结果的征兆

普通Lisp，74 71字节

(defun g(x)(/(apply'+ x)(length x)))(defun f(x y)(signum(-(g x)(g y))))

在线尝试！