Rosetta Stone Challenge: ¿Cuál es el promedio de todos modos?

38

El objetivo de Rosetta Stone Challenge es escribir soluciones en tantos idiomas como sea posible. ¡Muestra tu programación multilingüismo!

El reto

Cuando las personas usan el término "promedio", generalmente se refieren a la media aritmética, que es la suma de los números divididos por el número de números. Sin embargo, hay muchos más significados para la palabra "media", incluyendo la media armónica , la media geométrica , la media aritmética , la media cuadrática y la media contraarmónica .

Su desafío es escribir un programa que ingrese una lista de números y genere esos 5 medios diferentes. Además, está intentando escribir programas en tantos idiomas como sea posible . Puede usar cualquier tipo de función de biblioteca estándar que tenga su idioma, ya que esto es principalmente un escaparate de idiomas.

Entrada

La entrada será una 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

Salida

La salida será las cinco medias en el orden mencionado anteriormente (armónico, geométrico, aritmético, cuadrático, contraarmónico). Convenientemente, esto es lo mismo que aumentar el orden.

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

Habrá cierta indulgencia razonable en el formato de E / S, pero quiero varios decimales de precisión. Como quiero una salida de punto flotante, puede asumir la entrada de punto flotante.

El criterio objetivo ganador

En cuanto a un criterio ganador objetivo, aquí está: cada idioma es una competencia separada en cuanto a quién puede escribir la entrada más corta, pero el ganador general sería la persona que gana la mayoría de estas subcompeticiones. Esto significa que una persona que responde en muchos idiomas poco comunes puede obtener una ventaja. Code-golf es principalmente un desempate para cuando hay más de una solución en un idioma: la persona con el programa más corto obtiene crédito por ese idioma.

Si hay un empate, el ganador sería la persona con la mayor cantidad de envíos de segundo lugar (y así sucesivamente).

Reglas, restricciones y notas

Su programa se puede escribir en cualquier idioma que existiera antes del 2 de septiembre de 2014. También tendré que confiar en la comunidad para validar algunas respuestas escritas en algunos de los idiomas más infrecuentes / esotéricos, ya que es improbable que pueda probar ellos.

Mantenga todas sus presentaciones diferentes contenidas en una sola respuesta.

Además, no hay travesuras con básicamente la misma respuesta en dialectos de idiomas ligeramente diferentes. Seré el juez en cuanto a qué presentaciones son lo suficientemente diferentes.


Tabla de clasificación actual

Esta sección se actualizará periódicamente para mostrar la cantidad de idiomas y quién lidera cada uno.

  • Algoid (337) - Decaimiento Beta
  • APL (42) - algormshark
  • Awk (78) - Dennis
  • BBC BASIC (155) - Decaimiento Beta
  • C (136) - Dennis
  • C ++ (195) - Zeta
  • C # (197) - Martin Büttner
  • CJam (43) - Dennis
  • Clojure (324) - Michael Easter
  • Cobra (132) - Ourous
  • CoffeeScript (155) - Martin Büttner
  • Commodore BASIC (104) - Marca
  • Lisp común (183) - DLosc
  • Erlang (401) - Marca
  • Fortran (242) - Kyle Kanos
  • Fortran 77 (286) - Decaimiento Beta
  • GNU bc (78) - Dennis
  • GolfScript (83) - Dennis
  • Groovy (157) - Michael Easter
  • Haskell (140) - Zeta
  • J (28) - algoritmos de tiburón
  • Java (235) - Michael Easter
  • JavaScript (ES6) (112) - Dennis
  • JRuby (538) - Michael Easter
  • Julia (79) - Martin Büttner
  • Lua (113) - AndoDaan
  • Mathematica (65) - Martin Büttner
  • Matlab (63) - Martin Büttner
  • Octava (68) - Dennis
  • OpenScript (849?) - COTO
  • Pascal (172) - Marca
  • Perl (76) - Sucio
  • PHP (135) - Dennis
  • POV-Ray 3.7 (304) - Marca
  • Prólogo (235) - DLosc
  • Pyth (52) - Dennis
  • Python 2 (96) - Dennis
  • Python 3 (103) - DLosc
  • Q (53) - algoritmos de tiburón
  • Q'Nial (68) - Algoritmo de tiburón
  • QBasic (96) - DLosc
  • R (91) - plannapus
  • Rubí (118) - Martin Büttner
  • Óxido (469) - Vi.
  • Scala (230) - Michael Pascua
  • T-SQL (122) - MickyT
  • TI-Basic (85) - Ypnypn
  • TypeScript (393) - rink.attendant.6
  • VBA (Excel) (387) - Estiramiento maniaco
  • wxMaxima (134) - Kyle Kanos

