17

Étant donné un entier positif n, les entiers a et b (formant une fraction réduite a / b ) tels que:

Formule a / b = produit de k = 1 à n: (p_k ^ 2 - 1) / (p_k ^ 2 + 1)

Où p _k est le k ème nombre premier (avec p ₁ = 2).

Exemples:

1   -> 3, 5
2   -> 12, 25
3   -> 144, 325
4   -> 3456, 8125
5   -> 41472, 99125
15  -> 4506715396450638759507001344, 11179755611058498955501765625
420 -> very long

Les vérifications probabilistes de prime sont autorisées, et ce n'est pas grave si votre réponse échoue en raison de limitations dans le type entier de votre langue.

Le code le plus court en octets gagne.

code-golf arithmetic

— orlp
source

Pouvons-nous également produire 3.0au lieu de 3?

— Adnan

2

@AandN Je suppose ... Assurez-vous que votre programme est correct pour toutes les entrées et ne souffre pas d'erreurs en virgule flottante pour les grandes entrées.

— orlp

Pouvons-nous produire aet bcomme un type rationnel?

— Alex A.

2

@AlexA. Seulement si la sortie montre clairement les deux entiers.

— orlp

1

@SamYonnou Ceux-ci existent déjà, mais abuser des types de nombres natifs pour banaliser un problème est l'une des failles interdites par défaut.

— Dennis

6

M , 9 octets

RÆN²‘İḤCP

Essayez-le en ligne!

Trivia

Rencontrez M!

M est une fourchette de Jelly, destinée aux défis mathématiques. La principale différence entre Jelly et M est que M utilise une précision infinie pour tous les calculs internes, représentant symboliquement les résultats. Une fois que M sera plus mature, Jelly deviendra progressivement plus polyvalente et moins orientée mathématique.

M est beaucoup de travail en cours (plein de bugs, et pas vraiment que différent de Jelly en ce moment), mais il fonctionne comme un charme pour ce défi et je ne pouvais pas résister.

Comment ça fonctionne

RÆN²‘İḤCP  Main link. Argument: n

R          Range; yield [1, ..., n].
 ÆN        Compute the kth primes for each k in that range.
   ²‘      Square and increment each prime p.
     İ     Invert; turn p² + 1 into the fraction 1 / (p² + 1).
      Ḥ    Double; yield 2 / (p² + 1).
       C   Complement; yield 1 - 2 / (p² + 1).
        P  Product; multiply all generated differences.

— Dennis
source

Est ÆNle seul opérateur spécifique à M? Aussi Melly

— CalculatorFeline

Aucun de ces opérateurs n'est spécifique à M. La différence est que M calcule une fraction, tandis que Jelly calcule un nombre à virgule flottante.

— Dennis

9

Mathematica, 32 octets

1##&@@(1-2/(Prime@Range@#^2+1))&

Une fonction sans nom qui prend une entrée entière et renvoie la fraction réelle.

Cela utilise le fait que . Le code est ensuite joué grâce au fait que Mathematica enfile toute l'arithmétique de base sur des listes. Nous créons donc d'abord une liste , puis récupérons tous ces nombres premiers et connectons cette liste à l'expression ci-dessus. Cela nous donne une liste de tous les facteurs. Enfin, nous multiplions tout ensemble en appliquant à la liste, qui peut être jouée au golf .(p²-1)/(p²+1) = 1-2/(p²+1){1, 2, ..., n}Times1##&

Alternativement, nous pouvons utiliser Arraypour le même nombre d'octets:

1##&@@(1-2/(Prime~Array~#^2+1))&

— Martin Ender
source

1-2= 1, non?

— CalculatorFeline

@CatsAreFluffy Oui (en -1fait), mais 1-2/x ≠ -1/x. ;)

— Martin Ender

@Range@±~Array~

— CalculatriceFeline

6

Python 2, 106 octets

from fractions import*
n=input()
F=k=P=1
while n:b=P%k>0;n-=b;F*=1-Fraction(2*b,k*k+1);P*=k*k;k+=1
print F

Les première et quatrième lignes font tellement mal ... il s'est avéré qu'il Fractionétait préférable d' utiliser que de multiplier séparément et d'utiliser gcd, même en Python 3.5+ où gcdréside math.

Prime generation adaptée de la réponse de @ xnor ici , qui utilise le théorème de Wilson.

— Sp3000
source

5

Rubis, 122 77 65 octets

Merci à Sherlock d'avoir rasé 10 octets.

require'prime'
->n{Prime.take(n).map{|x|1-2r/(x*x+1)}.reduce(:*)}

Définit une fonction anonyme qui prend un nombre et renvoie un Rational.

— un spaghetto
source

4

PARI / GP , 33 octets

n->prod(i=1,n,1-2/(prime(i)^2+1))

Version alternative (46 octets):

n->t=1;forprime(p=2,prime(n),t*=1-2/(p^2+1));t

Version non concurrente donnant le résultat à virgule flottante ( t_REAL) (38 octets):

n->prodeuler(p=2,prime(n),1-2/(p^2+1))

— Charles
source

4

