Ermitteln des Durchschnitts einer Liste (z. B. [2,6,7])

• Holen Sie sich die Länge der Liste: [2,6,7] -> 3
• Addieren Sie die Zahlen in der Liste: 2 + 6 + 7 = 15.
• Teilen Sie die Summe durch ihre Zahl: 15 / 3 = 5.

Sie sollten die Durchschnittswerte zweier Listen positiver ganzer Zahlen N und M vergleichen , indem Sie einen Wert zurückgeben, wenn N einen höheren Durchschnitt aufweist, einen anderen Wert, wenn M einen höheren Durchschnitt aufweist, und einen anderen Wert im Falle eines Gleichstands.

I / O-Regeln

Alle standardmäßigen Eingabe- und Ausgabemethoden sind zulässig.

Eingang

Sie können Eingaben in Form von zwei separaten Listen, einer verschachtelten Liste oder anderen Elementen vornehmen, die Sie für die Aufgabe als geeignet erachten. Bitte geben Sie das Format an.

Ausgabe

Die angegebenen Werte müssen eindeutig sein und aus mindestens einem Nicht-Leerzeichen bestehen. Außerdem müssen sie zwischen den Läufen konsistent sein (ein einzelner Wert für N , ein einzelner Wert für M , ein einzelner Wert für Tie ). Bitte geben Sie diese in Ihrer Antwort an. Die Werte können nicht leere Strings, Bool-Werte, Ganzzahlen oder alles sein, was Sie für geeignet halten.

Technische Daten

• Die Listen müssen nicht unbedingt gleich lang sein.

• Sie werden garantiert, dass die Listen nicht leer sind.

Testfälle

Ich entschied mich für die Werte N wins, M winsund Tie, was ziemlich viel selbstverständlich sind.

N, M -> Output (Durchschnittswerte)

[7], [6] -> N gewinnt (N hat 7, M hat 6)
[4,5], [4,4] -> N gewinnt (N hat 4,5, M hat 4)
[2,3,4], [4,5,6] -> M gewinnt (N hat 3, M hat 5)
[4,1,3], [7,3,2,1,1,2] -> Krawatte (beide haben 2,666 ...)
[100,390,1], [89,82,89] -> N Siege (N hat 163,666 ..., M hat 86,666 ...)
[92,892], [892,92] -> Krawatte (Listen sind grundsätzlich identisch) 
[10,182], [12,78,203,91] -> Krawatte (beide haben 96)

Es gelten Standardlücken . Erklärungen sind erwünscht! Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

Eigentlich 5 Bytes

♂æi-s

Probieren Sie es online!

1für N > M, 0für N = M, -1für N < M.

Erläuterung:

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

Mathematica, 15 Bytes

Order@@Mean/@#&

Probieren Sie es online!

Functiondas erwartet eine Liste von zwei Listen. Mean/@#Nimmt man das arithmetische Mittel jeder Liste in der Eingabe, so werden diese Mittelwerte übergeben Order, die zurückgegeben werden, -1wenn die erste Liste gewinnt, 0wenn ein Gleichstand besteht und 1wenn die zweite Liste gewinnt.

JavaScript (ES6), 52-50 Byte

(2 Bytes dank @Shaggy gespeichert.)

Hier sind zwei 50-Byte-Lösungen:

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

Gibt Infinity für N, -Infinity für M und NaN für einen Gleichstand zurück.

Die erste Lösung erfordert aufgrund der Rekursion möglicherweise einige Erläuterungen:

Wird beim ersten Aufruf der Funktion aals Durchschnitt des NArrays initialisiert :

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

M Hat an dieser Stelle einen Wert, so heißt der erste Teil des bedingten Ausdrucks:

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

Die Funktion ist in diesem Ausdruck bezeichnet, diesmal Substitution Mfür N.

Bei diesem zweiten Aufruf der Funktion awird der Durchschnitt von N–– initialisiert, der Mbeim vorherigen Aufruf ermittelt wurde.

Da es während dieses Funktionsaufrufs keinen zweiten Parameter gibt, wird der zweite Teil des Bedingungsausdrucks ausgelöst, der den Durchschnitt zurückgibt:

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

Wir können den Ausdruck jetzt besser verstehen:

(a - f(M)) / 0

Es ist:

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

Die Differenz zwischen den Durchschnittswerten ist eine positive Zahl, eine negative Zahl oder 0.

Wenn Sie die Differenz durch 0 dividieren , erhalten Sie Infinity , -Infinity oder NaN - und die erforderlichen drei unterschiedlichen Werte.

Testfälle:

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 Bytes

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

1 für #Siege, -1 für #2Siege, 0 für Gleichstand.

MATL , 8 Bytes

Soooo viele Modifikatoren ( Yund Z). Ich kann keinen Weg finden, es kürzer zu machen. sum / number_of_elementsist drei Bytes. Es könnte eine bessere Möglichkeit sein -ZS, aber ich kann keine finden.

YmiYm-ZS

Probieren Sie es online!

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

Gibt zurück, 1wenn die erste Eingabe größer ist, 0wenn sie gleich ist und -1wenn die zweite Eingabe größer ist.

