Ottenere la media di un elenco (ad es. [2,6,7])

• Ottieni la lunghezza dell'elenco: [2,6,7] -> 3
• Sommare i numeri nell'elenco: 2 + 6 + 7 = 15.
• Dividere la somma per il loro conteggio: 15 / 3 = 5.

Dovresti confrontare le medie di due elenchi di numeri interi positivi N e M , restituendo un valore se N ha una media più alta, un altro valore se M ha una media più alta e un altro in caso di pareggio.

Regole I / O

Sono consentiti tutti i metodi di input e output standard .

Ingresso

È possibile accettare input come due elenchi separati, un elenco nidificato o qualsiasi altra cosa ritenuta adatta all'attività. Si prega di specificare il formato.

Produzione

I valori forniti devono essere distinti e devono consistere in almeno un carattere non bianco. Inoltre, devono essere coerenti tra le esecuzioni (un singolo valore per N , un singolo valore per M , un singolo valore per Tie ). Si prega di specificare quelli nella risposta. I valori possono essere stringhe non vuote, valori Bool, numeri interi o qualsiasi cosa tu ritenga adatta.

Specifiche

• Le liste non avranno necessariamente la stessa lunghezza.

• Si garantisce che le liste non sono vuote.

Casi test

Ho scelto i valori N wins, M winse Tieche sono più o meno evidente.

N, M -> Uscita (medie)

[7], [6] -> N vince (N ha 7, M ha 6)
[4,5], [4,4] -> N vince (N ha 4,5, M ha 4)
[2,3,4], [4,5,6] -> M vince (N ha 3, M ha 5)
[4,1,3], [7,3,2,1,1,2] -> Cravatta (entrambi hanno 2.666 ...)
[100.390,1], [89,82,89] -> N vince (N ha 163.666 ..., M ha 86.666 ...)
[92.892], [892,92] -> Cravatta (le liste sono sostanzialmente identiche) 
[10.182], [12,78.203,91] -> Cravatta (entrambi hanno 96)

Si applicano le lacune predefinite . Le spiegazioni sono incoraggiate! Questo è code-golf , quindi vince il codice più corto in byte!

In realtà , 5 byte

♂æi-s

Provalo online!

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

Spiegazione:

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

Mathematica, 15 byte

Order@@Mean/@#&

Provalo online!

Functionche prevede un elenco di due elenchi. Mean/@#prende la media aritmetica di ciascuna lista nell'input, quindi vengono passati quei mezzi Order, che ritorna -1se la prima lista vince, 0se c'è un pareggio e 1se la seconda lista vince.

JavaScript (ES6), 52 50 byte

(Salvato 2 byte grazie a @Shaggy.)

Ecco due soluzioni da 50 byte:

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

Restituisce Infinity per N, -Infinity per M e NaN per un pareggio.

La prima soluzione potrebbe richiedere un po 'di spiegazione a causa della ricorsione:

Alla prima chiamata alla funzione, aviene inizializzato come media Ndell'array:

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

M ha un valore a questo punto, quindi la prima parte dell'espressione condizionale si chiama:

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

La funzione viene richiamata all'interno di questa espressione, questa volta sostituendo Mper N.

In questa seconda chiamata alla funzione, aviene inizializzato come media di N–– che era Mnella chiamata precedente.

Poiché non esiste un secondo parametro durante questa chiamata alla funzione, viene attivata la seconda parte dell'espressione condizionale, che restituisce la media:

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

Ora possiamo capire meglio l'espressione:

(a - f(M)) / 0

Suo:

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

La differenza tra le medie sarà un numero positivo, un numero negativo o 0.

Dividendo la differenza per 0 si ottengono Infinito , -Infinito o NaN - fornendo i tre valori distinti come richiesto.

Casi 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 byte

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

1 per #vittorie, -1 per #2vittorie, 0 per pareggio.

MATL , 8 byte

Davvero molti modificatori ( Ye Z). Non riesco a trovare un modo per renderlo più breve. sum / number_of_elementsè di tre byte. Potrebbe essere un modo migliore per farlo -ZS, ma non riesco a trovarne uno.

YmiYm-ZS

Provalo online!

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

Restituisce 1se il primo input è più grande, 0se si associano e -1se il secondo input è più grande.

05AB1E , 9 byte

1 se Mvince, -1 se Nvince e 0 per un pareggio.

