বোকা সীমাবদ্ধতা এবং মরুভূমি


18

সুতরাং, আপনি পাই এর প্রথম 20 অঙ্ক গণনা করার জন্য একটি প্রোগ্রাম গল্ফ করে আপনার ডেস্কে বসে ছিলেন এবং পাশাপাশি আপনার বস এসে আপনার অ্যাপল IIe কে উইন্ডো থেকে ছুঁড়ে ফেলেছে। আপনি এখন একটি নতুন প্রকল্পে কাজ করছেন এবং এই কম্পিউটারে এখনও কোনও পাঠ্য ক্ষমতা নেই। কোনটিই নয়। কোনও ফন্ট নেই কিছুই নেই।

এখন আসুন যে প্রোগ্রাম শেষ। আপনার প্রোগ্রামের অংশ নয় এমন কোনও ফন্ট ব্যবহার না করে পাই এর প্রথম 20 টি অক্ষর গণনা করুন এবং প্রদর্শন করুন। আপনার আউটপুট একটি চিত্র ফাইল (জেপেইগ, পিএনজি, জিআইএফ, এসভিজি (যতক্ষণ আপনি কোনও অক্ষর ব্যবহার করবেন না), বিএমপি, এক্সপিএম) হিসাবে স্ট্যান্ডার্ড আউট বা প্রদর্শিত হতে পারে। আপনি যে কোনও ভাষা ব্যবহার করতে পারেন তবে আপনি নিজের ভাষার ফন্ট ফাংশন, পাঠ্য প্রদর্শন বা অনুরূপ ব্যবহার করতে পারবেন না।

ছোট বোনাস (10 টি অক্ষর) যদি এটি কোনও লিসায় কাজ করে।

সম্পাদনা করুন: যাঁরা এটি অনুভব করেননি তাদের জন্য আমার অনুপ্রেরণাটি ছিল প্রথম ম্যাক এবং শিরোনামটি একটি পাং pun @ সুকিমিন্ডারের কাছে একটি বড় কুডোস যার অ্যানিমেটেড জিআইএফ ঠিক দুর্দান্ত। আরও ভাল উত্তর সাথে আসে প্রতিযোগিতা শেষ হয় না।


আমি চ্যালেঞ্জটি পছন্দ করি তবে প্রযুক্তিগতভাবে কি এমন কোনও সিস্টেম উত্স কোড প্রদর্শন করতে অক্ষম হবে না? পিট বাদে অবশ্যই।
ApproachingDarknessFish

2
@ ভালেকহাল্ফ হার্ট আপনি অন্য একটি মেশিন থেকে উত্স কোডটি লোড করতে পারবেন
জন ডিভোরাক

1
এবং আপনি কীভাবে মানব পাঠযোগ্যকে সংজ্ঞায়িত করবেন? উদাহরণস্বরূপ, আমার হস্তাক্ষরটি কিছু মানুষের কাছে (কমপক্ষে একটিতে) পাঠযোগ্য এবং অন্যের কাছে নয়। (যাইহোক, 2 ^ (2x2) = 16, সমস্ত 11 সংখ্যার জন্য পর্যাপ্ত গ্লিফস;;))
কেন্ডল ফ্রে

4
আমি শিরোনামটি মোটেই বুঝতে পারি না, যখন আমরা পাঠ্য প্রদর্শনটি ব্যবহার করতে পারি না তখন ASCII শিল্প কীভাবে ঠিক হতে পারে তা আমি বুঝতে পারি না, এবং প্রশ্নের খুব "ডিগ্রি পিআই গণনা" এর সংজ্ঞা প্রয়োজন।
পিটার টেলর

2
"গণনা পাই" বলতে আসলে কী বোঝায়? আমি কি প্রথম 20 দশমিকের একটি বিটম্যাপটিকে হার্ড-কোড করতে পারি? (কোনও অন্তর্নির্মিত পিআই ধ্রুবক বা অনুরূপ ব্যবহার করবেন না)
ফায়ারফ্লাই

উত্তর:


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
কি হ্যাক? আমি ভেবেছিলাম আমাদের কোনও পাঠ্য আউটপুট ব্যবহার করার কথা ছিল না। আপনার কম্পিউটার কীভাবে *কোনও ফন্ট ছাড়াই ফাঁকা স্থানগুলি রেন্ডার করতে চলেছে ?
বুথবি