05AB1E , 9 Bytes

1 wenn Mgewinnt, -1 wenn Ngewinnt und 0 für ein Unentschieden.

vyOyg/}.S

Probieren Sie es online!

Erläuterung

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

Julia , 27 Bytes

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

Probieren Sie es online!

Gibt zurück, 1wenn der erste Durchschnitt größer ist, -1wenn der zweite größer ist und 0wenn sie gleich sind.

Python 2 , 43 Bytes

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

Probieren Sie es online!

Oktave , 27 Bytes

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

Probieren Sie es online!

Nimmt zwei Vektoren x.yals Eingabe, nimmt den meanvon beiden Vektoren und subtrahiert einen vom anderen. Holen Sie sich das Zeichen dafür, zu bekommen 1, 0und -1für die drei verschiedenen Alternativen.

Python 2, 49 Bytes

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

Probieren Sie es online aus

APL (Dyalog) , 11 Bytes

Fordert zur Eingabe einer Liste mit zwei Listen auf. Druckt1Wird wenn der linke Durchschnitt höher ist, 0, wenn derselbe Durchschnitt vorliegt, und ¯1wenn der rechte Durchschnitt höher ist.

×-/(+/÷≢)¨⎕

Probieren Sie es online!

⎕ Prompt

(…)¨  Wenden auf jede folgende stillschweigende Funktion an:

 +/ die Summe

 ÷ geteilt durch

 ≢ die Bilanz

-/ Fügen Sie ein Minus dazwischen ein (und werten Sie es aus)

× signum

Javascript, 81 66 58 56 Bytes

15 Bytes gespart dank Luke

2 Bytes gespart dank Justin Mariner

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

Gleichstand ist 0, M ist 1 und N ist -1. Wird mit der Currying-Syntax aufgerufen, z.f([7])([6])

PHP , 68 Bytes

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

Probieren Sie es online!

PHP , 69 Bytes

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

Probieren Sie es online!

Raumschiffoperator -1 weniger als, 0 Gleichstand, 1 größer als

Haskell, 65 43 Bytes

22 Bytes gespart dank nimi!

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

Es muss einen viel besseren Weg geben ... Aber Typumwandlungen haben mich fertig gemacht.

Verwendung

