Si 1 n'est pas compté comme un facteur, alors

• 40 a deux facteurs voisins (4 et 5)
• 1092 a deux facteurs voisins (13 et 14)
• 350 n'a pas deux facteurs voisins (sur ses facteurs 2, 5, 7, 10, 14, 25, 35, 50, 70 et 175, aucun n'est consécutif)

La proportion d'entiers positifs qui ont cette propriété est la proportion divisible par l'un de 6 (2 × 3), 12 (3 × 4), 20 (4 × 5), 30, 56,…. Si nous calculons uniquement la proportion divisible par les n premiers de ceux-ci, nous obtenons une approximation qui devient plus précise à mesure que n augmente.

Par exemple, pour n = 1 , nous trouvons la proportion d'entiers divisible par 2 × 3 = 6, qui est 1/6. Pour n = 2 , tous les entiers divisibles par 3 × 4 = 12 sont également divisibles par 6, donc l'approximation est toujours 1/6. Pour n = 3 , la proportion d'entiers divisibles par 6 ou 20 est 1/5, et ainsi de suite.

Voici les premières valeurs:

1  1/6                0.16666666666666666
3  1/5                0.20000000000000000
6  22/105             0.20952380952380953
9  491/2310           0.21255411255411255
12 2153/10010         0.21508491508491510
15 36887/170170       0.21676558735382265
21 65563/301070       0.21776663234463747
24 853883/3913910     0.21816623274423785
27 24796879/113503390 0.21846817967287144

Pour les valeurs de n entre les valeurs fournies, la sortie doit être la même que la sortie pour la valeur ci-dessus (par exemple n = 5 → 1/5).

Votre programme doit prendre n et produire une réponse fractionnaire ou décimale. Vous pouvez prendre n à n'importe quel décalage (par exemple, l'indexation 0 ou l'indexation 2 dans cette séquence, au lieu de l'indexation 1).

Pour une sortie décimale, votre programme doit être précis à au moins 5 chiffres pour tous les cas de test donnés.

La notation est le code-golf , avec le gain de code le plus court.

^{Inspiré par Quelle proportion d'entiers positifs a deux facteurs qui diffèrent de 1? par marty cohen - en particulier, par la réponse de Dan .}

Gelée ,  14 13  10 octets

-1 en utilisant l'idée d'Erik l'Outgolfer pour prendre la moyenne d'une liste de zéros et de uns.
-3 en utilisant l'indexation 3 (comme le permet la question) - merci à Dennis de l'avoir signalé.

ḊPƝḍⱮ!Ẹ€Æm

Un lien monadique acceptant un entier n+2, ce qui donne un flottant.

Essayez-le en ligne! (très inefficace car il teste la divisibilité sur la plage)$[2, (n+2)!]$

(Commencé comme +2µḊPƝḍⱮ!§T,$Ẉ, prenant net cédant [numerator, denominator], non réduit)

Comment?

ḊPƝḍⱮ!Ẹ€Æm - Link: integer, x=n+2
Ḋ          - dequeue (implicit range of) x  - i.e. [2,3,4,...,n+2]
  Ɲ        - apply to neighbours:
 P         -   product                             [2×3,3×4,...,(n+1)×(n+2)]
     !     - factorial of x                        x!
    Ɱ      - map across (implicit range of) x! with:
   ḍ       -   divides?                            [[2×3ḍ1,3×4ḍ1,...,(n+1)×(n+2)ḍ1],[2×3ḍ2,3×4ḍ2,...,(n+1)×(n+2)ḍ2],...,[2×3ḍ(x!),3×4ḍ(x!),...,(n+1)×(n+2)ḍ(x!)]]
       €   - for each:
      Ẹ    -   any?  (1 if divisible by any of the neighbour products else 0)
        Æm - mean

05AB1E , 15 octets

Ì©!Lε®LüP¦Öà}ÅA

Port de @JonathanAllan 's Jelly answer , donc aussi extrêmement lent.

Essayez-le en ligne ou vérifiez les trois premiers cas de test .

Explication:

Ì                 # Add 2 to the (implicit) input
                  #  i.e. 3 → 5
 ©                # Store this in the register (without popping)
  !               # Take the factorial of it
                  #  i.e. 5 → 120
   L              # Create a list in the range [1, (input+2)!]
                  #   i.e. 120 → [1,2,3,...,118,119,120]
    ε       }     #  Map over each value in this list
     ®            #  Push the input+2 from the register
      L           #  Create a list in the range [1, input+2]
                  #   i.e. 5 → [1,2,3,4,5]
       ü          #  Take each pair
                  #    i.e. [1,2,3,4,5] → [[1,2],[2,3],[3,4],[4,5]]
        P         #   And take the product of that pair
                  #    i.e. [[1,2],[2,3],[3,4],[4,5]] → [2,6,12,20]
         ¦        #  Then remove the first value from this product-pair list
                  #   i.e. [2,6,12,20] → [6,12,20]
          Ö       #  Check for each product-pair if it divides the current map-value
                  #  (1 if truthy; 0 if falsey)
                  #   i.e. [1,2,3,...,118,119,120] and [6,12,20]
                  #    → [[0,0,0],[0,0,0],[0,0,0],...,[0,0,0],[0,0,0],[1,1,1]]
           à      #  And check if it's truthy for any by taking the maximum
                  #   i.e. [[0,0,0],[0,0,0],[0,0,0],...,[0,0,0],[0,0,0],[1,1,1]]
                  #    → [0,0,0,...,0,0,1]
             ÅA   # After the map, take the mean (and output implicitly)
                  #  i.e. [0,0,0,...,0,0,1] → 0.2