Gelée , 14 13 octets

RÆN²µ’ż‘Pµ÷g/

Essayez-le en ligne! Merci à @Dennis pour -1 octet.

R                       Range [1..n]
 ÆN                     Nth prime
   ²                    Square
    µ                   Start new monadic chain
     ’ż‘                Turn each p^2 into [p^2-1, p^2+1]
        P               Product
         µ              Start new monadic chain
          ÷             Divide by...
           g/           Reduce GCD

— Sp3000
source

4

Pyth, 26 25

/RiFN=N*MCm,tdhd^R2.fP_ZQ

Essayez-le ici ou exécutez la suite de tests .

1 octet économisé grâce à Jakube!

Mise en œuvre assez naïve du cahier des charges. Utilise le "nouveau" (je ne sais pas quand cela a été ajouté, mais je ne l'ai jamais vu auparavant) P<neg>qui retourne si la valeur positive d'un nombre négatif est première ou non. Une partie de la cartographie, etc. peut probablement être jouée au golf ...

— FryAmTheEggman
source

3

Julia, 59 42 octets

n->prod(1-big(2).//-~primes(2n^2)[1:n].^2)

Il s'agit d'une fonction anonyme qui accepte un entier et renvoie un RationalavecBigInt numérateur et dénominateur.

On commence par générer la liste des nombres premiers inférieurs à 2 n ² et sélectionner les n premiers éléments. Cela fonctionne parce que le n ème premier est toujours inférieur à n ² pour tout n > 1. ( Voir ici .)

Pour chaque p des n nombres premiers sélectionnés, nous quadrillons p en utilisant la puissance par élément ( .^2), et construisons le rationnel 2 / ( p + 1), où 2 est d'abord converti en a BigIntpour assurer une précision suffisante. Nous soustrayons cela de 1, prenons le produit du tableau résultant de rationnels et retournons le rationnel résultant.

Exemple d'utilisation:

julia> f = n->prod(1-big(2).//-~primes(2n^2)[1:n].^2)
(anonymous function)

julia> f(15)
4506715396450638759507001344//11179755611058498955501765625

Enregistré 17 grâce à Sp3000!

— Alex A.
source

2

Convexe, 28 octets

Convex est un nouveau langage que je développe qui est fortement basé sur CJam et Golfscript. L'interprète et l'IDE peuvent être trouvés ici . L'entrée est un entier dans les arguments de la ligne de commande. Les index sont à base unique. Utilise l'encodage CP-1252.

,:)_{µ²1-}%×\{µ²1+}%×¶_:Ðf/p

Vous pouvez ou non considérer cette réponse comme concurrente, car je travaillais sur quelques fonctionnalités que ce programme utilise avant la publication du défi, mais la validation a été effectuée une fois que j'ai vu ce défi disparaître.

— GamrCorps
source

2

MATL , 18 octets

:Yq2^tqpwQpZd1Mhw/

Essayez-le en ligne!

Échoue pour les entrées volumineuses car seuls les nombres entiers jusqu'à 2^52 peuvent être représentés avec précision en interne.

Explication

:     % implicitly take input n. Generate range [1,...,n]
Yq    % first n prime numbers
2^    % square
tqp   % duplicate. Subtract 1. Product
wQp   % swap. Add 1. Product
Zd    % gcd of both products
1M    % push the two products again
h     % concatenate horizontally
w/    % swap. Divide by previously computed gcd. Implicitly display

— Luis Mendo
source

2

Mathematica, 45 octets

Times@@Array[(Prime@#^2-1)/(Prime@#^2+1)&,#]&

Primes? Des fractions? Mathematica.

— CalculatorFeline
source

1

Haskell, 53 octets

Fonction anonyme, 53 caractères:

(scanl(*)1[1-2%(p*p+1)|p<-nubBy(((>1).).gcd)[2..]]!!)

Essayez-le ici (remarque: dans GHCi standard, vous devez d'abord vous assurer Data.Ratioet Data.Listsont importés):

λ (scanl(*)1[1-2%(p*p+1)|p<-nubBy(((>1).).gcd)[2..]]!!) 5
41472 % 99125
:: Integral a => Ratio a

L'indexation de liste de Haskell !!est basée sur 0. (___!!)est une section opérateur , formant une fonction anonyme afin que(xs !!) n == xs !! n .

C'est quatre octets de moins pour générer la séquence entière:

λ mapM_ print $ take 10 $     -- just for a nicer output
    scanl(*)1[1-2%(n*n+1)|n<-[2..],all((>0).rem n)[2..n-1]]
1 % 1
3 % 5
12 % 25
144 % 325
3456 % 8125
41472 % 99125
3483648 % 8425625
501645312 % 1221715625
18059231232 % 44226105625
4767637045248 % 11719917990625
:: IO ()

— Will Ness
source

0

Sérieusement, 25 octets

,r`PªD;⌐k`M┬`π`Mi│g;)@\)\

Sorties a\nb( \nest une nouvelle ligne). Les grandes entrées prendront beaucoup de temps (et pourraient échouer en raison d'un manque de mémoire) car la génération principale est assez lente.