Rosetta Stone Challenge oyununun amacı mümkün olduğu kadar çok dilde çözümler yazmaktır. Programlama çok dilliliğini gösterin!

Meydan okuma

İnsanlar "ortalama" terimini kullandıklarında, genellikle sayı sayısına bölünen sayıların toplamı olan aritmetik ortalama anlamına gelir. Bununla birlikte, harmonik ortalama , geometrik ortalama , aritmetik ortalama , kuadratik ortalama ve kontraharmonik ortalama da dahil olmak üzere "ortalama" kelimesinin daha fazla anlamı vardır .

Buradaki zorluk, bir sayı listesi ve bu 5 farklı yöntemi veren bir program yazmaktır. Ayrıca, programları olabildiğince çok dilde yazmaya çalışıyorsunuz . Dilinizin sahip olduğu herhangi bir standart kütüphane işlevini kullanmanıza izin verilir, çünkü bu çoğunlukla bir dil gösterimidir.

Giriş

Giriş, pozitif sayıların bir listesi olacaktır.

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

Çıktı

Çıktı yukarıda sıralanan sırayla beş araç olacaktır (harmonik, geometrik, aritmetik, ikinci dereceden, kontraharmonik). Uygun olarak, bu artan siparişle aynıdır.

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

G / Ç formatında makul bir esneklik olacaktır, ancak birkaç ondalık doğruluk yeri istiyorum. Kayan nokta çıkışını istediğimden, kayan nokta girişini varsayabilirsiniz.

Amaç Kazanan Kriter

Amaç kazanma kriterine gelince, işte burada: Her dil, en kısa girişi kimin yazabileceği konusunda ayrı bir yarışmadır, ancak genel kazanan, bu alt yarışmaların çoğunu kazanan kişi olacaktır. Bu, pek çok nadir dilde cevap veren bir kişinin bir avantaj sağlayabileceği anlamına gelir. Code-golf çoğunlukla, bir dilde birden fazla çözüm bulunması durumunda daha başarılıdır: en kısa programa sahip olan kişi bu dil için kredi alır.

Bir beraberlik varsa, kazanan ikinci sıradaki başvuruları (vb.) Alan kişi olacaktır.

Kurallar, Kısıtlamalar ve Notlar

Programınız 2 Eylül 2014'ten önce var olan herhangi bir dilde yazılabilir. Ayrıca, daha nadir / ezoterik dillerden bazılarında yazılı cevapları doğrulamak için topluluğa güvenmek zorunda kalacağım. onlar.

Lütfen tüm gönderilerinizi tek bir cevapta tutunuz.

Ayrıca, biraz farklı bir dil lehçesinde temelde aynı cevabı veren hiçbir şenangil yok. Hangi başvuruların yeterince farklı olduğuna karar vereceğim.

Güncel Lider Tablosu

Bu bölüm, dil sayısını ve her birinde lider olanları göstermek için periyodik olarak güncellenecektir.

• Algoid (337) - Beta Bozunması
• APL (42) - algorithmshark
• Awk (78) - Dennis
• BBC BASIC (155) - Beta Bozunması
• C (136) - Dennis
• C ++ (195) - Zeta
• C # (197) - Martin Büttner
• CJam (43) - Dennis
• Clojure (324) - Michael Paskalya
• Kobra (132) - Ourous
• CoffeeScript (155) - Martin Büttner
• Commodore BASIC (104) - İşaretle
• Ortak Lisp (183) - DLosc
• Erlang (401) - Mark
• Fortran (242) - Kyle Kanos
• Fortran 77 (286) - Beta Bozunması
• GNU bc (78) - Dennis
• GolfScript (83) - Dennis
• Groovy (157) - Michael Paskalya
• Haskell (140) - Zeta
• J (28) - algorithmshark
• Java (235) - Michael Paskalya
• JavaScript (ES6) (112) - Dennis
• JRuby (538) - Michael Paskalya
• Julia (79) - Martin Büttner
• Lua (113) - AndoDaan
• Mathematica (65) - Martin Büttner
• Matlab (63) - Martin Büttner
• Oktav (68) - Dennis
• Açılan metin (849?) - COTO
• Pascal (172) - İşaretle
• Perl (76) - Grimy
• PHP (135) - Dennis
• POV-Ray 3.7 (304) - İşaretle
• Prolog (235) - DLosc
• Pyth (52) - Dennis
• Python 2 (96) - Dennis
• Python 3 (103) - DLosc
• S (53) - algorithmshark
• Q'Nial (68) - algorithmshark
• QBasic (96) - DLosc
• R (91) - plannapus
• Yakut (118) - Martin Büttner
• Pas (469) - Vi.
• Scala (230) - Michael Paskalya
• T-SQL (122) - MickyT
• TI-Basic (85) - Ypnypn
• TypeScript (393) - rink.attendant.6
• VBA (Excel) (387) - Esnek Maniac
• wxMaxima (134) - Kyle Kanos

