Rosetta Stone挑战:平均水平是多少?


38

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)

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


当您说您对I / O宽容时,这是否也意味着允许使用函数,还是所有内容都必须是一个程序(就某种意义而言,在某些语言中该概念才有意义)?
Martin Ender 2014年

您错过了我最喜欢的均值:对数均值(a-b)/ln(a/b)。我承认,直到今天我才发现它是如何概括为两个以上样本集的:-) en.wikipedia.org/wiki/Logarithmic_mean
Level River St St

1
9月2日,是吗?
amalloy 2014年

1
此外-当涉及到内置的命令在Linux中,你认为bcawk等是“语言”或“命令” -所以会不同的方式来实现这从一个shell在不同的语言来算的?
弗洛里斯2014年

Answers:


22

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

21
put the length of the inputs into n?O_O我已经喜欢这种语言了。
DLosc 2014年

2
语法使我想起了Chef
Comintern

2
语法使我想起了COBOL。
阿玛丹2014年

3
有关更极端(且特定于用法)的“自然”外观语言,请查看
Inform7。– Beska

3
通知7是一种真实的语言-仅仅是I / O是文本冒险。人们已经在其中编写了国际象棋引擎,Dijkstra的最短路径是:en.literateprograms.org/Dijkstra's_algorithm_(Inform_7)
Jerry Jeremiah

18

语言: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]}

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


我意识到这是事实,但是如果使用norm(l)/n^.5,您可能会丢失3个Julia字节norm(l)/sqrt(n)
Alex A.

13

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是基于类别理论的。(在这里获取。)它与其他三个语言(从左到右,首先解析!)都非常不同。但是,与其他语言相比,它与它们的关联性仍然更高。


知道在APL中有更好的方法可以做到这一点。所以我可以引用在右边定义的变量; 不会想到我自己-J代码令人印象深刻!每当我看到您的答案之一时,我都会对自己说:您必须学习该语言。,但是后来我开始阅读一些文档/教程,突然之间我不知道我是在上英语课还是在火车站...:P
Dennis

@Dennis是的,APL / J / K分配返回值(大多数时间!)。谢谢你 :)学习J时,它可能会变得与您的家庭语言的哪个部分相对应,令人困惑,因此Iverson在编写文档时试图禁止您重新尝试使用F字(函数)。滚动并稍后提出自己的类比是最简单的方法。
algorithmhark

我仍然认为APL是迄今为止最易读的数组语言。对于“仅写”而言,这真是太难了!太糟糕了,GNU APL不支持任何现代语法(嵌套的D-funs,词法作用域,条件返回,钩子和训练……地狱,它使它窒息/⍨),这可能是为了移植真正的旧代码。你用什么?Dyalog?NARS2000?我认为J采取ASCII噪声方法确实很不幸。该语言的实现是天才的工作。但是我不愿意在精神上进行解析]a(,,]*%~)*:a
Tobia

@Tobia我曾短暂使用过Dyalog,但实际上我几乎不了解足够的APL来应对。我是J / K迷,主要是因为ASCII具有可移植性,并且等级模型比APL更具意义。([0.5]?Ew。)通过练习,您习惯了默认J。比这差得多。
algorithmhark

12

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.00.1,而不是11..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读取空格分隔的浮点数。


您可以在C:while(cond)...,n++;vsfor(;cond;n++)...;
Zeta 2014年

我们真的需要在我们的计数中包括shebang行吗?
OregonTrail 2014年

@OregonTrail:我已经将shebangs包含在代码中,因为它比解释每个提交都运行interpreter switches script起来容易。习惯上,除非包含非默认开关,否则不计算shebang行。如我的回答所述,我算#!/usr/bin/awk -f为零字节(-f表示从文件中读取程序),但算作#!/usr/bin/perl -n一个字节(-n表示在输入行上进行迭代)。
丹尼斯

您不应该算-q八度和-lmC吗?
nyuszika7h 2014年

-q只是为了安静地输出。-lmGCC需要。其他编译器可能会讨厌它。
丹尼斯

6

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擅长处理弦乐,那么我们将赢得更多的高尔夫比赛……


那是RegEx吗?:P
小孩

