Rosetta Stone Challenge의 목표는 가능한 한 많은 언어로 솔루션을 작성하는 것입니다. 다국어 프로그래밍을 과시하십시오!

도전

사람들이 "평균"이라는 용어를 사용하는 경우, 일반적으로 산술 평균을 숫자의 수를 숫자의 수로 나눈 값을 의미합니다. 그러나 "평균"이라는 단어에는 고조파 평균 , 기하 평균 , 산술 평균 , 2 차 평균 및 대차 평균을 포함 하여 더 많은 의미가 있습니다.

당신의 도전은 숫자 목록을 입력하고 그 5 가지 다른 수단을 출력하는 프로그램을 작성하는 것입니다. 또한 가능한 많은 언어로 프로그램을 작성하려고 합니다 . 대부분 언어 쇼케이스이기 때문에 언어에있는 모든 종류의 표준 라이브러리 함수를 사용할 수 있습니다.

입력

입력은 양수 목록입니다.

1,2,3,4,5
1.7,17.3,3.14,24,2.718,1.618
8.6
3,123456
10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
3,4,4,6.2,6.2,6.2

산출

출력은 위에 나열된 순서 (고조파, 기하, 산술, 2 차, 대조)의 5 가지 수단이됩니다. 편리하게는 순서를 늘리는 것과 같습니다.

2.18978,2.6052,3,3.31662,3.66667
3.01183,4.62179,8.41267,12.2341,17.7915
8.6,8.6,8.6,8.6,8.6
5.99985,608.579,61729.5,87296.6,123453.
5.95799,14.3041,22.5453,27.9395,34.6243
4.5551,4.74682,4.93333,5.10425,5.28108

I / O 형식에는 합리적인 수준의 leniency가 있지만 소수점 이하 몇 자리 정도의 정확성을 원합니다. 부동 소수점 출력을 원하므로 부동 소수점 입력을 가정 할 수 있습니다.

객관적인 승리 기준

객관적인 승리 기준은 다음과 같습니다. 각 언어는 가장 짧은 참가작을 작성할 수있는 사람에 대한 별도의 경쟁이지만 전체 우승자는 이러한 하위 경쟁을 가장 많이이기는 사람이됩니다. 이것은 많은 다른 언어로 대답하는 사람이 이점을 얻을 수 있음을 의미합니다. 코드 골프는 언어에 하나 이상의 솔루션이있을 때 가장 큰 걸림돌입니다.

동점이 있다면, 가장 많은 2 등을 한 사람이 승자가됩니다.

규칙, 제한 및 참고

귀하의 프로그램은 2014 년 9 월 2 일 이전에 존재했던 어떤 언어로도 작성 될 수 있습니다. 또한 저는 테스트를 할 수 없기 때문에 커뮤니티에 의존하여 좀 더 흔하지 않은 / 비언어적 언어로 작성된 일부 응답의 유효성을 검증해야합니다 그들.

하나의 답변 안에 포함 된 모든 다른 제출물을 보관하십시오.

또한 약간 다른 언어 방언으로 기본적으로 동일한 대답을 가진 shenanigans는 없습니다. 어떤 제출물이 충분히 다른지 판단 할 것입니다.

현재 리더 보드

이 섹션은 정기적으로 업데이트되어 언어의 수와 각 언어를 구사하는 사람을 보여줍니다.

• 알고 이드 (337)-베타 붕괴
• APL (42)-알고리즘
• 어크 (78)-데니스
• BBC 베이직 (155)-베타 붕괴
• C (136)-데니스
• C ++ (195)-제타
• C # (197)-마틴 부트 너
• CJam (43)-데니스
• 클로저 (324)-마이클 이스터
• 코브라 (132)-Ourous
• CoffeeScript (155)-마틴 부트 너
• 코모도 베이직 (104)-마크
• 커먼 리스프 (183)-DLosc
• 얼랭 (401)-마크
• 포트란 (242)-카일 카 노스
• 포트란 77 (286)-베타 붕괴
• GNU BC (78)-데니스
• GolfScript (83)-데니스
• 그루비 (157)-마이클 이스터
• 하스켈 (140)-제타
• J (28)-알고리즘
• 자바 (235)-마이클 이스터
• 자바 스크립트 (ES6) (112)-Dennis
• JRuby (538)-마이클 이스터
• 줄리아 (79)-마틴 부트 너
• 루아 (113)-안도 다안
• 마 테마 티카 (65)-마틴 부트 너
• MATLAB (63)-마틴 부트 너
• 옥타브 (68)-데니스
• Openscript (849?)-COTO
• 파스칼 (172)-마크
• 펄 (76)-그리미
• PHP (135)-데니스
• POV-Ray 3.7 (304)-마크
• 프롤로그 (235)-DLosc
• 피스 (52)-데니스
• 파이썬 2 (96)-데니스
• 파이썬 3 (103)-DLosc
• Q (53)-알고리즘
• Q'Nial (68)-알고리즘
• QBasic (96)-DLosc
• R (91)-플라나 푸스
• 루비 (118)-마틴 부트 너
• 녹 (469)-Vi.
• 스칼라 (230)-마이클 이스터
• T-SQL (122)-MickyT
• TI 기본 (85)-Ypnypn
• TypeScript (393)-링크 교환 원 .6
• VBA (엑셀) (387)-스트레치 미치광이
• wxMaxima (134)-카일 카 노스

현재 사용자 순위

1. 데니스 (10)
2. 마틴 부트 너 (6)
3. 마이클 이스터 (5)
4. Mark, DLosc, 알고리즘 상어 (4)
5. 베타 부패 (3)
6. 카일 카 노스 제타 (2)
7. Ourous, AndoDaan, COTO, Grimy, plannapus, Vi., MickyT, Ypnypn, rink.attendant.6, 스트레칭 미치광이 (1)

(위의 순위에서 실수를 한 경우 알려 주시면 해결하겠습니다. 또한 순위 결정이 아직 적용되지 않았습니다.)

언어 : 1

오픈 스크립트 (수백)

(수년 전에 프로그래밍하는 법을 배웠기 때문에 가장 좋아하는 애매하고 슬프게도 프로그래밍 언어가 마음에 들었습니다.;)

openFile "inputs.txt"
readFile "inputs.txt" to EOF

put it into my input_string

closeFile "inputs.txt"

local inputs[]

fill the inputs with my input_string in [item] order

