Мета Challenge Rosetta Stone - написати рішення на якомога більшій мові. Покажіть багатомовність програмування!

Змагання

Коли люди використовують термін "середній", вони, як правило, означають середнє арифметичне, що є сумою чисел, поділеною на кількість чисел. Є, однак, набагато більше значення до слова «середнє» , включаючи гармонійне середнє , в середньому геометричному , на середньому арифметичному , в середньому квадратичному , і 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

У форматі вводу / виводу буде деяка розумна поблажливість, але я хочу отримати кілька точок у точності. Оскільки я хочу вивести з плаваючою комою, ви можете припустити введення з плаваючою комою.

Об'єктивний критерій виграшу

Що стосується об’єктивного критерію виграшу, то ось він: Кожна мова - це окремий конкурс щодо того, хто може написати найкоротший запис, але загальним переможцем буде та людина, яка виграє більшість із цих змагань. Це означає, що людина, яка відповідає на багатьох незвичайних мовах, може отримати перевагу. Код-гольф - це здебільшого краватка, коли в мові існує більше одного рішення: особа, яка має найкоротшу програму, отримує заслуги за цю мову.

Якщо є нічия, переможцем стане людина, яка отримала найбільш друге місце (тощо).

Правила, обмеження та примітки

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

Будь ласка, зберігайте всі ваші різні матеріали, що містяться в одній відповіді.

Крім того, немає шенагіганів, які мають в основному однакову відповідь на дещо інших мовних діалектах. Я буду суддею щодо того, які подання є досить різними.

Поточна таблиця лідерів

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

• Алгоїд (337) - бета-розпад
• APL (42) - алгоритмневикористання
• Awk (78) - Денніс
• BBC BASIC (155) - бета-розпад
• C (136) - Денніс
• С ++ (195) - Зета
• C # (197) - Мартін Бюттнер
• CJam (43) - Денніс
• Clojure (324) - Михайло Пасха
• Кобра (132) - Полярний
• CoffeeScript (155) - Мартін Бюттнер
• Commodore BASIC (104) - Марка
• Звичайний Лісп (183) - DLosc
• Ерланг (401) - Марк
• Фортран (242) - Кайл Канос
• Фортран 77 (286) - бета-розпад
• GNU bc (78) - Денніс
• GolfScript (83) - Денніс
• Гровий (157) - Михайло Пасха
• Хаскелл (140) - Зета
• J (28) - алгоритмневикористання
• Ява (235) - Михайло Пасха
• JavaScript (ES6) (112) - Денніс
• JRuby (538) - Майкл Пасха
• Джулія (79) - Мартін Бюттнер
• Луа (113) - AndoDaan
• Математика (65) - Мартін Бюттнер
• Матлаб (63) - Мартін Бюттнер
• Октава (68) - Денніс
• Відкриття (849?) - COTO
• Паскаль (172) - Марк
• Перл (76) - Грим
• PHP (135) - Денніс
• POV-Ray 3.7 (304) - Позначити
• Пролог (235) - DLosc
• Піт (52) - Денніс
• Пітон 2 (96) - Денніс
• Python 3 (103) - DLosc
• Q (53) - алгоритмзметки
• Q'Nial (68) - алгоритм Шарк
• QBasic (96) - DLosc
• R (91) - планувальник
• Рубі (118) - Мартін Бюттнер
• Іржа (469) - Vi.
• Скала (230) - Михайло Пасха
• T-SQL (122) - MickyT
• TI-Basic (85) - Ypnypn
• 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

Відкриття (багато сотень)

(Моя улюблена незрозуміла і сумно неіснуюча мова програмування, тому що я навчився програмувати її багато років тому;;)

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, але мені доведеться шукати багато, щоб додати їх, щоб вони почували себе правильно.)

С, 196 190 171 165 байт

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

Читає вхід як окремі аргументи командного рядка і записує розділений комою список засобів в STDOUT.

Дякуємо за деякі вдосконалення Quentin.

C ++, 200 байт

Це те саме, що вищевказаний код C, плюс два включає. Я включаю це, тому що це довше, ніж виграшне подання на C ++, тому я гадаю, що шкоди не завдано, і я хотів би, щоб ця публікація фактично містила кожну мою мову. :)

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

C #, 220 197 байт

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

Визначає функцію в класі, яка бере Listподвійний і повертає масив пар з п'ятьма засобами.

