Rosetta Stone挑战赛的目标是用尽可能多的语言编写解决方案。炫耀您的编程多语言！

挑战

人们使用“平均”一词时，通常指的是算术平均值，即数字的总和除以数字的数量。但是，“均值”一词还有更多含义，包括谐波均值，几何均值，算术均值，二次均值和逆谐波均值。

您的挑战是编写一个程序，该程序输入数字列表并输出这5种不同的方式。此外，您正在尝试使用尽可能多的语言编写程序。您可以使用您的语言具有的任何标准库函数，因为这主要是语言展示。

输入值

输入将是一个正数列表。

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

输出量

输出将是上面列出的顺序中的五种均值（谐波，几何，算术，二次，逆谐波）。方便地，这与递增顺序相同。

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

I / O格式将有一定的宽大处理，但我确实希望精度达到几个小数位。由于我要浮点输出，因此可以假定为浮点输入。

客观获胜标准

关于客观的获胜标准，这是：关于谁可以写得最短的参赛作品，每种语言都是一场单独的比赛，但总的获胜者将是赢得这些子比赛中最多的人。这意味着以多种不同寻常的语言回答的人可以获得优势。当一种语言中有多个解决方案时，代码高尔夫球通常是决胜局：程序最短的人会为该语言赢得赞誉。

如果平局，那么获胜者将是排名第二的人（依此类推）。

规则，限制和注释

您的程序可以用2014年9月2日之前存在的任何语言编写。由于我不太可能测试，因此我还必须依靠社区来验证以某些较不常见/深奥的语言编写的答复。他们。

请把您所有的不同意见都包含在一个答案中。

同样，在语言方言中稍有不同的情况下，也没有答案基本相同的恶作剧。我将判断哪些提交内容足够不同。

现任排行榜

本部分将定期更新以显示语言的数量以及每种语言的领先者。

• Algoid（337）-Beta衰变
• APL（42）-算法
• Awk（78）-丹尼斯
• BBC BASIC（155）-Beta衰变
• C（136）-丹尼斯
• C ++（195）-Zeta
• C＃（197）-马丁·布特纳
• 果酱（43）-丹尼斯
• Clojure（324）-迈克尔·复活节
• 眼镜蛇（132）-乌鲁斯人
• CoffeeScript（155）-马丁·布特纳
• Commodore BASIC（104）-马克
• 普通Lisp（183）-DLosc
• Erlang（401）-马克
• Fortran（242）-凯尔·卡诺斯（Kyle Kanos）
• Fortran 77（286）-Beta衰减
• GNU BC（78）-丹尼斯
• GolfScript（83）-丹尼斯
• Groovy（157）-迈克尔·复活节
• Haskell（140）-泽塔
• J（28）-算法
• Java（235）-迈克尔·复活节
• JavaScript（ES6）（112）-丹尼斯
• JRuby（538）-迈克尔·复活节
• 朱莉娅（79）-马丁·布特纳
• Lua（113）-安多大安
• Mathematica（65）-马丁·布特纳
• Matlab（63）-马丁·布特纳
• 八度（68）-丹尼斯
• Openscript（849？）-COTO
• 帕斯卡（172）-马克
• Perl（76）-肮脏的
• PHP（135）-丹尼斯
• POV-Ray 3.7（304）-马克
• Prolog（235）-DLosc
• 珀斯（52）-丹尼斯
• Python 2（96）-丹尼斯
• Python 3（103）-DLosc
• Q（53）-算法
• Q'Nial（68）-算法
• QBasic（96）-DLosc
• R（91）-扁平虫
• 红宝石（118）-马丁·布特纳
• 锈（469）-Vi。
• 斯卡拉（230）-迈克尔·复活节
• T-SQL（122）-MickyT
• TI基础（85）-Ypnypn
• TypeScript（393）-rink.attendant.6
• VBA（Excel）（387）-弹力狂人
• wxMaxima（134）-凯尔·卡诺斯（Kyle Kanos）