put 0 into the harmonic_mean
put 0 into the geometric_mean
put 0 into the arithmetic_mean
put 0 into the quadratic_mean

put the length of the inputs into n

step i from 1 to n
    get inputs[i]
    increment the harmonic_mean by 1/it
    increment the geometric_mean by log( it )
    increment the arithmetic_mean by it
    increment the quadratic_mean by it*it
end

get "outputs.txt"
createFile it

writeFile n/harmonic_mean                & "," to it 
writeFile exp( geometric_mean/n )        & "," to it
writeFile arithmetic_mean/n              & "," to it
writeFile sqrt( quadratic_mean/n )       & "," to it
writeFile quadratic_mean/arithmetic_mean to it

closeFile it

언어 : 13

이 목록에는 최소한 간단한 문제를 해결하기에 충분히 잘 알고있는 모든 프로그래밍 언어가 포함되어야한다고 생각합니다. 새로운 언어를 살펴볼 때 시간이 지남에 따라이 목록을 완성하려고 노력할 것입니다. (내가 사용하는 일부 스몰 토크와 델파이를 알고,하지만 난 바로 느낌을 추가하는 정도까지보고해야 할 것이다.)

C, 196 190 171 165 바이트

main(int c,char**v){float n=c-1,x,h,g=1,q,a=h=q=0;for(;c-1;h+=1/x,g*=pow(x,1/n),a+=x/n,q+=x*x/n)sscanf(v[--c],"%f",&x);printf("%f,%f,%f,%f,%f",n/h,g,a,sqrt(q),q/a);}

입력을 개별 명령 행 인수로 읽고 쉼표로 구분 된 평균 목록을 STDOUT에 씁니다.

Quentin의 일부 개선에 감사드립니다.

C ++, 200 바이트

이것은 위의 C 코드와 동일하며 두 개의 포함입니다. 나는 C ++ 제출보다 오래 걸리기 때문에 이것을 포함하고 있습니다. 따라서 아무런 해를 끼치 지 않는 것 같습니다.이 게시물이 실제로 내가 아는 모든 언어를 포함하고 싶습니다. :)

#include <cmath>
#include <cstdio>
main(int c,char**v){float n=c-1,x,h,g=1,q,a=h=q=0;for(;c-1;h+=1/x,g*=pow(x,1/n),a+=x/n,q+=x*x/n)sscanf(v[--c],"%f",&x);printf("%f,%f,%f,%f,%f",n/h,g,a,sqrt(q),q/a);}

C #을 220 197 바이트

namespace System{using Linq;class F{double[]f(double[]l){double n=l.Length,a=l.Sum()/n,q=l.Sum(x=>x*x)/n;return new[]{n/l.Sum(x=>1/x),l.Aggregate((p,x)=>p*Math.Pow(x,1.0/n)),a,Math.Sqrt(q),q/a};}}}

클래스 List에서 두 배의 double을 가져 와서 다섯 가지 방법으로 double의 배열을 반환 하는 함수를 정의합니다 .

Visual Melon 및 Bob의 개선 사항에 감사드립니다.

CJam, 52 바이트

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

입력을 명령 행 인수로 가져 와서 5 개의 값이있는 목록을 STDOUT에 인쇄합니다.

CoffeeScript, 155 바이트

이것은 JavaScript 솔루션과 거의 동일하지만 처음에는 그런 이유로 계산하지 않았지만 OP는 점수 판에 포함 시켰으므로 전체 제출로 승격했습니다. 그들은 하다 결국 기술적으로 다른 언어.

f=(l)->l.r=l.reduce;n=l.length;[n/l.r(((s,x)->s+1/x),0),Math.pow(l.r(((p,x)->p*x),1),1/n),a=l.r(((s,x)->s+x),0)/n,Math.sqrt(q=l.r(((s,x)->s+x*x),0)/n),q/a]

자바 스크립트 (ES6) 155 153 바이트

f=l=>{l.r=l.reduce;n=l.length;return[n/l.r((s,x)=>s+1/x,0),Math.pow(l.r((p,x)=>p*x,1),1/n),a=l.r((s,x)=>s+x,0)/n,Math.sqrt(q=l.r((s,x)=>s+x*x,0)/n),q/a]}

숫자 배열을 취하고 5 개의 평균으로 배열을 반환하는 함수를 정의합니다.

William Barbosa에 대한 개선 사항에 감사드립니다.

줄리아, 79 바이트

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

숫자 목록을 가져 와서 다섯 가지 방법으로 목록을 반환하는 함수를 정의합니다.

루아, 120 바이트

f=function(l)h=0;q=0;a=0;g=1;for i=1,#l do x=l[i]h=h+1/x;a=a+x/#l;g=g*x^(1/#l)q=q+x*x/#l end;return#l/h,g,a,q^.5,q/a end

숫자 목록을 가져 와서 평균에 대해 5 개의 개별 값을 반환하는 함수를 정의합니다.

매스 매 티카, 73 67 65 바이트

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

부동 소수점 숫자의 목록을 가져 와서 다섯 가지 방법으로 목록을 반환하는 함수를 정의합니다.

재미있는 사실 : Mathematica에는 5 가지의 수단이 모두 내장되어 있지만 (제 원래의 제출물이었습니다) 그 중 3 개는 함수 이름보다 적은 문자로 구현할 수 있습니다.

Matlab, 65 63 바이트

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

사용자에게 입력을 숫자 배열로 요청하고 5 개의 평균을 개별적으로 출력합니다.

Dennis Jaheruddin에 대한 개선 사항에 감사드립니다.

PHP ≥ 5.4, 152 (149) 143 바이트

function f($l){$g=1;$n=count($l);foreach($l as$x){$q+=$x*$x/$n;$h+=1/$x;$g*=pow($x,1/$n);}return[$n/$h,$g,$a=array_sum($l)/$n,sqrt($q),$q/$a];}

이전과 동일한 기능 구현.

Ismael Miguel의 일부 개선에 감사드립니다.

파이썬 2, 127 바이트

def f(l):n=len(l);a=sum(l)/n;q=sum(x*x for x in l)/n;return[n/sum(1/x for x in l),reduce(lambda x,y:x*y,l)**(1./n),a,q**.5,q/a]

이전과 동일한 기능 구현.

루비, 129118 바이트

