Целью Rosetta Stone Challenge является написание решений на максимально возможном количестве языков. Покажите свое программирование многоязычия!

Соревнование

Когда люди используют термин «среднее», они обычно означают среднее арифметическое, которое представляет собой сумму чисел, деленную на число чисел. Есть, однако, гораздо больше значения к слову «среднее» , включая гармоническое среднее , в среднем геометрическом , на среднем арифметическом , в среднем квадратичном , и contraharmonic среднего .

Ваша задача - написать программу, которая вводит список чисел и выводит эти 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.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

Будет некоторое разумное снисхождение в формате ввода / вывода, но я действительно хочу несколько десятичных знаков точности. Поскольку я хочу вывод с плавающей запятой, вы можете предполагать ввод с плавающей запятой.

Объективный критерий победы

Что касается объективного критерия выигрыша, то вот он: каждый язык - это отдельное соревнование в отношении того, кто может написать самую короткую запись, но общим победителем будет тот, кто выиграет большинство из этих субконкурсов. Это означает, что человек, который отвечает на многих необычных языках, может получить преимущество. Code-golf - это, в основном, тай-брейк, когда на языке существует более одного решения: человек с самой короткой программой получает кредит на этом языке.

Если будет ничья, победителем станет тот, у кого больше всего постов (и т. Д.).

Правила, ограничения и примечания

Ваша программа может быть написана на любом языке, существовавшем до 2 сентября 2014 года. Мне также придется полагаться на сообщество для проверки некоторых ответов, написанных на некоторых из более необычных / эзотерических языков, поскольку я вряд ли смогу протестировать их.

Пожалуйста, сохраняйте все ваши различные материалы, содержащиеся в одном ответе.

Кроме того, нет махинаций с в основном одинаковым ответом на несколько разных языковых диалектах. Я буду судить о том, какие представления достаточно разные.

Текущий список лидеров

Этот раздел будет периодически обновляться, чтобы показать количество языков и лидирующих в каждом.

• Алгоид (337) - бета-распад
• APL (42) - алгоритм
• Авк (78) - Денис
• BBC BASIC (155) - бета-распад
• С (136) - Деннис
• С ++ (195) - дзета
• C # (197) - Мартин Бюттнер
• CJam (43) - Деннис
• Clojure (324) - Майкл Пасха
• Кобра (132)
• CoffeeScript (155) - Мартин Бюттнер
• Коммодор Бейсик (104) - Марк
• Common Lisp (183) - DLosc
• Эрланг (401) - Марк
• Фортран (242) - Кайл Канос
• Фортран 77 (286) - бета-распад
• GNU bc (78) - Денис
• GolfScript (83) - Деннис
• Groovy (157) - Майкл Пасха
• Хаскелл (140) - Зета
• J (28) - алгоритм
• Ява (235) - Майкл Пасха
• JavaScript (ES6) (112) - Денис
• JRuby (538) - Майкл Пасха
• Юлия (79) - Мартин Бюттнер
• Луа (113) - AndoDaan
• Математика (65) - Мартин Бюттнер
• Матлаб (63) - Мартин Бюттнер
• Октава (68) - Деннис
• Openscript (849?) - COTO
• Паскаль (172) - Марк
• Perl (76) - Grimy
• 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-Basic (85) - Ипныпн
• TypeScript (393) - rink.attendant.6
• VBA (Excel) (387) - эластичный маньяк
• wxMaxima (134) - Кайл Канос

Рейтинг текущих пользователей

1. Деннис (10)
2. Мартин Бюттнер (6)
3. Майкл Пасха (5)
4. Марк, DLosc, алгоритм алгоритма (4)
5. Бета-распад (3)
6. Зета, Кайл Канос (2)
7. Ourous, AndoDaan, COTO, Grimy, plannapus, Vi., MickyT, Ypnypn, rink.attendant.6, Stretch Maniac (1)

(Если я допустил ошибку в приведенном выше рейтинге, дайте мне знать, и я исправлю это. Кроме того, тай-брейк еще не применен.)

Языки: 1

Openscript (много сотен)

