Languages: 1

Openscript (many hundreds)

(My favourite obscure and sadly defunct programming language, because I learned to program on it many years ago. ;)

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

• 21
  \$\begingroup\$ put the length of the inputs into n? O_O I love this language already. \$\endgroup\$

  DLosc

  – DLosc

  2014年09月03日 01:57:26 +00:00

  Commented Sep 3, 2014 at 1:57
• 2
  \$\begingroup\$ The syntax reminds me of Chef. \$\endgroup\$

  Comintern

  – Comintern

  2014年09月03日 03:27:08 +00:00

  Commented Sep 3, 2014 at 3:27
• 2
  \$\begingroup\$ The syntax reminds me of COBOL. \$\endgroup\$

  Amadan

  – Amadan

  2014年09月03日 04:11:25 +00:00

  Commented Sep 3, 2014 at 4:11
• 3
  \$\begingroup\$ For an even more extreme (and usage specific) "natural" looking language, check out Inform 7. \$\endgroup\$

  Beska

  – Beska

  2014年09月03日 12:41:46 +00:00

  Commented Sep 3, 2014 at 12:41
• 3
  \$\begingroup\$ inform 7 is a real language - it's just that the I/O is a text adventure. People have written chess engines in it and Dijkstra's shortest path is at: en.literateprograms.org/Dijkstra's_algorithm_(Inform_7) \$\endgroup\$

  Jerry Jeremiah

  – Jerry Jeremiah

  2014年09月07日 10:41:12 +00:00

  Commented Sep 7, 2014 at 10:41

Languages: 13

I think this list should now contain every programming language that I know sufficiently well to solve at least simple problems in. I'll try to keep this list complete over time as I look into some new languages. (I used to know some Smalltalk and Delphi, but I'd have to look up to much for adding them to feel right.)

C, (削除) 196 (削除ここまで) (削除) 190 (削除ここまで) (削除) 171 (削除ここまで) 165 bytes

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

Reads the input as individual command line arguments and writes a comma-separated list of the means to STDOUT.

Thanks for some improvements to Quentin.

C++, 200 bytes

This is the same as the above C code, plus two includes. I'm including this because it's longer than the winning C++ submission, so I guess no harm is done, and I'd like this post to actually contain every language I know. :)

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

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

Defines a function in a class taking a List of doubles and returning an array of doubles with the five means.

Thanks for some improvements to Visual Melon and Bob.

CJam, 52 bytes

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

Takes the input as command-line arguments and prints a list with the five values to STDOUT.

CoffeeScript, 155 bytes

This is almost the same as the JavaScript solution further down (and initially I didn't count it for that reason), but the OP included it in the scoreboard anyway, so I promoted it to a full submission. They are technically different languages after all.

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 bytes

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

Defines a function taking a array of numbers and returning a array with the five means.

Thanks for some improvements to William Barbosa.

Julia, 79 bytes

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

Defines a function taking a list of numbers and returning a list with the five means.

Lua, 120 bytes

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

Defines a function taking a list of numbers and returning 5 separate values for the means.

Mathematica, (削除) 73 (削除ここまで) (削除) 67 (削除ここまで) 65 bytes

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

Defines a function taking a list of floating point numbers and returning a list with the five means.

Fun fact: Mathematica has all 5 means built in (and that was my original submission), but three of them can be implemented in fewer characters than their function names.

Matlab, (削除) 65 (削除ここまで) 63 bytes

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

Requests the input as an array of numbers from the user and outputs the five means individually.

Thanks for some improvements to Dennis Jaheruddin.

PHP ≥ 5.4, (削除) 152 (削除ここまで) (削除) 149 (削除ここまで) 143 bytes

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

Same functional implementation as the earlier ones.

Thanks for some improvements to Ismael Miguel.

Python 2, 127 bytes

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]

Same functional implementation as the earlier ones.

Ruby, (削除) 129 (削除ここまで) 118 bytes

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

Same functional implementation as the earlier ones.

