प्राकृतिक पाई # 0 - रॉक

Question

लक्ष्य

एक प्रोग्राम / फ़ंक्शन बनाएं जो एक इनपुट लेता है N, यह जांचें कि क्या Nपूर्णांकों के यादृच्छिक जोड़े अपेक्षाकृत प्रमुख हैं, और रिटर्न sqrt(6 * N / #coprime)।

टी एल; डॉ

ये चुनौतियां एल्गोरिदम का अनुकरण हैं जो केवल प्रकृति और आपके मस्तिष्क (और शायद कुछ फिर से उपयोग करने योग्य संसाधनों) को लगभग अनुमानित पीआई की आवश्यकता होती है। यदि आप वास्तव में ज़ोंबी सर्वनाश के दौरान पाई की जरूरत है, इन तरीकों बारूद बर्बाद नहीं है ! अभी आठ और चुनौतियां हैं। सिफारिशें करने के लिए सैंडबॉक्स पोस्ट को चेकआउट करें ।

सिमुलेशन

हम क्या अनुकरण कर रहे हैं? खैर, संभावना है कि दो यादृच्छिक पूर्णांक अपेक्षाकृत प्राइम हैं (यानी कॉप्रेम या जीसीडी == 1) 6/Pi/Pi, इसलिए पाई की गणना करने का एक प्राकृतिक तरीका दो बाल्टी (या मुट्ठी भर) चट्टानों को स्कूप करना होगा; उन्हें गिनो; देखें कि क्या उनकी gcd 1 है; दोहराएँ। एक दो बार ऐसा करने के बाद , sqrt(6.0 * total / num_coprimes)ओर रुख करेंगे Pi। यदि एपोकॉलिक दुनिया में वर्गमूल की गणना आपको परेशान करती है, तो चिंता न करें! उसके लिए न्यूटन की विधि है।

हम इसका अनुकरण कैसे कर रहे हैं?

• इनपुट लें N
• निम्न Nबार करें:
  • समान रूप से यादृच्छिक सकारात्मक पूर्णांक उत्पन्न करते हैं, iऔरj
  • साथ में 1 <= i , j <= 10^6
  • यदि gcd(i , j) == 1:result = 1
  • अन्य: result = 0
• Nपरिणाम का योग लें ,S
• वापसी sqrt(6 * N / S)

विशिष्टता

• इनपुट
  • लचीले, किसी भी मानक तरीके (जैसे फ़ंक्शन पैरामीटर, एसटीडीआईएन) और किसी भी मानक प्रारूप (जैसे स्ट्रिंग, बाइनरी) में इनपुट लें
• उत्पादन
  • लचीले, किसी भी मानक तरीके से आउटपुट दें (जैसे रिटर्न, प्रिंट)
  • श्वेत स्थान, अनुगामी और प्रमुख श्वेत स्थान स्वीकार्य है
  • सटीकता, कृपया सटीकता के कम से कम 4 दशमलव स्थान प्रदान करें (अर्थात 3.1416)
• स्कोरिंग
  • सबसे छोटा कोड जीतता है!

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

रैंडम चांस के कारण आपका आउटपुट इनसे ऊपर नहीं जा सकता है। लेकिन औसतन, आपको दिए गए मूल्य के लिए इस सटीकता के बारे में जानना चाहिए N।

Input     ->  Output 
-----         ------
100       ->  3.????
10000     ->  3.1???
1000000   ->  3.14??

Comments

क्या हमारे जवाब के लिए काम करने की जरूरत है N = 1000000या क्या यह ठीक है अगर कार्यक्रम वापस आ जाता है जैसे एक स्टैक अतिप्रवाह यदि Nबहुत बड़ा है?

— घातक

@ अगर यह भाषा की सीमा है, तो निश्चित करें। अन्यथा, आपको संभालने की आवश्यकता है N=10^6।

— नॉनलाइनयरफ्रूट

संबंधित

— लुइस मेंडो

लक्ष्य भ्रामक है, यह बताता है कि पूर्णांकों की केवल एक जोड़ी की जाँच की जाती है।

— user253751

क्या उत्पन्न यादृच्छिक संख्या की ऊपरी सीमा ठीक 1000000 होनी चाहिए? क्या एक बड़ी ऊपरी सीमा स्वीकार्य होगी?

— सोक

Answer 1

एपीएल, 23 ​​बाइट्स

{.5*⍨6×⍵÷1+.=∨/?⍵2⍴1e6}

स्पष्टीकरण:

• ?⍵2⍴1e6: श्रेणी में यादृच्छिक संख्याओं का 2-by-2 मैट्रिक्स उत्पन्न करें [1..10 ⁶ ]
• 1+.=∨/: प्रत्येक जोड़ी का जीसीडी प्राप्त करें और देखें कि कितने 1 के बराबर हैं। यह गणना एस।
• .5*⍨6×⍵÷: (6 × (÷ S) ^0.5

Answer 2

जेली , 20 18 16 बाइट्स

-2 बाइट्स @ Pietu1998 के लिए धन्यवाद (चेन और उपयोग गिनती 1s, ċ1दो से कम के स्थान पर <2S)

-2 बाइट्स @ @ डेनिस के लिए धन्यवाद (चेनिंग से बचने के लिए नमूना लेने से पहले कई बार 1e6 दोहराएं)

Ḥȷ6xX€g2/ċ1÷³6÷½

(यादृच्छिक समारोह के कारण बेहद धीमी गति से)

कैसे?

Ḥȷ6xX€g2/ċ1÷³6÷½ - Main link: n
 ȷ6              - 1e6
   x             - repeat
Ḥ                -     double, 2n
    X€           - random integer in [1,1e6] for each
       2/        - pairwise reduce with
      g          -     gcd
         ċ1      - count 1s
           ÷     - divide
            ³    - first input, n
             6   - literal 6
              ÷  - divide
               ½ - square root

TryItOnline

Comments

ḤRµȷ6Xµ€g2/ċ1÷³6÷½2 बाइट्स बचाता है। ( ȷ6एक ċ1

— नीलदाद

आह, मैं इसे कैसे चेन बना सकता हूं, इस तरह से (मैंने कुछ चीजों की कोशिश की), और गिनती 1 चाल को भूल गया - धन्यवाद (मुझे लगता ȷ²है कि एक छोटे से थोड़ा तेज है ȷ6)

— जोनाथन एलन

हो सकता है। अब जब कि मैं इसके बारे में सोचता हूं, ȷ²दो लिंक यहां चोट नहीं करते हैं, लेकिन एक अतिरिक्त लिंक की आवश्यकता होगी या ¤कुछ उपयोग के मामलों के लिए

— PurkkaKoodari

Ḥȷ6xX€यादृच्छिक नमूने के लिए काम करना चाहिए।

— डेनिस

Answer 3

अजगर 2, 143 140 132 124 122 124 122 बाइट्स

जब से मैंने गोल्फ की कोशिश की है, तब से काफी समय हो गया है, इसलिए मुझे यहाँ कुछ याद आ सकता है! मैं इसे छोटा करने के रूप में अद्यतन कर रहा हूँ।

import random as r,fractions as f
n,s=input(),0
k=lambda:r.randrange(1e6)+1
exec's+=f.gcd(k(),k())<2;'*n
print(6.*n/s)**.5

^{मुझे यहाँ टेस्ट करो !}

^{दो-बाइट बचाने के लिए जोनाथन एलन को धन्यवाद :)}

Comments

ओपी के अनुसार 1 <= i , j <= 10^6, इसलिए आपको उपयोग करने की आवश्यकता है randrange(1,1e6+1)।

— mbomb007

इसके अलावा, भाषा के नाम के भीतर repl.it लिंक होना वास्तव में अजीब है। लैंग नाम का एक लिंक भाषा के होम पेज पर होना चाहिए, अगर कुछ भी हो। अपने repl.it लिंक को अपने कोड के नीचे एक अलग लिंक के रूप में रखें।

— mbomb007

@ mbomb007 अच्छी बात है, मैंने इसे ठीक कर लिया है :) थोड़ी देर हो गई!

— केड

k=lambda:r.randrange(1e6)+1दो बाइट्स बचाता है

— जोनाथन एलन

@JonathanAllan अच्छी पकड़, धन्यवाद!

— Kade

Answer 4

गणितज्ञ, ४ ९ ४ by ५१ बाइट्स

एक बाइट को बचाया और @ LegionMammal978 को एक बग धन्यवाद दिया ।

(6#/Count[GCD@@{1,1*^6}~RandomInteger~{2,#},1])^.5&

Comments

आप एक बाइट बचा सकते हैं:(6#/Count[GCD@@1*^6~RandomInteger~{2,#},1])^.5&

— LegionMammal978

इसके अलावा, यह सुनिश्चित करने के लिए 1*^6प्रतिस्थापित किया जाना चाहिए {1,1*^6}कि i , j

— Leg

Answer 5

आर, 103 99 95 99 99 98 94 बाइट्स

संभावना थोड़ा नीचे गोल्फ हो सकता है। @ एंटोनी-सैक, और एक अन्य 4 बाइट्स के कारण एक अलियास को परिभाषित sampleकरने के ^.5बजाय sqrt, और के 1e6बजाय का उपयोग करके 4 बाइट्स में कटौती करें 10^6। जोड़ा गया 4 बाइट सुनिश्चित करना है कि के नमूने iऔर jसही मायने में एक समान है। एक बाइट को हटाने के बाद मुझे एहसास हुआ कि 6*N/sum(x)यह उसी तरह है 6/mean(x)। 4 बाइट्स को बचाने के pryr::fबजाय उपयोग किया जाता है function(x,y)।

N=scan()
s=sample
g=pryr::f(ifelse(o<-x%%y,g(y,o),y))
(6/mean(g(s(1e6,N,1),s(1e6,N,1))==1))^.5

नमूना उत्पादन:

N=100     -> 3.333333
N=10000   -> 3.137794
N=1000000 -> 3.141709

Comments

आप बस उपयोग कर सकते हैं sample(10^6,N)। न केवल यह कम है, यह बहुत अधिक कुशल भी है।

— asac -

मैं गलत हो सकता हूं, लेकिन ठीक से एकसमान यादृच्छिक पूर्णांकों के लिए प्रतिस्थापित = टी के साथ नमूना का उपयोग नहीं किया जाना चाहिए। उदाहरण के लिए sample(10,10)1:10 में सभी नंबरों को वापस करने की गारंटी है, जबकि sample(10,10,T)एक यादृच्छिक चयन का उत्पादन करेगा जहां संख्याओं को दोहराया जा सकता है।

— मिकट

@ मिक्की तुम बिल्कुल सही हो, मुझे अभी कुछ मिनट पहले ही इस बात का एहसास हुआ। मुझे पूरी तरह से यकीन नहीं है कि यह इस उदाहरण में गणितीय रूप से कैसे निभाता है - जहां तक ​​मैं बता सकता हूं, दोनों विधियां लगभग समान रूप से सटीक हैं। मैं इस जानकारी को जोड़ने के लिए अपनी पोस्ट संपादित करूंगा।

— rturnbull

एन << 10 ^ 6 जब दोनों विधियां समान रूप से सटीक होती हैं। मनमाने ढंग से बड़े एन को संभालने के लिए, आपको प्रतिस्थापन, अच्छी पकड़ के साथ नमूना लेना होगा।

— asac -

Answer 6

दरअसल, 19 बाइट्स

`6╤;Ju@Ju┤`nkΣß6*/√

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

स्पष्टीकरण:

`6╤;Ju@Ju┤`nkΣß6*/√
`6╤;Ju@Ju┤`n         do this N times:
 6╤;                   two copies of 10**6
    Ju                 random integer in [0, 10**6), increment
      @Ju              another random integer in [0, 10**6), increment
         ┤             1 if coprime else 0
            kΣ       sum the results
              ß      first input again
               6*    multiply by 6
                 /   divide by sum
                  √  square root

Comments

i, j को 0

— isaacg

@isaacg वे नहीं हैं। यदि आप स्पष्टीकरण को पढ़ेंगे, तो यह कहता है कि यादृच्छिक मानों का चयन [0, 10 ** 6) से किया जाता है, फिर वेतन वृद्धि।

— मेगो

Answer 7

MATL , 22 बाइट्स

1e6Hi3$YrZ}Zd1=Ym6w/X^

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

1e6      % Push 1e6
H        % Push 2
i        % Push input, N
3$Yr     % 2×N matrix of uniformly random integer values between 1 and 1e6
Z}       % Split into its two rows. Gives two 1×N arrays
Zd       % GCD, element-wise. Gives a 1×N array
1=       % Compare each entry with 1. Sets 1 to 0, and other values to 0
Ym       % Mean of the array
6w/      % 6 divided by that
X^       % Square root. Implicitly display

Answer 8

पायथ, 21 बाइट्स

@*6cQ/iMcmhO^T6yQ2lN2

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

व्याख्या

                Q          input number
               y           twice that
         m                 map numbers 0 to n-1:
             T                 10
            ^ 6                to the 6th power
           O                   random number from 0 to n-1
          h                    add one
        c        2         split into pairs
      iM                   gcd of each pair
     /            lN       count ones
   cQ                      divide input number by the result
 *6                        multiply by 6
@                   2      square root

Answer 9

स्काला, 149 126 बाइट्स

val& =BigInt
def f(n: Int)={math.sqrt(6f*n/Seq.fill(n){val i,j=(math.random*99999+1).toInt
if(&(i).gcd(&(j))>1)0 else 1}.sum)}

स्पष्टीकरण:

val& =BigInt                //define & as an alias to the object BigInt, because it has a gcd method
def f(n:Int)={              //define a method
  math.sqrt(                //take the sqrt of...
    6f * n /                //6 * n (6f is a floating-point literal to prevent integer division)
    Seq.fill(n){            //Build a sequence with n elements, where each element is..
      val i,j=(math.random*99999+1).toInt //take 2 random integers
      if(&(i).gcd(&(j))>1)0 else 1        //put 0 or 1 in the list by calling
                                          //the apply method of & to convert the numbers to
                                          //BigInt and calling its bcd method
    }.sum                   //calculate the sum
  )
}

Comments

मैं <3 स्काला! खासकर, क्योंकि यह कभी-कभी एक स्पष्टीकरण की आवश्यकता होती है।

— रोमन ग्रैफ़

@ RomanGräf ईमानदार होने के लिए, मुझे लगता है कि केवल चीजें अस्पष्ट हो सकती हैं 6f, Seq.fillऔर math.random।

— corvus_192

Answer 10

रैकेट 92 बाइट्स

(λ(N)(sqrt(/(* 6 N)(for/sum((c N))(if(= 1(gcd(random 1 1000000)(random 1 1000000)))1 0)))))

Ungolfed:

(define f
  (λ (N)
    (sqrt(/ (* 6 N) 
            (for/sum ((c N))
              (if (= 1
                     (gcd (random 1 1000000)
                          (random 1 1000000)))
                  1 0)
              )))))

परिक्षण:

(f 100)
(f 1000)
(f 100000)

आउटपुट:

2.970442628930023
3.188964020716403
3.144483068444827

Answer 11

जावास्क्रिप्ट (ईएस 7), 107 95 94 बाइट्स

n=>(n*6/(r=_=>Math.random()*1e6+1|0,g=(a,b)=>b?g(b,a%b):a<2,q=n=>n&&g(r(),r())+q(n-1))(n))**.5

ES6 संस्करण बिल्कुल 99 बाइट्स है, लेकिन ES7 घातांक ऑपरेटर **5 बाइट्स बचाता है Math.sqrt।

Ungolfed

function pi(n) {
  function random() {
    return Math.floor(Math.random() * 1e6) + 1;
  }
  function gcd(a, b) {
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }
  function q(n) {
    if (n == 0)
      return 0;
    return (gcd(random(), random()) == 1 ? 1 : 0) + q(n - 1));
  }
  return Math.sqrt(n * 6 / q(n));
}

