Celem Stone Rosetta Challenge jest pisanie rozwiązań w jak największej liczbie języków. Pochwal się swoją wielojęzycznością programistyczną!

Wyzwanie

Kiedy ludzie używają terminu „średnia”, zwykle mają na myśli średnią arytmetyczną, która jest sumą liczb podzielonych przez liczbę liczb. Istnieje jednak o wiele więcej znaczeń w słowie „średnia”, w tym średnia harmoniczna , średnia geometryczna , średnia arytmetyczna , średnia kwadratowa i średnia kontrastowa .

Twoim wyzwaniem jest napisanie programu, który wprowadzi listę liczb i wyprowadzi te 5 różnych środków. Ponadto próbujesz pisać programy w jak największej liczbie języków . Możesz używać dowolnej standardowej funkcji bibliotecznej, którą posiada Twój język, ponieważ jest to głównie prezentacja języka.

Wkład

Dane wejściowe będą listą liczb dodatnich.

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

Wydajność

Wyjście będzie pięcioma średnimi w wyżej wymienionej kolejności (harmoniczna, geometryczna, arytmetyczna, kwadratowa, przeciwharmoniczna). Dogodnie jest to to samo, co zwiększenie porządku.

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

Będzie pewna rozsądna łagodność w formacie I / O, ale chcę kilku miejsc dziesiętnych dokładności. Ponieważ chcę danych wyjściowych zmiennoprzecinkowych, możesz założyć dane zmiennoprzecinkowe.

Kryterium zwycięskiego celu

Jeśli chodzi o obiektywne kryterium wygranej, oto on: Każdy język to osobny konkurs na to, kto może napisać najkrótszą pracę, ale ogólnym zwycięzcą byłaby osoba, która wygra najwięcej z tych pod-konkursów. Oznacza to, że osoba, która odpowiada w wielu nietypowych językach, może zyskać przewagę. Code-golf jest przeważnie rozstrzygający, gdy istnieje więcej niż jedno rozwiązanie w języku: osoba z najkrótszym programem otrzymuje kredyt za ten język.

W przypadku remisu zwycięzcą byłaby osoba, która zgłosi najwięcej miejsc na drugim miejscu (i tak dalej).

Reguły, ograniczenia i uwagi

Twój program może być napisany w dowolnym języku, który istniał przed 2 września 2014 r. Będę także musiał polegać na społeczności, aby zweryfikować niektóre odpowiedzi napisane w niektórych bardziej rzadkich / ezoterycznych językach, ponieważ jest mało prawdopodobne, że będę w stanie przetestować im.

Zachowaj wszystkie swoje różne zgłoszenia zawarte w jednej odpowiedzi.

Ponadto nie ma shenaniganów z zasadniczo taką samą odpowiedzią w nieco innych dialektach językowych. Będę sędzią, które wnioski są wystarczająco różne.

Aktualny ranking

Ta sekcja będzie okresowo aktualizowana, aby pokazać liczbę języków i kto prowadzi w każdym z nich.

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

Aktualne rankingi użytkowników

1. Dennis (10)
2. Martin Büttner (6)
3. Michael Easter (5)
4. Mark, DLosc, algorytmshark (4)
5. Rozpad beta (3)
6. Zeta, Kyle Kanos (2)
7. Ourous, AndoDaan, COTO, Grimy, plannapus, Vi., MickyT, Ypnypn, lodowisko.attendant.6, Stretch Maniac (1)

(Jeśli popełniłem błąd w powyższych rankingach, daj mi znać, a go naprawię. Ponadto remis nie został jeszcze zastosowany.)

Języki: 1

Openscript (wiele setek)

(Mój ulubiony niejasny i niestety nieczynny język programowania, ponieważ nauczyłem się go programować wiele lat temu;)

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

Języki: 13

Myślę, że ta lista powinna teraz zawierać każdy język programowania, który znam wystarczająco dobrze, aby rozwiązać co najmniej proste problemy. Postaram się z czasem uzupełniać tę listę, gdy zajrzę do kilku nowych języków. (I używane wiedzieć trochę Smalltalk i Delphi, ale będę musiał patrzeć na wiele dodawania ich do czuję się dobrze).