• \$\begingroup\$ I realize this is quite after the fact, but you can lose 3 Julia bytes by using norm(l)/n^.5 in place of norm(l)/sqrt(n). \$\endgroup\$

  Alex A.

  – Alex A.

  2015年03月31日 18:55:54 +00:00

  Commented Mar 31, 2015 at 18:55

4 languages

J - (削除) 32 (削除ここまで) 28 char!

A function taking the list of numbers as its sole argument.

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

a here is an adverb, which is J's take on second-order functions.

• +/ % # is a train in J, meaning Sum Divided-by Count, the definition of the arithmetic mean.
• &.: is a conjunction called Under, where u&.:v(y) is equivalent to vi(u(v(y))) and vi is the functional inverse of v. Yes, J can take functional inverses.
• Finally, a useful feature of J is that certain functions can automatically loop over lists, because J knows to apply them pointwise if it wouldn't make sense to apply them on the whole argument. So the square of a list is a list of the squares, for instance.

Thus a takes a function on the left, and returns a mean that "adjusts" the values by the function, takes the arithmetic mean, and then reverses the adjustment afterwards.

• %a is the harmonic mean, because % means Reciprocal, and is its own inverse.
• ^.a is the geometric mean, because ^. is the natural logarithm and its inverse is the exponential. (Π x)^(1/n) = exp(Σ log(x)/n)
• [a is the arithmetic mean, because [ is the identity function.
• *:a is the quadratic mean, because *: is Square, and its inverse is the square root.
• The contraharmonic gives us a whole host of trouble—mean of the squares divided by mean—so we do a little math to get it: (*:a divided by ([a divided by *:a)). This looks like [a(]%%)*:a. While we're at it, we prepend each of the means, [a(,,]*%~)*:a.

Finally, we use commas to append the rest of the results together. We require no further parens because concatenation is (in this case at least) associative.

In use at the 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

Single argument function. We just make a list of all the means we want.

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

The same thing in other versions of k is below.

• 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

Function taking list as argument.

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

Explained by explosion:

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

You're going to love this one.

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

Q'Nial is another array-oriented language, an implementation of Nial, which is based on an obscure Array Theory in the sam way Haskell is based on category theory. (Get it here.) It's very different from any of the other three—it parses left-to-right, first of all!—but it is still more related to them than to any other languages.

• \$\begingroup\$ I knew there was a better way to do this in APL. So I can deference a variable I defined at its right; wouldn't have thought of that myself... -- That J code is impressive! Every time I see one of your answers, I say to myself You have to learn that language., but then I start reading some documentation/tutorial and I suddenly don't know if I'm in English class or at a train station... :P \$\endgroup\$

  Dennis

  – Dennis

  2014年09月07日 18:45:06 +00:00

  Commented Sep 7, 2014 at 18:45
• \$\begingroup\$ @Dennis Yeah, APL/J/K assignments return values (most of the time!). And thanks. :) When learning J, it can start to get confusing as to what corresponds to what parts of your home language, so Iverson essentially banned the F-word (function) when writing the docs to try to force you to start fresh. Rolling with it and coming up with your own analogy later is the easiest way to do it. \$\endgroup\$

  algorithmshark

  – algorithmshark

  2014年09月07日 20:29:55 +00:00

  Commented Sep 7, 2014 at 20:29
• \$\begingroup\$ I still maintain APL is by far the most readable array language. So much for "write-only" snarks! Too bad GNU APL does not support any of the modern syntax (nested D-funs, lexical scoping, conditional return, hooks and trains... hell, it chokes on /⍨) It was probably meant for porting really old code. What do you use? Dyalog? NARS2000? I think it's really unfortunate that J took the ASCII noise approach. That language's implementation is otherwise a work of genius. But I can't be bothered to mentally parse ]a(,,]*%~)*:a \$\endgroup\$

  Tobia

  – Tobia

  2015年01月18日 10:19:21 +00:00

  Commented Jan 18, 2015 at 10:19
• \$\begingroup\$ @Tobia I briefly used Dyalog, but I actually barely know enough APL to get by. I'm a J/K fanboy mostly because ASCII is portable, and the rank models make more sense than APL's. ([0.5]? Ew.) With practice, you get used to tacit J, though. It gets far worse than this. \$\endgroup\$

  algorithmshark

  – algorithmshark

  2015年01月18日 16:56:56 +00:00

  Commented Jan 18, 2015 at 16:56

12 languages

CJam, (削除) 45 (削除ここまで) (削除) 44 (削除ここまで) 43 bytes

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

Reads an array of floats (e.g., [1.0 2.0 3.0 4.0 5.0]) from STDIN. Try it online.

APL, (削除) 67 (削除ここまで) (削除) 61 (削除ここまで) (削除) 53 (削除ここまで) (削除) 52 (削除ここまで) 50 bytes

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

Try it online.

Pyth, (削除) 55 (削除ここまで) 52 bytes

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

Reads space-separated numbers (e.g., 1 2 3 4 5) from STDIN.

Octave, 68 bytes

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

Not counting the shebang. Reads an array (e.g., [1 2 3 4 5]) from STDIN.

GNU bc, 78 bytes

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

Counting the shebang as 1 byte (-l switch). Reads whitespace separated floats from STDIN, followed by a zero.

Awk, 78 bytes

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

Not counting the shebang. Reads one number per line from STDIN.

GolfScript, (削除) 86 (削除ここまで) 83 bytes

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

GolfScript has no built-in support for floats, so the code is parsing them. Therefore, the input format is rather restrictive: you must input 1.0 and 0.1 rather than 1, 1. or .1.

Reads floats (as explained above) one by line, from STDIN. Try it online.

Perl, (削除) 90 (削除ここまで) 85 bytes

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

Counting the shebang as 1 byte (-n switch). Reads one number per line from STDIN.

Python 2, (削除) 102 (削除ここまで) 96 bytes

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

Not counting the shebang. Reads a list of floats (e.g., 1.0,2.0,3.0,4.0,5.0) from STDIN.

ECMAScript 6 (JavaScript), (削除) 114 (削除ここまで) 112 bytes

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

Not counting the LF. Expects an array (e.g., [1,2,3,4,5]) as argument.

PHP, 135 (or 108?) bytes

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

Not counting shebang or LF. Reads floats as command-line arguments.

I have a shorter solution, but I don't know how to count the bytes:

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

Counting the bytes in each code string and adding two for -R and -E, this approach would score 108.

C, (削除) 172 (削除ここまで) (削除) 140 (削除ここまで) (削除) 139 (削除ここまで) (削除) 137 (削除ここまで) 136 bytes

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

Not counting the LF. Compile with gcc -lm. Reads whitespace separated floats from STDIN.

• \$\begingroup\$ You can save one byte in C: while(cond)...,n++; vs for(;cond;n++)...; \$\endgroup\$

  Zeta

  – Zeta

  2014年09月03日 17:42:30 +00:00

  Commented Sep 3, 2014 at 17:42
• \$\begingroup\$ Do we really need to include shebang lines in our counts? \$\endgroup\$

  OregonTrail

  – OregonTrail

  2014年09月04日 08:42:53 +00:00

  Commented Sep 4, 2014 at 8:42
• \$\begingroup\$ @OregonTrail: I've included the shebangs in the code since it's easier than explaining run this as interpreter switches script for every submission. Convention is that shebang lines are not counted, unless the contain non-default switches. As stated in my answer, I've counted #!/usr/bin/awk -f as zero bytes (-f means read program from file), but #!/usr/bin/perl -n as one byte (-n means iterate over input lines). \$\endgroup\$

  Dennis

  – Dennis

  2014年09月04日 13:23:39 +00:00

  Commented Sep 4, 2014 at 13:23
• \$\begingroup\$ Shouldn't you count -q for Octave and -lm for C? \$\endgroup\$

  user344

  – user344

  2014年09月16日 11:53:04 +00:00

  Commented Sep 16, 2014 at 11:53
• \$\begingroup\$ -q is just to quiet output. -lm is needed by GCC. Other compilers may noy require it. \$\endgroup\$

  Dennis

  – Dennis

  2014年09月16日 13:21:02 +00:00

  Commented Sep 16, 2014 at 13:21

J (50):

This is the sort of thing J is good at:

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

As always: an explosion in the smiley factory. However, some of the smileys were left intact this time around: :) and :*: (that's a guy with four eyes and a gem embeded in his face) My interactive session that was used to create this: http://pastebin.com/gk0ksn2b

In action:

 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

Explanation:

As you might expect, there are actually 5 functions that are bundled into a list with a train of forks and hooks. (Don't worry about it, it's just a convenient way of making multiple functions output to a single list).

The lines that I used to make J generate this answer might be a bit clearer:

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

Let's look at them separately.

Harmonic

(# % +/@:%)

• # - Length (of the array)
• % - Divided by
• +/@:% - The sum (+/, or fold + in the array (+/1 2 3 4 == 1+2+3+4)) atop divide, but this time in the monadic case. What this means here, is that J automatically "guesses" that 1 would be the most useful value.

Geometric

(# %: */)

• # - Length (of the array)
• %: - Root (4 %: 7 would mean 'the fourth (or tesseract) root of seven)
• */ - Product (*/ is similar in meaning to +/, see the previous function for this)

Arithmetic

(+/ % #)

• +/ - sum, should be familiar now
• % - divided by
• # - Lenght

Root mean square

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

Ehm, yeah...

• %: - The root of
  • %@# - The inverse of the lenght
  • * - Times
  • +/@:*: - The sum of the squares (*: is squared, even though *~ is as well.)

Contraharmonic

+/@:*: % +/

• +/@:*: - The sum of the squares
• % - divided by
• +/ - the sum.

I actually found out that my function was (削除) one byte (削除ここまで) two bytes too long by explaining this, so that's good!

If J were just this good at processing strings, we'd be winning a lot more golfing competitions...

• \$\begingroup\$ Is that RegEx?? :P \$\endgroup\$

  An SO User

  – An SO User

  2014年09月02日 20:01:52 +00:00

  Commented Sep 2, 2014 at 20:01
• \$\begingroup\$ @LittleChild Nope. It's J. (jsoftware.com) \$\endgroup\$

  ɐɔıʇǝɥʇuʎs

  – ɐɔıʇǝɥʇuʎs

  2014年09月02日 20:03:23 +00:00

  Commented Sep 2, 2014 at 20:03
• 5
  \$\begingroup\$ @LittleChild: Be glad it's not APL \$\endgroup\$

  slebetman

  – slebetman

  2014年09月03日 01:10:27 +00:00

  Commented Sep 3, 2014 at 1:10
• \$\begingroup\$ J certainly does a great job in both terseness and in the smiley department -- I also found %) and :@( ... \$\endgroup\$

  Desty

  – Desty

  2014年09月09日 16:01:07 +00:00

  Commented Sep 9, 2014 at 16:01

Languages: 5

POV-Ray 3.7 Scene Description Language: 304 bytes

#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 doesn't have console input functions, so I've substituted file input. Output is to the console, but is surrounded by a good deal of program status output.)

Commodore BASIC: (削除) 111 (削除ここまで) 104 bytes

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

(Not all of the characters in this program can be represented in Unicode. | is used to represent SHIFT+H, ┌ represents SHIFT+O, ┐ represents SHIFT+P, / represents SHIFT+N. Because of the limitations in Commodore Basic I/O, the input is entered one number at a time, with an input of -1 to indicate the end of input. Output is tab-delimited.)

QBasic: 96 bytes

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

Uses the same I/O scheme as DLosc's entry; I golfed 15 bytes off by using the fact that INPUT V returns 0 (which evaluates to false) when an empty line is input (at least in MS-DOS QBasic 1.1 -- I don't know if it also works in QB64).

Pascal (FPC compiler): 172 bytes

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.

The input is separated by spaces, not commas, and is newline terminated. Output is space-separated.

Erlang: 401 bytes

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

String handling in Erlang is a royal pain. Consequently, all floating-point numbers must be entered with at least one digit after the decimal point -- string:to_float/1 will not convert 1, but will convert 1.0.

(More to come, especially if I figure out how to do this in RoboTalk, a language with neither floating-point operations nor I/O)

• \$\begingroup\$ I loved my Commodore 64 \$\endgroup\$

  AquaAlex

  – AquaAlex

  2014年09月03日 07:33:41 +00:00

  Commented Sep 3, 2014 at 7:33
• \$\begingroup\$ Ditto ... and the amiga \$\endgroup\$

  MickyT

  – MickyT

  2014年09月04日 09:01:35 +00:00

  Commented Sep 4, 2014 at 9:01
• \$\begingroup\$ A fellow QBasic fan! I independently came up with the same thing after realizing that we didn't have to handle 0 as a valid input. ;) I see you've used (Q/N)^.5 to my SQR(q/n), but that doesn't affect the length. Maybe we could share the lead? (I make the byte count 96, not including the trailing newline.) \$\endgroup\$

  DLosc

  – DLosc

  2014年09月05日 00:21:28 +00:00

  Commented Sep 5, 2014 at 0:21
• \$\begingroup\$ @DLosc, My byte counter (wc) includes the trailing newline, which I suppose gives us both the lead -- at least until I figure out how to get rid of that duplicate INPUT V. \$\endgroup\$

  Mark

  – Mark

  2014年09月05日 05:51:30 +00:00

  Commented Sep 5, 2014 at 5:51
• \$\begingroup\$ Good luck. :^) I tried some fancy stuff with GOTOs instead of the loop, but couldn't get any further reduction. \$\endgroup\$

  DLosc

  – DLosc

  2014年09月05日 19:35:52 +00:00

  Commented Sep 5, 2014 at 19:35

Languages: 3

Unless noted otherwise, numbers need to be seperated by space.

C: (削除) 181 (削除ここまで) 163

Takes numbers till end of input.

#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

Takes numbers till end of input.

#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

Takes arbitrarily many lists of numbers seperated by newline.

Implementation

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 (thanks shiona) bytes are just for IO :/.

Example

(Powershell's echo aka Write-Output prints every parameter on a single line)

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]

• \$\begingroup\$ you should be able to inline some of the definitions in the haskell answer. for example, instead of writing ;c=t/a in the let clause, write [h,g,a/z,r,t/a] after the in. \$\endgroup\$

  proud haskeller

  – proud haskeller

  2014年09月07日 13:29:42 +00:00

  Commented Sep 7, 2014 at 13:29
• \$\begingroup\$ also, writing s$m(1/)x is shorter than s.m(1/)$x, as is s$m(^2)x. \$\endgroup\$

  proud haskeller

  – proud haskeller

  2014年09月07日 13:40:33 +00:00

  Commented Sep 7, 2014 at 13:40
• \$\begingroup\$ @proudhaskeller: Again thanks. One can probably tell that the code gradually evolved from a non-golfed version. Also replaced fromIntegral.length$x with foldr(\_ x->x+1)0x. \$\endgroup\$

  Zeta

  – Zeta

  2014年09月07日 13:47:11 +00:00

  Commented Sep 7, 2014 at 13:47
• \$\begingroup\$ nice trick! but now that you made me look at it, i found this: s$m(const 1)x. \$\endgroup\$

  proud haskeller

  – proud haskeller

  2014年09月07日 13:54:55 +00:00

  Commented Sep 7, 2014 at 13:54
• \$\begingroup\$ @proudhaskeller: Good find, which brought me to s$m(\_->1)x. \$\endgroup\$

  Zeta

  – Zeta

  2014年09月07日 13:57:48 +00:00

  Commented Sep 7, 2014 at 13:57

Languages - 4

I always love an excuse to pull out good old

QBasic, (削除) 112 (削除ここまで) 96 bytes

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 isn't good with variable numbers of inputs, so the program requires one number per line, terminated with 0 or an empty line. Output is separated with spaces.

(Shortened once I realized that 0 isn't a valid number and can be used for input termination.)

Tested using QB64:

Testing the QBasic means program

Common Lisp, 183 bytes

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

For some reason I expected this to be shorter. I'm not any kind of Lisp expert, so tips are appreciated. Ungolfed version:

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

Probably the best way to test is by pasting the function into the clisp REPL, like so:

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

I love how Lisp uses exact fractions instead of floats when dividing two integers.

Prolog, 235 bytes

Prolog isn't great at math, but we're gonna use it anyway. Tested with SWI-Prolog. I think the sumlist predicate may not be standard Prolog, but whatever, I'm using it.

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

Ungolfed:

m(L, H, G, A, Q, C) :-
 length(L, N), % stores the length into N
 h(L, I), % stores the sum of inverses into I
 H is N/I,
 p(L, P), % stores the product into P
 G is P^(1/N),
 sumlist(L, S), % stores the sum into S
 A is S/N,
 q(L, R), % stores the sum of squares into R
 Q is sqrt(R/N),
 C is R/S.
% Helper predicates:
% p calculates the product of a list
p([H|T], R) :-
 p(T, P), % recursively get the product of the tail
 R is H*P. % multiply that by the head
p([], 1). % product of empty list is 1
% q calculates the sum of squares of a list
q([H|T], R) :-
 q(T, P), % recursively get the sum of squares of the tail
 R is H*H+P. % add that to the square of the head
q([], 0). % sum of empty list is 0
% h calculates the sum of inverses of a list
h([H|T], R) :-
 h(T, P), % recursively get the sum of inverses of the tail
 R is 1/H+P. % add that to the inverse of the head
h([], 0). % sum of empty list is 0

On Linux, with the code in a file called means.pro, test like this:

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

Gives a correct but rather amusing result when there's only one number:

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

Python 3, 103 bytes

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)

Same strategy as Dennis's Python 2 version. Takes a comma-separated list of numbers; handles both ints and floats. A single-number input must be wrapped in square braces (and a list of numbers always may be); a fix would cost 4 bytes.

8 Languages

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

Output:

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)

Output:

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

I'm not a Javascripter so any tips would be greatly appreciated

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

Look it up on the Google Play Store or the 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

This is syntactically correct and all, but all current interpreters just don't work...

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'

• 1
  \$\begingroup\$ You can save 1 character using sqrt(b4/l) instead of (b4/l)**0.5 and many more by using a,b,c,d instead of b1-4. You're also making me cry by using 77 instead of the more-modern F90+. \$\endgroup\$

  Kyle Kanos

  – Kyle Kanos

  2014年09月03日 14:01:17 +00:00

  Commented Sep 3, 2014 at 14:01
• \$\begingroup\$ @Kyle Haha, I'll start learning F99 then \$\endgroup\$

  Beta Decay

  – Beta Decay

  2014年09月03日 14:23:55 +00:00

  Commented Sep 3, 2014 at 14:23
• \$\begingroup\$ I'm more impressed by the fact that even after seeing the programming train that is Martin, you still decide to go for 6 (more?) languages... Nah, just kidding. I'm most impress by people knowing more than a couple of languages. \$\endgroup\$

  AndoDaan

  – AndoDaan

  2014年09月03日 14:53:33 +00:00

  Commented Sep 3, 2014 at 14:53
• 1
  \$\begingroup\$ In JS, you can use comma operator to avoid repeating var: var l=readline(),b=0,d=1,e=0,f=0;. Not sure what readline function is, though. \$\endgroup\$

  Oriol

  – Oriol

  2014年09月04日 00:45:15 +00:00

  Commented Sep 4, 2014 at 0:45
• 1
  \$\begingroup\$ You should be able to save some bytes by omitting Length of sequence? or at least making it shorter. \$\endgroup\$

  user344

  – user344

  2014年09月16日 11:55:42 +00:00

  Commented Sep 16, 2014 at 11:55

Languages: 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(L12)),mean(L12)/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);}}

