L'obiettivo di una Rosetta Stone Challenge è scrivere soluzioni in quante più lingue possibile. Mostra il tuo multilinguismo di programmazione!

La sfida

Quando le persone usano il termine "media", generalmente indicano la media aritmetica, che è la somma dei numeri divisa per il numero di numeri. Vi sono, tuttavia, molti più significati della parola "media", tra cui la media armonica , la media geometrica , la media aritmetica , la media quadratica e la media contrarmonica .

La tua sfida è scrivere un programma che inserisca un elenco di numeri e produca quei 5 diversi mezzi. Inoltre, stai provando a scrivere programmi in quante più lingue possibile . Puoi usare qualsiasi tipo di funzione di libreria standard nella tua lingua, poiché questa è principalmente una vetrina linguistica.

Ingresso

L'input sarà un elenco di numeri positivi.

1,2,3,4,5
1.7,17.3,3.14,24,2.718,1.618
8.6
3,123456
10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
3,4,4,6.2,6.2,6.2

Produzione

L'output sarà i cinque mezzi nell'ordine sopra elencato (armonico, geometrico, aritmetico, quadratico, contraarmonico). Convenientemente, è uguale all'ordine crescente.

2.18978,2.6052,3,3.31662,3.66667
3.01183,4.62179,8.41267,12.2341,17.7915
8.6,8.6,8.6,8.6,8.6
5.99985,608.579,61729.5,87296.6,123453.
5.95799,14.3041,22.5453,27.9395,34.6243
4.5551,4.74682,4.93333,5.10425,5.28108

Ci sarà una ragionevole clemenza nel formato I / O, ma voglio diversi decimali di precisione. Dal momento che desidero l'output in virgola mobile, puoi assumere l'input in virgola mobile.

Il criterio vincente dell'obiettivo

Per quanto riguarda un criterio obiettivo vincente, eccolo qui: ogni lingua è una competizione separata su chi può scrivere la voce più breve, ma il vincitore generale sarebbe la persona che vince la maggior parte di queste sotto-competizioni. Ciò significa che una persona che risponde in molte lingue non comuni può ottenere un vantaggio. Il code-golf è principalmente un tiebreak per quando c'è più di una soluzione in una lingua: la persona con il programma più corto ottiene credito per quella lingua.

In caso di pareggio, il vincitore sarebbe la persona con il maggior numero di iscrizioni al secondo posto (e così via).

Regole, restrizioni e note

Il tuo programma può essere scritto in qualsiasi lingua esistente prima del 2 settembre 2014. Dovrò anche fare affidamento sulla comunità per convalidare alcune risposte scritte in alcune delle lingue più insolite / esoteriche, poiché è improbabile che io sia in grado di testare loro.

Conservare tutte le diverse comunicazioni contenute in un'unica risposta.

Inoltre, nessuno shenanigans ha sostanzialmente la stessa risposta in dialetti di lingua leggermente diversi. Sarò il giudice su ciò che le osservazioni sono abbastanza diverse.

Classifica attuale

Questa sezione verrà periodicamente aggiornata per mostrare il numero di lingue e chi guida in ciascuna di esse.

• Algoid (337) - Decadimento beta
• APL (42) - algoritmo condiviso
• Awk (78) - Dennis
• BBC BASIC (155) - Decadimento beta
• C (136) - Dennis
• C ++ (195) - Zeta
• C # (197) - Martin Büttner
• CJam (43) - Dennis
• Clojure (324) - Michael Easter
• Cobra (132) - Ourous
• CoffeeScript (155) - Martin Büttner
• Commodore BASIC (104) - Mark
• Common Lisp (183) - DLosc
• Erlang (401) - Mark
• Fortran (242) - Kyle Kanos
• Fortran 77 (286) - Decadimento beta
• GNU bc (78) - Dennis
• GolfScript (83) - Dennis
• Groovy (157) - Michael Easter
• Haskell (140) - Zeta
• J (28) - algoritmo condiviso
• Java (235) - Michael Easter
• JavaScript (ES6) (112) - Dennis
• JRuby (538) - Michael Easter
• Julia (79) - Martin Büttner
• Lua (113) - AndoDaan
• Mathematica (65) - Martin Büttner
• Matlab (63) - Martin Büttner
• Octave (68) - Dennis
• Openscript (849?) - COTO
• Pascal (172) - Mark
• Perl (76) - Grimy
• PHP (135) - Dennis
• POV-Ray 3.7 (304) - Mark
• Prolog (235) - DLosc
• Pyth (52) - Dennis
• Python 2 (96) - Dennis
• Python 3 (103) - DLosc
• Q (53) - algoritmo condiviso
• Q'Nial (68) - algoritmo condiviso
• QBasic (96) - DLosc
• R (91) - plannapus
• Ruby (118) - Martin Büttner
• Ruggine (469) - Vi.
• Scala (230) - Michele Pasqua
• T-SQL (122) - MickyT
• TI-Basic (85) - Ypnypn
• TypeScript (393) - rink.attendant.6
• VBA (Excel) (387) - Stretch Maniac
• wxMaxima (134) - Kyle Kanos

Classifiche utente corrente

1. Dennis (10)
2. Martin Büttner (6)
3. Michael Easter (5)
4. Mark, DLosc, algoritmo condiviso (4)
5. Decadimento beta (3)
6. Zeta, Kyle Kanos (2)
7. Ourous, AndoDaan, COTO, Grimy, plannapus, Vi., MickyT, Ypnypn, rink.attendant.6, Stretch Maniac (1)

(Se ho fatto un errore nelle classifiche sopra, fammi sapere e lo risolverò. Inoltre, il tiebreaker non è stato ancora applicato.)

Lingue: 1

Openscript (molte centinaia)

(Il mio linguaggio di programmazione oscuro e tristemente preferito preferito, perché ho imparato a programmarlo molti anni fa.;)

openFile "inputs.txt"
readFile "inputs.txt" to EOF

put it into my input_string

closeFile "inputs.txt"

local inputs[]

fill the inputs with my input_string in [item] order

put 0 into the harmonic_mean
put 0 into the geometric_mean
put 0 into the arithmetic_mean
put 0 into the quadratic_mean

put the length of the inputs into n

step i from 1 to n
    get inputs[i]
    increment the harmonic_mean by 1/it
    increment the geometric_mean by log( it )
    increment the arithmetic_mean by it
    increment the quadratic_mean by it*it
end

get "outputs.txt"
createFile it

writeFile n/harmonic_mean                & "," to it 
writeFile exp( geometric_mean/n )        & "," to it
writeFile arithmetic_mean/n              & "," to it
writeFile sqrt( quadratic_mean/n )       & "," to it
writeFile quadratic_mean/arithmetic_mean to it

closeFile it

Lingue: 13

Penso che questo elenco dovrebbe ora contenere tutti i linguaggi di programmazione che conosco sufficientemente bene per risolvere almeno semplici problemi. Cercherò di mantenere questo elenco completo nel tempo mentre cerco nuovi linguaggi. (I utilizzato per conoscere alcune Smalltalk e Delphi, ma avrei dovuto guardare in alto a molto per l'aggiunta di loro di sentirsi bene.)

C, 196 190 171 165 byte

main(int c,char**v){float n=c-1,x,h,g=1,q,a=h=q=0;for(;c-1;h+=1/x,g*=pow(x,1/n),a+=x/n,q+=x*x/n)sscanf(v[--c],"%f",&x);printf("%f,%f,%f,%f,%f",n/h,g,a,sqrt(q),q/a);}

Legge l'input come singoli argomenti della riga di comando e scrive un elenco separato da virgole dei mezzi su STDOUT.

Grazie per alcuni miglioramenti a Quentin.

C ++, 200 byte

Questo è lo stesso del codice C sopra, più due include. Lo sto includendo perché è più lungo della presentazione C ++ vincente, quindi immagino che non venga fatto alcun danno e vorrei che questo post contenga effettivamente tutte le lingue che conosco. :)

