Ziel einer Rosetta Stone Challenge ist es, Lösungen in möglichst vielen Sprachen zu schreiben. Zeigen Sie Ihre Programmiervielsprachigkeit!

Die Herausforderung

Wenn Menschen den Begriff "Durchschnitt" verwenden, meinen sie im Allgemeinen das arithmetische Mittel, dh die Summe der Zahlen geteilt durch die Anzahl der Zahlen. Es gibt jedoch viel mehr Bedeutungen für das Wort "Mittel", einschließlich des harmonischen Mittels , des geometrischen Mittels , des arithmetischen Mittels , des quadratischen Mittels und des kontraharmonischen Mittels .

Ihre Herausforderung besteht darin, ein Programm zu schreiben, das eine Liste von Zahlen eingibt und diese 5 verschiedenen Mittel ausgibt. Darüber hinaus versuchen Sie, Programme in möglichst vielen Sprachen zu schreiben . Sie dürfen jede Art von Standardbibliotheksfunktion verwenden, die Ihre Sprache hat, da dies meistens ein Sprachschaufenster ist.

Eingang

Die Eingabe erfolgt in Form einer Liste positiver Zahlen.

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

Ausgabe

Die Ausgabe erfolgt über die fünf Mittelwerte in der oben angegebenen Reihenfolge (harmonisch, geometrisch, arithmetisch, quadratisch, kontraharmonisch). Praktischerweise ist dies das Gleiche wie das Erhöhen der Reihenfolge.

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

Im E / A-Format wird es eine angemessene Nachgiebigkeit geben, aber ich möchte mehrere Dezimalstellen für die Genauigkeit. Da ich eine Gleitkommaausgabe möchte, können Sie eine Gleitkommaeingabe annehmen.

Das objektiv gewinnende Kriterium

Als objektives Gewinnkriterium gilt: Jede Sprache stellt einen eigenen Wettbewerb dar, wer den kürzesten Beitrag schreiben kann, aber der Gesamtsieger wäre die Person, die die meisten dieser Teilwettbewerbe gewinnt. Dies bedeutet, dass eine Person, die in vielen ungewöhnlichen Sprachen antwortet, einen Vorteil erzielen kann. Code-Golf ist vor allem dann ein Tiebreak, wenn es mehr als eine Lösung in einer Sprache gibt: Die Person mit dem kürzesten Programm bekommt für diese Sprache eine Anerkennung.

Bei einem Gleichstand gewinnt die Person mit den zweitplatziertesten Einsendungen (und so weiter).

Regeln, Einschränkungen und Hinweise

Ihr Programm kann in jeder Sprache geschrieben werden, die vor dem 2. September 2014 existierte. Ich muss mich auch auf die Community verlassen, um einige Antworten zu validieren, die in einer der ungewöhnlicheren / esoterischeren Sprachen geschrieben wurden, da es unwahrscheinlich ist, dass ich sie testen kann Sie.

Bitte bewahren Sie alle Ihre verschiedenen Beiträge in einer einzigen Antwort auf.

Auch keine Shenanigans mit im Grunde der gleichen Antwort in einer etwas anderen Dialektsprache. Ich werde beurteilen, welche Einsendungen unterschiedlich genug sind.

Aktuelle Rangliste

Dieser Abschnitt wird regelmäßig aktualisiert, um die Anzahl der Sprachen und die jeweils führenden Personen anzuzeigen.

• Algoid (337) - Beta-Zerfall
• APL (42) - Algorithmushai
• Awk (78) - Dennis
• BBC BASIC (155) - Beta-Zerfall
• C (136) - Dennis
• C ++ (195) - Zeta
• C # (197) - Martin Büttner
• CJam (43) - Dennis
• Clojure (324) - Michael Easter
• Kobra (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) - Beta-Zerfall
• GNU bc (78) - Dennis
• GolfScript (83) - Dennis
• Groovy (157) - Michael Easter
• Haskell (140) - Zeta
• J (28) - Algorithmushai
• 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
• Oktave (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) - Algorithmushai
• Q'Nial (68) - Algorithmushai
• QBasic (96) - DLosc
• R (91) - Plannapus
• Rubin (118) - Martin Büttner
• Rust (469) - Vi.
• Scala (230) - Michael Easter
• T-SQL (122) - MickyT
• TI-Basic (85) - Ypnypn
• TypeScript (393) - rink.attendant.6
• VBA (Excel) (387) - Stretch Maniac
• wxMaxima (134) - Kyle Kanos

