O objetivo do Rosetta Stone Challenge é escrever soluções no maior número possível de idiomas. Mostre seu multilinguismo de programação!

O desafio

Quando as pessoas usam o termo "média", geralmente significam a média aritmética, que é a soma dos números divididos pelo número de números. Há, no entanto, muitos outros significados para a palavra "média", incluindo a média harmônica , a média geométrica , a média aritmética , a média quadrática e a média contra- harmônica .

Seu desafio é escrever um programa que insira uma lista de números e produza esses 5 meios diferentes. Além disso, você está tentando escrever programas no maior número possível de idiomas . Você tem permissão para usar qualquer tipo de função de biblioteca padrão que seu idioma possua, pois essa é principalmente uma demonstração de idioma.

Entrada

A entrada será uma lista de números positivos.

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

Saída

A saída será as cinco médias na ordem listada acima (harmônica, geométrica, aritmética, quadrática, contra-harmônica). Convenientemente, isso é o mesmo que aumentar a ordem.

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

Haverá alguma tolerância razoável no formato de E / S, mas quero várias casas decimais de precisão. Como eu quero saída de ponto flutuante, você pode assumir a entrada de ponto flutuante.

O Critério de Vencimento Objetivo

Quanto a um critério de vitória objetivo, aqui está: Cada idioma é uma competição separada sobre quem pode escrever a entrada mais curta, mas o vencedor geral será a pessoa que vencer a maioria dessas subcompetições. Isso significa que uma pessoa que responde em muitos idiomas incomuns pode obter uma vantagem. O código-golfe é principalmente um desempate para quando há mais de uma solução em um idioma: a pessoa com o programa mais curto recebe crédito por esse idioma.

Se houver empate, o vencedor será a pessoa com o maior número de finalizações em segundo lugar (e assim por diante).

Regras, restrições e notas

Seu programa pode ser escrito em qualquer idioma que existia antes de 2 de setembro de 2014. Também terei que confiar na comunidade para validar algumas respostas escritas em alguns dos idiomas mais incomuns / esotéricos, pois é improvável que eu possa testar eles.

Mantenha todos os seus diferentes envios contidos em uma única resposta.

Além disso, não há travessuras com basicamente a mesma resposta em um dialeto de idioma ligeiramente diferente. Eu serei o juiz sobre quais submissões são diferentes o suficiente.

Classificação atual

Esta seção será atualizada periodicamente para mostrar o número de idiomas e quem lidera em cada um.

• Algoid (337) - Deterioração beta
• APL (42) - algoritmshark
• Awk (78) - Dennis
• BBC BASIC (155) - Deterioração beta
• C (136) - Dennis
• C ++ (195) - Zeta
• C # (197) - Martin Büttner
• CJam (43) - Dennis
• Clojure (324) - Michael Páscoa
• Cobra (132) - Ourous
• CoffeeScript (155) - Martin Büttner
• Commodore BASIC (104) - Marca
• Lisp comum (183) - DLosc
• Erlang (401) - Mark
• Fortran (242) - Kyle Kanos
• Fortran 77 (286) - Decaimento Beta
• GNU bc (78) - Dennis
• GolfScript (83) - Dennis
• Groovy (157) - Michael Páscoa
• Haskell (140) - Zeta
• J (28) - algoritmos
• Java (235) - Michael Páscoa
• JavaScript (ES6) (112) - Dennis
• JRuby (538) - Michael Páscoa
• Julia (79) - Martin Büttner
• Lua (113) - AndoDaan
• Mathematica (65) - Martin Büttner
• Matlab (63) - Martin Büttner
• Oitava (68) - Dennis
• Openscript (849?) - COTO
• Pascal (172) - Marcos
• Perl (76) - Sujo
• PHP (135) - Dennis
• POV-Ray 3.7 (304) - Marca
• Prolog (235) - DLosc
• Pitão (52) - Dennis
• Python 2 (96) - Dennis
• Python 3 (103) - DLosc
• Q (53) - algoritmshark
• Q'Nial (68) - algoritmshark
• QBasic (96) - DLosc
• R (91) - plannapus
• Rubi (118) - Martin Büttner
• Ferrugem (469) - Vi.
• Scala (230) - Michael Páscoa
• T-SQL (122) - MickyT
• TI-Básico (85) - Ypnypn
• TypeScript (393) - rink.attendant.6
• VBA (Excel) (387) - maníaco por alongamento
• wxMaxima (134) - Kyle Kanos

Classificação do usuário atual

