Wenn 1 nicht als Faktor gezählt wird, dann

• 40 hat zwei benachbarte Faktoren (4 und 5)
• 1092 hat zwei benachbarte Faktoren (13 und 14)
• 350 hat keine zwei benachbarten Faktoren (von den Faktoren 2, 5, 7, 10, 14, 25, 35, 50, 70 und 175 sind keine zwei aufeinanderfolgend)

Der Anteil positiver Ganzzahlen mit dieser Eigenschaft ist der Anteil, der durch 6 (2 × 3), 12 (3 × 4), 20 (4 × 5), 30, 56,… teilbar ist. Wenn wir nur den Anteil berechnen, der durch das erste n davon teilbar ist , erhalten wir eine Näherung, die mit zunehmendem n genauer wird.

Zum Beispiel finden wir für n = 1 den Anteil der ganzen Zahlen, der durch 2 × 3 = 6 teilbar ist, was 1/6 ist. Für n = 2 sind alle durch 3 × 4 = 12 teilbaren ganzen Zahlen auch durch 6 teilbar, sodass die Näherung immer noch 1/6 beträgt. Für n = 3 beträgt der Anteil der durch 6 oder 20 teilbaren ganzen Zahlen 1/5 und so weiter.

Hier sind die ersten Werte:

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

Für Werte von n zwischen den angegebenen Werten sollte die Ausgabe dieselbe sein wie die Ausgabe für den obigen Wert (z. B. n = 5 → 1/5).

Ihr Programm sollte n nehmen und entweder einen Bruch oder eine Dezimalantwort ausgeben. Sie können n bei jedem Versatz nehmen (z. B. 0-Indizierung oder 2-Indizierung in diese Sequenz anstelle von 1-Indizierung).

Für die Dezimalausgabe muss Ihr Programm für alle angegebenen Testfälle auf mindestens 5 Stellen genau sein.

Das Scoring ist Code-Golf , wobei der kürzeste Code gewinnt.

^{Inspiriert von Welcher Anteil positiver Ganzzahlen hat zwei Faktoren, die sich um 1 unterscheiden? von marty cohen - insbesondere von Dan ‚s Antwort.}

Gelee ,  14 13  10 Bytes

-1 unter Verwendung der Idee von Erik dem Outgolfer, den Mittelwert einer Liste von Nullen und Einsen zu nehmen.
-3 durch 3-Indexierung (wie in der Frage erlaubt) - danke an Dennis für den Hinweis.

ḊPƝḍⱮ!Ẹ€Æm

Ein monadischer Link, der eine Ganzzahl akzeptiert n+2, die einen Float ergibt.

Probieren Sie es online aus! (sehr ineffizient, da es die Teilbarkeit über den Bereichtestet)$[2, (n+2)!]$

(Begonnen als +2µḊPƝḍⱮ!§T,$Ẉ, nehmen nund nachgeben [numerator, denominator], nicht reduziert)

Wie?

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

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

Port of @JonathanAllans Jelly Antwort , also auch extrem langsam.

Probieren Sie es online aus oder überprüfen Sie die ersten drei Testfälle .

Erläuterung:

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

2 Bytes dank @Shaggy + 2 weitere Bytes von dort gespeichert

Gibt eine Dezimalnäherung zurück.

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

Probieren Sie es online aus!

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]

Probieren Sie es online aus!

Gelee , 12 Bytes

Ḋב$ḍẸ¥ⱮP$Æm

Probieren Sie es online aus!

-2 dank Jonathan Allans Vorschlag, das LCM durch das Produkt zu ersetzen (dh das LCM multipliziert mit einer ganzen Zahl).

Dennis bemerkte, dass ich auch 2-Index kann.

Holzkohle , 26 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Hoffnungslos ineffizient (O (n! ²)), funktioniert also nur bis zu n=4TIO. Erläuterung:

ＦＮ⊞υ×⁺²ι⁺³ι

Geben Sie ndie ersten nProdukte benachbarter Faktoren ein und berechnen Sie sie .

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

Nehmen Sie das Produkt all dieser Faktoren und berechnen Sie daraus den Anteil der Zahlen mit mindestens einem dieser Faktoren.

30-Byte weniger langsame Version ist nur O (n!), Kann also bis zu n=6TIO tun :

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes.

Die 46-Byte-Version ist nur O (lcm (1..n + 2)) und kann daher bis zu n=10TIO ausgeführt werden:

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes.

Die um 45 Byte schnellere Version ist nur O (2ⁿ), kann also bis zu n=13TIO:

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes.

Die schnellste 54-Byte-Version verwendet effizienteres LCM und kann daher bis zu n=18TIO:

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes.

Wolfram Language (Mathematica) , 69 68 61 52 Byte

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

Probieren Sie es online aus!

3-indiziert. Zuerst wollte ich verwenden, LCM@@aber mir wurde klar, dass #!das kürzer sein würde ... aber jetzt ist es viel Speicher für Range[#!]...

Es ist gelungen, den Zustand um 2 Bytes zu verbessern, was sehr schön war.

Ältere numerische Lösung (56 Bytes):

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

Probieren Sie es online aus!

2-indiziert. Effizienter, wenn #!>5^8( #>9vorausgesetzt, es #handelt sich um eine Ganzzahl).

Python 2 , 78 Bytes

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

Probieren Sie es online aus!

Gibt die ungefähre Dezimalstelle auf +5 Stellen zurück. verwendet den naiven Brute-Force-Ansatz, den xnor in Kommentaren zu der Frage vorschlägt.