@ বুথবি: এটি 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()

এন = 80 এর আউটপুট :


পাই হিসাব

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

হ্যাঁ, এটা। সূত্র ব্যবহার প্রয়োগের ফল ইউলার ট্রান্সফর্ম করতে লিবনিজের সিরিজ সমষ্টি বাকি থেকে, এবং তারপর আউট ফ্যাক্টরিং প্রতিটি শব্দ। সূত্রটি রৈখিকভাবে রূপান্তরিত হয়; প্রতিটি অঙ্কের জন্য লগ 2 প্রয়োজন (10) ≈ 3.32 প্রয়োজন পুনরুক্তি প্রয়োজন। উপার্জনে আগ্রহীদের জন্য, পরিশিষ্ট এ দেখুন A.

প্রদর্শন

পিআইএল ইমেজ জেনারেশনের জন্য ব্যবহৃত হয়, কারণ এটি আমার জানা সবচেয়ে সুবিধাজনক লাইব্রেরি। একটি ফাঁকা 141 × 11 কালো এবং সাদা বিটম্যাপ তৈরি করা হয়েছে, এবং তারপরে তার উপর সাতটি বিভাগের ফ্যাশনগুলিতে সাদা লাইনগুলি আঁকা হয়, এটি একবারে একটি পিক্সেল। প্রতিটি বিভাগে আঁকার জন্য প্রয়োজনীয় অবস্থানগুলি বিটমাস্ক স্ট্রিংয়ে সংরক্ষণ করা হয়, বিটগুলি নিম্নলিখিত পদের সাথে সম্পর্কিত:

 000
3   5
3   5
 111
4   6
4   6
 222

