सह-सम्यक्त्व और संख्या पी

Question

परिचय

संख्या सिद्धांत अप्रत्याशित कनेक्शन के रूप में चमत्कार से भरा है। यहाँ उनमें से एक है।

दो पूर्णांक सह-अभाज्य हैं यदि उनके पास 1 के अलावा अन्य कोई कारक नहीं है। एक संख्या N को देखते हुए , 1 से N तक के सभी पूर्णांकों पर विचार करें । यादृच्छिक पर दो ऐसे पूर्णांक ड्रा करें (सभी पूर्णांकों में प्रत्येक ड्रा पर चुने जाने की समान संभावना है; ड्रॉ स्वतंत्र और प्रतिस्थापन के साथ हैं)। चलो पी संभावना है कि दो चयनित पूर्णांकों सह रूढ़ हैं निरूपित करते हैं। फिर पी 6 / आदत π ² ≈ 0.6079 ... के रूप में एन अनंत को जाता है।

चुनौती

इस चुनौती का उद्देश्य N के कार्य के रूप में p की गणना करना है ।

एक उदाहरण के रूप में, एन = 4 पर विचार करें । पूर्णांक 1,2,3,4 से प्राप्त 16 संभावित जोड़े हैं। उनमें से 11 जोड़े सह-प्रधान हैं, अर्थात् (1,1), (1,2), (1,3), (1,4), (2,1), (3,1), (4,1) ), (2,3), (3,2), (3,4), (4,3)। इस प्रकार पी 11/16 = के लिए 0.6875 है एन = 4।

सटीक का मूल्य पी कम से कम के साथ गणना की जा करने की जरूरत है चार दशमलव के। इसका तात्पर्य यह है कि गणना को नियतात्मक होना चाहिए (मोंटे कार्लो के विपरीत)। लेकिन यह उपरोक्त के रूप में सभी जोड़े का प्रत्यक्ष ज्ञान होने की आवश्यकता नहीं है; किसी भी विधि का उपयोग किया जा सकता है।

फ़ंक्शन तर्क या स्टड / स्टडआउट का उपयोग किया जा सकता है। यदि आउटपुट प्रदर्शित करते हैं, तो ट्रेलिंग जीरो छोड़ा जा सकता है। इसलिए उदाहरण के लिए 0.6300प्रदर्शित किया जा सकता है 0.63। इसे एक दशमलव संख्या के रूप में प्रदर्शित किया जाना चाहिए, न कि एक अंश के रूप में (स्ट्रिंग 63/100को प्रदर्शित करने की अनुमति नहीं है)।

कसौटी जीतना सबसे कम बाइट्स है। अंतर्निहित कार्यों के उपयोग पर कोई प्रतिबंध नहीं है।

परीक्षण के मामलों

इनपुट / आउटपुट (केवल चार दशमलव अनिवार्य हैं, जैसा कि ऊपर बताया गया है):

1    / 1.000000000000000
2    / 0.750000000000000
4    / 0.687500000000000
10   / 0.630000000000000
100  / 0.608700000000000
1000 / 0.608383000000000

Comments

क्या इनपुट की सीमा पर कोई सीमा है?

— एरिक टावर्स

@EricTowers प्रोग्राम को मेमोरी और डेटा प्रकार की सीमाओं तक किसी भी उचित आकार के लिए काम करना चाहिए। कम से कम 1000

— लुइस मेंडो

क्या परिमेय संख्याओं को रिटर्न मान (स्ट्रिंग्स नहीं) की अनुमति है? मेरी भाषा में एक देशी तर्कसंगत प्रकार है, जिसमें 63/100एक मान्य शाब्दिक है, गणना में प्रयोग करने योग्य। (लैंग्स मैं बात कर रहा हूं: फैक्टर , रैकेट )

— बिल्ली

@cat ज़रूर, आगे बढ़ो! हालांकि, आवश्यक परिशुद्धता को ध्यान में रखें

