Nous savons tous que le nombre d'Euler , noté e, à la puissance d'une variable x, peut être approximé en utilisant l' expansion de la série Maclaurin :

En laissant x égal à 1, on obtient

Défi

Écrivez un programme dans n'importe quelle langue qui se rapproche du nombre d'Euler en prenant une entrée N et calcule la série au N-ème terme. Notez que le premier terme a le dénominateur 0 !, pas 1 !, c'est-à-dire que N = 1 correspond à 1/0 !.

Notation

Le programme avec le moins d'octets gagne.

code-golf math number approximation Meow Mix
la source

7

NSi les valeurs sont suffisamment grandes, les résultats seront les mêmes si vous utilisez un nombre à virgule flottante de précision finie. Ce comportement est-il acceptable ou le résultat doit-il progressivement devenir plus précis à l' Napproche de l'infini?

FryAmTheEggman

12

Certains cas de test seraient soignés.

Lynn

7

(Ce type de problème est de préférence résolu dans le bac à sable - si vous postez vos défis en premier, les golfeurs donneront des commentaires utiles.)

Lynn

2

X ^ n est-il le nième terme ou le (n + 1) ème?

msh210

4

Je le méprise personnellement, mais il y a des gens qui se réfèrent au terme à l'index 0 comme un terme nul. Indépendamment de nos réflexions à ce sujet, la question doit être aussi claire que possible. De plus, quelques cas de test pour vérifier que les solutions fonctionnent correctement seraient très utiles.

Dennis

12

Gelée , 5 octets

R’!İS

Essayez-le en ligne!

Comment ça fonctionne

R’!İS  Main link. Argument: n

R      Yield the range [1, ..., n].
 ’     Map decrement over the list.
  !    Map factorial over the list.
   İ   Map inverse over the list.
    S  Compute the sum.

Dennis
la source

8

"Avoir un intégré pour [1, n] est plus logique que d'en avoir un pour [0, n) à mon humble avis."

Leaky Nun

6

… Et un mois et un peu plus tard, Jelly a Ḷ, ce qui fait une gamme [0, n) . ^ v ^;

Lynn

13

Wistful-C - 336 octets

Mon premier vrai programme mélancolique! Il y a en fait un peu de golf que j'ai fait, en utilisant somedayau lieu de wait forparce que le premier avait une longueur plus courte.

if only <stdio.h> were included...
if only int f were 1...
if only int N were 0...
wish for "%d",&N upon a star
if only int i were 0...
if only double e were 0...
someday i will be N...
        if only e were e+1./f...
        if only i were i+1...
        if only f were f*i...
*sigh*
wish "%f\n",e upon a star
if wishes were horses...

Maltysen
la source

On m'a dit que vous n'avez pas besoin d'inclure<stdio.h>

Leaky Nun

Fonctionne someday i were N...au lieu de someday i will be N...?

Leaky Nun

10

Pyth, 7 6 octets

smc1.!

Essayez-le ici.

 m      map over range 0..input:
    .!  factorial
  c1    1 / ^
s       sum

Merci à FryAmTheEggman pour un octet!

Poignée de porte
la source

9

TI-84 BASIC, 12 15 14

