Mục tiêu của Thử thách Rosetta Stone là viết các giải pháp bằng càng nhiều ngôn ngữ càng tốt. Thể hiện đa ngôn ngữ lập trình của bạn!

Các thách thức

Khi mọi người sử dụng thuật ngữ "trung bình", họ thường có nghĩa là trung bình số học, là tổng của các số chia cho số lượng số. Tuy nhiên, có nhiều ý nghĩa hơn của từ "trung bình", bao gồm cả ý nghĩa hài hòa , trung bình hình học , trung bình số học , trung bình bậc hai và trung bình contraharmonic .

Thách thức của bạn là viết một chương trình nhập danh sách các số và xuất ra 5 phương tiện khác nhau. Ngoài ra, bạn đang cố gắng viết chương trình bằng nhiều ngôn ngữ nhất có thể . Bạn được phép sử dụng bất kỳ loại chức năng thư viện tiêu chuẩn nào mà ngôn ngữ của bạn có, vì đây chủ yếu là một ngôn ngữ giới thiệu.

Đầu vào

Đầu vào sẽ là một danh sách các số dương.

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

Đầu ra

Đầu ra sẽ là năm phương tiện theo thứ tự được liệt kê ở trên (hài hòa, hình học, số học, bậc hai, contraharmonic). Thuận tiện, điều này giống như tăng thứ tự.

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

Sẽ có một số khoan hồng hợp lý trong định dạng I / O, nhưng tôi muốn có một số vị trí chính xác thập phân. Vì tôi muốn đầu ra dấu phẩy động, bạn có thể giả sử đầu vào dấu phẩy động.

Tiêu chí chiến thắng khách quan

Đối với một tiêu chí chiến thắng khách quan, đây là: Mỗi ngôn ngữ là một cuộc thi riêng biệt để ai có thể viết bài dự thi ngắn nhất, nhưng người chiến thắng chung cuộc sẽ là người chiến thắng hầu hết các cuộc thi phụ này. Điều này có nghĩa là một người trả lời bằng nhiều ngôn ngữ không phổ biến có thể đạt được lợi thế. Code-golf chủ yếu là một công cụ hòa nhập khi có nhiều hơn một giải pháp trong một ngôn ngữ: người có chương trình ngắn nhất được tín dụng cho ngôn ngữ đó.

Nếu có hòa, người chiến thắng sẽ là người có nhiều bài dự thi thứ hai nhất (v.v.).

Quy tắc, hạn chế và ghi chú

Chương trình của bạn có thể được viết bằng bất kỳ ngôn ngữ nào tồn tại trước ngày 2 tháng 9 năm 2014. Tôi cũng sẽ phải dựa vào cộng đồng để xác thực một số câu trả lời được viết bằng một số ngôn ngữ không phổ biến / bí truyền hơn, vì tôi không thể kiểm tra họ

Vui lòng giữ tất cả các bài nộp khác nhau của bạn trong một câu trả lời.

Ngoài ra, không có shenanigans với câu trả lời cơ bản giống nhau trong một phương ngữ ngôn ngữ hơi khác nhau. Tôi sẽ là người đánh giá xem những bài nộp nào đủ khác nhau.

Bảng xếp hạng hiện tại

Phần này sẽ được cập nhật định kỳ để hiển thị số lượng ngôn ngữ và những người đang dẫn đầu trong mỗi ngôn ngữ.

