18

तो, आप अपने डेस्क पर बैठे थे, पाई के पहले 20 अंकों की गणना करने के लिए एक कार्यक्रम को गोल्फ, और अपने मालिक के साथ आता है और अपने सेब IIe को खिड़की से बाहर फेंकता है। अब आप एक नई परियोजना पर काम कर रहे हैं और इस कंप्यूटर में अभी तक कोई पाठ क्षमता नहीं है। कोई नहीं। कोई फोंट नहीं। कुछ भी तो नहीं।

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

छोटा बोनस (10 अक्षर) यदि यह एक लिसा पर काम करेगा।

संपादित करें: उन लोगों के लिए जिन्होंने इसे मेरी प्रेरणा नहीं माना, पहला मैक था, और शीर्षक एक वाक्य है। @Sukminder को एक बड़ा कुदोस जिसका एनिमेटेड जिफ सिर्फ ठंडा है। बेहतर जवाब के साथ आने पर प्रतियोगिता खत्म नहीं होती है।

— hildred
स्रोत

मुझे चुनौती पसंद है, लेकिन तकनीकी रूप से ऐसी प्रणाली भी स्रोत कोड प्रदर्शित करने में असमर्थ होगी? पीट को छोड़कर, बिल्कुल।

— ApproachingDarknessFish

2

@ValekHalfHeart आप एक अलग मशीन से सोर्स कोड लोड कर सकते हैं

— जॉन ड्वोरक

1

और आप मानव पठनीय को कैसे परिभाषित करते हैं? उदाहरण के लिए, मेरी लिखावट कुछ मनुष्यों (कम से कम एक) के लिए पठनीय है और दूसरों के लिए नहीं। (वैसे, 2 ^ (2x2) = 16, सभी 11 अंकों के लिए पर्याप्त ग्लिफ़।))

— केंडल फ्रे

4

मुझे शीर्षक बिल्कुल समझ में नहीं आता है, मुझे समझ नहीं आता है कि जब हम टेक्स्ट डिस्प्ले का उपयोग नहीं कर सकते, तो ASCII कला कैसे ठीक हो सकती है, और प्रश्न "पीआई की गणना" की परिभाषा की बहुत आवश्यकता है।

— पीटर टेलर

2

"पी की गणना" का वास्तव में क्या मतलब है? क्या मैं पहले 20 दशमलव के बिटमैप को हार्ड-कोड कर सकता हूं? (किसी भी अंतर्निहित PI निरंतर या समान का उपयोग नहीं करता है)

— FireFly

6

पायथन, 222 वर्ण

n=[10**20*277991633/1963319607/10**i%10 for i in range(19,1,-1)]
print' *     *'
print' * **    '+' '.join(' ** * ***** *****  *'[2*d:2*d+2]for d in n)
print'**     * '+' '.join('**  *    * ** ***** '[2*d:2*d+2]for d in n)

पहली पंक्ति सन्निकटन का उपयोग करके पाई के अंकों की गणना करती है pi-3 ~= 277991633/1963319607। अगली तीन पंक्तियाँ ASCII कला नेमेथ ब्रेल का उपयोग करके पाई के 20 वर्णों का उत्पादन करती हैं ।

 *     *
 * **    *  ** *  *   * *  ** *  ** *  *   * **  * ** *  ** * 
**     *     *     * *  *  *   *     * ** *  ** *     *     **

मैं यहां दो दिशाओं में सीमाओं को आगे बढ़ा रहा हूं, "गणनात्मक पाई" और "मानव पठनीय" इंद्रियों दोनों में।

— कीथ रान्डेल
स्रोत

3

क्या बिल्ली है? मुझे लगा कि हम किसी भी टेक्स्ट आउटपुट का उपयोग करने वाले नहीं थे। आपका कंप्यूटर *बिना किसी फ़ॉन्ट के रिक्त स्थान और रेंडर करने के लिए कैसे जा रहा है ?

— बूथबाई

@boothby: यह ASCII कला है। *1x1 श्वेत पिक्सेल के रूप में और `` को 1x1 सफ़ेद पिक्सेल के रूप में सोचें ।

— कीथ रान्डेल

1

वह एक बिंदु है। आप *फोंट का उपयोग किए बिना रेंडर नहीं कर सकते , मुझे लगता है कि आप अयोग्य हैं

— सायरन

18

पायथन, 217 बाइट्स

आवश्यक पायथन इमेजिंग पुस्तकालय

import Image
x=p=141
i=Image.new('1',(x,11))
while~-p:x=p/2*x/p+2*10**19;p-=2
for c in str(x):[i.putpixel((j%7/5*4-~j%7/4*~j/7+p,j%7*3%14%8+j%14/10+2),1&ord('}`7gjO_a\177o'[int(c)])>>j%7)for j in range(17)];p+=7
i.show()

बाइट काउंट मानता है कि बचा हुआ चरित्र \177उसके शाब्दिक समकक्ष (चार्ट 127 ) से बदल दिया गया है ।

आउटपुट निम्न के रूप में दिखाई देगा (यह आपके डिफ़ॉल्ट * .bmp दर्शक में खुलेगा):

ध्यान दें कि आपके द्वारा पसंद किए गए किसी भी अंक को प्रिंट करने के लिए इसे आसानी से पैरामीटर किया जा सकता है। निम्नलिखित स्टड से एक पूर्णांक इनपुट को स्वीकार करेगा, और प्रदर्शित करेगा कि कई अंक:

import Image
n=input()
x=p=n*7|1
i=Image.new('1',(x,11))
while~-p:x=p/2*x/p+2*10**(n-1);p-=2
for c in str(x):[i.putpixel((j%7/5*4-~j%7/4*~j/7+p,j%7*3%14%8+j%14/10+2),1&ord('}`7gjO_a\177o'[int(c)])>>j%7)for j in range(17)];p+=7
i.show()

N = 80 के लिए आउटपुट :

पाई गणना

while~-p:x=p/2*x/p+2*10**19;p-=2

हाँ, यह बात है। उपयोग किया गया सूत्र लिबनीज़ श्रृंखला के लिए यूलर के ट्रांसफ़ॉर्म को लागू करने का परिणाम है , और फिर शेष राशि से प्रत्येक शब्द को फैक्टरिंग करता है। सूत्र रैखिक रूप से परिवर्तित होता है; प्रत्येक अंक में लॉग ₂ (10) ≈ 3.32 पुनरावृत्तियों की आवश्यकता होती है । व्युत्पत्ति में रुचि रखने वालों के लिए, परिशिष्ट ए देखें।

प्रदर्शन

