ดังนั้นคุณกำลังนั่งอยู่ที่โต๊ะทำงานของคุณเล่นกอล์ฟเพื่อคำนวณตัวเลข 20 ตัวแรกของไพและตามมาด้วยเจ้านายของคุณแล้วโยนแอปเปิ้ล IIe ของคุณออกไปนอกหน้าต่าง ตอนนี้คุณกำลังทำงานในโครงการใหม่และคอมพิวเตอร์เครื่องนี้ยังไม่มีความสามารถด้านข้อความใด ๆ ไม่มี. ไม่มีแบบอักษร ไม่มีอะไร

ตอนนี้ขอจบโปรแกรมนั่น คำนวณและแสดง 20 ตัวอักษรแรกของ pi โดยไม่ใช้แบบอักษรใด ๆ ที่ไม่ได้เป็นส่วนหนึ่งของโปรแกรมของคุณ เอาต์พุตของคุณสามารถแสดงหรือเขียนลงในไฟล์สแตนดาร์ดเป็นไฟล์รูปภาพ (jpeg, png, gif, svg (ตราบใดที่คุณไม่ได้ใช้อักขระใด ๆ ), bmp, xpm) คุณสามารถใช้ภาษาใดก็ได้ แต่คุณไม่สามารถใช้ฟังก์ชั่นแบบอักษรของภาษาการแสดงข้อความหรือสิ่งที่คล้ายกันได้

โบนัสขนาดเล็ก (10 ตัวอักษร) ถ้ามันจะใช้ได้กับ Lisa

แก้ไข: สำหรับผู้ที่ไม่ได้คิดว่าแรงบันดาลใจของฉันคือแม็คแรกและชื่อเป็นปุน ความรุ่งโรจน์ที่ยิ่งใหญ่ของ @Sukminder ซึ่งเป็น gif ที่เคลื่อนไหวได้ยอดเยี่ยมมาก การประกวดยังไม่จบหากมีคำตอบที่ดีกว่า

Python 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บรรทัดแรกจะคำนวณตัวเลขของปี่โดยใช้ประมาณ สามบรรทัดถัดไปเอาต์พุต 20 ตัวอักษรของ pi โดยใช้ ASCII art Nemeth Braille

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

ฉันกำลังผลักดันขอบเขตในสองทิศทางที่นี่ทั้งใน "การคำนวณ Pi" และ "มนุษย์อ่านได้" ความรู้สึก

Python ขนาด 217 ไบต์

ต้องการPython Imaging Library

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 เริ่มต้นของคุณ):

โปรดทราบว่าการกำหนดค่าพารามิเตอร์นี้สามารถพิมพ์ตัวเลขที่คุณต้องการได้อย่างง่ายดาย ต่อไปนี้จะยอมรับอินพุตจำนวนเต็มจาก stdin และแสดงตัวเลขหลายหลัก:

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 :

การคำนวณ Pi

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

ใช่นั่นแหล่ะ สูตรที่ใช้เป็นผลมาจากการใช้การแปลงของออยเลอร์กับซีรีส์ Leibnizจากนั้นแยกแต่ละคำออกจากส่วนที่เหลือของผลรวม สูตรมาบรรจบกันเป็นเส้นตรง แต่ละหลักต้องการบันทึก₂ (10) ≈ 3.32ซ้ำ สำหรับผู้ที่สนใจแหล่งที่มาโปรดดูที่ภาคผนวกก

แสดง

PILใช้สำหรับการสร้างภาพเพราะมันเป็นห้องสมุดที่สะดวกที่สุดที่ฉันรู้จัก เปล่า141 × 11สีดำและสีขาวบิตแมปจะถูกสร้างขึ้นและเส้นสีขาวจากนั้นจะมีการวาดเกี่ยวกับมันในแฟชั่นเจ็ดส่วนหนึ่งพิกเซลในเวลา ตำแหน่งที่ต้องการวาดแต่ละเซ็กเมนต์จะถูกเก็บไว้ในสตริง bitmask โดยมีบิตที่สอดคล้องกับตำแหน่งต่อไปนี้:

 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

ภาคผนวกก