@LittleChild不。是J.(jsoftware.com
2014年

5
@LittleChild:很高兴它不是APL
slebetman 2014年

J在简洁和笑脸方面当然做得很好-我也发现%)和:@(...
Desty

5

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


我爱我的准将64号
-AquaAlex

同上...和amiga
MickyT 2014年

QBasic的同伴!在意识到我们不必将0作为有效输入处理之后,我独立地提出了同样的想法。;)我看到您已经习惯(Q/N)^.5SQR(q/n),但这并不影响长度。也许我们可以分享线索?(我将字节数
设为

@DLosc,我的字节计数器(wc)包括结尾的换行符,我想这让我们俩都领先了-至少直到我弄清楚如何摆脱那个重复符为止INPUT V
标记

祝好运。:^)我用GOTOs而不是循环尝试了一些奇特的东西,但是无法得到进一步的减少。
DLosc 2014年

5

语言: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]

您应该能够内联haskell答案中的一些定义。例如,不要;c=t/a在let子句中编写[h,g,a/z,r,t/a],而在in。之后编写。
骄傲的haskeller 2014年

@proudhaskeller:好的,谢谢!
Zeta 2014年

同时,写作s$m(1/)x是比短s.m(1/)$x,因为是s$m(^2)x
骄傲的haskeller 2014年

@proudhaskeller:再次感谢。可能可以说出该代码是从非高尔夫版本逐渐演变而来的。也替换fromIntegral.length$xfoldr(\_ x->x+1)0x
Zeta 2014年

好招!但是现在您让我看看了,我发现了:s$m(const 1)x
自豪的haskeller 2014年

4

语言-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测试:

测试QBasic均值程序

普通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个字节。


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'

1
您可以使用保存1个字符sqrt(b4/l),而不是(b4/l)**0.5和多用abcd来代替b1-4。您还使用77而不是更现代的F90 +令我哭泣。
凯尔·坎诺斯

@Kyle Haha,然后我将开始学习F99
Beta Decay

即使看到了Martin的编程火车,您仍然决定选择6种(更多?)语言,这让我印象深刻。人们对多种语言的了解使我印象最深刻。
AndoDaan 2014年

1
在JS中,您可以使用逗号运算符来避免重复varvar l=readline(),b=0,d=1,e=0,f=0;readline但是,不确定什么功能。
Oriol 2014年

1
您应该能够通过省略Length of sequence?或至少使其更短来节省一些字节。
nyuszika7h 2014年

3

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

您可以添加Java的示例输出吗?与OP中的输出相比,它提供多少精度的小数位?
迈克尔·复活节

对于TI-BASIC来说,短得{dim(Ans)/sum(Ansֿ¹),dim(Ans)√(prod(Ans)),mean(Ans),√(mean(Ans²)),mean(Ans²)/mean(Ans
要紧的

3

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

Python版本适用于Python 2和3,但请注意输出格式并不完全相同。
nyuszika7h 2014年

3

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

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


如果您使用您可以保存一个字符d=s(x^2)和替换后两种用途s(x^2)使用d
Kyle Kanos 2014年

的确,谢谢!
plannapus 2014年

3

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*

看起来比Ruby更像Ruby。:P
丹尼斯

@丹尼斯 ;-)
贾斯汀

您为什么要对手段进行排序?
丹尼斯2014年

@丹尼斯我不需要吗?“方便地,结果将以递增的顺序进行。”
贾斯汀2014年

4
这只是评论,不是必要条件。调和平均值小于或等于几何平均值,小于或等于算术平均值,等等。顺便说一句,您在对谐平均值中有一个错误。结果应该l*l高出几倍,即l浮点数。
丹尼斯

3

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

1
也许您还可以包括高尔夫球版,这样人们就可以检查计数了吗?
圣保罗Ebermann

3

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$;/$.,$;/$}){

通常将包含两个非默认开关的shebang计为两个字节。话虽如此,非常令人印象深刻的解决方案!
丹尼斯2014年

3

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


1
在SQL解决方案上击败我。您可以使用sqrt(sum(v v)/ count())和sum(v * v)/ sum(v)在最后2个字符上保存很多字符。此外,在Oracle SQL中,您可以将另一个字符保存为函数是ln而不是log。
Alchymist 2014年

@Alchymist非常感谢。掌心:)
MickyT 2014年

3

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

2

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

2

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

5
目的是为每种语言编写最短的代码,因此您可能希望使用单字符标识符,并在可能的地方省略空格。
彼得·泰勒

1
@PeterTaylor哦,好吧!不知道 新来的。
小孩

@LittleChild随时编辑您的代码,使其尽可能短。不要忘了在帖子顶部写下您使用的字符数。
mbomb007

2

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

2

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

1

语言: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...但是,您知道。


0

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)

2
我没有Excel,但我认为您可以使用范围A:A来定位整个列A
丹尼斯2014年

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

松散

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如何确定隐式值(将值添加到未设置的变量会返回该值)和隐式操作(任何涉及字符串的操作都是隐式串联)。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.