Obtener el promedio de una lista (p [2,6,7]. Ej. )

• Obtenga la longitud de la lista: [2,6,7] -> 3
• Sumar los números de la lista: 2 + 6 + 7 = 15.
• Dividir la suma por su cuenta: 15 / 3 = 5.

Debe comparar los promedios de dos listas de enteros positivos N y M , devolviendo un valor si N tiene un promedio más alto, otro valor si M tiene un promedio más alto y otro en caso de empate.

Reglas de E / S

Todos los métodos de entrada y salida estándar están permitidos.

Entrada

Puede tomar la entrada como dos listas separadas, una lista anidada o cualquier otra cosa que considere adecuada para la tarea. Por favor especifique el formato.

Salida

Los valores proporcionados deben ser distintos y deben constar de al menos un carácter que no sea un espacio en blanco. Además, deben ser consistentes entre ejecuciones (un valor único para N , un valor único para M , un valor único para Tie ). Por favor especifique aquellos en su respuesta. Los valores pueden ser cadenas no vacías, valores de bool, enteros o cualquier cosa que considere adecuada.

Especificaciones

• Las listas no necesariamente tendrán la misma longitud.

• Le garantizamos que las listas no están vacías.

Casos de prueba

Elegí los valores N wins, M winsy Tie, que son más o menos evidente.

N, M -> Salida (promedios)

[7], [6] -> N gana (N tiene 7, M tiene 6)
[4,5], [4,4] -> N gana (N tiene 4.5, M tiene 4)
[2,3,4], [4,5,6] -> M gana (N tiene 3, M tiene 5)
[4,1,3], [7,3,2,1,1,2] -> Empate (ambos tienen 2.666 ...)
[100,390,1], [89,82,89] -> N gana (N tiene 163.666 ..., M tiene 86.666 ...)
[92,892], [892,92] -> Empate (las listas son básicamente idénticas) 
[10,182], [12,78,203,91] -> Empate (ambos tienen 96)

Se aplican las lagunas predeterminadas . ¡Se alientan las explicaciones! Este es el código de golf , por lo que gana el código más corto en bytes.

En realidad , 5 bytes

♂æi-s

Pruébalo en línea!

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

Explicación:

♂æ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/@#&

Pruébalo en línea!

Functionque espera una lista de dos listas. Mean/@#toma la media aritmética de cada lista en la entrada, luego se pasan esas medias Order, que regresa -1si la primera lista gana, 0si hay un empate y 1si la segunda lista gana.

JavaScript (ES6), 52 50 bytes

(Guardado 2 bytes gracias a @Shaggy.)

Aquí hay dos soluciones de 50 bytes:

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

Devuelve Infinito para N, -Infinito para M y NaN para un empate.

La primera solución puede requerir un poco de explicación debido a la recursividad:

En la primera llamada a la función, ase inicializa como el promedio de la Nmatriz:

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

M tiene un valor en este punto, por lo que la primera parte de la expresión condicional se llama:

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

La función se llama dentro de esta expresión, esta vez sustituyendo Mpor N.

En esta segunda llamada a la función, ase inicializa como el promedio de N–– que estaba Men la llamada anterior.

Como no hay un segundo parámetro durante esta llamada a la función, se activa la segunda parte de la expresión condicional, que devuelve el promedio:

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

Ahora podemos entender mejor la expresión:

(a - f(M)) / 0

Sus:

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

La diferencia entre los promedios será un número positivo, un número negativo o 0.

Dividir la diferencia por 0 da como resultado Infinito , -Infinito o NaN , proporcionando los tres valores distintos según sea necesario.

Casos de prueba:

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 para #victorias, -1 para #2victorias, 0 para empate.

MATL , 8 bytes

Tantos modificadores ( Yy Z). No puedo encontrar una manera de hacerlo más corto. sum / number_of_elementsson tres bytes Puede ser una mejor manera de hacerlo -ZS, pero no puedo encontrar una.

YmiYm-ZS

Pruébalo en línea!

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

Devuelve 1si la primera entrada es más grande, 0si están vinculadas y -1si la segunda entrada es más grande.

05AB1E , 9 bytes

