Rosetta Stone Challengeの目標は、可能な限り多くの言語でソリューションを作成することです。プログラミングの多言語性を自慢しましょう！

チャレンジ

「平均」という用語を使用する場合、一般的に算術平均を意味します。これは、数の合計を数で割ったものです。ただし、「平均」という言葉には、調和平均、幾何平均、算術平均、二次平均、および逆調和平均など、さらに多くの意味があります。

あなたの挑戦は、数字のリストを入力し、それらの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

出力

出力は、上記の順序の5つの平均（調和、幾何、算術、二次、逆調和）になります。便利なことに、これは昇順と同じです。

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形式にはある程度の妥当性がありますが、小数点以下の桁数の精度が必要です。浮動小数点出力が必要なので、浮動小数点入力を想定できます。

目標達成基準

客観的な勝利基準については、次のとおりです。各言語は、最短のエントリを書くことができる人に関する個別の競争ですが、全体的な勝者は、これらのサブ競争のほとんどに勝った人になります。これは、多くの一般的でない言語で答える人が有利になることを意味します。Code-golfは、言語に複数の解決策がある場合の大部分のタイブレーカーです。最短のプログラムを持っている人がその言語の功績を認められます。

同点の場合、勝者は最も多くの2位の応募者（など）になります。

ルール、制限、および注意

あなたのプログラムは、2014年9月2日より前に存在した任意の言語で作成できます。また、テストすることができないため、より一般的ではない/難解な言語で作成されたいくつかの応答を検証するために、コミュニティに頼る必要がありますそれら。

単一の回答に含まれるすべての異なる提出物を保管してください。

また、わずかに異なる言語の方言で基本的に同じ答えを持つシェナンガンはありません。私は、提出物が十分に異なっているかどうかの裁判官になります。

現在のリーダーボード

このセクションは定期的に更新され、言語の数と各言語のリーダーを示します。

• アルゴイド（337）-ベータ崩壊
• APL（42）-algorithmshark
• アウク（78）-デニス
• BBC BASIC（155）-ベータ崩壊
• C（136）-デニス
• C ++（195）-ゼータ
• C＃（197）-マーティン・ブットナー
• CJam（43）-デニス
• Clojure（324）-マイケル・イースター
• コブラ（132）-オウラス
• CoffeeScript（155）-マーティン・ブットナー
• コモドールベーシック（104）-マーク
• Common Lisp（183）-DLosc
• アーラン（401）-マーク
• Fortran（242）-カイルカノス
• Fortran 77（286）-ベータ崩壊
• GNU bc（78）-デニス
• GolfScript（83）-デニス
• グルーヴィー（157）-マイケル・イースター
• ハスケル（140）-ゼータ
• J（28）-algorithmshark
• Java（235）-マイケル・イースター
• JavaScript（ES6）（112）-デニス
• JRuby（538）-マイケル・イースター
• ジュリア（79）-マーティン・ブトナー
• ルア（113）-AndoDaan
• Mathematica（65）-マーティン・ブットナー
• Matlab（63）-マーティン・ブットナー
• オクターブ（68）-デニス
• Openscript（849？）-COTO
• パスカル（172）-マーク
• Perl（76）-グリミー
• PHP（135）-デニス
• POV-Ray 3.7（304）-マーク
• プロローグ（235）-DLosc
• ピス（52）-デニス
• Python 2（96）-デニス
• Python 3（103）-DLosc
• Q（53）-algorithmshark
• Q'Nial（68）-algorithmshark
• QBasic（96）-DLosc
• R（91）-プランナパス
• ルビー（118）-マーティン・ブットナー
• 錆（469）-Vi。
• Scala（230）-マイケル・イースター
• T-SQL（122）-MickyT
• TI-ベーシック（85）-Ypnypn
• TypeScript（393）-rink.attendant.6
• VBA（Excel）（387）-ストレッチマニアック
• wxMaxima（134）-カイルカノス

現在のユーザーランキング

1. デニス（10）
2. マーティン・ブットナー（6）
3. マイケル・イースター（5）
4. マーク、DLosc、algorithmshark（4）
5. ベータ崩壊（3）
6. ゼータ、カイルカノス（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コードと同じですが、2つのインクルードがあります。受賞した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};}}}

Listのdouble を取り、5つの手段でdoubleの配列を返すクラスの関数を定義します。

Visual MelonとBobにいくつかの改善をありがとう。

CJam、52バイト

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

入力をコマンドライン引数として受け取り、5つの値を含むリストをSTDOUTに出力します。

CoffeeScript、155バイト

これは、JavaScriptソリューションのさらに下位にあるものとほぼ同じですが（そのため、最初はカウントしませんでした）、とにかくスコアボードに含まれていたため、完全な提出に昇格しました。結局のところ、それらは技術的に異なる言語です。

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

数値の配列を取り、5つの手段で配列を返す関数を定義します。

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

数値のリストを取得し、5つの平均値を持つリストを返す関数を定義します。

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}

浮動小数点数のリストを取得し、5つの平均値を持つリストを返す関数を定義します。

おもしろい事実： Mathematicaには5つの手段がすべて組み込まれています（それが私の最初の提出でした）が、そのうち3つは関数名よりも少ない文字で実装できます。

Matlab、65 63バイト

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

入力をユーザーの数値の配列として要求し、5つの手段を個別に出力します。

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

以前のものと同じ機能実装。

イスマエル・ミゲルのいくつかの改善に感謝します。

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]

以前のものと同じ機能実装。

ルビー、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の2次関数です。

