목록의 평균을 얻기 (예 [2,6,7])

• 목록의 길이를 가져옵니다. [2,6,7] -> 3
• 목록의 숫자를 합산하십시오 2 + 6 + 7 = 15.
• 합계를 개수로 나눕니다 15 / 3 = 5..

N 이 높은 평균을 갖는 경우 값을, M 이 높은 평균을 갖는 경우 다른 값 을, 넥타이의 경우 다른 값 을 리턴하여 양의 정수 N 및 M 의 두 목록의 평균을 비교해야합니다 .

I / O 규칙

모든 표준 입력 및 출력 방법 이 허용됩니다.

입력

입력을 두 개의 별도 목록, 중첩 목록 또는 작업에 적합한 것으로 간주 할 수 있습니다. 형식을 지정하십시오.

산출

제공된 값은 고유해야하며 공백이 아닌 문자로 구성되어야합니다. 또한 실행간에 일관성이 있어야합니다 ( 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]-> 넥타이 (둘 다 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 개)

기본 허점이 적용됩니다. 설명이 권장됩니다! 이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

실제로 5 바이트

♂æi-s

온라인으로 사용해보십시오!

1for N > M, 0for N = M, -1for 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두 번째 목록 이기면.

자바 스크립트 (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에 대한, 그리고 NaN의 넥타이합니다.

첫 번째 솔루션은 재귀로 인해 약간의 설명이 필요할 수 있습니다.

함수에 대한 첫 번째 호출 a에서 N배열 의 평균으로 초기화됩니다 .

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

M 이 시점에서 값을 가지므로 조건식의 첫 번째 부분이 호출됩니다.

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

이 표현식 내에서 함수가 호출되며 이번에는를 대신 M합니다 N.

이 두 번째 함수 호출에서는 이전 호출에 있었던 –– a의 평균으로 초기화됩니다 .NM

이 함수 호출 중에 두 번째 매개 변수가 없으므로 조건식의 두 번째 부분이 트리거되어 평균을 리턴합니다.

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)

수학, 21 바이트

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

#승리의 경우 1, 승리의 경우 -1 #2, 타이의 경우 0

MATL , 8 바이트

많은 수정 자 ( Y및 Z). 더 짧은 방법을 찾을 수 없습니다. sum / number_of_elements3 바이트입니다. 더 나은 방법 일 수는 -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제 2 입력이 큰 경우.

05AB1E , 9 바이트

한 경우 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묶는 경우를 반환 합니다 .

파이썬 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세 가지 다른 대안 을 얻으십시오 .

파이썬 2, 49 바이트

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

온라인으로 사용해보십시오

APL (Dyalog) , 11 바이트

두 목록의 목록을 묻는 메시지가 표시됩니다. 1왼쪽의 평균이 높은 경우 인쇄 하고, 같은 평균의 경우 0, 오른쪽의 평균이 높은 경우 인쇄 합니다 ¯1.

×-/(+/÷≢)¨⎕

온라인으로 사용해보십시오!

⎕ 신속한

(… )¨ 다음의 암묵적 기능을 각각에 적용하십시오.

 +/ 합계

 ÷ 로 나눈

 ≢ 탈리

-/ 그들 사이에 마이너스를 삽입 (및 평가)

× 부호

자바 스크립트, 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입니다. 카레 구문을 사용하여 호출합니다 (예 :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 바이트

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 포크입니다.
• &Dyadic 포크에 변형을 제공합니다. 그것은 오른쪽 (이 경우 평균 동사)을 두 인수 모두에 적용 한 다음 왼쪽의 동사로 전달합니다.이 경우에는 ...
• *@- 빼기 뒤에 "sign of": 오른쪽 avg가 왼쪽에서 빼고 결과의 부호가 _1, 1 또는 0으로 표시됩니다.

Pyth, 10 8 7 6 바이트

바이트를 저장해 주셔서 감사합니다 @isaacg

._-F.O

입력은 중첩 목록으로 사용 [N, M]됩니다. -1if N < M, 1if N > M및 0같으면 출력 합니다 .

온라인으로 사용해보십시오

TI 기본, 25 21 13 12 10 바이트

lirtosiast 덕분에 -2 바이트

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

젤리 , 7 바이트

S÷Lµ€IṠ

두 목록의 목록을 받아들이는 모나드 링크 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)

