รับค่าเฉลี่ยของรายการ (เช่น[2,6,7])

• รับความยาวของรายการ: [2,6,7] -> 3
• 2 + 6 + 7 = 15สรุปตัวเลขในรายการ:
• 15 / 3 = 5แบ่งผลรวมโดยการนับจำนวนของพวกเขา:

คุณควรเปรียบเทียบค่าเฉลี่ยของทั้งสองรายการของบวกจำนวนเต็มNและMโดยการกลับค่าถ้าไม่มีมีค่าเฉลี่ยสูงกว่าค่าอื่นถ้า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 ชนะ (ไม่มีมี 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 มี 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, สำหรับ-1N < 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, -Infinityสำหรับ M และน่านสำหรับผูก

โซลูชันแรกอาจต้องการคำอธิบายเล็กน้อยเนื่องจากการเรียกซ้ำ:

ในการเรียกใช้ฟังก์ชันครั้งแรกaค่าเริ่มต้นจะเป็นค่าเฉลี่ยของNอาร์เรย์:

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

M มีค่า ณ จุดนี้ดังนั้นส่วนแรกของนิพจน์เงื่อนไขเรียกว่า:

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

ฟังก์ชั่นที่เรียกว่าภายในนิพจน์นี้เวลานี้แทนสำหรับMN

ในการเรียกครั้งที่สองไปยังฟังก์ชัน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หรือน่าน - ให้สามค่าที่แตกต่างกันตามความต้องการ

กรณีทดสอบ:

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 ไบต์

Soooo ตัวดัดแปลงจำนวนมาก ( 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

Julia , 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ถ้าด้านซ้ายมีค่าเฉลี่ยที่สูงกว่า 0 หากพวกเขามีค่าเฉลี่ยเดียวกันและ¯1ถ้าด้านขวามีค่าเฉลี่ยที่สูงขึ้น

×-/(+/÷≢)¨⎕

ลองออนไลน์!

⎕ รวดเร็ว

(...)¨  ใช้ฟังก์ชัน tacit ต่อไปนี้กับแต่ละรายการ:

 +/ ผลรวม

 ÷ หารด้วย

 ≢ นับ

-/ แทรก (และประเมินผล) ลบระหว่างพวกเขา

× Signum

Javascript, 81 66 58 56 ไบต์

บันทึก 15 ไบต์ขอบคุณลุค

บันทึกแล้ว 2 ไบต์ขอบคุณ Justin Mariner

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 อันยิ่งใหญ่แล้ว

Haskell, 65 43 Bytes

บันทึก 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 มาตรฐานสำหรับการคำนวณค่าเฉลี่ยของรายการ
• &จัดให้มีการเปลี่ยนแปลงในส้อม dyadic มันใช้ด้านขวา (กริยาเฉลี่ยในกรณีนี้) กับการขัดแย้งทั้งสองแล้วส่งพวกเขาไปตามกริยาทางด้านซ้ายซึ่งในกรณีนี้คือ ...
• *@- ลบแล้วตามด้วย "sign of": ดังนั้น avg ด้านขวาจะถูกลบออกจากด้านซ้ายและเราจะได้รับเครื่องหมายของผลลัพธ์ - _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Ṡ

ลิงก์ 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และสำหรับfalseM

JavaScript (ES6), 60 54 ไบต์

-6 ไบต์ขอบคุณ @Luke และ @Neil

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

[N, M]จะเข้าเป็นอาร์เรย์ 2 องค์ประกอบ ขาออก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.
• *, map. Take a unary operator and apply it to each element of a list. For instance, # gives the length of a list, but #* gives (a list of) the lengths of the list's items.
• These two metaoperators can be combined: $+* maps fold/plus over a list, summing each of the list's elements.

The other thing to know about Pip is that a lot of operators work item-wise on lists by default. For instance, [1 2 3] * 5 gives [5 10 15]; [1 2 3] * [2 3 4] gives [2 6 12]; and [[1 2] [3 4]] * [5 6] gives [[5 10] [18 24]].

Explanation

We'll use an example input of [[2 3 4] [2 3 4 6]]:

• {...}
  Defines a function. The (first) argument is bound to the local variable a.
• #*a
  Map # to the function's argument, getting the lengths of the sublists. Result: [3 4]
• a/#*a
  Divide (the elements of) the sublists of a by their respective lengths. Result: [[0.667 1 1.333] [0.5 0.75 1 1.5]]
• $+*a/#*a
  Map $+ (fold on addition) to that result, summing the sublists. Result: [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!