• +/ % # 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はもう1つの配列指向言語であり、Nialの実装です。これは、Haskellがカテゴリー理論に基づいているのと同じ方法で、あいまいな配列理論に基づいています。（ここで入手してください。）他の3つの言語とはまったく異なります-まず左から右に解析します！-しかし、他の言語よりもさらに関連しています。

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からfloat（たとえば、）の配列を読み取ります。オンラインでお試しください。

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 5STDINからスペースで区切られた数値（例：）を読み取ります。

オクターブ、68バイト

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

シバンを数えません。[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

シバングを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}

シバンを数えません。STDINから行ごとに1つの数値を読み取ります。

GolfScript、86 83バイト

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

GolfScriptにはfloatのサポートが組み込まれていないため、コードはfloatを解析しています。したがって、入力形式にはかなり制限があります。、またはではなく1.0andを入力する必要があります。0.111..1

STDINから1行ずつ（上記で説明したように）フロートを読み取ります。オンラインでお試しください。

Perl、90 85バイト

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

シバングを1バイトとしてカウントします（-nスイッチ）。STDINから行ごとに1つの数値を読み取ります。

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

シバンを数えません。1.0,2.0,3.0,4.0,5.0STDINからフロートのリスト（例：）を読み取ります。

ECMAScript 6（JavaScript）、114 112バイト

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

シバンまたは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]);'

各コード文字列のバイト数をカウントし、とに2を追加する-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が得意とするものです。

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

いつものように：スマイリー工場の爆発。：しかし、スマイリーのいくつかは、この時期に無傷で残っていた:)し、:*:これを作成するために使用された私の対話セッション（4目で男と彼の顔に埋め込ま宝石だもの）：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つの関数がフォークとフックの列でリストにバンドルされています。（心配する必要はありません。複数の関数を1つのリストに出力する便利な方法です）。

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番目の4番目（またはtesseract）のルート」を意味します）
• */-製品（*/意味が似+/ています、これについては前の機能を参照してください）

算術

(+/ % #)

• +/ -合計、今おなじみのはず
• % - で割った
• # -長さ

二乗平均平方根

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

ええ、ええ...

• %: -のルート
  • %@# -長さの逆数
  • * -タイムズ
  • +/@:*:- *:二乗の合計（二乗されています*~が、二乗されています。）

コントラハーモニック

+/@:*: % +/

• +/@:*: -二乗の合計
• % - で割った
• +/ - 合計。

これを説明することで、関数が1バイト 2バイト長すぎることが実際にわかりました。

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：111 104バイト

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れます。CommodoreBasic I / Oの制限により、入力は一度に1つずつ入力されます。入力の終わりを示すための-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空の行が入力されたときに（少なくともMS-DOS QBasic 1.1で-QB64でも機能するかどうかはわかりません）0 を返す（falseと評価される）事実を使用して、15バイトをオフにしました。

パスカル（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.

入力はコンマではなくスペースで区切られ、改行で終了します。出力はスペースで区切られます。

アーラン：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での文字列の処理は王室の痛みです。その結果、すべての浮動小数点数は、小数点の後に少なくとも1桁で入力する必要があります- string:to_float/1変換しません1が、変換し1.0ます。

（特に、浮動小数点演算もI / OもないRoboTalkでこれを行う方法を見つけたら）

言語：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";}

ハスケル：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はすべてのパラメーターを1行で出力します）

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

言語-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は可変数の入力には適していません。そのため、プログラムは行ごとに1つの数値を必要とし、0または空の行で終了します。出力はスペースで区切られます。

（0は有効な数値ではなく、入力終了に使用できることに気づいたら短縮されました。）

QB64を使用してテスト済み：

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

おそらくテストするための最良の方法はclisp、次のようにREPLに関数を貼り付けることです。

$ 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は、2つの整数を除算するときに、浮動小数点数ではなく正確な分数を使用する方法が大好きです。

プロローグ、235バイト

Prologは数学が得意ではありませんが、とにかくそれを使用します。SWI-Prologでテスト済み。私が思うにsumlist、述語は、標準のプロローグではないかもしれないが、何でも、私はそれを使用しています。

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.

数字が1つしかない場合は、正しいがかなり面白い結果が得られます。

 ?- 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バージョンと同じ戦略。数字のコンマ区切りリストを受け取ります。intとfloatの両方を処理します。単一の数値の入力は、角括弧で囲む必要があります（数値のリストは常にそうである場合があります）。修正には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

BBCベーシック-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ストアやラズベリーパイストア

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

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

言語-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経由で呼び出して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

入力：1行に1つの数字。

編集：これは1文字長くなりますが、明らかにシバンの行は合計にカウントされないため、最終的にはより良くなります：

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

T-SQL、136 122

I（整数）がリストを識別し、V（浮動）が値を持つテーブルSに格納された番号リスト。

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

一部のエントリは、float / doubleの代わりにJavaのBigDecimalを使用して、丸めエラー（小数点以下4桁まで）を回避しようとし、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

Java- 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- 524 324文字

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

Scala- 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の構文です。いずれにせよ、私はロゼッタストーンの精神にそれを含めています。

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

ルア-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

グルーヴィー：

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バイト

最初の列に値を入力してから、このコードをトリガーするボタンを押すと、2番目の列に値が出力されます。

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

playrustでテストするためのループまたは入力のないコンパクトな 430バイトバージョン：

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をだまして使用することもできました...しかし、あなたは知っています。

エクセル-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が暗黙的な値を決定する方法（値を未設定変数に追加すると値が返されます）および暗黙的な操作（文字列を含むものはすべて暗黙的に連結されます）に依存します。