펄 6 , 25 바이트

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

온라인으로 사용해보십시오!

두 개의 요소로 구성된 숫자 목록 인 단일 인수를 사용합니다. 반환 1제 목록이 큰 평균이 있다면 -1두 번째 목록이 없으면 및 0평균치가 동일한 경우.

자바 스크립트 (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.

자바 스크립트 (ES6), 60 54 바이트

@Luke와 @Neil 덕분에 -6 바이트

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

Pip, 13 bytes

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

This is a function that takes a list of lists. Returns 1 if the first average is bigger, -1 if the second is bigger, 0 if tied. Run all test cases here.

Background

This solution makes heavy use of two of Pip's metaoperators:

• $, fold. Take a binary operator and apply it between the elements of a list. For instance, + is addition, but $+ sums a list. Note that $ makes a binary operator into a unary operator.
• *,지도. 단항 연산자를 사용하여 목록의 각 요소에 적용하십시오. 예를 들어# gives the length of a list, but #* gives (a list of) the lengths of the list's items.
• 이 두 가지 메타 오퍼레이터를 결합 할 수 있습니다. $+*맵은 목록의 각 요소를 합산하여 겹치 거나 더합니다.

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
  Fold on CM, which gives -1, 0, or 1 depending on the comparison of its two operands (like Python's cmp). Result: -1 (because 3 is smaller than 3.75).

You can also define functions in Pip by writing expressions containing the identity function _. For example, _*_ is a function that squares its argument--syntactic sugar for {a*a}, and fewer bytes. However, there's a bug in the current version of the interpreter that prevents _ from working with the * metaoperator. Once that's fixed, this solution can be 11 bytes: $CM$+*_/#*_.

C (gcc), 91 98 bytes

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;}

Wrong place for C and probably the only answer that doesn't need division. At least the code is displayed without a slider.

Return 0,1,2 for M>N, M=N, M<N respectively. Takes input as length of M, length of N, M, N.

Brachylog, 8 bytes

⟨+/l⟩ᵐ-ṡ

Try it online!

Outputs 1 if the first list has a bigger average, -1 is the second list has a bigger average, and 0 if they are tied.

Explanation

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

Java, 105 bytes

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

Lambda that takes a nested list, as per allowable inputs.

Streams the list of lists, converts both to their averages, then returns the sign of the difference. 1 if the first list is larger, -1 if the second list is larger, 0 for a tie.

R 38 34 bytes

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

Function that takes as input two numeric vectors. Returns 1 if first list average is higher, 0 if they are the same and -1 if second list average is higher.

MATL, 6 bytes

Don't be so mean!*

!-ssZS

Input stack order:

M
N

Output:

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

Try it online!

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

_{*This answer was golfed without being mean to any poor, defenseless numbers.}

Java (OpenJDK 8), 76 62 bytes

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

Try it online!

Since the input can be anything, I decided to take IntStreams as input. You can get such an input from a standard int[] with Arrays.stream(array).

The output is 1 for "N wins", -1 for "M wins", and 0 for tie.

Saves

• -14 bytes from insights of both @Zircon and @Xanderhall!

Dyalog APL, 14 bytes

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

1 if the left is greater, ¯1 if the right is and 0 on tie.

How?

¨∘⊢ for each list

+/÷≢ calculate average (+/ sum ÷ divide by ≢ length)

-/ subtract the averages

× sign of the result

Common Lisp, 74 71 bytes

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

Try it online!