Aktuelle Benutzerrankings

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

(Wenn ich in der obigen Rangliste einen Fehler gemacht habe, lass es mich wissen und ich werde ihn beheben. Außerdem wurde der Tiebreaker noch nicht angewendet.)

Sprachen: 1

Openscript (viele hundert)

(Meine obskure und leider nicht mehr verfügbare Lieblingsprogrammiersprache, weil ich vor vielen Jahren gelernt habe, darauf zu programmieren.;)

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

Sprachen: 13

Ich denke, diese Liste sollte jetzt alle Programmiersprachen enthalten, die ich gut genug kenne, um zumindest einfache Probleme zu lösen. Ich werde versuchen, diese Liste im Laufe der Zeit zu vervollständigen, wenn ich mir einige neue Sprachen anschaue. ( Früher kannte ich Smalltalk und Delphi, aber ich musste zu viel nachschlagen, um sie hinzuzufügen, damit ich mich richtig fühlte.)

C 196 190 171 165 Bytes

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

Liest die Eingabe als einzelne Befehlszeilenargumente und schreibt eine durch Kommas getrennte Liste der Mittelwerte nach STDOUT.

Vielen Dank für einige Verbesserungen an Quentin.

C ++, 200 Bytes

Dies ist derselbe wie der obige C-Code, plus zwei Includes. Ich beziehe dies mit ein, weil es länger ist als die gewinnende C ++ - Einreichung, also schade ich wohl nicht und ich möchte, dass dieser Beitrag tatsächlich jede Sprache enthält, die ich kenne. :)

#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 Bytes

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

Definiert eine Funktion in einer Klasse, die ein ListDouble nimmt und ein Array von Double mit den fünf Mitteln zurückgibt.

Vielen Dank für einige Verbesserungen an Visual Melon und Bob.

CJam, 52 Bytes

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

Nimmt die Eingabe als Befehlszeilenargumente und druckt eine Liste mit den fünf Werten nach STDOUT.

CoffeeScript, 155 Bytes

Dies ist fast das Gleiche wie die JavaScript-Lösung weiter unten (und ursprünglich habe ich sie aus diesem Grund nicht gezählt), aber das OP hat sie trotzdem in den Anzeiger aufgenommen, sodass ich sie zu einer vollständigen Einreichung befördert habe. Das sind doch technisch unterschiedliche Sprachen.

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

Definiert eine Funktion, die ein Array von Zahlen verwendet und mit den fünf Mitteln ein Array zurückgibt.

Vielen Dank für einige Verbesserungen an William Barbosa.

Julia, 79 Bytes

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

Definiert eine Funktion, die eine Liste von Zahlen aufnimmt und eine Liste mit den fünf Mitteln zurückgibt.

Lua, 120 Bytes

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

Definiert eine Funktion, die eine Liste von Zahlen verwendet und 5 separate Werte für die Mittelwerte zurückgibt.

Mathematica, 73 67 65 Bytes

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

Definiert eine Funktion, die eine Liste mit Gleitkommazahlen erstellt und eine Liste mit den fünf Mitteln zurückgibt.

Lustige Tatsache: Mathematica hat alle 5 Mittel eingebaut (und das war meine ursprüngliche Übermittlung), aber drei von ihnen können in weniger Zeichen als ihre Funktionsnamen implementiert werden.

Matlab, 65 63 Bytes

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

Fordert die Eingabe als Array von Zahlen vom Benutzer an und gibt die fünf Mittelwerte einzeln aus.

Vielen Dank für einige Verbesserungen an Dennis Jaheruddin.

PHP ≥ 5,4, 152 149 143 Bytes

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

Gleiche funktionale Implementierung wie die vorherigen.

Vielen Dank für einige Verbesserungen an Ismael Miguel.

Python 2, 127 Bytes

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]

Gleiche funktionale Implementierung wie die vorherigen.

Ruby, 129 118 Bytes

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

Gleiche funktionale Implementierung wie die vorherigen.

4 Sprachen

J - 32 28 char!

Eine Funktion, deren einziges Argument die Liste der Zahlen ist.

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

a Hier ist ein Adverb, bei dem es sich um die Übernahme von Funktionen zweiter Ordnung durch J handelt.