पीआईएल का उपयोग छवि निर्माण के लिए किया जाता है, क्योंकि यह सबसे सुविधाजनक पुस्तकालय है जिसे मैं जानता हूं। एक खाली 141 × 11 काले और सफेद बिटमैप का निर्माण होता है, और फिर सात खंडों वाले फैशन में उस पर सफेद रेखाएं खींची जाती हैं, एक समय में एक पिक्सेल। प्रत्येक खंड को खींचने के लिए आवश्यक पदों को बिटमास्क स्ट्रिंग में संग्रहीत किया जाता है, जिसमें निम्न पदों के लिए बिट्स होते हैं:

(j%7/5*4-~j%7/4*~j/7+p,j%7*3%14%8+j%14/10+2)निम्न क्रम (बेस -18) में प्रत्येक बिट का जादू प्रत्येक पिक्सेल उत्पन्न करता है:

(2, 2), (2, 5), (2, 8), (1, 3), (1, 6), (5, 3), (5, 6),
(3, 2), (3, 5), (3, 8), (1, 4), (1, 7), (5, 4), (5, 7),
(4, 2), (4, 5), (4, 8)

 07e
3   5
a   c
 18f
4   6
b   d
 29g

परिशिष्ट A

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

हम लाइबनिट्स श्रृंखला के साथ शुरू करेंगे:

$\frac{\pi}{4}=\sum\limits_{n=0}^\infty\frac{(-1)^n}{2n+1}=1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\frac{1}{9}-\frac{1}{11}+\frac{1}{13}-\dots$

फिर प्रत्येक शब्द को आधे में विभाजित करें, पड़ोसी शब्दों को मिलाएं:

$\frac{\pi}{4}=\frac{1}{2}+(\frac{1}{2}-\frac{1}{6})-(\frac{1}{6}-\frac{1}{10})+(\frac{1}{10}-\frac{1}{14})-(\frac{1}{14}-\frac{1}{18})+(\frac{1}{18}-\frac{1}{22})-(\frac{1}{22}-\frac{1}{26})+\dots$

सरलीकृत:

$\frac{\pi}{4}=\frac{1}{2}+\frac{1}{3}-\frac{1}{15}+\frac{1}{35}-\frac{1}{63}+\frac{1}{99}-\frac{1}{143}+\dots$

सामान्यीकृत:

$\frac{\pi}{4}=\frac{1}{2}+\sum\limits_{n=0}^\infty\frac{(-1)^n}{(2n+1)(2n+3)}$

ध्यान दें कि अग्रणी that के पास एक साथी शब्द नहीं था, और इस तरह उसे शेष राशि से बाहर रखा गया था। यह रूपांतरित श्रृंखला का पहला शब्द है। अगला शब्द खोजने के लिए, हम इस प्रक्रिया को फिर से दोहराते हैं:

$\frac{\pi}{4}=\frac{1}{2}+\frac{1}{6}+(\frac{1}{6}-\frac{1}{30})-(\frac{1}{30}-\frac{1}{70})+(\frac{1}{70}-\frac{1}{126})-(\frac{1}{126}-\frac{1}{198})+(\frac{1}{198}-\frac{1}{286})-\dots$ $\frac{\pi}{4}=\frac{1}{2}+\frac{1}{6}+\frac{2}{15}-\frac{2}{105}+\frac{2}{315}-\frac{2}{693}+\frac{2}{1287}-\dots$

और फिर:

$\frac{\pi}{4}=\frac{1}{2}+\frac{1}{6}+\frac{1}{15}+(\frac{1}{15}-\frac{1}{105})-(\frac{1}{105}-\frac{1}{315})+(\frac{1}{315}-\frac{1}{693})-(\frac{1}{693}-\frac{1}{1287})+\dots$ $\frac{\pi}{4}=\frac{1}{2}+\frac{1}{6}+\frac{1}{15}+\frac{2}{35}-\frac{2}{315}+\frac{2}{1155}-\frac{2}{3003}+\dots$

और फिर:

$\frac{\pi}{4}=\frac{1}{2}+\frac{1}{6}+\frac{1}{15}+\frac{1}{35}+(\frac{1}{35}-\frac{1}{315})-(\frac{1}{315}-\frac{1}{1155})+(\frac{1}{1155}-\frac{1}{3003})-\dots$ $\frac{\pi}{4}=\frac{1}{2}+\frac{1}{6}+\frac{1}{15}+\frac{1}{35}+\frac{8}{315}-\frac{8}{3465}+\frac{8}{15015}-\dots$

और एक बार अच्छे उपाय के लिए:

$\frac{\pi}{4}=\frac{1}{2}+\frac{1}{6}+\frac{1}{15}+\frac{1}{35}+\frac{4}{315}+(\frac{4}{315}-\frac{4}{3465})-(\frac{4}{3465}-\frac{4}{15015})+\dots$ $\frac{\pi}{4}=\frac{1}{2}+\frac{1}{6}+\frac{1}{15}+\frac{1}{35}+\frac{4}{315}+\frac{8}{693}-\frac{8}{9009}+\dots$

इस समय हमारे पास पहले पाँच पद हैं, और छठा पद स्पष्ट है। यह सामान्य करने के लिए पर्याप्त होना चाहिए, इसलिए हम यहां रुकेंगे। हम संख्यात्मक और भाजक को तथ्य द्वारा शुरू करेंगे:

$\frac{\pi}{4}=\frac{1}{2}+\frac{1}{2\cdot 3}+\frac{1}{3\cdot 5}+\frac{1}{5\cdot 7}+\frac{2^2}{3^2\cdot 5\cdot 7}+\frac{2^2}{3^2\cdot 7\cdot 11}+\dots$

हर जगह जाहिर तौर पर 2n + 1 का दोहरा गुण होता है , इसलिए हम इसमें पैच करेंगे:

$\frac{\pi}{4}=\frac{1}{2}+\frac1{2\cdot 3}+\frac1{3\cdot 5}+\frac{3}{3\cdot 5\cdot 7}+\frac{2^2\cdot 3}{3\cdot 5\cdot 7\cdot 9}+\frac{2^2\cdot 3\cdot 5}{3\cdot 5\cdot 7\cdot 9\cdot 11}+\dots$

सब कुछ फिट बैठता है, पहले दो शब्दों को छोड़कर जो हर में 2 के लिए बेहिसाब है। हम संपूर्ण अभिव्यक्ति को 2 से गुणा करके इसे ठीक कर सकते हैं :

$\frac{\pi}{2}=1+\frac{1}{3}+\frac{2}{3\cdot 5}+\frac{2\cdot 3}{3\cdot 5\cdot 7}+\frac{2^3\cdot 3}{3\cdot 5\cdot 7\cdot 9}+\frac{2^3\cdot 3\cdot 5}{3\cdot 5\cdot 7\cdot 9\cdot 11}+\dots$