C 196 190 171 165 bajtów

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

Odczytuje dane wejściowe jako indywidualne argumenty wiersza poleceń i zapisuje rozdzielaną przecinkami listę środków do STDOUT.

Dzięki za ulepszenia Quentin.

C ++, 200 bajtów

Jest to to samo co powyższy kod C, plus dwa obejmują. Uwzględniam to, ponieważ jest dłuższe niż zwycięskie zgłoszenie w C ++, więc myślę, że nie wyrządzono żadnej szkody, i chciałbym, aby ten post zawierał właściwie każdy język, który znam. :)

#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 bajtów

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

Definiuje funkcję w klasie przyjmującą Listliczbę podwójną i zwracającą tablicę podwójnych za pomocą pięciu środków.

Dzięki za ulepszenia Visual Melona i Boba.

CJam, 52 bajty

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

Pobiera dane wejściowe jako argumenty wiersza poleceń i wypisuje listę z pięcioma wartościami do STDOUT.

CoffeeScript, 155 bajtów

Jest to prawie to samo, co rozwiązanie JavaScript w dół (i początkowo z tego powodu nie liczyłem), ale OP i tak umieściło je w tabeli wyników, więc awansowałem do pełnego przesłania. W końcu są to technicznie różne języki.

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 bajtów

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

Definiuje funkcję pobierającą tablicę liczb i zwracającą tablicę z pięcioma środkami.

Dzięki za ulepszenia Williama Barbosy.

Julia, 79 bajtów

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

Definiuje funkcję pobierającą listę liczb i zwracającą listę z pięcioma środkami.

Lua, 120 bajtów

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

Definiuje funkcję pobierającą listę liczb i zwracającą 5 oddzielnych wartości dla średnich.

Mathematica, 73 67 65 bajtów

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

Definiuje funkcję pobierającą listę liczb zmiennoprzecinkowych i zwracającą listę z pięcioma środkami.

Ciekawostka: Mathematica ma wbudowane wszystkie 5 środków (i to było moje oryginalne przesłanie), ale trzy z nich można zaimplementować za pomocą mniejszej liczby znaków niż nazwy funkcji.

Matlab, 65 63 bajtów

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

Żąda wprowadzenia danych jako tablicy liczb od użytkownika i wypisuje pięć środków indywidualnie.

Dzięki za ulepszenia Dennisa Jaheruddina.

PHP ≥ 5,4, 152 149 143 bajtów

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

Ta sama funkcjonalna implementacja, co wcześniejsze.

Dzięki za ulepszenia Ismaela Miguela.

Python 2, 127 bajtów

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]

Ta sama funkcjonalna implementacja, co wcześniejsze.

Rubin, 129 118 bajtów

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

Ta sama funkcjonalna implementacja, co wcześniejsze.

4 języki

J - 32 28 znaków!

Funkcja przyjmująca listę liczb za swój jedyny argument.

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

a tutaj jest przysłówek, który jest zajęciem J funkcji drugiego rzędu.

• +/ % # jest pociągiem w J, co oznacza Sumę podzieloną przez liczbę, definicję średniej arytmetycznej.
• &.:jest koniunkcją zwaną Under, gdzie u&.:v(y)jest równoważna vi(u(v(y)))i vijest odwrotnością funkcjonalną v. Tak, J może przyjmować funkcjonalne odwrotności .
• Wreszcie, użyteczną cechą J jest to, że niektóre funkcje mogą automatycznie zapętlać listy, ponieważ J wie, że stosuje je punktowo, jeśli nie ma sensu stosować ich do całego argumentu. Tak więc kwadrat listy jest na przykład listą kwadratów.

W ten sposób aprzyjmuje funkcję po lewej stronie i zwraca średnią, która „dostosowuje” wartości przez funkcję, przyjmuje średnią arytmetyczną, a następnie cofa regulację później.