• Algoid (337) - Phân rã Beta
• APL (42) - thuật toán
• Awk (78) - Dennis
• BBC BASIC (155) - Phân rã Beta
• C (136) - Dennis
• C ++ (195) - Zeta
• C # (197) - Martin Büttner
• CJam (43) - Dennis
• Clojure (324) - Phục sinh Michael
• Cobra (132) - Chúng tôi
• CoffeeScript (155) - Martin Büttner
• BASIC hàng hóa (104) - Đánh dấu
• Lisp thường gặp (183) - DLosc
• Erlang (401) - Đánh dấu
• Fortran (242) - Kyle Kanos
• Fortran 77 (286) - Phân rã Beta
• GNU bc (78) - Dennis
• GolfScript (83) - Dennis
• Groovy (157) - Michael Phục sinh
• Haskell (140) - Zeta
• J (28) - thuật toán
• Java (235) - Michael Phục sinh
• JavaScript (ES6) (112) - Dennis
• JRuby (538) - Michael Phục sinh
• Julia (79) - Martin Büttner
• Lua (113) - AndoDaan
• Toán học (65) - Martin Büttner
• Matlab (63) - Martin Büttner
• Octave (68) - Dennis
• Bản mở rộng (849?) - COTO
• Pascal (172) - Đánh dấu
• Perl (76) - Grimy
• PHP (135) - Dennis
• POV-Ray 3.7 (304) - Đánh dấu
• Prolog (235) - DLosc
• Pyth (52) - Dennis
• Con trăn 2 (96) - Dennis
• Python 3 (103) - DLosc
• Q (53) - thuật toán
• Q'Nial (68) - thuật toán
• QBasic (96) - DLosc
• R (91) - plannapus
• Ruby (118) - Martin Büttner
• Mộc (469) - Vi.
• Scala (230) - Michael Phục sinh
• T-SQL (122) - MickyT
• TI-Basic (85) - Ypnypn
• TypeScript (393) - rink.attguard.6
• VBA (Excel) (387) - Căng thẳng
• wxMaxima (134) - Kyle Kanos

Xếp hạng người dùng hiện tại

1. Dennis (10)
2. Martin Büttner (6)
3. Michael Phục sinh (5)
4. Đánh dấu, DLosc, thuật toán (4)
5. Phân rã Beta (3)
6. Zeta, Kyle Kanos (2)
7. Ourous, AndoDaan, COTO, Grimy, plannapus, Vi., MickyT, Ypnypn, rink.attguard.6, Stretch Maniac (1)

(Nếu tôi mắc lỗi trong bảng xếp hạng trên, hãy cho tôi biết và tôi sẽ sửa nó. Ngoài ra, bộ bẻ khóa chưa được áp dụng.)

Ngôn ngữ: 1

Bản mở rộng (hàng trăm)

(Ngôn ngữ lập trình mơ hồ và đáng buồn của tôi, vì tôi đã học lập trình trên đó nhiều năm trước.)

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

Ngôn ngữ: 13

Tôi nghĩ rằng danh sách này bây giờ nên chứa mọi ngôn ngữ lập trình mà tôi biết đủ rõ để giải quyết ít nhất các vấn đề đơn giản. Tôi sẽ cố gắng duy trì danh sách này theo thời gian khi tôi tìm hiểu một số ngôn ngữ mới. (Tôi đã từng biết một số Smalltalk và Delphi, nhưng tôi phải tìm kiếm nhiều để thêm chúng để cảm thấy đúng.)

C, 196 190 171 165 byte

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 đầu vào dưới dạng đối số dòng lệnh riêng lẻ và viết danh sách các phương tiện được phân tách bằng dấu phẩy cho STDOUT.

Cảm ơn vì một số cải tiến cho Quentin.

C ++, 200 byte

Điều này giống như mã C ở trên, cộng với hai bao gồm. Tôi bao gồm điều này bởi vì nó dài hơn bài nộp C ++ chiến thắng, vì vậy tôi đoán không có tác hại nào được thực hiện và tôi muốn bài đăng này thực sự chứa mọi ngôn ngữ tôi biết. :)

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

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

Xác định một hàm trong một lớp lấy một Listsố nhân đôi và trả về một mảng nhân đôi với năm phương tiện.

Cảm ơn vì một số cải tiến cho Visual Melon và Bob.

CJam, 52 byte

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

Lấy đầu vào dưới dạng đối số dòng lệnh và in một danh sách có năm giá trị thành STDOUT.

CoffeeScript, 155 byte