বিট ম্যাজিক (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

অ্যাপেন্ডিক্স এ

ইউলারের ট্রান্সফর্ম একটি কনভার্জেন্স ত্বরণ প্রযুক্তি যা কোনও সিরিজের জন্য কাজ করে যা পরম একজাতীয় রূপান্তর প্রদর্শন করে। ফলস্বরূপ সিরিজগুলি সাধারণত প্রতি শব্দ বিট হারে রৈখিকভাবে একত্রিত হবে (নোট করুন যে মূল সিরিজটি ইতিমধ্যে সুপার-লিনিয়ার হলে, ফলস্বরূপ সিরিজটি আসলে ধীরে ধীরে রূপান্তরিত হবে)। বিশুদ্ধরূপে গাণিতিক বিবরণ , অনুসরণ করতে একটি বিট কঠিন তাই আমি পদ্ধতিগত পদ্ধতির গ্রহণ করা হবে।

আমরা লাইবনিজ সিরিজ দিয়ে শুরু করব:

তারপরে প্রতিবেশীর পদগুলির সংমিশ্রণ করে প্রতিটি পদ অর্ধেকে বিভক্ত করুন:

সরলীকৃত:

সাধারণ:

লক্ষ্য করুন যে নেতৃস্থানীয় ½ এর অংশীদার পদ নেই, সুতরাং এই পরিমাণটি বাকি অংশ থেকে বাদ দেওয়া হয়েছিল। এটি রূপান্তরিত সিরিজের প্রথম শব্দ। পরবর্তী শব্দটি সন্ধানের জন্য, আমরা আবার প্রক্রিয়াটি পুনরাবৃত্তি করি:

এবং আবার:

এবং আবার:

এবং ভাল পরিমাপের জন্য আরও একবার:

এই মুহুর্তে আমাদের প্রথম পাঁচটি পদ রয়েছে এবং ষষ্ঠ পদটি স্পষ্ট। এটি সাধারণকরণের জন্য পর্যাপ্ত হওয়া উচিত, সুতরাং আমরা এখানেই থামব। আমরা সংখ্যার এবং ডিনোমিনেটরগুলি ফ্যাক্টর করে শুরু করব:

ডোনমিনেটরগুলিতে স্পষ্টত 2n + 1 এর একটি ডাবল ফ্যাক্টরিয়াল থাকে , সুতরাং আমরা এটিকে প্যাচ করব:

প্রথম দুটি পদ বাদে সবকিছুই খাপ খায় যা ডিনোমিনেটরে 2 এর জন্য একটি অ্যাকাউন্টহীন থাকে । সম্পূর্ণ এক্সপ্রেশনটিকে 2 দিয়ে গুণ করে আমরা এটি ঠিক করতে পারি :

2 3 = 2 · 4 , সুতরাং:

অঙ্কটি এখন সহজেই চিহ্নিত করা যেতে পারে এন !

লক্ষ করুন যে, ফ্যাক্টর প্রত্যেক ক্রমানুযায়ী শব্দটি এ যোগ করেছেন N / (2n + 1 টি) , যেমন পন্থা গণমাধ্যমে এন বড় হয়ে শব্দটি প্রতি এক বিট হারে একটি রৈখিক অভিসৃতি implying - এই নকশা দ্বারা আসলে। একটি দুর্দান্ত ফলাফল, তবে এটি সেখানে ফ্যাক্টরিয়ালগুলি ছাড়া আরও ভাল লাগবে। আমরা এখানে যা করতে পারি তা হ'ল বাকী যোগফল থেকে প্রতিটি ধারাবাহিক শব্দ নির্ধারণ করা, যা নেস্টেড এক্সপ্রেশন তৈরি করবে:



এটি পুনরাবৃত্ত সম্পর্ক হিসাবে আবার লেখা যেতে পারে:

যেখানে n back লগ 2 (10) · d ⌉ .. থেকে পিছনের দিকে গণনা করে 0 where ডি প্রয়োজনীয় সংখ্যার সংখ্যা।

এটি আকর্ষণীয় হতে পারে যে এই পুনরাবৃত্তির স্থিতিশীল বিন্দু হুবহু 2 (বা 4 আপনি যদি এটি দ্বিগুণ করেছেন, যেমন আমার উপরের প্রতিবিম্বটি রয়েছে), যাতে আপনি সঠিকভাবে আরম্ভ করে বেশ কয়েকটি পুনরাবৃত্তি সংরক্ষণ করতে পারেন। যদিও, আপনার অন্য যে কোনও প্রয়োজনের মতো এলোমেলো মান শুরু করা, এবং শীর্ষে কয়েকটি অতিরিক্ত পুনরাবৃত্তি ছড়িয়ে দেওয়া সাধারণত বাইট-ওয়াসের দ্বারা সস্তা।


1
খুব সুন্দর, পাঠের জন্য ধন্যবাদ! আমি কি পাবেন না কি pমধ্যে p/2 * x/p + ...করছে .. AIUI পাইথন একটি biginteger পর ডাটাটাইপ স্বয়ংক্রিয় প্রচার সমর্থন করে, তাই এটি একটি স্পষ্টতা জিনিস করা উচিত হবে না, কিন্তু একরকম ঐ pব্যাপার গুলি এবং আউট বাতিল না করেন মত আমি কল্পনা তাদের কাছে ... আমি এখানে কী মিস করছি?
ফায়ারফ্লাই

@ ফায়ারফ্লাই pঅদ্ভুত সূচনা করেছে, যাতে এটি p/2/pসমান - পূর্ণসংখ্যা বিভাগের অধীনে - থেকে ((p-1)/2)/p। এই উত্পাদন করে 1/3, 2/5, 3/7, ইত্যাদি পদ উপরে উদ্ভূত।
প্রিমো

12

# সি - 777 টি অক্ষর

সি - 731 অক্ষর

GIF প্রিন্ট করে stdout

  • প্রশ্ন: প্রথমে কমা নেই 3

প্রি-কনফিগার করা শিরোলেখ থেকে জিআইএফ একসাথে সেলাই করা + প্রতিটি অঙ্ক 5x5 পিক্সেলের হোম ব্রিউড (এম্বেডেড) ফন্ট দ্বারা প্রতিনিধিত্ব করা হয়।

ফলাফল

এখানে চিত্র বর্ণনা লিখুন

এটি সেখানে --- ^

নোট করুন যে জিআইএফ এক দৌড়ের পরে কখনও কখনও ক্রোমে অদৃশ্য হয়ে যায়।

#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);}

সংক্ষিপ্ত ভূমিকা:

পিআই এর গণনা

পাই ডিক উইন্টার এবং আচিম ফ্লেমেনক্যাম্পের রবিনোভিটস এবং ওয়াগনের অ্যালগরিদম implementation এর সংখ্যার অঙ্কের অঙ্কের জন্য প্রয়োগের কিছুটা পরিবর্তিত সংস্করণ ব্যবহার করে গণনা করা হয় π

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);}