1. Dennis (10)
2. Martin Büttner (6)
3. Michael Easter (5)
4. Mark, DLosc, algoritmshark (4)
5. Deterioração beta (3)
6. Zeta, Kyle Kanos (2)
7. Ourous, AndoDaan, COTO, Grimy, plannapus, Vi., MickyT, Ypnypn, rink.attendant.6, Stretch Maniac (1)

(Se eu cometi um erro nas classificações acima, informe-me e eu o corrigirei. Além disso, o desempate ainda não foi aplicado.)

Idiomas: 1

Openscript (muitas centenas)

(Minha linguagem de programação obscura e tristemente extinta favorita, porque aprendi a programar nela há muitos anos.;)

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

Línguas: 13

Acho que agora esta lista deve conter todas as linguagens de programação que eu conheço suficientemente bem para resolver pelo menos problemas simples. Tentarei manter essa lista completa ao longo do tempo, enquanto observo algumas novas linguagens. (I utilizado para conhecer alguns Smalltalk e Delphi, mas eu teria que procurar muito para adicioná-los a se sentir bem.)

C, 196 190 171 165 bytes

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

Lê a entrada como argumentos individuais da linha de comando e grava uma lista separada por vírgula dos meios para STDOUT.

Obrigado por algumas melhorias no Quentin.

C ++, 200 bytes

É o mesmo que o código C acima, mais duas inclusões. Estou incluindo isso porque é mais longo do que o envio vencedor de C ++, então acho que nenhum dano foi causado e gostaria que este post contivesse todos os idiomas que eu conheço. :)

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

C #, 220 197 bytes

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

Define uma função em uma classe tirando um Listdos duplos e retornando uma matriz de duplos com as cinco médias.

Obrigado por algumas melhorias no Visual Melon e Bob.

CJam, 52 bytes

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

Pega a entrada como argumentos da linha de comando e imprime uma lista com os cinco valores em STDOUT.

CoffeeScript, 155 bytes

Isso é quase o mesmo que a solução JavaScript mais abaixo (e inicialmente eu não contei por esse motivo), mas o OP o incluiu no placar de qualquer maneira, então eu a promovi para um envio completo. Eles são idiomas tecnicamente diferentes, afinal.

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

JavaScript (ES6), 155 153 bytes

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

Define uma função pegando uma matriz de números e retornando uma matriz com as cinco médias.

Obrigado por algumas melhorias em William Barbosa.

Julia, 79 bytes

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

Define uma função pegando uma lista de números e retornando uma lista com as cinco médias.

Lua, 120 bytes

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

Define uma função que obtém uma lista de números e retorna 5 valores separados para as médias.

Mathematica, 73 67 65 bytes

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

Define uma função que obtém uma lista de números de ponto flutuante e retorna uma lista com as cinco médias.

Curiosidade: o Mathematica possui todos os cinco meios integrados (e esse foi o meu envio original), mas três deles podem ser implementados em menos caracteres que os nomes de suas funções.

Matlab, 65 63 bytes

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

Solicita a entrada como uma matriz de números do usuário e gera as cinco médias individualmente.

Obrigado por algumas melhorias em Dennis Jaheruddin.

PHP ≥ 5,4, 152 149 143 bytes

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

Mesma implementação funcional que as anteriores.

Obrigado por algumas melhorias em Ismael Miguel.

Python 2, 127 bytes

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

Mesma implementação funcional que as anteriores.

Ruby, 129 118 bytes

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

Mesma implementação funcional que as anteriores.

4 idiomas

J - 32 28 char!

Uma função que toma a lista de números como seu único argumento.

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

a aqui está um advérbio, que é a opinião de J sobre funções de segunda ordem.

• +/ % # é um trem em J, que significa soma dividida por contagem, a definição da média aritmética.
• &.:é uma conjunção chamada Under, onde u&.:v(y)é equivalente vi(u(v(y)))e vié o inverso funcional de v. Sim, J pode receber inversões funcionais .
• Finalmente, um recurso útil de J é que certas funções podem fazer um loop automático sobre listas, porque J sabe aplicá-las pontualmente, se não fizer sentido aplicá-las em todo o argumento. Portanto, o quadrado de uma lista é uma lista dos quadrados, por exemplo.

Assim, apega uma função à esquerda e retorna uma média que "ajusta" os valores pela função, pega a média aritmética e depois inverte o ajuste posteriormente.