• \$\begingroup\$ Can you add the sample output for Java? How many decimal places of accuracy does it give compared to the output in OP? \$\endgroup\$

  Michael Easter

  – Michael Easter

  2014年09月03日 09:21:05 +00:00

  Commented Sep 3, 2014 at 9:21
• \$\begingroup\$ Trivially shorter for TI-BASIC is {dim(Ans)/sum(Ansֿ¹),dim(Ans)√(prod(Ans)),mean(Ans),√(mean(Ans²)),mean(Ans²)/mean(Ans \$\endgroup\$

  lirtosiast

  – lirtosiast

  2015年06月08日 01:56:47 +00:00

  Commented Jun 8, 2015 at 1:56

Languages - 2

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

• \$\begingroup\$ The Python version works in both Python 2 and 3, but note that the output format isn't exactly the same. \$\endgroup\$

  user344

  – user344

  2014年09月16日 12:42:54 +00:00

  Commented Sep 16, 2014 at 12:42

1 language

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

Takes a vector of value and output a vector of means.

• \$\begingroup\$ You can save a character if you use d=s(x^2) and replace the latter two uses of s(x^2) with d. \$\endgroup\$

  Kyle Kanos

  – Kyle Kanos

  2014年09月03日 14:27:09 +00:00

  Commented Sep 3, 2014 at 14:27

1 Language

Golfscript, 162

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

Yes, it's huge. And it can definitely be made smaller. Which I will do sometime later. Try it out here.

It expects the input to be newline separated. If that is not allowed, I'll fix it (+2 chars). It outputs the list newline separated.

Here's a slightly more readable version:

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

• \$\begingroup\$ Looks like more Ruby than GolfScript. :P \$\endgroup\$

  Dennis

  – Dennis

  2014年09月03日 03:22:11 +00:00

  Commented Sep 3, 2014 at 3:22
• \$\begingroup\$ @Dennis It is. ;-) \$\endgroup\$

  Justin

  – Justin

  2014年09月03日 03:36:48 +00:00

  Commented Sep 3, 2014 at 3:36
• \$\begingroup\$ Why are you sorting the means? \$\endgroup\$

  Dennis

  – Dennis

  2014年09月03日 04:25:08 +00:00

  Commented Sep 3, 2014 at 4:25
• \$\begingroup\$ @Dennis I don't need to? "Conveniently, the results will be in increasing order." \$\endgroup\$

  Justin

  – Justin

  2014年09月03日 04:40:05 +00:00

  Commented Sep 3, 2014 at 4:40
• 4
  \$\begingroup\$ That's a comment, not a requirement. The harmonic mean is less or equal to the geometric mean, which is less or equal to the arithmetic mean, etc. By the way, you have a bug in your contraharmonic mean. The result should be l*l times higher, where l is the number of floats. \$\endgroup\$

  Dennis

  – Dennis

  2014年09月03日 04:41:29 +00:00

  Commented Sep 3, 2014 at 4:41

Languages 2

Fortran: 242

I've ungolfed it for clarity, but the golfed version is what is counted. you first need to input the number of values to be added, then the values.

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

Copy this into the editor, ctrl+enter and then call via m([1,2,3,4,5]),numer to get floating point output (otherwise you get symbolic output).

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

• 1
  \$\begingroup\$ Maybe you could additionally include the golfed version, so people could check the count? \$\endgroup\$

  Paŭlo Ebermann

  – Paŭlo Ebermann

  2014年09月05日 20:53:44 +00:00

  Commented Sep 5, 2014 at 20:53

Perl, (削除) 86 (削除ここまで) 76

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

Input: one number per line.

EDIT: this is one character longer, but since apparently shebang lines aren’t counted toward the total, it ends up being better:

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

• \$\begingroup\$ It's customary to count a shebang containing two non-default switches as two bytes. That being said, very impressive solution! \$\endgroup\$

  Dennis

  – Dennis

  2014年09月06日 04:24:07 +00:00

  Commented Sep 6, 2014 at 4:24

T-SQL, (削除) 136 (削除ここまで) 122

With the number lists stored in table S with I (integer) identifying the list and V (float) the value.

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

Saved 14 thanks to Alchymist

• 1
  \$\begingroup\$ Beat me to it on the SQL solution. You can save quite a few characters on the last 2 with sqrt(sum(vv)/count()) and sum(v*v)/sum(v) Also, in Oracle SQL, you can save another character as the function is ln rather than log. \$\endgroup\$

  Alchymist

  – Alchymist

  2014年09月04日 08:05:12 +00:00

  Commented Sep 4, 2014 at 8:05
• \$\begingroup\$ @Alchymist Thanks a lot. Face palm :) \$\endgroup\$

  MickyT

  – MickyT

  2014年09月04日 08:45:01 +00:00

  Commented Sep 4, 2014 at 8:45