• +/ % # ist ein Zug in J und bedeutet Summe geteilt durch Anzahl, die Definition des arithmetischen Mittels.
• &.:ist eine Konjunktion mit dem Namen Under, wobei u&.:v(y)gleichbedeutend mit vi(u(v(y)))und vidie Funktionsumkehrung von ist v. Ja, J kann funktionelle Umkehrungen annehmen .
• Ein nützliches Merkmal von J ist schließlich, dass bestimmte Funktionen automatisch Listen durchlaufen können, da J weiß, dass sie punktweise angewendet werden, wenn es keinen Sinn macht, sie auf das gesamte Argument anzuwenden. So ist beispielsweise das Quadrat einer Liste eine Liste der Quadrate.

So animmt eine Funktion auf der linken Seite, und kehrt mit einem mittleren , dass „Regelt“ die Werte durch die Funktion, das arithmetische Mittel nimmt, und dann die Einstellung kehren danach.

• %aist das harmonische Mittel, weil es %wechselseitig bedeutet und seine eigene Umkehrung ist.
• ^.aist das geometrische Mittel, weil ^.es sich um den natürlichen Logarithmus handelt und dessen Umkehrung das Exponential ist.(Π x)^(1/n) = exp(Σ log(x)/n)
• [aist das arithmetische Mittel, weil [es die Identitätsfunktion ist.
• *:aist der quadratische Mittelwert, weil *:Quadrat ist, und seine Umkehrung ist die Quadratwurzel.
• Die Kontraharmonie gibt uns eine Menge Ärger - Mittelwert der Quadrate geteilt durch Mittelwert -, also rechnen wir ein wenig, um es zu bekommen: ( *:ageteilt durch ( [ageteilt durch *:a)). Das sieht so aus [a(]%%)*:a. Während wir gerade dabei sind, stellen wir jedes der Mittel voran [a(,,]*%~)*:a.

Schließlich setzen wir Kommas, um den Rest der Ergebnisse zusammenzufügen. Wir benötigen keine weiteren Parens, da die Verkettung (zumindest in diesem Fall) assoziativ ist.

Im Einsatz bei der 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 Zeichen

Einzelargumentfunktion. Wir machen nur eine Liste aller Mittel, die wir wollen.

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

Dasselbe gilt für andere Versionen von k.

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

APL - 42 Zeichen

Funktionsauflistung als Argument.

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

Erklärt durch Explosion:

{                                         } ⍝ 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 Zeichen

Du wirst diesen lieben.

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

Q'Nial ist eine weitere Array-orientierte Sprache, eine Implementierung von Nial , die auf einer obskuren Array-Theorie basiert, so wie Haskell auf Kategorietheorie basiert. (Holen Sie es sich hier .) Es unterscheidet sich sehr von den anderen drei - es analysiert vor allem von links nach rechts!

12 Sprachen

CJam, 45 44 43 Bytes

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

Liest ein Array von Floats (zB [1.0 2.0 3.0 4.0 5.0]) aus STDIN. Probieren Sie es online aus.

APL, 67 61 53 52 50 Bytes

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

Probieren Sie es online aus.

Pyth, 55 52 Bytes

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

Liest durch Leerzeichen getrennte Zahlen (zB 1 2 3 4 5) aus STDIN.

Oktave, 68 Bytes

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

Ohne den Schebang. Liest ein Array (zB [1 2 3 4 5]) aus STDIN.

GNU bc, 78 Bytes

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

Zählen Sie den Shebang als 1 Byte ( -lSchalter). Liest durch Leerzeichen getrennte Floats von STDIN, gefolgt von einer Null.

Awk, 78 Bytes

#!/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}

Ohne den Schebang. Liest eine Nummer pro Zeile aus STDIN.

GolfScript, 86 83 Bytes

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

GolfScript hat keine eingebaute Unterstützung für Floats, daher analysiert der Code diese. Daher ist das Eingabeformat eher restriktiv: Sie Eingabe muss 1.0und 0.1anstatt 1, 1.oder .1.

Liest Floats (wie oben erklärt) zeilenweise von STDIN. Probieren Sie es online aus.

Perl, 90 85 Bytes

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

Zählen Sie den Shebang als 1 Byte ( -nSchalter). Liest eine Nummer pro Zeile aus STDIN.

Python 2, 102 96 Bytes

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

Ohne den Schebang. Liest eine Liste von Floats (zB 1.0,2.0,3.0,4.0,5.0) aus STDIN.

ECMAScript 6 (JavaScript), 114 112 Bytes

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

LF nicht mitgerechnet. Erwartet ein Array (zB [1,2,3,4,5]) als Argument.

PHP, 135 (oder 108?) Bytes

#!/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]);

Ohne Shebang oder LF. Liest Gleitkommazahlen als Befehlszeilenargumente.

Ich habe eine kürzere Lösung, weiß aber nicht, wie ich die Bytes zählen soll:

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]);'

Wenn Sie die Bytes in jeder Codezeichenfolge zählen und zwei für -Rund hinzufügen -E, würde dieser Ansatz 108 Punkte erzielen.

C 172 140 139 137 136 Bytes

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

LF nicht mitgerechnet. Kompilieren mit gcc -lm. Liest durch Leerzeichen getrennte Floats von STDIN.

J (50):

Das ist die Art von Dingen, in denen J gut ist:

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

Wie immer: eine Explosion in der Smileyfabrik. Einige der Smileys blieben jedoch dieses Mal intakt: :)und :*:(das ist ein Typ mit vier Augen und einem Edelstein, der in sein Gesicht eingebettet ist) Meine interaktive Sitzung, die verwendet wurde, um dies zu erstellen: http://pastebin.com/gk0ksn2b