#include <cmath>
#include <cstdio>
main(int c,char**v){float n=c-1,x,h,g=1,q,a=h=q=0;for(;c-1;h+=1/x,g*=pow(x,1/n),a+=x/n,q+=x*x/n)sscanf(v[--c],"%f",&x);printf("%f,%f,%f,%f,%f",n/h,g,a,sqrt(q),q/a);}

C #, 220 197 byte

namespace System{using Linq;class F{double[]f(double[]l){double n=l.Length,a=l.Sum()/n,q=l.Sum(x=>x*x)/n;return new[]{n/l.Sum(x=>1/x),l.Aggregate((p,x)=>p*Math.Pow(x,1.0/n)),a,Math.Sqrt(q),q/a};}}}

Definisce una funzione in una classe che prende un Listdoppio e restituisce un array di doppi con i cinque mezzi.

Grazie per alcuni miglioramenti a Visual Melon e Bob.

CJam, 52 byte

ea_,:L;:d_Wf#:+L\/\_:*1Ld/#\_:+L/:A\2f#:+L/:QmqQA/]p

Prende l'input come argomento della riga di comando e stampa un elenco con i cinque valori su STDOUT.

CoffeeScript, 155 byte

Questo è quasi lo stesso della soluzione JavaScript più in basso (e inizialmente non l'ho contato per quel motivo), ma l'OP l'ha incluso comunque nel quadro di valutazione, quindi l'ho promosso fino a una presentazione completa. Dopotutto sono lingue tecnicamente diverse.

f=(l)->l.r=l.reduce;n=l.length;[n/l.r(((s,x)->s+1/x),0),Math.pow(l.r(((p,x)->p*x),1),1/n),a=l.r(((s,x)->s+x),0)/n,Math.sqrt(q=l.r(((s,x)->s+x*x),0)/n),q/a]

JavaScript (ES6), 155 153 byte

f=l=>{l.r=l.reduce;n=l.length;return[n/l.r((s,x)=>s+1/x,0),Math.pow(l.r((p,x)=>p*x,1),1/n),a=l.r((s,x)=>s+x,0)/n,Math.sqrt(q=l.r((s,x)=>s+x*x,0)/n),q/a]}

Definisce una funzione che accetta una matrice di numeri e restituisce una matrice con i cinque mezzi.

Grazie per alcuni miglioramenti a William Barbosa.

Julia, 79 byte

f(l)=(n=length(l);[n/sum(1/l),prod(l)^(1/n),a=mean(l),q=norm(l)/sqrt(n),q*q/a])

Definisce una funzione che prende un elenco di numeri e restituisce un elenco con i cinque mezzi.

Lua, 120 byte

f=function(l)h=0;q=0;a=0;g=1;for i=1,#l do x=l[i]h=h+1/x;a=a+x/#l;g=g*x^(1/#l)q=q+x*x/#l end;return#l/h,g,a,q^.5,q/a end

Definisce una funzione che prende un elenco di numeri e restituisce 5 valori separati per le medie.

Mathematica, 73 67 65 byte

f[l_]:={1/(m=Mean)[1/l],GeometricMean@l,a=m@l,Sqrt[q=m[l*l]],q/a}

Definisce una funzione che prende un elenco di numeri in virgola mobile e restituisce un elenco con i cinque mezzi.

Curiosità: Mathematica ha tutti e 5 i mezzi integrati (e questa era la mia presentazione originale), ma tre di essi possono essere implementati in meno caratteri rispetto ai nomi delle loro funzioni.

Matlab, 65 63 byte

l=input('');a=mean(l);q=rms(l);harmmean(l)
geomean(l)
a
q
q*q/a

Richiede l'input come una matrice di numeri dall'utente e genera i cinque mezzi singolarmente.

Grazie per alcuni miglioramenti a Dennis Jaheruddin.

PHP ≥ 5,4, 152 149 143 byte

function f($l){$g=1;$n=count($l);foreach($l as$x){$q+=$x*$x/$n;$h+=1/$x;$g*=pow($x,1/$n);}return[$n/$h,$g,$a=array_sum($l)/$n,sqrt($q),$q/$a];}

Stessa implementazione funzionale delle precedenti.

Grazie per alcuni miglioramenti a Ismael Miguel.

Python 2, 127 byte

def f(l):n=len(l);a=sum(l)/n;q=sum(x*x for x in l)/n;return[n/sum(1/x for x in l),reduce(lambda x,y:x*y,l)**(1./n),a,q**.5,q/a]

Stessa implementazione funzionale delle precedenti.

Rubino, 129 118 byte

f=->l{n=l.size
r=->l{l.reduce :+}
[n/r[l.map{|x|1/x}],l.reduce(:*)**(1.0/n),a=r[l]/n,(q=r[l.map{|x|x*x}]/n)**0.5,q/a]}

Stessa implementazione funzionale delle precedenti.

4 lingue

J - 32 28 caratteri!

Una funzione che prende l'elenco dei numeri come unico argomento.

%a,^.a,[a(,,]%%)*:a=.+/%#&.:

a ecco un avverbio, che è il punto di vista di J sulle funzioni del secondo ordine.

• +/ % # è un treno in J, che significa Somma divisa per conte, la definizione della media aritmetica.
• &.: è una congiunzione chiamata Under, dove u&.:v(y) è equivalente vi(u(v(y)))ed viè l'inverso funzionale di v. Sì, J può accettare inversioni funzionali .
• Infine, una caratteristica utile di J è che alcune funzioni possono automaticamente scorrere su elenchi, poiché J sa applicarli in modo puntuale se non ha senso applicarli sull'intero argomento. Quindi il quadrato di un elenco è un elenco di quadrati, per esempio.

Quindi aprende una funzione a sinistra e restituisce una media che "regola" i valori con la funzione, prende la media aritmetica e quindi inverte la regolazione in seguito.

• %aè la media armonica, perché %significa reciproco, ed è il suo contrario.
• ^.a è la media geometrica, perché ^. è il logaritmo naturale e il suo inverso è l'esponenziale.(Π x)^(1/n) = exp(Σ log(x)/n)
• [a è la media aritmetica, perché [ è la funzione identità.
• *:a è la media quadratica, perché *: è quadrata, e il suo inverso è la radice quadrata.
• Il contraarmonico ci dà tutta una serie di problemi - media dei quadrati divisi per media - quindi facciamo un po 'di matematica per ottenerlo: ( *:adiviso per ( [adiviso per *:a)). Questo sembra [a(]%%)*:a. Mentre ci siamo, anteponiamo ciascuno dei mezzi,[a(,,]*%~)*:a .

Infine, utilizziamo le virgole per aggiungere insieme il resto dei risultati. Non abbiamo bisogno di ulteriori parentesi perché la concatenazione è (almeno in questo caso) associativa.

In uso presso J REPL:

   (%a,^.a,[a(,,]%%)*:a=.+/%#&.:) 1,2,3,4,5   NB. used inline
2.18978 2.60517 3 3.31662 3.66667
   f =: %a,^.a,[a(,,]%%)*:a=.+/%#&.:          NB. named
   f 1.7,17.3,3.14,24,2.718,1.618
3.01183 4.62179 8.41267 12.2341 17.7915
   f 8.6
8.6 8.6 8.6 8.6 8.6
   f 3,123456
5.99985 608.579 61729.5 87296.6 123453
   f 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.95799 14.3041 22.5453 27.9395 34.6243
   f 3,4,4,6.2,6.2,6.2
4.5551 4.74682 4.93333 5.10425 5.28108

Q - 53 char

Funzione a argomento singolo. Facciamo solo un elenco di tutti i mezzi che vogliamo.

{s:(a:avg)x*x;(1%a@1%x;exp a log x;a x;sqrt s;s%a x)}

La stessa cosa in altre versioni di k è sotto.

• k4, 51 caratteri: {s:(a:avg)x*x;(%a@%x;exp a log x;a x;sqrt s;s%a x)}
• k2, 54 caratteri: {s:(a:{(+/x)%#x})x*x;(%a@%x;(*/x)^%#x;a x;s^.5;s%a x)}

APL - 42 caratteri

Elenco delle funzioni come argomento.

{(÷M÷⍵)(*M⍟⍵)A(S*.5),(S←M⍵*2)÷A←(M←+/÷≢)⍵}

Spiegato dall'esplosione:

{                                         } ⍝ function with argument ⍵
                                   +/÷≢     ⍝ Sum Divide Length, aka mean
                                 M←         ⍝ assign function to M for Mean
                              A←(M     )⍵   ⍝ arithmetic Mean, assign to A
                     (S←M⍵*2)               ⍝ Mean of squares, assign to S
                      S      ÷A             ⍝ S divide A, aka contraharmonic mean
              (S*.5)                        ⍝ sqrt(S), aka quadratic mean/RMS
                    ,                       ⍝ concatenate into a list
             A                              ⍝ prepend A (APL autoprepends to lists)
        *M⍟⍵                                ⍝ exp of Mean of logs, aka geometric
       (    )                               ⍝ prepend (auto)
  ÷M÷⍵                                      ⍝ recip of Mean of recips, aka harmonic
 (    )                                     ⍝ prepend (auto)

Q'Nial - 68 char

Ti piacerà questo.

op\{$is/[+,tally];^is$*[pass,pass];[1/$(1/),exp$ln,$,sqrt^,/[^,$]]\}

Q'Nial è un altro linguaggio orientato all'array, un'implementazione di Nial , che si basa su un'oscura teoria dell'array nel modo in cui Haskell si basa sulla teoria delle categorie. (Scaricalo qui .) È molto diverso da tutti gli altri tre - analizza da sinistra a destra, prima di tutto! - ma è ancora più legato a loro che a qualsiasi altra lingua.

12 lingue

CJam, 45 44 43 byte

q~:Q,:LQWf#:+/Q:*LW##Q:+L/_Q2f#:+L/_mq\@/]`

Legge una matrice di float (ad es. [1.0 2.0 3.0 4.0 5.0]) Da STDIN. Provalo online.

APL, 67 61 53 52 50 byte

{(N÷+/÷⍵)(×/⍵*÷N)A(Q*÷2),(Q←+/(⍵*2)÷N)÷A←+/⍵÷N←⍴⍵}

Provalo online.

Pyth, 55 52 byte

JyzKlJ=YcsJK=Zcsm^d2JK(cKsmc1kJ ^u*GHJc1K Y ^Z.5 cZY

Legge i numeri separati da spazio (ad es. 1 2 3 4 5) Da STDIN.

Ottava, 68 byte

#!/usr/bin/octave -qf
[mean(I=input(''),"h") mean(I,"g") a=mean(I) q=mean(I.*I)**.5 q*q/a]

Senza contare lo shebang. Legge un array (ad es. [1 2 3 4 5]) Da STDIN.

GNU bc, 78 byte

#!/usr/bin/bc -l
while(i=read()){h+=1/i;g+=l(i);a+=i;q+=i*i;n+=1}
n/h;e(g/n);a/n;sqrt(q/n);q/a

Contando lo shebang come 1 byte ( -lswitch). Legge i float separati da spazi bianchi da STDIN, seguiti da uno zero.

Awk, 78 byte

#!/usr/bin/awk -f
{h+=1/$0;g+=log($0);a+=$0;q+=$0^2;n++}END{print n/h,exp(g/n),a/n,(q/n)^.5,q/a}

Senza contare lo shebang. Legge un numero per riga da STDIN.

GolfScript, 86 83 byte

n%{~.2.-1:$??./*\`,10\?/\+\;}%..,:^0@{$?+}//p.{*}*^$??p.{+}*^/.p\0\{.*+}/^/.2$??p\/

GolfScript non ha il supporto integrato per i float, quindi il codice li sta analizzando. Pertanto, il formato di input è piuttosto restrittivo: devi inserire 1.0e 0.1piuttosto che 1, 1.o .1.

Legge i float (come spiegato sopra) uno per riga, da STDIN. Provalo online.

Perl, 90 85 byte

#!/usr/bin/perl -n
$h+=1/$_;$g+=log;$a+=$_;$q+=$_**2}{$,=$";print$./$h,exp$g/$.,$a/$.,($q/$.)**.5,$q/$a

Contando lo shebang come 1 byte ( -nswitch). Legge un numero per riga da STDIN.

Python 2, 102 96 byte

#!/usr/bin/python
h=a=q=n=0;g=1
for i in input():h+=1/i;g*=i;a+=i;q+=i*i;n+=1
print n/h,g**n**-1,a/n,(q/n)**.5,q/a

Senza contare lo shebang. Legge un elenco di float (ad es. 1.0,2.0,3.0,4.0,5.0) Da STDIN.

ECMAScript 6 (JavaScript), 114 112 byte

m=I=>{for(g=1,h=a=q=n=0,p=Math.pow;i=I.pop();h+=1/i,g*=i,a+=i,q+=i*i)n++;
return[n/h,p(g,1/n),a/n,p(q/n,.5),q/a]}

Senza contare l'LF. Si aspetta un array (ad esempio, [1,2,3,4,5]) come argomento.

PHP, 135 (o 108?) Byte

#!/usr/bin/php
<?for($c=1;$c<$argc;$c++){$i=$argv[$c];$h+=1/$i;$g+=log($i);$a+=$i;$q+=$i*$i;$n++;}
print_r([$n/$h,exp($g/$n),$a/$n,sqrt($q/$n),$q/$a]);

Senza contare Shebang o LF. Legge float come argomenti della riga di comando.

Ho una soluzione più breve, ma non so come contare i byte:

php -R '$i=$argn;$h+=1/$i;$g+=log($i);$a+=$argn;$q+=$i^2;$n++;' \
-E 'print_r([$n/$h,exp($g/$n),$a/$n,sqrt($q/$n),$q/$a]);'

Contando i byte in ciascuna stringa di codice e aggiungendone due per -Re -E, questo approccio otterrebbe 108.

C, 172 140 139 137 136 byte

float i,h,g=1,a,q,n;main(){for(;scanf("%f",&i)+1;n++)h+=1/i,g*=i,a+=i,q+=i*i;
printf("%f %f %f %f %f",n/h,pow(g,1/n),a/n,sqrt(q/n),q/a);}

Senza contare l'LF. Compila con gcc -lm. Legge i float separati da spazi bianchi da STDIN.

J (50):

Questo è il tipo di cosa in cui J è bravo:

(#%+/@:%),(#%:*/),(+/%#),%:@(%@#*+/@:*:),+/@:*:%+/

Come sempre: un'esplosione nella fabbrica di smiley. Tuttavia, alcune faccine sono state lasciate intatte questa volta: :)e :*:(quello è un ragazzo con quattro occhi e una gemma incastonata nella sua faccia) La mia sessione interattiva che è stata usata per creare questo: http://pastebin.com/gk0ksn2b

In azione:

   f=:(#%+/@:%),(#%:*/),(+/%#),%:@(%@#*+/@:*:),+/@:*:%+/
   f 1,2,3,4,5
2.18978 2.60517 3 3.31662 3.66667
   f 1.7,17.3,3.14,24,2.718,1.618
3.01183 4.62179 8.41267 12.2341 17.7915
   f 8.6
8.6 8.6 8.6 8.6 8.6
   f 3,123456
5.99985 608.579 61729.5 87296.6 123453
   f 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.95799 14.3041 22.5453 27.9395 34.6243
   f 3,4,4,6.2,6.2,6.2
4.5551 4.74682 4.93333 5.10425 5.28108

Spiegazione:

Come ci si potrebbe aspettare, in realtà ci sono 5 funzioni che sono raggruppate in un elenco con un treno di forchette e ganci. (Non preoccuparti, è solo un modo conveniente per creare più funzioni in un unico elenco).

Le righe che ho usato per fare in modo che J generasse questa risposta potrebbero essere leggermente più chiare:

   f=:harmonic , Geometric , arithmatic , rms , contraharmonic
   f
harmonic , Geometric , arithmatic , rms , contraharmonic
   f f.
(# % +/@:%) , (# %: */) , (+/ % #) , %:@(%@# * +/@:*:) , +/ %~ +/@:*:

Diamo un'occhiata a loro separatamente.

Armonico

(# % +/@:%)

• # - Lunghezza (dell'array)
• % - Diviso per
• +/@:%- La somma ( +/o piega +nell'array ( +/1 2 3 4== 1+2+3+4)) in cima alla divisione, ma questa volta nel caso monadico. Ciò significa che J "automaticamente" indovina che 1 sarebbe il valore più utile.

Geometrico

(# %: */)

• # - Lunghezza (dell'array)
• %:- Root ( 4 %: 7significherebbe 'la quarta (o tesseract) radice di sette)
• */- Prodotto ( */è simile nel significato a +/, vedere la funzione precedente per questo)

Aritmetica

(+/ % #)

• +/ - somma, dovrebbe essere familiare ora
• % - diviso per
• # - Lunghezza

Radice quadrata media

%:@(%@# * +/@:*:)

Ehm, sì ...

• %: - La radice di
  • %@# - L'inverso della lunghezza
  • * - Tempi
  • +/@:*:- La somma dei quadrati ( *:è quadrata, anche se lo *~è anche.)

Contraharmonic

+/@:*: % +/

• +/@:*: - La somma dei quadrati
• % - diviso per
• +/ - la somma.

In realtà ho scoperto che la mia funzione era un byte due byte troppo a lungo spiegando questo, quindi va bene!

Se J fosse così bravo nell'elaborare le stringhe, vinceremo molte più competizioni golfistiche ...

Lingue: 5

POV-Ray 3.7 Descrizione della scena Lingua: 304 byte

#fopen I"i"read#declare S=0;#declare N=0;#declare Q=0;#declare P=1;#declare R=0;#while(defined(I))#read(I,V)#declare S=S+V;#declare N=N+1;#declare Q = Q+V*V;#declare P=P*V;#declare R=R+1/V;#end#warning concat(str(N/R,0,5),",",str(pow(P,1/N),0,5),",",str(S/N,0,5),",",str(sqrt(Q/N),0,5),",",str(Q/S,0,5))

(POV-Ray SDL non ha funzioni di input della console, quindi ho sostituito l'input del file. L'output è per la console, ma è circondato da una buona quantità di output dello stato del programma.)

Commodore BASIC: 111 104 byte

1 P=1:O┐1,0
2 I/#1 V:IF V=0T|G┌4
3 S=S+V:N=N+1:Q=Q+V*V:P=P*V:R=R+1/V:G┌2
4 ?N/R,P↑(1/N),S/N,(Q/N)↑.5,Q/S

(Non tutti i caratteri di questo programma possono essere rappresentati in Unicode. |Viene utilizzato per rappresentare SHIFT+H, ┌rappresentare SHIFT+O, ┐rappresentare SHIFT+P, /rappresentareSHIFT+N . A causa delle limitazioni nell'I / O di Commodore Basic, l'ingresso viene inserito un numero alla volta, con un input di -1 per indicare la fine dell'input. L'output è delimitato da tabulazioni.)

QBasic: 96 byte

P=1:INPUT V:WHILE V:S=S+V:N=N+1:Q=Q+V*V:P=P*V:R=R+1/V:INPUT V:WEND:?N/R;P^(1/N);S/N;(Q/N)^.5;Q/S

Utilizza lo stesso schema I / O della voce DLosc; Ho giocato a golf di 15 byte usando il fatto cheINPUT V restituisce 0 ( restituisce false) quando viene immessa una riga vuota (almeno in QBasic 1.1 MS-DOS - Non so se funziona anche in QB64).

Pascal (compilatore FPC): 172 byte

program M;uses math;var v,p,s,n,q,r:real; begin p:=1;while not eoln do begin read(v);s:=s+v;n:=n+1;q:=q+v*v;p:=p*v;r:=r+1/v end;write(n/r,p**(1/n),s/n,(q/n)**0.5,q/s);end.

L'input è separato da spazi, non da virgole ed è terminato a capo. L'output è separato dallo spazio.

Erlang: 401 byte

-module(means).
-import(io).
-import(math).
-import(string).
-import(lists).
-export([means/6]).

means(S,N,Q,P,R,[]) -> io:fwrite("~f,~f,~f,~f,~f~n", [N/R,math:pow(P,(1/N)),S/N,math:sqrt(Q/N),Q/S]);
means(S,N,Q,P,R,[V|T]) -> means(S+V,N+1,Q+V*V,P*V,R+1/V,T).

means:means(0,0,0,1,0,lists:map(fun({F,R}) -> F end, lists:map(fun(X) -> string:to_float(X) end, string:tokens(io:get_line(""), ",\n")))).

La gestione delle corde in Erlang è un dolore reale. Di conseguenza, tutti i numeri in virgola mobile devono essere inseriti con almeno una cifra dopo il punto decimale - string:to_float/1non verranno convertiti 1, ma verranno convertiti1.0 .

(Altro a venire, soprattutto se capisco come farlo in RoboTalk, un linguaggio senza operazioni in virgola mobile né I / O)

Lingue: 3

Salvo diversamente specificato, i numeri devono essere separati dallo spazio.

C: 181 163

Prende i numeri fino alla fine dell'input.

#include<math.h>
main(){double h=0,g=1,a=0,q=0,k,n=0;for(;scanf("%lf",&k);++n)h+=1/k,g*=k,a+=k,q+=k*k;printf("%f %f %f %f %f\n",n/h,pow(g,1/n),a/n,sqrt(q/n),q/a);}

(ISO) C ++: 195

Prende i numeri fino alla fine dell'input.

#include<iostream>
#include<cmath>
int main(){double h=0,g=1,a=0,q=0,k,n=0;for(;std::cin>>k;++n)h+=1/k,g*=k,a+=k,q+=k*k;std::cout<<n/h<<" "<<pow(g,1/n)<<" "<<a/n<<" "<<sqrt(q/n)<<" "<<q/a<<"\n";}

Haskell: 185 180 164 159 149 140

Prende arbitrariamente molti elenchi di numeri separati da newline.

Implementazione

m=map
f x=let{s=sum;n=s$m(\_->1)x;t=s$m(^2)x}in[n/s(m(1/)x),product x**(1/n),s x/n,sqrt$t/n,t/s x]
main=getLine>>=print.f.m read.words>>main

50 41 (grazie shiona) byte sono solo per IO: /.

Esempio

(Powershell's echoaka Write-Outputstampa ogni parametro su una sola riga)

PS> echo "1 2 3 4 5" "1.7 17.3 3.14 24 2.718 1.618" | runhaskell SO.hs
[2.18978102189781,2.605171084697352,3.0,3.3166247903554,3.6666666666666665]
[3.011834514901806,4.621794669196026,8.412666666666668,12.234139719108438,17.791525635945792]

Lingue - 4

Adoro sempre una scusa per tirar fuori il buon vecchio

QBasic, 112 96 byte

g=1:INPUT x:WHILE x:h=h+1/x:g=g*x:a=a+x:q=q+x^2:n=n+1:INPUT x:WEND:?n/h;g^(1/n);a/n;SQR(q/n);q/a

QBasic non è buono con un numero variabile di input, quindi il programma richiede un numero per riga, terminato con 0 o una riga vuota. L'output è separato da spazi.

(Accorciato quando mi sono reso conto che 0 non è un numero valido e può essere utilizzato per la terminazione dell'input.)

Testato utilizzando QB64 :

Lisp comune, 183 byte

(defun m(l)(let((a(apply #'+ l))(q(apply #'+(map'list #'(lambda(x)(* x x))l)))(n(length l)))(list(/ n(apply #'+(map'list #'/ l)))(expt(apply #'* l)(/ n))(/ a n)(sqrt(/ q n))(/ q a))))

Per qualche ragione mi aspettavo che questo fosse più breve. Non sono un esperto di Lisp, quindi i suggerimenti sono apprezzati. Versione non golfata:

(defun means (l)
  (let ((a (apply #'+ l))                                    ; sum of numbers
        (q (apply #'+ (map 'list #'(lambda (x) (* x x)) l))) ; sum of squares
        (n (length l)))
    (list                                 ; Return a list containing:
      (/ n (apply #'+ (map 'list #'/ l))) ; n over sum of inverses
      (expt (apply #'* l) (/ n))          ; product to the power of 1/n
      (/ a n)                             ; a/n
      (sqrt (/ q n))                      ; square root of q/n
      (/ q a)                             ; q/a
    )
  )
)

Probabilmente il modo migliore per testare è incollare la funzione nel clispREPL, in questo modo:

$ clisp -q
[1]> (defun m(l)(let((a(apply #'+ l))(q(apply #'+(map'list #'(lambda(x)(* x x))l)))(n(length l)))(list(/ n(apply #'+(map'list #'/ l)))(expt(apply #'* l)(/ n))(/ a n)(sqrt(/ q n))(/ q a))))
M
[2]> (m '(1 2 3 4 5))
(300/137 2.6051712 3 3.3166249 11/3)
[3]> (m '(8.6))
(8.6 8.6 8.6 8.6 8.6)
[4]> (m '(3 123456))
(246912/41153 608.5787 123459/2 87296.58 5080461315/41153)

Adoro il modo in cui Lisp usa le frazioni esatte invece dei float quando divide due numeri interi.

Prolog, 235 byte

Prolog non è eccezionale in matematica, ma lo useremo comunque. Testato con SWI-Prolog. Penso che il sumlistpredicato potrebbe non essere Prolog standard, ma comunque lo sto usando.

m(L,H,G,A,Q,C):-length(L,N),h(L,I),H is N/I,p(L,P),G is P^(1/N),sumlist(L,S),A is S/N,q(L,R),Q is sqrt(R/N),C is R/S.
p([H|T],R):-p(T,P),R is H*P.
p([],1).
q([H|T],R):-q(T,P),R is H*H+P.
q([],0).
h([H|T],R):-h(T,P),R is 1/H+P.
h([],0).

Ungolfed:

m(L, H, G, A, Q, C) :-
        length(L, N),   % stores the length into N
        h(L, I),        % stores the sum of inverses into I
        H is N/I,
        p(L, P),        % stores the product into P
        G is P^(1/N),
        sumlist(L, S),  % stores the sum into S
        A is S/N,
        q(L, R),        % stores the sum of squares into R
        Q is sqrt(R/N),
        C is R/S.

% Helper predicates:

% p calculates the product of a list
p([H|T], R) :-
        p(T, P),     % recursively get the product of the tail
        R is H*P.    % multiply that by the head
p([], 1).            % product of empty list is 1

% q calculates the sum of squares of a list
q([H|T], R) :-
        q(T, P),     % recursively get the sum of squares of the tail
        R is H*H+P.  % add that to the square of the head
q([], 0).            % sum of empty list is 0

% h calculates the sum of inverses of a list
h([H|T], R) :-
        h(T, P),     % recursively get the sum of inverses of the tail
        R is 1/H+P.  % add that to the inverse of the head
h([], 0).            % sum of empty list is 0

Su Linux, con il codice in un file chiamato means.pro , prova in questo modo:

$ swipl -qs means.pro
?-  m([1,2,3,4,5],H,G,A,Q,C).
H = 2.18978102189781,
G = 2.605171084697352,
A = 3,
Q = 3.3166247903554,
C = 3.6666666666666665.

Fornisce un risultato corretto ma piuttosto divertente quando c'è un solo numero:

 ?- m([8.6],H,G,A,Q,C).
 H = G, G = A, A = Q, Q = C, C = 8.6.

Python 3, 103 byte

h=a=q=n=0;g=1
for x in eval(input()):h+=1/x;g*=x;a+=x;q+=x*x;n+=1
print(n/h,g**(1/n),a/n,(q/n)**.5,q/a)

Stessa strategia della versione Python 2 di Dennis . Prende un elenco di numeri separato da virgole; gestisce sia ints che float. Un input a numero singolo deve essere racchiuso tra parentesi quadre (e può sempre esserci un elenco di numeri ); una correzione costerebbe 4 byte.

8 lingue

Fortran 77 - 286

      READ*,l
      b1=0
      b2=1
      b3=0
      b4=0
      DO 10 i=1,l
        READ*,j
        b1=b1+1/j
        b2=b2*j
        b3=b3+j
        b4=b4+j**2
   10 CONTINUE
      h=l/b1
      g=b2**(1/l)
      a=b3/l
      q=(b4/l)**0.5
      c=b4/b3
      PRINT*,h,g,a,q,c
      END

BBC BASIC - 131

INPUT l
b=0:d=1:e=0:f=0
FOR i=1 TO l
  INPUTj:b+=1/j:d*=j:e+=j:f+=j^2
NEXT l
h=l/b:g=d^(1/l):a=e/l:q=(f/l)^0.5:c=f/e
PRINTh,g,a,q,c

Produzione:

5 
5
100
12
15
1
9.7914836236097695 26.600000000000001 45.596052460711988 78.15789473684211  

C ++ - 292

#include <iostream>
#include <cmath>
using namespace std;int main(){cout << "Length of sequence?: ";cin >> l;int b=0;int d=1;int e=0;int f=0;int j;int seq[l];for(int i=0;i<l;i++){cin >> j;b+=1/j;d*=j;e+=j;f+=pow(j,2);}
    h=l/b;g=pow(d,(1/l));a=e/l;q=pow((f/l),0.5);c=f/e;cout << h,g,a,q,c;}

Python 3 - 151

s=input().split(',');l=len(s);b=0;d=1;e=0;f=0
for i in s:i=float(i);b+=1/i;d*=i;e+=i;f+=i**2
h=l/b;g=d**(1/l);a=e/l;q=(f/l)**0.5;c=f/e
print(h,g,a,q,c)

Produzione:

5,100,12,15,1       # Input
3.6764705882352944 9.7914836236097695 26.600000000000001 45.596052460711988 78.15789473684211

Java - 421

class Sequences {
    public static void main( String[] args){
        System.out.println("Length of sequence?: ");Scanner reader = new Scanner(System.in);l=reader.nextInt();int b=0;int d=1;int e=0;int f=0;int j;int seq[l];
        for(int i=0;i<l;i++){j=reader.nextInt();b+=1/j;d*=j;e+=j;f+=Math.pow(j,2);}
        h=l/b;g=Math.pow(d,(1/l));a=e/l;q=Math.sqrt(f/l);c=f/e;System.out.println(h+' '+g +' '+ a+' '+q+' '+c);}}

Javascript - 231

Non sono un Javascripter quindi qualsiasi consiglio sarebbe molto apprezzato

console.log("Length of sequence?: ");
var l=readline(),b=0,d=1,e=0,f=0;
for(var i = 0;i<l;i++) {var j=readline();b+=1/j;d*=j;e+=j;f+=pow(j,2);}
h=l/b;g=pow(d,(1/l));a=e/l;q=sqrt(f/l);c=f/e;
console.log(h+' '+g+' '+a+' '+q+' '+c);

Algoid - 337

Cerca su Google Play Store o Raspberry Pi Store

text.clear();
set l=text.inputNumber("Length of sequence?: ");set b=0;set d=1;set e=0;set f=0;set seq=array{};
for(set i=1; i<=l; i++){set j=text.inputNumber(i..": ");b+=1/j;d*=j;e+=j;f+=math.pow(j,2);}
set h=l/b;set g=math.pow(d,(1/l));set a=e/l;set q=math.sqrt(f/l);set c=f/l;set str=h.." "..g.." "..a.." "..q.." "..c;text.output(str);

var'aQ - 376

Questo è sintatticamente corretto e tutto, ma tutti gli interpreti attuali non funzionano ...

0 ~ b cher
1 ~ d cher
0 ~ e cher
0 ~ f cher
'Ij mI'moH ~ l cher
l {
    'Ij mI'moH ~ j cher
    b 1 j wav boq ~ b cher
    d j boq'egh ~ d cher
    e j boq ~ e cher
    f j boqHa'qa boq ~ f cher
} vangqa'
l b boqHa''egh ~ h cher
d 1 l boqHa''egh boqHa'qa  ~ g cher
e l boqHa''egh ~ a cher
f l boqHa''egh loS'ar ~ q cher
f e boqHa''egh c cher
h cha'
g cha'
a cha'
q cha'
c cha'

Lingue: 3

CJam, 58

qS%:d:A{1\/}%:+A,\/SA:*1.A,/#SA:+A,/:BSA{2#}%:+A,/:CmqSCB/

TI-Basic, 85

Input L1:{dim(L1)/sum(1/(L1),dim(L1)√prod(L1),mean(L1),√(mean(L1²)),mean(L1²)/mean(L1

Java, 457

import java.util.*;class C{public static void main(String[]s){List r=new ArrayList();double[]d=Arrays.stream(new Scanner(System.in).nextLine().split(",")).mapToDouble(Double::new).toArray();double x=0,y,z;for(double D:d){x+=1/D;}r.add(d.length/x);x=1;for(double D:d){x*=D;}r.add(Math.pow(x,1./d.length));r.add(y=Arrays.stream(d).average().getAsDouble());x=1;for(double D:d){x+=D*D;}r.add(Math.sqrt(z=x/d.length));r.add(z/y);r.forEach(System.out::println);}}

Lingue - 2

Cobra - 132

def f(l as number[])
    a,b,c,d=0d,1d,0d,0d
    for i in l,a,b,c,d=a+1/i,b*i,c+i,d+i**2
    print (e=l.length)/a,b**(1/e),c/e,(d/e)**0.5,d/c

Python - 129

def f(l):a,b,c=len(l),sum(i*i for i in l),sum(l);print(a/sum(1/i for i in l),eval('*'.join(map(str,l)))**(1/a),c/a,(b/a)**.5,b/c)

1 lingua

R, 92 91

f=function(x){n=length(x);s=sum;d=s(x^2);c(n/s(1/x),prod(x)^(1/n),mean(x),(d/n)^.5,d/s(x))}

Prende un vettore di valore e genera un vettore di mezzi.

1 lingua

Golfscript, 162

n/:@,:^;'(1.0*'@'+'*+')/'+^+'('@'*'*+')**(1.0/'+^+')'+^'/(1.0/'+@'+1.0/'*+')'+'(1.0/'^+'*('+@'**2+'*+'**2))**0.5'+'('@'**2+'*+'**2)/'+4$+'*'+^+]{'"#{'\+'}"'+~}%n*

Sì, è enorme. E può sicuramente essere ridotto. Cosa che farò qualche tempo dopo. Provalo qui .

Si aspetta che l'input sia separato da newline. Se ciò non è consentito, lo aggiusterò (+2 caratteri). Emette l'elenco newline separato.

Ecco una versione leggermente più leggibile:

n/:@,:^;
'(1.0*'@'+'*+')/'+^+
'('@'*'*+')**(1.0/'+^+')'+
^'/(1.0/'+@'+1.0/'*+')'+
'(1.0/'^+'*('+@'**2+'*+'**2))**0.5'+
'('@'**2+'*+'**2)/'+4$+'*'+^+
]{'"#{'\+'}"'+~}%
n*

Lingue 2

Fortran: 242

L'ho ignorato per chiarezza, ma la versione da golf è ciò che viene contato. devi prima inserire il numero di valori da aggiungere, quindi i valori.

program g
   real,allocatable::x(:)
   read*,i
   allocate(x(i));read*,x
   print*,m(x)
 contains
   function m(x) result(p)
      real::x(:),p(5)
      n=size(x)
     p(1:4)=[n/sum(1/x),product(x)**(1./n),sum(x)/n,sqrt(sum(x**2)/n)]
     p(5)=p(4)**2/p(3)
   endfunction
end

wxMaxima 134

Copia questo nell'editor, ctrl+enter quindi chiama via m([1,2,3,4,5]),numerper ottenere un output in virgola mobile (altrimenti otterrai un output simbolico).

m(x):=block([n:length(x),d:0,c:mean(x)],for i:1 thru n do(g:x[i],d:d+g*g),return([1/mean(1/x),apply("*",x)^(1/n),c,sqrt(d/n),d/n/c]));

Perl, 86 76

$,=$";$h+=1/uc,$g+=log,$a+=lc,$q+=$_**2for<>;print$./$h,exp$g/$.,$a/$.,sqrt$q/$.,$q/$a

Input: un numero per riga.

EDIT: questo è un personaggio più lungo, ma poiché apparentemente le linee di shebang non sono contate per il totale, finisce per essere migliore:

#!perl -pl
$"+=1/uc,$,+=log,$}+=lc,$;+=$_**2}for($./$",exp$,/$.,$}/$.,sqrt$;/$.,$;/$}){

T-SQL, 136 122

Con gli elenchi di numeri memorizzati nella tabella S con I (intero) che identifica l'elenco e V (float) il valore.

SELECT COUNT(*)/SUM(1/V),EXP(SUM(LOG(V))/COUNT(*)),AVG(V),SQRT((1./COUNT(*))*(SUM(V*V))),SUM(V*V)/SUM(V) FROM S GROUP BY I

SQLFiddle

Salvato 14 grazie ad Alchymist

Lingue: 5

Alcune voci si sforzano di evitare errori di arrotondamento (al 4 ° decimale), usando il BigDecimal di Java invece di float / double, e accettano le regole IO per OP.

Le voci più recenti rilassano sia le regole IO sia BigDecimal.

Groovy - 409 400 164 157 caratteri

float i=0,j=1,k=0,l,n=0,m=0,p;args.each{x=it as float;i+=1/x;j*=x;k+=x;m+=x*x;n++};l=k/n;p=m/n;println "${n/i},${Math.pow(j,1f/n)},$l,${Math.sqrt p},${p/l}"

esempio di esecuzione:

bash$ groovy F.groovy 10.1381 29.8481 14.7754 9.3796 44.3052 22.2936 49.5572 4.5940 39.6013 0.9602
5.957994213465398,14.304084339049883,22.545269,27.939471625408938,34.62429631138658

Java - 900 235 caratteri

class F{public static void main(String[]a){float i=0,j=1,k=0,l,n=0,m=0,p;for(String s:a){float x=Float.valueOf(s);i+=1/x;j*=x;k+=x;m+=x*x;n++;}l=k/n;p=m/n;System.out.println(n/i+","+Math.pow(j,1f/n)+","+l+","+Math.sqrt(p)+","+p/l);}}

esempio di esecuzione:

bash$ java F 10.1381 29.8481 14.7754 9.3796 44.3052 22.2936 49.5572 4.5940 39.6013 0.9602
5.957994,14.304084906138343,22.545269,27.939471625408938,34.6243

Clojure - 524 324 caratteri

(defn r[x](/ (reduce + 0.0 x)(count x)))
(defn s[x](reduce #(+ %1 (* %2 %2)) 0.0 x))
(defn f[x](let[n (* 1.0 (count x))][(/ n(reduce #(+ %1 (/ 1.0 %2)) 0.0 x))(Math/pow(reduce * x)(/ 1.0 n))(r x)(Math/sqrt(/(s x) n))(/(/(s x) n)(r x))]))
(doseq [x(f(map #(Float/valueOf %) *command-line-args*))](print(str x ",")))
(println)

esempio di esecuzione (ha una virgola finale alla fine):

bash$ java -jar clojure-1.6.0.jar m2.clj 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.957994368133907,14.30408424976292,22.545269936323166,27.93947151073554,34.62429460831333,

Scala - 841 663 230 caratteri

import java.math._
object F{def main(a:Array[String]){
var i,j,k,l,m,p=0f;var n=0
a.foreach{y=>var x=y.toFloat;i+=1/x;j*=x;k+=x;m+=x*x;n+=1}
l=k/n;p=m/n;System.out.println(n/i+","+Math.pow(j,1f/n)+","+l+","+Math.sqrt(p)+","+p/l)}}

esempio di esecuzione:

bash$ scala F.scala 10.1381 29.8481 14.7754 9.3796 44.3052 22.2936 49.5572 4.5940 39.6013 0.9602
5.957994,0.0,22.545269,27.939471625408938,34.6243

JRuby - 538 caratteri

Non è chiaro se JRuby differisce da Ruby: questo deve essere eseguito su JVM. Eppure è la sintassi di Ruby. Ad ogni modo, lo sto includendo nello spirito di una Rosetta Stone.

require 'java'
java_import 'java.math.BigDecimal'
o=BigDecimal::ONE
z=BigDecimal::ZERO
def b(s) java.math.BigDecimal.new s end
def p(x,y) java.lang.Math::pow(x.doubleValue,y.doubleValue) end
def d(x,y) x.divide y,5,BigDecimal::ROUND_UP end
def r(x,n) d(x.inject(b(0)){|a,v|a.add v},n) end
def s(x) x.inject(b(0)){|a,v|a.add(v.multiply v)} end
x=[]
ARGV[0].split(",").each{|i|x<<b(i)}
n=b x.size
puts "#{d n,x.inject(z){|a,v|a.add(d o,v)}},#{p x.inject(o){|a,v|a.multiply v},d(o,n)},#{r(x,n)},#{p d(s(x),n),b("0.5")},#{d d(s(x),n),r(x,n)}"

esempio di esecuzione (stampa un avviso su stderr):

bash$ jruby Mean.rb 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.95781,14.30408436301878,22.54527,27.939471541172715,34.62430

Lingue 1

lua - 113

e=arg s=#e h,g,a,r=0,1,0,0 for i=1,s do x=e[i]h=h+1/x g=g*x a=a+x/s r=r+x^2/s end print(s/h,g^(1/s),a,r^.5,r/a)

Lingue - 1

Groovy:

def input = [1.7,17.3,3.14,24,2.718,1.618];
def arithmeticMean
def harmonicMean
def geometricMean
def quadraticMean
def contraharmonicMean

def sum = 0
def product = 1
// Arithmetic Mean
for(each in input){
    sum += each
}
arithmeticMean = sum / input.size()

// Harmonic Mean
sum = 0
for(each in input){
    sum += (1/each)
}
harmonicMean = input.size() / sum

// Geometric Mean
for(each in input){
    product *= each
}
geometricMean = Math.pow(product,1/input.size());

// Quadratic Mean
sum = 0
for(each in input){
    sum += (each*each)
}
quadraticMean = Math.pow(sum/input.size() ,(1/2))

// Contraharmonic Mean
sum = 0
def sum2 = 0
for( each in input ){
    sum += each
    sum2 += (each * each)
}
contraharmonicMean = (sum2/input.size()) / (sum/input.size())

println "Arithmetic Mean: $arithmeticMean"
println "Harmonic Mean: $harmonicMean"
println "Geometric Mean: $geometricMean"
println "Quadratic Mean: $quadraticMean"
println "Contraharmoic Mean: $contraharmonicMean"

2 lingue

Java - 243 byte

class M{public static void main(String[]a){float h=0,l=a.length,p=1,s=0,q=0;for(int i=0;i<l;i++){float v=Float.valueOf(a[i]);q+=v*v;s+=v;h+=1/v;p*=v;}System.out.println(l/h+"\n"+Math.pow(p,1.0/l)+"\n"+s/l+"\n"+Math.sqrt((1.0/l)*q)+"\n"+q/s);}}

allargato:

class Means {
    public static void main(String[] a) {
        float h = 0, l = a.length, p = 1, s = 0, q = 0;
        for (int i = 0; i < l; i++) {
            float v = Float.valueOf(a[i]);
            q += v * v;
            s += v;
            h += 1 / v;
            p *= v;
        }
        System.out.println(l / h + "\n" + Math.pow(p, 1.0 / l) + "\n" + s / l
                + "\n" + Math.sqrt((1.0 / l) * q) + "\n" + q / s);
    }
}

vba - excel, 387 byte

Inserisci i valori nella prima colonna, quindi premi il pulsante (che attiva questo codice) e genera i valori nella seconda colonna.

Private Sub a_Click()
Dim d,s,q,h,p As Double
Dim y As Integer
h=0
q=0
s=0
p=1
y=1
While Not IsEmpty(Cells(y,1))
s=s+Cells(y,1)
q=q+Cells(y,1)*Cells(y,1)
h=h+1/Cells(y,1)
p=p*Cells(y,1)
y=y+1
Wend
y=y-1
Cells(1,2)=y/h
Cells(2,2)=p^(1/y)
Cells(3,2)=s/y
Cells(4,2)=((1/y)*q)^0.5
Cells(5,2)=q/s
End Sub

1 lingua

Ruggine - 469

( rustc 0.11.0-pre (3851d68 2014-06-13 22:46:35 +0000))

use std::io;use std::from_str::from_str;use std::num;fn main(){loop{let a:Vec<f64>=io::stdin().read_line().ok().expect("").as_slice().split(',').map(|x|std::from_str::from_str(x.trim_chars('\n')).expect("")).collect();let n:f64=num::from_uint(a.len()).expect("");let s=a.iter().fold(0.0,|a,b|a+*b);let q=a.iter().fold(0.0,|a,b|a+*b* *b);println!("{},{},{},{},{}",n / a.iter().fold(0.0,|a,b|a+1.0/ *b),(a.iter().fold(1.0,|a,b|a**b)).powf(1.0/n),s/n,(q/n).sqrt(),q/s,);}}

Versione non golfata:

use std::io;
use std::from_str::from_str;
use std::num;

fn main() {
    loop {
        let a : Vec<f64>  = io::stdin().read_line().ok().expect("").as_slice().split(',')
                               .map(|x|std::from_str::from_str(x.trim_chars('\n')).expect("")).collect();
        let n : f64 = num::from_uint(a.len()).expect("");
        let s = a.iter().fold(0.0, |a, b| a + *b);
        let q = a.iter().fold(0.0, |a, b| a + *b * *b);
        println!("{},{},{},{},{}",
                 n / a.iter().fold(0.0, |a, b| a + 1.0 / *b),
                 (a.iter().fold(1.0, |a, b| a * *b)).powf(1.0/n),
                 s / n,
                 (q / n).sqrt(),
                 q / s,
                 );
    }
}

Versione compatta da 430 byte senza loop o input, per test in playrust :

use std::from_str::from_str;use std::num;fn main(){let a:Vec<f64>="1,2,3,4".as_slice().split(',').map(|x|std::from_str::from_str(x.trim_chars('\n')).expect("")).collect();let n:f64=num::from_uint(a.len()).expect("");let s=a.iter().fold(0.0,|a,b|a+*b);let q=a.iter().fold(0.0,|a,b|a+*b**b);println!("{},{},{},{},{}",n / a.iter().fold(0.0, |a, b| a + 1.0 / *b),(a.iter().fold(1.0, |a, b| a * *b)).powf(1.0/n),s/n,(q/n).sqrt(),q/s);}

Aggiornato per Rust più recente:

Ungolfed:

use std::io;                 
fn main(){
    let mut s=String::new();
    io::stdin().read_line(&mut s);
    let a:Vec<f64>=s
        .split(',')
        .map(|x|x.trim().parse().expect(""))
        .collect();
    let n:f64=a.len() as f64;
    let s=a.iter().fold(0.0,|a,b|a+*b);
    let q=a.iter().fold(0.0,|a,b|a+*b**b);
    println!("{},{},{},{},{}",
        n / a.iter().fold(0.0, |a, b| a + 1.0 / *b),
        (a.iter().fold(1.0, |a, b| a * *b)).powf(1.0/n),s/n,
        (q/n).sqrt(),q/s);
}

Golfato (402 byte):

use std::io;fn main(){ let mut s=String::new(); io::stdin().read_line(&mut s); let a:Vec<f64>=s .split(',') .map(|x|x.trim().parse().expect("")) .collect(); let n:f64=a.len() as f64; let s=a.iter().fold(0.0,|a,b|a+*b); let q=a.iter().fold(0.0,|a,b|a+*b**b); println!("{},{},{},{},{}", n / a.iter().fold(0.0, |a, b| a + 1.0 / *b), (a.iter().fold(1.0, |a, b| a * *b)).powf(1.0/n),s/n, (q/n).sqrt(),q/s);}

Lingue: 4

CoffeeScript, 193

Accetta una stringa di input separata da virgola:

m=(q)->m=Math;q.r=q.reduce;q=q.split(',').map Number;l=q.length;x=q.r ((p,v)->(p+v)),0;y=q.r ((p,v)->(p+v*v)),0;[l/q.r(((p,v)->(p+1/v)),0),m.pow(q.r(((p,v)->(p*v)),1),1/l),x/l,m.sqrt(y/l),y/x];

JavaScript (ES5), 256

Ancora una volta, accetta una stringa di input separata da virgola:

function m(q){m=Math,q=q.split(',').map(Number),q.r=q.reduce,l=q.length,x=q.r(function(p, v){return p+v;},0),y=q.r(function(p,v){return p+v*v},0);return[l/q.r(function(p,v){return p+1/v},0),m.pow(q.r(function(p,v){return p*v},1),1/l),x/l,m.sqrt(y /l),y/x]}

PHP, 252

Stesso concetto:

<?function m($q){$r=array_reduce;$q=explode(',',$q);$l=count($q);$x=array_sum($q);$y=$r($q,function($p,$v){return $p+$v*$v;});return[$l/$r($q,function($p,$v){return $p+1/$v;}),pow($r($q,function($p,$v){return $p*$v;},1),1/$l),$x/$l,sqrt($y/$l),$y/$x];}

TypeScript, 393 *

Dato che TypeScript è un superset di JavaScript, avrei potuto inviare lo stesso codice, ma non sarebbe davvero giusto ora. Ecco un codice TypeScript minimizzato con tutte le funzioni, variabili e parametri completamente digitati:

function m(q:String):number[]{var a:number[]=q.split(',').map(Number),l:number=a.length,x:number=a.reduce(function(p:number,v:number):number{return p+v},0),y:number=a.reduce(function(p:number,v:number):number{return p+v*v},0);return[l/a.reduce(function(p:number,v:number):number{return p+1/v},0),Math.pow(a.reduce(function(p:number,v:number):number{return p*v},1),1/l),x/l,Math.sqrt(y/l),y/x]}

Avrebbe potuto imbrogliare e usare anche il tipo any... ma, lo sai.

Excel - 120

Non sono sicuro se questo conta come un linguaggio di "programmazione", ma ho pensato che le persone potessero effettivamente utilizzare un foglio di calcolo per questo tipo di cose

Con i numeri in A2: J2

L2 (harmonic) =HARMEAN(A2:J2)
M2 (geometric) =GEOMEAN(A2:J2)
N2 (arithmetic) =AVERAGE(A2:J2)
O2 (quadratic) =SQRT(SUMSQ(A2:J2)/COUNT(A2:J2))
P2 (contraharmonic) =(SUMSQ(A2:J2)/COUNT(A2:J2))/AVERAGE(A2:J2)

VBA (Excel) - 105

a=1:for each n in i:a=a*n:b=b+1/n:c=c+n:d=d+n*n:next:x=ubound(i)+1:?x/b","a^(1/x)","c/x","(d/x)^0.5","d/c

Ungolfed:

a=1:               set a variable to 1 (for the geometric mean)
for each n in i:   loop through the list
    a=a*n:            product of the list
    b=b+1/n:          sum of inverses of the list
    c=c+n:            sum of the list
    d=d+n*n:          sum of squares of the list
next:              end loop
x=ubound(i)+1:     get the number of elements in the list
?                  prepare to print
 x/b","               harmonic = count / sum(inverses)
 a^(1/x)","           geometric = product^(1/count)
 c/x","               arithmetic = sum / count
 (d/x)^0.5","         quadratic = square root of ( sum of squares / count )
 d/c                  contraharmonic = sum of squares / sum

Questo codice deve essere eseguito nella finestra immediata e l'array deve essere chiamato i . Poiché non vi è alcuna raccolta di errori, nessuna pulizia, nessuna caduta / rilascio variabile, se si desidera testare questo codice è possibile utilizzare il seguente pezzo di codice (basta incollare nella finestra immediata ed eseguire le righe in ordine):

b=0:c=0:d=0:set i = nothing:i= array(1,2,3,4,5)
a=1:for each n in i:a=a*n:b=b+1/n:c=c+n:d=d+n*n:next:x=ubound(i)+1:?x/b","a^(1/x)","c/x","(d/x)^0.5","d/c

Niente di speciale, solo la scelta di usare la finestra immediata : per sostituire le interruzioni di riga, che consente di risparmiare qualche byte rispetto all'impostazione di un sub o funzione e alla sua chiusura; usando? stampare anziché debug.print (solo nella finestra immediata); e basandosi su come vba determina i valori impliciti (l'aggiunta di un valore a una variabile non impostata restituisce il valore) e le operazioni implicite (tutto ciò che coinvolge una stringa è implicitamente concatenazione).