• %ajest średnią harmoniczną, ponieważ %oznacza odwrotność i jest własną odwrotnością.
• ^.ajest średnią geometryczną, ponieważ ^.jest logarytmem naturalnym, a jego odwrotnością jest wykładniczy.(Π x)^(1/n) = exp(Σ log(x)/n)
• [ajest średnią arytmetyczną, ponieważ [jest funkcją tożsamości.
• *:ajest średnią kwadratową, ponieważ *:jest kwadratem, a jego odwrotnością jest pierwiastek kwadratowy.
• Kontraharmonia daje nam mnóstwo kłopotów - średnią kwadratów podzielonych przez średnią - więc robimy małą matematykę, aby je zdobyć: ( *:apodzielone przez ( [apodzielone przez *:a)). To wygląda jak [a(]%%)*:a. Chociaż już przy tym jesteśmy, możemy poprzedzić każdy z środków [a(,,]*%~)*:a.

Na koniec używamy przecinków, aby dołączyć pozostałe wyniki razem. Nie wymagamy żadnych dodatkowych części, ponieważ konkatenacja jest (przynajmniej w tym przypadku) asocjacyjna.

W użyciu na 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 znak

Funkcja pojedynczego argumentu. Po prostu tworzymy listę wszystkich potrzebnych środków.

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

To samo w innych wersjach k jest poniżej.

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

APL - 42 znaki

Lista przejmująca funkcje jako argument.

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

Wyjaśnione przez wybuch:

{                                         } ⍝ 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 znaków

Pokochasz ten.

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

Q'Nial to kolejny język zorientowany na tablice, implementacja Nial , która oparta jest na niejasnej teorii macierzy w taki sam sposób, w jaki Haskell opiera się na teorii kategorii. (Pobierz tutaj .) Różni się bardzo od pozostałych trzech - przede wszystkim analizuje od lewej do prawej! - ale nadal jest z nimi bardziej związany niż z jakimkolwiek innym językiem.

12 języków

CJam, 45 44 43 bajty

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

Czyta tablicę pływaków (np. [1.0 2.0 3.0 4.0 5.0]) Ze STDIN. Wypróbuj online.

APL, 67 61 53 52 50 bajtów

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

Wypróbuj online.

Pyth, 55 52 bajtów

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

Odczytuje liczby rozdzielone spacjami (np. 1 2 3 4 5) Ze STDIN.

Oktawa, 68 bajtów

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

Nie licząc shebang. Odczytuje tablicę (np. [1 2 3 4 5]) Ze STDIN.

GNU bc, 78 bajtów

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

Licząc shebang jako 1 bajt ( -lprzełącznik). Odczytuje liczby zmiennoprzecinkowe oddzielone od STDIN, a następnie zero.

Awk, 78 bajtów

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

Nie licząc shebang. Odczytuje jedną liczbę z linii ze STDIN.

GolfScript, 86 83 bajtów

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

GolfScript nie ma wbudowanej obsługi liczb zmiennoprzecinkowych, więc kod je analizuje. Dlatego format wejściowy jest raczej restrykcyjny: musisz wprowadzić 1.0i 0.1zamiast 1, 1.lub .1.

Odczytuje zmiennoprzecinkowe (jak wyjaśniono powyżej) jeden po wierszu, ze STDIN. Wypróbuj online.

Perl, 90 85 bajtów

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

Licząc shebang jako 1 bajt ( -nprzełącznik). Odczytuje jedną liczbę z linii ze STDIN.

Python 2, 102 96 bajtów

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

Nie licząc shebang. Czyta listę liczb zmiennoprzecinkowych (np. 1.0,2.0,3.0,4.0,5.0) Ze STDIN.

ECMAScript 6 (JavaScript), 114 112 bajtów

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

Nie licząc LF. Oczekuje tablicy (np. [1,2,3,4,5]) Jako argumentu.

PHP, 135 (lub 108?) Bajtów

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

Nie licząc shebang ani LF. Odczytuje liczby zmiennoprzecinkowe jako argumenty wiersza poleceń.

Mam krótsze rozwiązanie, ale nie wiem, jak policzyć bajty:

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

Zliczając bajty w każdym ciągu kodu i dodając dwa dla -Ri -E, to podejście dałoby wynik 108.

C, 172 140 139 137 136 bajtów

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

Nie licząc LF. Kompiluj z gcc -lm. Czyta zmiennoprzecinkowe oddzielone spacje od STDIN.

J (50):

Właśnie w tym jest dobry J:

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

Jak zawsze: eksplozja w fabryce buźek. Jednak niektóre buźki pozostały nietknięte tym razem: :)i :*:(to facet z czterema oczami i klejnotem osadzonym na twarzy) Moja interaktywna sesja, której użyto do stworzenia tego: http://pastebin.com/gk0ksn2b

W akcji:

   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

Wyjaśnienie:

Jak można się spodziewać, w rzeczywistości istnieje 5 funkcji, które są spakowane w listę z ciągiem widelców i haków. (Nie martw się o to, jest to po prostu wygodny sposób na wyprowadzenie wielu funkcji na jedną listę).

Linie, których użyłem, aby J wygenerował tę odpowiedź, mogą być nieco jaśniejsze:

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

Spójrzmy na nich osobno.

Harmoniczny

(# % +/@:%)

• # - Długość (tablicy)
• % - Podzielony przez
• +/@:%- Suma ( +/lub złożenie +w tablicy ( +/1 2 3 4== 1+2+3+4)) na szczycie podzielić, ale tym razem w przypadku monadycznym. Oznacza to, że J automatycznie „zgaduje”, że 1 byłby najbardziej użyteczną wartością.

Geometryczny

(# %: */)

• # - Długość (tablicy)
• %:- Korzeń ( 4 %: 7oznaczałoby „czwarty (lub tesseract) pierwiastek z siedmiu)
• */- Produkt ( */ma podobne znaczenie +/, patrz do tego poprzednia funkcja)

Arytmetyka

(+/ % #)

• +/ - suma, powinien być teraz znajomy
• % - podzielony przez
• # - długość

Root średni kwadrat

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

Ehm, tak ...

• %: - Korzeń
  • %@# - Odwrotna długość
  • * - Razy
  • +/@:*:- Suma kwadratów ( *:jest kwadratowa, mimo że *~również.)

Contraharmonic

+/@:*: % +/

• +/@:*: - Suma kwadratów
• % - podzielony przez
• +/ - Suma.

W rzeczywistości dowiedziałem się, że moja funkcja była o jeden bajt o dwa bajty za długa, wyjaśniając to, więc to dobrze!

Gdyby J był tak dobry w przetwarzaniu strun, wygrywalibyśmy o wiele więcej zawodów golfowych ...

Języki: 5

POV-Ray 3.7 Scena Opis Język: 304 bajty

#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 nie ma funkcji wprowadzania na konsolę, więc podłożyłem dane wejściowe do pliku. Dane wyjściowe są przesyłane do konsoli, ale są otoczone dużą ilością danych wyjściowych o statusie programu).

Commodore BASIC: 111 104 bajtów

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

(Nie wszystkie znaki w tym programie mogą być reprezentowane w Unicode. |Służy do reprezentowania SHIFT+H, ┌reprezentowania SHIFT+O, ┐reprezentowania SHIFT+P, /reprezentowania SHIFT+N. Ze względu na ograniczenia w Commodore Basic I / O, dane wejściowe są wprowadzane pojedynczo, za pomocą danych wejściowych od -1, aby wskazać koniec wprowadzania. Dane wyjściowe są rozdzielane tabulatorami.)

QBasic: 96 bajtów

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

Używa tego samego schematu We / Wy, co wpis DLosc; Grałem w golfa o 15 bajtów, korzystając z faktu, że INPUT Vzwraca 0 (co daje wartość false), gdy wprowadzana jest pusta linia (przynajmniej w MS-DOS QBasic 1.1 - nie wiem, czy to działa również w QB64).

Pascal (kompilator FPC): 172 bajty

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.

Dane wejściowe są oddzielone spacjami, a nie przecinkami, i kończą się znakiem nowej linii. Dane wyjściowe są rozdzielone spacjami.

Erlang: 401 bajtów

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

Obsługa sznurków w Erlang to królewski ból. W związku z tym wszystkie liczby zmiennoprzecinkowe muszą być wprowadzane co najmniej jedną cyfrą po przecinku - string:to_float/1nie będą konwertowane 1, ale zostaną przeliczone 1.0.

(Więcej w przyszłości, zwłaszcza jeśli wymyślę, jak to zrobić w RoboTalk, języku bez operacji zmiennoprzecinkowych ani we / wy)

Języki: 3

O ile nie zaznaczono inaczej, liczby muszą być oddzielone spacją.

C: 181 163

Pobiera liczby do końca wprowadzania.

#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

Pobiera liczby do końca wprowadzania.

#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

Pobiera dowolnie wiele list liczb oddzielonych znakiem nowej linii.

Realizacja

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 bajków (dzięki shiona) jest tylko dla IO: /.

Przykład

( echoAka Powershell Write-Outputdrukuje każdy parametr w jednym wierszu)

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.6666666666666666]
[3.011834514901806,4.621794669196026,8.412666666666668,12.234139719108438,17.791525635945792]

Języki - 4

Zawsze lubię wymówkę, aby wyciągnąć stare dobre

QBasic, 112 96 bajtów

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 nie jest dobry ze zmienną liczbą wejść, więc program wymaga jednej liczby na linię, zakończonej 0 lub pustą linią. Dane wyjściowe są oddzielone spacjami.

(Skrócone, gdy zdałem sobie sprawę, że 0 nie jest prawidłową liczbą i może być użyte do zakończenia wejścia.)

Testowane przy użyciu QB64 :

Common Lisp, 183 bajtów

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

Z jakiegoś powodu spodziewałem się, że będzie to krótsze. Nie jestem ekspertem od Lisp, więc wskazówki są mile widziane. Wersja bez golfa:

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

Prawdopodobnie najlepszym sposobem na przetestowanie jest wklejenie funkcji do clispREPL, na przykład:

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

Uwielbiam sposób, w jaki Lisp używa dokładnych ułamków zamiast liczb zmiennoprzecinkowych przy dzieleniu dwóch liczb całkowitych.

Prolog, 235 bajtów

Prolog nie jest świetny z matematyki, ale i tak go wykorzystamy. Testowane z SWI-Prolog. Myślę, że sumlistpredykat może nie być standardowym Prologiem, ale cokolwiek, używam go.

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

Nie golfowany:

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

W systemie Linux, z kodem w pliku o nazwie means.pro, przetestuj w następujący sposób:

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

Daje poprawny, ale raczej zabawny wynik, gdy jest tylko jedna liczba:

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

Python 3, 103 bajty

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)

Ta sama strategia, co wersja Dennisa w Python 2. Pobiera listę liczb oddzieloną przecinkami; obsługuje zarówno ints, jak i floaty. Wprowadzanie pojedynczej liczby musi być owinięte w nawiasy kwadratowe (zawsze może być lista liczb ); poprawka kosztowałaby 4 bajty.

8 języków

Fortran 77 - 286

      READ*,l
      b1=0
      b2=1
      b3=0
      b4=0
      DO 10 i=1,l
        READ*,j
        b1=b1+1/j
        b2=b2*j
        b3=b3+j
        b4=b4+j**2
   10 CONTINUE
      h=l/b1
      g=b2**(1/l)
      a=b3/l
      q=(b4/l)**0.5
      c=b4/b3
      PRINT*,h,g,a,q,c
      END

BBC BASIC - 131

INPUT l
b=0:d=1:e=0:f=0
FOR i=1 TO l
  INPUTj:b+=1/j:d*=j:e+=j:f+=j^2
NEXT l
h=l/b:g=d^(1/l):a=e/l:q=(f/l)^0.5:c=f/e
PRINTh,g,a,q,c

Wydajność:

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)

Wydajność:

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

Nie jestem Javascripter, więc wszelkie wskazówki będą mile widziane

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

Zajrzyj do sklepu Google Play lub Raspberry Pi Store

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

Jest to poprawne składniowo i wszystko, ale wszyscy obecni tłumacze po prostu nie działają ...

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'

Języki: 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);}}