Ranking de usuarios actuales

  1. Dennis (10)
  2. Martin Büttner (6)
  3. Michael Pascua (5)
  4. Mark, DLosc, algoritmos de tiburón (4)
  5. Decaimiento Beta (3)
  6. Zeta, Kyle Kanos (2)
  7. Ourous, AndoDaan, COTO, Grimy, plannapus, Vi., MickyT, Ypnypn, rink.attendant.6, Stretch Maniac (1)

(Si cometí un error en las clasificaciones anteriores, avíseme y lo arreglaré. Además, el desempate aún no se ha aplicado).

PhiNotPi
fuente
Cuando dice que es indulgente con las E / S, ¿eso significa que las funciones también están permitidas o todo tiene que ser un programa (en la medida en que esa noción tenga sentido en algunos idiomas)?
Martin Ender
Te perdiste mi medio favorito: el medio logarítmico (a-b)/ln(a/b). Admito que solo hoy descubrí cómo se generaliza a un conjunto de muestra de más de dos :-) es.wikipedia.org/wiki/Logarithmic_mean
Level River St
1
2 de septiembre, ¿eh?
amalloy
1
También - cuando se trata de comandos integrados en Linux, ¿considera bc, awketc para ser "lenguas" o "comandos" - por lo que serían las diferentes maneras de implementar esto desde una cáscara de ser contado en diferentes idiomas?
Floris
2
@Floris En caso de duda: meta.codegolf.stackexchange.com/a/2073/8478
Martin Ender

Respuestas:

22

Idiomas: 1

OpenScript (muchos cientos)

(Mi lenguaje de programación oscuro, oscuro y lamentablemente favorito, porque aprendí a programarlo hace muchos años.)

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
COTO
fuente
21
put the length of the inputs into n? O_O Ya amo este idioma.
DLosc
2
La sintaxis me recuerda a Chef .
Comintern
2
La sintaxis me recuerda a COBOL.
Amadan
3
Para un lenguaje de aspecto "natural" aún más extremo (y específico de uso), consulte Inform 7.
Beska
3
inform 7 es un lenguaje real, es solo que la E / S es una aventura de texto. La gente ha escrito motores de ajedrez y el camino más corto de Dijkstra está en: en.literateprograms.org/Dijkstra's_algorithm_(Inform_7)
Jerry Jeremiah
18

Idiomas: 13

Creo que esta lista ahora debería contener todos los lenguajes de programación que conozco lo suficientemente bien como para resolver al menos problemas simples. Intentaré mantener esta lista completa con el tiempo a medida que busco nuevos lenguajes. ( Solía conocer Smalltalk y Delphi, pero tenía que mirar mucho para agregarlos para sentirme bien).

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

Lee la entrada como argumentos de línea de comandos individuales y escribe una lista separada por comas de los medios en STDOUT.

Gracias por algunas mejoras a Quentin.

C ++, 200 bytes

Esto es lo mismo que el código C anterior, más dos incluye. Incluyo esto porque es más largo que la presentación ganadora de C ++, así que supongo que no se hace daño, y me gustaría que esta publicación contenga todos los idiomas que conozco. :)

#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 una función en una clase que toma una Listde dobles y devuelve una matriz de dobles con las cinco medias.

Gracias por algunas mejoras en Visual Melon y Bob.

CJam, 52 bytes

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

Toma la entrada como argumentos de línea de comandos e imprime una lista con los cinco valores en STDOUT.

CoffeeScript, 155 bytes

Esto es casi lo mismo que la solución de JavaScript más abajo (e inicialmente no lo conté por esa razón), pero el OP lo incluyó en el marcador de todos modos, así que lo promoví a un envío completo. Ellos son técnicamente diferentes idiomas después de todo.

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 una función que toma una matriz de números y devuelve una matriz con las cinco medias.