Languages: 5

Some entries strive to avoid rounding errors (to 4 decimal places), using Java's BigDecimal instead of float/double, and accept IO rules per OP.

Newer entries relax both IO rules and BigDecimal.

Groovy - (削除) 409 (削除ここまで) (削除) 400 (削除ここまで) (削除) 164 (削除ここまで) 157 chars

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

sample run:

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 chars

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

sample run:

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 chars

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

sample run (it does have a trailing comma at the end):

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 chars

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

sample run:

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 chars

It is unclear if JRuby differs from Ruby: this must run on the JVM. Yet it is Ruby syntax. Either way, I'm including it in the spirit of 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)}"

sample run (does print a warning to 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

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

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

• 5
  \$\begingroup\$ The aim is to write the shortest possible code for each language, so you probably want to use single-character identifiers and omit whitespace where possible. \$\endgroup\$

  Peter Taylor

  – Peter Taylor

  2014年09月02日 22:06:20 +00:00

  Commented Sep 2, 2014 at 22:06
• 1
  \$\begingroup\$ @PeterTaylor Oh, okay! Didn't know that. New here. \$\endgroup\$

  An SO User

  – An SO User

  2014年09月03日 07:21:41 +00:00

  Commented Sep 3, 2014 at 7:21
• \$\begingroup\$ @LittleChild Feel free to edit your code to be as short as possible. Don't forget to write the number of characters you used at the top of your post. \$\endgroup\$

  mbomb007

  – mbomb007

  2015年01月21日 19:33:22 +00:00

  Commented Jan 21, 2015 at 19:33

2 Languages

Java - 243 bytes

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

expanded:

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 bytes

Fill in values in the first column, then press the button (that triggers this code) and it outputs the values in the second column.

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 language

Rust - 469

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

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

Ungolfed version:

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

Compacted 430-byte version without loop or input, for testing in 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);}