การแปลงของออยเลอร์เป็นเทคนิคการเร่งความเร็วแบบคอนเวอร์เจนซ์ที่ใช้กับซีรีย์ใด ๆ ที่แสดงคอนเวอร์เจนซ์แบบโมโนโทนิ ชุดผลลัพธ์จะรวมกันเป็นเส้นตรงโดยทั่วไปจะอยู่ที่อัตราหนึ่งบิตต่อเทอม (โปรดทราบว่าหากชุดดั้งเดิมเป็นแบบเส้นตรงสุดแล้วชุดผลลัพธ์จะรวมกันช้าลงจริง ๆ ) อธิบายทางคณิตศาสตร์อย่างหมดจดเป็นบิตยากที่จะปฏิบัติตามดังนั้นฉันจะได้รับการใช้วิธีการขั้นตอน

เราจะเริ่มต้นด้วย Leibniz Series:

จากนั้นแบ่งแต่ละเทอมเป็นครึ่งรวมคำที่อยู่ใกล้เคียง:

ย่อ:

ทั่วไป:

โปรดสังเกตว่าผู้นำ½ไม่มีคำที่เป็นพันธมิตรและถูกแยกออกจากส่วนที่เหลือทั้งหมด นี่เป็นเทอมแรกของซีรีย์ที่ถูกเปลี่ยน หากต้องการค้นหาคำถัดไปเราจะทำขั้นตอนนี้ซ้ำอีกครั้ง:

และอีกครั้ง:

และอีกครั้ง:

และอีกครั้งสำหรับการวัดที่ดี:

เมื่อถึงจุดนี้เรามีเทอมห้าข้อแรกและเทอมที่หกชัดเจน นี่ควรจะเพียงพอที่จะพูดคุยทั่วไปดังนั้นเราจะหยุดที่นี่ เราจะเริ่มต้นด้วยการแยกตัวหารและตัวส่วน:

denominators เห็นได้ชัดว่ามีปัจจัยคู่ของ2n + 1ดังนั้นเราจะแก้ไขว่าใน:

ทุกอย่างลงตัวยกเว้นคำสองคำแรกซึ่งมี2 บัญชีในส่วนที่ไม่ได้นับ เราสามารถแก้ไขได้โดยคูณการแสดงออกทั้งหมดด้วย2 :

2 ³ = 2 · 4ดังนั้น:

ตัวเศษสามารถระบุได้อย่างง่ายดายว่าn!.

โปรดสังเกตว่าปัจจัยที่เพิ่มลงในแต่ละคำที่ต่อเนื่องคือn / (2n + 1)วิธีการ½เมื่อnมีขนาดใหญ่หมายถึงการลู่เชิงเส้นในอัตราหนึ่งบิตต่อเทอม - นี่คือความจริงโดยการออกแบบ ผลลัพธ์ที่ดี แต่มันจะดีกว่าหากไม่มีแฟคทอเรียลอยู่ตรงนั้น สิ่งที่เราสามารถทำได้ที่นี่คือการแยกแยะแต่ละคำที่ต่อเนื่องจากส่วนที่เหลือของผลรวมซึ่งจะสร้างนิพจน์ซ้อนกัน:

สิ่งนี้สามารถเขียนใหม่เป็นความสัมพันธ์ที่เกิดซ้ำ:

โดยที่nนับถอยหลังจาก⌈ log ₂ (10) · d ⌉ .. 0โดยที่dคือจำนวนตัวเลขที่ต้องการ

อาจเป็นที่น่าสนใจที่จะทราบว่าจุดคงที่ของการเกิดซ้ำนี้คือ2 (หรือ4หากคุณเพิ่มเป็นสองเท่าดังที่ฉันมีในการใส่เข้าไปด้านบน) ดังนั้นคุณสามารถบันทึกจำนวนซ้ำได้โดยเริ่มต้นอย่างถูกต้อง แม้ว่าการเริ่มต้นเป็นค่าแบบสุ่มที่คุณต้องการที่อื่นและการเพิ่มการทำซ้ำสองสามครั้งที่ด้านบนนั้นโดยทั่วไปแล้วจะถูกกว่าแบบไบท์

#C - 777 ตัวอักษร

C - 731 ตัวละคร

พิมพ์ GIF stdoutเพื่อ

• มุมแหลม: 3ไม่มีเครื่องหมายจุลภาคครั้งแรกหลังจากที่