Gracias por algunas mejoras a 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 una función que toma una lista de números y devuelve una lista con las cinco medias.

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 una función que toma una lista de números y devuelve 5 valores separados para las medias.

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 una función que toma una lista de números de coma flotante y devuelve una lista con las cinco medias.

Dato curioso: Mathematica tiene los 5 medios incorporados (y ese fue mi envío original), pero tres de ellos se pueden implementar en menos caracteres que los nombres de sus funciones.

Matlab, 65 63 bytes

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

Solicita la entrada como una matriz de números del usuario y genera los cinco medios individualmente.

Gracias por algunas mejoras a 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];}

La misma implementación funcional que las anteriores.

Gracias por algunas mejoras a 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]

La misma implementación funcional que las anteriores.

Rubí, 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]}

La misma implementación funcional que las anteriores.

Martin Ender
fuente
Me doy cuenta de que esto es bastante después del hecho, pero puede perder 3 bytes de Julia si lo usa norm(l)/n^.5en lugar de norm(l)/sqrt(n).
Alex A.
13

4 idiomas

J - 32 28 char!

Una función que toma la lista de números como único argumento.

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

a Aquí hay un adverbio, que es la toma de J de las funciones de segundo orden.

  • +/ % # es un tren en J, que significa suma dividida por conteo, la definición de la media aritmética.
  • &.:es una conjunción llamada Under, donde u&.:v(y)es equivalente vi(u(v(y)))y vies el inverso funcional de v. Sí, J puede tomar inversas funcionales .
  • Finalmente, una característica útil de J es que ciertas funciones pueden recorrer automáticamente las listas, porque J sabe aplicarlas puntualmente si no tiene sentido aplicarlas en todo el argumento. Entonces, el cuadrado de una lista es una lista de los cuadrados, por ejemplo.

Por lo tanto, atoma una función a la izquierda y devuelve una media que "ajusta" los valores por la función, toma la media aritmética y luego invierte el ajuste.

  • %aes la media armónica, porque %significa recíproco, y es su propio inverso.
  • ^.aes la media geométrica, porque ^.es el logaritmo natural y su inverso es el exponencial.(Π x)^(1/n) = exp(Σ log(x)/n)
  • [aes la media aritmética, porque [es la función de identidad.
  • *:aes la media cuadrática, porque *:es cuadrada, y su inversa es la raíz cuadrada.
  • La contraarmonía nos da una gran cantidad de problemas, la media de los cuadrados divididos por la media, por lo que hacemos un poco de matemática para obtenerla: ( *:adividida por ( [adividida por *:a)). Esto se parece [a(]%%)*:a. Mientras estamos en ello, que anteponer a cada uno de los medios, [a(,,]*%~)*:a.

Finalmente, usamos comas para agregar el resto de los resultados juntos. No necesitamos más parentes porque la concatenación es (en este caso al menos) asociativa.

En uso en la 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 caracteres

Función de argumento único. Simplemente hacemos una lista de todos los medios que queremos.

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

Lo mismo en otras versiones de k está abajo.

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

Función que toma la lista como argumento.

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

Explicado por explosión:

{                                         } ⍝ function with argument ⍵
                                   +/÷≢     ⍝ Sum Divide Length, aka mean
                                 M←         ⍝ assign function to M for Mean
                              A←(M     )⍵   ⍝ arithmetic Mean, assign to A
                     (S←M⍵*2)               ⍝ Mean of squares, assign to S
                      S      ÷A             ⍝ S divide A, aka contraharmonic mean
              (S*.5)                        ⍝ sqrt(S), aka quadratic mean/RMS
                    ,                       ⍝ concatenate into a list
             A                              ⍝ prepend A (APL autoprepends to lists)
        *M⍟⍵                                ⍝ exp of Mean of logs, aka geometric
       (    )                               ⍝ prepend (auto)
  ÷M÷⍵                                      ⍝ recip of Mean of recips, aka harmonic
 (    )                                     ⍝ prepend (auto)

Q'Nial - 68 char

Te va a encantar este.

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

Q'Nial es otro lenguaje orientado a arreglos, una implementación de Nial , que se basa en una oscura teoría de matrices de la misma manera que Haskell se basa en la teoría de categorías. (Consíguelo aquí .) Es muy diferente de cualquiera de los otros tres (¡se analiza de izquierda a derecha, en primer lugar!), Pero aún está más relacionado con ellos que con cualquier otro idioma.

Algoritmo de tiburón
fuente
Yo sabía que había una mejor manera de hacer esto en la LPA. Entonces puedo deducir una variable que definí a su derecha ; No habría pensado en eso yo mismo ... - ¡Ese código J es impresionante! Cada vez que veo una de tus respuestas, me digo que tienes que aprender ese idioma. , pero luego empiezo a leer documentación / tutoriales y de repente no sé si estoy en clase de inglés o en una estación de tren ...: P
Dennis
@ Dennis Sí, las asignaciones APL / J / K devuelven valores (¡la mayoría de las veces!). Y gracias. :) Al aprender J, puede comenzar a ser confuso lo que corresponde a qué partes de su idioma materno, por lo que Iverson esencialmente prohibió la palabra F (función) al escribir los documentos para tratar de forzarlo a comenzar de nuevo. Rodar con él y encontrar su propia analogía más tarde es la forma más fácil de hacerlo.
algormshark
Todavía mantengo que APL es, con mucho, el lenguaje de matriz más legible. ¡Tanto por los snarks de "solo escritura"! Lástima que GNU APL no admita ninguna de las sintaxis modernas (D-funs anidadas, alcance léxico, retorno condicional, ganchos y trenes ... demonios, se ahoga /⍨) Probablemente fue para portar código muy antiguo. ¿Que usas? Dyalog? NARS2000? Creo que es realmente lamentable que J haya adoptado el enfoque de ruido ASCII. La implementación de ese lenguaje es, por lo demás, una obra de genio. Pero no me molesto en analizar mentalmente]a(,,]*%~)*:a
Tobia
@Tobia Usé brevemente Dyalog, pero en realidad apenas conozco suficiente APL para sobrevivir. Soy un fanático de J / K principalmente porque ASCII es portátil, y los modelos de rango tienen más sentido que los de APL. ( [0.5]? Ew.) Con la práctica, te acostumbras a tácito J, sin embargo. Se pone mucho peor que esto.
algorithmshark
12

