Rosetta Stone Challenge: Was ist sowieso Durchschnitt?

38

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

PhiNotPi
quelle
Wenn Sie sagen, dass Sie in Bezug auf E / A nachsichtig sind, sind dann auch Funktionen zulässig, oder muss alles ein Programm sein (soweit dies in einigen Sprachen sinnvoll ist)?
Martin Ender
Sie haben meinen Lieblingsmittelwert verpasst: den logarithmischen Mittelwert (a-b)/ln(a/b). Ich gebe zu, dass ich erst heute herausgefunden habe, wie es sich auf einen Beispielsatz von mehr als zwei verallgemeinert :-) de.wikipedia.org/wiki/Logarithmic_mean
Level River St
1
2. September, wie?
Amalloy
1
Auch - wenn sie in Befehle in Linux zu bauen kommt, tun Sie betrachten bc, awketc „Sprachen“ oder „Befehle“ zu sein - so würden die verschiedenen Möglichkeiten zur Umsetzung dieser von einem Shell in verschiedenen Sprachen gezählt werden?
Floris
2
@ Floris Im Zweifelsfall: meta.codegolf.stackexchange.com/a/2073/8478
Martin Ender

Antworten:

22

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
COTO
quelle
21
put the length of the inputs into n? O_O Ich liebe diese Sprache schon.
DLosc
2
Die Syntax erinnert mich an Chef .
Comintern
2
Die Syntax erinnert mich an COBOL.
Amadan
3
Für eine noch extremere (und
benutzerspezifischere
3
inform 7 ist eine echte Sprache - es ist nur so, dass das I / O ein Textabenteuer ist. Die Leute haben Schach-Engines geschrieben und Dijkstra's kürzester Weg ist bei: de.literateprograms.org/Dijkstra's_algorithm_(Inform_7)
Jerry Jeremiah
18

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.

Martin Ender
quelle
Mir ist klar, dass dies ziemlich spät ist, aber Sie können 3 Julia-Bytes verlieren, indem Sie norm(l)/n^.5anstelle von verwenden norm(l)/sqrt(n).
Alex A.
13

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!

algorithmshark
quelle
Ich wusste, dass es einen besseren Weg gibt, dies in APL zu tun. So kann ich eine Variable, die ich rechts definiert habe , verschieben. Daran hätte ich selbst nicht gedacht ... - Dieser J-Code ist beeindruckend! Jedes Mal, wenn ich eine Ihrer Antworten sehe, sage ich mir, dass Sie diese Sprache lernen müssen. , aber dann lese ich ein paar Dokumentationen / Tutorials und weiß plötzlich nicht mehr, ob ich im Englischunterricht oder an einem Bahnhof bin ...: P
Dennis
@Dennis Ja, APL / J / K-Zuweisungen geben Werte zurück (die meiste Zeit!). Und danke. :) Wenn Sie J lernen, kann es verwirrend werden, was welchen Teilen Ihrer Muttersprache entspricht. Iverson hat das F-Wort (die Funktion) beim Schreiben der Dokumente im Wesentlichen verboten, um Sie zum Neustart zu zwingen. Am einfachsten ist es, wenn Sie sich damit beschäftigen und später Ihre eigene Analogie finden.
Algorithmushai
Ich behaupte immer noch, APL ist bei weitem die am besten lesbare Array-Sprache. Soviel zu "Nur-Schreiben" -Snarks! Schade, dass GNU APL keine der modernen Syntaxen unterstützt (verschachtelte D-funs, lexikalisches Scoping, bedingte Rückkehr, Hooks und Züge… verdammt noch /⍨mal , es drosselt ). Es war wahrscheinlich dafür gedacht, wirklich alten Code zu portieren. Was benutzt du? Dyalog? NARS2000? Ich finde es wirklich bedauerlich, dass J den ASCII-Rauschansatz gewählt hat. Die Implementierung dieser Sprache ist ansonsten ein geniales Werk. Aber ich kann mich nicht darum kümmern, mich mental zu analysieren]a(,,]*%~)*:a
Tobia
@Tobia Ich habe Dyalog kurz benutzt, aber ich kenne eigentlich kaum genug APL, um damit auszukommen. Ich bin ein J / K-Fan, vor allem, weil ASCII portabel ist und die Rangmodelle sinnvoller sind als APLs. ( [0.5]? Ew.) Mit der Zeit gewöhnt man sich jedoch daran, J still zu halten. Es wird noch schlimmer.
Algorithmushai
12

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.

