पाई के अंकों की गणना करें

Question

यह कुछ अलग काम है। X 1024 हेक्साडेसिमल की गणना करें, th की 1024 वीं हेक्साडेसिमल जगह पर शुरुआत करते हुए।

औपचारिक रूप से: आपका कार्यक्रम कम से कम 1 मिनट में पूरा होना चाहिए और निम्नलिखित आउटपुट का उत्पादन करना चाहिए:

25d479d8f6e8def7e3fe501ab6794c3b976ce0bd04c006bac1a94fb6409f60c45e5c9ec2196a246368fb6faf3e6c53b51339b2eb3b52ec6f6dfc511f9b30952ccc814544af5ebd09bee3d004de334afd660f2807192e4bb3c0cba85745c8740fd20b5f39b9d3fbdb5579c0bd1a60320ad6a100c6402c7279679f25fefb1fa3cc8ea5e9f8db3222f83c7516dffd616b152f501ec8ad0552ab323db5fafd23876053317b483e00df829e5c57bbca6f8ca01a87562edf1769dbd542a8f6287effc3ac6732c68c4f5573695b27b0bbca58c8e1ffa35db8f011a010fa3d98fd2183b84afcb56c2dd1d35b9a53e479b6f84565d28e49bc4bfb9790e1ddf2daa4cb7e3362fb1341cee4c6e8ef20cada36774c01d07e9efe2bf11fb495dbda4dae909198eaad8e716b93d5a0d08ed1d0afc725e08e3c5b2f8e7594b78ff6e2fbf2122b648888b812900df01c4fad5ea0688fc31cd1cff191b3a8c1ad2f2f2218be0e1777ea752dfe8b021fa1e5a0cc0fb56f74e818acf3d6ce89e299b4a84fe0fd13e0b77cc43b81d2ada8d9165fa2668095770593cc7314211a1477e6ad206577b5fa86c75442f5fb9d35cfebcdaf0c7b3e89a0d6411bd3ae1e7e4900250e2d2071b35e226800bb57b8e0af2464369bf009b91e5563911d59dfa6aa78c14389d95a537f207d5ba202e5b9c5832603766295cfa911c819684e734a41b3472dca7b14a94a

सबसे कम लंबाई वाला कार्यक्रम जीतता है। आपको रनटाइम पर सभी अंकों की गणना करनी होगी। आपको algorithm गणना करने वाले एल्गोरिथ्म को लागू करने की आवश्यकता नहीं है; यदि आपकी भाषा पहले से ही उस कार्यक्षमता को प्रदान करती है, तो आप इसका उपयोग कर सकते हैं।

Comments

हह, आसान होना चाहिए। (+1, अभी भी) मुझे यकीन है कि मैं इसे कुछ सेकंड से भी कम समय में निष्पादित कर सकता हूं।

— मतीन उल्हाक

@ मंटू: और? आपका समाधान कहां है?

— फ़ूजज़नल

मैं इसे करना भूल गया। :) BTW, गति! = कोड-गोल्फ।

— मतीन उल्हाक

@ मंटू: मुझे पता है। लेकिन मुझे यह भी लगता है, कि 5 दिन ऐसे आसान काम के लिए अच्छा समय है।

— फ़ूजएक्सएक्सएल

Answer 1

साधु, 29 चार

यह तकनीकी रूप से धोखा नहीं है, क्योंकि अंकों की गणना रनटाइम पर की जाती है। उस ने कहा, यह अभी भी नरक के रूप में सस्ता है।

hex(floor(pi*2^8192))[1025:]

Comments

निश्चित रूप से धोखा नहीं है।

— FUZxxl

मम्म, फर्श पी।

— ब्रेडबॉक्स

Answer 2

शैल उपयोगिताएँ: 48

curl -sL ow.ly/5u3hc|grep -Eom 1 '[a-f0-9]{1024}'