Updated for newer Rust:

Ungolfed:

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

Golfed (402 bytes):

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

Languages: 4

CoffeeScript, 193

Takes a comma-separated string of input:

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

Again, takes a comma-separated string of input:

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

Same concept:

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

Since TypeScript is a superset of JavaScript, I could have just submitted the same code but that wouldn't really be fair now. Here's a minified TypeScript code with all functions, variables, and parameters fully typed:

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

Could have cheated and used the type any as well... but, you know.

Excel - 120

Not sure if this counts as a "programming" language, but thought people may actually use a spreadsheet for this type of thing

With the numbers in 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)

• 2
  \$\begingroup\$ I don't have Excel, but I think you can use the range A:A to target the entire column A. \$\endgroup\$

  Dennis

  – Dennis

  2014年09月06日 04:21:03 +00:00

  Commented Sep 6, 2014 at 4:21

VBA (Excel) - 105

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

Ungolfed :

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

This code has to be run in the immediate window, and the array must be called i. Since there is no error collection, no cleaning, no variable dropping/releasing, if you want to test this code you can use the following piece of code (just paste in the immediate window and run the lines in order) :

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

Nothing very special, just the choice to use the immediate window with : to replace line breaks, which saves a few bytes vs setting up a sub or function and closing it; using ? to print rather than debug.print (only in the immediate window); and relying on how vba determines implicit values (adding a value to an un-set variable returns the value) and implicit operations (anything involving a string is implicitly concatenation).

• code-golf
• rosetta-stone