12 idiomas


CJam, 45 44 43 bytes

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

Lee una matriz de flotadores (por ejemplo, [1.0 2.0 3.0 4.0 5.0]) de STDIN. Pruébalo en línea.


APL, 67 61 53 52 50 bytes

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

Pruébalo en línea.


Pyth, 55 52 bytes

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

Lee números separados por espacios (por ejemplo, 1 2 3 4 5) de STDIN.


Octava, 68 bytes

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

Sin contar el shebang. Lee una matriz (por ejemplo, [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 el shebang como 1 byte ( -linterruptor). Lee espacios flotantes separados por espacios en blanco de STDIN, seguidos de un cero.


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}

Sin contar el shebang. Lee un número por línea de STDIN.


GolfScript, 86 83 bytes

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

GolfScript no tiene soporte incorporado para flotantes, por lo que el código los analiza. Por lo tanto, el formato de entrada es bastante restrictivo: debe ingresar 1.0y en 0.1lugar de 1, 1.o .1.

Lee flotantes (como se explicó anteriormente) uno por línea, de STDIN. Pruébalo en línea.


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 el shebang como 1 byte ( -ninterruptor). Lee un número por línea de 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

Sin contar el shebang. Lee una lista de flotadores (por ejemplo, 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]}

Sin contar el LF. Espera una matriz (por ejemplo, [1,2,3,4,5]) como argumento.


PHP, 135 (¿o 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]);

Sin contar shebang o LF. Lee flota como argumentos de línea de comandos.

Tengo una solución más corta, pero no sé cómo contar los 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 los bytes en cada cadena de código y agregando dos para -Ry -E, este enfoque obtendría 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);}

Sin contar el LF. Compilar con gcc -lm. Lee espacios flotantes separados por espacios en blanco de STDIN.