Input N
Σ(A!⁻¹,A,0,N

TI est un langage à jetons (les octets sont comptés via des jetons , pas des caractères individuels).

Sans nom
la source

1

Le meta post cité a 11 votes positifs et 10 votes négatifs. Ce n'est pas un consensus. Ansn'est pas un format d'entrée valide, donc seule la version à 15 octets est valide.

Mego

C'est suffisant; montage ...

No Name

1

Ansa toujours été le format d'entrée par défaut ici chez PPCG (regardez mes anciennes réponses TI), et plus de gens sont d'accord que pas d'accord, alors ne vous laissez pas intimider pour changer votre réponse.

Timtech

2

@MickLH ce n'est pas le litige ici. En outre, ce sont des octets de 8 bits.

hobbs

1

@Timtech Bien que je sois d'accord avec vous, le consensus communautaire est défini comme le dit Mego.

Conor O'Brien

9

Julia, 28 27 21 octets

n->sum(1./gamma(1:n))

Il s'agit d'une fonction anonyme qui accepte un entier et renvoie un flottant. Pour l'appeler, affectez-le à une variable.

L'approche est assez simple. Nous sum1 divisé par la fonction gamma évaluée à chacun de 1 à n . Cela profite de la propriété n ! = Γ ( n +1).

Essayez-le en ligne!

Enregistré 1 octet grâce à Dennis et 6 grâce à Glen O!

Alex A.
la source

Presque exactement la même chose dans MATLAB:@(n)sum(1./factorial(0:n))

flawr

6

Python, 36 octets

Python 2:

f=lambda n,i=1:n/i and 1.+f(n,i+1)/i

Python 3:

f=lambda n,i=1:i<=n and 1+f(n,i+1)/i

xnor
la source

Variante Python 3 pourrait être plus courte avec au orlieu de and: f=lambda n,i=1:i>=n or 1+f(n,i+1)/i.

Constructeur

6

dc, 43 octets

[d1-d1<f*]sf[dlfx1r/r1-d1<e+]se1?dk1-d1<e+p

Il s'agit d'une traduction assez directe de la série. J'ai essayé d'être plus intelligent, mais cela a abouti à un code plus long.

Explication

[d1-d1<f*]sf

Une fonction factorielle simple, pour n> 0

[dlfx1r/r1-d1<e+]se

Exécutez la factorielle pour n, ..., 1; inverser et additionner

1?dk1-

Amorcez la pile avec 1; accepter l'entrée et définir une précision appropriée

d1<e+

Si l'entrée était 0 ou 1, nous pouvons simplement la transmettre, sinon calculer la somme partielle.

Imprimez le résultat.

Résultats de test

Les 100 premières extensions:

0
1
2
2.500
2.6666
2.70832
2.716665
2.7180553
2.71825394
2.718278766
2.7182815251
2.71828180110
2.718281826194
2.7182818282857
2.71828182844671
2.718281828458223
2.7182818284589936
2.71828182845904216
2.718281828459045062
2.7182818284590452257
2.71828182845904523484
2.718281828459045235331
2.7182818284590452353584
2.71828182845904523536012
2.718281828459045235360273
2.7182818284590452353602862
2.71828182845904523536028736
2.718281828459045235360287457
2.7182818284590452353602874700
2.71828182845904523536028747123
2.718281828459045235360287471339
2.7182818284590452353602874713514
2.71828182845904523536028747135253
2.718281828459045235360287471352649
2.7182818284590452353602874713526606
2.71828182845904523536028747135266232
2.718281828459045235360287471352662481
2.7182818284590452353602874713526624964
2.71828182845904523536028747135266249759
2.718281828459045235360287471352662497738
2.7182818284590452353602874713526624977552
2.71828182845904523536028747135266249775705
2.718281828459045235360287471352662497757231
2.7182818284590452353602874713526624977572453
2.71828182845904523536028747135266249775724691
2.718281828459045235360287471352662497757247074
2.7182818284590452353602874713526624977572470919
2.71828182845904523536028747135266249775724709352
2.718281828459045235360287471352662497757247093683
2.7182818284590452353602874713526624977572470936984
2.71828182845904523536028747135266249775724709369978
2.718281828459045235360287471352662497757247093699940
2.7182818284590452353602874713526624977572470936999574
2.71828182845904523536028747135266249775724709369995936
2.718281828459045235360287471352662497757247093699959554
2.7182818284590452353602874713526624977572470936999595729
2.71828182845904523536028747135266249775724709369995957475
2.718281828459045235360287471352662497757247093699959574944
2.7182818284590452353602874713526624977572470936999595749646
2.71828182845904523536028747135266249775724709369995957496673
2.718281828459045235360287471352662497757247093699959574966943
2.7182818284590452353602874713526624977572470936999595749669652
2.71828182845904523536028747135266249775724709369995957496696740
2.718281828459045235360287471352662497757247093699959574966967601
2.7182818284590452353602874713526624977572470936999595749669676254
2.71828182845904523536028747135266249775724709369995957496696762747
2.718281828459045235360287471352662497757247093699959574966967627699
2.7182818284590452353602874713526624977572470936999595749669676277220
2.71828182845904523536028747135266249775724709369995957496696762772386
2.718281828459045235360287471352662497757247093699959574966967627724050
2.7182818284590452353602874713526624977572470936999595749669676277240739
2.71828182845904523536028747135266249775724709369995957496696762772407632
2.718281828459045235360287471352662497757247093699959574966967627724076601
2.7182818284590452353602874713526624977572470936999595749669676277240766277
2.71828182845904523536028747135266249775724709369995957496696762772407663006
2.718281828459045235360287471352662497757247093699959574966967627724076630325
2.7182818284590452353602874713526624977572470936999595749669676277240766303508
2.71828182845904523536028747135266249775724709369995957496696762772407663035328
2.718281828459045235360287471352662497757247093699959574966967627724076630353518
2.7182818284590452353602874713526624977572470936999595749669676277240766303535449
2.71828182845904523536028747135266249775724709369995957496696762772407663035354729
2.718281828459045235360287471352662497757247093699959574966967627724076630353547565
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475915
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759429
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594542
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945681
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457111
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571352
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713792
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138185
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382143
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821752
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217826
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178492
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785218
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852481
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525131
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251635
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516607
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166394

En utilisant 1000 termes:

2.7182818284590452353602874713526624977572470936999595749669676277240\
766303535475945713821785251664274274663919320030599218174135966290435\
729003342952605956307381323286279434907632338298807531952510190115738\
341879307021540891499348841675092447614606680822648001684774118537423\
454424371075390777449920695517027618386062613313845830007520449338265\
602976067371132007093287091274437470472306969772093101416928368190255\
151086574637721112523897844250569536967707854499699679468644549059879\
316368892300987931277361782154249992295763514822082698951936680331825\
288693984964651058209392398294887933203625094431173012381970684161403\
970198376793206832823764648042953118023287825098194558153017567173613\
320698112509961818815930416903515988885193458072738667385894228792284\
998920868058257492796104841984443634632449684875602336248270419786232\
090021609902353043699418491463140934317381436405462531520961836908887\
070167683964243781405927145635490613031072085103837505101157477041718\
986106873969655212671546889570350116

Toby Speight
la source

5

J, 10 octets

[:+/%@!@i.

Approche directe.

Explication

[:+/%@!@i.    Input: n
        i.    Creates the range [0, 1, ..., n-1]
      !@      Maps factorial to each
    %@        Map 1/x to each
[:+/          Take the sum of the values and return it

miles
la source

Agréable. Amélioration triviale de 1 octet:1#.%@!@i.

Jonah

4

CJam, 11

r~,:m!Wf#:+

ou

r~{m!W#}%:+

Essayez-le en ligne: première version et deuxième version

Explication:

r~= lire et évaluer
m!= factoriel
W#= monter à -1 puissance ( W= -1)
:+= somme du tableau La
première version construit le tableau [0… N-1] et applique le factoriel et l'inverse à tous ses éléments; La 2ème version fait factorielle et inverse pour chaque nombre puis les place dans un tableau.

aditsu
la source

4

JavaScript ES6, 44 42 40

n=>{for(k=s=m=1;m<n;s+=k/=m++);return s}

Une fonction sans nom maintenant.

Merci d'avoir sauvé 2 octets @AlexA et merci à @LeakyNun pour encore 2 octets!

ಠ_ಠ
la source

n=>{for(k=s=m=1;m<n;s+=k/=m++);return s}

Leaky Nun

4

MATL, 11 7 octets

:Ygl_^s

4 octets économisés grâce à la recommandation de @ Luis d'utiliser gamma( Yg)

Essayez-le en ligne

Explication

        % Implicitly grab input (N)
:       % Create an array from 1...N
Yg      % Compute factorial(x-1) for each element (x) in the array
l_^     % Take the inverse
s       % Sum all elements
        % Implicitly display the result

Suever
la source

Vous pouvez supprimer]

Luis Mendo

Aussi, 1i:Yg/spour 7 octets

Luis Mendo

@LuisMendo oh yea J'espérais qu'il y avait une meilleure façon d'obtenir une factorielle mais j'avais oublié le gamma. Mise à jour sous peu

Suever

4

MATL , 6 octets

q_t1Zh

Ceci calcule la somme en utilisant la fonction hypergéométrique ₁F ₁ ( a ; b ; z ):

Fonctionne sur Octave et sur le compilateur en ligne, mais pas sur Matlab, en raison d' une différence dans la définition de la fonction hypergéométrique (qui sera corrigée).

Essayez-le en ligne!

Explication

q_    % Take N implicitly. Compute -N+1
t     % Duplicate
1     % Push 1
Zh    % Hypergeometric function 1F1(-N+1;-N+1;1). Implicitly display

Luis Mendo
la source

4

C, 249 octets

#include <stdio.h>
#include <stdlib.h>
#define z double
z f(z x){z r=1;z n=1;while(x>0){r*=n;n++;x--;}return r;}int main(int argc, char **argv){z e=0;z p=0;z d=0;p=strtod(argv[1],NULL);while(p>0){e+=1.0d/f(d);printf("%.10f\n",e);p--;d++;}return 0;}

Non golfé:

/* approximate e */

#include <stdio.h>
#include <stdlib.h>

double fact(double x){
    double result = 1;
    double num = 1;

    while (x > 0){
        result *= num;
        num++;
        x--;
    }
    return result;
}

int main(int argc, char **argv){
    double e = 0;
    double precision = 0;
    double denom = 0;

    precision = strtod(argv[1], NULL);
    while (precision > 0){
        e += 1.0d / fact(denom);
        printf("%.10f\n", e);
        precision--;
        denom++;
    }
    return 0;
}

Prend un nombre comme argument pour déterminer le nombre d'itérations.

LordCreepity
la source

Bonjour et bienvenue chez PPCG! Excellent premier post!

NoOneIsHere

Bienvenue sur Programmation Puzzles & Code Golf! Je pense que le programme est destiné à imprimer uniquement la dernière approximation. Au moins avec GCC, vous n'avez pas besoin de l' intavant mainet du return 0. De plus, si vous remplacez NULLpar 0, vous n'avez pas besoin des inclusions. argcet argvpeut être raccourci en variables à lettre unique. Si vous aimez jouer au golf en C, les conseils pour jouer au golf en C pourraient vous être utiles.

Dennis

À mon humble avis, même si le compilateur émet quelques avertissements mais renvoie le résultat correct néanmoins, vous pouvez jeter de nombreuses parties de votre code au point que rien ne pourrait être réduit sans erreur.

Andreï Kostyrka

Et vous n'avez pas besoin#include <stdio.h>

Leaky Nun

3

k (13 octets)

Sous réserve de débordements pour N>20

{+/%*\1,1+!x}

skeevey
la source

3

05AB1E, 6 octets

$L<!/O

Expliqué

$           # push 1 and input: N = 5
 L<         # range [0..N-1]: [0,1,2,3,4]
   !        # factorial over range [1,1,2,6,24]
    /       # divide 1/range: [1.0, 1.0, 0.5, 0.16666666666666666, 0.041666666666666664]
     O      # sum: 2.708333333333333

Essayez-le en ligne

Emigna
la source

1

5 octets avec L<!zO.

Grimmy

3

Pyke, 10 octets

FSBQi^R/)s

Essayez-le ici!

Ou 8 octets si puissance = 1

FSB1R/)s

Essayez-le ici!

Bleu
la source

le premier code a été désactivé par plus de 3 lorsque je l'ai exécuté: 5.436532738095238

tox123

@ tox123 fixe maintenant

Blue

les testez-vous? J'ai eu: 7.3887125220458545 pour le premier, le second fonctionne beaucoup mieux.

tox123

Celui-là est un e ^ x un que vous connaissez pas seulement e

Blue

ce n'est pas le défi.

tox123

3

JavaScript (ES6), 28 octets

f=(n,i=1)=>n&&1+f(n-1,i+1)/i

Neil
la source

3

Dyalog APL , 6 octets

+/÷!⍳⎕

+/somme des
÷inverses des
!factorielles des
⍳nombres de 0 à
⎕l'entrée numérique

Suppose ⎕IO←0, qui est par défaut sur de nombreux systèmes.

TryAPL !

Adam
la source

3

Haskell, 37 octets

((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)

Pas le plus court, mais sans doute le plus joli.

Avec l' aimable autorisation de Laikoni , voici une solution plus courte de 2 octets :

sum.(`take`((1/)<$>scanl(*)1[1..]))

λ> let f = ((scanl (+) 0 $ (1/) <$> scanl (*) 1 [1..]) !!)

λ> map f [1..5]
[1.0,2.0,2.5,2.6666666666666665,2.708333333333333]

λ> f 10
2.7182815255731922

λ> f 100
2.7182818284590455

λ> log (f 10)
0.9999998885745155

λ> log (f 100)
1.0

Rodrigo de Azevedo
la source

2

Vous pouvez utiliser ce compteur d'octets UTF-8 . J'ai mis une modification suggérée pour ajouter votre nombre d'octets, ce qui est 50. Pour ajouter un en- tête, utilisez: ## Language, <xxx> bytes.

NoOneIsHere

1

Avez-vous besoin d'espace blanc?

NoOneIsHere

1

Vous ne pouvez pas supposer que l'entrée est présente dans une variable, vous devez donc ajouter un préfixe f n=ou \n->obtenir une soumission de fonction valide. Cependant, nous pouvons également économiser quelques octets: (\x->1/x)peut être raccourci à la section (1/), [1,2..]est identique [1..]et map(...)$peut l'être (...)<$>. Ensemble 36 octets: essayez-le en ligne!

Laikoni

1

La conversion en fonction sans point permet d'économiser un autre octet: essayez-le en ligne! Et même si c'est un octet plus long, ((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)ça a l'air bien aussi.

Laikoni

1

Comme vous l'avez vu vous-même, la version sans parenthèses n'est qu'une expression Haskell valide lors de l'insertion d'une valeur après celle-ci, mais comme en supposant que l'entrée d'être présente dans une variable prédéfinie n'est pas autorisée , vous devez ajouter les parenthèses ou à nouveau un début \n->pour créer une fonction.

Laikoni

3

APL (Dyalog Unicode) , 5 octets

⍳⊥⊢÷!

Essayez-le en ligne!

En utilisant l'astuce de base mixte trouvé dans ma réponse d' un autre défi . Utilise ⎕IO←0.

Comment ça fonctionne

⍳⊥⊢÷!  Right argument: n, the number of terms
  ⊢÷!  v: 1÷(n-1)!
⍳      B: The array of 0 .. n-1
 ⊥     Expand v to length-n array V,
       then mixed base conversion of V in base B

Base | Digit | Value
--------------------
0    | v     | v×(1×2×..×(n-1)) = 1÷0!
1    | v     | v×(2×3×..×(n-1)) = 1÷1!
2    | v     | v×(3×..×(n-1))   = 1÷2!
..   | ..    | ..
n-2  | v     | v×(n-1)          = 1÷(n-2)!
n-1  | v     | v                = 1÷(n-1)!

Bubbler
la source

10k rep! Maintenant pour voir si je peux retirer ça dans Turing Machine ....

ouflak

Belle réponse mais j'ai du mal à voir comment 1÷(n-1)!va un chiffre? Pourriez-vous le traduire en J pour clarifier?

Jonah

2

En fait, 6 octets

r♂!♂ìΣ

Essayez-le en ligne!

Explication:

r♂!♂ìΣ
r       range(N) ([0, N-1])
 ♂!     factorial of each element
   ♂ì   reciprocal of each element
     Σ  sum

Mego
la source

2

Brachylog , 18 octets

:1-:0r:ef:$!a:/a+.

Explication

:1-                 Subtract 1 from Input
   :0r              Create the list [0, Input - 1]
      :ef           Find all integers between 0 and Input - 1
         :$!a       Apply factorial to each member of that list
             :/a    Apply inverse to each element of that list
                +.  Unify the output with the sum of the list

Fatalize
la source

2

Érable, 18

add(1/i!,i=0..n-1)

Usage:

> f:=n->add(1/i!,i=0..n-1);
> f(1);
  1
> f(4);
  8/3

DSkoog
la source

Je pense que la fonction est n-> add (1 / i!, I = 0..n-1)

RosLuP

2

C, 69 octets

double f(int n){double s=1,f=1;for(int i=0;i++<n;s+=f)f/=i;return s;}

Ideone it!

Leaky Nun
la source

2

Java avec pôle laser de dix pieds , 238 236 octets

import sj224.tflp.math.*;interface U{static void main(String[]a){BigRational r=null,s,t;r=s=t=r.ONE;for(int n=new java.util.Scanner(System.in).nextInt()-1;n-->0;){t=t.multiply(r);s=s.add(t.pow(-1));r=r.add(r.ONE);}System.out.print(s);}}

A une bien meilleure résistance aux débordements que la plupart des autres réponses. Pour 100 termes, le résultat est

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

SuperJedi224
la source

2

Julia, 28 octets

~k=k<1?1:1/gamma(k+1)+~(k-1)

Explication

~k=                    #Define ~ to be
    k<1                #If k is less than 1
        ?1             #to be one
        :1/gamma(k+1)  #else add the reciprocal factorial to 
            +~(k-1)    #the function applied to the predecessor value

gamma(k+1)est égal à factorial(k)pour les entrées entières positives et le généralise pour toutes les valeurs autres que les entiers non négatifs. Il enregistre un octet, alors pourquoi ne pas l'utiliser?

eaglgenes101
la source

1

MATLAB / Octave, 22 octets

@(x)sum(1./gamma(1:x))

Crée une fonction anonyme nommée ansqui peut être appelée à l'aide de ans(N).

Cette solution calcule gamma(x)pour chaque élément du tableau [1 ... N] qui est égal à factorial(x-1). Nous prenons ensuite l'inverse de chaque élément et additionnons tous les éléments.

Démo en ligne

Suever
la source

1

Perl 5, 37 octets

Pas un gagnant, mais gentil et simple:

$e=$p=1;$e+=1/($p*=$_)for 1..<>;say$e

Sorties pour entrées de 0 à 10:

1
2
2.5
2.66666666666667
2.70833333333333
2.71666666666667
2.71805555555556
2.71825396825397
2.71827876984127
2.71828152557319
2.71828180114638

Hobbs
la source

1

R, 17 octets

sum(1/gamma(1:n))

Assez simple, bien que des problèmes de précision numérique surgissent à un moment donné.

Andreï Kostyrka
la source

1

WolframAlpha , 12 octets

sum1/k!,0..n

Anastasiya-Romanova 秀
la source

Approximation de e

Défi

Notation

Réponses:

Gelée , 5 octets

Comment ça fonctionne

Wistful-C - 336 octets

Pyth, 7 6 octets

TI-84 BASIC, 12 15 14

Julia, 28 27 21 octets

Python, 36 octets

dc, 43 octets

Explication

Résultats de test

J, 10 octets

Explication

CJam, 11

JavaScript ES6, 44 42 40

MATL, 11 7 octets

MATL , 6 octets

Explication

C, 249 octets

k (13 octets)

05AB1E, 6 octets

Pyke, 10 octets

JavaScript (ES6), 28 octets

Dyalog APL , 6 octets

Haskell, 37 octets

APL (Dyalog Unicode) , 5 octets

Comment ça fonctionne

En fait, 6 octets

Brachylog , 18 octets

Explication

Érable, 18

C, 69 octets

Java avec pôle laser de dix pieds , 238 236 octets

Julia, 28 octets

Explication

MATLAB / Octave, 22 octets

Perl 5, 37 octets

R, 17 octets

WolframAlpha , 12 octets