Comments

Ungolfed संस्करण gcdमें फ़ंक्शन को कॉल करता हैg

— रोमन ग्रैफ़

r=_=>क्या वह कोड या एक ड्राइंग है?

— aross

n=>(n*6/(r=_=>Math.random()*1e6,g=(a,b)=>b?g(b,a%b):a>-2,q=n=>n&&g(~r(),~r())+q(n-1))(n))**.51 बी छोटा

— l4m2

n=>(n*6/(q=_=>n--&&q(r=_=>Math.random()*1e6)+g(~r(),~r()))(g=(a,b)=>b?g(b,a%b):a>-2))**.5

— l4m2

Answer 12

PHP, 82 77 74 बाइट्स

for(;$i++<$argn;)$s+=2>gmp_gcd(rand(1,1e6),rand(1,1e6));echo(6*$i/$s)**.5;

इस तरह से चलाएं:

echo 10000 | php -R 'for(;$i++<$argn;)$s+=2>gmp_gcd(rand(1,1e6),rand(1,1e6));echo(6*$i/$s)**.5;' 2>/dev/null;echo

व्याख्या

टिन पर दिये गये निर्देशों का पालन करो। इसके लिए PHP_GMP की आवश्यकता है gcd।

बदलाव

• का उपयोग करके 3 बाइट्स सहेजे गए $argn