• सभी आउटपुट रनटाइम पर "गणना" किया जाता है। (समाधान पोस्ट करने के लिए ओपी को धन्यवाद)
• एक मिनट से कम में चलता है। (आपके इंटरनेट कनेक्शन की गति पर निर्भर हो सकता है)

Comments

आमतौर पर मैं इस तरह के समाधानों को अस्वीकार कर देता हूं, क्योंकि वे नियमों का एक सामान्य दुरुपयोग हैं और अब मजाकिया नहीं हैं। लेकिन सिर्फ इसलिए कि आप प्रदान किए गए संदर्भ समाधान को लेने के लिए बहुत डरपोक हैं और लिखते हैं कि रनटाइम पर सभी आउटपुट "गणना" है। (समाधान पोस्ट करने के लिए ओपी को धन्यवाद) , मैं आपको एक

— उत्थान देता हूं

गोल्फ संस्करण: curl -sL ow.ly/shKGY|grep -Po \\w{99,}(37)। डैश में काम करता है। बैश को एक अतिरिक्त बाइट की आवश्यकता होगी।

— डेनिस

Answer 3

जे, ^{156, 140, 137} 127

d=:3 :'1|+/4 _2 _1 _1*+/(y&(16^-)%1 4 5 6+8*])"0 i.y+9'
,1([:}.'0123456789abcdef'{~[:|.[:<.[:(],~16*1|{.)^:8 d)"0\1024x+8*i.128

BBP सूत्र का उपयोग करना।

करता नहीं एक मिनट के अंतर्गत में चलाने (लेकिन हम एक जम्मू उत्तर है: पी)

Π के पहले 104 अंकों के लिए उदाहरण (यह तेजी से चलता है):

,1([:}.'0123456789abcdef'{~[:|.[:<.[:(],~16*1|{.)^:8 d)"0\8*i.13x

243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89
452821e638d01377be5466cf34e90c6cc0ac29b7

Comments

आप हेक्साडेसिमल में संख्याओं को परिवर्तित करने के लिए # का उपयोग क्यों नहीं करते हैं?

— फ़ूजएक्सएक्सएल

मुझे नहीं पता तुम्हारा क्या मतलब है। #:हेक्स अंकों को आउटपुट नहीं करेगा।

— बारह

IMHO # का उपयोग करना आसान है: और अपने वर्तमान दृष्टिकोण की तुलना में हेक्स-अंक उत्पन्न करने के लिए एक नया आकार।

— 21

आप कुछ मतलब है (... 16 #:) Pi? मुझे लगता है कि हमारे पास पर्याप्त अंक नहीं हैं इसलिए हमें उन्हें वैसे भी उत्पन्न करना होगा।

— 12

BTW, मुझे पता चला कि hfdसंख्या को हेक्साडेसिमल में बदलने की क्रिया है।

— 13

Answer 4

जावास्क्रिप्ट, 536

(केवल दायित्व के लिए लाइनब्रेक और इंडेंटेशन)

var d='0123456789abcdef',p='',o='',l=3e3,c=0,e='length';d=d+d;
function $(n,r){return n[e]<=r?0:d.indexOf(n[r])}
function g(a,b){for(i=0,t='',s=16;i<l;i++,t+=d[~~(s/b)],s=(s%b)*16);
for(;a--;t=_(t,t,1));return t}
function _(a,b,s){for(i=(a[e]>b[e]?a[e]:b[e])-1,r='',c=0;i>=0;r=(s?
  function(k){c=k>15;return d[k]}($(a,i)+$(b,i)+c):
  function(k){c=k<0;return d[k+16]}($(a,i)-$(b,i)-c))+r,i--);return r}
for(i=0;i<l;i++,p+='2');
for(j=1;j<l;p=_(p,(o+='0')+_(_(_(g(2,8*j+1),g(1,8*j+4)),g(0,8*j+5)),g(0,8*j+6)),1),j++);
console.log(p.slice(1024,2048))

इंटेल i5 कोर का उपयोग करते हुए Google Chrome 14 पर मेरे लैप-टॉप पर लगभग 25 सेकंड लगते हैं। किसी और को इस कोड गोल्फ कर सकते हैं? मैं अच्छी तरह से गोल्फ नहीं कर सकता .. :(

नीचे गैर-गोल्फ है। मैं सिर्फ सभी टिप्पणियों को हटाता हूं और लूप के लिए गोल्फ में बदल गया हूं।

के बारे में उल्लेख नहीं है for(;s>=b;s-=b);s*=16;। मैंने इसे बदल दिया s=(s%b)*16। : पी

/**
Calculate PI-3 to 3000 (3e3) digits.
a : a
b : b
c : carry
d : digits
e : length
f : get from d
g : calculate (2^a)/b.
i,j, : for looping
l : length to calculate
p : pi
r,t : return value
*/
var d='0123456789abcdef',p='',o='',l=3e3,c=0,e='length';
d=d+d;//for carring

function $(n,r){return n[e]<=r?0:d.indexOf(n[r])}
/*
Calculate (2^a)/b. Assume that 2^a < b.
*/
function g(a,b){
    for(i=0,t='',s=16;i<l;i++){t+=d[~~(s/b)];for(;s>=b;s-=b);s*=16;}
    for(;a--;t=_(t,t,1));return t}
/*
Calculate a±b. (+ when s=1, - when s=0) When calculating minus, assume that 1>b>a>0.
*/
function _(a,b,s){
    for(i=(a[e]>b[e]?a[e]:b[e])-1,r='',c=0;i>=0;
        r=(s?function(k){c=k>15;return d[k]}($(a,i)+$(b,i)+c):
            function(k){c=k<0;return d[k+16]}($(a,i)-$(b,i)-c))+r,i--);return r;
}
/*
Using BBP formula. Calc when j=0...
4/1 - 2/4 - 1/5 - 1/6 = 3.22222222.... (b16)
*/
for(i=0;i<l;i++,p+='2');
//Calc when j>0
for(j=1;j<l;p=_(p,(o+='0')+_(_(_(g(2,8*j+1),g(1,8*j+4)),g(0,8*j+5)),g(0,8*j+6)),1),j++);
console.log(p.slice(1024,2048));

संपादित करें: पूरी तरह से अप्रयुक्त फ़ंक्शन को हटा दिया गया। (मैंने ऐसा क्यों रखा ?: /)

पुनश्च। पीआई के पहले 100 अंक

243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89452821e638d01377be5466cf34e90c6cc0ab

Comments

@FUZxxl: क्या गैर-गोल्फ कोड पर्याप्त नहीं था? .. :(

— जमिनपी

वाकई ऐसा था। लेकिन IMHO यह बेहतर दिखता है, यदि आप बैकटिक सिंटैक्स का उपयोग करने के बजाय कोड स्वरूपण का उपयोग करते हैं। जैसा कि मैंने लिखा है, यदि आप नापसंद करते हैं तो वापस लौटने के लिए स्वतंत्र महसूस करें।

— फ़ूजएक्सएक्सएल

d='0123456789abcdef',l=3e3,p=Array(l+1).join(2),o='',c=0,e='length';d+=d;function _(a,b,s){for(i=(a[e]>b[e]?a[e]:b[e])-1,r='',c=0;i+1;r=d[Z=F(b,i,1)+c,k=F(a,i,1)+(s?Z:16-Z),c=s?k>15:k<16,k]+r,i--);return r}function F(a,b,f){if(f)f=a[e]>b?d.indexOf(a[b]):0;else{for(i=0,f='',s=16;i++<l;f+=d[~~(s/b)],s=(s%b)*16);while(a--)f=_(f,f,1)}return f}for(j=0;++j<l;p=_(p,(o+='0')+_(_(_(F(2,z=8*j+1),F(1,z+3)),F(0,z+4)),F(0,z+5)),1));console.log(p.slice(1024,2048))

— पीटर टेलर

यह वास्तव में सभी सूक्ष्म-अनुकूलन हैं, हालांकि उनमें से कुछ काफी बड़े दिखते हैं। सबसे बड़ी बचत ऑपरेटर के _पक्ष में दो गुमनाम कार्यों को समाप्त करने से आती है ,। पेचीदा एक उनके बीच चयन करने के लिए एक वैकल्पिक तर्क के साथ $और gएक समारोह में विलय है। functionऔर returnदोनों काफी महंगे हैं, इसलिए एक if(f)...elseऔर एक जोड़ी ,1एक उचित व्यापार है।

— पीटर टेलर

Answer 5

PHP 116 114 बाइट्स

<?for(;$g?$d=0|($$g=$g--/2*$d+($$g?:2)%$g*$f)/$g--:4613^printf($i++>257?'%04x':'',$e+$d/$f=4*$g=16384)^$e=$d%$f;);

यह समाधान एक समय में 2048 हेक्स अंकों, चार हेक्स अंकों तक सभी की गणना करता है, और उनमें से अंतिम आधे को आउटपुट करता है। निष्पादन का समय 5 सेकंड से कम है। गणना के लिए प्रयुक्त सूत्र निम्नलिखित है:

pi = 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + 5/11*(2 + 6/13*(2 + 7/15*(2 + ... )))))))

सटीक एक सरणी में अवशेषों को संग्रहीत करने के लिए प्राप्त किया जाता है, और 2 ^ 14 डिवीजनों में से प्रत्येक को लगातार जारी रखा जाता है।

पायथन 64 बाइट्स

x=p=16385
while~-p:x=p/2*x/p+2*2**8192;p-=2
print('%x'%x)[1025:]

ऊपर जैसा ही तरीका। लगभग 0.2s में चलता है।

या 73 बाइट्स में वन-लाइनर के रूप में :

print('%x'%reduce(lambda x,p:p/2*x/p+2*2**8192,range(16387,1,-2)))[1025:]

Answer 6

PARI / GP-2.4, 141

forstep(d=1024,2047,8,y=frac(apply(x->sum(k=0,d+30,16^(d-k)/(8*k+x)),[1,4,5,6])*[4,-2,-1,-1]~);for(i=0,7,y=16*frac(y);printf("%X",floor(y))))

बेली-बोरवेइन-प्लॉफ़ सूत्र (निश्चित रूप से) का उपयोग करना।

एक मिनट के भीतर अच्छी तरह से चलाता है।

Answer 7

सी कोड:

long ki,k,e,d=1024;
int  dig,tD=0,c,Co=0,j,js[4]  ={1,4,5,6};
double res=0.0,tres=0.0,gT,ans[4] ={0.0};
while(tD < 1024)
{while(Co<4){ j= js[Co],gT=0.0,ki= 0;
 for(; ki < d+1;ki++){ k = 8*ki+j,e= d-ki,c=1; while(e--) c = 16*c % k; gT+=((double)(c)/(double)k);}
 ans[Co] = (gT - (int)gT),++Co;}
 double gA = 4*ans[0]-2*ans[1]-ans[2]-ans[3];
 gA = (gA<0) ? gA + -1*(int)gA +1 : gA -(int)gA;
 dig=0;while(dig++ < 6 && tD++ < 1024) gA *=16, printf("%X",gA),gA -= (int)gA;
 d+=6,Co = 0;}

रनटाइम = एक इंटेल क्वाड कोर पर 8.06 सेकंड

Comments

यह कोड गोल्फ है। लघु चर नामों का उपयोग करके और व्हॉट्सएप से बचने के द्वारा अपने कोड को यथासंभव संपीड़ित करने का प्रयास करें। उदाहरण के लिए, आप printf("%X",(int)gA)उस लंबी सूची के बजाय बहुत से वर्णों को सहेज सकते हैं ।

— फ़ूजएक्सएक्सएल

Answer 8

PARI / GP - 40 बाइट्स

यह संस्करण \xपरिणाम के हेक्साडेसिमल अंकों को प्रदर्शित करने के लिए 'धोखा' देता है ।

\p8197
x=Pi<<4^6;x-=x\1;x=(x<<4^6)\1
\xx

यह संस्करण सामान्य तरीके से हेक्साडेसिमल में बदलने के लिए 87 बाइट्स लेता है।

\p8197
x=Pi<<4^6;x-=x\1;concat([Vec("0123456789abcdef")[n+1]|n<-digits((x<<4^6)\1,16)])

दोनों संस्करण एक दूसरे के एक छोटे से अंश में चलते हैं।

Answer 9

पर्ल - 59

use ntheory"Pi";say substr int(Pi(3000)<<8192)->as_hex,1027

0.1 से कम है।

Answer 10

शैल 68

उपकरण: बीसी-एल, ट्र, कट

echo "scale=2468;obase=16;4*a(1)"|bc -l|tr -d '\\\n'|cut -c1027-2051

शेल 64, टूल्स: बीसी-एल, ट्र, टेल, अंतिम स्थान के गोलाई में भिन्न होता है

echo "scale=2466;obase=16;4*a(1)"|bc -l|tr -d '\\\n'|tail -c1024

धोखा माना जा सकता है, क्योंकि पीआई की गणना करने का ज्ञान 4 * ए (1) में है, और उस 1 को स्केल = 2466 का उपयोग करना था।

कटौती का उपयोग करने के विचार के लिए ब्रेडबॉक्स के लिए धन्यवाद।

Comments

मैं यह नहीं देखता कि इसे धोखा कैसे माना जा सकता है; अंकों की गणना रनटाइम पर की जाती है। हालांकि मुझे ध्यान देना चाहिए कि जब मैं इसे चलाता हूं, तो यह आउटपुट अंतिम अंक (ए के बजाय 7) पर भिन्न होता है। BTW, मुझे लगता है कि आप कुछ वर्णों को बचाने के लिए ddकमांड को बदल सकते हैं tail -c1024।

— ब्रेडबॉक्स

हां, मैंने अंतर भी देखा (और इस पर आधा घंटा खर्च किया :))। अगर मैं bc को x अंकों के पैमाने का उपयोग करने के लिए कहता हूं, तो यह दशमलव मोड में उस अंक तक पहुंच जाता है, और बाद में हेक्स रूपांतरण करता है। इसलिए अगर मैं एक और अंक लेता हूं, तो यह एक 69 का उत्पादन करता है, न कि एक 7. हालांकि - राउंडिंग स्टाइल या ट्रंकेशन प्रश्न में निर्दिष्ट नहीं किया गया था। और पूंछ विचार के लिए धन्यवाद। :)

— उपयोगकर्ता अज्ञात

यह प्रश्न निर्दिष्ट करता है: निर्दिष्ट किए गए आउटपुट को पहचान के रूप में समाप्त करता है और उत्पादन करता है।

— फ्यूजएक्सएक्सएल

@FUZxxl: "चाहिए ...", "नहीं होना चाहिए ..." - मैंने सोचा कि यह जांचने में मदद होनी चाहिए, क्या हेक्स रूपांतरण अच्छा कर रहा है, और वर्णों की गिनती को छोड़ना है, विनिर्देश के भाग के रूप में नहीं , 1024 के अंतिम अंक के अनुरूप। लेकिन मैंने दिया और एक को बदलने के लिए 16 वर्ण जोड़े।

— उपयोगकर्ता अज्ञात

यह देखते हुए कि वाक्य "औपचारिक रूप से" शब्द के साथ शुरू होता है, मैं सहमत हूं कि ओपी का मतलब शायद शब्द के आरएफसी अर्थ में है। इसके अलावा, आप अभी भी के उपयोग बदलकर अपना नया समाधान सुधार कर सकते हैं ddके साथ cut -c1027-2051। (शेल में पाठ धाराओं में हेरफेर करने के लिए कई उपकरण हैं।)

— ब्रेडबॉक्स