Dennis
quelle
Sie können ein Byte in C: while(cond)...,n++;vsfor(;cond;n++)...;
Zeta
Müssen wir wirklich Shebang-Linien in unsere Zählung einbeziehen?
OregonTrail
@ OregonTrail: Ich habe die Shebangs in den Code aufgenommen, da es einfacher ist, dies wieinterpreter switches script bei jeder Einreichung zu erklären . Konvention ist, dass Shebang-Linien nicht gezählt werden, es sei denn, sie enthalten nicht standardmäßige Schalter. Wie in meiner Antwort angegeben, habe ich #!/usr/bin/awk -fals null Byte gezählt ( -fbedeutet, dass das Programm aus der Datei gelesen wird), aber #!/usr/bin/perl -nals ein Byte ( -nbedeutet, dass ich über die Eingabezeilen iteriere).
Dennis
Sollten Sie nicht -qfür Oktave und -lmfür C zählen?
Nyuszika7h
-qist nur zu leise Ausgabe. -lmwird von GCC benötigt. Andere Compiler benötigen es möglicherweise nicht.
Dennis
6

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

ɐɔıɐɔuʇǝɥʇs
quelle
Ist das RegEx? : P
Little Child
@ LittleChild Nope. Es ist J. ( jsoftware.com )
ɐɔıɐɔuʇǝɥʇs
5
@ LittleChild: Seien Sie froh, dass es nicht APL ist
Slebetman
J macht sicherlich einen tollen Job sowohl in der Knappheit als auch in der Smiley-Abteilung - ich fand auch%) und: @ (...
Desty
5

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

Kennzeichen
quelle
Ich liebte meinen Commodore 64
AquaAlex
Ditto ... und der Amiga
MickyT
Ein anderer QBasic-Fan! Nachdem ich festgestellt hatte, dass wir 0 nicht als gültige Eingabe behandeln mussten, kam ich unabhängig auf dasselbe. ;) Ich sehe, dass du (Q/N)^.5an meine gewöhnt bist SQR(q/n), aber das hat keinen Einfluss auf die Länge. Vielleicht könnten wir die Führung teilen? (Ich mache die Byteanzahl 96, ohne die abschließende Newline.)
DLosc
@ DLosc, Mein Bytezähler ( wc) enthält die nachgestellte Zeile, die uns vermutlich beide den Vorsprung verschafft - zumindest bis ich herausgefunden habe, wie ich dieses Duplikat beseitigen kann INPUT V.
Mark
Viel Glück. : ^) Ich habe ein paar ausgefallene Sachen mit GOTOs anstelle der Schleife ausprobiert , konnte aber keine weitere Reduzierung erzielen.
DLosc
5

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]
Zeta
quelle
Sie sollten in der Lage sein, einige der Definitionen in die Antwort von haskell einzufügen. Anstatt beispielsweise ;c=t/ain die let-Klausel zu schreiben, schreiben Sie [h,g,a/z,r,t/a]nach dem in.
stolzer Haskeller
@ proudhaskeller: Guter Punkt, danke!
Zeta
Außerdem ist das Schreiben s$m(1/)xkürzer als s.m(1/)$xwie es ist s$m(^2)x.
stolzer Haskeller
@ proudhaskeller: Nochmals vielen Dank. Man kann wahrscheinlich feststellen, dass sich der Code allmählich von einer nicht golfenen Version entwickelt hat. Auch ersetzt fromIntegral.length$xdurch foldr(\_ x->x+1)0x.
Zeta
Guter Trick! aber jetzt , dass Sie mich auf sie aussehen, fand ich diese: s$m(const 1)x.
stolzer Haskeller
4

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 :

Testen der QBasic bedeutet Programm

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.