(#) [7] [6]

Gibt zurück, GTwenn das erste Argument gewinnt, LTwenn das zweite Argument gewinnt und EQwenn sie gleich sind.

Probieren Sie es online!

J, 10 Bytes

*@-&(+/%#)

Eine Liste links, eine rechts. Gibt _1 zurück, wenn der linke Durchschnitt kleiner ist, 1, wenn er größer ist, und 0, wenn sie gleich sind

• (+/%#) ist eine Standard-J-Gabel zur Berechnung des Durchschnitts einer Liste
• &bietet eine Variation der dyadischen Gabel. es wendet die rechte Seite (in diesem Fall das Durchschnittsverb) auf beide Argumente an und leitet sie dann an das Verb auf der linken Seite weiter, das in diesem Fall ...
• *@- subtrahieren, gefolgt von "Vorzeichen von": Der rechte Durchschnitt wird von dem linken subtrahiert, und wir erhalten das Vorzeichen des Ergebnisses - _1, 1 oder 0

Pyth, 10 8 7 6 Bytes

Vielen Dank an @isaacg für das Speichern eines Bytes

._-F.O

Die Eingabe wird als verschachtelte Liste verwendet [N, M]. Ausgänge -1wenn N < M,1 ob N > Mund 0ob sie gleich sind.

Probieren Sie es online

TI-Basic, 25 21 13 12 10 Bytes

-2 Bytes dank Lirtosiast

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

Gelee , 7 Bytes

S÷Lµ€IṠ

Ein monadischer Link, der eine Liste der beiden Listen akzeptiert und Folgendes N,Mzurückgibt:
[-1]for N;
[1]für M; und
[0]für ein Unentschieden.
Als Full - Programm gibt es das Ergebnis (Einzelstücklisten drucken dessen Inhalt nur so -1, 1oder 0).

Probieren Sie es online!

Wie?

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 Bytes

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

Probieren Sie es online!

Nimmt ein einziges Argument, eine aus zwei Elementen bestehende Liste von Zahlenlisten. Gibt zurück, 1wenn die erste Liste einen höheren Durchschnitt aufweist, -1wenn die zweite Liste einen höheren Durchschnitt aufweist und 0wenn die Durchschnittswerte gleich sind.

JavaScript (ES6), 60 Byte

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

Ausgänge 0für Tie, truefür Nund falsefür M.

JavaScript (ES6), 60 54 Bytes

-6 Bytes dank @Luke und @Neil

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

Nimmt Eingaben als Array mit zwei Elementen an [N, M]. Ausgänge true, 0oder falsefürN , TieoderM , respectively.

Erläuterung

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

Testschnipsel

Geben Sie Zahlen durch Leerzeichen / Kommas getrennt ein.

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}

Dies ist eine Funktion, die eine Liste von Listen aufnimmt. Gibt zurück, 1wenn der erste Durchschnitt größer ist, -1wenn der zweite größer ist, 0wenn er gebunden ist. Führen Sie hier alle Testfälle aus.

Hintergrund

Diese Lösung nutzt zwei der Pip-Metaoperatoren:

• $, falten. Nehmen Sie einen binären Operator und wenden Sie ihn zwischen den Elementen einer Liste an. Zum Beispiel +ist Addition, $+summiert aber eine Liste. Beachten Sie, $dass ein binärer Operator zu einem unären Operator wird.
• *, Karte. Nehmen Sie einen unären Operator und wenden Sie ihn auf jedes Element einer Liste an. Gibt zum Beispiel #die Länge einer Liste an, #*gibt aber (eine Liste von) die Länge der Listenelemente an.
• Diese beiden Metaoperatoren können kombiniert werden: $+*Maps falten / plus über eine Liste und summieren die einzelnen Elemente der Liste.

Das andere, was Sie über Pip wissen sollten, ist, dass viele Operatoren standardmäßig in Listen arbeiten. Zum Beispiel [1 2 3] * 5gibt [5 10 15]; [1 2 3] * [2 3 4]gibt [2 6 12]; und [[1 2] [3 4]] * [5 6]gibt [[5 10] [18 24]].

Erläuterung

Wir verwenden eine Beispieleingabe von [[2 3 4] [2 3 4 6]]:

• {...}
  Definiert eine Funktion. Das (erste) Argument ist an die lokale Variable gebunden a.
• #*a
  Ordnen Sie #dem Argument der Funktion zu und ermitteln Sie die Länge der Unterlisten. Ergebnis:[3 4]
• a/#*a
  Teilen Sie die Elemente der Unterlisten adurch ihre jeweilige Länge. Ergebnis:[[0.667 1 1.333] [0.5 0.75 1 1.5]]
• $+*a/#*a
  Ordnen Sie $+diesem Ergebnis eine (aufklappbare) Addition zu und addieren Sie die Unterlisten. Ergebnis:[3 3.75]
• $CM$+*a/#*a
  Falte auf CM, was ergibt -1, 0oder 1abhängig vom Vergleich seiner beiden Operanden (wie Pythons cmp). Ergebnis: -1(weil 3kleiner als 3.75).

Sie können Funktionen in Pip auch definieren, indem Sie Ausdrücke schreiben, die die Identitätsfunktion enthalten _. Zum Beispiel _*_ist eine Funktion, die ihr Argument quadriert - syntaktischer Zucker für {a*a}und weniger Bytes. In der aktuellen Version des Interpreters gibt es jedoch einen Fehler, der die _Arbeit mit dem *Metaoperator verhindert. Sobald das Fest ist, kann diese Lösung 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;}

Falscher Platz für C und wahrscheinlich die einzige Antwort, die keine Division benötigt. Zumindest der Code wird ohne Schieberegler angezeigt.

Rück 0,1,2 für M>N, M=N, M<Njeweils. Nimmt als Eingang length of M, length of N, M, N.

Brachylog , 8 Bytes

⟨+/l⟩ᵐ-ṡ

Probieren Sie es online!

Gibt aus, 1ob die erste Liste einen größeren Durchschnitt aufweist, -1die zweite Liste einen größeren Durchschnitt aufweist und0 ob sie gebunden sind.

Erläuterung

     ᵐ        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, das eine verschachtelte Liste gemäß zulässiger Eingaben annimmt.

Überträgt die Liste der Listen in einen Stream, wandelt beide in ihre Durchschnittswerte um und gibt dann das Vorzeichen der Differenz zurück. 1Wenn die erste Liste größer ist, -1wenn die zweite Liste größer ist, 0für ein Unentschieden.

R 38 34 Bytes

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

Funktion, die zwei numerische Vektoren als Eingabe verwendet. Gibt 1 zurück, wenn der erste Listenmittelwert höher ist, 0, wenn sie gleich sind, und -1, wenn der zweite Listenmittelwert höher ist.

MATL , 6 Bytes

Sei nicht so gemein! *

!-ssZS

Stapelreihenfolge eingeben:

M
N

Ausgabe:

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

Probieren Sie es 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

_{* Diese Antwort wurde gespielt, ohne gegen arme, wehrlose Zahlen zu sein.}

Java (OpenJDK 8) , 76 62 Bytes

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

Probieren Sie es online!

Da der Input alles sein kann, habe ich mich entschieden, IntStreams als Input zu nehmen . Sie können eine solche Eingabe von einem Standard int[]mit erhalten Arrays.stream(array).

Die Ausgabe erfolgt 1für "N Siege", -1für "M Siege" und 0für Unentschieden.

Speichert

• -14 Bytes aus den Erkenntnissen von @Zircon und @Xanderhall!

Dyalog APL, 14 Bytes

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

1wenn die linke ist größer, ¯1wenn die rechte ist und 0auf Krawatte.

Wie?

¨∘⊢ für jede Liste

+/÷≢ Durchschnitt berechnen (+/ Summe ÷durch ≢Länge teilen )

-/ subtrahieren Sie die Durchschnitte

× Zeichen des Ergebnisses

Common Lisp , 74 71 Bytes

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

Probieren Sie es online!