vyOyg/}.S

Provalo online!

Spiegazione

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

Julia , 27 byte

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

Provalo online!

Restituisce 1se la prima media è maggiore, -1se la seconda è, e 0se pareggiano.

Python 2 , 43 byte

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

Provalo online!

Ottava , 27 byte

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

Provalo online!

Accetta due vettori x.ycome input, prende meanentrambi i vettori e sottrae l'uno dall'altro. Prendi il segno di questa, per ottenere 1, 0e -1per le tre diverse alternative.

Python 2, 49 byte

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

Provalo online

APL (Dyalog) , 11 byte

Richiede un elenco di due elenchi. Stampa 1se la sinistra ha una media più alta, 0 se hanno la stessa media e ¯1se la destra ha una media più alta.

×-/(+/÷≢)¨⎕

Provalo online!

⎕ richiesta

(... )¨ applica la seguente funzione tacita a ciascuno:

 +/ la somma

 ÷ diviso per

 ≢ il conteggio

-/ inserire (e valutare) un segno meno tra di loro

× Signum

Javascript, 81 66 58 56 byte

risparmiato 15 byte grazie a Luke

risparmiato 2 byte grazie a Justin Mariner

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

Il pareggio è 0, M è 1 e N è -1. Chiamato utilizzando la sintassi del curry, ad es.f([7])([6])

PHP , 68 byte

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

Provalo online!

PHP , 69 byte

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

Provalo online!

operatore dell'astronave -1 meno allora, 0 pareggio, 1 maggiore allora

Haskell, 65 43 byte

Risparmiato 22 byte grazie a nimi!

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

Deve esserci un modo molto migliore ... Ma le conversioni di tipo mi hanno fregato.

uso