Języki - 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 język

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

Pobiera wektor wartości i wyprowadza wektor środków.

1 język

Golfscript, 162

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

Tak, jest ogromny. I zdecydowanie można go zmniejszyć. Co zrobię później. Wypróbuj tutaj .

Oczekuje, że dane wejściowe zostaną rozdzielone znakiem nowej linii. Jeśli nie jest to dozwolone, naprawię to (+2 znaki). Wypisuje rozdzieloną listę nowej linii.

Oto nieco bardziej czytelna wersja:

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

Języki 2

Fortran: 242

Odkryłem to dla jasności, ale liczy się wersja golfowa. najpierw musisz wprowadzić liczbę wartości do dodania, a następnie wartości.

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

Skopiuj to do edytora, ctrl+entera następnie wywołaj przez, m([1,2,3,4,5]),numeraby uzyskać wynik zmiennoprzecinkowy (w przeciwnym razie otrzymasz wynik symboliczny).

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

Wprowadzanie: jedna liczba na linię.

EDYCJA: jest to jedna postać dłużej, ale ponieważ najwyraźniej linie shebang nie są wliczane do sumy, ostatecznie jest lepiej:

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

T-SQL, 136 122

Z listami numerów zapisanymi w tabeli S, gdzie I (liczba całkowita) identyfikuje listę, a V (liczba zmiennoprzecinkowa) wartość.

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