In Aktion:

   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

Erläuterung:

Wie zu erwarten, gibt es tatsächlich 5 Funktionen, die in einer Liste mit einer Reihe von Gabeln und Haken zusammengefasst sind. (Keine Sorge, es ist nur eine bequeme Möglichkeit, mehrere Funktionen in einer einzigen Liste auszugeben.)

Die Zeilen, die ich verwendet habe, um J zu veranlassen, diese Antwort zu generieren, könnten etwas klarer sein:

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

Schauen wir sie uns getrennt an.

Harmonisch

(# % +/@:%)

• # - Länge (des Arrays)
• % - Geteilt durch
• +/@:%- Die Summe ( +/oder Falte +im Array ( +/1 2 3 4== 1+2+3+4)), die oben geteilt wird, diesmal jedoch im monadischen Fall. Was dies hier bedeutet, ist, dass J automatisch "vermutet", dass 1 der nützlichste Wert wäre.

Geometrisch

(# %: */)

• # - Länge (des Arrays)
• %:- Wurzel ( 4 %: 7würde 'die vierte (oder tesseract) Wurzel von sieben bedeuten)
• */- Produkt (entspricht */in der Bedeutung +/der vorherigen Funktion)

Arithmetik

(+/ % #)

• +/ - Summe, sollte jetzt vertraut sein
• % - geteilt durch
• # - Länge

Quadratischer Mittelwert

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

Ähm, ja ...

• %: - Die Wurzel von
  • %@# - Die Umkehrung der Länge
  • * - Zeiten
  • +/@:*:- Die Summe der Quadrate ( *:wird quadriert, obwohl *~es auch so ist.)

Kontraharmonisch

+/@:*: % +/

• +/@:*: - Die Summe der Quadrate
• % - geteilt durch
• +/ - die Summe.

Ich fand heraus, dass meine Funktion ein Byte, zwei Bytes zu lang war, indem ich das erklärte, also ist das gut!

Wenn J Saiten so gut verarbeiten könnte, würden wir viel mehr Golfwettbewerbe gewinnen ...

Sprachen: 5

POV-Ray 3.7 Szenenbeschreibung Sprache: 304 Bytes

#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 verfügt nicht über Konsoleneingabefunktionen, daher habe ich die Dateieingabe ersetzt. Die Ausgabe erfolgt an die Konsole, ist jedoch von zahlreichen Programmstatusausgaben umgeben.)

Commodore BASIC: 111 104 Bytes

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

(Es können nicht alle Zeichen in diesem Programm in Unicode dargestellt werden. |Wird zum Darstellen SHIFT+H, ┌Darstellen SHIFT+O, ┐Darstellen SHIFT+P, /Darstellen verwendet SHIFT+N. Aufgrund der Einschränkungen in Commodore Basic I / O wird die Eingabe einzeln mit einer Eingabe eingegeben von -1, um das Ende der Eingabe anzuzeigen. Die Ausgabe ist durch Tabulatoren getrennt.)

QBasic: 96 Bytes

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

Verwendet dasselbe E / A-Schema wie der Eintrag von DLosc. Ich habe 15 Bytes weniger gespielt, indem ich die Tatsache verwendet habe, dass INPUT Vbei der Eingabe einer leeren Zeile 0 zurückgegeben wird (was als falsch ausgewertet wird) (zumindest in MS-DOS QBasic 1.1 - ich weiß nicht, ob es auch in QB64 funktioniert).

Pascal (FPC-Compiler): 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.

Die Eingabe wird durch Leerzeichen und nicht durch Kommas getrennt und mit einem Zeilenumbruch abgeschlossen. Die Ausgabe ist durch Leerzeichen getrennt.

Erlang: 401 Bytes

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

Das Saitenhandling in Erlang ist ein königlicher Schmerz. Folglich müssen alle Gleitkommazahlen mit mindestens einer Nachkommastelle eingegeben werden - string:to_float/1wird nicht konvertiert 1, sondern konvertiert 1.0.

(Weitere Informationen, insbesondere, wenn ich herausfinde, wie dies in RoboTalk, einer Sprache ohne Gleitkommaoperationen und ohne E / A-Vorgänge, geschehen soll.)

Sprachen: 3

Sofern nicht anders angegeben, müssen Zahlen durch Leerzeichen getrennt werden.

C: 181 163

Nimmt Zahlen bis zum Ende der Eingabe auf.

#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

Nimmt Zahlen bis zum Ende der Eingabe auf.

#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

Nimmt beliebig viele durch Zeilenvorschub getrennte Nummernlisten auf.

Implementierung

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 (danke shiona) Bytes sind nur für IO: /.

Beispiel

(Powershell's echoaka Write-Outputdruckt jeden Parameter in einer einzigen Zeile)

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.66666666666665]
[3.011834514901806,4.621794669196026,8.4126666666668,12.234139719108438,17.791525635945792]

Sprachen - 4

Ich liebe immer eine Ausrede, um gute alte herauszuholen

QBasic, 112 96 Bytes

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 eignet sich nicht für eine variable Anzahl von Eingaben, daher benötigt das Programm eine Nummer pro Zeile, die mit 0 oder einer leeren Zeile abgeschlossen wird. Die Ausgabe wird durch Leerzeichen getrennt.

(Wurde gekürzt, als mir klar wurde, dass 0 keine gültige Zahl ist und zur Beendigung der Eingabe verwendet werden kann.)

Getestet mit QB64 :

Common Lisp, 183 Bytes

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

Aus irgendeinem Grund erwartete ich, dass dies kürzer sein würde. Ich bin kein Lisp-Experte, daher sind Tipps willkommen. Ungolfed-Version:

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

Der wahrscheinlich beste Weg zum Testen besteht darin, die Funktion clispwie folgt in die REPL einzufügen:

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

Ich mag, wie Lisp beim Teilen von zwei ganzen Zahlen exakte Brüche anstelle von Floats verwendet.

Prolog, 235 Bytes

In Mathe ist Prolog nicht besonders gut, aber wir werden es trotzdem verwenden. Getestet mit SWI-Prolog. Ich denke, das sumlistPrädikat ist möglicherweise kein Standard-Prolog, aber was auch immer, ich verwende es.

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

means.proTesten Sie unter Linux mit dem Code in einer Datei mit dem Namen wie folgt:

$ 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.

Gibt ein korrektes, aber ziemlich amüsantes Ergebnis, wenn es nur eine Zahl gibt:

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

Python 3, 103 Bytes

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)

Gleiche Strategie wie Dennis ' Python 2-Version. Nimmt eine durch Kommas getrennte Liste von Zahlen; verarbeitet sowohl Ints als auch Floats. Eine Eingabe mit einer einzelnen Zahl muss in eckige Klammern gesetzt werden (und eine Liste von Zahlen kann es immer sein). Ein Fix würde 4 Bytes kosten.

8 Sprachen

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

Ausgabe:

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)

Ausgabe:

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

Ich bin kein Javascripter, daher wären alle Tipps sehr willkommen

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

Schlagen Sie im Google Play Store oder im Raspberry Pi Store nach

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

Das ist syntaktisch korrekt und alles, aber alle aktuellen Interpreter funktionieren einfach nicht ...

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'

Sprachen: 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);}}

