L'objectif du Rosetta Stone Challenge est d'écrire des solutions dans le plus grand nombre de langues possible. Montrez votre programmation multilinguisme!

Le défi

Lorsque les gens utilisent le terme "moyenne", ils désignent généralement la moyenne arithmétique, qui est la somme des nombres divisée par le nombre de nombres. Toutefois, le mot "moyenne" a encore beaucoup de sens, y compris la moyenne harmonique , la moyenne géométrique , la moyenne arithmétique , la moyenne quadratique et la moyenne controharmonique .

Votre défi consiste à écrire un programme qui entre une liste de nombres et les 5 moyens différents. En outre, vous essayez d'écrire des programmes dans autant de langues que possible . Vous êtes autorisé à utiliser n’importe quelle fonction de bibliothèque standard de votre langue, car il s’agit principalement d’une vitrine linguistique.

Contribution

L'entrée sera une liste de nombres positifs.

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

Sortie

La sortie correspondra aux cinq moyennes dans l’ordre indiqué ci-dessus (harmonique, géométrique, arithmétique, quadratique, contraharmonique). De manière pratique, cela équivaut à un ordre croissant.

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

Il y aura une certaine indulgence raisonnable dans le format d'E / S, mais je souhaite plusieurs décimales de précision. Puisque je veux une sortie en virgule flottante, vous pouvez supposer une entrée en virgule flottante.

Le critère gagnant objectif

En ce qui concerne un critère objectif objectif, le voici: chaque langue est un concours distinct pour déterminer qui peut écrire la candidature la plus courte, mais le gagnant est la personne qui remporte le plus grand nombre de ces sous-compétitions. Cela signifie qu'une personne qui répond dans de nombreuses langues peu communes peut obtenir un avantage. Code-golf est généralement un jeu décisif lorsqu'il existe plus d'une solution dans une langue: la personne ayant le programme le plus court obtient un crédit pour cette langue.

En cas d'égalité, le gagnant serait la personne avec le plus grand nombre de soumissions en deuxième place (et ainsi de suite).

Règles, restrictions et notes

Votre programme peut être écrit dans n’importe quelle langue qui existait avant le 2 septembre 2014. Je devrai également compter sur la communauté pour valider certaines réponses écrites dans certains des langages les plus rares / ésotériques, car il est peu probable que je puisse tester leur.

Veuillez conserver toutes vos différentes soumissions dans une seule réponse.

En outre, pas de manigances avec fondamentalement la même réponse dans des dialectes légèrement différents. Je serai le juge quant aux propositions suffisamment différentes.

Classement actuel

Cette section sera périodiquement mise à jour pour indiquer le nombre de langues et le leader dans chacune d'elles.

• Algoid (337) - Beta Decay
• APL (42) - algorithmshark
• Awk (78) - Dennis
• BBC BASIC (155) - Beta Decay
• 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) - Marque
• Common Lisp (183) - DLosc
• Erlang (401) - Marque
• Fortran (242) - Kyle Kanos
• Fortran 77 (286) - Beta Decay
• GNU bc (78) - Dennis
• GolfScript (83) - Dennis
• Groovy (157) - Michael Easter
• Haskell (140) - Zeta
• J (28) - algorithmeshark
• 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
• Octave (68) - Dennis
• Openscript (849?) - COTO
• Pascal (172) - Marque
• Perl (76) - Grimy
• PHP (135) - Dennis
• POV-Ray 3,7 (304) - Marque
• Prolog (235) - DLosc
• Pyth (52) - Dennis
• Python 2 (96) - Dennis
• Python 3 (103) - DLosc
• Q (53) - algorithmeshark
• Q'Nial (68) - algorithmshark
• QBasic (96) - DLosc
• R (91) - plannapus
• Ruby (118) - Martin Büttner
• Rouille (469) - Vi.
• Scala (230) - Michael Easter
• T-SQL (122) - MickyT
• TI-Basic (85) - Ypnypn
• TypeScript (393) - rink.attendant.6
• VBA (Excel) (387) - Maniaque de bout droit
• wxMaxima (134) - Kyle Kanos