• %aé a média harmônica, porque %significa recíproca e é inversa.
• ^.aé a média geométrica, porque ^.é o logaritmo natural e seu inverso é o exponencial.(Π x)^(1/n) = exp(Σ log(x)/n)
• [aé a média aritmética, porque [é a função de identidade.
• *:aé a média quadrática, porque *:é quadrado e sua inversa é a raiz quadrada.
• O contra-harmônico nos dá uma série de problemas - média dos quadrados divididos por média -, então fazemos um pouco de matemática para obtê-lo: ( *:adividido por ( [adividido por *:a)). Isso parece [a(]%%)*:a. Enquanto estamos nisso, acrescentamos cada um dos meios [a(,,]*%~)*:a,.

Por fim, usamos vírgulas para anexar o restante dos resultados. Não precisamos de mais parênteses, porque a concatenação é (pelo menos nesse caso) associativa.

Em uso no 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

Função de argumento único. Apenas fazemos uma lista de todos os meios que queremos.

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

A mesma coisa em outras versões do k está abaixo.

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

APL - 42 car

Função tendo lista como argumento.

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

Explicado por explosão:

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

Você vai amar este.

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

Q'Nial é outra linguagem orientada a array, uma implementação de Nial , que é baseada em uma Teoria de Arrays obscura, da mesma forma que Haskell é baseada em teoria de categorias. (Obtenha aqui .) É muito diferente de qualquer um dos outros três - ele analisa da esquerda para a direita, antes de tudo! -, mas ainda está mais relacionado a eles do que a qualquer outro idioma.

12 idiomas

CJam, 45 44 43 bytes

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

Lê uma matriz de carros alegóricos (por exemplo, [1.0 2.0 3.0 4.0 5.0]) de STDIN. Experimente online.

APL, 67 61 53 52 50 bytes

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

Experimente online.

Pitão, 55 52 bytes

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

Lê números separados por espaço (por exemplo, 1 2 3 4 5) de STDIN.

Oitava, 68 bytes

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

Sem contar o shebang. Lê uma matriz (por exemplo, [1 2 3 4 5]) de STDIN.

GNU bc, 78 bytes

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

Contando o shebang como 1 byte ( -lswitch). Lê carros alegóricos separados por espaço em branco de STDIN, seguidos por um zero.

Awk, 78 bytes

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

Sem contar o shebang. Lê um número por linha do STDIN.

GolfScript, 86 83 bytes

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

O GolfScript não tem suporte interno para carros alegóricos, portanto, o código está analisando-os. Portanto, o formato de entrada é bastante restritivo: você deve inserir 1.0e 0.1não1 , 1.ou .1.

Lê carros alegóricos (como explicado acima), um por linha, a partir de STDIN. Experimente online.

Perl, 90 85 bytes

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

Contando o shebang como 1 byte (-n switch). Lê um número por linha do STDIN.

Python 2, 102 96 bytes

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

Sem contar o shebang. Lê uma lista de carros alegóricos (por exemplo,1.0,2.0,3.0,4.0,5.0 ) de STDIN.

ECMAScript 6 (JavaScript), 114 112 bytes

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

Sem contar o LF. Espera uma matriz (por exemplo,[1,2,3,4,5] ) como argumento.

PHP, 135 (ou 108?) Bytes

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

Sem contar shebang ou LF. Lê flutuadores como argumentos de linha de comando.

Eu tenho uma solução mais curta, mas não sei como contar os bytes:

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

Contando os bytes em cada sequência de códigos e adicionando dois para -Re-E , essa abordagem terá 108.

C, 172 140 139 137 136 bytes

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

Sem contar o LF. Compile com gcc -lm. Lê carros alegóricos separados por espaço em branco de STDIN.

J (50):

Este é o tipo de coisa em que J é bom:

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

Como sempre: uma explosão na fábrica de smileys. No entanto, alguns dos smileys foram deixados intactos desta vez: :)e :*:(esse é um cara com quatro olhos e uma gema embutida no rosto) Minha sessão interativa usada para criar isso: http://pastebin.com/gk0ksn2b

Em ação:

   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

Explicação:

Como você pode esperar, na verdade existem 5 funções agrupadas em uma lista com um conjunto de garfos e ganchos. (Não se preocupe, é apenas uma maneira conveniente de gerar várias funções em uma única lista).

As linhas que eu usei para fazer J gerar essa resposta podem ser um pouco mais claras:

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

Vamos examiná-los separadamente.

Harmônica

(# % +/@:%)

• # - Comprimento (da matriz)
• % - Dividido por
• +/@:%- A soma ( +/, ou dobra +na matriz ( +/1 2 3 4== 1+2+3+4)) no topo da divisão, mas desta vez no caso monádico. O que isso significa aqui é que J "adivinha" automaticamente que 1 seria o valor mais útil.

Geométrico

(# %: */)

• # - Comprimento (da matriz)
• %:- Raiz ( 4 %: 7significaria 'a quarta (ou tesserata) raiz de sete)
• */- Produto ( */é semelhante ao significado +/, consulte a função anterior)

Aritmética

(+/ % #)

• +/ - soma, deve ser familiar agora
• % - dividido por
• # - Comprimento

Quadrado médio da raiz

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

Ehm, sim ...

• %: - A raiz de
  • %@# - O inverso do comprimento
  • * - Tempos
  • +/@:*:- A soma dos quadrados ( *:é quadrado, embora *~também seja).

Contra-harmônico

+/@:*: % +/

• +/@:*: - A soma dos quadrados
• % - dividido por
• +/ - a soma.

Na verdade, eu descobri que minha função tinha um byte e dois bytes demais explicando isso, então isso é bom!

Se J fosse tão bom no processamento de strings, estaríamos ganhando muito mais competições de golfe ...

Línguas: 5

POV-Ray 3.7 Cena Descrição Idioma: 304 bytes

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

(O POV-Ray SDL não possui funções de entrada do console, por isso substituí a entrada de arquivo. A saída é para o console, mas é cercada por uma boa parte da saída do status do programa.)

Commodore BASIC: 111 104 bytes

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

(Nem todos os caracteres deste programa podem ser representados em Unicode. |É usado para representar SHIFT+H, ┌representa SHIFT+O, ┐representa SHIFT+P, /representaSHIFT+N . Devido às limitações do Commodore Basic I / O, a entrada é inserida um número por vez, com uma entrada de -1 para indicar o final da entrada. A saída é delimitada por tabulação.)

QBasic: 96 bytes

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

Usa o mesmo esquema de E / S da entrada do DLosc; Joguei 15 bytes usando o fato de queINPUT V retornar 0 (que é falso) quando uma linha vazia é inserida (pelo menos no MS-DOS QBasic 1.1 - não sei se também funciona no QB64).

Pascal (compilador FPC): 172 bytes

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

A entrada é separada por espaços, não vírgulas, e a nova linha é finalizada. A saída é separada por espaço.

Erro: 401 bytes

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

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

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

O manuseio de cordas em Erlang é uma dor real. Conseqüentemente, todos os números de ponto flutuante devem ser inseridos com pelo menos um dígito após o ponto decimal - string:to_float/1não serão convertidos 1, mas serão convertidos1.0 .

(Mais por vir, especialmente se eu descobrir como fazer isso no RoboTalk, um idioma sem operações de ponto flutuante nem E / S)

Línguas: 3

Salvo indicação em contrário, os números precisam ser separados pelo espaço.

C: 181 163

Leva números até o final da entrada.

#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

Leva números até o final da entrada.

#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 149 140

Leva arbitrariamente muitas listas de números separados por nova linha.

Implementação

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 (obrigado shiona) bytes são apenas para E / S: /.

Exemplo

(O Powershell's echoaka Write-Outputimprime todos os parâmetros em uma única linha)

PS> eco "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]

Idiomas - 4

Eu sempre amo uma desculpa para tirar boa e velha

QBasic, 112 96 bytes

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

O QBasic não é bom com números variáveis ​​de entradas, portanto, o programa requer um número por linha, finalizado com 0 ou uma linha vazia. A saída é separada por espaços.

(Reduzido quando percebi que 0 não é um número válido e pode ser usado para finalização de entrada.)

Testado usando QB64 :

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

Por alguma razão, esperava que isso fosse mais curto. Como não sou especialista em Lisp, as dicas são apreciadas. Versão não destruída:

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

Provavelmente, a melhor maneira de testar é colando a função no clispREPL, da seguinte maneira:

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

Eu amo como o Lisp usa frações exatas em vez de flutuadores ao dividir dois números inteiros.

Prolog, 235 bytes

O prólogo não é bom em matemática, mas vamos usá-lo de qualquer maneira. Testado com SWI-Prolog. Eu acho que o sumlistpredicado pode não ser o Prolog padrão, mas seja o que for, eu estou usando.

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

No Linux, com o código em um arquivo chamado means.pro, teste como este:

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

Dá um resultado correto, mas bastante divertido, quando há apenas um número:

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

Mesma estratégia que a versão Python 2 de Dennis . Leva uma lista de números separados por vírgula; lida com ints e floats. Uma entrada de número único deve ser colocada entre colchetes (e uma lista de números sempre pode ser); uma correção custaria 4 bytes.

8 Idiomas

Fortran 77-286

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

BBC BASIC - 131

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

Saída:

5 
5
100
12
15
1
9.7914836236097695 26.600000000000001 45.596052460711988 78.15789473684211  

C ++ - 292

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

Python 3-151

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

Saída:

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

Java - 421

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

Javascript - 231

Eu não sou um Javascripter, então qualquer dica seria muito apreciada

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

Algoid - 337

Procure na Google Play Store ou na 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

Isso é sintaticamente correto e tudo, mas todos os intérpretes atuais simplesmente não funcionam ...

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'

Línguas: 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

Java, 457

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

Idiomas - 2

Cobra - 132

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

Python - 129

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

1 idioma

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

Pega um vetor de valor e gera um vetor de médias.

1 idioma

Golfscript, 162

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

Sim, é enorme. E definitivamente pode ser feito menor. O que farei algum tempo depois. Experimente aqui .

Ele espera que a entrada seja separada por nova linha. Se isso não for permitido, eu o corrigirei (+2 caracteres). Ele gera a nova linha da lista separada.

Aqui está uma versão um pouco mais legível:

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

Línguas 2

Fortran: 242

Eu o destruí para maior clareza, mas a versão do golfe é o que é contado. você primeiro precisa inserir o número de valores a serem adicionados e, em seguida, os valores.

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

Copie isso no editor ctrl+entere chame via m([1,2,3,4,5]),numerpara obter saída de ponto flutuante (caso contrário, você obtém saída simbólica).

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

Entrada: um número por linha.

EDIT: este é um caractere a mais, mas, como aparentemente as linhas shebang não são contadas no total, acaba sendo melhor:

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

T-SQL, 136 122

Com as listas de números armazenadas na tabela S, com I (inteiro) identificando a lista e V (flutuante) o valor.

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

Guardado 14 graças a Alchymist

Línguas: 5

Algumas entradas se esforçam para evitar erros de arredondamento (até quatro casas decimais), usando o BigDecimal do Java em vez de float / double, e aceitam regras de E / S por OP.

As entradas mais recentes relaxam as regras de E / S e o BigDecimal.

Groovy - 409 400 164 157 caracteres

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

amostra de execução:

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 caracteres

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

amostra de execução:

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 caracteres

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

amostra executada (ela possui uma vírgula no final):

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 caracteres

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

amostra de execução:

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 caracteres

Não está claro se o JRuby difere do Ruby: isso deve ser executado na JVM. No entanto, é a sintaxe do Ruby. De qualquer forma, estou incluindo no espírito de uma Pedra de Roseta.

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

amostra executada (imprime um aviso ao 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

Línguas 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)

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

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

expandido:

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

Preencha os valores na primeira coluna, pressione o botão (que aciona esse código) e ele gera os valores na segunda coluna.

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 idioma

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

Versão não destruída:

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

Versão compactada de 430 bytes sem loop ou entrada, para teste em 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);}

Atualizado para ferrugem mais recente:

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

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

Línguas: 4

CoffeeScript, 193

Toma uma sequência de entrada separada por vírgula:

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

Novamente, recebe uma sequência de entrada separada por vírgula:

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

Mesmo conceito:

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

Como o TypeScript é um superconjunto de JavaScript, eu poderia ter enviado o mesmo código, mas isso não seria realmente justo agora. Aqui está um código TypeScript minificado com todas as funções, variáveis ​​e parâmetros totalmente digitados:

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

Poderia ter trapaceado e usado o tipo anytambém ... mas, você sabe.

Excel - 120

Não tenho certeza se isso conta como uma linguagem de "programação", mas pensei que as pessoas podem realmente usar uma planilha para esse tipo de coisa

Com os números em 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

Esse código deve ser executado na janela imediata e a matriz deve ser chamada i . Como não há coleta de erros, limpeza ou remoção / liberação de variável, se você deseja testar esse código, pode usar o seguinte trecho de código (basta colar na janela imediata e executar as linhas em ordem):

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

Nada muito especial, apenas a opção de usar a janela imediata : para substituir as quebras de linha, o que economiza alguns bytes versus configurar uma sub ou função e fechá-la; usando? imprimir em vez de debug.print (apenas na janela imediata); e depender de como o vba determina valores implícitos (adicionar um valor a uma variável não definida retorna o valor) e operações implícitas (qualquer coisa que envolva uma cadeia de caracteres é concatenação implicitamente).