Sprachen - 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 Sprache

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

Nimmt einen Wertevektor und gibt einen Mittelwertevektor aus.

1 Sprache

Golfscript, 162

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

Ja, es ist riesig. Und es kann definitiv kleiner gemacht werden. Was ich später machen werde. Probieren Sie es hier aus .

Es wird erwartet, dass die Eingabe durch Zeilenumbrüche getrennt ist. Wenn das nicht erlaubt ist, repariere ich es (+2 Zeichen). Es gibt die Liste Newline getrennt aus.

Hier ist eine etwas besser lesbare Version:

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

Sprachen 2

Fortran: 242

Ich habe es aus Gründen der Klarheit ungolfed, aber die Golfversion ist das, was gezählt wird. Sie müssen zuerst die Anzahl der hinzuzufügenden Werte und dann die Werte eingeben.

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

Kopieren Sie dies in den Editor ctrl+enterund rufen Sie dann via m([1,2,3,4,5]),numerauf, um eine Gleitkommaausgabe zu erhalten (andernfalls erhalten Sie eine symbolische Ausgabe).

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

Eingabe: eine Nummer pro Zeile.

BEARBEITEN: Dies ist ein Zeichen länger, aber da anscheinend Shebang-Linien nicht zur Gesamtsumme gezählt werden, ist es am Ende besser:

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