Mevcut Kullanıcı Sıralaması

1. Dennis (10)
2. Martin Büttner (6)
3. Michael Paskalya (5)
4. Mark, DLosc, algoritma paketi (4)
5. Beta Bozunması (3)
6. Zeta, Kyle Kanos (2)
7. Ourous, AndoDaan, COTO, Grimy, plannapus, Vi., MickyT, Ypnypn, rink.attendant.6, Streç Maniac (1)

(Yukarıdaki sıralamalarda bir hata yaptıysam, bana bildirin ve düzelteceğim. Ayrıca, tiebreaker henüz uygulanmadı.)

Diller: 1

Openscript (birçok yüzlerce)

(En sevdiğim gizemli ve ne yazık ki programlama dilini fena halde terk etti, çünkü onu yıllar önce programlamayı öğrendim.)

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

Diller: 13

Şimdi bu listenin, en azından basit sorunları çözmek için yeterince iyi bildiğim her programlama dilini içermesi gerektiğini düşünüyorum. Bu listeyi, bazı yeni dillere bakarken zaman içinde tam tutmaya çalışacağım. (Ben kullanılan bazı Smalltalk ve Delphi bilmek, ama doğru hissetmeye ekleyerek için çok kadar bakmak gerekir.)

C, 196 190 171 165 bayt

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

Girişi ayrı komut satırı argümanları olarak okur ve araçların virgülle ayrılmış bir listesini STDOUT'a yazar.

Quentin'deki bazı iyileştirmeler için teşekkürler.

C ++, 200 bayt

Bu yukarıdaki C koduyla aynıdır, artı iki içerir. Bunu ekliyorum çünkü kazanan C ++ gönderiminden daha uzun sürüyor, bu yüzden herhangi bir zarar gelmediğini tahmin ediyorum ve bu yazının aslında bildiğim her dili içermesini istiyorum. :)

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

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

Bir sınıftaki Listiki katından birini alan ve beş araçla iki katından oluşan bir dizi döndüren bir işlev tanımlar .

Görsel Kavun ve Bob'taki bazı iyileştirmeler için teşekkürler.

CJam, 52 bayt

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

Girdiyi komut satırı argümanları olarak alır ve STDOUT değerine beş değeri içeren bir liste yazdırır.

CoffeeScript, 155 bayt

Bu hemen hemen JavaScript çözümü ile aynıdır (ve başlangıçta bu sebeple saymadım), ancak OP yine de puan tablosuna dahil etti, ben de tam bir sunuma terfi ettim. Bunlar şunlardır sonuçta teknik olarak farklı diller.

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 bayt

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

Sayı dizisi alan ve beş yollu diziyi döndüren bir işlev tanımlar.

William Barbosa’daki bazı iyileştirmeler için teşekkürler.

Julia, 79 bayt

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

Sayı listesini alan ve listeyi beş yöntemle döndüren bir işlevi tanımlar.

Lua, 120 bayt

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

Sayıların listesini alan ve araçlar için 5 ayrı değer döndüren bir işlev tanımlar.

Mathematica, 73 67 65 bayt

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

Kayan nokta sayıları listesini alan ve beş yollu bir liste döndüren bir işlev tanımlar.

Eğlenceli gerçek: Mathematica, yerleşik 5 araca sahiptir (orijinal gönderimdi), ancak üçü, işlev adlarından daha az karakterle uygulanabilir.

Matlab, 65 63 bayt

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

Giriş, kullanıcıdan gelen bir sayı dizisi olarak talep edilir ve beş aracın ayrı ayrı çıktısını alır.

Dennis Jaheruddin’deki bazı iyileştirmeler için teşekkürler.

PHP 4 5.4, 152 149 143 bayt

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

Daha öncekilerle aynı işlevsel uygulama.

Ismael Miguel’deki bazı iyileştirmeler için teşekkürler.

