Nếu 1 không được tính là một yếu tố, thì

• 40 có hai yếu tố lân cận (4 và 5)
• 1092 có hai yếu tố lân cận (13 và 14)
• 350 không có hai yếu tố lân cận (trong số các yếu tố 2, 5, 7, 10, 14, 25, 35, 50, 70 và 175, không có hai yếu tố nào liên tiếp)

Tỷ lệ số nguyên dương có thuộc tính này là tỷ lệ chia hết cho 6 (2 × 3), 12 (3 × 4), 20 (4 × 5), 30, 56, Chiếm. Nếu chúng ta chỉ tính tỷ lệ chia hết cho n đầu tiên trong số này, chúng ta sẽ có được một xấp xỉ chính xác hơn khi n tăng.

Ví dụ: với n = 1 , chúng tôi thấy tỷ lệ số nguyên chia hết cho 2 × 3 = 6, là 1/6. Với n = 2 , tất cả các số nguyên chia hết cho 3 × 4 = 12 cũng chia hết cho 6, do đó, xấp xỉ vẫn là 1/6. Với n = 3 , tỷ lệ số nguyên chia hết cho 6 hoặc 20 là 1/5, v.v.

Dưới đây là một vài giá trị đầu tiên:

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

Đối với các giá trị n giữa các giá trị được cung cấp, đầu ra phải giống với đầu ra cho giá trị trên (ví dụ n = 5 → 1/5).

Chương trình của bạn sẽ lấy n và xuất một câu trả lời phân số hoặc thập phân. Bạn có thể lấy n ở bất kỳ giá trị bù nào (ví dụ: lập chỉ mục 0 hoặc lập chỉ mục 2 vào chuỗi này, thay vì lập chỉ mục 1).

Đối với đầu ra thập phân, chương trình của bạn phải chính xác đến ít nhất 5 chữ số cho tất cả các trường hợp thử nghiệm được cung cấp.

Ghi điểm là môn đánh gôn , với chiến thắng mã ngắn nhất.

^{Lấy cảm hứng từ tỷ lệ số nguyên dương nào có hai yếu tố khác nhau 1? bởi marty cohen - đặc biệt, bởi câu trả lời của Dan .}

Thạch ,  14 13  10 byte

-1 sử dụng ý tưởng của Erik the Outgolfer để lấy ý nghĩa của danh sách các số không và số không.
-3 bằng cách sử dụng 3 chỉ mục (như được cho phép trong câu hỏi) - cảm ơn Dennis vì đã chỉ ra điều này.

ḊPƝḍⱮ!Ẹ€Æm

Một liên kết đơn nguyên chấp nhận một số nguyên, n+2mang lại một số float.

Hãy thử trực tuyến! (rất không hiệu quả vì nó kiểm tra tính phân chia trong phạm vi)$[2, (n+2)!]$

(Bắt đầu như +2µḊPƝḍⱮ!§T,$Ẉ, lấy nvà cho [numerator, denominator], không được giảm)

Làm sao?

Ḋ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 byte

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

Cảng @JonathanAllan 's Jelly câu trả lời , vì vậy cũng rất chậm.

Hãy thử trực tuyến hoặc xác minh ba trường hợp thử nghiệm đầu tiên .

Giải trình:

Ì                 # 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 byte

Đã lưu 2 byte nhờ @Shaggy + 2 byte nữa từ đó

Trả về một xấp xỉ thập phân.

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

Hãy thử trực tuyến!

JavaScript (ES6), 131 byte

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

Hãy thử trực tuyến!

Thạch , 12 byte

Ḋב$ḍẸ¥ⱮP$Æm

Hãy thử trực tuyến!

-2 nhờ đề xuất của Jonathan Allan để thay thế LCM bằng sản phẩm (tức là LCM nhân với một số nguyên).

Dennis nhận thấy tôi có thể 2 chỉ số là tốt.

Than , 26 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Vô vọng không hiệu quả (O (n! ²)) vì vậy chỉ hoạt động tối đa n=4trên TIO. Giải trình:

ＦＮ⊞υ×⁺²ι⁺³ι

Nhập nvà tính các nsản phẩm đầu tiên của các yếu tố lân cận.

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

Lấy sản phẩm của tất cả các yếu tố đó và sử dụng nó để tính tỷ lệ các số có ít nhất một trong các yếu tố đó.

Phiên bản chậm hơn 30 byte chỉ là O (n!) Vì vậy có thể thực hiện tối đa n=6trên TIO:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

Phiên bản nhanh hơn 46 byte chỉ là O (lcm (1..n + 2)) nên có thể thực hiện tối đa n=10trên TIO:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

Phiên bản nhanh hơn 45 byte chỉ là O (2ⁿ) nên có thể thực hiện tối đa n=13trên TIO:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

Phiên bản nhanh nhất 54 byte sử dụng LCM hiệu quả hơn để có thể thực hiện n=18trên TIO:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

Ngôn ngữ Wolfram (Mathicala) , 69 68 61 52 byte

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

Hãy thử trực tuyến!

3 chỉ số. Lúc đầu tôi sẽ sử dụng LCM@@nhưng nhận ra rằng nó #!sẽ ngắn hơn ... nhưng bây giờ nó có rất nhiều bộ nhớ cho Range[#!]...

Quản lý để golf xuống điều kiện 2 byte, đó là tốt đẹp.

Giải pháp số cũ hơn (56 byte):

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

Hãy thử trực tuyến!

2 chỉ mục. Hiệu quả hơn khi #!>5^8( #>9, giả sử #là một số nguyên).

Python 2 , 78 byte

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

Hãy thử trực tuyến!

Trả về số thập phân gần đúng đến +5 chữ số; sử dụng cách tiếp cận vũ phu ngây thơ xnor gợi ý trong các bình luận về câu hỏi.