T-SQL, 136 122

Mit den in Tabelle S gespeicherten Nummernlisten, wobei I (Integer) die Liste kennzeichnet und V (Float) den Wert.

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

14 dank Alchymist gerettet

Sprachen: 5

Einige Einträge sind bestrebt, Rundungsfehler (auf 4 Dezimalstellen) zu vermeiden, indem sie Javas BigDecimal anstelle von float / double verwenden und E / A-Regeln pro OP akzeptieren.

Neuere Einträge lockern sowohl IO-Regeln als auch BigDecimal.

Groovy - 409 400 164 157 Zeichen

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

Probelauf:

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 Zeichen

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

Probelauf:

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 Zeichen

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

Probelauf (am Ende steht ein Komma):

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 Zeichen

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

Probelauf:

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 Zeichen

Es ist unklar, ob sich JRuby von Ruby unterscheidet: Dies muss auf der JVM ausgeführt werden. Es ist jedoch Ruby-Syntax. In jedem Fall beziehe ich es in den Geist eines Rosetta-Steins ein.

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

Probelauf (gibt eine Warnung an stderr aus):

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

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

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

Java - 243 Bytes

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

erweitert:

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 Bytes

Tragen Sie Werte in die erste Spalte ein, drücken Sie dann die Taste (die diesen Code auslöst) und sie gibt die Werte in der zweiten Spalte aus.

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 Sprache

Rust - 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,);}}

Ungolfed-Version:

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

Kompakte 430-Byte-Version ohne Schleife oder Eingabe zum Testen 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);}

Aktualisiert für neueren Rust:

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

Golf (402 Bytes):

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

Sprachen: 4

CoffeeScript, 193

Nimmt eine durch Kommas getrennte Zeichenfolge von Eingaben:

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

Auch hier wird eine durch Kommas getrennte Eingabezeichenfolge verwendet:

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

Gleiches Konzept:

<?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 *

Da TypeScript eine Obermenge von JavaScript ist, hätte ich einfach den gleichen Code einreichen können, aber das wäre jetzt nicht wirklich fair. Hier ist ein verkleinerter TypeScript-Code mit allen Funktionen, Variablen und Parametern, die vollständig eingegeben wurden:

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

Hätte auch schummeln und den Typ benutzen können any... aber du weißt schon.

Excel - 120

Ich bin mir nicht sicher, ob dies als "Programmiersprache" gilt, dachte aber, die Leute könnten tatsächlich eine Tabelle für diese Art von Dingen verwenden

Mit den Zahlen 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

Dieser Code muss im unmittelbaren Fenster ausgeführt werden und das Array muss i heißen . Da es keine Fehlererfassung, keine Bereinigung, kein Löschen / Freigeben von Variablen gibt, können Sie zum Testen dieses Codes den folgenden Code verwenden (einfach in das unmittelbare Fenster einfügen und die Zeilen der Reihe nach ausführen):

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

Nichts Besonderes, nur die Wahl mit den Direkt - Fenster zu verwenden : Zeilenumbrüche zu ersetzen, was ein paar Bytes speichert vs eine Sub oder Funktion Einrichten und Schließen; benutzen? anstatt debug.print zu drucken (nur im unmittelbaren Fenster); und sich darauf verlassen, wie vba implizite Werte bestimmt (das Hinzufügen eines Werts zu einer nicht gesetzten Variablen gibt den Wert zurück) und implizite Operationen (alles, was eine Zeichenfolge betrifft, ist implizite Verkettung).