1 si Mgana, -1 si Ngana y 0 por empate.

vyOyg/}.S

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Devuelve 1si el primer promedio es mayor, -1si el segundo es, y 0si empatan.

Python 2 , 43 bytes

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

Pruébalo en línea!

Octava , 27 bytes

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

Pruébalo en línea!

Toma dos vectores x.ycomo entrada, toma los meandos vectores y resta uno del otro. Obtener el signo de esto, para conseguir 1, 0y -1para las tres alternativas diferentes.

Python 2, 49 bytes

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

Pruébalo en línea

APL (Dyalog) , 11 bytes

Solicita una lista de dos listas. Imprime 1si la izquierda tiene un promedio más alto, 0 si tienen el mismo promedio y ¯1si la derecha tiene un promedio más alto.

×-/(+/÷≢)¨⎕

Pruébalo en línea!

⎕ rápido

(… )¨ Aplique la siguiente función tácita a cada uno:

 +/ la suma

 ÷ dividido por

 ≢ el recuento

-/ inserte (y evalúe) un signo menos entre ellos

× signum

Javascript, 81 66 58 56 bytes

ahorró 15 bytes gracias a Luke

ahorró 2 bytes gracias a Justin Mariner

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

El empate es 0, M es 1 y N es -1. Llamado usando la sintaxis de curry, por ejemplo.f([7])([6])

PHP , 68 bytes

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

Pruébalo en línea!

PHP , 69 bytes

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

Pruébalo en línea!

operador de nave espacial -1 menos que, 0 empate, 1 mayor que

Haskell, 65 43 Bytes

Guardado 22 bytes gracias a nimi!

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

Tiene que haber una manera mucho mejor ... Pero las conversiones de tipos me fastidiaron.

Uso

(#) [7] [6]

Devuelve GTsi gana el primer argumento, LTsi gana el segundo argumento y EQsi empatan.

Pruébalo en línea!

J, 10 bytes

*@-&(+/%#)

Una lista dada a la izquierda, otra a la derecha. Devuelve _1 si el promedio izquierdo es menor, 1 si es mayor y 0 si son iguales

• (+/%#) es una bifurcación J estándar para calcular el promedio de una lista
• &Proporciona una variación de la horquilla diádica. aplica el lado derecho (el verbo promedio, en este caso) a ambos argumentos, y luego los pasa al verbo del lado izquierdo, que en este caso es ...
• *@- restar seguido de "signo de": entonces el promedio de la derecha se resta de la izquierda, y se nos da el signo del resultado: _1, 1 o 0

Pyth, 10 8 7 6 bytes

Gracias @isaacg por guardar un byte

._-F.O

De entrada se toma como una lista anidada, [N, M]. Salidas -1si N < M, 1si N > My 0si son iguales.

Pruébalo en línea

TI-Basic, 25 21 13 12 10 bytes

-2 bytes gracias a lirtosiast

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

Jalea , 7 bytes

S÷Lµ€IṠ

Un enlace monádico que acepta una lista de las dos listas, N,Mque devuelve:
[-1]para N;
[1]para M; y
[0]por un empate.
Como un completo programa imprime el resultado (listas única opción permite imprimir su contenido solamente, así que -1, 1o 0).

Pruébalo en línea!

¿Cómo?

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/$_}}

Pruébalo en línea!

Toma un solo argumento, una lista de dos elementos de listas de números. Devuelve 1si la primera lista tiene un promedio mayor, -1si la segunda tiene, y 0si los promedios son iguales.

JavaScript (ES6), 60 bytes

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

Salidas 0para Tie, truepara Ny falsepara M.

JavaScript (ES6), 60 54 bytes

-6 bytes gracias a @Luke y @Neil

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

Toma la entrada como una matriz de 2 elementos [N, M]. Salidas true, 0, o falsepara N, Tie, o M, respectivamente.

Explicación

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

Fragmento de prueba

Ingrese números separados por espacios / comas.

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}

Esta es una función que toma una lista de listas. Devuelve 1si el primer promedio es mayor, -1si el segundo es mayor, 0si está empatado. Ejecute todos los casos de prueba aquí.

Antecedentes