জিআইএফ জেনারেশন

জিআইএফ চিত্রগুলির 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);
}

Ulating গণনার জন্য একটি সংক্ষিপ্ত / অন্যান্য অ্যালগরিদম ব্যবহার করতে চাইছেন π


2
আমি ছবিতে প্রথম 3 এর পরে বিন্দুটি দেখতে পাচ্ছি না।
ভিক্টর স্টাফুসা

1
পিআই দশমিক প্রজন্মের অ্যালগরিদম সম্পর্কে তথ্যের কোনও লিঙ্ক আপনার কাছে রয়েছে? আমি আপনার কোডটি কিছুটা খেলেছি (জিআইএফ স্টাফগুলি সরিয়ে দেওয়ার পরে), তবে
পাইটির

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>

এটি একটি ওয়েব ব্রাউজারে দেখা যেতে পারে; সংখ্যাগুলি এসভিজি পাথ হিসাবে আউটপুট।

একটি ওয়েব ব্রাউজারে এসভিজি আউটপুটটির স্ক্রিনশট

  • এটি আকর্ষণীয় উপায়ে পাই গণনা করে না এবং জেএসের 20 টি সংখ্যা প্রদর্শন করার জন্য নির্ভুলতার সাথে সংখ্যার ধরণের অভাব রয়েছে।

  • অক্ষরগুলি সংরক্ষণ করতে, আমি "0" -এর জন্য পথের তথ্য বাদ দিয়েছি, কারণ এটি ক্রম হিসাবে প্রদর্শিত হয় না।


ওহ, ভেক্টর-ভিত্তিক পদ্ধতি। খুব সুন্দর, ফন্টে খুব ভাল কাজ।
ফায়ারফ্লাই

5

জাভা - 866 860 857 853 চর, প্লাস 574 অক্ষর সহ প্রতারণামূলক সংস্করণ

১৯৯ 1996 সাল থেকে সাইমন প্লাউফ সূত্রটি ব্যবহার করে, x.pngকালো পটভূমিতে সাদা ডিজিটাল-ঘড়ির মতো সংখ্যার একটি ফাইল আউটপুট করে :

Pi

এটি সংকুচিত কোড:

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 টি অক্ষর

আমার পূর্ববর্তী উত্তরটি অনুলিপি করা হচ্ছে, ১৯৯ the সাল থেকে সাইমন প্লাফের সূত্রটি ব্যবহার করে But তবে পরিবর্তে 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 অক্ষর

@ সুক্মিন্ডারের কোডে অ্যালগরিদম ব্যবহার করে পাই (প্রায় নির্লজ্জভাবে ধার নেওয়া এবং তাদের কোডটি কিছুটা রিফ্যাক্ট করা) Appro একটি বাইনারি পিবিএম চিত্র আউটপুট দেয় , যা উদাহরণস্বরূপ ইমেজম্যাগিকের সাথে রূপান্তরিত হতে পারে।

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);}

আমার ব্রেইল-ভিত্তিক পিপিএম রেন্ডারারের সাথে আউটপুটটি কেমন দেখাচ্ছে তা এখানে:

আউটপুট স্ক্রিনশট

@ সুক্মিন্ডারের উত্তরের মতো একই গলদ রয়েছে যে এতে দশমিক বিভাজক নেই। এছাড়াও, আমার আউটপুটটি উল্লম্ব এবং এটি মানব-পঠনযোগ্য কিনা তর্কযোগ্য ...

সম্পাদনা: @ উগোরেনের পরামর্শগুলি প্রয়োগ করা হয়েছে


ক্ষুদ্র উন্নতি: পদক্ষেপ putsমধ্যে for আরম্ভের, নির্ধারণ L[5]এবং ফেরত ,0। (কমা সংরক্ষণ করুন) এর জন্য dএকটি প্যারামিটার তৈরি করুন main
উগোরেন