(#) [7] [6]

Restituisce GTse vince il primo argomento, LTse vince il secondo argomento e EQse vincolano.

Provalo online!

J, 10 byte

*@-&(+/%#)

Un elenco fornito a sinistra, uno a destra. Restituirà _1 se la media sinistra è più piccola, 1 se è più grande e 0 se sono uguali

• (+/%#) è un fork J standard per il calcolo della media di un elenco
• &fornisce una variazione sulla forcella diadica. applica il lato destro (il verbo medio, in questo caso) ad entrambi gli argomenti, quindi li passa al verbo sul lato sinistro, che in questo caso è ...
• *@- sottrazione seguita da "segno di": quindi la media destra viene sottratta dalla sinistra e ci viene dato il segno del risultato - _1, 1 o 0

Pyth, 10 8 7 6 byte

Grazie @isaacg per aver salvato un byte

._-F.O

L'ingresso è preso come una lista annidata, [N, M]. Emette -1se N < M, 1se N > Me 0se sono uguali.

Provalo online

TI-Basic, 25 21 13 12 10 byte

-2 byte grazie a lirtosiast

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

Gelatina , 7 byte

S÷Lµ€IṠ

Un collegamento monadico che accetta un elenco dei due elenchi, N,Mche restituisce:
[-1]for N;
[1]per M; e
[0]per un pareggio.
Come programma completo stampa il risultato (gli elenchi di singoli elementi stampano solo il loro contenuto, quindi -1,1 o 0).

Provalo online!

Come?

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 byte

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

Provalo online!

Accetta un singolo argomento, un elenco di due elementi di elenchi di numeri. Restituisce 1se la prima lista ha una media maggiore, -1se la seconda lo fa e 0se le medie sono uguali.

JavaScript (ES6), 60 byte

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

Uscite 0per Tie, trueper Ne falseper M.

JavaScript (ES6), 60 54 byte

-6 byte grazie a @Luke e @Neil

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

Accetta l'input come una matrice a 2 elementi [N, M]. Uscite true, 0o falseper N,Tie , o M, rispettivamente.

Spiegazione

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

Test dello snippet

Immettere i numeri separati da spazi / virgole.

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 byte

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

Questa è una funzione che accetta un elenco di elenchi. Restituisce 1se la prima media è più grande, -1se la seconda è più grande, 0se legata. Esegui tutti i casi di test qui.

sfondo

Questa soluzione fa ampio uso di due dei metaoperatori di Pip:

• $, piega. Prendi un operatore binario e applicalo tra gli elementi di un elenco. Ad esempio, +è aggiunta, ma $+somma un elenco. Si noti che $trasforma un operatore binario in un operatore unario.
• *, carta geografica. Prendi un operatore unario e applicalo a ciascun elemento di un elenco. Per esempio,# fornisce la lunghezza di un elenco, ma #*fornisce (un elenco di) la lunghezza degli elementi dell'elenco.
• Questi due metaoperatori possono essere combinati: le $+*mappe piegano / più su un elenco, sommando ciascuno degli elementi dell'elenco.

L'altra cosa da sapere su Pip è che molti operatori lavorano per impostazione predefinita sugli elenchi. Ad esempio, [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]].

Spiegazione

Useremo un input di esempio di [[2 3 4] [2 3 4 6]]:

• {...}
  Definisce una funzione. Il (primo) argomento è associato alla variabile locale a.
• #*a
  Mappa #sull'argomento della funzione, ottenendo le lunghezze delle liste secondarie. Risultato:[3 4]
• a/#*a
  Dividi (gli elementi di) le liste secondarie aper le loro rispettive lunghezze. Risultato:[[0.667 1 1.333] [0.5 0.75 1 1.5]]
• $+*a/#*a
  Mappa $+(piega su aggiunta) a quel risultato, sommando le liste secondarie. Risultato:[3 3.75]
• $CM$+*a/#*a
  Fold on CM, che dà -1, 0o in 1base al confronto dei suoi due operandi (come quello di Python cmp). Risultato: -1(perché 3è più piccolo di 3.75).

È inoltre possibile definire le funzioni in Pip scrivendo espressioni contenenti la funzione di identità _. Ad esempio, _*_è una funzione che quadra il suo argomento: zucchero sintattico {a*a}e meno byte. Tuttavia, c'è un bug nella versione corrente dell'interprete che impedisce _di lavorare con il *metaoperatore. Una volta che è fissato, questa soluzione può essere 11 byte : $CM$+*_/#*_.

C (gcc), 91 98 byte

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

Posto sbagliato per C e probabilmente l'unica risposta che non ha bisogno di divisione. Almeno il codice viene visualizzato senza un dispositivo di scorrimento.

Rientro 0,1,2 per M>N, M=N, M<Nrispettivamente. Prende input come length of M, length of N, M, N.

Brachylog , 8 byte

⟨+/l⟩ᵐ-ṡ

Provalo online!

Emette 1se il primo elenco ha una media maggiore, -1se il secondo elenco ha una media maggiore e 0se sono collegati.

Spiegazione

     ᵐ        Map:
⟨   ⟩           Fork:
 +                Sum…
  /               …divided by…
   l              …length
       -      Subtract
        ṡ     Sign

Java, 105 byte

s->s.stream().map(l->l.stream().reduce((i,j)->i+j).get()/l.size()).reduce((i,j)->Math.signum(i-j)).get();

Lambda che accetta un elenco nidificato, secondo gli input consentiti.

Trasmette in streaming l'elenco delle liste, converte entrambe le loro medie, quindi restituisce il segno della differenza. 1se il primo elenco è più grande, -1se il secondo elenco è più grande, 0per un pareggio.

R 38 34 byte

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

Funzione che accetta come input due vettori numerici. Restituisce 1 se la media della prima lista è più alta, 0 se sono uguali e -1 se la media della seconda lista è più alta.

MATL , 6 byte

Non essere così cattivo! *

!-ssZS

Ordine di stack di input:

M
N

Produzione:

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

Provalo 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

_{* Questa risposta è stata giocata a golf senza essere cattiva con i numeri poveri e indifesi.}

Java (OpenJDK 8) , 76 62 byte

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

Provalo online!

Dato che l'input può essere qualsiasi cosa, ho deciso di prendere IntStreams come input. È possibile ottenere tale input da uno standard int[]con Arrays.stream(array).

L'output è 1per "N vittorie", -1per "M vittorie" e 0per pareggio.

Salva

• -14 byte dalle intuizioni di @Zircon e @Xanderhall!

Dyalog APL, 14 byte

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

1se la sinistra è maggiore, ¯1se la destra è e 0in pareggio.

Come?

¨∘⊢ per ogni elenco

+/÷≢calcolare la media ( +/somma ÷divisa per ≢lunghezza)

-/ sottrarre le medie

× segno del risultato

Lisp comune , 74 71 byte

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

Provalo online!