Python 2, 127 bayt

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]

Daha öncekilerle aynı işlevsel uygulama.

Ruby, 129 118 bayt

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

Daha öncekilerle aynı işlevsel uygulama.

4 dil

J - 32 28 karakter!

Sayılar listesini tek argüman olarak alan bir işlev.

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

a işte J, ikinci dereceden fonksiyonları üstlenen bir zarf.

• +/ % # J'deki bir trendir, yani Toplam Bölme Sayımı, aritmetik ortalamanın tanımı.
• &.:Altında adında bir bağdaştırıcı u&.:v(y), eşdeğeri vi(u(v(y)))ve vibunun tersidir v. Evet, J işlevsel ters alabilir .
• Son olarak, J'nin kullanışlı bir özelliği, belirli işlevlerin listelerde otomatik olarak dolaşabilmesidir, çünkü J bunları tüm argümana uygulamak mantıklı olmazsa, onları noktaya doğru uygulamayı bilir. Yani bir listenin karesi, örneğin karelerin bir listesidir.

Böylece asoldan bir fonksiyon alır ve değerleri fonksiyona göre "ayarlayan" bir ortalama döndürür, aritmetik ortalamayı alır ve daha sonra ayarlamayı tersine çevirir.

• %aharmonik ortalama, çünkü %Karşılıklı anlamına gelir ve kendi tersidir.
• ^.ageometrik ortalama, çünkü ^.doğal logaritma ve tersi üsteldir.(Π x)^(1/n) = exp(Σ log(x)/n)
• [aaritmetik ortalama, çünkü [kimlik işlevi.
• *:akaresel ortalama, çünkü *:Kare, tersi de kareköktür.
• Kontraharmonik bize bir sürü sorun yaratır - ortalamalara bölünmüş karelerin ortalaması - bu yüzden bunu elde etmek için biraz matematik yaparız: ( *:abölü ( [abölü *:a)). Bu gibi görünüyor [a(]%%)*:a. Biz varken, araçların her birini hazırlıyoruz [a(,,]*%~)*:a.

Son olarak, sonuçların geri kalanını bir araya getirmek için virgül kullanıyoruz. Başka bir parene ihtiyacımız yok çünkü birleştirme (en azından bu durumda) birleştiricidir.

J REPL'de kullanımda:

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

S - 53 karakter

Tek argüman işlevi. Sadece istediğimiz tüm araçların bir listesini yaparız.

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

K'nın diğer sürümlerinde de aynı şey aşağıda.

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

APL - 42 karakter

Argüman olarak fonksiyon alma listesi.

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

Patlama ile açıklanacak:

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

Bunu seveceksin.

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

Q'Nial, Haskell'in kategori teorisine dayanan, karanlık bir dizi teorisine dayanan bir Nial uygulaması olan dizi odaklı bir dildir . ( Buradan alın .) Diğer üçünden herhangi birinden çok farklıdır - soldan sağa ayrıştırır, her şeyden önce!

12 dil

CJam, 45 44 43 bayt

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

STDIN'den bir dizi float (örn [1.0 2.0 3.0 4.0 5.0].) Okur . Çevrimiçi deneyin.

APL, 67 61 53 52 50 bayt

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

Çevrimiçi deneyin.

Pyth, 55 52 bayt

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

Boşluktan ayrılmış sayıları (örn 1 2 3 4 5.) STDIN'den okur .

Octave, 68 bayt

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

Shebang'ı saymamak. STDIN'den bir dizi okur (örn [1 2 3 4 5].).

GNU bc, 78 bayt

#!/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 bayt olarak sayma ( -lanahtar). Boşlukları STDIN'den ayıran ve ardından sıfır olan boşlukları okur.

Awk, 78 bayt

#!/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'ı saymamak. STDIN'den satır başına bir sayı okur.

GolfScript, 86 83 bayt

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

GolfScript, yüzer işlemler için yerleşik desteğe sahip olmadığı için, kod onları ayrıştırır. Bu nedenle, giriş biçimi oldukça kısıtlayıcı şudur: girişini gerekir 1.0ve 0.1yerine 1, 1.ya .1.

Yüzenleri (yukarıda açıklandığı gibi) STDIN'den satır satır okur. Çevrimiçi deneyin.

Perl, 90 85 bayt

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

Shebang'ı 1 bayt olarak sayma ( -nanahtar). STDIN'den satır başına bir sayı okur.

Python 2, 102 96 bayt

#!/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'ı saymamak. STDIN'den bir yüzdürme listesi (örn 1.0,2.0,3.0,4.0,5.0.) Okur .

ECMAScript 6 (JavaScript), 114 112 bayt

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'yi saymamak. Bir diziyi (örn [1,2,3,4,5].) Argüman olarak bekler .

PHP, 135 (veya 108?) Bayt

#!/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 veya LF'yi saymamak. Yüzenleri komut satırı argümanları olarak okur.

Daha kısa bir çözümüm var, ancak baytları nasıl hesaplayacağımı bilmiyorum:

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

Her kod dizesinde bayt Sayma ve için iki ekleyerek -Rve -Ebu yaklaşım 108 puanı.

C, 172 140 139 137 136 bayt

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'yi saymamak. İle derleyin gcc -lm. Beyaz boşluktan ayrılmış kayan noktaları STDIN'den okur.

J (50):

J'nin iyi olduğu bir şey bu:

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

Her zamanki gibi: gülen fabrikada bir patlama. Ancak, suratlardan bazıları bu sefer bozulmadan kaldı: :)ve :*:(bu dört gözü olan bir adam ve yüzüne gömülen bir mücevher) Bunu oluşturmak için kullanılan etkileşimli oturumum: http://pastebin.com/gk0ksn2b

Eylemde:

   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

Açıklama:

Tahmin edebileceğiniz gibi, bir çatal ve kanca treninin bir listeye dahil edilmiş 5 işlevi vardır. (Endişelenmeyin, tek bir listeye birden fazla fonksiyon çıktısı almanın uygun bir yoludur).

J'yi bu cevabı oluştururken kullandığım satırlar biraz daha net olabilir:

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

Onlara ayrı ayrı bakalım.

Harmonik

(# % +/@:%)

• # - Uzunluk (dizinin)
• % - Bölü
• +/@:%- Toplam ( +/veya +dizideki katlama ( +/1 2 3 4== 1+2+3+4)) bölmenin üstüne, ancak bu kez monadik durumda. Bunun anlamı, J'nin otomatik olarak 1'in en faydalı değer olacağını tahmin etmesidir.

Geometrik

(# %: */)

• # - Uzunluk (dizinin)
• %:- Kök ( 4 %: 7'dördüncü (veya tesseract) kökü anlamına gelir')
• */- Ürün ( */anlam bakımından benzer +/, bunun için önceki işleve bakın)

Aritmetik

(+/ % #)

• +/ - toplam, şimdi tanıdık olmalı
• % - bölü
• # - Uzunluk

Kök kare ortalama

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

Ehm, evet ...

• %: - Kökü
  • %@# - Uzunluğun tersi
  • * - Zamanlar
  • +/@:*:- Karelerin toplamı ( aynı şekilde de *:olsa karedir *~).

Contraharmonic

+/@:*: % +/

• +/@:*: - Karelerin toplamı
• % - bölü
• +/ - toplam.

Aslında benim işlevi olduğunu öğrendim bir byte , bu nedenle 's iyi olduğunu iki bayt çok uzun bu açıklayarak!

Eğer J, ipleri işlemede bu kadar iyi olsaydı, çok daha fazla golf müsabakası kazanırdık ...

Diller: 5

POV-Ray 3.7 Sahne Tanımı Dil: 304 bayt

#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 konsol giriş işlevlerine sahip değildir, bu yüzden dosya girişini değiştirdim. Çıkış konsola geliyor, ancak çok fazla program durumu çıkışıyla çevrili.)

Commodore BASIC: 111 104 bayt

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

(Tüm bu programa karakter Unicode temsil edilebilir. |Temsil etmek için kullanılır SHIFT+H, ┌temsil SHIFT+O, ┐temsil SHIFT+P, /temsil eder SHIFT+N. Çünkü Commodore Temel I / O sınırlamalardan dolayı, giriş bir giriş ile, her seferinde bir dizi girilir -1, girişin sonunu belirtmek için kullanılır.

QBasic: 96 bayt

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 girişi ile aynı G / Ç şemasını kullanır; INPUT VBoş bir satır girişi olduğunda 0 döndüren (yanlış olarak değerlendirilir) gerçeğini kullanarak 15 baytlık golf oynadım (en azından MS-DOS QBasic 1.1 - QB64'te de çalışıp çalışmadığını bilmiyorum).

Pascal (FPC derleyicisi): 172 bayt

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.

Girdi, virgüllerle değil boşluklarla ayrılır ve yeni satır sonlandırılır. Çıktı boşlukla ayrılmıştır.

Erlang: 401 bayt

-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'da sicim kullanımı kraliyet acısıdır. Sonuç olarak, tüm kayan noktalı sayılar, ondalık noktasından sonra en az bir rakam ile girilmelidir - string:to_float/1dönüştürülmez 1, dönüştürülür 1.0.

(Daha fazlası, özellikle RoboTalk'ta bunun nasıl yapılacağını çözersem, ne kayan nokta işlemlerine ne de G / Ç'ye sahip bir dil)

Diller: 3

Aksi belirtilmedikçe, sayıların boşlukla ayrılması gerekir.

C: 181 163

Girişin sonuna kadar sayıları alır.

#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

Girişin sonuna kadar sayıları alır.

#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

Keyfi olarak newline ile ayrılmış pek çok sayı listesi alır.

uygulama

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 (teşekkürler shiona) bayt sadece IO içindir: /.

Örnek

(Powershell'in echoaka Write-Outputher parametresini tek bir satırda yazdırır)

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]

Diller - 4

Eski güzelliği çıkarmak için her zaman bir bahaneyi severim

QBasic, 112 96 bayt

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 değişken sayıdaki girişlerle iyi değildir, bu nedenle programın satır başına bir sayı olması gerekir, 0 veya boş bir satırla sonlandırılır. Çıktı boşluklarla ayrılmıştır.

(0'ın geçerli bir sayı olmadığını ve giriş sonlandırma için kullanılabileceğini anladığımda kısaltıldı.)

QB64 kullanılarak test edildi :

Ortak Lisp, 183 bayt

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

Nedense bunun daha kısa olmasını bekliyordum. Herhangi bir Lisp uzmanı değilim, bu yüzden ipuçları için teşekkür ederiz. Ungolfed versiyonu:

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

Muhtemelen test etmenin en iyi yolu, işlevi clispREPL'e yapıştırmaktır.

$ 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'in iki tamsayıyı bölerken yüzmek yerine tam kesirleri kullanmasını seviyorum.

Prolog, 235 bayt

Prolog matematikte pek iyi değil ama yine de kullanacağız. SWI-Prolog ile test edilmiştir. Bence sumliststandart Prolog olmayabilir, ama her neyse onu kullanıyorum.

m(L,H,G,A,Q,C):-length(L,N),h(L,I),H is N/I,p(L,P),G is P^(1/N),sumlist(L,S),A is S/N,q(L,R),Q is sqrt(R/N),C is R/S.
p([H|T],R):-p(T,P),R is H*P.
p([],1).
q([H|T],R):-q(T,P),R is H*H+P.
q([],0).
h([H|T],R):-h(T,P),R is 1/H+P.
h([],0).

Ungolfed:

m(L, H, G, A, Q, C) :-
        length(L, N),   % stores the length into N
        h(L, I),        % stores the sum of inverses into I
        H is N/I,
        p(L, P),        % stores the product into P
        G is P^(1/N),
        sumlist(L, S),  % stores the sum into S
        A is S/N,
        q(L, R),        % stores the sum of squares into R
        Q is sqrt(R/N),
        C is R/S.

% Helper predicates:

% p calculates the product of a list
p([H|T], R) :-
        p(T, P),     % recursively get the product of the tail
        R is H*P.    % multiply that by the head
p([], 1).            % product of empty list is 1

% q calculates the sum of squares of a list
q([H|T], R) :-
        q(T, P),     % recursively get the sum of squares of the tail
        R is H*H+P.  % add that to the square of the head
q([], 0).            % sum of empty list is 0

% h calculates the sum of inverses of a list
h([H|T], R) :-
        h(T, P),     % recursively get the sum of inverses of the tail
        R is 1/H+P.  % add that to the inverse of the head
h([], 0).            % sum of empty list is 0

Linux'ta, bir dosyadaki kodla birlikte means.pro, şöyle test edin:

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

Yalnızca bir sayı olduğunda doğru ama eğlenceli bir sonuç verir:

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

Python 3, 103 bayt

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'in Python 2 versiyonu ile aynı strateji . Virgülle ayrılmış bir numara listesi alır; Hem giriş hem de yüzer. Tek sayı giriş, köşeli parantez içine alınmalıdır (ve her zaman bir sayı listesi olabilir ); bir düzeltme 4 bayta mal olacak.

8 dilde

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

Çıktı:

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)

Çıktı:

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

Ben bir Javascripter değilim, bu yüzden herhangi bir ipucu çok takdir edilecektir

console.log("Length of sequence?: ");
var l=readline(),b=0,d=1,e=0,f=0;
for(var i = 0;i<l;i++) {var j=readline();b+=1/j;d*=j;e+=j;f+=pow(j,2);}
h=l/b;g=pow(d,(1/l));a=e/l;q=sqrt(f/l);c=f/e;
console.log(h+' '+g+' '+a+' '+q+' '+c);

Algoid - 337

Google Play Store'da veya Ahududu Pi Mağazasında arayın

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

Bu, sözdizimsel olarak doğrudur ve hepsidir, fakat tüm güncel tercümanlar işe yaramadı ...

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'

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

Diller - 2

Kobra - 132

def f(l as number[])
    a,b,c,d=0d,1d,0d,0d
    for i in l,a,b,c,d=a+1/i,b*i,c+i,d+i**2
    print (e=l.length)/a,b**(1/e),c/e,(d/e)**0.5,d/c

Python - 129

def f(l):a,b,c=len(l),sum(i*i for i in l),sum(l);print(a/sum(1/i for i in l),eval('*'.join(map(str,l)))**(1/a),c/a,(b/a)**.5,b/c)

1 dil

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

Bir değer vektörünü alır ve bir araç vektörünü çıkarır.

1 dil

Golf Yazısı, 162

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

Evet, çok büyük. Ve kesinlikle daha küçük yapılabilir. Hangi zaman sonra yapacağım. Burada dene .

Girişin yeni satır ayrılmış olmasını bekler. Buna izin verilmezse, düzelteceğim (+2 karakter). Ayrılan listenin yeni satırını gösterir.

İşte biraz daha okunabilir bir sürüm:

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

Dil 2

Fortran: 242

Netlik için onu çözdüm, ama golf versiyonu sayılır. önce eklenecek değerlerin sayısını, ardından değerleri girmeniz gerekir.

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

Bunu editöre kopyalayın ctrl+enterve sonra m([1,2,3,4,5]),numerkayan nokta çıktısı almak için arayın (aksi takdirde sembolik çıktı alırsınız).

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

Giriş: satır başına bir sayı.

EDIT: Bu bir karakter daha uzun, ama görünüşe göre Shebang satırları toplam doğru sayılmadığından, daha iyi olur

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

T-SQL, 136 122

Tabloda depolanan sayı listelerinde I (tamsayı) ile listeyi tanımlar ve V (değişken) değerini gösterir.

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'e 14 teşekkürler

Diller: 5

Bazı girişler, float / double yerine Java'nın BigDecimal özelliğini kullanarak yuvarlama hatalarından (4 ondalık basamağa) kaçınmak ve OP başına IO kurallarını kabul etmek için çaba göstermektedir.

Yeni girişler hem IO kurallarını hem de BigDecimal'i rahatlatır.

Groovy - 409 400 164 157 karakter

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

örnek çalışma:

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 karakter

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

örnek çalışma:

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 karakter

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

örnek çalışma (sonunda sonunda virgül var):

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 karakter

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

örnek çalışma:

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 karakter

JRuby'nin Ruby'den farklı olup olmadığı belli değil: bu JVM'de çalışmalı. Yine de Ruby sözdizimidir. Her iki şekilde de, onu bir Rosetta Taşı ruhuna dahil ediyorum.

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

örnek çalışma (stderr için bir uyarı yazdırır):

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

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

Diller - 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 dil

Java - 243 bayt

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

genişletilmiş:

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 bayt

İlk sütundaki değerleri doldurun, ardından düğmesine basın (bu kodu tetikleyen) ve bu değerleri ikinci sütunda verir.

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 dil

Pas - 469

( rustc 0.11.0-pre (3851d68 2014-06-13 22:46:35 +0000))

use std::io;use std::from_str::from_str;use std::num;fn main(){loop{let a:Vec<f64>=io::stdin().read_line().ok().expect("").as_slice().split(',').map(|x|std::from_str::from_str(x.trim_chars('\n')).expect("")).collect();let n:f64=num::from_uint(a.len()).expect("");let s=a.iter().fold(0.0,|a,b|a+*b);let q=a.iter().fold(0.0,|a,b|a+*b* *b);println!("{},{},{},{},{}",n / a.iter().fold(0.0,|a,b|a+1.0/ *b),(a.iter().fold(1.0,|a,b|a**b)).powf(1.0/n),s/n,(q/n).sqrt(),q/s,);}}

Ungolfed versiyonu:

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

Oynatma süresinde test etmek için sıkıştırılmış 430 bayt sürümü, döngü veya giriş olmadan :

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

Yeni Pas için güncellendi:

Ungolfed:

use std::io;                 
fn main(){
    let mut s=String::new();
    io::stdin().read_line(&mut s);
    let a:Vec<f64>=s
        .split(',')
        .map(|x|x.trim().parse().expect(""))
        .collect();
    let n:f64=a.len() as f64;
    let s=a.iter().fold(0.0,|a,b|a+*b);
    let q=a.iter().fold(0.0,|a,b|a+*b**b);
    println!("{},{},{},{},{}",
        n / a.iter().fold(0.0, |a, b| a + 1.0 / *b),
        (a.iter().fold(1.0, |a, b| a * *b)).powf(1.0/n),s/n,
        (q/n).sqrt(),q/s);
}

Golf (402 bayt):

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

Diller: 4

CoffeeScript, 193

Virgülle ayrılmış bir girdi dizesini alır:

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

Yine, virgülle ayrılmış bir girdi dizesini alır:

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

Aynı kavram:

<?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'in bir üst kümesi olduğundan, aynı kodu daha yeni gönderebilirdim, ancak bu gerçekten adil olmazdı. İşte tüm fonksiyonları, değişkenleri ve tamamen yazılan parametreleri içeren küçültülmüş bir TypeScript kodu:

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

Türü de aldatmış ve kullanılmış olabilir any... ama, bilirsin.

Excel - 120

Bunun bir "programlama" dili olarak sayılıp sayılmadığından emin değiliz, ancak insanların bu tür bir şey için gerçekten bir elektronik tablo kullanabileceğini düşündü

A2'deki sayılarla: J2

L2 (harmonic) =HARMEAN(A2:J2)
M2 (geometric) =GEOMEAN(A2:J2)
N2 (arithmetic) =AVERAGE(A2:J2)
O2 (quadratic) =SQRT(SUMSQ(A2:J2)/COUNT(A2:J2))
P2 (contraharmonic) =(SUMSQ(A2:J2)/COUNT(A2:J2))/AVERAGE(A2:J2)

VBA (Excel) - 105

a=1:for each n in i:a=a*n:b=b+1/n:c=c+n:d=d+n*n:next:x=ubound(i)+1:?x/b","a^(1/x)","c/x","(d/x)^0.5","d/c

Ungolfed:

a=1:               set a variable to 1 (for the geometric mean)
for each n in i:   loop through the list
    a=a*n:            product of the list
    b=b+1/n:          sum of inverses of the list
    c=c+n:            sum of the list
    d=d+n*n:          sum of squares of the list
next:              end loop
x=ubound(i)+1:     get the number of elements in the list
?                  prepare to print
 x/b","               harmonic = count / sum(inverses)
 a^(1/x)","           geometric = product^(1/count)
 c/x","               arithmetic = sum / count
 (d/x)^0.5","         quadratic = square root of ( sum of squares / count )
 d/c                  contraharmonic = sum of squares / sum

Bu kod hemen pencerede çalıştırılmalı ve dizi i olarak adlandırılmalıdır . Hata toplama, temizleme, değişken bırakma / bırakma olmadığından, bu kodu test etmek istiyorsanız aşağıdaki kod parçasını kullanabilirsiniz (hemen pencereye yapıştırın ve satırları sırayla çalıştırın):

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

Çok özel bir şey yok, sadece şu anki pencereyi şu seçeneklerle kullanın : alt satırları değiştirmek, alt baytlar veya alt fonksiyonlar ayarlamak veya kapatmak; kullanarak? debug.print yerine yazdırmak için (sadece pencerede); ve vba'nın örtük değerleri nasıl belirlediğine (ayarlanmamış bir değişkene bir değer eklemek, değeri döndürür) ve örtük işlemlere (bir dizgeyi içeren herhangi bir şey örtülü birleştirmedir) dayanır.