Answer 13

पर्ल, 64 बाइट्स

sub r{1+~~rand 9x6}$_=sqrt$_*6/grep{2>gcd r,r}1..$_

कमांड लाइन विकल्प की आवश्यकता होती है -pMntheory=gcd, जिसे 13. के रूप में गिना जाता है। इनपुट स्टड से लिया जाता है।

नमूना उपयोग

$ echo 1000 | perl -pMntheory=gcd pi-rock.pl
3.14140431218772

Answer 14

आर, 94 बाइट्स

N=scan();a=replicate(N,{x=sample(1e6,2);q=1:x[1];max(q[!x[1]%%q&!x[2]%%q])<2});(6*N/sum(a))^.5

अपेक्षाकृत धीमी गति से लेकिन फिर भी काम करता है। एन बार एक फ़ंक्शन को दोहराएं जो 2 यादृच्छिक संख्या (1 से 1e6 तक) लेता है और जांचता है कि क्या उनकी एलसीडी 2 से कम है ( मेरा एक पुराना एलसीडी फ़ंक्शन का उपयोग करके )।

Comments

यदि आप चेतावनी के बारे में चिंतित नहीं हैं, 1:xतो काम करेंगे।

— मिकी

Answer 15

PowerShell v2 +, 118 114 बाइट्स

