Obtenir la moyenne d'une liste (par exemple [2,6,7])

• Obtenez la longueur de la liste: [2,6,7] -> 3
• La somme des numéros dans la liste: 2 + 6 + 7 = 15.
• Diviser la somme par leur nombre: 15 / 3 = 5.

Vous devez comparer les moyennes de deux listes d' entiers positifs N et M , en renvoyant une valeur si N a une moyenne plus élevée, une autre valeur si M a une moyenne plus élevée et une autre en cas d'égalité.

Règles d'E / S

Toutes les méthodes d'entrée et de sortie standard sont autorisées.

Contribution

Vous pouvez prendre la saisie sous la forme de deux listes distinctes, une liste imbriquée ou tout autre élément que vous jugez approprié pour la tâche. Veuillez spécifier le format.

Production

Les valeurs fournies doivent être distinctes et doivent comprendre au moins un caractère non blanc. De plus, ils doivent être cohérents entre les exécutions (une seule valeur pour N , une seule valeur pour M , une seule valeur pour Tie ). Veuillez les préciser dans votre réponse. Les valeurs peuvent être des chaînes non vides, des valeurs booléennes, des entiers ou tout ce que vous jugez approprié.

Spécifications

• Les listes n'auront pas nécessairement la même longueur.

• Vous êtes assuré que les listes ne sont pas vides.

Cas de test

J'ai choisi les valeurs N wins, M winsetTie qui sont assez évidentes.

N, M -> Sortie (moyennes)

[7], [6] -> N gagne (N en a 7, M en a 6)
[4,5], [4,4] -> N gagne (N en a 4,5, M en a 4)
[2,3,4], [4,5,6] -> M gagne (N en a 3, M en a 5)
[4,1,3], [7,3,2,1,1,2] -> Cravate (les deux ont 2,666 ...)
[100,390,1], [89,82,89] -> N gagne (N a 163,666 ..., M a 86,666 ...)
[92,892], [892,92] -> Tie (les listes sont fondamentalement identiques) 
[10,182], [12,78,203,91] -> Cravate (les deux en ont 96)

Les échappatoires par défaut s'appliquent. Les explications sont encouragées! C'est le code-golf , donc le code le plus court en octets gagne!

En fait , 5 octets

♂æi-s

Essayez-le en ligne!

1pour N > M, 0pour N = M, -1pour N < M.

Explication:

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

Mathematica, 15 octets

Order@@Mean/@#&

Essayez-le en ligne!

Functionqui attend une liste de deux listes. Mean/@#prend la moyenne arithmétique de chaque liste en entrée, puis ces moyennes sont passées à Order, qui retourne -1si la première liste gagne, 0s'il y a égalité et 1si la deuxième liste gagne.

JavaScript (ES6), 52 50 octets

(Enregistré 2 octets grâce à @Shaggy.)

Voici deux solutions de 50 octets:

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

Renvoie Infinity pour N, -Infinity pour M et NaN pour une égalité.

La première solution peut nécessiter un peu d'explication en raison de la récursivité:

Au premier appel à la fonction, aest initialisé comme la moyenne du Ntableau:

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

M a une valeur à ce stade, donc la première partie de l'expression conditionnelle est appelée:

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

La fonction est appelée dans cette expression, cette fois remplaçant MpourN .

Sur ce deuxième appel à la fonction, aest initialisé comme la moyenne de N–– qui étaitM lors de l'appel précédent.

Puisqu'il n'y a pas de second paramètre lors de cet appel à la fonction, la deuxième partie de l'expression conditionnelle est déclenchée, ce qui renvoie la moyenne:

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

Nous pouvons maintenant mieux comprendre l'expression:

(a - f(M)) / 0

Ses:

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

La différence entre les moyennes sera un nombre positif, un nombre négatif ou 0.

En divisant la différence par 0 , vous obtenez Infinity , -Infinity ou NaN - fournissant les trois valeurs distinctes requises.

Cas de test:

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 octets

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

1 pour les #victoires, -1 pour les #2victoires, 0 pour l'égalité.

MATL , 8 octets

Soooo de nombreux modificateurs ( Yet Z). Je ne peux pas trouver un moyen de le raccourcir. sum / number_of_elementsest de trois octets. Ce pourrait être une meilleure façon de le faire -ZS, mais je n'en trouve pas.

YmiYm-ZS

Essayez-le en ligne!

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

Renvoie 1si la première entrée est plus grande, 0si elles sont liées et -1si la deuxième entrée est plus grande.

05AB1E , 9 octets

1 si Mgagne, -1 si Ngagne et 0 pour une égalité.

vyOyg/}.S

Essayez-le en ligne!

Explication

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

Julia , 27 octets

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

Essayez-le en ligne!

Renvoie 1si la première moyenne est plus grande, -1si la seconde l'est et 0si elles sont égales.

Python 2 , 43 octets

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

Essayez-le en ligne!

Octave , 27 octets

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

Essayez-le en ligne!

Prend deux vecteurs x.yen entrée, prend les meandeux vecteurs et soustrait l'un de l'autre. Obtenez le signe de cela, pour obtenir 1, 0et -1pour les trois alternatives différentes.

Python 2, 49 octets

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

Essayez-le en ligne

APL (Dyalog) , 11 octets

Demande une liste de deux listes. Imprime 1si la gauche a une moyenne plus élevée, 0 si elles ont la même moyenne et ¯1si la droite a une moyenne plus élevée.

×-/(+/÷≢)¨⎕

Essayez-le en ligne!

⎕ rapide

(… )¨ Appliquer à chacun la fonction tacite suivante:

 +/ la somme

 ÷ divisé par

 ≢ le décompte