Ocalono 14 dzięki Alchymist

Języki: 5

Niektóre wpisy starają się unikać błędów zaokrąglania (do 4 miejsc po przecinku), używając BigDecimal Java zamiast float / double i akceptują reguły IO na OP.

Nowsze wpisy rozluźniają zarówno reguły IO, jak i BigDecimal.

Groovy - 409 400 164 157 znaków

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

przykładowy przebieg:

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 znaków

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

przykładowy przebieg:

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 znaków

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

przykładowy przebieg (na końcu ma przecinek końcowy):

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 znaków

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

przykładowy przebieg:

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 znaków

Nie jest jasne, czy JRuby różni się od Ruby: to musi działać na JVM. Jest to jednak składnia Rubiego. Tak czy inaczej, włączam to w duchu kamienia z Rosetty.

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

uruchomienie próbne (wyświetla ostrzeżenie do 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

Języki 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)

Języki - 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 języki

Java - 243 bajty

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

rozszerzony:

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 bajtów

Wpisz wartości w pierwszej kolumnie, a następnie naciśnij przycisk (który uruchamia ten kod), a wyświetli wartości w drugiej kolumnie.

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 język

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

Wersja bez golfa:

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

Kompaktowa wersja 430 bajtów bez pętli lub wejścia, do testowania w trybie odtwarzania :

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