Classement des utilisateurs actuels

1. Dennis (10)
2. Martin Büttner (6)
3. Michael Easter (5)
4. Mark, DLosc, algorithmshark (4)
5. Beta Decay (3)
6. Zeta, Kyle Kanos (2)
7. Ourous, AndoDaan, COTO, Grimy, Plannapus, Vi., MickyT, Ypnypn, rink.attendant.6, Stretch Maniac (1)

(Si j'ai commis une erreur dans le classement ci-dessus, faites-le-moi savoir et je la corrigerai. De plus, le bris d'égalité n'a pas encore été appliqué.)

Langues: 1

Openscript (plusieurs centaines)

(Mon langage de programmation obscur et tristement préféré, car j’ai appris à le programmer il ya de nombreuses années.;)

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

Langues: 13

Je pense que cette liste devrait maintenant contenir tous les langages de programmation que je connais suffisamment bien pour résoudre au moins des problèmes simples. J'essaierai de garder cette liste complète au fil du temps au fur et à mesure que je chercherai de nouveaux langages. (J'ai utilisé pour en savoir Smalltalk et Delphi, mais je dois chercher à beaucoup pour les ajouter à sentir.)

C, 196 190 171 165 octets

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

Lit l'entrée sous forme d'arguments de ligne de commande individuels et écrit une liste de moyens séparés par des virgules dans STDOUT.

Merci pour quelques améliorations à Quentin.

C ++, 200 octets

C'est le même que le code C ci-dessus, plus deux inclus. J'inclus cela parce que c'est plus long que la soumission gagnante en C ++, donc je suppose qu'aucun mal n'est causé, et j'aimerais que ce message contienne en réalité toutes les langues que je connais. :)

#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 octets

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

Définit une fonction dans une classe prenant un Listdouble et renvoyant un tableau de doubles avec les cinq moyennes.

Merci pour quelques améliorations à Visual Melon et Bob.

CJam, 52 octets

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

Prend l'entrée en tant qu'argument de ligne de commande et imprime une liste avec les cinq valeurs dans STDOUT.

CoffeeScript, 155 octets

C'est presque la même chose que la solution JavaScript plus bas (et au départ, je ne l'ai pas comptée pour cette raison), mais le PO l'a inclus de toute façon dans le tableau de bord, alors je l'ai promue en soumission complète. Ce sont des langues techniquement différentes après tout.

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 octets

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

Définit une fonction prenant un tableau de nombres et renvoyant un tableau avec les cinq moyennes.

Merci pour quelques améliorations à William Barbosa.

Julia, 79 octets

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

Définit une fonction prenant une liste de nombres et renvoyant une liste avec les cinq moyennes.

Lua, 120 octets

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

Définit une fonction prenant une liste de nombres et renvoyant 5 valeurs distinctes pour les moyennes.

Mathematica, 73 67 65 octets

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

Définit une fonction prenant une liste de nombres à virgule flottante et renvoyant une liste avec les cinq moyennes.

Fait amusant: Mathematica possède les 5 moyens intégrés (et c'était ma soumission originale), mais trois d'entre eux peuvent être implémentés avec moins de caractères que leurs noms de fonctions.

Matlab, 65 63 octets

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

Demande l'entrée sous forme de tableau de nombres à l'utilisateur et génère les cinq moyennes individuellement.

Merci pour quelques améliorations à Dennis Jaheruddin.

PHP ≥ 5.4, 152 149 143 octets

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

Même implémentation fonctionnelle que les précédentes.

Merci pour quelques améliorations à Ismael Miguel.

Python 2, 127 octets

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]

Même implémentation fonctionnelle que les précédentes.

Ruby, 129 118 octets

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

Même implémentation fonctionnelle que les précédentes.

4 langues

J - 32 28 car!