Дякуємо за деякі вдосконалення Visual Melon та Bob.

CJam, 52 байти

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

Приймає введення як аргументи командного рядка і друкує список з п'ятьма значеннями STDOUT.

CoffeeScript, 155 байт

Це майже те саме, що рішення JavaScript далі (і спочатку я його не рахував з цієї причини), але ОП все одно включив його в табло, тому я просунув його до повного подання. Вони є технічно різними мовами врешті-решт.

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 окремих значень для засобів.

Математика, 73 67 65 байт

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

Визначає функцію, що приймає список номерів з плаваючою комою та повертає список за допомогою п'яти засобів.

Забавний факт: у Mathematica є вбудовані всі 5 засобів (і це було моє оригінальне подання), але три з них можуть бути реалізовані меншою кількістю символів, ніж їхні назви функцій.

Матлаб, 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 char!

Функція, що приймає список чисел як єдиний аргумент.

%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 char

Функція єдиного аргументу. Ми просто робимо список усіх засобів, які ми хочемо.

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

Те ж саме в інших версіях k знаходиться нижче.

• 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

Функція, що приймає список як аргумент.

{(÷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\@/]`

Читає масив floats (наприклад, [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.

Читає плаває (як пояснено вище) по рядку від 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]}

Не рахуючи НЧ. Очікує масив (наприклад, [1,2,3,4,5]) як аргумент.

PHP, 135 (або 108?) Байт

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

Не рахуючи shebang або LF. Читання плаває як аргументи командного рядка.

У мене коротше рішення, але я не знаю, як рахувати байти:

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

Підрахунок байтів у кожному рядку коду та додавання двох для -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);}

Не рахуючи НЧ. Компілювати з gcc -lm. Читає розділені пробіли з пробілів від STDIN.

J (50):

Це така річ, у яку добре вживатися:

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

Як завжди: вибух на фабриці смайлів. Однак деякі смайлики цього разу залишилися недоторканими: :)і :*:(це хлопець з чотирма очима і дорогоцінним каменем, вбудованим в обличчя) Мій інтерактивний сеанс, який був використаний для його створення: 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 функцій, які входять у список із набором виделок та гачків. (Не хвилюйтеся з цього приводу, це просто зручний спосіб виведення декількох функцій в один список).

Рядки, за допомогою яких я створював цю відповідь, можуть бути трохи зрозумілішими:

   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означав би «четвертий (або тессеракт) корінь із семи)
• */- Продукт ( */подібний за значенням +/, див. Попередню функцію для цього)

Арифметика

(+/ % #)

• +/ - сума, має бути знайома зараз
• % - ділиться на
• # - Довго

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

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

Е-е, так ...

• %: - Корінь
  • %@# - Зворотна довжина
  • * - Таймс
  • +/@:*:- Сума квадратів (у *:квадраті, навіть незважаючи на *~це.)

Контрагармонія

+/@:*: % +/

• +/@:*: - Сума квадратів
• % - ділиться на
• +/ - сума.

Я фактично з'ясував, що моя функція була одним байтом два байти занадто довго, пояснюючи це, так що це добре!

Якби 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 не має функцій введення консолі, тому я замінив введення файлів. Вихід є на консоль, але оточений великою кількістю виводу стану програми.)

Основа Commodore: 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

(Не всі символи цієї програми можуть бути представлені в Unicode. |Використовується для представлення SHIFT+H, ┌представляє SHIFT+O, ┐представляє SHIFT+P, /представляє SHIFT+N. Через обмеження в Commodore Basic I / O введення вводиться по одному номеру за один раз, із введенням від -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 (що оцінює значення false), коли вводиться порожній рядок (принаймні в 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.

Вхід відокремлено пробілами, а не комами, і закінчується новий рядок. Вихід розділений пробілом.

Ерланг: 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

Якщо не зазначено інше, числа потрібно розділити пробілом.

С: 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 (дякую, шіона) байти призначені саме для IO: /.

Приклад

(Powershell це 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 :

Лист звичайний, 183 байти

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

Чомусь я очікував, що це буде коротшим. Я не будь-який експерт Lisp, тому поради високо оцінені. Безгольова версія:

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

Мабуть, найкращий спосіб перевірити - вставити функцію в 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-Prolog. Я думаю, що sumlistприсудок може бути не стандартним Prolog, але що б я не використовував.

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

Безголівки:

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

% Helper predicates:

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

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

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

В Linux, з кодом у файлі, який називається means.pro, тестуйте так:

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

Дає правильний, але досить кумедний результат, коли є лише одне число:

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

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 Dennis . Приймає розділений комами список номерів; обробляє і ints, і floats. Введення на одну цифру повинно бути загорнуте в квадратні дужки (і список номерів завжди може бути); виправлення коштуватиме 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  

C ++ - 292

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

Пітон 3 - 151

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

Вихід:

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

Ява - 421

class Sequences {
    public static void main( String[] args){
        System.out.println("Length of sequence?: ");Scanner reader = new Scanner(System.in);l=reader.nextInt();int b=0;int d=1;int e=0;int f=0;int j;int seq[l];
        for(int i=0;i<l;i++){j=reader.nextInt();b+=1/j;d*=j;e+=j;f+=Math.pow(j,2);}
        h=l/b;g=Math.pow(d,(1/l));a=e/l;q=Math.sqrt(f/l);c=f/e;System.out.println(h+' '+g +' '+ a+' '+q+' '+c);}}

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 Store або в 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

Це синтаксично правильно і все, але всі поточні перекладачі просто не працюють ...

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

Перл, 86 76

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

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

EDIT: це на два символи довше, але оскільки очевидно, що рядки shebang не зараховуються до загальної кількості, це в кінцевому підсумку стає кращим:

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

T-SQL, 136 122

У списках номерів, збережених у таблиці S, з I (цілим числом) ідентифікується список та V (плаваюче) значення.

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

SQLFiddle

Збережено 14 завдяки алхіміку

Мови: 5

Деякі записи прагнуть уникнути помилок округлення (до 4 знаків після коми), використовуючи BigDecimal Java замість float / double та приймаючи правила IO на ОП.

Нові записи розслаблюють як правила IO, так і BigDecimal.

Groovy - 409 400 164 157 символів

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

проба запуску:

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

Ява - 900 235 символів

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

проба запуску:

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

Clojure - 524 324 символів

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

зразок запуску (у нього є кінцева кома в кінці):

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

Scala - 841 663 230 символів

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

проба запуску:

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

JRuby - 538 символів

Незрозуміло, чи відрізняється JRuby від Ruby: це має працювати на JVM. І все-таки це синтаксис Ruby. Так чи інакше, я включаю це в дусі каменю розетки.

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

запуск зразка (друкує попередження для stderr):

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

Мови 1

луа - 113

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

Мови - 1

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 мови

Java - 243 байти

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

розширено:

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

vba - excel, 387 байт

Заповніть значення у першому стовпці, потім натисніть кнопку (яка запускає цей код), і він виведе значення у другому стовпчику.

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

1 мова

Іржа - 469

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

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

Безгольова версія:

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

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

Компактна 430-байтна версія без циклу або вводу для тестування в ігровій послідовності :

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

Оновлено новіші іржі:

Безголівки:

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

Гольф (402 байти):

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

Мови: 4

CoffeeScript, 193

Приймає розділений комою рядок введення:

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

JavaScript (ES5), 256

Знову приймає введений комою рядок введення:

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

PHP, 252

Те саме поняття:

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

TypeScript, 393 *

Оскільки TypeScript - це набір JavaScript, я міг би просто подати той самий код, але це справді не було б справедливим. Ось мінімізований код TypeScript з усіма повністю набраними функціями, змінними та параметрами:

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

Могли б і обдурили, і використали тип any... але, знаєте.

Excel - 120

Не впевнений, чи вважається це мовою "програмування", але люди думають, що фактично можуть використовувати електронну таблицю для цього типу

З числами в А2: 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

Безумовно:

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

Цей код повинен бути запущений у безпосередньому вікні, і масив повинен бути названий i . Оскільки немає збору помилок, немає чищення, відсутня зміна / вивільнення змінних, якщо ви хочете перевірити цей код, ви можете скористатися наступним фрагментом коду (просто вставити в безпосереднє вікно і запустити рядки в порядку):

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

Нічого не особливо особливого, просто вибір використовувати безпосереднє вікно : замінити перерви рядка, що економить кілька байтів проти налаштування суб або функції та закриття; використовуючи? друкувати, а не debug.print (лише у безпосередньому вікні); і покладаючись на те, як vba визначає неявні значення (додавання значення до невстановленої змінної повертає значення) та неявні операції (все, що стосується рядка, неявно конкатенація).