Esta solución hace un uso intensivo de dos de los metaoperadores de Pip:

• $Doblar Tome un operador binario y aplíquelo entre los elementos de una lista. Por ejemplo, +es una suma, pero $+suma una lista. Tenga en cuenta que $convierte a un operador binario en un operador unario.
• *, mapa. Tome un operador unario y aplíquelo a cada elemento de una lista. Por ejemplo, #da la longitud de una lista, pero #*da (una lista de) las longitudes de los elementos de la lista.
• Estos dos metaoperadores se pueden combinar: los $+*mapas se pliegan / agregan sobre una lista, sumando cada uno de los elementos de la lista.

La otra cosa que debe saber sobre Pip es que muchos operadores trabajan por elementos en las listas de forma predeterminada. Por ejemplo, [1 2 3] * 5da [5 10 15]; [1 2 3] * [2 3 4]da [2 6 12]; y [[1 2] [3 4]] * [5 6]da [[5 10] [18 24]].

Explicación

Usaremos un ejemplo de entrada de [[2 3 4] [2 3 4 6]]:

• {...}
  Define una función. El (primer) argumento está vinculado a la variable local a.
• #*a
  Asigne #el argumento de la función, obteniendo las longitudes de las sublistas. Resultado:[3 4]
• a/#*a
  Divida (los elementos de) las sublistas de apor sus respectivas longitudes. Resultado:[[0.667 1 1.333] [0.5 0.75 1 1.5]]
• $+*a/#*a
  Asigne $+(doble al agregar) a ese resultado, sumando las sublistas. Resultado:[3 3.75]
• $CM$+*a/#*a
  Doblar CM, lo que da -1, 0o 1dependiendo de la comparación de sus dos operandos (como el de Python cmp). Resultado: -1(porque 3es más pequeño que 3.75).

También puede definir funciones en Pip escribiendo expresiones que contengan la función de identidad _. Por ejemplo, _*_es una función que cuadra su argumento: azúcar sintáctico para {a*a}, y menos bytes. Sin embargo, hay un error en la versión actual del intérprete que impide _trabajar con el* metaoperador. Una vez que se fija, esta solución puede ser 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;}

Lugar equivocado para C y probablemente la única respuesta que no necesita división. Al menos el código se muestra sin un control deslizante.

0,1,2 volver para M>N, M=N, M<Nrespectivamente. Toma de entrada como length of M, length of N, M, N.

Brachylog , 8 bytes

⟨+/l⟩ᵐ-ṡ

Pruébalo en línea!

Salidas 1si la primera lista tiene un promedio mayor, si -1la segunda lista tiene un promedio mayor y 0si están vinculadas.

Explicación

     ᵐ        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 que toma una lista anidada, según las entradas permitidas.

Transmite la lista de listas, convierte ambas a sus promedios y luego devuelve el signo de la diferencia. 1si la primera lista es más grande, -1si la segunda lista es más grande, 0para un empate.

R 38 34 bytes

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

Función que toma como entrada dos vectores numéricos. Devuelve 1 si el promedio de la primera lista es mayor, 0 si son iguales y -1 si el promedio de la segunda lista es mayor.

MATL , 6 bytes

¡No seas tan malo! *

!-ssZS

Orden de pila de entrada:

M
N

Salida:

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

Pruébalo en línea!

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

_{* Esta respuesta se jugó sin ser mala con ningún número pobre e indefenso.}

Java (OpenJDK 8) , 76 62 bytes

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

Pruébalo en línea!

Como la entrada puede ser cualquier cosa, decidí tomar IntStreams como entrada. Puede obtener dicha entrada de un estándar int[]con Arrays.stream(array).

La salida es 1para "N victorias", -1para "M victorias" y 0para empate.

Ahorra

• -14 bytes de las ideas de @Zircon y @Xanderhall!

Dyalog APL, 14 bytes

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

1si la izquierda es mayor, ¯1si la derecha está y 0en empate.

¿Cómo?

¨∘⊢ para cada lista

+/÷≢calcular el promedio ( +/suma ÷dividida por ≢longitud)

-/ restar los promedios

× signo del resultado

Lisp común , 74 71 bytes

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

Pruébalo en línea!