Obtendo a média de uma lista (por exemplo [2,6,7])

• Obtenha o comprimento da lista: [2,6,7] -> 3
• Somar os números na lista: 2 + 6 + 7 = 15.
• Divida a soma por sua contagem: 15 / 3 = 5.

Você deve comparar as médias de duas listas de números inteiros positivos N e M , retornando um valor se N tiver uma média mais alta, outro valor se M tiver uma média mais alta e outro em caso de empate.

Regras de E / S

Todos os métodos padrão de entrada e saída são permitidos.

Entrada

Você pode receber a entrada como duas listas separadas, uma lista aninhada ou qualquer outra coisa que considere adequada para a tarefa. Por favor, especifique o formato.

Resultado

Os valores fornecidos devem ser distintos e devem consistir em pelo menos um caractere que não seja um espaço em branco. Além disso, eles devem ser consistentes entre as execuções (um valor único para N , um valor único para M , um valor único para empate ). Especifique aqueles em sua resposta. Os valores podem ser Strings não vazios, valores Bool, Inteiros ou qualquer coisa que você considere adequado.

Especificações

• As listas não terão necessariamente o mesmo comprimento.

• Você está garantido que as listas não estão vazias.

Casos de teste

Eu escolhi os valores N wins, M winse Tie, que são bastante auto-evidente.

N, M -> Saída (médias)

[7], [6] -> N vence (N tem 7, M tem 6)
[4,5], [4,4] -> N vence (N tem 4,5, M tem 4)
[2,3,4], [4,5,6] -> M vence (N tem 3, M tem 5)
[4,1,3], [7,3,2,1,1,2] -> Empate (ambos têm 2,666 ...)
[100.390,1], [89,82,89] -> N vitórias (N tem 163.666 ..., M tem 86.666 ...)
[92.892], [892,92] -> Empate (as listas são basicamente idênticas) 
[10.182], [12,78.203,91] -> Empate (ambos têm 96)

Aplicam-se lacunas padrão . As explicações são incentivadas! Isso é código-golfe , então o código mais curto em bytes vence!

Na verdade , 5 bytes

♂æi-s

Experimente online!

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

Explicação:

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

Experimente online!

Functionque espera uma lista de duas listas. Mean/@#assume a média aritmética de cada lista na entrada, então esses meios são passados Order, o que retorna -1se a primeira lista vencer, 0se houver um empate e 1se a segunda lista vencer.

JavaScript (ES6), 52 50 bytes

(Economizou 2 bytes graças a @Shaggy.)

Aqui estão duas soluções 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

Retorna Infinito para N, -Infinito para M e NaN para um empate.

A primeira solução pode exigir um pouco de explicação devido à recursão:

Na primeira chamada para a função, aé inicializado como a média da Nmatriz:

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

M tem um valor neste momento, portanto, a primeira parte da expressão condicional é chamada:

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

A função é chamada dentro desta expressão, desta vez substituindo Mpara N.

Nesta segunda chamada para a função, aé inicializado como a média de N–– que estava Mna chamada anterior.

Como não há segundo parâmetro durante esta chamada para a função, a segunda parte da expressão condicional é acionada, o que retorna a média:

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

Agora podemos entender melhor a expressão:

(a - f(M)) / 0

Está:

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

A diferença entre as médias será um número positivo, um número negativo ou 0.

Dividir a diferença por 0 resulta em Infinito , -Infinito ou NaN - fornecendo os três valores distintos, conforme necessário.

Casos de teste:

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

MATL , 8 bytes

Tããão muitos modificadores ( Ye Z). Não consigo encontrar uma maneira de torná-lo mais curto. sum / number_of_elementsé de três bytes. Pode ser uma maneira melhor de fazer isso -ZS, mas não consigo encontrar uma.

YmiYm-ZS

Experimente online!

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

Retorna 1se a primeira entrada for maior, 0se eles empatarem e -1se a segunda entrada for maior.

05AB1E , 9 bytes