param($n)for(;$k-le$n;$k++){$i,$j=0,1|%{Random -mi 1};while($j){$i,$j=$j,($i%$j)}$o+=!($i-1)}[math]::Sqrt(6*$n/$o)

इनपुट लेता है $n, forतब तक एक लूप शुरू करता है जब तक $kबराबर $n( $k=0पहले लूप में प्रवेश करने पर निहित )। प्रत्येक पुनरावृत्ति, नए Randomनंबर प्राप्त करें $iऔर $j( -miअधिकतम 1ध्वज सुनिश्चित करें कि हम हैं >=1और कोई भी अधिकतम ध्वज अप करने की अनुमति नहीं देता है [int]::MaxValue, जिसे ओपी द्वारा अनुमति दी जाती है क्योंकि यह उससे बड़ा है 10e6)।

हम फिर जीसीडी whileलूप में जाते हैं । फिर, जब तक जीसीडी है 1, तब तक बढ़ $oजाता है। forलूप के अंत में , हम एक साधारण [math]::Sqrt()कॉल करते हैं, जो पाइप लाइन पर छोड़ दिया जाता है और आउटपुट निहित है।

10000मेरे ~ 1 वर्षीय कोर i5 लैपटॉप पर इनपुट के साथ चलने के लिए लगभग 15 मिनट लगते हैं ।

