Revision 3dbf230c-be2c-4da1-a16e-b529c3665651 - Code Golf Stack Exchange
#Languages - 4
I always love an excuse to pull out good old
##QBasic, <s>112</s> 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](http://en.wikipedia.org/wiki/QB64):
![Testing the QBasic means program][1]
## 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][2] 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.
[1]: https://i.sstatic.net/GEDUy.png
[2]: http://codegolf.stackexchange.com/a/37239/16766