पड़ोसी कारकों के साथ पूर्णांकों के अनुपात को अनुमानित करें

Question

यदि 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 प्रदान की मूल्यों के बीच, उत्पादन ऊपर (जैसे मूल्य के लिए आउटपुट के रूप में एक ही होना चाहिए एन = 5 → 1/5)।

आपके प्रोग्राम को n और आउटपुट या तो एक अंश या दशमलव उत्तर लेना चाहिए । आप समय लग सकता है n किसी भी ऑफसेट (जैसे 0 अनुक्रमण या इस अनुक्रम में 2-अनुक्रमण, के बजाय 1 अनुक्रमण) पर।

दशमलव आउटपुट के लिए, आपके प्रोग्राम को दिए गए सभी परीक्षण मामलों के लिए कम से कम 5 अंकों का सटीक होना चाहिए।

स्कोरिंग कोड-गोल्फ है , जिसमें सबसे छोटा कोड जीता जाता है।

^{सकारात्मक पूर्णांकों के किस अनुपात से प्रेरित होने के दो कारक हैं जो 1 से भिन्न हैं? मार्टिन कोहेन द्वारा - विशेष रूप से, दान के जवाब से।}

Comments

दशमलव उत्तर होना कितना सही है? एक स्वाभाविक रणनीति यह प्रतीत होती है कि पूर्णांक को किसी विशाल श्रेणी में मान्य भाजक के साथ गिना जाए और सीमा की लंबाई से विभाजित किया जाए, जो एक सन्निकटन के रूप में बेहतर हो जाता है क्योंकि सीमा बड़ी हो जाती है।

— 19

@xnor मैंने अब पोस्ट में संबोधित किया है।

— डोर्कनोब

Answer 1

जेली ,  14 13  10 बाइट्स

-1 शून्य और लोगों की एक सूची का मतलब लेने के लिए आउटगोल्फ के विचार का उपयोग करना।
3-अनुक्रमणिका का उपयोग करके -3 (जैसा कि प्रश्न में अनुमति दी गई है) - इसे इंगित करने के लिए डेनिस का धन्यवाद।

Ḋ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

Comments

हम्म ... मुझे संदेह है कि यह मेरी तुलना में कम है जो !इसके बजाय का उपयोग करता है æl/... आह, सोते समय नियमों के परिवर्तन।

— आउटगॉल्फर

जब मैं करीब देखता हूं तो @EriktheOutgolfer हाँ, बहुत समान तरीके! क्या आप P13 से नीचे जाने के लिए उपयोग कर सकते हैं ?

— जोनाथन एलन

इसके बजाय Ẹ€? मुझे डर Pहै कि यह उसी तरह है ׃1$, इसलिए यह काम नहीं करेगा। (और वह 14 वैसे भी होगा ...) के बजाय तो æl/, हो सकता है ( P है एलसीएम * कश्मीर सब के बाद)।

— को एग्री आउटफोलर

@EriktheOutgolfer के बजायæl/

— जोनाथन एलन

हाँ, मुझे लगता है कि मैं ऐसा कर सकता हूं, और परिणाम सैद्धांतिक रूप से æl/मेरे अनुमान के अनुसार सटीक होगा । (नाइट-उल्लू गोल्फिंग के मुद्दे हैं ...) संपादित करें: हाँ, हालांकि मुझे TIO पर तर्क को कम करना होगा 4...: पी

— एरिक आउटगॉल्फ

Answer 2

05AB1E , 15 बाइट्स

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

पोर्ट @JonathanAllan के जेली उत्तर , इसलिए भी बहुत धीमी गति से।

इसे ऑनलाइन आज़माएं या पहले तीन परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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

Answer 3

जावास्क्रिप्ट (ईएस 6),  94 92  90 बाइट्स

सहेजे गए 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)``

इसे ऑनलाइन आज़माएं!

---

जावास्क्रिप्ट (ईएस 6), 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]

इसे ऑनलाइन आज़माएं!

Comments

-2 बाइट्स

— झबरा

यह काम करना चाहिए, सिद्धांत में 82 बाइट्स के लिए।

— झबरा

@ शैगी मुझे वास्तव में पता नहीं है कि इस तरह के उत्तरों के लिए आम सहमति क्या है। हालांकि यह सिद्धांत रूप में काम करता है , यह किसी भी इनपुट के लिए अभ्यास में काम नहीं करता है। (मैं व्यक्तिगत रूप से इस तरह के उत्तरों को नापसंद करता हूं। यही कारण है कि मैं आमतौर पर एक नियम शामिल करता हूं जैसे कि "आपकी संहिता को कम से कम किसी दिए गए सीमा तक काम करना चाहिए" मेरी अपनी चुनौतियों में जब मुझे संदेह है कि मुझे ऐसे जवाब मिलेंगे जैसे कि "केवल काम करता है" टीआईओ पर n = 1 के लिए " ... या वर्तमान मामले में बिल्कुल भी काम नहीं करता है।)

— अरनौलड

व्यक्तिगत रूप से, मैं अनंत समय और स्मृति आम सहमति का एक बड़ा प्रशंसक हूं;)

— झबरा

ओह मुझे भी अच्छा लगता है। :) मेरा एकमात्र आरक्षण यह है कि मुझे लगता है कि कम से कम कुछ अलग इनपुट के लिए किसी भी उत्तर का परीक्षण करना संभव होना चाहिए।

— अरनुलद

Answer 4

जेली , 12 बाइट्स

Ḋב$ḍẸ¥ⱮP$Æm

इसे ऑनलाइन आज़माएं!

-2 जोनाथन एलन के एलसीएम को उत्पाद के साथ बदलने के सुझाव (यानी एलसीएम को एक पूर्णांक से गुणा किया गया) के लिए धन्यवाद ।

डेनिस ने देखा मैं 2-इंडेक्स भी कर सकता हूं।

Answer 5

चारकोल , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। पूरी तरह से अक्षम (O (n! So)) केवल n=4TIO पर काम करता है । स्पष्टीकरण:

ＦＮ⊞υ×⁺²ι⁺³ι

इनपुट करें nऔर nपड़ोसी कारकों के पहले उत्पादों की गणना करें ।

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

उन सभी कारकों के उत्पाद लें और उन कारकों के कम से कम एक होने वाले संख्याओं के अनुपात की गणना करने के लिए उपयोग करें।

30-बाइट कम धीमा संस्करण केवल O (n!) है, इसलिए n=6TIO पर कर सकते हैं :

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

46-बाइट तेजी से संस्करण केवल O (lcm (1..n + 2)) है ताकि n=10TIO पर किया जा सके:

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

45-बाइट तेज़ संस्करण केवल O (2 by) है, ताकि n=13TIO पर कर सकें :

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

54-बाइट सबसे तेज़ संस्करण अधिक कुशल LCM का उपयोग करता है ताकि n=18TIO पर किया जा सके:

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

Answer 6

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 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, मान #एक पूर्णांक है)।

Answer 7

पायथन 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 प्रश्न पर टिप्पणी में पता चलता है।