Dennis
fuente
Puede guardar un byte en C: while(cond)...,n++;vsfor(;cond;n++)...;
Zeta
¿Realmente necesitamos incluir líneas shebang en nuestros recuentos?
OregonTrail
@OregonTrail: he incluido los shebangs en el código ya que es más fácil que explicar ejecutar esto comointerpreter switches script para cada envío. La convención es que las líneas shebang no se cuentan, a menos que contengan modificadores no predeterminados. Como se indicó en mi respuesta, he contado #!/usr/bin/awk -fcomo cero bytes ( -fsignifica leer el programa del archivo), pero #!/usr/bin/perl -ncomo un byte ( -nsignifica iterar sobre las líneas de entrada).
Dennis
¿No deberías contar -qpara Octave y -lmpara C?
nyuszika7h
-qes solo para salida silenciosa. -lmes necesario por GCC. Otros compiladores pueden no requerirlo.
Dennis
6

J (50):

Este es el tipo de cosas en las que J es bueno:

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

Como siempre: una explosión en la fábrica de smiley. Sin embargo, algunas de las caritas quedaron intactas esta vez: :)y :*:(ese es un chico con cuatro ojos y una gema incrustada en su rostro) Mi sesión interactiva que se utilizó para crear esto: http://pastebin.com/gk0ksn2b

En acción:

   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

Explicación:

Como es de esperar, en realidad hay 5 funciones que se agrupan en una lista con un tren de horquillas y ganchos. (No se preocupe por eso, es solo una forma conveniente de hacer que múltiples funciones salgan a una sola lista).

Las líneas que usé para hacer que J generara esta respuesta podrían ser un poco más claras:

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

Echemos un vistazo por separado.

Armónico