Điều này gần giống với giải pháp JavaScript hơn nữa (và ban đầu tôi không tính nó vì lý do đó), nhưng dù sao thì OP cũng đã đưa nó vào bảng điểm, vì vậy tôi đã quảng cáo nó thành một bản đệ trình đầy đủ. Họ là những ngôn ngữ kỹ thuật khác nhau sau khi tất cả.

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 byte

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

Xác định một hàm lấy một mảng các số và trả về một mảng với năm phương tiện.

Cảm ơn vì một số cải tiến cho William Barbosa.

Julia, 79 byte

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

Xác định hàm lấy danh sách các số và trả về danh sách với năm phương tiện.

Lua, 120 byte

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

Xác định hàm lấy danh sách các số và trả về 5 giá trị riêng cho phương tiện.

Toán học, 73 67 65 byte

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

Xác định hàm lấy danh sách các số dấu phẩy động và trả về danh sách với năm phương tiện.

Sự thật thú vị: Mathicala có tất cả 5 phương tiện được xây dựng (và đó là đệ trình ban đầu của tôi), nhưng ba trong số chúng có thể được thực hiện với ít ký tự hơn tên hàm của chúng.

Matlab, 65 63 byte

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

Yêu cầu đầu vào dưới dạng một dãy số từ người dùng và xuất ra năm phương tiện riêng lẻ.

Cảm ơn vì một số cải tiến cho Dennis Jaheruddin.

PHP ≥ 5,4, 152 149 143 byte

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

Thực hiện chức năng tương tự như những người trước đó.

Cảm ơn vì một số cải tiến cho Ismael Miguel.

Python 2, 127 byte

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]

Thực hiện chức năng tương tự như những người trước đó.

Ruby, 129 118 byte

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

Thực hiện chức năng tương tự như những người trước đó.

4 ngôn ngữ

J - 32 28 char!

Một hàm lấy danh sách các số làm đối số duy nhất của nó.

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

a đây là một trạng từ, là J đảm nhận các chức năng bậc hai.

• +/ % # là một chuyến tàu trong J, có nghĩa là Sum Divided-by Count, định nghĩa của trung bình số học.
• &.:là một kết hợp được gọi là Under, nơi u&.:v(y)tương đương vi(u(v(y)))và vilà nghịch đảo chức năng của v. Có, J có thể đảo ngược chức năng .
• Cuối cùng, một tính năng hữu ích của J là một số chức năng nhất định có thể tự động lặp qua các danh sách, bởi vì J biết áp dụng chúng theo chiều dọc nếu việc áp dụng chúng trên toàn bộ đối số sẽ không có ý nghĩa. Vì vậy, hình vuông của một danh sách là một danh sách các hình vuông, ví dụ.

Do đó, acó một hàm ở bên trái và trả về một giá trị "điều chỉnh" các giá trị theo hàm, lấy trung bình số học và sau đó đảo ngược điều chỉnh sau đó.