JavaScript (ES6),  94 92  90 octets

2 octets enregistrés grâce à @Shaggy + 2 octets supplémentaires à partir de là

Renvoie une approximation décimale.

n=>(x=2,g=a=>n--?g([...a,x*++x]):[...Array(1e6)].map((_,k)=>n+=a.some(d=>k%d<1))&&n/1e6)``

Essayez-le en ligne!

JavaScript (ES6), 131 octets

$[numerator, denominator]$

f=(n,a=[],p=x=1)=>n?f(n-1,[...a,q=++x*-~x],p*q/(g=(a,b)=>a?g(b%a,a):b)(p,q)):[...Array(p)].map((_,k)=>n+=a.some(d=>-~k%d<1))&&[n,p]

Essayez-le en ligne!

Gelée , 12 octets

Ḋב$ḍẸ¥ⱮP$Æm

Essayez-le en ligne!

-2 grâce à la suggestion de Jonathan Allan de remplacer le LCM par le produit (ie le LCM multiplié par un entier).

Dennis a remarqué que je peux aussi indexer 2.

Fusain , 26 octets

ＦＮ⊞υ×⁺²ι⁺³ιＩ∕ＬΦΠυ¬⌊Ｅυ﹪ιλΠυ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Désespérément inefficace (O (n! ²)) donc ne fonctionne que n=4sur TIO. Explication:

ＦＮ⊞υ×⁺²ι⁺³ι

Saisissez net calculez les premiers nproduits des facteurs voisins.

Ｉ∕ＬΦΠυ¬⌊Ｅυ﹪ιλΠυ

Prenez le produit de tous ces facteurs et utilisez-le pour calculer la proportion de nombres ayant au moins un de ces facteurs.

La version moins lente de 30 octets n'est que O (n!) Donc peut faire jusqu'à n=6sur TIO:

Ｆ⊕Ｎ⊞υ⁺²ιＩ∕ＬΦΠυΣＥυ∧μ¬﹪ι×λ§υ⊖μΠυ

Essayez-le en ligne! Le lien est vers la version détaillée du code.

La version plus rapide de 46 octets est uniquement O (lcm (1..n + 2)), donc peut faire jusqu'à n=10sur TIO:

ＦＮ⊞υ×⁺²ι⁺³ι≔⁰η≔⁰ζＷ∨¬η⌈Ｅυ﹪ηκ«≦⊕η≧⁺⌈Ｅυ¬﹪ηκζ»Ｉ∕ζη

Essayez-le en ligne! Le lien est vers la version détaillée du code.

La version plus rapide de 45 octets est uniquement O (2ⁿ), donc peut faire jusqu'à n=13sur TIO:

⊞υ±¹ＦＥＮ×⁺²ι⁺³ιＦ⮌υ⊞υ±÷×ικ⌈Φ⊕ι∧λ¬∨﹪ιλ﹪κλＩΣ∕¹✂υ¹

Essayez-le en ligne! Le lien est vers la version détaillée du code.

La version la plus rapide de 54 octets utilise un LCM plus efficace, donc peut faire jusqu'à n=18sur TIO:

⊞υ±¹ＦＥＮ×⁺²ι⁺³ιＦＥυ⟦κι⟧«Ｗ⊟κ⊞⊞Ｏκλ﹪§κ±²λ⊞υ±÷Π…κ²⊟κ»ＩΣ∕¹✂υ¹

Essayez-le en ligne! Le lien est vers la version détaillée du code.

Wolfram Language (Mathematica) , 69 68 61 52 octets

Count[Range[#!],b_/;Or@@(# #-#&@Range[3,#]∣b)]/#!&

Essayez-le en ligne!

3 indexés. Au début, j'allais utiliser LCM@@mais j'ai réalisé que ce #!serait plus court ... mais maintenant, il y a beaucoup de mémoire pour Range[#!]...

J'ai réussi à jouer au golf sur 2 octets, ce qui était bien.

Solution numérique plus ancienne (56 octets):

N@Count[Range[5^8],b_/;Or@@Array[(# #-#)∣b&,#,3]]/5^8&

Essayez-le en ligne!

2 indexés. Plus efficace lorsque #!>5^8( #>9, en supposant qu'il #s'agit d'un entier).

Python 2 , 78 octets

lambda n:sum(any(-~i%(j*-~j)<1for j in range(2,n+2))for i in range(10**7))/1e7

Essayez-le en ligne!

Renvoie la décimale approximative à +5 chiffres; utilise l'approche de force brute naïve suggérée par xnor dans les commentaires sur la question.