— लुइस मेंडो

Answer 1

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

RÆṪSḤ’÷²

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

निम्न बाइनरी कोड जेली दुभाषिया के इस संस्करण के साथ काम करता है ।

0000000: 52 91 b0 53 aa b7 9a 8a  R..S....

विचार

स्पष्ट रूप से, जोड़े की संख्या (j, k) ऐसी है कि j j k और j और k सह-प्राइम हैं, समान संख्याओं को संतुष्ट करने वाले जोड़े (k, j) की संख्या के बराबर है । इसके अलावा, अगर j = k , j = 1 = k ।

इस प्रकार, 1 और n के बीच निर्देशांक के साथ सह-प्रधान जोड़े की संख्या की गणना करने के लिए, यह जोड़े की मात्रा मीटर (जे, के) की गणना करने के लिए पर्याप्त है , जैसे कि ≤ k , फिर 2m - 1 की गणना करें ।

अंत में, के बाद से यूलर totient समारोह φ (के) के बीच के बीच संख्या पूर्णांक पैदावार 1 और कश्मीर कि सह रूढ़ कर रहे हैं k , हम गणना कर सकते हैं मीटर के रूप में φ (1) + ... + φ (एन) ।

कोड

RÆṪSḤ’÷²    Input: n

R           Yield [1, ..., n].
 ÆṪ         Apply Euler's totient function to each k in [1, ..., n].
   S        Compute the sum of all results.
    Ḥ       Multiply the result by 2.
     ’      Subtract 1.
      ÷²    Divide the result by n².

Comments

ओह, जेली में मुख्य कार्य शामिल है !? अछा सुझाव!

— लुइस मेंडू

जब तक MATL में T-1 दिन का एक कमांड कमांड शामिल है ...

— क्विंटोपिया

@ क्विंटोपिया (मैंने अंत में टोटिएंट फंक्शन को शामिल किया) :- डी

— लुइस मेंडो

Answer 2

गणितज्ञ 43 42 बाइट्स

मुझे मूल से दृश्यमान लोटिस अंक मिले , जिससे नीचे दी गई तस्वीर को इकाई जाली के दिए गए वर्ग क्षेत्र के बारे में निम्नलिखित प्रश्नों के माध्यम से समस्या को हल करने में मददगार होना चाहिए:

• इकाई-जाली बिंदुओं के किस अंश में सह-प्रधान निर्देशांक हैं?
• इकाई-जाली बिंदुओं के किस अंश को मूल से देखा जा सकता है?

---