4

পিএইচপি 380

চিত্র আউটপুট জন্য জিডি সক্ষম করা প্রয়োজন

<? 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);

এখানে চিত্র বর্ণনা লিখুন

পাই গণনা: যেহেতু বেস পিএইচপি 14 এর ডিফল্ট যথার্থতা রয়েছে এবং আমি স্বেচ্ছাসেবী যথার্থ এক্সটেনশনগুলি সক্ষম করে সার্ভারটি পুনরায় সংকলন করতে চাইনি, তাই প্রয়োজনীয় দশমিকের সাথেও আমি পিআরও পিওআই করতে পারিনি, তার পরিবর্তে এটি টাউ / 2 গণনা করে দশমিকের বাকি

যেহেতু গ্রাফিকটি 0 এবং 1 এর তৈরি, তাই আমি জিডি অপসারণ করতে পারি কিনা তা দেখতে পরে WBMP ফর্ম্যাট হিসাবে ব্যবহার করতে চেষ্টা করতে পারি


সেই চিত্রটি কালো রঙের, এবং সত্যিই ছোট, তবে 500% এ কাছাকাছি থাকলে আপনি এটি পড়তে পারেন। (এবং
কালারব্লাইন্ড

@hildred প্রতিটি চরিত্র 3x5 with 1 px between chars। রঙটি কেবল চারটি অক্ষর কমাতে লাল, তবে আমি জিতব না তা বিবেচনা করে, আমি এটি
পড়ার

আমার মন্তব্য একটি সমালোচনা হিসাবে নয়, একটি ব্যাখ্যা হিসাবে ভোট উত্সাহিত করা।
21:38 '

চিত্রশ্রেণীতে কোনও অক্ষর সংরক্ষণ করা যাবে? যেমন ফাংশন বিদ্যমান?
hildred

একটি পলিট চিত্র ( imagecreate) এর সাথে কাজ করার সময় @ ছোট্ট , এর প্রথম অনুরোধimagecolorallocate পটভূমির রঙ নির্ধারণের , এবং লেখার রঙ সেট করার জন্য দ্বিতীয় সেকেন্ডের প্রয়োজন। তাই এটি আরও দীর্ঘ হয়
আইনাসিও

4

সি + লেজার রাইটার প্রিন্টার 599 - 10 = 589

আপনার লেজার রাইটারে আউটপুটটি পাইপ করুন! :) এটি একটি লিসায় (সি সংকলক সহ) কাজ করা উচিত।

এটি 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");
}

অবহেলিত স্তর -১ (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


আমি মনে করি আমারও একটি ফন্ট তৈরি করতে হবে।
লুসার droog

হুম। এভাবে কখনও পর্যাপ্ত অঙ্ক পেতে যাবেন না। পিএসে কেবল 32-বিট ফ্লোট রয়েছে।
লুসার droog

দুর্দান্ত ধারণা, আমি গল্ফিংয়ের জন্য পোস্টস্ক্রিপ্ট পছন্দ করি।
hildred

অঙ্কগুলির জন্য আমার কাছে বিটম্যাপ ফন্ট রয়েছে তবে গল্ফিং কেবল এটি নষ্ট করবে!
লুসার droog

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- iPhone?rq=1


দেখে মনে হচ্ছে আপনি পিআই গণনা করার পরিবর্তে ধ্রুবক ব্যবহার করেছেন।

এটি একটি দুর্দান্ত মোড়। এটি এখন কাজ করে।
ক্লেটন

ট্রাই-ক্যাচ ব্লকটি যোগ throws Exceptionকরে mainএবং মুছে ফেলে আপনি এটি আরও কিছুটা সংক্ষেপ করতে পারেন। আরও, আপনি নাম পরিবর্তন করতে পারেন piএবং sqrtপদ্ধতি এবংloc , args, SCALE, x0এবং x11 গৃহস্থালির কাজ শনাক্তকারী করতে ভেরিয়েবল। এবং আপনাকে অবশ্যই সম্পূর্ণ ক্লাস যুক্ত করতে হবে, এর মধ্যে class Foo{ঘোষণা এবং আমদানি অন্তর্ভুক্ত রয়েছে ।
ভিক্টর স্টাফুসা
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.