如果1不算作因素，则

• 40有两个相邻因素（4和5）
• 1092有两个相邻因素（13和14）
• 350没有两个相邻因子（在因子2、5、7、10、14、25、35、50、70和175中，没有两个是连续的）

具有此属性的正整数比例是可以被6（2×3），12（3×4），20（4×5），30、56…中的任何一个整除的比例。如果我们仅计算可被前n个因子整除的比例，则得到的近似值随着n的增加而变得更加准确。

例如，对于n = 1，我们找到被2×3 = 6整除的整数比例，即1/6。对于n = 2，所有可被3×4 = 12整除的整数也可被6整除，因此近似值仍为1/6。对于n = 3，可被6或20整除的整数比例为1/5，依此类推。

以下是前几个值：

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

对于介于提供的值之间的n值，输出应与上述值的输出相同（例如n = 5 →1/5）。

您的程序应采用n并输出小数或十进制答案。您可以在任何偏移量处取n（例如，在此序列中使用0索引或2索引，而不是1索引）。

对于十进制输出，对于给定的所有测试用例，您的程序必须至少精确到5位数字。

得分是打高尔夫的，打码时间最短。

^{受启发于什么比例的正整数具有两个相差1的因子？由马蒂·科恩（Marty Cohen）讲，特别是由丹（Dan）的回答。}

果冻， 14 13  10 字节

-1使用Outgolfer的想法Erik取零和一的列表的平均值。
-3通过使用3索引（在问题允许的范围内）-感谢Dennis指出了这一点。

ḊPƝḍⱮ!Ẹ€Æm

接受整数的单子链接n+2，产生浮点数。

$[2, (n+2)!]$

（开始时为+2µḊPƝḍⱮ!§T,$Ẉ，取n并屈服[numerator, denominator]，未还原）

怎么样？

Ḋ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 个字节

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

@JonathanAllan的Jelly答案端口，因此也非常慢。

在线尝试或验证前三个测试用例。

说明：

Ì                 # 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字节

@Shaggy节省了2个字节+那里还有2个字节

返回十进制近似值。

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

在线尝试！

JavaScript（ES6），131个字节

$[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]

在线尝试！

果冻，12字节

Ḋב$ḍẸ¥ⱮP$Æm

在线尝试！

-2感谢乔纳森·艾伦（Jonathan Allan）的建议，将LCM替换为乘积（即LCM乘以整数）。

丹尼斯注意到，我也可以2分索引。

木炭，26字节

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

在线尝试！链接是详细版本的代码。效率极低（O（n！²）），因此只能n=4在TIO上使用。说明：

ＦＮ⊞υ×⁺²ι⁺³ι

输入n并计算n邻近因素的第一乘积。

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

取所有这些因素的乘积，然后使用该乘积计算至少具有那些因素之一的数字的比例。

低30字节的慢速版本只有O（n！），因此可以n=6在TIO上完成：

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

在线尝试！链接是详细版本的代码。

46字节的较快版本只有O（lcm（1..n + 2）），因此可以n=10在TIO上完成：

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

在线尝试！链接是详细版本的代码。

45字节的更快版本只有O（2ⁿ），因此可以n=13在TIO上完成：

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

在线尝试！链接是详细版本的代码。

54字节最快的版本使用更有效的LCM，因此可以n=18在TIO上完成：

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

在线尝试！链接是详细版本的代码。

Wolfram语言（Mathematica），69 68 61 52字节

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

在线尝试！

3分索引。起初我要使用，LCM@@但意识到那#!会更短...但是现在它有很多内存供Range[#!]...

设法将条件降低了2个字节，这很好。

较旧的数值解决方案（56个字节）：

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

在线尝试！

2分索引。当#!>5^8（#>9，假设#是整数）时效率更高。

Python 2，78个字节

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

在线尝试！

返回大约十进制的+5位数字；使用xnor在问题评论中建议的朴素暴力手段。