1 se Mvencer, -1 se Nvencer e 0 para empate.

vyOyg/}.S

Experimente online!

Explicação

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

Experimente online!

Retorna 1se a primeira média for maior, -1se a segunda for e 0se elas estiverem vinculadas.

Python 2 , 43 bytes

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

Experimente online!

Oitava , 27 bytes

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

Experimente online!

Pega dois vetores x.ycomo entrada, pega os meandois vetores e subtrai um do outro. Obter o sinal deste, para chegar 1, 0e -1para as três alternativas diferentes.

Python 2, 49 bytes

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

Experimente online

APL (Dyalog) , 11 bytes

Solicita uma lista de duas listas. Imprime 1se a esquerda tiver uma média mais alta, 0 se eles tiverem a mesma média e ¯1se a direita tiver uma média mais alta.

×-/(+/÷≢)¨⎕

Experimente online!

⎕ pronto

(… )¨ Aplique a seguinte função tácita a cada um:

 +/ a soma

 ÷ dividido por

 ≢ a contagem

-/ insira (e avalie) um sinal de menos entre eles

× signum

Javascript, 81 66 58 56 bytes

economizou 15 bytes graças a Luke

economizou 2 bytes graças a Justin Mariner

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

Empate é 0, M é 1 e N é -1. Chamado usando a sintaxe de currying, por exemplo.f([7])([6])

PHP , 68 bytes

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

Experimente online!

PHP , 69 bytes

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

Experimente online!

operador de espaçonave -1 menos que, 0 empate, 1 maior que

Haskell, 65 43 bytes

Economizou 22 bytes graças a nimi!

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

Tem que haver uma maneira muito melhor ... Mas as conversões de tipo me ferraram.

Uso