f=->l{n=l.size
r=->l{l.reduce :+}
[n/r[l.map{|x|1/x}],l.reduce(:*)**(1.0/n),a=r[l]/n,(q=r[l.map{|x|x*x}]/n)**0.5,q/a]}

이전과 동일한 기능 구현.

4 개 언어

J- 32 28 자!

숫자 목록을 유일한 인수로 취하는 함수입니다.

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

a 여기에 부사가 있는데, 이것은 J가 2 차 함수를 취하는 것입니다.

• +/ % # 는 J의 열차로, 합산의 합, 즉 산술 평균의 정의를 의미합니다.
• &.:아래라는 결합이다 u&.:v(y)동등 vi(u(v(y)))과 vi의 기능적 반전된다 v. 예, J는 기능 역수를 취할 수 있습니다 .
• 마지막으로, J의 유용한 기능은 특정 함수가 목록 전체를 자동으로 반복 할 수 있다는 것입니다. J는 인수 전체에 적용하는 것이 의미가 없다면이를 점으로 적용한다는 것을 알고 있기 때문입니다. 예를 들어리스트의 제곱은 제곱의리스트입니다.

따라서 a왼쪽에 함수를 취하고 함수에 의해 값을 "조정"하고 산술 평균을 취한 다음 조정을 되 돌리는 평균을 반환합니다.