उदाहरण

PS C:\Tools\Scripts\golfing> .\natural-pi-0-rock.ps1 100
3.11085508419128

PS C:\Tools\Scripts\golfing> .\natural-pi-0-rock.ps1 1000
3.17820863081864

PS C:\Tools\Scripts\golfing> .\natural-pi-0-rock.ps1 10000
3.16756133579975

Answer 16

जावा 8, 164 151 बाइट्स

n->{int c=n,t=0,x,y;while(c-->0){x=1+(int)(Math.random()*10e6);y=1+(int)(Math.random()*10e6);while(y>0)y=x%(x=y);if(x<2)t++;}return Math.sqrt(6f*n/t);}

व्याख्या

n->{
    int c=n,t=0,x,y;
    while(c-->0){                          // Repeat n times
        x=1+(int)(Math.random()*10e6);     // Random x
        y=1+(int)(Math.random()*10e6);     // Random y
        while(y>0)y=x%(x=y);               // GCD
        if(x<2)t++;                        // Coprime?
    }
    return Math.sqrt(6f*n/t);              // Pi
}

दोहन ​​परीक्षण

class Main {
    public static interface F{ double f(int n); }
    public static void g(F s){
        System.out.println(s.f(100));
        System.out.println(s.f(1000));
        System.out.println(s.f(10000));
    }
    public static void main(String[] args) {
        g(
            n->{int c=n,t=0,y,x;while(c-->0){x=1+(int)(Math.random()*10e6);y=1+(int)(Math.random()*10e6);while(y>0)y=x%(x=y);if(x<2)t++;}return Math.sqrt(6f*n/t);}
        );
    }
}

अद्यतन करें

• -13 [16-10-05] के लिए धन्यवाद @TNT और कहा कि परीक्षण दोहन

Comments