การต่อกัน GIF จากส่วนหัวที่กำหนดไว้ล่วงหน้า + แต่ละหลักที่แสดงโดยแบบอักษรแบบชงที่บ้าน (ฝัง) ที่ 5x5 พิกเซล

ผลลัพธ์

มันมี --- ^

โปรดทราบว่า GIF หายไปในบางครั้งใน Chrome หลังจากการเรียกใช้ครั้งเดียว

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

แนะนำสั้น ๆ :

การคำนวณ PI

Pi คำนวณโดยใช้ Dik Winter รุ่นดัดแปลงเล็กน้อยและการนำ Achim Flammenkamp ไปใช้ในการคำนวณอัลกอริทึมของ Rabinowitz และ Wagon สำหรับการคำนวณตัวเลขของπ

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

กำลังมองหาที่จะใช้อัลกอริทึมที่สั้นลง / อื่น ๆ สำหรับการคำนวณπ

JavaScript, 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

• มันไม่ได้คำนวณ pi ในวิธีที่น่าสนใจและ JS ไม่มีประเภทตัวเลขที่มีความแม่นยำในการแสดง 20 หลัก

• ในการบันทึกตัวละครฉันละเว้นข้อมูลพา ธ สำหรับ "0" เนื่องจากไม่แสดงตามลำดับ

Java - 866 860 857 853 chars รวมทั้ง cheating เวอร์ชั่น 574 chars

ใช้สูตร Simon Plouffe จากปี 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);}}

ด้วยการระบุและ whitespaces บางอย่างจะเป็นเช่นนี้:

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

การโกงกฎและพิจารณาว่าการคำนวณ PI สามารถทำได้ในฐานะ "การแสดงตัวเลขของสตริง 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);}}

ชวา - 642 622 ตัวอักษร

คัดลอกจากคำตอบก่อนหน้าของฉันโดยใช้สูตร Simon Plouffe จากปี 1996 แต่ให้ผลลัพธ์ ASCII-art แทน:

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

เอาท์พุท:

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

C, 253 250 ตัวอักษร

ประมาณค่า pi โดยใช้อัลกอริทึมในรหัสของ @ 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 ที่ใช้อักษรเบรลล์ของฉัน:

มีความแปลกประหลาดแบบเดียวกับคำตอบของ @ Sukminder เพราะมันไม่มีตัวคั่นทศนิยม นอกจากนี้ผลผลิตของฉันเป็นแนวตั้งและไม่ว่าจะเป็นที่มนุษย์สามารถอ่านได้มีการพิสูจน์ ...

แก้ไข: ใช้คำแนะนำของ @ ugoren

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

การคำนวณ pi: เนื่องจาก base php มีความแม่นยำเริ่มต้นที่ 14 และฉันไม่ต้องการคอมไพล์เซิร์ฟเวอร์อีกครั้งด้วยการเปิดใช้งานส่วนขยายความแม่นยำตามอำเภอใจฉันจึงไม่สามารถแม้แต่ aproximate PI กับทศนิยมที่ต้องการดังนั้นแทนที่จะคำนวณ tau / 2 แล้ว ส่วนที่เหลือของทศนิยม

เนื่องจากกราฟิกทำจาก 0 และ 1 ฉันอาจลองใช้ WBMP เป็นรูปแบบในภายหลังเพื่อดูว่าฉันสามารถลบ gd ได้ไหม

เครื่องพิมพ์ C + LaserWriter 599 - 10 = 589

ส่งออกไปยัง LaserWriter ของคุณ! :) สิ่งนี้ควรใช้กับ Lisa (กับคอมไพเลอร์ C)

มันคำนวณpiในเครื่องพิมพ์โดยการคำนวณผลรวมของความยาวของส่วนของเส้นตรงซึ่งใกล้เคียงกับลำดับเส้นโค้ง Bezier ซึ่งใกล้เคียงกับครึ่งวงกลมหารด้วยเส้นผ่านศูนย์กลางคูณ 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");
}

PostScript Ungolfed Level-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

เอาท์พุท:

Java, 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;
}

วิธี Pi รวบรวมจาก: /programming/8343977/calculate-pi-on-an-android-phone?rq=1