当前用户排名

1. 丹尼斯（10）
2. 马丁·布特纳（6）
3. 迈克尔·复活节（5）
4. 标记，DLosc，算法哈希（4）
5. Beta衰变（3）
6. Zeta，Kyle Kanos（2）
7. Ourous，AndoDaan，COTO，Grimy，Plannapus，Vi。，MickyT，Ypnypn，rink.attendant.6，Stretch Maniac（1）

（如果我在上述排名中犯了一个错误，请告诉我，我将予以解决。此外，决胜局尚未应用。）

语言：1

Openscript（数百个）

（我最喜欢的晦涩难懂的编程语言是因为我很多年前就学会了用它编程。）

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

语言：13

我认为该列表现在应该包含我所熟知的每种编程语言，至少可以解决其中的一些简单问题。随着时间的推移，当我研究一些新语言时，我将尽量保持此列表的完整性。（我曾经认识过一些Smalltalk和Delphi，但是我不得不为增加它们的使用感而已。）

C，196个 190 171 165字节

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

将输入作为单独的命令行参数读取，并将以逗号分隔的方式列表写入STDOUT。

感谢您对昆汀的一些改进。

C ++，200字节

这与上面的C代码相同，外加两个include。我之所以加入其中，是因为它比获胜的C ++提交要长，因此我认为没有任何危害，我希望这篇文章实际包含我所知道的每种语言。:)

#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字节

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

在类中定义一个函数，该函数采用a List的double值并以5的平均值返回double数组。

感谢对Visual Melon和Bob的一些改进。

CJam，52个字节

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

将输入作为命令行参数，并将带有五个值的列表打印到STDOUT。

CoffeeScript，155个字节

这几乎与下层JavaScript解决方案相同（起初，我没有将其归类于此），但是OP仍然将其包含在记分板中，因此我将其提升为完整提交。毕竟，它们是技术上不同的语言。

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字节

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

定义一个函数，该函数接受一个数字数组，并用五个均值返回一个数组。

感谢William Barbosa的一些改进。

朱莉娅79字节

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

定义一个函数，该函数接受一个数字列表并使用五种方法返回一个列表。

Lua，120个字节

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

定义一个函数，该函数采用数字列表并为均值返回5个单独的值。

Mathematica，73 67 65字节

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

定义一个函数，该函数获取浮点数列表，并使用五种方法返回列表。

有趣的事实： Mathematica内置了全部5种方法（这是我最初提交的方法），但是其中3种可以用少于函数名称的字符来实现。

Matlab，65 63字节

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

向用户请求以数字数组形式输入，并分别输出五个平均值。

感谢Dennis Jaheruddin所做的一些改进。

PHP≥5.4，152个 149 143字节

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

与早期版本相同的功能实现。

感谢您对Ismael Miguel所做的一些改进。

Python 2，127字节

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]

与早期版本相同的功能实现。

Ruby，129 118字节

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

与早期版本相同的功能实现。

4种语言

J- 32 28个字符！

以数字列表为唯一参数的函数。

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

a 这是一个副词，它是J的二阶函数。

• +/ % # 是用J表示的火车，意思是总和除以算术平均值的定义。
• &.:是称为Under的连接，其中u&.:v(y)等于vi(u(v(y)))和vi是的函数逆v。是的，J可以取函数逆。
• 最后，J的一个有用功能是某些函数可以自动循环列表，因为J知道如果没有理由将它们应用于整个参数，则逐点应用它们。因此，列表的平方是例如平方的列表。

因此a，在左边取一个函数，并返回一个平均值，该平均值通过函数“调整”值，取算术平均值，然后将其反向。