(# % +/@:%)
  • # - Longitud (de la matriz)
  • % - Dividido por
  • +/@:%- La suma ( +/o plegado +en la matriz ( +/1 2 3 4== 1+2+3+4)) encima de dividir, pero esta vez en el caso monádico. Lo que esto significa aquí es que J automáticamente "adivina" que 1 sería el valor más útil.

Geométrico

(# %: */)
  • # - Longitud (de la matriz)
  • %:- Raíz ( 4 %: 7significaría 'la cuarta (o tesseract) raíz de siete)
  • */- Producto ( */es similar en significado a +/, vea la función anterior para esto)

Aritmética

(+/ % #)
  • +/ - suma, debería ser familiar ahora
  • % - dividido por
  • # - longitud

Media cuadrática

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

Ehm, si ...

  • %: - La raíz de
    • %@# - El inverso de la longitud
    • * - Tiempos
    • +/@:*:- La suma de los cuadrados ( *:es cuadrado, aunque *~también lo sea).

Contraarmónico

+/@:*: % +/
  • +/@:*: - La suma de los cuadrados.
  • % - dividido por
  • +/ - la suma.

De hecho, descubrí que mi función era un byte dos bytes demasiado larga al explicar esto, ¡así que eso es bueno!

Si J fuera tan bueno procesando cadenas, estaríamos ganando muchas más competencias de golf ...

ɐɔıʇǝɥʇuʎs
fuente
¿Es eso RegEx? : P
Niño pequeño
@LittleChild Nope. It's J. ( jsoftware.com )
Sepıʇǝɥʇuʎs
55
@LittleChild: me alegro de que no sea APL
slebetman
J ciertamente hace un gran trabajo tanto en la brevedad como en el departamento de smiley, también encontré%) y: @ (...
Desty
5

Idiomas: 5

POV-Ray 3.7 Lenguaje de descripción de escena: 304 bytes

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

(POV-Ray SDL no tiene funciones de entrada de consola, por lo que he sustituido la entrada de archivos. La salida es a la consola, pero está rodeada por una buena cantidad de salida de estado del programa).

Commodore BASIC: 111104 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

(No todos los personajes de este programa pueden representarse en Unicode. | Se usa para representar SHIFT+H, representa SHIFT+O, representa SHIFT+P, /representa SHIFT+N. Debido a las limitaciones de Commodore Basic I / O, la entrada se ingresa un número a la vez, con una entrada de -1 para indicar el final de la entrada. La salida está delimitada por tabulaciones.)

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

Utiliza el mismo esquema de E / S que la entrada de DLosc; Utilicé el hecho de que INPUT Vdevuelve 0 bytes (que se evalúa como falso) cuando se ingresa una línea vacía (al menos en MS-DOS QBasic 1.1; no sé si también funciona en 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.

La entrada está separada por espacios, no por comas, y se termina en línea nueva. La salida está separada por espacios.

Erlang: 401 bytes

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

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

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

El manejo de cuerdas en Erlang es un dolor real. En consecuencia, todos los números de coma flotante deben ingresarse con al menos un dígito después del punto decimal:string:to_float/1 no se convertirá 1, pero se convertirá 1.0.

(Más por venir, especialmente si descubro cómo hacer esto en RoboTalk, un lenguaje sin operaciones de punto flotante ni E / S)

marca
fuente
Me encantó mi Commodore 64
AquaAlex
Lo mismo ... y la amiga
MickyT
¡Un compañero fanático de QBasic! Independientemente se me ocurrió lo mismo después de darme cuenta de que no teníamos que manejar 0 como entrada válida. ;) Veo que te has acostumbrado (Q/N)^.5a mi SQR(q/n), pero eso no afecta la longitud. Tal vez podríamos compartir el liderazgo? (Hago que el byte cuente 96, sin incluir la nueva línea final.)
DLosc
@DLosc, My byte counter ( wc) incluye la nueva línea final, que supongo que nos da a ambos la ventaja, al menos hasta que descubra cómo deshacerme de ese duplicado INPUT V.
Marque el
Buena suerte. : ^) Intenté algunas cosas elegantes con GOTOs en lugar del bucle, pero no pude obtener ninguna reducción adicional.
DLosc
5

Idiomas: 3

A menos que se indique lo contrario, los números deben estar separados por espacio.

C: 181 163

Toma números hasta el final de la 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

Toma números hasta el final de la 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 140

Toma arbitrariamente muchas listas de números separados por nueva línea.

Implementación

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 (gracias shiona) bytes son solo para IO: /.

Ejemplo

(Powershell's echoaka Write-Outputimprime cada parámetro en una sola línea)

PS> echo "1 2 3 4 5" "1.7 17.3 3.14 24 2.718 1.618" | runhaskell SO.hs
[2.18978102189781,2.605171084697352,3.0,3.3166247903554,3.6666666666666665]
[3.011834514901806,4.621794669196026,8.412666666666668,12.234139719108438,17.791525635945792]
Zeta
fuente
debería poder incluir algunas de las definiciones en la respuesta de haskell. por ejemplo, en lugar de escribir ;c=t/aen la cláusula let, escriba [h,g,a/z,r,t/a]después de in.
orgulloso Haskeller
@proudhaskeller: Buen punto, ¡gracias!
Zeta
Además, la escritura s$m(1/)xes más corta que s.m(1/)$x, tal como está s$m(^2)x.
orgulloso Haskeller
@proudhaskeller: De nuevo, gracias. Probablemente se puede decir que el código evolucionó gradualmente de una versión no golfizada. También reemplazado fromIntegral.length$xcon foldr(\_ x->x+1)0x.
Zeta
¡buen truco! pero ahora que usted me hizo la miro, me encontré con esto: s$m(const 1)x.
orgulloso Haskeller
4

Idiomas - 4

Siempre me encanta una excusa para sacar buenos viejos

QBasic, 112 96 bytes

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

QBasic no es bueno con números variables de entradas, por lo que el programa requiere un número por línea, terminado con 0 o una línea vacía. La salida se separa con espacios.

(Acortado una vez que me di cuenta de que 0 no es un número válido y puede usarse para la terminación de entrada).

Probado con QB64 :

Probar el programa de medios QBasic

Lisp común, 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 alguna razón, esperaba que esto fuera más corto. No soy ningún tipo de experto en Lisp, por lo que se agradecen los consejos. Versión sin golf:

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

Probablemente la mejor manera de probar es pegando la función en clispREPL, de esta manera:

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

Me encanta cómo Lisp usa fracciones exactas en lugar de flotantes cuando divide dos enteros.

Prólogo, 235 bytes

Prolog no es bueno en matemáticas, pero lo usaremos de todos modos. Probado con SWI-Prolog. Creo que el sumlistpredicado puede no ser Prolog estándar, pero lo que sea, lo estoy 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).

Sin golf:

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

En Linux, con el código en un archivo llamado means.pro, pruebe así:

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

Da un resultado correcto pero bastante divertido cuando solo hay un 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)

La misma estrategia que la versión Python 2 de Dennis . Toma una lista de números separados por comas; maneja tanto ints como flotadores. Una entrada de un solo número debe estar entre llaves (y una lista de números siempre puede estar); una solución costaría 4 bytes.

DLosc
fuente
4

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

Salida:

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)

Salida:

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

No soy un Javascripter, por lo que cualquier consejo sería muy apreciado

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

Búscalo en Google Play Store o en 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

Esto es sintácticamente correcto y todo, pero todos los intérpretes actuales simplemente no funcionan ...

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'
Decaimiento Beta
fuente
1
Puede guardar 1 carácter utilizando sqrt(b4/l)en lugar de (b4/l)**0.5y muchos más mediante el uso de a, b, c, den lugar de b1-4. También me estás haciendo llorar al usar 77 en lugar del más moderno F90 +.
Kyle Kanos
@Kyle Haha, entonces comenzaré a aprender F99
Beta Decay
Estoy más impresionado por el hecho de que incluso después de ver el tren de programación que es Martin, aún decides ir por 6 (¿más?) Idiomas ... No, es broma. Me impresiona mucho la gente que sabe más de un par de idiomas.
AndoDaan
1
En JS, se puede usar una coma operador para evitar la repetición var: var l=readline(),b=0,d=1,e=0,f=0;. Sin readlineembargo, no estoy seguro de qué función es.
Oriol
1
Debería poder guardar algunos bytes omitiendo Length of sequence?o al menos haciéndolo más corto.
nyuszika7h
3

Idiomas: 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);}}
Ypnypn
fuente
¿Se puede agregar la salida de muestra para Java? ¿Cuántos decimales de precisión da en comparación con la salida en OP?
Michael Easter
Trivialmente más corto para TI-BASIC es{dim(Ans)/sum(Ansֿ¹),dim(Ans)√(prod(Ans)),mean(Ans),√(mean(Ans²)),mean(Ans²)/mean(Ans
lirtosiast
3

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)
Οurous
fuente
La versión de Python funciona en Python 2 y 3, pero tenga en cuenta que el formato de salida no es exactamente el mismo.
nyuszika7h
3

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

Toma un vector de valor y genera un vector de medias.

plannapus
fuente
Puede guardar un personaje si usa d=s(x^2)y reemplaza los dos últimos usos de s(x^2)con d.
Kyle Kanos
De hecho, gracias!
plannapus
3

1 idioma

Golfscript, 162

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

Si, es enorme. Y definitivamente puede hacerse más pequeño. Lo que haré más tarde. Pruébalo aquí .

Espera que la entrada esté separada por una nueva línea. Si eso no está permitido, lo arreglaré (+2 caracteres). Produce la lista nueva línea separada.

Aquí hay una versión un poco más legible:

n/:@,:^;
'(1.0*'@'+'*+')/'+^+
'('@'*'*+')**(1.0/'+^+')'+
^'/(1.0/'+@'+1.0/'*+')'+
'(1.0/'^+'*('+@'**2+'*+'**2))**0.5'+
'('@'**2+'*+'**2)/'+4$+'*'+^+
]{'"#{'\+'}"'+~}%
n*
Justin
fuente
Parece más Ruby que GolfScript. : P
Dennis
@ Dennis lo es. ;-)
Justin
¿Por qué estás ordenando los medios?
Dennis
@ Dennis no necesito? "Convenientemente, los resultados estarán en orden creciente".
Justin
44
Eso es un comentario, no un requisito. La media armónica es menor o igual que la media geométrica, que es menor o igual que la media aritmética, etc. Por cierto, tiene un error en su media contraarmónica. El resultado debería ser l*lveces mayor, donde les el número de flotadores.
Dennis
3