(Мой любимый малоизвестный и печально не существующий язык программирования, потому что я научился программировать на нем много лет назад.;)

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

Я думаю, что этот список должен теперь содержать каждый язык программирования, который я знаю достаточно хорошо, чтобы решить хотя бы простые проблемы. Я постараюсь, чтобы этот список оставался полным с течением времени, когда я буду искать некоторые новые языки. (Я использовал знал немного Smalltalk и Delphi, но мне пришлось бы искать много, чтобы добавить их, чтобы чувствовать себя хорошо.)

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.

Спасибо за некоторые улучшения для Квентина.

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

Принимает входные данные в качестве аргументов командной строки и печатает список с пятью значениями в 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]

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

Определяет функцию, принимающую массив чисел и возвращающую массив с помощью пяти средних.

Спасибо за некоторые улучшения Уильяму Барбозе.

Юлия, 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 отдельных значений для средних.

Mathematica, 73 67 65 байт

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

Определяет функцию, принимающую список чисел с плавающей запятой и возвращающую список с пятью средними значениями.

Интересный факт: Mathematica имеет все 5 встроенных средств (и это было мое первоначальное представление), но три из них могут быть реализованы в меньшем количестве символов, чем их имена функций.

Matlab, 65 63 байта

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

Запрашивает ввод как массив чисел от пользователя и выводит пять средних по отдельности.

Спасибо за некоторые улучшения Денниса Джаруддина.

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

Такая же функциональная реализация, как и у предыдущих.

Спасибо за некоторые улучшения Исмаила Мигеля.

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

Такая же функциональная реализация, как и у предыдущих.

Рубин, 129 118 байт

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 принимает на функции второго порядка.

• +/ % # является поездом в J, что означает сумму, разделенную на граф, определение среднего арифметического.
• &.:является соединением, называемым Under, где u&.:v(y)эквивалентно vi(u(v(y)))и viявляется функциональной инверсией v. Да, J может принимать функциональные противоположности .
• Наконец, полезной особенностью J является то, что некоторые функции могут автоматически зацикливаться на списках, потому что J знает, как применять их поточечно, если не имеет смысла применять их ко всему аргументу. Так, квадрат списка - это, например, список квадратов.

Таким образом, aберется функция слева и возвращается среднее значение, которое «корректирует» значения с помощью функции, принимает среднее арифметическое и затем переворачивает настройку впоследствии.