• %a是调和平均数，因为%表示倒数，并且是它自己的逆数。
• ^.a是几何平均值，因为^.它是自然对数，而其倒数是指数。(Π x)^(1/n) = exp(Σ log(x)/n)
• [a是算术平均值，因为[是恒等函数。
• *:a是平方均值，因为*:是平方，并且其平方是平方根。
• 逆谐波给我们带来了很多麻烦-平方的均值除以均值-因此我们做了一点数学运算来得到它：（*:a除以（[a除以*:a））。看起来像[a(]%%)*:a。在执行此操作时，我们会先添加每种方法[a(,,]*%~)*:a。

最后，我们使用逗号将其余结果附加在一起。我们不需要进一步的括号，因为串联（至少在这种情况下）是关联的。

在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个字符

单参数函数。我们只是列出我们想要的所有手段。

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

下面是k的其他版本中的相同内容。

• k4，51个字符： {s:(a:avg)x*x;(%a@%x;exp a log x;a x;sqrt s;s%a x)}
• k2，54个字符： {s:(a:{(+/x)%#x})x*x;(%a@%x;(*/x)^%#x;a x;s^.5;s%a x)}

APL-42个字符

以列表为参数的函数。

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

爆炸解释：

{                                         } ⍝ 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个字符

您将爱上这个。

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

Q'Nial是另一种面向数组的语言，它是Nial的实现，它基于晦涩的数组理论，而Haskell是基于类别理论的。（在这里获取。）它与其他三个语言（从左到右，首先解析！）都非常不同。但是，与其他语言相比，它与它们的关联性仍然更高。

12种语言

CJam，45 44 43字节

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

[1.0 2.0 3.0 4.0 5.0]从STDIN 读取一个浮点数组（例如）。在线尝试。

APL，67 61 53 52 50字节

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

在线尝试。

Pyth，55 52字节

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

1 2 3 4 5从STDIN 读取以空格分隔的数字（例如）。

八度，68字节

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

不算shebang。[1 2 3 4 5]从STDIN 读取数组（例如）。

GNU bc，78个字节

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

将shebang计为1个字节（-l切换）。从STDIN读取空格分隔的浮点数，后跟零。

Awk，78个字节

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

不算shebang。每行从STDIN读取一个数字。

GolfScript，86 83字节

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

GolfScript没有对浮点数的内置支持，因此代码正在解析它们。因此，输入格式是相当严格的：你必须输入1.0和0.1，而不是1，1.或.1。

从STDIN逐行读取浮点数（如上所述）。在线尝试。

Perl，90 85字节

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

将shebang计为1个字节（-n切换）。每行从STDIN读取一个数字。

Python 2，102 96字节

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

不算shebang。1.0,2.0,3.0,4.0,5.0从STDIN 读取浮点列表（例如）。

ECMAScript 6（JavaScript），114112字节

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。需要一个数组（例如[1,2,3,4,5]）作为参数。

PHP，135（或108？）个字节

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

不算shebang或LF。读取浮点数作为命令行参数。

我有一个较短的解决方案，但是我不知道如何计算字节数：

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

计算每个代码字符串中的字节，并为-R和添加两个-E，这种方法的得分为108。

C，172个 140 139 137 136字节

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。用编译gcc -lm。从STDIN读取空格分隔的浮点数。

J（50）：

这是J擅长的事情：

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

一如既往：笑脸工厂里发生爆炸。但是，这次有些笑脸仍然完好无损：（:)而且:*:（这是一个有四只眼睛的家伙，他的脸上嵌入了一颗宝石））我用来创建它的交互式会话：http : //pastebin.com/gk0ksn2b

实际上：

   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

说明：

如您所料，实际上有5个函数捆绑在一起，并带有一系列的前叉和后叉。（不必担心，这只是将多个函数输出到单个列表的一种便捷方式）。

我用来让J生成此答案的行可能会更清晰一些：

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

让我们分别看看它们。

谐波

(# % +/@:%)

• # -（数组的）长度
• % - 除以
• +/@:%-总和（+/，或+数组中的倍数（+/1 2 3 4== 1+2+3+4））位于除法运算的最前面，但是这次是单子运算。这意味着J会自动“猜测” 1将是最有用的值。

几何

(# %: */)

• # -（数组的）长度
• %:-根（4 %: 7表示'7的第四个（或tesseract）根）
• */-产品（*/含义与相似+/，请参见以前的功能）

算术

(+/ % #)

• +/ -总和，现在应该熟悉
• % - 除以
• # -长度

均方根

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

嗯是的

• %: -的根源
  • %@# -长度的倒数
  • * -时代
  • +/@:*:-平方和（*:即使也平方*~）。

调和

+/@:*: % +/

• +/@:*: -平方和
• % - 除以
• +/ - 总和。

通过解释这一点，我实际上发现我的函数过长了一个字节两个字节，所以这很好！

如果J擅长处理弦乐，那么我们将赢得更多的高尔夫比赛……

语言：5

POV-Ray 3.7场景描述语言：304字节

#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没有控制台输入功能，因此我替换了文件输入。输出到控制台，但周围有很多程序状态输出。）

Commodore BASIC：111104字节

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

（并非该程序中的所有字符都可以用Unicode表示。 |用于表示SHIFT+H，┌表示SHIFT+O，┐表示SHIFT+P，/表示SHIFT+N。由于Commodore Basic I / O的限制，输入一次只能输入一个数字，并且输入-1表示输入的结尾。输出以制表符分隔。）

QBasic：96个字节

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

使用与DLosc条目相同的I / O方案；我通过使用INPUT V输入空行时返回0（其结果为false）（至少在MS-DOS QBasic 1.1中不知道-我不知道它是否也可以在QB64中使用）的事实打高尔夫球15个字节。

Pascal（FPC编译器）：172字节

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.

输入以空格分隔，而不是逗号，并且以换行符终止。输出以空格分隔。

Erlang：401个字节

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

Erlang中的字符串处理是一种皇家痛苦。因此，所有浮点数必须在小数点后至少输入一位数字- string:to_float/1不会转换1，但会转换1.0。

（更多内容，特别是如果我弄清楚如何在RoboTalk中做到这一点，RoboTalk是既没有浮点运算也没有I / O的语言）

语言：3

除非另有说明，否则数字需要用空格分隔。

C：181 163

取数字直到输入结束。

#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

取数字直到输入结束。

#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

任意取许多由换行符分隔的数字列表。

实作

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（感谢shiona）字节仅用于IO：/。

例

（Powershell的echo又称将Write-Output每个参数打印在一行上）

PS> echo“ 1 2 3 4 5”“ 1.7 17.3 3.14 24 2.718 1.618” | 朗哈斯科尔公司
[2.18978102189781,2.605171084697352,3.0,3.3166247903554,3.6666666666666665]
[3.011834514901806,4.621794669196026,8.412666666666668,12.234139719108438,17.791525635945792]

语言-4

我总是喜欢借口拉出好老头

QBasic，112 96字节

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不能很好地使用可变数量的输入，因此该程序需要每行一个数字，以0或空行结尾。输出用空格分隔。

（一旦我意识到0不是有效数字并且可用于输入终止，则将其缩短。）

使用QB64测试：

普通Lisp，183个字节

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

由于某种原因，我希望它会更短一些。我不是Lisp的专家，因此建议您多加注意。非高尔夫版本：

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

最好的测试方法是将功能粘贴到clispREPL中，如下所示：

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

我喜欢Lisp在将两个整数相除时如何使用精确分数而不是浮点数。

Prolog，235字节

Prolog在数学方面并不擅长，但我们还是要使用它。经过SWI-Prolog测试。我认为该sumlist谓词可能不是标准的Prolog，但是无论如何，我正在使用它。

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

取消高尔夫：

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

在Linux上，将代码包含在名为的文件中means.pro，进行如下测试：

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

只有一个数字时，给出正确但相当有趣的结果：

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

Python 3，103个字节

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)

与Dennis的 Python 2版本相同的策略。以逗号分隔的数字列表；处理整数和浮点数。单数输入必须用方括号括起来（并且可能总是有数字列表）；修复将花费4个字节。

8种语言

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

英国广播公司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

输出：

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)

输出：

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

我不是Javascripter，所以任何提示将不胜感激

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

藻类-337

在Google Play商店或Raspberry Pi商店中查找

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

从语法上讲这是正确的，但是所有当前的口译员都不起作用 ...

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'

语言：3

果酱（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

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

语言-2

眼镜蛇-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

蟒蛇-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种语言

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

取值向量并输出均值向量。

1种语言

Golfscript，162

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

是的，它很大。而且绝对可以做得更小。我稍后会做。在这里尝试。

它期望输入以换行符分隔。如果不允许这样做，我将修复它（+2个字符）。它输出列表换行符分隔。

这是一个更具可读性的版本：

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

语言2

Fortran：242

为了清楚起见，我将其取消高尔夫运动，但高尔夫版本才是最重要的。您首先需要输入要添加的值的数量，然后输入值。

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

将其复制到编辑器中，ctrl+enter然后调用via m([1,2,3,4,5]),numer获得浮点输出（否则将获得符号输出）。

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

输入：每行一个数字。

编辑：这更长了一个字符，但是由于显然shebang行不计入总数，因此最终会更好：

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

T-SQL，136 122

使用存储在表S中的数字列表，其中I（整数）标识列表，而V（浮点数）标识值。

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

由于Alchymist节省了14

语言：5

一些条目使用Java的BigDecimal而不是float / double来努力避免舍入错误（四舍五入到小数点后四位），并接受每个OP的IO规则。

较新的条目放宽了IO规则和BigDecimal。

常规- 409 400 164 157个字符

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

样品运行：

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

爪哇- 900 235个字符

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

样品运行：

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- 524324个字符

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

样本运行（末尾确实有逗号结尾）：

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,

斯卡拉- 841 663 230个字符

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

样品运行：

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个字符

目前尚不清楚JRuby是否与Ruby不同：它必须在JVM上运行。但这是Ruby语法。无论哪种方式，我都将本着Rosetta Stone的精神包含在内。

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

样品运行（确实向stderr打印警告）：

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

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

语言-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种语言

Java-243个字节

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

扩展：

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个字节

在第一列中填写值，然后按下按钮（触发此代码），然后在第二列中输出值。

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种语言

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

非高尔夫版本：

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

压缩的430字节版本，无循环或输入，可在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);}

为更新的Rust进行了更新：

取消高尔夫：

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

打高尔夫球（402位元组）：

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

语言：4

《 CoffeeScript》，193年

接受以逗号分隔的输入字符串：

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

同样，采用逗号分隔的输入字符串：

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

相同的概念：

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

由于TypeScript是JavaScript的超集，所以我本可以提交相同的代码，但是现在还不公平。这是最小化的TypeScript代码，其中所有函数，变量和参数均已完全键入：

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

可能会欺骗并使用该类型any...但是，您知道。

Excel-120

不确定这是否算作“编程”语言，但认为人们可能实际上将电子表格用于此类事情

用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

松散

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

该代码必须在立即窗口中运行，并且该数组必须称为i。由于没有错误收集，没有清理，没有变量删除/释放，因此，如果要测试此代码，可以使用以下代码（只需粘贴在立即窗口中并按顺序运行这些行）：

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

没什么特别的，只是选择使用带有以下内容的立即窗口：替换换行符，这比设置子或函数并关闭它节省了一些字节；使用？打印而不是debug.print（仅在立即窗口中）；并取决于vba如何确定隐式值（将值添加到未设置的变量会返回该值）和隐式操作（任何涉及字符串的操作都是隐式串联）。