• %alà trung bình hài hòa, bởi vì %có nghĩa là đối ứng, và là nghịch đảo của chính nó.
• ^.alà trung bình hình học, bởi vì ^.logarit tự nhiên và nghịch đảo của nó là hàm mũ.(Π x)^(1/n) = exp(Σ log(x)/n)
• [alà trung bình số học, bởi vì [là hàm nhận dạng.
• *:alà trung bình bậc hai, vì *:là Square và nghịch đảo của nó là căn bậc hai.
• Contraharmonic cung cấp cho chúng ta toàn bộ rắc rối có nghĩa là trung bình của các ô vuông được chia cho trung bình vì vậy chúng ta làm một phép toán nhỏ để có được nó: ( *:achia cho ( [achia cho *:a)). Điều này trông giống như [a(]%%)*:a. Trong khi chúng tôi đang ở đó, chúng tôi trả trước từng phương tiện , [a(,,]*%~)*:a.

Cuối cùng, chúng tôi sử dụng dấu phẩy để nối phần còn lại của kết quả với nhau. Chúng tôi không yêu cầu thêm nữa vì sự kết hợp là (trong trường hợp này ít nhất là) kết hợp.

Đang sử dụng tại 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 char

Hàm đối số đơn. Chúng tôi chỉ lập một danh sách tất cả các phương tiện chúng tôi muốn.

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

Điều tương tự trong các phiên bản khác của k là bên dưới.

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

APL - 42 char

Chức năng lấy danh sách làm đối số.

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

Giải thích bằng vụ nổ:

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

Bạn sẽ thích cái này

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

Q'Nial là một ngôn ngữ hướng mảng khác, triển khai Nial , dựa trên Lý thuyết Mảng tối nghĩa theo cách sam Haskell dựa trên lý thuyết thể loại. (Lấy nó ở đây .) Nó rất khác so với bất kỳ ba ngôn ngữ nào khác, nó phân tích cú pháp từ trái sang phải, trước hết!, Nhưng nó vẫn liên quan đến chúng nhiều hơn bất kỳ ngôn ngữ nào khác.

12 ngôn ngữ

CJam, 45 44 43 byte

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

Đọc một mảng các số float (ví dụ [1.0 2.0 3.0 4.0 5.0]:) từ STDIN. Hãy thử trực tuyến.

APL, 67 61 53 52 50 byte

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

Hãy thử trực tuyến.

Bình thường, 55 52 byte

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

Đọc các số được phân tách bằng dấu cách (ví dụ 1 2 3 4 5:) từ STDIN.

Octave, 68 byte

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

Không tính shebang. Đọc một mảng (ví dụ, [1 2 3 4 5]) từ STDIN.

GNU bc, 78 byte

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

Đếm shebang là 1 byte ( -lswitch). Đọc các khoảng trắng được phân tách nổi từ STDIN, theo sau là số không.

Awk, 78 byte

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

Không tính shebang. Đọc một số trên mỗi dòng từ STDIN.

GolfScript, 86 83 byte

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

GolfScript không có hỗ trợ tích hợp cho float, vì vậy mã đang phân tích cú pháp chúng. Do đó, định dạng đầu vào khá hạn chế: bạn phải nhập 1.0và 0.1thay vì 1, 1.hoặc .1.

Đọc các số float (như đã giải thích ở trên) từng dòng một, từ STDIN. Hãy thử trực tuyến.

Perl, 90 85 byte

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

Đếm shebang là 1 byte ( -nswitch). Đọc một số trên mỗi dòng từ STDIN.

Python 2, 102 96 byte

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

Không tính shebang. Đọc danh sách các số float (ví dụ 1.0,2.0,3.0,4.0,5.0:) từ STDIN.

ECMAScript 6 (JavaScript), 114 112 byte

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

Không tính đến số LF. Yêu cầu một mảng (ví dụ, [1,2,3,4,5]) làm đối số.

PHP, 135 (hoặc 108?) Byte

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

Không tính shebang hoặc LF. Đọc float như các đối số dòng lệnh.

Tôi có một giải pháp ngắn hơn, nhưng tôi không biết cách đếm byte:

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

Đếm các byte trong mỗi chuỗi mã và thêm hai cho -Rvà -E, cách tiếp cận này sẽ đạt 108 điểm.

C, 172 140 139 137 136 byte

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

Không tính đến số LF. Biên dịch với gcc -lm. Đọc các khoảng trắng được phân tách từ STDIN.

J (50):

Đây là loại điều J giỏi:

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

Như mọi khi: một vụ nổ trong nhà máy mặt cười. Tuy nhiên, một số mặt cười vẫn còn nguyên vẹn trong khoảng thời gian này: :)và :*:(đó là một chàng trai có bốn mắt và một viên đá quý được gắn vào mặt anh ta) Phiên tương tác của tôi được sử dụng để tạo ra điều này: http://pastebin.com/gk0ksn2b

Trong hành động:

   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

Giải trình:

Như bạn có thể mong đợi, thực sự có 5 chức năng được gói vào một danh sách với một chuỗi các dĩa và móc. (Đừng lo lắng về điều đó, đây chỉ là một cách thuận tiện để tạo nhiều chức năng xuất ra một danh sách).

Các dòng mà tôi đã sử dụng để tạo J tạo ra câu trả lời này có thể rõ ràng hơn một chút:

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

Hãy xem xét chúng một cách riêng biệt.

Điều hòa

(# % +/@:%)

• # - Chiều dài (của mảng)
• % - Chia
• +/@:%- Tổng ( +/hoặc gấp +trong mảng ( +/1 2 3 4== 1+2+3+4)) trên đỉnh chia, nhưng lần này trong trường hợp đơn âm. Điều này có nghĩa ở đây, là J tự động "đoán" rằng 1 sẽ là giá trị hữu ích nhất.

Hình học

(# %: */)

• # - Chiều dài (của mảng)
• %:- Root ( 4 %: 7có nghĩa là 'gốc thứ tư (hoặc tesseract) trong bảy)
• */- Sản phẩm ( */có ý nghĩa tương tự +/, xem chức năng trước đó cho việc này)

Số học

(+/ % #)

• +/ - tổng, nên làm quen ngay
• % - chia
• # - Chiều dài

Root có nghĩa là vuông

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

Ơ, ừ ...

• %: - Các gốc rễ của
  • %@# - Nghịch đảo chiều dài
  • * - Thời đại
  • +/@:*:- Tổng bình phương ( *:bình phương, mặc dù *~là tốt.)

Contraharmonic

+/@:*: % +/

• +/@:*: - Tổng bình phương
• % - chia
• +/ - Tổng.

Tôi thực sự phát hiện ra rằng hàm của tôi dài một byte hai byte bằng cách giải thích điều này, vậy thì tốt quá!

Nếu J chỉ giỏi xử lý dây, chúng ta sẽ chiến thắng nhiều cuộc thi golf hơn ...

Ngôn ngữ: 5

Ngôn ngữ mô tả cảnh POV-Ray 3.7: 304 byte

#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 không có chức năng nhập bảng điều khiển, vì vậy tôi đã thay thế đầu vào tệp. Đầu ra là cho bảng điều khiển, nhưng được bao quanh bởi rất nhiều đầu ra trạng thái chương trình.)

BASIC hàng hóa: 111 104 byte

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

(Không phải tất cả các ký tự trong chương trình này đều có thể được biểu thị bằng Unicode. |Được sử dụng để thể hiện SHIFT+H, ┌đại diện SHIFT+O, ┐đại diện SHIFT+P, /đại diện SHIFT+N. Do những hạn chế trong I / O hàng hóa cơ bản, đầu vào được nhập một số tại một thời điểm, với đầu vào bằng -1 để chỉ ra kết thúc đầu vào. Đầu ra được phân định bằng tab.)

QBasic: 96 byte

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

Sử dụng lược đồ I / O tương tự như mục nhập của DLosc; Tôi đã loại bỏ 15 byte bằng cách sử dụng thực tế INPUT Vtrả về 0 (đánh giá là sai) khi một dòng trống được nhập vào (ít nhất là trong MS-DOS QBasic 1.1 - Tôi không biết nếu nó cũng hoạt động trong QB64).

Pascal (trình biên dịch FPC): 172 byte

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.

Đầu vào được phân tách bằng dấu cách, không phải dấu phẩy và dòng mới kết thúc. Đầu ra được phân tách không gian.

Erlang: 401 byte

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

Xử lý chuỗi trong Erlang là một nỗi đau của hoàng gia. Do đó, tất cả các số dấu phẩy động phải được nhập với ít nhất một chữ số sau dấu thập phân - string:to_float/1sẽ không chuyển đổi 1, nhưng sẽ chuyển đổi 1.0.

(Sẽ có nhiều hơn, đặc biệt là nếu tôi tìm ra cách thực hiện điều này trong RoboTalk, một ngôn ngữ không có hoạt động dấu phẩy động cũng như I / O)

Ngôn ngữ: 3

Trừ khi có ghi chú khác, các số cần được phân tách bằng dấu cách.

C: 181 163

Mất số cho đến khi kết thúc đầu vào.

#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

Mất số cho đến khi kết thúc đầu vào.

#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

Lấy tùy ý nhiều danh sách các số được phân tách bằng dòng mới.

Thực hiện

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 (cảm ơn shiona) byte chỉ dành cho IO: /.

Thí dụ

(Powershell's echoakaWrite-Output in mọi tham số trên một dòng)

PS> tiếng vang "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.666666666666666665]
[3.011834514901806,4.621794669196026,8.412666666666668,12.234139419108438,17.791525635945792]

Ngôn ngữ - 4

Tôi luôn thích một cái cớ để lôi ra những điều tốt đẹp

QBasic, 112 96 byte

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 không tốt với số lượng đầu vào thay đổi, vì vậy chương trình yêu cầu một số trên mỗi dòng, kết thúc bằng 0 hoặc một dòng trống. Đầu ra được phân tách bằng dấu cách.

(Rút ngắn một khi tôi nhận ra rằng 0 không phải là số hợp lệ và có thể được sử dụng để chấm dứt đầu vào.)

Đã kiểm tra bằng QB64 :

Lisp thông thường, 183 byte

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

Đối với một số lý do tôi mong đợi điều này sẽ ngắn hơn. Tôi không phải là chuyên gia Lisp, vì vậy các mẹo được đánh giá cao. Phiên bản bị đánh cắp:

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

Có lẽ cách tốt nhất để kiểm tra là dán chức năng vào clispREPL, như vậy:

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

Tôi thích cách Lisp sử dụng các phân số chính xác thay vì nổi khi chia hai số nguyên.

Prolog, 235 byte

Prolog không giỏi toán, nhưng dù sao chúng ta cũng sẽ sử dụng nó. Đã thử nghiệm với SWI-Prolog. Tôi nghĩ rằng sumlistvị ngữ có thể không phải là Prolog tiêu chuẩn, nhưng dù sao đi nữa, tôi đang sử dụng nó.

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

Ung dung:

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

Trên Linux, với mã trong một tệp được gọi means.pro, hãy kiểm tra như sau:

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

Cung cấp một kết quả chính xác nhưng khá thú vị khi chỉ có một số:

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

Python 3, 103 byte

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)

Chiến lược tương tự như phiên bản Python 2 của Dennis . Đưa ra một danh sách các số được phân tách bằng dấu phẩy; xử lý cả ints và float. Một đầu vào một số phải được bọc trong dấu ngoặc vuông (và một danh sách các số luôn luôn có thể); một sửa chữa sẽ có giá 4 byte.

8 ngôn ngữ

Pháo đài 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 CƠ BẢN - 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

Đầu ra:

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

Con trăn 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)

Đầu ra:

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

Tôi không phải là một Javascripter nên mọi lời khuyên sẽ được đánh giá rất cao

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

Đại số - 337

Tra cứu nó trên Google Play Store hoặc 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

Điều này đúng về mặt cú pháp và tất cả, nhưng tất cả các thông dịch viên hiện tại chỉ không hoạt động ...

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'

Ngôn ngữ: 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);}}

Ngôn ngữ - 2

Rắn hổ mang - 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

Con trăn - 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 ngôn ngữ

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

Lấy một vectơ giá trị và xuất ra một vectơ phương tiện.

1 ngôn ngữ

Golf, 162

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

Vâng, nó rất lớn. Và nó chắc chắn có thể được làm nhỏ hơn. Mà tôi sẽ làm sau này Hãy thử nó ở đây .

Nó hy vọng đầu vào sẽ được tách dòng mới. Nếu điều đó không được phép, tôi sẽ sửa nó (+2 ký tự). Nó xuất ra danh sách dòng mới được phân tách.

Đây là một phiên bản dễ đọc hơn một chút:

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

Ngôn ngữ 2

Pháo đài: 242

Tôi đã không hiểu nó cho rõ ràng, nhưng phiên bản golf là những gì được tính. trước tiên bạn cần nhập số lượng giá trị được thêm vào, sau đó là giá trị.

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

Sao chép phần này vào trình chỉnh sửa, ctrl+entersau đó gọi qua m([1,2,3,4,5]),numerđể lấy đầu ra dấu phẩy động (nếu không bạn sẽ có đầu ra tượng trưng).

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

Đầu vào: một số trên mỗi dòng.

EDIT: đây là một ký tự dài hơn, nhưng vì rõ ràng các dòng shebang không được tính vào tổng số, nên cuối cùng nó sẽ tốt hơn:

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

T-SQL, 136 122

Với các danh sách số được lưu trong bảng S với I (số nguyên) xác định danh sách và V (float) giá trị.

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

Lưu 14 nhờ Alchymist

Ngôn ngữ: 5

Một số mục nhập cố gắng tránh các lỗi làm tròn (đến 4 chữ số thập phân), sử dụng BigDecimal của Java thay vì float / double và chấp nhận các quy tắc IO trên mỗi OP.

Các mục mới hơn giúp thư giãn cả quy tắc IO và BigDecimal.

Groovy - 409 400 164 157 ký tự

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

chạy mẫu:

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 ký tự

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

chạy mẫu:

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 ký tự

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

chạy mẫu (nó có dấu phẩy ở cuối):

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 ký tự

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

chạy mẫu:

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 ký tự

Không rõ nếu JRuby khác với Ruby: điều này phải chạy trên JVM. Tuy nhiên, đó là cú pháp của Ruby. Dù bằng cách nào, tôi bao gồm nó theo tinh thần của Rosetta Stone.

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

chạy mẫu (không in cảnh báo đế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

Ngôn ngữ 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)

Ngôn ngữ - 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 ngôn ngữ

Java - 243 byte

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

mở rộng:

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 byte

Điền vào các giá trị trong cột đầu tiên, sau đó nhấn nút (kích hoạt mã này) và nó xuất ra các giá trị trong cột thứ hai.

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 ngôn ngữ

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

Phiên bản bị đánh cắp:

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

Phiên bản được nén 430 byte không có vòng lặp hoặc đầu vào, để thử nghiệm trong playrust :

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

Cập nhật cho Rust mới hơn:

Ung dung:

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

Đã đánh gôn (402 byte):

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

Ngôn ngữ: 4

Cà phê, 193

Có một chuỗi đầu vào được phân tách bằng dấu phẩy:

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

Một lần nữa, lấy một chuỗi đầu vào được phân tách bằng dấu phẩy:

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

Khái niệm tương tự:

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

Vì TypeScript là một siêu mã JavaScript, tôi có thể vừa gửi cùng một mã nhưng điều đó thực sự không công bằng bây giờ. Đây là mã TypeScript được rút gọn với tất cả các hàm, biến và tham số được nhập đầy đủ:

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

Có thể đã lừa dối và sử dụng loại anynày ... nhưng, bạn biết đấy.

Excel - 120

Không chắc chắn nếu điều này được tính là ngôn ngữ "lập trình", nhưng mọi người nghĩ rằng thực sự có thể sử dụng bảng tính cho loại điều này

Với các số trong 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

Ung dung:

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

Mã này phải được chạy trong cửa sổ ngay lập tức và mảng phải được gọi là i . Vì không có bộ sưu tập lỗi, không có dọn dẹp, không có biến / thả biến, nếu bạn muốn kiểm tra mã này, bạn có thể sử dụng đoạn mã sau (chỉ cần dán vào cửa sổ ngay lập tức và chạy các dòng theo thứ tự):

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

Không có gì đặc biệt, chỉ là lựa chọn sử dụng cửa sổ ngay lập tức với : để thay thế ngắt dòng, giúp tiết kiệm một vài byte so với thiết lập một phụ hoặc hàm và đóng nó; sử dụng? để in chứ không phải debug.print (chỉ trong cửa sổ ngay lập tức); và dựa vào cách vba xác định các giá trị ngầm định (thêm một giá trị vào một biến chưa được đặt sẽ trả về giá trị) và các hoạt động ngầm (bất cứ điều gì liên quan đến một chuỗi đều được nối ngầm).