-/ insérer (et évaluer) un moins entre eux

× signum

Javascript, 81 66 58 56 octets

économisé 15 octets grâce à Luke

économisé 2 octets grâce à Justin Mariner

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

Le lien est 0, M est 1 et N est -1. Appelé en utilisant la syntaxe de curry, par exemple.f([7])([6])

PHP , 68 octets

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

Essayez-le en ligne!

PHP , 69 octets

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

Essayez-le en ligne!

opérateur de vaisseau spatial -1 inférieure à, 0 tie, une plus grande alors

Haskell, 65 43 octets

22 octets enregistrés grâce à nimi!

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

Il doit y avoir un bien meilleur moyen ... Mais les conversions de type m'ont foutu.

Usage

(#) [7] [6]

Renvoie GTsi le premier argument l'emporte, LTsi le deuxième argument l'emporte et EQs'ils sont liés.

Essayez-le en ligne!

J, 10 octets

*@-&(+/%#)

Une liste donnée à gauche, une à droite. Renvoie _1 si la moyenne de gauche est plus petite, 1 si elle est plus grande et 0 si elles sont égales

• (+/%#) est une fourchette J standard pour calculer la moyenne d'une liste
• &fournit une variation sur la fourche dyadique. il applique le côté droit (le verbe moyen, dans ce cas) aux deux arguments, puis les transmet au verbe du côté gauche, qui dans ce cas est ...
• *@- soustraire suivi de "signe de": donc la moyenne de droite est soustraite de la gauche, et on nous donne le signe du résultat - _1, 1 ou 0

Pyth, 10 8 7 6 octets

Merci @isaacg d'avoir enregistré un octet

._-F.O

L' entrée est considérée comme une liste imbriquée, [N, M]. Sorties -1si N < M, 1si N > Met0 si elles sont égales.

Essayez-le en ligne

TI-Basic, 25 21 13 12 10 octets

-2 octets grâce au lirtosiast

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

Gelée , 7 octets

S÷Lµ€IṠ

Un lien monadique acceptant une liste des deux listes, N,Mqui renvoie:
[-1]for N;
[1]pour M; et
[0]pour une cravate.
En tant que programme complet , il imprime le résultat (liste d'article unique imprimer leur contenu uniquement, donc -1, 1ou0 ).

Essayez-le en ligne!

Comment?

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 octets

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

Essayez-le en ligne!

Prend un seul argument, une liste à deux éléments de listes de nombres. Renvoie 1si la première liste a une moyenne supérieure, -1si la deuxième liste en a et 0si les moyennes sont égales.

JavaScript (ES6), 60 octets

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

Sorties 0pour Tie, truepour Net falsepour M.

JavaScript (ES6), 60 54 octets

-6 octets grâce à @Luke et @Neil

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

Prend l'entrée comme un tableau à 2 éléments [N, M]. Sorties true, 0ou falsepour N, Tieou M, respectivement.

Explication

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

Extrait de test

Entrez les nombres séparés par des espaces / virgules.

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 octets

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

Il s'agit d'une fonction qui prend une liste de listes. Renvoie 1si la première moyenne est plus grande, -1si la seconde est plus grande, 0si elle est liée.Exécutez tous les cas de test ici.

Contexte

Cette solution fait un usage intensif de deux des méta-opérateurs de Pip:

• $, plier. Prenez un opérateur binaire et appliquez-le entre les éléments d'une liste. Par exemple, +est addition, mais $+résume une liste. Notez que $transforme un opérateur binaire en opérateur unaire.
• *, carte. Prenez un opérateur unaire et appliquez-le à chaque élément d'une liste. Par exemple, #donne la longueur d'une liste, mais#* donne (une liste de) la longueur des éléments de la liste.
• Ces deux méta-opérateurs peuvent être combinés: les $+*cartes se replient / plus sur une liste, sommant chacun des éléments de la liste.

L'autre chose à savoir sur Pip est que de nombreux opérateurs travaillent par défaut sur les listes. Par exemple, [1 2 3] * 5donne [5 10 15]; [1 2 3] * [2 3 4]donne [2 6 12]; et [[1 2] [3 4]] * [5 6]donne[[5 10] [18 24]] .

Explication

Nous utiliserons un exemple d'entrée de [[2 3 4] [2 3 4 6]]:

• {...}
  Définit une fonction. Le (premier) argument est lié à la variable locale a.
• #*a
  Mappez #à l'argument de la fonction, en obtenant les longueurs des sous-listes. Résultat:[3 4]
• a/#*a
  Divisez (les éléments de) les sous-listes de apar leurs longueurs respectives. Résultat:[[0.667 1 1.333] [0.5 0.75 1 1.5]]
• $+*a/#*a
  Mappez $+(pliez sur addition) à ce résultat, en additionnant les sous-listes. Résultat:[3 3.75]
• $CM$+*a/#*a
  Fold on CM, ce qui donne -1, 0ou 1selon la comparaison de ses deux opérandes (comme Python cmp). Résultat: -1(car 3est plus petit que 3.75).

Vous pouvez également définir des fonctions dans Pip en écrivant des expressions contenant la fonction d'identité _. Par exemple, _*_est une fonction qui met son argument au carré - sucre syntaxique pour {a*a}, et moins d'octets. Cependant, il existe un bogue dans la version actuelle de l'interpréteur qui empêche _de travailler avec le *méta - opérateur. Une fois que ce fixe, cette solution peut être 11 octets : $CM$+*_/#*_.

C (gcc), 91 98 octets

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

Mauvais endroit pour C et probablement la seule réponse qui n'a pas besoin de division. Au moins, le code est affiché sans curseur.

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!