N@Mean[Mean/@Boole@Array[CoprimeQ,{#,#}]]&

---

उदाहरण

ट्रेलिंग शून्य को छोड़ दिया जाता है।

N@Mean[Mean/@Boole@Array[CoprimeQ,{#,#}]]&/@Range@10

* ", 0.75, 0.777778, 0.6875, 0.76, 0.638889, 0.714286, 0.671875, 0.679012, 0.63}

---

समय

समय, सेकंड में, उत्तर से पहले होता है।

N@Mean[Mean/@Boole@Array[CoprimeQ,{#,#}]]&[1000]// AbsoluteTiming

{0.605571, 0.608383}

Answer 3

पायथ - 13 11 बाइट्स

.OqR1iM^SQ2

टेस्ट सूट ।

Answer 4

गणितज्ञ, 42 32 बाइट्स

Count[GCD~Array~{#,#},1,2]/#^2.&

बेनामी फ़ंक्शन, सरल जानवर बल का उपयोग करता है। आखिरी मामला मेरे मशीन पर लगभग .37 सेकंड में चलता है। स्पष्टीकरण:

                               &   A function taking N and returning
Count[               , , ]           the number of
                      1               ones
                                     in the
                        2             second
                                     level of
         ~Array~                      a matrix of
      GCD                              the greatest common denominators of
                {#,#}                 all 2-tuples in [1..N]
                          /         divided by
                           #          N
                            ^2.      squared.

Comments

क्या आप उन लोगों के लिए उदाहरण और स्पष्टीकरण पोस्ट कर सकते हैं, जिनके पास गणितज्ञ नहीं है?

— लुइस मेंडू

यह हमारे सबमिशन को एकजुट करता है: Count[Array[GCD,{#, #}],1,2]/#^2.& मेरे मेहमान बनें।

— डेविड डिस

Answer 5

दिल्लोग एपीएल, 15 बाइट्स

(+/÷⍴)∘∊1=⍳∘.∨⍳

बहुत सीधा। यह एक मोनोडिक फंक्शन ट्रेन है। Iota 1 से इनपुट तक की संख्या है, इसलिए हम बाहरी उत्पाद को gcd द्वारा लेते हैं, फिर लोगों के अनुपात को गिनते हैं।

Answer 6

ऑक्टेव, 49 47 बाइट्स

बस gcdसभी जोड़ियों की गणना और गिनती।

@(n)mean(mean(gcd(c=kron(ones(n,1),1:n),c')<2))

क्रोनकर प्रोडक्ट कमाल का है।

Comments

kron! अच्छा विचार!

— लुइस मेंडू

मैंने पहले इस्तेमाल किया meshgrid, लेकिन फिर मैंने देखा कि मैं kronइनलाइन के साथ भी ऐसा कर सकता हूं ! (-> अनाम फ़ंक्शन)

— दोष

Answer 7

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

n=>eval(`p=0;for(i=n;i;i--)for(j=n;j;j--,p+=a)for(a=1,k=j;k>1;k--)a=i%k||j%k?a:0;p/n/n`)

व्याख्या

n=>
  eval(`                     // use eval to enable for loop without {} or return
    p=0;                     // p = number of pairs
    for(i=n;i;i--)           // i = 1 to n
      for(j=n;j;j--,p+=a)    // j = i to n, a will equal 1 if i and j are coprime, else 0
        for(a=1,k=j;k>1;k--) // for each number from 0 to j
          a=i%k||j%k?a:0;    // if i%k and j%k are both 0, this pair is not coprime
    p/n/n                    // return result (equivalent to p/(n*n))
  `)

परीक्षा

बड़े ( >100) मूल्यों के लिए थोड़ी देर लेता है n।

var solution = n=>eval(`p=0;for(i=n;i;i--)for(j=n;j;j--,p+=a)for(a=1,k=j;k>1;k--)a=i%k||j%k?a:0;p/n/n`)

N = <input type="text" id="input" value="100" />
<button onclick="result.textContent=solution(+input.value)">Go</button>
<pre id="result"></pre>

Answer 8

गंभीरता से, 15 बाइट्स

,;ª)u1x`▒`MΣτD/

हेक्स डंप:

2c3ba62975317860b1604de4e7442f

यह ऑनलाइन की कोशिश करो

मैं इसे समझाने की जहमत नहीं उठा रहा हूँ क्योंकि यह सचमुच डेनिस के जेली समाधान के समान एल्गोरिथ्म का उपयोग करता है (हालांकि मैंने इसे स्वतंत्र रूप से प्राप्त किया है)।

Answer 9

जे, 19 17 बाइट्स

*:%~1-~5+/@p:|@i:

उपयोग:

   (*:%~1-~5+/@p:|@i:) 4
0.6875

स्पष्टीकरण:

*:%~1-~5+/@p:|@i:
               i: [-n..n]
             |@   absolute value of each element ([n..1,0,1,..n])
       5+/@p:     sum of the totient function for each element
    1-~           decreased by one, giving the number of co-prime pairs
*:%~              divided by N^2

डेनिस का समाधान एक अच्छी व्याख्या देता है कि हम टोटिएंट फ़ंक्शन का उपयोग कैसे कर सकते हैं।

इसे यहाँ ऑनलाइन आज़माएँ।

Answer 10

मैथेमेटिका, 35 बाइट्स

इम्प्लीमेंट्स @ डेनिस एल्गोरिथम।

(2`4Plus@@EulerPhi@Range[#]-1)/#^2&

1 से लेकर इनपुट मान तक के कुल योग (ईयूलर फी फंक्शन) की गणना करें। फ्लोटिंग पॉइंट दो से गुणा करें (सटीकता के चार अंकों के साथ) और एक को घटाएं। (इसके बजाय " 2" और "1`4 " के ।) यह कुलप्रेमी जोड़े की कुल संख्या है, इसलिए वांछित अंश प्राप्त करने के लिए इनपुट के वर्ग से विभाजित करें। क्योंकि दोनों एक अनुमानित संख्या है, इसलिए इसका परिणाम है।

परीक्षण (बाएं स्तंभ में समय डेटा के साथ क्योंकि हम में से कम से कम एक को लगता है कि यह दिलचस्प है), फ़ंक्शन को सौंपा गया है fताकि परीक्षण लाइन अधिक आसानी से पढ़ी जा सके:

f=(2`4Plus@@EulerPhi@Range[#]-1)/#^2&
RepeatedTiming[f[#]] & /@ {1, 2, 4, 10, 100, 1000}
(* {{5.71*10^-6, 1.000}, 
    {5.98*10^-6, 0.750}, 
    {0.000010  , 0.6875}, 
    {0.0000235 , 0.6300}, 
    {0.00028   , 0.6087}, 
    {0.0033    , 0.6084} }  *)

संपादित करें: इनपुट की सीमा का विस्तार दिखाते हुए (दो के बजाय एक की शुद्धता की अदला-बदली करें क्योंकि अन्यथा परिणाम नीरस मिलते हैं) और दूसरों को भी ऐसा करने के लिए चुनौती देते हैं ...

f = (2 Plus @@ EulerPhi@Range[#] - 1`4)/#^2 &
{#}~Join~RepeatedTiming[f[#]] & /@ {1, 2, 4, 10, 100, 1000, 10^4, 10^5, 10^6, 10^7}
(*  Results are {input, wall time, output}
    {{       1,  5.3*10^-6, 1.000}, 
     {       2,  6.0*10^-6, 0.7500}, 
     {       4,  0.0000102, 0.68750}, 
     {      10,  0.000023 , 0.63000}, 
     {     100,  0.00028  , 0.6087000}, 
     {    1000,  0.0035   , 0.608383000}, 
     {   10000,  0.040    , 0.60794971000}, 
     {  100000,  0.438    , 0.6079301507000}, 
     { 1000000,  4.811    , 0.607927104783000}, 
     {10000000, 64.0      , 0.60792712854483000}}  *)

RepeatedTiming[]कई बार गणना करता है और ठंड के समय और अन्य प्रभावों को अनदेखा करने का प्रयास करता है, जिससे समय आउटलेयर का कारण बनता है। विषम सीमा है

N[6/Pi^2,30]
(*  0.607927101854026628663276779258  *)

तर्क> 10 ^ 4 के लिए, हम सिर्फ "0.6079" वापस कर सकते हैं और निर्दिष्ट परिशुद्धता और सटीकता आवश्यकताओं को पूरा कर सकते हैं।

Answer 11

जूलिया, 95 बाइट्स

n->(c=combinations([1:n;1:n],2);((L=length)(collect(filter(x->gcd(x...)<2,c)))÷2+1)/L(∪(c)))

अभी के लिए बस सीधा दृष्टिकोण; मैं जल्द ही छोटे / अधिक सुरुचिपूर्ण समाधानों पर ध्यान दूंगा। यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और एक फ्लोट देता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

Ungolfed:

function f(n::Integer)
    # Get all pairs of the integers from 1 to n
    c = combinations([1:n; 1:n], 2)

    # Get the coprime pairs
    p = filter(x -> gcd(x...) == 1, c)

    # Compute the probability
    return (length(collect(p)) ÷ 2 + 1) / length(unique(c))
end

Comments

जहाँ तक मैं बता सकता हूँ, आपको इसे collectलेने के लिए किसी आलसी वस्तु की आवश्यकता नहीं है length।

— बिल्ली

@ आप कुछ के लिए करते हैं जहाँ lengthएक विधि परिभाषित नहीं है, जो फ़िल्टर्ड संयोजनों के लिए यहाँ मामला है। इसी तरह endofकाम नहीं करेगा क्योंकि उस प्रकार के लिए कोई तरीका नहीं है getindex।

— एलेक्स ए।

लेकिन भाषा असहमत है।

— बिल्ली

@cat rangeऑब्जेक्ट की तरह वापस नहीं करता है combinations। उत्तरार्द्ध संयोजनों पर एक पुनरावृत्ति देता है जो एक अलग प्रकार है जिसमें कोई परिभाषित lengthविधि नहीं है । देखें यहाँ । (साथ ही निर्माण श्रेणियों के लिए :सिंटैक्स को प्राथमिकता दी rangeजाती है;))

— एलेक्स ए।

Answer 12

ऋषि, 55 बाइट्स

lambda a:n((sum(map(euler_phi,range(1,a+1)))*2-1)/a**2)

प्रतीकात्मक रूप से सब कुछ कंप्यूटिंग के लिए धन्यवाद, मशीन एप्सिलॉन और फ्लोटिंग-पॉइंट मुद्दे फसल नहीं करते हैं। ट्रेडऑफ़, आउटपुट स्वरूप नियम का पालन करने के लिए, n()(दशमलव सन्निकटन फ़ंक्शन) के लिए एक अतिरिक्त कॉल की आवश्यकता है।

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

Comments

बहुत अच्छा! आप ऋषि का उपयोग कर रहे हैं प्रतीत होता है बहुत बार हाल ही में :-)

— लुइस मेंडो

@LuisMendo ऋषि महान हैं और सभी चीजों को करते हैं। गणित-आधारित चुनौतियों पर उपयोग करना बहुत अच्छा है क्योंकि इसमें मैथमेटिका जैसी विशाल बिलियन लाइब्रेरी है, लेकिन सिंटेक्स बेहतर है (ए) के कारण मैथमेटिका नहीं बन रहा है, और बी) पायथन पर बनाया जा रहा है।

— मेघो

Answer 13

MATL , 20 17 बाइट्स

यह भाषा के वर्तमान संस्करण (5.0.0) का उपयोग करता है ।

@ दोष के उत्तर के आधार पर दृष्टिकोण ।

i:tg!X*t!Zd1=Y)Ym

संपादित करें (28 अप्रैल, 2015) : इसे ऑनलाइन आज़माएं! इस उत्तर को पोस्ट करने के बाद, फ़ंक्शन Y)का नाम बदल दिया गया X:; लिंक में वह परिवर्तन शामिल है।

उदाहरण

>> matl i:tg!X*t!Zd1=Y)Ym
> 100
0.6087

व्याख्या

i:         % vector 1, 2, ... up to input number
tg!        % copy, convert into ones, transpose
X*         % Kronecker product. Produces a matrix
t!         % copy, transpose
Zd         % gcd of all pairs
1=         % is it equal to 1?
Y)         % linearize into column array
Ym         % compute mean

---

पुराना उत्तर: 20 बाइट्स

Oi:t"t@Zd1=sb+w]n2^/

व्याख्या

O             % produce literal 0. Initiallizes count of co-prime pairs.
i             % input number, say N
:             % create vector 1, 2, ... N
t             % duplicate of vector
"             % for loop
    t         % duplicate of vector
    @         % loop variable: each element from vector
    Zd        % gcd of vector and loop variable. Produces a vector
    1=s       % number of "1" in result. Each "1" indicates co-primality
    b+w       % accumulate into count of co-prime pairs
]             % end
n2^/          % divide by N^2

Comments

क्या आप ऑक्टेव में उपयोग किए गए एक जैसे दृष्टिकोण के साथ भी छोटे हो सकते हैं?

— दोष

वास्तव में! धन्यवाद! 3 बाइट्स कम। आपको इसे MATL :-)

— लुइस

मुझे लगता है कि अगर यह मेरे सोते समय =) अतीत नहीं था की कोशिश की होगी

— दोष

Answer 14

PARI / GP , 25 बाइट्स

फ़ंक्शन को अनाम बनाने से एक बाइट बच जाएगी, लेकिन फिर मुझे selfइसे समग्र रूप से अधिक महंगा बनाने का उपयोग करना होगा।

f(n)=n^2-sum(j=2,n,f(n\j))

Answer 15

फैक्टर, 120 113 बाइट्स

मैंने इसे क्लास गोल्फिंग के लिए खर्च किया है और मैं इसे छोटा नहीं कर सकता।

: के अनुवाद जूलिया ।

[ [a,b] dup append 2 <combinations> [ members ] keep [ first2 coprime? ] filter [ length ] bi@ 2 /i 1 + swap /f ]

उदाहरण पहले 5 परीक्षण मामलों पर चलता है (1000 का मान संपादक को फ्रीज करने का कारण बनता है, और मुझे अभी एक निष्पादन योग्य संकलन करने के लिए परेशान नहीं किया जा सकता है):

! with floating point division
IN: scratchpad auto-use {
      1    
      2    
      4    
      10   
      100  
    }
    [ 
      [1,b] dup append 2 <combinations> [ members ] keep 
      [ first2 coprime? ] filter [ length ] bi@ 2 /i 1 + swap /f 
    ]
    map

--- Data stack:
{ 1.0 0.75 0.6875 0.63 0.6087 }
! with rational division
IN: scratchpad auto-use {
      1    
      2    
      4    
      10   
      100  
    }
    [ 
      [1,b] dup append 2 <combinations> [ members ] keep 
      [ first2 coprime? ] filter [ length ] bi@ 2 /i 1 + swap / 
    ]
    map

--- Data stack:
{ 1.0 0.75 0.6875 0.63 0.6087 }
{ 1 3/4 11/16 63/100 6087/10000 }

Comments

हो सकता है एक उदाहरण जोड़ें?

— लुइस मेन्डो

@LuisMendo ने किया!

— बिल्ली

Answer 16

Samau , 12 बाइट्स

अस्वीकरण: प्रतिस्पर्धा नहीं क्योंकि मैंने प्रश्न पोस्ट किए जाने के बाद भाषा को अपडेट किया।

▌;\φΣ2*($2^/

हेक्स डंप (Samau CP737 एन्कोडिंग का उपयोग करता है):

dd 3b 5c ad 91 32 2a 28 24 32 5e 2f

जैली में डेनिस के जवाब के रूप में एक ही एल्गोरिदम का उपयोग करना।

Answer 17

Python2 / Pypy, 178 बाइट्स

xफ़ाइल:

N={1:set([1])}
n=0
c=1.0
e=input()
while n<e:
 n+=1
 for d in N[n]:
  m=n+d
  try:N[m].add(d)
  except:N[m]=set([d,m])
 for m in range(1,n):
  if N[m]&N[n]==N[1]:c+=2
print c/n/n

चल रहा है:

$ pypy x <<<1
1.0
$ pypy x <<<10
0.63
$ pypy x <<<100
0.6087
$ pypy x <<<1000
0.608383

कोड (n,m) for m<nदो बार सह-प्राइम जोड़े को गिनता है ( c+=2)। यह उपेक्षा करता है, (i,i) for i=1..nजो इसके अलावा ठीक है (1,1), इस प्रकार क्षतिपूर्ति करने के लिए काउंटर को प्रारंभिक 1( 1.0बाद में फ्लोट डिवीजन के लिए तैयार करने) के साथ ठीक किया जा रहा है ।