Idiomas 2

Fortran: 242

No me ha gustado por claridad, pero la versión de golf es lo que cuenta. primero debe ingresar el número de valores que se agregarán, luego los 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

Copia esto en el editor, ctrl+enter y luego llame a través de m([1,2,3,4,5]),numerpara obtener una salida de punto flotante (de lo contrario, obtendrá una salida 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]));
Kyle Kanos
fuente
1
¿Quizás también podría incluir la versión de golf, para que la gente pueda verificar el conteo?
Paŭlo Ebermann
3

Perl 86 76

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

Entrada: un número por línea.

EDITAR: este es un personaje más largo, pero dado que aparentemente las líneas shebang no se cuentan para el total, termina siendo mejor:

#!perl -pl
$"+=1/uc,$,+=log,$}+=lc,$;+=$_**2}for($./$",exp$,/$.,$}/$.,sqrt$;/$.,$;/$}){
Mugriento
fuente
Es habitual contar un shebang que contiene dos conmutadores no predeterminados como dos bytes. Dicho esto, ¡una solución muy impresionante!
Dennis
3

T-SQL, 136 122

Con las listas de números almacenadas en la tabla S con I (entero) identificando la lista y V (flotante) el 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 gracias a Alchymist

MickyT
fuente
1
Me ganó en la solución SQL. Puede guardar bastantes caracteres en los últimos 2 con sqrt (sum (v v) / count ( )) y sum (v * v) / sum (v). Además, en Oracle SQL, puede guardar otro carácter como la función es ln en lugar de iniciar sesión.
Alchymist
@Alchymist Muchas gracias. Face palm :)
MickyT
3