• %a조화를 의미합니다. 왜냐하면 %역수를 의미하기 때문에 그 자체의 역수입니다.
• ^.a^.자연 대수이고 그 역수가 지수 이기 때문에 기하 평균 입니다.(Π x)^(1/n) = exp(Σ log(x)/n)
• [a[항등 함수 이기 때문에 산술 평균 입니다.
• *:a제곱 평균이기 때문에 2 차 평균이고, *:그 역은 제곱근입니다.
• 우리가 약간의 계산을 수행 contraharmonic 우리에게 문제가 평균으로 나눈 사각형의 전체 호스트 준다 평균을-그래서 그걸 얻기 위해 : ( *:a(로 나눈 [a으로 나눈 값 *:a)). 이것은 다음과 같습니다 [a(]%%)*:a. 우리가 그것을하는 동안, 우리는 각각의 수단을 앞에 붙 [a(,,]*%~)*:a입니다.

마지막으로 쉼표를 사용하여 나머지 결과를 함께 추가합니다. 연결이 (이 경우) 연관되어 있기 때문에 더 이상 parens가 필요하지 않습니다.

J REPL에서 사용 중 :

   (%a,^.a,[a(,,]%%)*:a=.+/%#&.:) 1,2,3,4,5   NB. used inline
2.18978 2.60517 3 3.31662 3.66667
   f =: %a,^.a,[a(,,]%%)*:a=.+/%#&.:          NB. named
   f 1.7,17.3,3.14,24,2.718,1.618
3.01183 4.62179 8.41267 12.2341 17.7915
   f 8.6
8.6 8.6 8.6 8.6 8.6
   f 3,123456
5.99985 608.579 61729.5 87296.6 123453
   f 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.95799 14.3041 22.5453 27.9395 34.6243
   f 3,4,4,6.2,6.2,6.2
4.5551 4.74682 4.93333 5.10425 5.28108

Q-53 자

단일 인수 함수. 우리는 우리가 원하는 모든 수단의 목록을 만듭니다.

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

다른 버전의 k에서도 같은 내용이 있습니다.

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

APL-42 자

인수로 함수 복용 목록.

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

폭발로 설명 :

{                                         } ⍝ function with argument ⍵
                                   +/÷≢     ⍝ Sum Divide Length, aka mean
                                 M←         ⍝ assign function to M for Mean
                              A←(M     )⍵   ⍝ arithmetic Mean, assign to A
                     (S←M⍵*2)               ⍝ Mean of squares, assign to S
                      S      ÷A             ⍝ S divide A, aka contraharmonic mean
              (S*.5)                        ⍝ sqrt(S), aka quadratic mean/RMS
                    ,                       ⍝ concatenate into a list
             A                              ⍝ prepend A (APL autoprepends to lists)
        *M⍟⍵                                ⍝ exp of Mean of logs, aka geometric
       (    )                               ⍝ prepend (auto)
  ÷M÷⍵                                      ⍝ recip of Mean of recips, aka harmonic
 (    )                                     ⍝ prepend (auto)

Q'Nial-68 자

당신은 이것을 좋아할 것입니다.

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

Q'Nial은 또 다른 배열 지향 언어, Nial 구현으로 , Haskell이 범주 이론을 기반으로하는 모호한 배열 이론을 기반으로합니다. ( 여기서 가져 가십시오 .) 다른 세 언어와는 매우 다릅니다. 우선 왼쪽에서 오른쪽으로 구문 분석합니다! 그러나 여전히 다른 언어보다 더 관련이 있습니다.

12 개 언어

CJam, 45 44 43 바이트

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

[1.0 2.0 3.0 4.0 5.0]STDIN에서 float 배열 (예 :)을 읽습니다 . 온라인으로 사용해보십시오.

APL, 67 61 53 52 50 바이트

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

온라인으로 사용해보십시오.

Pyth, 55 52 바이트

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

1 2 3 4 5STDIN에서 공백으로 구분 된 숫자 (예 :)를 읽습니다 .

옥타브, 68 바이트

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

shebang을 계산하지 않습니다. [1 2 3 4 5]STDIN에서 배열 (예 :)을 읽습니다 .

GNU BC, 78 바이트

#!/usr/bin/bc -l
while(i=read()){h+=1/i;g+=l(i);a+=i;q+=i*i;n+=1}
n/h;e(g/n);a/n;sqrt(q/n);q/a

shebang을 1 바이트로 계산합니다 ( -l스위치). STDIN에서 공백으로 분리 된 부동 소수점을 읽은 다음 0을 읽습니다.

어, 78 바이트

#!/usr/bin/awk -f
{h+=1/$0;g+=log($0);a+=$0;q+=$0^2;n++}END{print n/h,exp(g/n),a/n,(q/n)^.5,q/a}

shebang을 계산하지 않습니다. STDIN에서 한 줄에 하나의 숫자를 읽습니다.

GolfScript, 86 83 바이트

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

GolfScript는 플로트를 기본적으로 지원하지 않으므로 코드가 파싱합니다. 따라서, 입력 형식은 다소 제한적이다 : 당신이 입력을해야 1.0하고 0.1보다는 1, 1.또는 .1.

STDIN에서 플로트 (위에서 설명한대로)를 한 줄씩 읽습니다. 온라인으로 사용해보십시오.

펄, 90 85 바이트

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

shebang을 1 바이트로 계산합니다 ( -n스위치). STDIN에서 한 줄에 하나의 숫자를 읽습니다.

파이썬 2, 102 96 바이트

#!/usr/bin/python
h=a=q=n=0;g=1
for i in input():h+=1/i;g*=i;a+=i;q+=i*i;n+=1
print n/h,g**n**-1,a/n,(q/n)**.5,q/a

shebang을 계산하지 않습니다. 1.0,2.0,3.0,4.0,5.0STDIN에서 float 목록 (예 :)을 읽습니다 .

ECMAScript 6 (자바 스크립트), 114112 바이트

m=I=>{for(g=1,h=a=q=n=0,p=Math.pow;i=I.pop();h+=1/i,g*=i,a+=i,q+=i*i)n++;
return[n/h,p(g,1/n),a/n,p(q/n,.5),q/a]}

LF를 계산하지 않습니다. 배열 (예 :) [1,2,3,4,5]을 인수로 예상합니다 .

PHP, 135 (또는 108?) 바이트

#!/usr/bin/php
<?for($c=1;$c<$argc;$c++){$i=$argv[$c];$h+=1/$i;$g+=log($i);$a+=$i;$q+=$i*$i;$n++;}
print_r([$n/$h,exp($g/$n),$a/$n,sqrt($q/$n),$q/$a]);

shebang 또는 LF는 계산하지 않습니다. 부동 소수점을 명령 행 인수로 읽습니다.

더 짧은 솔루션이 있지만 바이트 수를 계산하는 방법을 모르겠습니다.

php -R '$i=$argn;$h+=1/$i;$g+=log($i);$a+=$argn;$q+=$i^2;$n++;' \
-E 'print_r([$n/$h,exp($g/$n),$a/$n,sqrt($q/$n),$q/$a]);'

각 코드 문자열의 바이트 수를 계산하고 for -Rand를 2 개 더하면 -E이 방법은 108 점을 얻습니다.

C, 172 140 139 137 136 바이트

float i,h,g=1,a,q,n;main(){for(;scanf("%f",&i)+1;n++)h+=1/i,g*=i,a+=i,q+=i*i;
printf("%f %f %f %f %f",n/h,pow(g,1/n),a/n,sqrt(q/n),q/a);}

LF를 계산하지 않습니다. 로 컴파일하십시오 gcc -lm. STDIN에서 공백으로 분리 된 수레를 읽습니다.

J (50) :

이것은 J가 잘하는 종류입니다.

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

언제나처럼 : 웃는 공장에서 폭발. : 그러나, 스마일 중 일부는이시기에 그대로 남았다 :)및 :*:이를 만드는 데 사용 된 내 대화 형 세션 (네 개의 눈을 가진 남자와 그의 얼굴에 박힌 보석이 있다는) : http://pastebin.com/gk0ksn2b

실제로 :

   f=:(#%+/@:%),(#%:*/),(+/%#),%:@(%@#*+/@:*:),+/@:*:%+/
   f 1,2,3,4,5
2.18978 2.60517 3 3.31662 3.66667
   f 1.7,17.3,3.14,24,2.718,1.618
3.01183 4.62179 8.41267 12.2341 17.7915
   f 8.6
8.6 8.6 8.6 8.6 8.6
   f 3,123456
5.99985 608.579 61729.5 87296.6 123453
   f 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.95799 14.3041 22.5453 27.9395 34.6243
   f 3,4,4,6.2,6.2,6.2
4.5551 4.74682 4.93333 5.10425 5.28108

설명:

예상 한대로 실제로 포크와 후크로 구성된 목록에 번들로 제공되는 5 개의 기능이 있습니다. (걱정하지 마십시오. 여러 함수를 단일 목록으로 출력하는 편리한 방법 일뿐입니다).

J 가이 답변을 생성하게하는 데 사용한 줄이 약간 더 명확 할 수 있습니다.

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

그것들을 따로 살펴 보자.

고조파

(# % +/@:%)

• # -길이 (어레이의)
• % - 로 나눈
• +/@:%- 나누기 상단 의 합 ( +/, 또는 겹치기 +( +/1 2 3 4== 1+2+3+4)), 그러나 이번에는 monadic 경우입니다. 여기서 의미하는 것은 J가 자동으로 1이 가장 유용한 값이라고 "추측"한다는 것입니다.

기하

(# %: */)

• # -길이 (어레이의)
• %:-루트 ( 4 %: 7'7의 네 번째 (또는 tesseract) 루트'를 의미 함)
• */-제품 ( */과 의미가 비슷 +/합니다. 이전 기능 참조)

산수

(+/ % #)

• +/ -합, 지금은 익숙해야한다
• % - 로 나눈
• # -길이

제곱 평균 제곱

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

흠 ...

• %: -의 뿌리
  • %@# -길이의 역
  • * -시간
  • +/@:*:-제곱의 합 ( *:제곱도 마찬가지 *~입니다.)

대조적

+/@:*: % +/

• +/@:*: -제곱의 합
• % - 로 나눈
• +/ -합계

실제로 이것을 설명함으로써 내 함수가 1 바이트 2 바이트 라는 것을 알았습니다 . 그래서 좋습니다!

J가 현을 처리하는 데 능숙하다면 우리는 더 많은 골프 대회에서 우승 할 것입니다 ...

언어 : 5

POV-Ray 3.7 장면 설명 언어 : 304 바이트

#fopen I"i"read#declare S=0;#declare N=0;#declare Q=0;#declare P=1;#declare R=0;#while(defined(I))#read(I,V)#declare S=S+V;#declare N=N+1;#declare Q = Q+V*V;#declare P=P*V;#declare R=R+1/V;#end#warning concat(str(N/R,0,5),",",str(pow(P,1/N),0,5),",",str(S/N,0,5),",",str(sqrt(Q/N),0,5),",",str(Q/S,0,5))

(POV-Ray SDL에는 콘솔 입력 기능이 없으므로 파일 입력을 대체했습니다. 출력은 콘솔로 보내지지만 많은 프로그램 상태 출력으로 둘러싸여 있습니다.)

코모도 베이직 : 111104 바이트

1 P=1:O┐1,0
2 I/#1 V:IF V=0T|G┌4
3 S=S+V:N=N+1:Q=Q+V*V:P=P*V:R=R+1/V:G┌2
4 ?N/R,P↑(1/N),S/N,(Q/N)↑.5,Q/S

(이 프로그램의 모든 문자를 유니 코드로 표현할 수있는 것은 아닙니다. |표현 SHIFT+H, ┌표현 SHIFT+O, ┐표현 SHIFT+P, /표현 하는 데 사용됩니다 SHIFT+N. Commodore Basic I / O의 한계로 인해 입력은 한 번에 하나씩 입력됩니다. -1은 입력의 끝을 나타내며 출력은 탭으로 구분됩니다.)

Q 기본 : 96 바이트

P=1:INPUT V:WHILE V:S=S+V:N=N+1:Q=Q+V*V:P=P*V:R=R+1/V:INPUT V:WEND:?N/R;P^(1/N);S/N;(Q/N)^.5;Q/S

DLosc의 항목과 동일한 I / O 체계를 사용합니다. INPUT V빈 줄이 입력 될 때 (적어도 MS-DOS QBasic 1.1에서-QB64에서도 작동하는지 모르겠습니다) 0 을 반환 하는 사실을 사용하여 15 바이트 를 골랐습니다.

파스칼 (FPC 컴파일러) : 172 바이트

program M;uses math;var v,p,s,n,q,r:real; begin p:=1;while not eoln do begin read(v);s:=s+v;n:=n+1;q:=q+v*v;p:=p*v;r:=r+1/v end;write(n/r,p**(1/n),s/n,(q/n)**0.5,q/s);end.

입력은 쉼표가 아닌 공백으로 구분되며 줄 바꿈으로 끝납니다. 출력은 공백으로 구분됩니다.

얼랭 : 401 바이트

-module(means).
-import(io).
-import(math).
-import(string).
-import(lists).
-export([means/6]).

means(S,N,Q,P,R,[]) -> io:fwrite("~f,~f,~f,~f,~f~n", [N/R,math:pow(P,(1/N)),S/N,math:sqrt(Q/N),Q/S]);
means(S,N,Q,P,R,[V|T]) -> means(S+V,N+1,Q+V*V,P*V,R+1/V,T).

means:means(0,0,0,1,0,lists:map(fun({F,R}) -> F end, lists:map(fun(X) -> string:to_float(X) end, string:tokens(io:get_line(""), ",\n")))).

Erlang의 문자열 처리는 막대한 고통입니다. 따라서, 모든 부동 소수점 숫자는 소수점 이후 적어도 하나 개의 숫자로 입력해야합니다 - string:to_float/1변환하지 않습니다 1,하지만 변환합니다 1.0.

(특히 부동 소수점 연산이나 I / O가없는 언어 인 RoboTalk 에서이 작업을 수행하는 방법을 알고 있다면 더 나올 것입니다)

언어 : 3

다른 언급이없는 한 숫자는 공백으로 구분해야합니다.

C : 181 163

입력이 끝날 때까지 숫자를받습니다.

#include<math.h>
main(){double h=0,g=1,a=0,q=0,k,n=0;for(;scanf("%lf",&k);++n)h+=1/k,g*=k,a+=k,q+=k*k;printf("%f %f %f %f %f\n",n/h,pow(g,1/n),a/n,sqrt(q/n),q/a);}

(ISO) C ++ : 195

입력이 끝날 때까지 숫자를받습니다.

#include<iostream>
#include<cmath>
int main(){double h=0,g=1,a=0,q=0,k,n=0;for(;std::cin>>k;++n)h+=1/k,g*=k,a+=k,q+=k*k;std::cout<<n/h<<" "<<pow(g,1/n)<<" "<<a/n<<" "<<sqrt(q/n)<<" "<<q/a<<"\n";}

하스켈 : 185 180 164 159 149 140

개행 문자로 구분 된 수많은 숫자 목록을 임의로 취합니다.

이행

m=map
f x=let{s=sum;n=s$m(\_->1)x;t=s$m(^2)x}in[n/s(m(1/)x),product x**(1/n),s x/n,sqrt$t/n,t/s x]
main=getLine>>=print.f.m read.words>>main

50 41 (감사합니다) 바이트는 IO : /에만 해당됩니다.

예

(Powershell의 echo일명 Write-Output은 모든 매개 변수를 한 줄에 인쇄합니다)

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

언어-4

나는 항상 좋은 오래된 것을 뽑아 변명을 사랑

QBasic, 112 96 바이트

g=1:INPUT x:WHILE x:h=h+1/x:g=g*x:a=a+x:q=q+x^2:n=n+1:INPUT x:WEND:?n/h;g^(1/n);a/n;SQR(q/n);q/a

QBasic은 가변적 인 입력 수에 적합하지 않으므로 프로그램은 한 줄에 하나의 숫자가 필요하며 0으로 끝나거나 빈 줄로 종료됩니다. 출력은 공백으로 구분됩니다.

(0은 유효한 숫자가 아니며 입력 종료에 사용될 수 있음을 알게되면 단축됩니다.)

QB64를 사용하여 테스트 :

공통 리스프, 183 바이트

(defun m(l)(let((a(apply #'+ l))(q(apply #'+(map'list #'(lambda(x)(* x x))l)))(n(length l)))(list(/ n(apply #'+(map'list #'/ l)))(expt(apply #'* l)(/ n))(/ a n)(sqrt(/ q n))(/ q a))))

어떤 이유로 나는 이것이 더 짧을 것으로 예상했다. 저는 Lisp 전문가가 아니므로 팁을 주시면 감사하겠습니다. 언 골프 버전 :

(defun means (l)
  (let ((a (apply #'+ l))                                    ; sum of numbers
        (q (apply #'+ (map 'list #'(lambda (x) (* x x)) l))) ; sum of squares
        (n (length l)))
    (list                                 ; Return a list containing:
      (/ n (apply #'+ (map 'list #'/ l))) ; n over sum of inverses
      (expt (apply #'* l) (/ n))          ; product to the power of 1/n
      (/ a n)                             ; a/n
      (sqrt (/ q n))                      ; square root of q/n
      (/ q a)                             ; q/a
    )
  )
)

아마도 테스트하는 가장 좋은 방법은 clisp다음과 같이 함수를 REPL 에 붙여 넣는 것입니다.

$ clisp -q
[1]> (defun m(l)(let((a(apply #'+ l))(q(apply #'+(map'list #'(lambda(x)(* x x))l)))(n(length l)))(list(/ n(apply #'+(map'list #'/ l)))(expt(apply #'* l)(/ n))(/ a n)(sqrt(/ q n))(/ q a))))
M
[2]> (m '(1 2 3 4 5))
(300/137 2.6051712 3 3.3166249 11/3)
[3]> (m '(8.6))
(8.6 8.6 8.6 8.6 8.6)
[4]> (m '(3 123456))
(246912/41153 608.5787 123459/2 87296.58 5080461315/41153)

나는 Lisp가 두 정수를 나눌 때 수레 대신 정확한 분수를 사용하는 방법을 좋아합니다.

프롤로그, 235 바이트

프롤로그는 수학에 능숙하지 않지만 어쨌든 사용할 것입니다. SWI-Prolog로 테스트되었습니다. 나는 sumlist술어가 표준 프롤로그가 아니라고 생각 하지만 어쨌든 그것을 사용하고 있습니다.

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

언 골프 드 :

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

% Helper predicates:

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

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

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

Linux에서 파일이라는 코드를 사용하여 means.pro다음과 같이 테스트하십시오.

$ swipl -qs means.pro
?-  m([1,2,3,4,5],H,G,A,Q,C).
H = 2.18978102189781,
G = 2.605171084697352,
A = 3,
Q = 3.3166247903554,
C = 3.6666666666666665.

숫자가 하나만있을 때 정확하지만 재미있는 결과를 제공합니다.

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

파이썬 3, 103 바이트

h=a=q=n=0;g=1
for x in eval(input()):h+=1/x;g*=x;a+=x;q+=x*x;n+=1
print(n/h,g**(1/n),a/n,(q/n)**.5,q/a)

Dennis의 Python 2 버전 과 동일한 전략 입니다. 쉼표로 구분 된 숫자 목록을 가져옵니다. int와 float를 모두 처리합니다. 단일 숫자 입력은 대괄호로 묶어야하며 숫자 목록은 항상 있을 수 있습니다. 수정에는 4 바이트가 필요합니다.

8 개 언어

포트란 77-286

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

BBC 베이직-131

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

산출:

5 
5
100
12
15
1
9.7914836236097695 26.600000000000001 45.596052460711988 78.15789473684211  

C ++-292

#include <iostream>
#include <cmath>
using namespace std;int main(){cout << "Length of sequence?: ";cin >> l;int b=0;int d=1;int e=0;int f=0;int j;int seq[l];for(int i=0;i<l;i++){cin >> j;b+=1/j;d*=j;e+=j;f+=pow(j,2);}
    h=l/b;g=pow(d,(1/l));a=e/l;q=pow((f/l),0.5);c=f/e;cout << h,g,a,q,c;}

파이썬 3-151

s=input().split(',');l=len(s);b=0;d=1;e=0;f=0
for i in s:i=float(i);b+=1/i;d*=i;e+=i;f+=i**2
h=l/b;g=d**(1/l);a=e/l;q=(f/l)**0.5;c=f/e
print(h,g,a,q,c)

산출:

5,100,12,15,1       # Input
3.6764705882352944 9.7914836236097695 26.600000000000001 45.596052460711988 78.15789473684211

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

자바 스크립트-231

저는 Javascripter가 아니므로 팁을 주시면 감사하겠습니다.

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

알고 이드-337

구글 플레이 스토어 또는 라즈베리 파이 스토어 에서 찾아보세요

text.clear();
set l=text.inputNumber("Length of sequence?: ");set b=0;set d=1;set e=0;set f=0;set seq=array{};
for(set i=1; i<=l; i++){set j=text.inputNumber(i..": ");b+=1/j;d*=j;e+=j;f+=math.pow(j,2);}
set h=l/b;set g=math.pow(d,(1/l));set a=e/l;set q=math.sqrt(f/l);set c=f/l;set str=h.." "..g.." "..a.." "..q.." "..c;text.output(str);

var'aQ-376

이것은 구문 상으로는 정확하지만 모든 현재 통역사 는 작동하지 않습니다 ...

0 ~ b cher
1 ~ d cher
0 ~ e cher
0 ~ f cher
'Ij mI'moH ~ l cher
l {
    'Ij mI'moH ~ j cher
    b 1 j wav boq ~ b cher
    d j boq'egh ~ d cher
    e j boq ~ e cher
    f j boqHa'qa boq ~ f cher
} vangqa'
l b boqHa''egh ~ h cher
d 1 l boqHa''egh boqHa'qa  ~ g cher
e l boqHa''egh ~ a cher
f l boqHa''egh loS'ar ~ q cher
f e boqHa''egh c cher
h cha'
g cha'
a cha'
q cha'
c cha'

언어 : 3

CJam, 58

qS%:d:A{1\/}%:+A,\/SA:*1.A,/#SA:+A,/:BSA{2#}%:+A,/:CmqSCB/

TI 기본, 85

Input L1:{dim(L1)/sum(1/(L1),dim(L1)√prod(L1),mean(L1),√(mean(L1²)),mean(L1²)/mean(L1

자바, 457

import java.util.*;class C{public static void main(String[]s){List r=new ArrayList();double[]d=Arrays.stream(new Scanner(System.in).nextLine().split(",")).mapToDouble(Double::new).toArray();double x=0,y,z;for(double D:d){x+=1/D;}r.add(d.length/x);x=1;for(double D:d){x*=D;}r.add(Math.pow(x,1./d.length));r.add(y=Arrays.stream(d).average().getAsDouble());x=1;for(double D:d){x+=D*D;}r.add(Math.sqrt(z=x/d.length));r.add(z/y);r.forEach(System.out::println);}}

언어-2

코브라-132

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

파이썬-129

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

1 개 언어

R, 92 (91)

f=function(x){n=length(x);s=sum;d=s(x^2);c(n/s(1/x),prod(x)^(1/n),mean(x),(d/n)^.5,d/s(x))}

값의 벡터를 취하고 평균의 벡터를 출력합니다.

1 언어

골프 스크립트, 162

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

그렇습니다. 그리고 확실히 작게 만들 수 있습니다. 나중에 언젠가 할 것입니다. 여기서 사용해보십시오 .

입력이 개행으로 분리 될 것으로 예상합니다. 그것이 허용되지 않으면, 그것을 고칠 것입니다 (+ 2 문자). 리스트 개행을 분리하여 출력합니다.

약간 더 읽기 쉬운 버전이 있습니다 :

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

언어 2

포트란 : 242

명확성을 위해 골프를 풀었지만 골프 버전이 계산됩니다. 먼저 추가 할 값 수를 입력 한 다음 값을 입력해야합니다.

program g
   real,allocatable::x(:)
   read*,i
   allocate(x(i));read*,x
   print*,m(x)
 contains
   function m(x) result(p)
      real::x(:),p(5)
      n=size(x)
     p(1:4)=[n/sum(1/x),product(x)**(1./n),sum(x)/n,sqrt(sum(x**2)/n)]
     p(5)=p(4)**2/p(3)
   endfunction
end

wxMaxima 134

이것을 편집기에 복사 ctrl+enter한 다음 via m([1,2,3,4,5]),numer를 호출하여 부동 소수점 출력을 얻습니다 (그렇지 않으면 기호 출력을 얻습니다).

m(x):=block([n:length(x),d:0,c:mean(x)],for i:1 thru n do(g:x[i],d:d+g*g),return([1/mean(1/x),apply("*",x)^(1/n),c,sqrt(d/n),d/n/c]));

펄, 86 76

$,=$";$h+=1/uc,$g+=log,$a+=lc,$q+=$_**2for<>;print$./$h,exp$g/$.,$a/$.,sqrt$q/$.,$q/$a

입력 : 라인 당 하나의 숫자.

편집 : 이것은 한 문자 더 길지만 분명히 shebang 행은 총계로 계산되지 않으므로 더 좋아집니다.

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

T-SQL, 136 122

숫자 S를 표 S에 저장하면 I (정수)로 목록을 식별하고 V (부동)로 값을 지정합니다.

SELECT COUNT(*)/SUM(1/V),EXP(SUM(LOG(V))/COUNT(*)),AVG(V),SQRT((1./COUNT(*))*(SUM(V*V))),SUM(V*V)/SUM(V) FROM S GROUP BY I

SQLFiddle

Alchymist 덕분에 14 절약

언어 : 5

일부 항목은 float / double 대신 Java의 BigDecimal을 사용하여 반올림 오류 (소수점 4 자리)를 피하기 위해 노력하고 OP 당 IO 규칙을 승인합니다.

최신 항목은 IO 규칙과 BigDecimal을 모두 완화합니다.

당연 - 409 개 400 164 157 문자

float i=0,j=1,k=0,l,n=0,m=0,p;args.each{x=it as float;i+=1/x;j*=x;k+=x;m+=x*x;n++};l=k/n;p=m/n;println "${n/i},${Math.pow(j,1f/n)},$l,${Math.sqrt p},${p/l}"

샘플 실행 :

bash$ groovy F.groovy 10.1381 29.8481 14.7754 9.3796 44.3052 22.2936 49.5572 4.5940 39.6013 0.9602
5.957994213465398,14.304084339049883,22.545269,27.939471625408938,34.62429631138658

자바 - 900 개 235 문자

class F{public static void main(String[]a){float i=0,j=1,k=0,l,n=0,m=0,p;for(String s:a){float x=Float.valueOf(s);i+=1/x;j*=x;k+=x;m+=x*x;n++;}l=k/n;p=m/n;System.out.println(n/i+","+Math.pow(j,1f/n)+","+l+","+Math.sqrt(p)+","+p/l);}}

샘플 실행 :

bash$ java F 10.1381 29.8481 14.7754 9.3796 44.3052 22.2936 49.5572 4.5940 39.6013 0.9602
5.957994,14.304084906138343,22.545269,27.939471625408938,34.6243

Clojure의 - (524 개) 324 문자

(defn r[x](/ (reduce + 0.0 x)(count x)))
(defn s[x](reduce #(+ %1 (* %2 %2)) 0.0 x))
(defn f[x](let[n (* 1.0 (count x))][(/ n(reduce #(+ %1 (/ 1.0 %2)) 0.0 x))(Math/pow(reduce * x)(/ 1.0 n))(r x)(Math/sqrt(/(s x) n))(/(/(s x) n)(r x))]))
(doseq [x(f(map #(Float/valueOf %) *command-line-args*))](print(str x ",")))
(println)

샘플 실행 (마지막 끝에 쉼표가 있음) :

bash$ java -jar clojure-1.6.0.jar m2.clj 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.957994368133907,14.30408424976292,22.545269936323166,27.93947151073554,34.62429460831333,

스칼라 - 841 개 663 230 문자

import java.math._
object F{def main(a:Array[String]){
var i,j,k,l,m,p=0f;var n=0
a.foreach{y=>var x=y.toFloat;i+=1/x;j*=x;k+=x;m+=x*x;n+=1}
l=k/n;p=m/n;System.out.println(n/i+","+Math.pow(j,1f/n)+","+l+","+Math.sqrt(p)+","+p/l)}}

샘플 실행 :

bash$ scala F.scala 10.1381 29.8481 14.7754 9.3796 44.3052 22.2936 49.5572 4.5940 39.6013 0.9602
5.957994,0.0,22.545269,27.939471625408938,34.6243

JRuby-538 자

JRuby가 Ruby와 다른지 확실하지 않습니다. JVM에서 실행해야합니다. 그러나 그것은 루비 구문입니다. 어느 쪽이든, 나는 Rosetta Stone의 정신에 그것을 포함시키고 있습니다.

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

샘플 실행 (stderr에 경고를 인쇄 함) :

bash$ jruby Mean.rb 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.95781,14.30408436301878,22.54527,27.939471541172715,34.62430

언어 1

루아-113

e=arg s=#e h,g,a,r=0,1,0,0 for i=1,s do x=e[i]h=h+1/x g=g*x a=a+x/s r=r+x^2/s end print(s/h,g^(1/s),a,r^.5,r/a)

언어-1

멋진, 근사한:

def input = [1.7,17.3,3.14,24,2.718,1.618];
def arithmeticMean
def harmonicMean
def geometricMean
def quadraticMean
def contraharmonicMean

def sum = 0
def product = 1
// Arithmetic Mean
for(each in input){
    sum += each
}
arithmeticMean = sum / input.size()

// Harmonic Mean
sum = 0
for(each in input){
    sum += (1/each)
}
harmonicMean = input.size() / sum

// Geometric Mean
for(each in input){
    product *= each
}
geometricMean = Math.pow(product,1/input.size());

// Quadratic Mean
sum = 0
for(each in input){
    sum += (each*each)
}
quadraticMean = Math.pow(sum/input.size() ,(1/2))

// Contraharmonic Mean
sum = 0
def sum2 = 0
for( each in input ){
    sum += each
    sum2 += (each * each)
}
contraharmonicMean = (sum2/input.size()) / (sum/input.size())

println "Arithmetic Mean: $arithmeticMean"
println "Harmonic Mean: $harmonicMean"
println "Geometric Mean: $geometricMean"
println "Quadratic Mean: $quadraticMean"
println "Contraharmoic Mean: $contraharmonicMean"

2 개 언어

자바-243 바이트

class M{public static void main(String[]a){float h=0,l=a.length,p=1,s=0,q=0;for(int i=0;i<l;i++){float v=Float.valueOf(a[i]);q+=v*v;s+=v;h+=1/v;p*=v;}System.out.println(l/h+"\n"+Math.pow(p,1.0/l)+"\n"+s/l+"\n"+Math.sqrt((1.0/l)*q)+"\n"+q/s);}}

넓히는:

class Means {
    public static void main(String[] a) {
        float h = 0, l = a.length, p = 1, s = 0, q = 0;
        for (int i = 0; i < l; i++) {
            float v = Float.valueOf(a[i]);
            q += v * v;
            s += v;
            h += 1 / v;
            p *= v;
        }
        System.out.println(l / h + "\n" + Math.pow(p, 1.0 / l) + "\n" + s / l
                + "\n" + Math.sqrt((1.0 / l) * q) + "\n" + q / s);
    }
}

vba-엑셀, 387 바이트

첫 번째 열에 값을 입력 한 다음이 코드를 트리거하는 버튼을 누르면 두 번째 열에 값이 출력됩니다.

Private Sub a_Click()
Dim d,s,q,h,p As Double
Dim y As Integer
h=0
q=0
s=0
p=1
y=1
While Not IsEmpty(Cells(y,1))
s=s+Cells(y,1)
q=q+Cells(y,1)*Cells(y,1)
h=h+1/Cells(y,1)
p=p*Cells(y,1)
y=y+1
Wend
y=y-1
Cells(1,2)=y/h
Cells(2,2)=p^(1/y)
Cells(3,2)=s/y
Cells(4,2)=((1/y)*q)^0.5
Cells(5,2)=q/s
End Sub

1 개 언어

녹-469

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

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

언 골프 버전 :

use std::io;
use std::from_str::from_str;
use std::num;

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

playrust 에서 테스트하기 위해 루프 또는 입력이없는 압축 된 430 바이트 버전 :

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

최신 Rust를 위해 업데이트 :

언 골프 드 :

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

골프 (402 바이트) :

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

언어 : 4

CoffeeScript, 193

쉼표로 구분 된 입력 문자열을받습니다.

m=(q)->m=Math;q.r=q.reduce;q=q.split(',').map Number;l=q.length;x=q.r ((p,v)->(p+v)),0;y=q.r ((p,v)->(p+v*v)),0;[l/q.r(((p,v)->(p+1/v)),0),m.pow(q.r(((p,v)->(p*v)),1),1/l),x/l,m.sqrt(y/l),y/x];

자바 스크립트 (ES5), 256

다시 쉼표로 구분 된 입력 문자열을 사용합니다.

function m(q){m=Math,q=q.split(',').map(Number),q.r=q.reduce,l=q.length,x=q.r(function(p, v){return p+v;},0),y=q.r(function(p,v){return p+v*v},0);return[l/q.r(function(p,v){return p+1/v},0),m.pow(q.r(function(p,v){return p*v},1),1/l),x/l,m.sqrt(y /l),y/x]}

PHP, 252

같은 개념 :

<?function m($q){$r=array_reduce;$q=explode(',',$q);$l=count($q);$x=array_sum($q);$y=$r($q,function($p,$v){return $p+$v*$v;});return[$l/$r($q,function($p,$v){return $p+1/$v;}),pow($r($q,function($p,$v){return $p*$v;},1),1/$l),$x/$l,sqrt($y/$l),$y/$x];}

TypeScript, 393 *

TypeScript는 JavaScript의 상위 집합이므로 방금 동일한 코드를 제출했지만 실제로는 공정하지 않습니다. 모든 함수, 변수 및 매개 변수가 완전히 입력 된 축소 된 TypeScript 코드는 다음과 같습니다.

function m(q:String):number[]{var a:number[]=q.split(',').map(Number),l:number=a.length,x:number=a.reduce(function(p:number,v:number):number{return p+v},0),y:number=a.reduce(function(p:number,v:number):number{return p+v*v},0);return[l/a.reduce(function(p:number,v:number):number{return p+1/v},0),Math.pow(a.reduce(function(p:number,v:number):number{return p*v},1),1/l),x/l,Math.sqrt(y/l),y/x]}

유형 any을 속이고 사용했을 수도 있지만 ...

엑셀-120

이것이 "프로그래밍"언어로 간주되는지 확실하지 않지만 사람들이 실제로 이런 유형의 스프레드 시트를 사용할 수 있다고 생각했습니다.

A2 : J2의 숫자로

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

VBA (엑셀)-105

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

언 골프 :

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

이 코드는 즉시 창에서 실행해야하며 배열은 i 로 호출되어야합니다 . 오류 수집, 정리, 변수 삭제 / 해제가 없으므로이 코드를 테스트하려면 다음 코드를 사용할 수 있습니다 (바로 창에 붙여넣고 순서대로 행을 실행하십시오).

b=0:c=0:d=0:set i = nothing:i= array(1,2,3,4,5)
a=1:for each n in i:a=a*n:b=b+1/n:c=c+n:d=d+n*n:next:x=ubound(i)+1:?x/b","a^(1/x)","c/x","(d/x)^0.5","d/c

매우 특별한 것은 없으며, 바로 다음 창을 사용하여 선택하는 것입니다 . 줄 바꿈을 대체하여 하위 또는 함수를 설정하고 닫는 것보다 몇 바이트를 절약합니다. 사용하여? debug.print 대신 인쇄 (즉시 창에서만); vba가 암시 적 값을 결정하는 방법 (값을 설정하지 않은 변수에 추가하면 값을 반환 함)과 암시 적 연산 (문자열과 관련된 것은 암시 적으로 연결됨)에 의존합니다.