Получение среднего из списка (например [2,6,7])

• Получить длину списка: [2,6,7] -> 3
• Суммировать числа в списке: 2 + 6 + 7 = 15.
• Разделите сумму на их подсчета: 15 / 3 = 5.

Вы должны сравнить средние значения двух списков натуральных чисел N и M , возвращая значение, если N имеет более высокое среднее значение, другое значение, если M имеет более высокое среднее значение, и другое значение в случае связи.

Правила ввода / вывода

Все стандартные методы ввода и вывода разрешены.

вход

Вы можете использовать входные данные в виде двух отдельных списков, вложенного списка или чего-либо еще, что вы считаете подходящим для этой задачи. Пожалуйста, укажите формат.

Выход

Указанные значения должны быть различны и состоять как минимум из одного непробельного символа. Кроме того, они должны быть согласованы между прогонами (одно значение для N , одно значение для M , одно значение для Tie ). Пожалуйста, укажите это в своем ответе. Значения могут быть непустыми строками, значениями типа Bool, целыми числами или чем угодно, что вы считаете подходящим.

Спекуляции

• Списки не обязательно будут иметь одинаковую длину.

• Вам гарантировано, что списки не являются пустыми.

Тестовые случаи

Я выбрал значения N wins, M winsи Tie, которые в значительной степени самоочевидны.

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] -> Tie (оба имеют 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 байт

(Сохранено 2 байта благодаря @Shaggy.)

Вот два 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, бесконечность для M и 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 или 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 байтов

1 если Mпобедит, -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 (Дьялог) , 11 байт

Запрашивает список из двух списков. Печатается, 1если левое имеет более высокое среднее значение, 0, если у них одинаковое среднее значение, а ¯1если справа - более высокое среднее.

×-/(+/÷≢)¨⎕

Попробуйте онлайн!

⎕ незамедлительный

(… )¨ Применить следующую молчаливую функцию к каждому:

 +/ сумма

 ÷ деленное на

 ≢ подсчет

-/ вставить (и оценить) минус между ними

× сигнум

Javascript, 81 66 58 56 байт

спас 15 байтов благодаря Люку

сэкономил 2 байта благодаря Джастину Маринеру

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

Галстук равен 0, М равен 1 и N равен -1. Вызывается с использованием синтаксиса карри, например.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 меньше, 0 галстук, 1 больше, чем

Хаскелл, 65 43 байта

Сохранено 22 байта благодаря NIMI!

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]. Выходы -1если N < M, 1если N > Mи 0если они равны.

Попробуйте онлайн

TI-Basic, 25 21 13 12 10 байт

-2 байта благодаря lirtosiast

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

Желе , 7 байт

S÷Lµ€IṠ

Монадическая ссылка, принимающая список из двух списков, N,Mкоторый возвращает:
[-1]for 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, это то, что многие операторы по умолчанию работают со списками по пунктам. Например, [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).

Вы также можете определить функции в 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.

Брахилог , 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();

Лямбда, которая принимает вложенный список, согласно допустимым входам.

Потоки списка списков, преобразует оба в их средние значения, а затем возвращает знак разницы. 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для «М выигрышей» и0 для ничьей.

Сохраняет

• -14 байтов из идей @Zircon и @Xanderhall!

Dyalog APL, 14 байтов

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

1если левый больше, ¯1если правый и 0на галстуке.

Как?

¨∘⊢ для каждого списка

+/÷≢рассчитать среднее ( +/сумма ÷делится на ≢длину)

-/ вычесть средние

× признак результата

Common Lisp , 74 71 байт

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

Попробуйте онлайн!