Une fonction prenant la liste des nombres comme unique argument.

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

a voici un adverbe, qui est J prend sur les fonctions de second ordre.

• +/ % # est un train dans J, ce qui signifie Somme divisée par le Compte, la définition de la moyenne arithmétique.
• &.:est une conjonction appelée Under, où u&.:v(y)est équivalent à vi(u(v(y)))et viest l'inverse fonctionnel de v. Oui, J peut prendre des inverses fonctionnels .
• Enfin, une fonctionnalité utile de J est que certaines fonctions peuvent automatiquement boucler sur des listes, parce que J sait les appliquer de manière ponctuelle s’il n’a aucun sens de les appliquer à l’ensemble de l’argument. Ainsi, le carré d'une liste est une liste de carrés, par exemple.

Ainsi, aprend une fonction à gauche et renvoie une moyenne qui "ajuste" les valeurs par la fonction, prend la moyenne arithmétique, puis inverse l'ajustement par la suite.

• %a est la moyenne harmonique, parce que % signifie réciproque, et est son propre inverse.
• ^.aest la moyenne géométrique, car ^.est le logarithme naturel et son inverse est l'exponentielle.(Π x)^(1/n) = exp(Σ log(x)/n)
• [aest la moyenne arithmétique, car [est la fonction d'identité.
• *:aest la moyenne quadratique, car *:est Carré et son inverse est la racine carrée.
• Le contreharmonique nous donne toute une série de problèmes - moyenne des carrés divisés par moyenne - nous faisons donc un peu de calcul pour l’obtenir: ( *:adivisé par ( [adivisé par *:a)). Cela ressemble [a(]%%)*:a. Pendant que nous y sommes, nous PREPEND chacun des moyens, [a(,,]*%~)*:a.

Enfin, nous utilisons des virgules pour annexer le reste des résultats. Nous n'avons pas besoin de parenthèses supplémentaires car la concaténation est (dans ce cas du moins) associative.

En usage sur le 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 caractères

Fonction à argument unique. Nous faisons juste une liste de tous les moyens que nous voulons.

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

La même chose dans les autres versions de k est ci-dessous.

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

APL - 42 caractères

Fonction prenant la liste comme argument.

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

Expliqué par explosion:

{                                         } ⍝ 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 caractères

Vous allez aimer celui-ci.

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

Q'Nial est un autre langage orienté sur les tableaux, une implémentation de Nial , qui est basé sur une obscure théorie des tableaux de la même manière que Haskell est basé sur la théorie des catégories. (Obtenez-le ici .) C'est très différent de l'un des trois autres - il analyse d'abord de gauche à droite!

12 langues

CJam, 45 44 43 octets

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

Lit un tableau de flottants (par exemple, [1.0 2.0 3.0 4.0 5.0]) à partir de STDIN. Essayez-le en ligne.

APL, 67 61 53 52 50 octets

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

Essayez-le en ligne.

Pyth, 55 52 octets

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

Lit les nombres séparés par des espaces (par exemple, 1 2 3 4 5) à partir de STDIN.

Octave, 68 octets

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

Sans compter le shebang. Lit un tableau (par exemple,[1 2 3 4 5] ) à partir de STDIN.

GNU bc, 78 octets

#!/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

Compter le shebang comme 1 octet ( -lcommutateur). Lit les espaces séparés de STDIN séparés par des espaces, suivis d'un zéro.

Awk, 78 octets

#!/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}

Sans compter le shebang. Lit un numéro par ligne à partir de STDIN.

GolfScript, 86 83 octets

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

GolfScript ne prenant pas en charge les flottants, le code les analyse. Par conséquent, le format de saisie est plutôt restrictif: vous devez saisir 1.0et 0.1plutôt que 1, 1.ou .1.

Lit les flottants (comme expliqué ci-dessus) un par ligne, à partir de STDIN. Essayez-le en ligne.

Perl, 90 85 octets

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

Compter le shebang comme 1 octet ( -ncommutateur). Lit un numéro par ligne à partir de STDIN.

Python 2, 102 à 96 octets

#!/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

Sans compter le shebang. Lit une liste de flottants (par exemple, 1.0,2.0,3.0,4.0,5.0) de STDIN.

ECMAScript 6 (JavaScript), 114 112 octets

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

Sans compter le LF. Attend un tableau (par exemple, [1,2,3,4,5]) comme argument.

PHP, 135 (ou 108?) Octets

#!/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]);

Sans compter shebang ou LF. Lit float en tant qu'argument de ligne de commande.

J'ai une solution plus courte, mais je ne sais pas compter les octets:

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

En comptant les octets dans chaque chaîne de code et en ajoutant deux pour -Ret -E, cette approche donnerait 108.

C, 172 140 139 137 136 136 octets

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

Sans compter le LF. Compiler avec gcc -lm. Lit les espaces séparés de STDIN.

J (50):

Voici le genre de choses sur lesquelles J est doué:

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

Comme toujours: une explosion dans l'usine de smileys. Cependant, certains des smileys sont restés intacts cette fois-ci: :)et :*:(c'est un gars avec quatre yeux et une gemme intégrée dans son visage) Ma session interactive qui a été utilisée pour créer ceci: http://pastebin.com/gk0ksn2b

En action:

   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

Explication:

Comme on pouvait s'y attendre, 5 fonctions sont regroupées dans une liste contenant un train de fourchettes et de crochets. (Ne vous inquiétez pas, c'est un moyen pratique de créer plusieurs fonctions en sortie dans une seule liste).

Les lignes que j’ai utilisées pour que J génère cette réponse pourraient être un peu plus claires:

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

Regardons-les séparément.

Harmonique

(# % +/@:%)

• # - Longueur (du tableau)
• % - Divisé par
• +/@:% - La somme (+/ ou pli +du tableau ( +/1 2 3 4==1+2+3+4 )) au sommet de la division, mais cette fois dans le cas monadique. Ce que cela signifie ici, c’est que J "devine" automatiquement que 1 serait la valeur la plus utile.

Géométrique

(# %: */)

• # - Longueur (du tableau)
• %:- Root ( 4 %: 7signifierait « la quatrième (ou Tesseract) racine de sept)
• */ - Produit (*/ est similaire à +/, voir la fonction précédente pour cela)

Arithmétique

(+/ % #)

• +/ - somme, devrait être familier maintenant
• % - divisé par
• # - longueur

Racine moyenne carrée

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

Euh, ouais ...

• %: - La racine de
  • %@# - l'inverse de la longueur
  • * - les temps
  • +/@:*:- La somme des carrés ( *:est au carré, même si l' *~est aussi.)

Contraharmonique

+/@:*: % +/

• +/@:*: - la somme des carrés
• % - divisé par
• +/ - la somme.

En fait, j'ai découvert que ma fonction consistait à expliquer un octet sur deux octets de trop, alors c'est bien!

Si J était juste aussi doué pour le traitement des chaînes, nous gagnerions beaucoup plus de compétitions de golf ...

Langues: 5

POV-Ray 3.7 Langue de description de la scène: 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 n’a pas de fonctions d’entrée console, c’est pourquoi j’ai substitué l’entrée fichier. La sortie est envoyée à la console, mais elle est entourée d’une bonne partie de la sortie de l’état du programme.)

Commodore BASIC: 111 104 octets

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

(Tous les caractères de ce programme ne peuvent pas être représentés en Unicode. |Est utilisé pour représenter SHIFT+H, ┌représenter SHIFT+O, ┐représenter SHIFT+P, /représenterSHIFT+N . En raison des limitations de Commodore Basic I / O, l’entrée est entrée chiffre par numéro, avec une entrée -1 pour indiquer la fin de l'entrée. La sortie est délimitée par des tabulations.)

QBasic: 96 octets

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

Utilise le même schéma d'E / S que l'entrée de DLosc; J'ai utilisé 15 octets INPUT Vde golf en renvoyant 0 (ce qui donne false) lorsqu'une ligne vide est entrée (au moins dans MS-DOS QBasic 1.1 - je ne sais pas si cela fonctionne également dans QB64).

Pascal (compilateur FPC): 172 octets

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.

L'entrée est séparée par des espaces, pas de virgules, et se termine par une nouvelle ligne. La sortie est séparée par des espaces.

Erlang: 401 octets

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

La manipulation des cordes à Erlang est une douleur royale. Par conséquent, tous les nombres en virgule flottante doivent être entrés avec au moins un chiffre après le signe décimal -string:to_float/1 ils ne seront pas convertis 1mais convertis.1.0 .

(Plus à venir, surtout si je découvre comment faire cela dans RoboTalk, un langage sans opérations en virgule flottante ni E / S)

Langues: 3

Sauf indication contraire, les nombres doivent être séparés par espace.

C: 181 163

Prend les nombres jusqu'à la fin de la saisie.

#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

Prend les nombres jusqu'à la fin de la saisie.

#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

Prend arbitrairement de nombreuses listes de numéros séparés par une nouvelle ligne.

la mise en oeuvre

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 (merci shiona) octets ne sont que pour IO: /.

Exemple

( echoAka de Powershell Write-Outputimprime chaque paramètre sur une seule ligne)

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.666666666666665]
[3.011834514901806,4.621794669196026,8.412666666666,12.234139719108438,17,791525635945792]

Langues - 4

J'aime toujours une excuse pour sortir bon vieux

QBasic, 112 96 octets

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 n'est pas bon avec un nombre d'entrées variable, le programme nécessite donc un nombre par ligne, terminé par 0 ou une ligne vide. La sortie est séparée par des espaces.

(Réduit une fois que j'ai compris que 0 n'est pas un nombre valide et peut être utilisé pour la terminaison d'entrée.)

Testé avec QB64 :

Common Lisp, 183 octets

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

Pour une raison quelconque, je m'attendais à ce que ce soit plus court. Je ne suis pas un expert en Lisp, les conseils sont donc appréciés. Version non-golfée:

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

Le meilleur moyen de tester consiste probablement à coller la fonction dans le clispREPL, comme suit:

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

J'adore la façon dont Lisp utilise des fractions exactes au lieu de float pour diviser deux entiers.

Prolog, 235 octets

Prolog n'est pas bon en maths, mais on va l'utiliser quand même. Testé avec SWI-Prolog. Je pense que le sumlistprédicat n'est peut-être pas un Prolog standard, mais peu importe, je l'utilise.

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

Sous Linux, avec le code dans un fichier appelé means.pro, testez comme ceci:

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

Donne un résultat correct mais plutôt amusant quand il n'y a qu'un seul chiffre:

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

Python 3, 103 octets

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)

Même stratégie que la version de Dennis Python 2. Prend une liste de nombres séparés par des virgules; gère à la fois les ints et les flotteurs. Une entrée à un seul chiffre doit être entourée d'accolades (et une liste de nombres peut l' être toujours ); un correctif coûterait 4 octets.

8 langues

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

Sortie:

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)

Sortie:

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

Je ne suis pas un Javascripter alors tout conseil serait grandement apprécié

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

Recherchez-le sur le Google Play Store ou le 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

C’est syntaxiquement correct et tout, mais tous les interprètes actuels ne fonctionnent tout simplement pas ...

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'

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

Langues - 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 langue

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

Prend un vecteur de valeur et génère un vecteur de moyen.

1 langue

Golfscript, 162

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

Oui, c'est énorme. Et cela peut certainement être réduit. Ce que je ferai un peu plus tard. Essayez-le ici .

Il s'attend à ce que l'entrée soit séparée par une nouvelle ligne. Si cela n'est pas autorisé, je le corrigerai (+2 caractères). Il sort la liste newline séparée.

Voici une version légèrement plus lisible:

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

Langues 2

Fortran: 242

Je l'ai ungolfé pour plus de clarté, mais c'est la version golfée qui compte. vous devez d’abord saisir le nombre de valeurs à ajouter, puis les valeurs.

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

Copiez ceci dans l'éditeur, ctrl+enterpuis appelez via m([1,2,3,4,5]),numerpour obtenir une sortie en virgule flottante (sinon, vous obtenez une sortie symbolique).

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

Entrée: un numéro par ligne.

EDIT: c'est un caractère de plus, mais comme apparemment les lignes de shebang ne comptent pas dans le total, cela finit par être meilleur:

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

T-SQL, 136 122

Avec les listes de numéros stockées dans la table S avec I (entier) identifiant la liste et V (float) la valeur.

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

Nous avons économisé 14 grâce à Alchymist

Langues: 5

Certaines entrées s'efforcent d'éviter les erreurs d'arrondi (jusqu'à 4 décimales) en utilisant BigDecimal de Java au lieu de float / double et acceptent les règles IO par OP.

Les nouvelles entrées assouplissent les règles IO et BigDecimal.

Groovy - 409 400 164 157 caractères

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

exemple de cycle:

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 caractères

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

exemple de cycle:

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 caractères

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

exemple de cycle (il y a une virgule de fin à la fin):

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 caractères

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

exemple de cycle:

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 caractères

On ne sait pas si JRuby diffère de Ruby: cela doit être exécuté sur la machine virtuelle Java. Pourtant, c'est la syntaxe Ruby. De toute façon, je l'inclue dans l'esprit d'une pierre de Rosette.

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

exemple d’exécution (affiche un avertissement à 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

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

Langues - 1

Sensationnel:

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 langues

Java - 243 octets

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

étendu:

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 octets

Renseignez les valeurs dans la première colonne, puis appuyez sur le bouton (qui déclenche ce code) pour afficher les valeurs dans la deuxième colonne.

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 langue

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

Version non-golfée:

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

Version compactée de 430 octets sans boucle ni entrée, à tester en lecture seule :

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

Mise à jour pour la nouvelle rouille:

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

Golfé (402 octets):

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

Langues: 4

CoffeeScript, 193

Prend une chaîne d'entrée séparée par des virgules:

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

Encore une fois, prend une chaîne d'entrée séparée par des virgules:

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

Même concept:

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

TypeScript, 393 *

Puisque TypeScript est un sur-ensemble de JavaScript, j'aurais pu simplement soumettre le même code, mais ce ne serait pas vraiment juste maintenant. Voici un code TypeScript minifié avec toutes les fonctions, variables et paramètres entièrement typés:

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

Pourrait avoir triché et utilisé le type anyaussi ... mais, vous savez.

Excel - 120

Pas sûr que cela compte comme un langage de "programmation", mais on pourrait penser que les gens peuvent utiliser un tableur pour ce genre de choses

Avec les chiffres 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)

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

Ce code doit être exécuté dans la fenêtre immédiate et le tableau doit être appelé i . Puisqu'il n'y a pas de collecte d'erreur, pas de nettoyage, pas de suppression / libération de variable, si vous voulez tester ce code, vous pouvez utiliser le code suivant (il suffit de coller dans la fenêtre immédiate et d'exécuter les lignes dans l'ordre):

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

Rien de très spécial, juste le choix d'utiliser la fenêtre immédiate avec : pour remplacer les sauts de ligne, ce qui économise quelques octets par rapport à la configuration et à la fermeture d'une sous-fonction ou d'une fonction; en utilisant ? pour imprimer plutôt que debug.print (seulement dans la fenêtre immédiate); et en s'appuyant sur la façon dont vba détermine les valeurs implicites (l'ajout d'une valeur à une variable non définie renvoie la valeur) et les opérations implicites (toute opération impliquant une chaîne est une concaténation implicite).