आपको पहले के आसपास कोष्ठक की आवश्यकता नहीं है n, t+=1बन सकते हैं t++, आप अपनी intघोषणाओं को एक पंक्ति में सीमित कर सकते हैं , अर्थात int c=n,t=0,x,y;, !=0( और मुझे लगता है) बन सकते हैं >0। कुल मिलाकर 12 बाइट्स बचाना चाहिए। हालांकि, यह x और y का GCD खोजने का एक साफ तरीका है।

— टीएनटी

Answer 17

पर्ल 6 , 56 53 बाइट्स

{sqrt 6*$_/(1..10⁶).roll(*).map(*gcd*==1)[^$_].sum}

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

Answer 18

फ्रिंक, 84 89

r[]:=random[10^6]+1
g=n=eval[input[1]]
for a=1to n
g=g-1%gcd[r[],r[]]
println[(6*n/g)^.5]

मैं भाग्यशाली रहा: जी = एन = ... जी = 0 एन = ... पर एक बाइट बचाता है ; और 1% gcd () देता है (0,1) बनाम (1,0) ताकि मैं घटा सकूं। और अशुभ: n पहले ही असाइन कर रहा है और एक का इस्तेमाल किया क्योंकि पाश चर और उनकी सीमा स्थानीय और लूप के बाहर अपरिभाषित है।

वाचाल

r[] := random[10^6] + 1     // function. Frink parses Unicode superscript!
g = n = eval[input[""]]     // input number, [1] works too
for a = 1 to n              // repeat n times
   g = g - 1%gcd[r[], r[]]  // subtract 1 if gcd(i, j) > 1
println[(6*n/g)^.5]         // ^.5 is shorter than sqrt[x], but no super ".", no ½

Comments

कि 90 बाइट्स और 88 चर्चे हैं ...?

— कैलक्यूलेटरफ्लेन

उस पकड़ने के लिए धन्यवाद। मैंने नई संख्याओं की गणना नहीं की है, और,, only केवल 1 बाइट हैं, अधिक। मैंने इसे 89 बाइट्स के साथ तय किया, जिसमें कोई अंतिम न्यूलाइन नहीं थी।

— मई

आपने क्रिया कोड निर्धारित नहीं किया है।

— कैलक्यूलेटरफ़ेलीन

वैसे भी स्पेस, कोट्स और नंबर्स आदि के साथ यह एक-से-एक मैच नहीं है

— maybeso

Answer 19

AWK , 109 बाइट्स

func G(p,q){return(q?G(q,p%q):p)}{for(;i++<$0;)x+=G(int(1e6*rand()+1),int(1e6*rand()+1))==1;$0=sqrt(6*$0/x)}1

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

मुझे आश्चर्य है कि यह उचित समय में 1000000 तक चलता है।

Answer 20

पाइट , 37 35 बाइट्स

←Đ0⇹`25*⁶⁺Đ1⇹ɾ⇹1⇹ɾǤ1=⇹3Ș+⇹⁻łŕ⇹6*⇹/√

स्पष्टीकरण:

←Đ                                              Push input onto stack twice
  0                                             Push 0
   ⇹                                            Swap top two elements of stack
    `                      ł                    Repeat until top of stack is 0
     25*⁶⁺Đ1⇹ɾ⇹1⇹ɾ                              Randomly generate two integers in the range [1,10^6]
                  Ǥ1=                           Is their GCD 1?
                     ⇹3Ș                        Reposition top three elements of stack
                        +                       Add the top 2 on the stack
                         ⇹⁻                     Swap the top two and subtract one from the new top of the stack
                            ŕ                   Remove the counter from the stack
                             ⇹                  Swap the top two on the stack
                              6*                Multiply top by 6
                                ⇹               Swap top two
                                 /              Divide the second on the stack by the first
                                  √             Get the square root

Answer 21

जे, 27 बाइट्स

3 :'%:6*y%+/(1:=?+.?)y#1e6'

स्पष्टीकरण:

3 :'                      '  | Explicit verb definition
                     y#1e6   | List of y copies of 1e6 = 1000000
            (1:=?+.?)        | for each item, generate i and j, and test whether their gcd is 1
          +/                 | Sum the resulting list
      6*y%                   | Divide y by it and multiply by six
    %:                       | Square root

एक 3.14157के साथ बहुत भाग्यशाली है N = 10000000, जो 2.44सेकंड लिया ।

Answer 22

जाप , 23 बाइट्स

*6/UÆ1+1e6ö)j1+1e6öÃx)¬

कोशिश करो