Contexte

On peut montrer que pour tout entier k >= 0, f(k) = tan(atan(0) + atan(1) + atan(2) + ... + atan(k))est un nombre rationnel.

Objectif

Écrivez un programme ou une fonction complète qui, lorsqu'elle est donnée k >= 0, sort f(k)en une seule fraction réduite (le numérateur et le dénominateur sont des coprimes).

Cas de test

Les premières valeurs sont

f(0) = (0,1)
f(1) = (1,1)
f(2) = (-3,1)
f(3) = (0,1)
f(4) = (4,1)
f(5) = (-9,19)
f(6) = (105,73)

Règles

• Les failles standard sont interdites.
• L'entrée et la sortie peuvent être dans n'importe quel format pratique. Vous pouvez sortir f(k)comme une chaîne numerator/denominator, comme un tuple de deux entiers, une fraction ou d'un objet rationnel, etc. Si vous émettez une chaîne, donnez seulement deux entiers, qui est, sortie au 3/2lieu de 1 1/2.
• C'est le code-golf, la réponse la plus courte (en octets) l'emporte.

M , 11 octets

×C÷@+
R0;ç/

Essayez-le en ligne!

Utilise la formule OEIS x(n) = (x(n-1)+n)/(1-n*x(n-1))avec x(0) = 0.

Mathematica, 28 octets

Fold[+##/(1-##)&,0,Range@#]&

Essayez-le en ligne!

Une approche plus longue mais plus intéressante (32 octets):

Im@#/Re@#&@Product[1+n I,{n,#}]&

Essayez-le en ligne!

Python 2 ,76 72 octets

from fractions import*
f=lambda k:Fraction(k and(k+f(k-1))/(1-k*f(k-1)))

Utilisez l'identité:

tan(A + B) = (tan(A) + tan(B)) / (1 - tan(A) * tan(B))

Nous avons:

f(k) = 0                                    if k = 0
     = (k + f(k - 1)) / (1 - k * f(k - 1))  if k > 0

Essayez-le en ligne!

Merci à Luis Mendo, économisez 4 octets.

APL (Dyalog) , 14 octets

Requiert ⎕FR←1287( 128 bit F loating point R ePresentation) pour la petite entrée. Prend kcomme bon argument.

1(∧÷,)3○¯3+.○⍳

Essayez-le en ligne!

⍳ entiers de un à kzéro (zéro n'est pas nécessaire car 0 = arctan 0)

¯3+.○ somme des tangentes d'arcus

3○ tangente

1(… ) Appliquez la fonction tacite suivante avec 1 comme argument de gauche et ce qui précède comme argument de droite:

 ∧ le plus petit commun multiple (de 1 et le bon argument); donne le numérateur

 ÷ divisé par

 , la concaténation (de 1 et le bon argument); donne le numérateur et le dénominateur

Haskell , 52 octets

Cela utilise l'extension de la série OEIS:

import Data.Ratio
f 0=0%1
f n|p<-f$n-1=(p+n)/(1-n*p)

Essayez-le en ligne!

Ou une version sans point:

(scanl1(\f n->(f+n)/(1-n*f))[0%1..]!!)

JavaScript (ES6), 80 octets

f=n=>n?([a,b]=f(n-1),g=(a,b)=>a?g(b%a,a):b,c=g(d=b*n+a,e=b-n*a),[d/c,e/c]):[0,1]

Renvoie une paire [numérateur, dénominateur]. Explication: f(n-1) = a/balors laissez f(n) = atan(tan(n)+tan(a/b)) = (n+a/b)/(1-n*a/b) = (b*n+a)/(b-n*a). Il reste alors à réduire la fraction à ses plus bas niveaux.

Environnement ES6 en ligne

Pari / GP , 36 octets

n->imag(x=prod(i=0,n,1+i*I))/real(x)

Essayez-le en ligne!

Ou la même longueur:

n->fold((x,y)->(x+y)/(1-x*y),[0..n])

Essayez-le en ligne!

05AB1E , 33 26 octets

0X)Iƒ©`N*+®`sN*-‚D¿D_i\¤}/

Essayez-le en ligne!

Explication

0X)                          # initialize stack with [0,1]
   Iƒ                        # for N in range [0 ... input] do:
     ©                       # store a copy of the current pair in the register
      `                      # push the pair separately to the stack
       N*                    # multiply the denominator with N
         +                   # add the numerator
          ®`s                # push the denominator then the numerator to the stack
             N*              # multiply the numerator by N
               -             # subtract it from the denominator
                D¿D          # get 2 copies of the greatest common divisor
                   0Qi  }    # if the gcd equals 0
                      \¤     # replace it with the denominator
                         /   # divide the pair with this number

Octave , 30 octets

format rat
tan(sum(atan(0:k)))

Essayez-le en ligne!

Casio-Basic, 35 octets

tExpand(tan(sum(seq(tan⁻¹(n),n,0,k

tan ^-1 doit être entré comme celui du clavier Trig; ou le ^-1 peut être entré séparément du clavier abc> Math. Selon le manuel du fx-CP400, il s'agit d'un seul caractère à deux octets (764).

Fonction, 34 octets pour le code, +1 octet à ajouter kcomme argument.

Explication

seq(tan-1(n),n,0,k)génère toutes les valeurs tan-1(n)de 0 à k.

sumles ajoute tous ensemble, puis tanfait la fonction tangente sur eux.

tExpand les transformera ensuite en une seule fraction.

Julia 0.6.0 40 octets

k->rationalize(tan(sum(x->atan(x),1:k)))

C'est une mise en œuvre simple de la question. La précision de la rationalisation peut parfois être étrange mais fonctionne très bien 99% du temps.