2 ³ = 2 · 4 , इसलिए:

$\frac{\pi}{2}=1+\frac{1}{3}+\frac{2}{3\cdot 5}+\frac{2\cdot 3}{3\cdot 5\cdot 7}+\frac{2\cdot 3\cdot 4}{3\cdot 5\cdot 7\cdot 9}+\frac{2\cdot 3\cdot 4\cdot 5}{3\cdot 5\cdot 7\cdot 9\cdot 11}+\dots$

अंश को अब आसानी से n के रूप में पहचाना जा सकता है ! ।

ध्यान दें कि कारक प्रत्येक क्रमिक शब्द, n / (2n + 1) में जोड़ा गया है , दृष्टिकोण, n के रूप में बड़ा हो जाता है, एक बिट प्रति शब्द की दर से एक रैखिक अभिसरण का अर्थ है - यह वास्तव में डिजाइन द्वारा है। एक अच्छा परिणाम है, लेकिन यह भी वहाँ में factorials के बिना अच्छा होगा। हम यहां क्या कर सकते हैं, प्रत्येक योग शब्द को शेष राशि से अलग किया जाएगा, जो एक नेस्टेड अभिव्यक्ति उत्पन्न करेगा:

$\frac{\pi}{2}=1+\frac{1}{3}(1+\frac{2}{5}+\frac{2\cdot 3}{5\cdot 7}+\frac{2\cdot 3\cdot 4}{5\cdot 7\cdot 9}+\frac{2\cdot 3\cdot 4\cdot 5}{5\cdot 7\cdot 9\cdot 11}+\dots$
$\frac{\pi}{2}=1+\frac{1}{3}(1+\frac{2}{5}(1+\frac{3}{7}+\frac{3\cdot 4}{7\cdot 9}+\frac{3\cdot 4\cdot 5}{7\cdot 9\cdot 11}+\dots$
$\frac{\pi}{2}=1+\frac{1}{3}(1+\frac{2}{5}(1+\frac{3}{7}(1+\frac{4}{9}+\frac{4\cdot 5}{9\cdot 11}+\dots$ $\frac{\pi}{2}=1+\frac{1}{3}(1+\frac{2}{5}(1+\frac{3}{7}(1+\frac{4}{9}(1+\frac{5}{11}(1+\dots+\frac{n}{2n+1}(1+\dots$

इसे पुनरावृत्ति संबंध के रूप में फिर से लिखा जा सकता है:

$x_{n}=1+\frac{n}{2n+1}x_{n+1}$

जहाँ n, ₂ log ₂ (10) · d 0 .. 0 से पीछे की ओर गिना जाता है , जहाँ d को अंकों की संख्या की आवश्यकता होती है।

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

— Primo
स्रोत

1

बहुत अच्छा, पाठ के लिए धन्यवाद! क्या मैं नहीं मिलता है क्या है pमें p/2 * x/p + ...क्या कर रहा है .. AIUI अजगर एक biginteger-ish डेटाप्रकार के लिए स्वत: पदोन्नति का समर्थन करता है, तो यह एक सटीक बात नहीं होना चाहिए, लेकिन किसी भी तरह उन pबात है और बाहर रद्द नहीं करते की तरह मुझे लगता है उन्हें ... मुझे यहाँ क्या याद आ रहा है?

— फायरफली

@ पूरी तरह से pप्रारंभिक विषम, ताकि p/2/pसमतुल्य है - पूर्णांक विभाजन के तहत - से ((p-1)/2)/p। यह पैदा करता है 1/3, 2/5, 3/7, आदि शर्तों ऊपर ली गई।

— प्रिमो

12

~~# सी - 777 वर्ण~~

सी - 731 वर्ण

GIF को प्रिंट करता है stdout।

Quirk: पहले के बाद कोई अल्पविराम नहीं 3।

पूर्व-कॉन्फ़िगर हेडर से जीआईएफ को एक साथ सिलाई करना + 5x5 पिक्सेल के होम पीवड (एम्बेडेड) फ़ॉन्ट द्वारा दर्शाए गए प्रत्येक अंक।

परिणाम

यहाँ छवि विवरण दर्ज करें

यह वहाँ है --- ^

ध्यान दें कि GIF गायब हो जाता है, कभी-कभी, क्रोम में एक रन के बाद।

#include <stdio.h>
#define G 68,30
#define F(e,i)for(i=0;i<e;++i)
#define B w[++k]
unsigned char r[][10]={{4,18,150,199,188,159,10,0},{4,18,102,169,188,122,64,1},{G,160,166,104,217,80,1},{G,160,166,184,140,66,1},{68,96,153,193,135,138,66,1},{G,6,107,199,155,80,40},{68,128,150,22,173,218,90,1},{G,160,182,169,254,84,1},{G,6,138,153,140,10,0},{G,6,138,185,250,66,1},{0,0,0,5,0,5,0,0,2,8}},w[440]={71,73,70,56,57,97,100,0,5,0,144,0,0,255,255,255,0,0,0};int main(){int a=10000,b=0,c=70,d,e=0,f[71],g;int i,j,k=18,s=0;char m[5];for(;b<c;)f[b++]=a/5;for(;d=0,g=c*2;c-=14,e=d%a){for(b=c;d+=f[b]*a,f[b]=d%--g,d/=g--,--b;d*=b);sprintf(m,"%d",e+d/a);F(4,i){B=44;B=s++*5;F(10,j)B=r[10][j];F(8,j)B=r[m[i]-'0'][j];B=0;}}B=59;fwrite(w,1,k,stdout);}

संक्षिप्त परिचय:

पीआई की गणना

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

int a=10000,b,c=2800,d,e,f[2801],g;main(){for(;b-c;)f[b++]=a/5;for(;d=0,g=c*2;c
-=14,printf("%.4d",e+d/a),e=d%a)for(b=c;d+=f[b]*a,f[b]=d%--g,d/=g--,--b;d*=b);}

GIF पीढ़ी

GIF इमेज canvasमें हेडर में एक गुण होता है। हम leftप्रत्येक अंक के लिए संपत्ति निर्धारित करके एकाधिक छवियों को प्रदर्शित करने के साथ संयोजन में इसका उपयोग कर सकते हैं - जहां प्रत्येक अंक अपने आप में एक (एम्बेडेड) छवि है।

प्रलेखन।

उदाहरण:

Header: Canvas Width  100 pixels
        Canvas Height   5 pixels

3 : left  0 pixels
1 : left  5 pixels
4 : left 10 pixels
… and so on.

विस्तारित कोड (टिप्पणियों के भार के साथ)

गन्दा, लेकिन यह न्यूनतमकरण का हिस्सा है :

#include <stdio.h>
#define G 68,30
#define F(e,i)for(i=0;i<e;++i)
#define B w[++k]

/* Font + Image Descriptor + Start of Image Data. 
 *
 * Font glyphs are black and white pixels making a 5x5 picture.
 * Each glyph has its own entry in array.
 * Pixels (White,White,Black,Black ...) are further compressed using LZW
 * compression.
 *
 * Next entry in array is Image Descriptor which is added before each glyph.
 * Last entry is start of Image Data.
 *
 * - "0" and comma are 7 and 5 bytes, but hacked to fill 8 bytes to make it 
 * easier to handle in minified code.
 * */
unsigned char r[][10]={
        /* Images representing glyphs. */
        { 4,   18, 150, 199, 188, 159, 10,  0}, /* 0 */
        { 4,   18, 102, 169, 188, 122, 64,  1}, /* 1 */
        { 68,  30, 160, 166, 104, 217, 80,  1}, /* 2 */
        { 68,  30, 160, 166, 184, 140, 66,  1}, /* 3 */
        { 68,  96, 153, 193, 135, 138, 66,  1}, /* 4 */
        { 68,  30,   6, 107, 199, 155, 80, 40}, /* 5 */
        { 68, 128, 150,  22, 173, 218, 90,  1}, /* 6 */
        { 68,  30, 160, 182, 169, 254, 84,  1}, /* 7 */
        { 68,  30,   6, 138, 153, 140, 10,  0}, /* 8 */
        { 68,  30,   6, 138, 185, 250, 66,  1}, /* 9 */
        {132, 143, 121, 177,  92,   0,  0,  0}, /* , (removed as not used) */
        {
        /* Image Descriptor */
        /* 0x2C    Image separator (Embedded in code)   */
           0,   /* Image Left   (LSB embedded in code.  */
        0, 0,   /* Image top    (16-bit Little endian)  */
        5, 0,   /* Image Width  (16-bit Little endian)  */
        5, 0,   /* Image Height (16-bit Little endian)  */
        0,      /* Packed byte  (Local color table (not used, etc.)) */
        /* Start of Image Data */
        2,      /* Starting size of LZW 2 + 1 = 3 */
        8       /* Number of bytes in data */
        }
};
/* GIF Header + Global Color table. 
 *
 * GIF's has a standard header.
 * Canvas size is the are on which to paint.
 * Usually this is size of whole image, but in this code I've spanned it out
 * and paint glyphs by rendering pictures on a canvas of size:
 * 20 * width_of_1_image (5 * 20 = 100)
 *
 * Each image can have an optional color table, but if not present the global
 * color table is used. In this code only global color table is used. It
 * consist of only black and white. (Though very easy to change if wanted.)
 * */
unsigned char buf[440] = {
        71, 73, 70,     /* Signature     "GIF" */
        56, 57, 97,     /* Version       "89a" */
        100, 0,         /* Canvas width  (16-bit Little endian) 5 * 20 = 100*/
          5, 0,         /* Canvas height (16-bit Little endian) 5 pixels.   */
        144,            /* Packed byte: 1 001 0 000
                                  1 : Has global color table.
                                001 : Color resolution.
                                  0 : Sorted Color Table (No)
                                000 : Size of Global Color table (2^(value+1))
                                        or 2 << value ...
                        */
        0,              /* Background Color index. */
        0,              /* Pixel aspect ratio. */
        /* Global color table. */
        255, 255, 255,  /* Index 0: White */
          0,   0,   0   /* Index 1: Black */
};

int main(void){
        /* PI generation variables. */
        int a = 10000, 
            b = 0,
            c = 70,
            d,
            e = 0,
            f[71],
            g;
        /* General purpose variables */
        int i,
            j,
            k = 18,     /* Current Index in out buffer. */
            s = 0;      /* Image counter:
                           (Tells us what "left/x" value should be). */
        char m[5];      /* Print next 4 digits of PI to this buffer. */
        /* Prepare / pre-fill for PI math. */
        for(;b < c;)
                f[b++] = a/5;
        /* Calculate 4 and 4 digits of PI and push onto out buffer. */
        for(; d = 0, g = c * 2; c -= 14 , e = d % a) { 
                for (b = c; d += f[b] * a, f[b] = d % --g, d /= g--, --b; d *= b);
                /* sprintf next 4 digits to temprary buffer.     */
                sprintf(m, "%d", e + d/a);
                /* We are served 4 and 4 digits. 
                 * Here we transalte them to glyphs and push onto out buffer*/
                for (i = 0; i < 4; ++i) {  
                        buf[++k] = 0x2C;     /* 0x2C : Image separator.        */
                        buf[++k] = s++ * 5;  /* xx   : Image left (x) on canvas.*/
                        for (j = 0; j < 10; ++j) {
                                /* Push "Start of Image Data" onto buffer      */
                                buf[++k] = r[11][j];
                        }
                        for (j = 0; j < 8; ++j) {
                                /* Push data of glyph (LZW-compressed) onto buffer. */
                                buf[++k] = r[m[i]-'0'][j];
                        }
                        /* Start of image data informs how big the image data 
                         * is. End with zero to mark that this is EOI. */
                        buf[++k] = 0;       
                }
        }
        /* 0x3b is Trailer, marking end of file. */
        buf[k] = 0x3b;
        /* Write buffer to standard output. 
         * 'k' holds length of data, though as we know this image is 
         * 100x5 etc. we can pre-define it as well.
         * */
        fwrite(buf, 1, k, stdout);
}

Ating की गणना के लिए एक छोटे / अन्य एल्गोरिथ्म का उपयोग करने की तलाश में।

— Runium
स्रोत

2

मैं छवि में पहले 3 के बाद डॉट नहीं देखता।

— विक्टर स्टैफुसा

1

क्या आपके पास pi डेसीमल जनरेशन एल्गोरिदम के बारे में जानकारी के लिए लिंक है? मैं आपके कोड के साथ थोड़ा खेलता हूं (GIF स्टफ को अलग करने के बाद), लेकिन मैं वास्तव में यह नहीं देखता कि यह पाई के अंकों में क्यों आता है ...

— FireFly

7

जावास्क्रिप्ट, 680 वर्ण

<html><body></body><script>v=["","41L70L7e","24C223060Ca0b587C592b2eLae","30L90L55L65C95a7a9Cac9e6eC5e3e2c","aaL2aL80L8e","90L40L36C455565C95a7a9Cac9e6eC5e3e2c","70C52272aC2c3e6eC9eacaaCa89666C36282a","20La0C745a5e","60C202435C465666C96a8aaCac9e6eC3e2c2aC283666C768695Ca4a060","a4Ca69868C382624C223060C90a2a4Ca77c5e","6dC7d7e6eC5e5d6d"];v["."]=v[10];a=(""+(4*Math.atan(1))).split("");s="";for(i in a)s+="<path d='M "+v[a[i]].split("").map(function(c){return+-c||c>"Z"?parseInt(c,16):c;}).join(" ")+"'transform='translate("+i*33+".5,10.5)scale(3,3)'fill='none'stroke='#333'stroke-linecap='round'stroke-linejoin='round'/>";document.body.innerHTML="<svg>"+s+"</svg>";</script></html>

इसे एक वेब ब्राउज़र में देखा जा सकता है; संख्या SVG पथ के रूप में आउटपुट हैं।

एक वेब ब्राउज़र में एसवीजी आउटपुट का स्क्रीनशॉट

यह एक दिलचस्प तरीके से पाई की गणना नहीं करता है, और जेएस में 20 अंकों को प्रदर्शित करने के लिए सटीक संख्या के साथ कमी है।
वर्णों को सहेजने के लिए, मैंने "0" के लिए पथ डेटा को छोड़ दिया, क्योंकि यह अनुक्रम में दिखाई नहीं देता है।

— JustinMimbs
स्रोत

ऊह, एक वेक्टर-आधारित दृष्टिकोण। फ़ॉन्ट पर भी बहुत अच्छा, अच्छा काम।

— फायरफली

5

जावा - , ६६ --६० 60५ 85 char५३ चार्ट, प्लस ४ char४ चार्ट के साथ एक धोखा संस्करण

1996 से साइमन प्लॉफ़ सूत्र का उपयोग करते हुए, x.pngएक काले बैकग्राउंड में सफेद डिजिटल-घड़ी जैसी संख्याओं के साथ एक फ़ाइल को आउटपुट करता है :

अनुकरणीय

यह संपीड़ित कोड है:

import java.math.BigDecimal;class E{static java.awt.Graphics g;public static void main(String[]h)throws Exception{java.awt.image.BufferedImage i=new java.awt.image.BufferedImage(213,17,1);g=i.getGraphics();BigDecimal y=v(-3);for(int n=1;n<99;n++)y=y.add(v(n).multiply(v(2).pow(n)).multiply(f(n).pow(2)).divide(f(2*n),42,0));int j=2;for(char c:y.toPlainString().substring(0,21).toCharArray()){if(j!=12){c-=48;boolean b=c!=1&c!=4;t(b,j,2,8,3);t(c<1|c>3&c!=7,j,2,3,8);t(c<5|c>6,j+5,2,3,8);t(c>1&c!=7,j,7,8,3);t(c%2==0&b,j,7,3,8);t(c!=2,j+5,7,3,8);t(b&c!=7,j,12,8,3);}j+=10;}t(true,17,12,3,3);javax.imageio.ImageIO.write(i,"png",new java.io.File("x.png"));}static BigDecimal v(int k){return BigDecimal.valueOf(k);}static BigDecimal f(int k){return k<2?v(1):f(k-1).multiply(v(k));}static void t(boolean x,int a,int b,int c,int d){if(x)g.fillRect(a,b,c,d);}}

यह पहचान और कुछ व्हाट्सएप के साथ यह होगा:

import java.math.BigDecimal;

class E {

    static java.awt.Graphics g;

    public static void main(String[] h) throws Exception {
        java.awt.image.BufferedImage i = new java.awt.image.BufferedImage(213, 17, 1);
        g = i.getGraphics();
        BigDecimal y = v(-3);

        // Calculate PI using the Simon Plouffe formula, 1996.
        for (int n = 1; n < 99; n++)
            y = y.add(v(n).multiply(v(2).pow(n)).multiply(f(n).pow(2)).divide(f(2 * n), 42, 0));

        int j = 2;
        for (char c : y.toPlainString().substring(0, 21).toCharArray()) {
            if (j != 12) {
                c -= 48;
                boolean b = c != 1 & c != 4;
                t(b, j, 2, 8, 3);
                t(c < 1 | c > 3 & c != 7, j, 2, 3, 8);
                t(c < 5 | c > 6, j + 5, 2, 3, 8);
                t(c > 1 & c != 7, j, 7, 8, 3);
                t(c % 2 == 0 & b, j, 7, 3, 8);
                t(c != 2, j + 5, 7, 3, 8);
                t(b & c != 7, j, 12, 8, 3);
            }
            j += 10;
        }
        t(true, 17, 12, 3, 3);
        javax.imageio.ImageIO.write(i, "png", new java.io.File("x.png"));
    }

    static BigDecimal v(int k) {
        return BigDecimal.valueOf(k);
    }

    static BigDecimal f(int k) {
        return k < 2 ? v(1) : f(k - 1).multiply(v(k));
    }

    static void t(boolean x, int a, int b, int c, int d) {
        if (x) g.fillRect(a, b, c, d);
    }
}

नियमों को धोखा देना और यह देखते हुए कि पीआई की गणना "स्ट्रिंग 3.1415926535897934384 का संख्यात्मक प्रतिनिधित्व" के रूप में की जा सकती है, इसे 574 चार्ट तक घटाया जा सकता है:

class F{static java.awt.Graphics g;public static void main(String[]h)throws Exception{java.awt.image.BufferedImage i=new java.awt.image.BufferedImage(213,17,1);g=i.getGraphics();int j=2;for(char c:"3.1415926535897932384".toCharArray()){if(j!=12){c-=48;boolean b=c!=1&c!=4;t(b,j,2,8,3);t(c<1|c>3&c!=7,j,2,3,8);t(c<5|c>6,j+5,2,3,8);t(c>1&c!=7,j,7,8,3);t(c%2==0&b,j,7,3,8);t(c!=2,j+5,7,3,8);t(b&c!=7,j,12,8,3);}j+=10;}t(true,17,12,3,3);javax.imageio.ImageIO.write(i,"png",new java.io.File("x.png"));}static void t(boolean x,int a,int b,int c,int d){if(x)g.fillRect(a,b,c,d);}}

— विक्टर स्टैफ़ुसा
स्रोत

4

जावा - 642 622 अक्षर

1996 से साइमन प्लॉफ़ सूत्र का उपयोग करते हुए मेरे पिछले उत्तर से नकल करना। लेकिन इसके बजाय ASCII- कला को आउटपुट देता है:

import java.math.BigDecimal;class H{public static void main(String[]h)throws Exception{int[]t={31599,4681,31183,29647,5101,29671,31719,4687,31727,29679,8192};BigDecimal y=v(-3);for(int n=1;n<99;n++)y=y.add(v(n).multiply(v(2).pow(n)).multiply(f(n).pow(2)).divide(f(2*n),42,0));for(int z=0;z<5;z++){for(char c:y.toPlainString().substring(0,21).toCharArray()){if(c<48)c=58;int a=(t[c-48]>>>z*3)&7;e(a/4);e(a/2&1);e(a&1);e(0);e(0);}e(10);}}static void e(int c){System.out.print((char)(c<2?c*3+32:c));}static BigDecimal v(int k){return BigDecimal.valueOf(k);}static BigDecimal f(int k){return k<2?v(1):f(k-1).multiply(v(k));}}

कुछ की पहचान और रिक्त स्थान के साथ, और पाठक को जादू की संख्याओं को समझने में थोड़ी मदद:

import java.math.BigDecimal;

class H {

    public static void main(String[] h) throws Exception {
        // Each block corresponds to a line. Each char has 5 lines with a 3-char width.
        int[] t = {
            0b111_101_101_101_111,
            0b001_001_001_001_001,
            0b111_100_111_001_111,
            0b111_001_111_001_111,
            0b001_001_111_101_101,
            0b111_001_111_100_111,
            0b111_101_111_100_111,
            0b001_001_001_001_111,
            0b111_101_111_101_111,
            0b111_001_111_101_111,
            0b010_000_000_000_000
        };

        // Calculate PI using the Simon Plouffe formula, 1996.
        BigDecimal y = v(-3);
        for (int n = 1; n < 99; n++)
            y = y.add(v(n).multiply(v(2).pow(n)).multiply(f(n).pow(2)).divide(f(2 * n), 42, 0));

        for (int z = 0; z < 5; z++) {
            for (char c : y.toPlainString().substring(0, 21).toCharArray()) {
                if (c < 48) c = 58;
                int a = (t[c - 48] >>> z * 3) & 7;
                e(a / 4);
                e(a / 2 & 2);
                e(a & 1);
                e(0);
                e(0); // Not needed, but makes a better art with the cost of 5 chars.
            }
            e(10);
        }
    }

    static void e(int c) {
        System.out.print((char) (c < 2 ? c * 3 + 32 : c));
    }

    static BigDecimal v(int k) {
        return BigDecimal.valueOf(k);
    }

    static BigDecimal f(int k) {
        return k < 2 ? v(1) : f(k - 1).multiply(v(k));
    }
}

आउटपुट:

###         #  # #    #  ###  ###  ###  ###  ###  ###  ###  ###  ###  ###  ###  ###  ###  ###  ###  # #  
  #         #  # #    #  #    # #    #  #    #      #  #    # #  # #    #  # #    #    #    #  # #  # #  
###         #  ###    #  ###  ###  ###  ###  ###  ###  ###  ###  ###    #  ###  ###  ###  ###  ###  ###  
  #         #    #    #    #    #  #    # #    #    #    #  # #    #    #    #    #  #      #  # #    #  
###   #     #    #    #  ###  ###  ###  ###  ###  ###  ###  ###  ###    #  ###  ###  ###  ###  ###    #

— विक्टर स्टैफ़ुसा
स्रोत

4

सी, 253 250 वर्ण

@ Sukminder के कोड में एल्गोरिथ्म का उपयोग करके पाई को शर्मिंदा करता है (बेशर्मी से उधार लेना और अपने कोड को फिर से भरना)। एक द्विआधारी PBM छवि को आउटपुट करता है , जो तब ImageMagick के साथ परिवर्तित किया जा सकता है।

b,c=70,e,f[71],g;v[71],j,k;L[5]={1072684944,792425072,492082832,256581624};
main(d){for(puts("P4\n8 100");b<c;)f[b++]=2;for(;d=0,g=--c*2;e=d%10){
for(b=c;d+=f[b]*10,f[b]=d%--g,d/=g--,--b;d*=b);v[j++]=e+d/10;}
for(;k<100;k++)putchar(L[k%5]>>3*v[k/5]&7);}

यहाँ मेरा ब्रेल-आधारित PPM रेंडरर के साथ उत्पादन कैसा दिखता है:

आउटपुट का स्क्रीनशॉट

@ क्विकाइंडर के उत्तर में वही क्वर्क है कि इसमें दशमलव विभाजक का अभाव है। इसके अलावा, मेरा उत्पादन ऊर्ध्वाधर है, और क्या यह मानव-पठनीय तर्कपूर्ण है ...

संपादित करें: @ ugoren के सुझावों को लागू किया गया।

— जुगनू
स्रोत

टिनी सुधार: चाल putsमें for प्रारंभ, परिभाषित L[5]और न आना ,0। dएक पैरामीटर बनाएं main(एक अल्पविराम सहेजें)।

— 13

4

PHP 380

छवि आउटपुट के लिए gd सक्षम होना चाहिए

<? header('Content-Type: image/png');$i=imagecreatetruecolor(84,5);$n=['71775777770','51115441550','51777771770','51411151510','71771771712'];$c=imagecolorallocate($i,255,255,255);$m=(6.28318/2).(5307*5).(28060387*32);$k=5;while($k--)for($j=0;$j<21;$j++){$p=str_pad(decbin($n[$k][($m[$j]!='.')?$m[$j]:10]),3,'0',0);$l=3;while($l--)$p[$l]&&imagesetpixel($i,$l+$j*4,$k,$c);}imagepng($i);

यहाँ छवि विवरण दर्ज करें

पीआई गणना: चूंकि बेस php में 14 की डिफ़ॉल्ट परिशुद्धता होती है और मैं सर्वर को पुनर्संयोजित नहीं करना चाहता था, ताकि मनमाने ढंग से सटीक एक्सटेंशन सक्षम किए जा सकें, मैं आवश्यक दशमलव के साथ पीआई को भी जोड़ नहीं सकता, इसलिए इसके बजाय यह ताऊ / 2 और फिर गणना करता है। बाकी दशमलव

चूँकि ग्राफिक 0 और 1 के बना होता है, इसलिए मैं WBMP का उपयोग करने की कोशिश कर सकता हूं क्योंकि बाद में यह देखने के लिए कि क्या मैं gd निकाल सकता हूँ

— Einacio
स्रोत

वह छवि काले रंग में लाल है, और वास्तव में छोटी है, लेकिन 500% पर आप इसे पढ़ सकते हैं यदि आप करीब दिखते हैं। (और colorblind नहीं कर रहे हैं।)

— hildred

@ निस्संदेह प्रत्येक चरित्र है 3x5 with 1 px between chars। रंग केवल 4 वर्णों को कम करने के लिए लाल है, लेकिन यह देखते हुए कि मैं नहीं

— जीतूंगा

मेरी टिप्पणी का उद्देश्य आलोचना के रूप में नहीं, बल्कि वोटों को प्रोत्साहित करने के लिए एक स्पष्टीकरण के रूप में था।

— हल्दी

क्या imagecreateindex किसी वर्ण को बचाएगा? क्या इस तरह के समारोह मौजूद है?

— हल्दी

@ हल्के जब एक पैलेट छवि ( imagecreate) के साथ काम करते हैं , imagecolorallocateतो पृष्ठभूमि रंग सेट करने का पहला आह्वान , और लेखन रंग सेट करने के लिए एक दूसरे की आवश्यकता होती है। इसलिए यह अधिक समय तक समाप्त होता है

— ईनाकोओ

4

C + LaserWriter प्रिंटर 599 - 10 = 589

अपने LaserWriter के लिए आउटपुट पाइप! :) यह एक लिसा (एक सी संकलक के साथ) पर काम करना चाहिए।

यह piप्रिंटर की गणना लाइन-सेगमेंट की लंबाई के योग की गणना करके करता है जो एक बेज़ियर वक्र अनुक्रम का अनुमान लगाता है जो व्यास द्वारा विभाजित एक आधा-चक्र, 2 बार होता है।

main(){
printf("/dist{dtransform dup mul exch dup mul add sqrt}def");
printf("/len{3 2 roll sub 3 1 roll exch sub dist}def");
printf("/pi{0 0 2 index 0 180 arc closepath flattenpath");
printf("[{2 copy}{2 copy 6 2 roll len 3 1 roll}{}{counttomark -2 roll len\n");
printf("counttomark 2 add 1 roll counttomark 1 sub{add}repeat\n");
printf("exch pop exch pop exch div 2 mul}pathforall}def\n");
printf("matrix setmatrix 100 dup scale 10 setflat 100 pi 10 string cvs\n");
printf("matrix defaultmatrix setmatrix/Palatino-Roman findfont 10 scalefont setfont\n");
printf("100 700 moveto show showpage");
}

अनगुल्ड लेवल -1 (1985-संगत) पोस्टस्क्रिप्ट:

%!
/dist { % dx dy  .  dz  
    dtransform
    dup mul exch dup mul add sqrt
} def 

/len { % x1 y1 x2 y2  .  dist(y2-y1,x2-x1)
    3 2 roll % x1 x2 y2 y1
    sub 3 1 roll exch sub % y2-y1 x2-x1
    dist
} def 

/pi { % rad 
    0 0 2 index 0 180 arc closepath % rad 
    flattenpath
    [   
    { % rad [ x(0) y(0)     (m)print
        2 copy 
    } %moveto proc
    { % rad [ ... x(n-1) y(n-1) x(n) y(n)     (l)print
        2 copy 6 2 roll len % rad [ ... x(n) y(n) dist
        3 1 roll % rad [ ... dist x(n) y(n)
    } %lineto proc
    {} %curveto proc % n.b. flattenpath leaves no curve segments
    { % rad [ x(0) y(0) dist(1) dist(2) ... dist(n-1) x(n) y(n)     (c)print
        counttomark -2 roll len % rad [ dist(1) dist(2) ... dist(n)
        counttomark 2 add 1 roll % dist(n) rad [ dist...
        counttomark 1 sub { add } repeat % dist(n) rad [ sum_dist
        exch pop % dist(n) rad sum_dist
        exch pop % dist(n) sum_dist
        exch % sum_dist dist(n)
        div  % length_of_half_circle/diameter
        2 mul % C/d 
    } %closepath proc
    pathforall
} def 

matrix setmatrix
100 dup scale
10 setflat
100 pi 10 string cvs 
matrix defaultmatrix setmatrix
/Palatino-Roman findfont 10 scalefont setfont
100 700 moveto show

आउटपुट:

ps_pi

— luser droog
स्रोत

मुझे लगता है कि मुझे एक फॉन्ट बनाने की जरूरत है।

— लूज़र ने

हम्म। इस तरह से कभी भी पर्याप्त अंक नहीं मिलेंगे। PS में केवल 32-बिट फ़्लोट्स हैं।

— लूसर ड्रोग

शांत विचार, मुझे गोल्फ के लिए पोस्टस्क्रिप्ट पसंद है।

— hildred

मेरे पास अंकों के लिए एक बिटमैप फ़ॉन्ट है लेकिन गोल्फिंग इसे बर्बाद कर देगा!

— लूसर

2

जावा, 1574 2643 1934 अक्षर

संप्रति 1934 अक्षर:

    public static void main(String[] args){int[][][]num={{{1,1,1},{1,0,1},{1,0,1},{1,0,1},{1,1,1}},{{0,0,1},{0,0,1},{0,0,1},{0,0,1},{0,0,1}},{{1,1,1},{0,0,1},{1,1,1},{1,0,0},{1,1,1}},{{1,1,1},{0,0,1},{1,1,1},{0,0,1},{1,1,1}},{{1,0,1},{1,0,1},{1,1,1},{0,0,1},{0,0,1}},{{1,1,1},{1,0,0},{1,1,1},{0,0,1},{1,1,1}},{{1,1,1},{1,0,0},{1,1,1},{1,0,1},{1,1,1}},{{1,1,1},{0,0,1},{0,0,1},{0,0,1},{0,0,1}},{{1,1,1},{1,0,1},{1,1,1},{1,0,1},{1,1,1}},{{1,1,1},{1,0,1},{1,1,1},{0,0,1},{0,0,1}},{{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,1}}};BufferedImage image=new BufferedImage(103,5,BufferedImage.TYPE_3BYTE_BGR);for(int q=0;q<103;q++){for(int w=0;w<5;w++){image.setRGB(q,w,0xFFFFFF);}}int loc = 0;String g=String.valueOf(pi(20));for(int w=0;w<g.length()-1;w++){Integer n=0;if(g.charAt(w)=='.'){n=10;}else{n=Integer.parseInt(String.valueOf(g.charAt(w)));}for(int t=0;t<5;t++){for(int q=0;q<3;q++){int c=num[n][t][q]==1?0x000000:0xFFFFFF;image.setRGB(loc+q,t,c);}}loc+=5;}try{BufferedImage bi=image;File f=new File("o.png");ImageIO.write(bi,"png",f);}catch(IOException e){}}public static BigDecimal pi(final int SCALE){BigDecimal a=BigDecimal.ONE;BigDecimal b=BigDecimal.ONE.divide(sqrt(new BigDecimal(2),SCALE),SCALE,BigDecimal.ROUND_HALF_UP);BigDecimal t=new BigDecimal(0.25);BigDecimal x=BigDecimal.ONE;BigDecimal y;while(!a.equals(b)){y=a;a=a.add(b).divide(new BigDecimal(2),SCALE,BigDecimal.ROUND_HALF_UP);b=sqrt(b.multiply(y),SCALE);t=t.subtract(x.multiply(y.subtract(a).multiply(y.subtract(a))));x=x.multiply(new BigDecimal(2));}return a.add(b).multiply(a.add(b)).divide(t.multiply(new BigDecimal(4)),SCALE,BigDecimal.ROUND_HALF_UP);}public static BigDecimal sqrt(BigDecimal A,final int SCALE){BigDecimal x0=new BigDecimal("0");BigDecimal x1=new BigDecimal(Math.sqrt(A.doubleValue()));while(!x0.equals(x1)){x0=x1;x1=A.divide(x0,SCALE,BigDecimal.ROUND_HALF_UP);x1=x1.add(x0);x1=x1.divide(new BigDecimal(2),SCALE,BigDecimal.ROUND_HALF_UP);}return x1;}}

विस्तारित 2643 वर्ण:

public static void main(String[] args) {
    int[][][] num = { { { 1, 1, 1 }, { 1, 0, 1 }, { 1, 0, 1 }, { 1, 0, 1 }, { 1, 1, 1 } },
            { { 0, 0, 1 }, { 0, 0, 1 }, { 0, 0, 1 }, { 0, 0, 1 }, { 0, 0, 1 } },
            { { 1, 1, 1 }, { 0, 0, 1 }, { 1, 1, 1 }, { 1, 0, 0 }, { 1, 1, 1 } },
            { { 1, 1, 1 }, { 0, 0, 1 }, { 1, 1, 1 }, { 0, 0, 1 }, { 1, 1, 1 } },
            { { 1, 0, 1 }, { 1, 0, 1 }, { 1, 1, 1 }, { 0, 0, 1 }, { 0, 0, 1 } },
            { { 1, 1, 1 }, { 1, 0, 0 }, { 1, 1, 1 }, { 0, 0, 1 }, { 1, 1, 1 } },
            { { 1, 1, 1 }, { 1, 0, 0 }, { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 } },
            { { 1, 1, 1 }, { 0, 0, 1 }, { 0, 0, 1 }, { 0, 0, 1 }, { 0, 0, 1 } },
            { { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 } },
            { { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 }, { 0, 0, 1 }, { 0, 0, 1 } },
            { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 1 } } };

    BufferedImage image = new BufferedImage(103, 5, BufferedImage.TYPE_3BYTE_BGR);

    for (int q = 0; q < 103; q++) {
        for (int w = 0; w < 5; w++) {
            image.setRGB(q, w, 0xFFFFFF);
        }
    }

    int loc = 0;

    String g = String.valueOf(pi(20));
    for (int w = 0; w < g.length()-1; w++) {
        Integer n = 0;
        if (g.charAt(w) == '.') {
            n = 10;
        } else {
            n = Integer.parseInt(String.valueOf(g.charAt(w)));
        }
        for (int t = 0; t < 5; t++) {
            for (int q = 0; q < 3; q++) {
                int c = num[n][t][q] == 1 ? 0x000000 : 0xFFFFFF;
                image.setRGB(loc + q, t, c);
            }
        }
        loc += 5;
    }
    try {
        BufferedImage bi = image;
        File outputfile = new File("out2.png");
        ImageIO.write(bi, "png", outputfile);
    } catch (IOException e) {

    }
}

public static BigDecimal pi(final int SCALE) {
    BigDecimal a = BigDecimal.ONE;
    BigDecimal b = BigDecimal.ONE.divide(sqrt(new BigDecimal(2), SCALE), SCALE, BigDecimal.ROUND_HALF_UP);
    BigDecimal t = new BigDecimal(0.25);
    BigDecimal x = BigDecimal.ONE;
    BigDecimal y;

    while (!a.equals(b)) {
        y = a;
        a = a.add(b).divide(new BigDecimal(2), SCALE, BigDecimal.ROUND_HALF_UP);
        b = sqrt(b.multiply(y), SCALE);
        t = t.subtract(x.multiply(y.subtract(a).multiply(y.subtract(a))));
        x = x.multiply(new BigDecimal(2));
    }
    return a.add(b).multiply(a.add(b)).divide(t.multiply(new BigDecimal(4)), SCALE, BigDecimal.ROUND_HALF_UP);

}

public static BigDecimal sqrt(BigDecimal A, final int SCALE) {
    BigDecimal x0 = new BigDecimal("0");
    BigDecimal x1 = new BigDecimal(Math.sqrt(A.doubleValue()));
    while (!x0.equals(x1)) {
        x0 = x1;
        x1 = A.divide(x0, SCALE, BigDecimal.ROUND_HALF_UP);
        x1 = x1.add(x0);
        x1 = x1.divide(new BigDecimal(2), SCALE, BigDecimal.ROUND_HALF_UP);
    }
    return x1;
}

पाई विधि इससे एकत्रित हुई: /programming/8343977/calculate-pi-on-an-android-phone?rq=1

— क्लेटन
स्रोत

ऐसा लगता है कि आपने पीआई की गणना करने के बजाय एक निरंतर उपयोग किया।

— हल्दी

यह एक अच्छा मोड़ है। अभी इस पर काम चल रहा है।

— क्लेटन

आप को जोड़कर एक थोड़ा और अधिक यह सेक कर सकते हैं throws Exceptionमें mainऔर कोशिश पकड़ ब्लॉक को हटाने के। इसके अलावा, आप नाम बदलना कर सकते हैं piऔर sqrtतरीकों और loc, args, SCALE, x0और x11 वर्ण पहचानकर्ता के लिए चर। और वैसे आपको पूरी कक्षा को जोड़ना होगा, इसमें class Foo{घोषणा और आयात शामिल हैं।

— विक्टर स्टैफ़ुसा

बेवकूफ प्रतिबंध और रेगिस्तान

पायथन, 222 वर्ण

पायथन, 217 बाइट्स

पाई गणना

प्रदर्शन

परिशिष्ट A

सी - 731 वर्ण

संक्षिप्त परिचय:

पीआई की गणना

GIF पीढ़ी

उदाहरण:

विस्तारित कोड (टिप्पणियों के भार के साथ)

जावास्क्रिप्ट, 680 वर्ण

जावा - , ६६ --६० 60५ 85 char५३ चार्ट, प्लस ४ char४ चार्ट के साथ एक धोखा संस्करण

जावा - 642 622 अक्षर

सी, 253 250 वर्ण

C + LaserWriter प्रिंटर 599 - 10 = 589

जावा, 1574 2643 1934 अक्षर