If 1 is not counted as a factor, then

• 40 has two neighboring factors (4 and 5)


• 1092 has two neighboring factors (13 and 14)


• 350 does not have two neighboring factors
  (out of its factors 2, 5, 7, 10, 14, 25, 35, 50, 70, and 175,
  no two are consecutive)

The proportion of positive integers that have this property
is the proportion divisible by any of
6 (2 × 3), 12 (3 × 4), 20 (4 × 5), 30, 56, ….
If we only calculate the proportion divisible by the first n of these,
we get an approximation that gets more accurate as n increases.

For example,
for n=1,
we find the proportion of integers divisible by 2 × 3 = 6,
which is 1/6.
For n=2,
all integers divisible by 3 × 4 = 12 are also divisible by 6,
so the approximation is still 1/6.
For n=3,
the proportion of integers divisible by 6 or 20 is 1/5,
and so on.

Here are the first few values:

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

For values of n between the provided values,
the output should be the same as the output for the value above
(e.g. n=5 → 1/5).

Your program should take n and output either a fraction or decimal answer.
You may take n at any offset
(e.g. 0-indexing or 2-indexing into this sequence, instead of 1-indexing).

For decimal output,
your program must be accurate to at least 5 digits
for all the test cases given.

Scoring is code-golf, with the shortest code winning.

^{Inspired by What proportion of positive integers have two factors that differ by 1? by marty cohen -- specifically, by Dan's answer.}

Jelly, 15 bytes

‘€×‘$ḍẸ¥Ɱæl/$Æm

Try it online!

JavaScript (ES6),  94 92  90 bytes

Saved 2 bytes thanks to @Shaggy + 2 more bytes from there

Returns a float.

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

Try it online!

JavaScript (ES6), 131 bytes

A much longer solution that returns an exact result as a pair $[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]

Try it online!

Charcoal, 26 bytes

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

Try it online! Link is to verbose version of code. Hopelessly inefficient (O(n!²)) so only works up to n=4 on TIO. Explanation:

ＦＮ⊞υ×⁺²ι⁺³ι

Input n and calculate the first n products of neighbouring factors.

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

Take the product of all of those factors and use that to calculate the proportion of numbers having at least one of those factors.

30-byte less slow version is only O(n!) so can do up to n=6 on TIO:

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

Try it online! Link is to verbose version of code.

46-byte faster version is only O(lcm(1..n+2)) so can do up to n=10 on TIO:

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

Try it online! Link is to verbose version of code.

Jelly,  14  13 bytes

-1 using Erik the Outgolfer's idea to take the mean of a list of zeros and ones.

+2µḊPƝḍⱮ!Ẹ€Æm

A monadic Link accepting an integer which yields a float.

Try it online! (very inefficient since it tests divisibility over the range of $(n+2)!$)

(Previous was +2µḊPƝḍⱮ!§T,$Ẉ yielding [numerator, denominator], unreduced)

How?

+2µḊPƝḍⱮ!Ẹ€Æm - Link: integer, n

+2            - add 2

  µ           - new monadic chain, call that x

   Ḋ          - dequeue (implicit range of) x

     Ɲ        - apply to neighbours:

    P         -   product

        !     - factorial of x = x!

       Ɱ      - map across (implicit range of) x! with:

      ḍ       -   divides?

         Ẹ€   - any? for each (1 if divisible by any of the neighbour products else 0)

           Æm - mean