• %aявляется гармоническим средним, потому что %означает Взаимное, и является его собственным обратным.
• ^.a это среднее геометрическое, потому что ^. является натуральным логарифмом, а его обратное является экспоненциальным.(Π x)^(1/n) = exp(Σ log(x)/n)
• [a среднее арифметическое, потому что [ это тождественная функция.
• *:a является квадратичным средним, потому что *: это квадрат, а его обратный корень квадратный.
• Противогармоника доставляет нам массу неприятностей - среднее значение квадратов, разделенных на среднее значение, поэтому мы делаем небольшую математику, чтобы ее получить: ( *:aделим на ( [aделим на *:a)). Это выглядит так [a(]%%)*:a. Пока мы на этом, мы добавляем каждое из средств,[a(,,]*%~)*:a .

Наконец, мы используем запятые, чтобы добавить остальные результаты вместе. Мы не требуем дополнительных паренов, потому что конкатенация (в данном случае, по крайней мере) ассоциативна.

Используется в 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 ниже.

• к4, 51 символ: {s:(a:avg)x*x;(%a@%x;exp a log x;a x;sqrt s;s%a x)}
• к2, 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. Попробуйте онлайн.

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 5) из STDIN.

Октава, 68 байт

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

Не считая Шебанга. Читает массив (например, [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

Считая Шебанг как 1 байт ( -lпереключатель). Читает пробелы, разделенные пробелами от STDIN, за которыми следует ноль.

Awk, 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}

Не считая Шебанга. Читает одно число в строке из STDIN.

GolfScript, 86 83 байта

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

В GolfScript нет встроенной поддержки чисел с плавающей точкой, поэтому код выполняет их синтаксический анализ. Поэтому формат ввода довольно ограничен: вы должны вводить 1.0и 0.1вместо 1, 1.или .1.

Читает float (как объяснено выше) по одной от STDIN. Попробуйте онлайн.

Perl, 90 85 байт

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

Считая Шебанг как 1 байт ( -nпереключатель). Читает одно число в строке из STDIN.

Python 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

Не считая Шебанга. Читает список с плавающей точкой (например, 1.0,2.0,3.0,4.0,5.0) из STDIN.

ECMAScript 6 (JavaScript), 114 112 байт

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

Не считая Шебанга или НЧ. Читает float как аргументы командной строки.

У меня есть более короткое решение, но я не знаю, как считать байты:

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

Считая байты в каждой строке кода и добавляя два для -Rи -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)) поверх деления, но на этот раз в монадическом случае. Это означает, что J автоматически «угадывает», что 1 будет наиболее полезным значением.

геометрический

(# %: */)

• # - длина (массива)
• %: - рут (4 %: 7 будет означать «четвертый (или тессеракт) корень из семи)
• */- Продукт ( */аналогичен по значению +/, см. Предыдущую функцию для этого)

арифметика

(+/ % #)

• +/ - сумма, должна быть знакома сейчас
• % - деленное на
• # - длина

Среднеквадратичное значение

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

Эмм, да ...

• %: - корень
  • %@# - обратная длина
  • * - раз
  • +/@:*:- Сумма квадратов ( *:возводится в квадрат, хотя *~тоже.)

Contraharmonic

+/@:*: % +/

• +/@:*: - сумма квадратов
• % - деленное на
• +/ - сумма.

Я на самом деле узнал, что моя функция была на один байт на два байта длиннее, объяснив это, так что это хорошо!

Если бы 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 не имеет функций ввода с консоли, поэтому я заменил ввод файла. Вывод на консоль, но он окружен большим количеством вывода статуса программы.)

Коммодор бейсик: 111 104 байта

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 ввод вводится по одному разу с вводом -1 для обозначения конца ввода. Выходные данные разделены табуляцией.)

QBasic: 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; Я сыграл в гольф 15 байтов, используя тот факт, чтоINPUT V возвращает 0 (что дает ложь), когда вводится пустая строка (по крайней мере, в MS-DOS QBasic 1.1 - я не знаю, работает ли это также в QB64).

Паскаль (компилятор 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.

Ввод разделяется пробелами, а не запятыми, и перевод строки завершается. Выход разделен пробелом.

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

Обработка струн в Эрланге - королевская боль. Следовательно, все числа с плавающей запятой должны вводиться как минимум с одной цифрой после десятичной запятой -string:to_float/1 не будут преобразованы 1, но будут преобразованы1.0 .

(Вперед, особенно если я пойму, как это сделать в 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";}

Haskell: 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 (спасибо Шион) байтов только для ввода-вывода: /.

пример

(Пауэрскелла echoакаWrite-Output печатает каждый параметр на одной строке)

PS> эхо "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 :

Common Lisp, 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))))

По какой-то причине я ожидал, что это будет короче. Я не специалист по Лиспу, поэтому советы приветствуются. Безголовая версия:

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

Вероятно, лучший способ проверить это - вставить функцию в clispREPL, например так:

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

Мне нравится, как Лисп использует точные дроби вместо плавающих при делении двух целых чисел.

Пролог, 235 байт

Пролог не очень хорош в математике, но мы все равно будем его использовать. Протестировано с SWI-Прологом. Я думаю, что 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).

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

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

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

Та же стратегия, что и в версии Денниса Python 2. Принимает разделенный запятыми список чисел; обрабатывает как целые и плавающие. Ввод одного числа должен быть заключен в квадратные скобки (и список чисел всегда может быть); исправление будет стоить 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 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

Выход:

5 
5
100
12
15
1
9.7914836236097695 26.600000000000001 45.596052460711988 78.15789473684211  

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

Javascript - 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

Найдите его в магазине Google Play или в магазине Raspberry Pi.

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-Basic, 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а затем вызовите через, 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]));

Perl, 86 76

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

Ввод: одно число в строке.

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$;/$.,$;/$}){

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

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"

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)

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