DLosc
quelle
4

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'
Beta-Zerfall
quelle
1
Sie können 1 Zeichen speichern verwenden sqrt(b4/l)statt (b4/l)**0.5und viele mehr durch den Einsatz a, b, c, dstatt b1-4. Du bringst mich auch zum Weinen, indem du 77 anstelle des moderneren F90 + verwendest.
Kyle Kanos
@ Kyle Haha, ich werde dann anfangen F99 zu lernen
Beta Decay
Ich bin mehr beeindruckt von der Tatsache, dass du dich auch nach dem Anblick des Programmierzuges von Martin für 6 (mehr?) Sprachen entscheidest ... Nein, nur ein Scherz. Ich bin am meisten beeindruckt von Leuten, die mehr als ein paar Sprachen sprechen.
AndoDaan
1
In JS, können Sie Komma - Operator zu wiederholen verwenden var: var l=readline(),b=0,d=1,e=0,f=0;. Nicht sicher, welche readlineFunktion ist.
Oriol
1
Sie sollten in der Lage sein, einige Bytes zu speichern, indem Sie sie weglassen Length of sequence?oder zumindest verkürzen.
Nyuszika7h
3

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);}}
Ypnypn
quelle
Können Sie die Beispielausgabe für Java hinzufügen? Wie viele Dezimalstellen Genauigkeit gibt es im Vergleich zur Ausgabe in OP?
Michael Ostern
Trivial kürzer für TI-BASIC ist{dim(Ans)/sum(Ansֿ¹),dim(Ans)√(prod(Ans)),mean(Ans),√(mean(Ans²)),mean(Ans²)/mean(Ans
Lirtosiast
3

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)
Οurous
quelle
Die Python-Version funktioniert sowohl in Python 2 als auch in Python 3, beachten Sie jedoch, dass das Ausgabeformat nicht genau dasselbe ist.
Nyuszika7h
3

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.

Plannapus
quelle
Sie können ein Zeichen speichern, wenn Sie d=s(x^2)die letzten beiden Verwendungen von s(x^2)durch ersetzen d.
Kyle Kanos
In der Tat, danke!
Plannapus
3

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*
Justin
quelle
Sieht aus wie mehr Ruby als GolfScript. : P
Dennis
@ Tennis Es ist. ;-)
Justin
Warum sortierst du die Mittel?
Dennis
@ Tennis brauche ich nicht? "Praktischerweise werden die Ergebnisse in aufsteigender Reihenfolge angezeigt."
Justin
4
Das ist ein Kommentar, keine Anforderung. Der harmonische Mittelwert ist kleiner oder gleich dem geometrischen Mittelwert, der kleiner oder gleich dem arithmetischen Mittelwert usw. ist. Übrigens, Sie haben einen Fehler in Ihrem kontraharmonischen Mittelwert. Das Ergebnis sollte l*lmal höher sein, wo list die Anzahl der Schwimmer.
Dennis
3

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]));
Kyle Kanos
quelle
1
Vielleicht könnten Sie zusätzlich die Golfversion einbinden, damit die Leute die Zählung überprüfen können?
Paŭlo Ebermann
3

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$;/$.,$;/$}){
Grimmig
quelle
Es ist üblich, einen Shebang, der zwei nicht standardmäßige Schalter enthält, als zwei Bytes zu zählen. Davon abgesehen, sehr beeindruckende Lösung!
Dennis
3

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

MickyT
quelle
1
Schlagen Sie mich auf die SQL-Lösung. Mit sqrt (summe (v v) / count ( )) und summe (v * v) / summe (v) können Sie in den letzten beiden Zeichen eine ganze Reihe von Zeichen speichern. In Oracle SQL können Sie auch ein anderes Zeichen als Funktion speichern ist ln eher als log.
Alchymist
@Alchymist Vielen Dank. Gesicht Palm :)
MickyT
3

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
Michael Easter
quelle
2

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)
AndoDaan
quelle
2

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"
Kleines Kind
quelle
5
Ziel ist es, den kürzestmöglichen Code für jede Sprache zu schreiben. Daher möchten Sie wahrscheinlich Kennungen mit nur einem Zeichen verwenden und Leerzeichen weglassen, wo dies möglich ist.
Peter Taylor
1
@ PeterTaylor Oh, okay! Wusste das nicht. Neu hier.
Kleines Kind
@LittleChild Fühlen Sie sich frei, Ihren Code so kurz wie möglich zu gestalten. Vergiss nicht, die Anzahl der Zeichen zu schreiben, die du oben in deinem Beitrag verwendet hast.
mbomb007
2

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
Stretch Maniac
quelle
2

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);}
Vi.
quelle
1

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.

rink.attendant.6
quelle
0

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)
Brian
quelle
2
Ich habe kein Excel, aber ich denke, Sie können den Bereich verwenden, A:Aum auf die gesamte Spalte abzuzielen A.
Dennis
0

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

Shazback
quelle