(#) [7] [6]

Retorna GTse o primeiro argumento vencer, LTse o segundo argumento vencer e EQse eles empatarem.

Experimente online!

J, 10 bytes

*@-&(+/%#)

Uma lista dada à esquerda e outra à direita. Retornará _1 se a média esquerda for menor, 1 se for maior e 0 se forem iguais

• (+/%#) é um garfo J padrão para calcular a média de uma lista
• &fornece uma variação no garfo diádico. aplica o lado direito (o verbo médio, neste caso) a ambos os argumentos e os transmite ao verbo no lado esquerdo, que neste caso é ...
• *@- subtrair seguido de "sign of": para que a média direita seja subtraída da esquerda e recebamos o sinal do resultado - _1, 1 ou 0

Pitão, 10 8 7 6 bytes

Obrigado @isaacg por salvar um byte

._-F.O

A entrada é aceita como uma lista aninhada [N, M]. Produz -1se N < M, 1se N > Me 0se são iguais.

Experimente Online

TI-Basic, 25 21 13 12 10 bytes

-2 bytes graças ao lirtosiast

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

Geléia , 7 bytes

S÷Lµ€IṠ

Um link monádico que aceita uma lista das duas listas, N,Mque retorna:
[-1]for N;
[1]para M; e
[0]por um empate.
Como um programa completo que imprime o resultado (listas de itens única imprimir seu conteúdo apenas, por isso -1, 1ou 0).

Experimente online!

Quão?

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

Experimente online!

Leva um único argumento, uma lista de dois elementos de listas de números. Retorna 1se a primeira lista tiver uma média maior, -1se a segunda lista 0tiver e se as médias forem iguais.

JavaScript (ES6), 60 bytes

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

Saídas 0para Tie, truepara Ne falsepara M.

JavaScript (ES6), 60 54 bytes

-6 bytes graças a @Luke e @Neil

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

Recebe entrada como uma matriz de 2 elementos [N, M]. Saídas true, 0ou falsepara N,Tie , or M, respectivamente.

Explicação

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

Snippet de teste

Números de entrada separados por espaços / vírgulas.

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 é uma função que leva uma lista de listas. Retorna 1se a primeira média for maior, -1se a segunda for maior, 0se empatada. Execute todos os casos de teste aqui.

fundo

Esta solução faz uso pesado de dois dos metaoperadores do Pip:

• $, dobre. Pegue um operador binário e aplique-o entre os elementos de uma lista. Por exemplo, +é adição, mas $+soma uma lista. Observe que $transforma um operador binário em um operador unário.
• *mapa. Pegue um operador unário e aplique-o a cada elemento de uma lista. Por exemplo,# fornece o comprimento de uma lista, mas #*fornece (uma lista de) os comprimentos dos itens da lista.
• Esses dois metaoperadores podem ser combinados: $+*mapas dobram / mais sobre uma lista, somando cada um dos elementos da lista.

A outra coisa a saber sobre o Pip é que muitos operadores trabalham por item nas listas por padrão. Por exemplo, [1 2 3] * 5dá [5 10 15]; [1 2 3] * [2 3 4]dá [2 6 12]; e [[1 2] [3 4]] * [5 6]dá [[5 10] [18 24]].

Explicação

Usaremos um exemplo de entrada de [[2 3 4] [2 3 4 6]]:

• {...}
  Define uma função. O (primeiro) argumento está vinculado à variável local a.
• #*a
  Mapeie #para o argumento da função, obtendo os comprimentos das sublistas. Resultado:[3 4]
• a/#*a
  Divida (os elementos de) os sublistas apelos seus respectivos comprimentos. Resultado:[[0.667 1 1.333] [0.5 0.75 1 1.5]]
• $+*a/#*a
  Mapeie $+(dobre na adição) para esse resultado, somando as sublistas. Resultado:[3 3.75]
• $CM$+*a/#*a
  Dobre CM, o que fornece -1, 0ou 1depende da comparação de seus dois operandos (como o de Python cmp). Resultado: -1(porque 3é menor que 3.75).

Você também pode definir funções no Pip escrevendo expressões contendo a função de identidade _. Por exemplo, _*_é uma função que enquadra seu argumento - açúcar sintático por {a*a}e menos bytes. No entanto, há um erro na versão atual do intérprete que impede o _trabalho com o *metaoperador. Uma vez que é fixo, esta solução pode 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 errado para C e provavelmente a única resposta que não precisa de divisão. Pelo menos o código é exibido sem um controle deslizante.

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

Braquilog , 8 bytes

⟨+/l⟩ᵐ-ṡ

Experimente online!

Resultados 1se a primeira lista tiver uma média maior, -1se a segunda lista tiver uma média maior e 0se eles estiverem vinculados.

Explicação

     ᵐ        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 recebe uma lista aninhada, conforme entradas permitidas.

Transmite a lista de listas, converte as duas para as médias e retorna o sinal da diferença. 1se a primeira lista for maior, -1se a segunda lista for maior, 0por empate.

R 38 34 bytes

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

Função que recebe como entrada dois vetores numéricos. Retorna 1 se a média da primeira lista for maior, 0 se eles forem iguais e -1 se a segunda média da lista for maior.

MATL , 6 bytes

Não seja tão mau! *

!-ssZS

Ordem da pilha de entrada:

M
N

Resultado:

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

Experimente 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

_{* Esta resposta foi jogada sem ser má com números pobres e indefesos.}

Java (OpenJDK 8) , 76 62 bytes

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

Experimente online!

Como a entrada pode ser qualquer coisa, decidi usar IntStreams como entrada. Você pode obter essa entrada de um padrão int[]com Arrays.stream(array).

A saída é 1para "N wins", -1"M wins" e 0empate.

Economizar

• -14 bytes de insights de @Zircon e @Xanderhall!

Dyalog APL, 14 bytes

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

1se a esquerda for maior, ¯1se a direita estiver 0empatada.

Quão?

¨∘⊢ para cada lista

+/÷≢calcular média ( divisão da +/soma ÷pelo ≢comprimento)

-/ subtrair as médias

× sinal do resultado

Lisp comum , 74 71 bytes

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

Experimente online!