Idiomas: 5

Algunas entradas se esfuerzan por evitar errores de redondeo (a 4 decimales), utilizando BigDecimal de Java en lugar de flotante / doble, y aceptan reglas de E / S por OP.

Las entradas más nuevas relajan las reglas IO y 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}"

muestra de ejecución:

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

muestra de ejecución:

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

ejecución de muestra (tiene una coma final al 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)}}

muestra de ejecución:

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

No está claro si JRuby difiere de Ruby: esto debe ejecutarse en la JVM. Sin embargo, es la sintaxis de Ruby. De cualquier manera, lo estoy incluyendo en el espíritu de una piedra de Rosetta.

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

ejecución de muestra (imprime una advertencia en 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
Michael Easter
fuente
2

Idiomas 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)
AndoDaan
fuente
2

Idiomas - 1

Maravilloso:

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"
Niño pequeño
fuente
55
El objetivo es escribir el código más corto posible para cada idioma, por lo que probablemente desee utilizar identificadores de un solo carácter y omitir espacios en blanco cuando sea posible.
Peter Taylor
1
@PeterTaylor ¡Oh, está bien! No lo sabia. Nuevo aquí.
Little Child
@LittleChild Siéntase libre de editar su código para que sea lo más breve posible. No olvides escribir la cantidad de caracteres que usaste en la parte superior de tu publicación.
mbomb007
2

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

Complete los valores en la primera columna, luego presione el botón (que activa este código) y generará los valores en la segunda columna.

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
Estiramiento maniaco
fuente
2

1 idioma

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

Versión sin golf:

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

Versión compacta de 430 bytes sin bucle o entrada, para probar en 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);}

Actualizado para el nuevo Rust:

Sin golf:

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

Golfizado (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);}
Vi.
fuente
1

Idiomas: 4

CoffeeScript, 193

Toma una cadena de entrada separada por comas:

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

De nuevo, toma una cadena de entrada separada por comas:

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

Mismo concepto:

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

Dado que TypeScript es un superconjunto de JavaScript, podría haber enviado el mismo código, pero eso no sería justo ahora. Aquí hay un código TypeScript minimizado con todas las funciones, variables y parámetros completamente tipados:

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

Podría haber hecho trampa y usar el tipo anytambién ... pero, ya sabes.

rink.attendant.6
fuente
0

Excel - 120

No estoy seguro si esto cuenta como un lenguaje de "programación", pero pensé que la gente podría usar una hoja de cálculo para este tipo de cosas

Con los números en 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)
Brian
fuente
2
No tengo Excel, pero creo que puedes usar el rango A:Apara apuntar a toda la columna A.
Dennis
0

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

Sin golf:

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

Este código debe ejecutarse en la ventana inmediata y la matriz debe llamarse i . Dado que no hay recopilación de errores, ni limpieza, ni caída / liberación de variables, si desea probar este código, puede usar el siguiente fragmento de código (solo pegue en la ventana inmediata y ejecute las líneas en orden):

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 muy especial, solo la opción de usar la ventana inmediata con : para reemplazar los saltos de línea, lo que ahorra unos pocos bytes en lugar de configurar una sub o función y cerrarla; utilizando ? para imprimir en lugar de debug.print (solo en la ventana inmediata); y confiando en cómo vba determina los valores implícitos (agregar un valor a una variable no establecida devuelve el valor) y las operaciones implícitas (cualquier cosa que involucre una cadena es concatenación implícita).

Shazback
fuente