Zaktualizowano dla nowszej rdzy:

Nie golfowany:

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

Gra w golfa (402 bajty):

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

Języki: 4

CoffeeScript, 193

Pobiera oddzielony przecinkami ciąg danych wejściowych:

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

Ponownie pobiera ciąg danych wejściowych oddzielony przecinkami:

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

Ta sama koncepcja:

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

Ponieważ TypeScript jest nadzbiorem JavaScriptu, mogłem właśnie przesłać ten sam kod, ale teraz nie byłoby to uczciwe. Oto zminimalizowany kod TypeScript ze wszystkimi funkcjami, zmiennymi i parametrami w pełni wpisanymi:

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

Mógł też oszukiwać i używać tego typu any... ale wiesz.

Excel - 120

Nie jestem pewien, czy liczy się to jako język „programowania”, ale pomyślałem, że ludzie mogą faktycznie używać arkusza kalkulacyjnego do tego typu rzeczy

Z liczbami w 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

Nie golfowany:

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

Ten kod musi zostać uruchomiony w bezpośrednim oknie, a tablica musi mieć nazwę i . Ponieważ nie ma gromadzenia błędów, czyszczenia, żadnych zmiennych upuszczania / zwalniania, jeśli chcesz przetestować ten kod, możesz użyć następującego fragmentu kodu (po prostu wklej w bezpośrednim oknie i uruchom wiersze w kolejności):

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

Nic specjalnego, tylko wybór bezpośredniego okna : do zastąpienia podziałów linii, co pozwala zaoszczędzić kilka bajtów w porównaniu do ustawienia podrzędnej lub funkcji i zamknięcia jej; za pomocą ? drukować zamiast debug.print (tylko w bezpośrednim oknie); i poleganie na tym, jak vba określa wartości niejawne (dodanie wartości do zmiennej nieustawionej zwraca wartość) i operacje niejawne (wszystko, co obejmuje łańcuch, jest niejawnie konkatenacją).