การสร้างไฟล์บิตแมป PBM จากข้อความ ASCII


19

รูปแบบPBM (Portable BitMap)เป็นรูปแบบบิตแมป ASCII ขาวดำที่ง่ายมาก

นี่คือตัวอย่างสำหรับตัวอักษร 'J' (คัดลอกวางจากลิงค์ wikipedia):

P1
# นี่คือตัวอย่างบิตแมปของตัวอักษร "J"
6 10
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
1 0 0 0 1 0
0 1 1 1 0 0
0 0 0 0 0 0
0 0 0 0 0 0

ถึงเวลาที่เราจะสร้างเครื่องมือขนาดเล็กเพื่อสร้างไฟล์ในรูปแบบที่ดีเล็ก ๆ น้อย ๆ !

เป้าหมายของคุณคือการเขียนโปรแกรมที่สั้นที่สุด (ในภาษาใด ๆ ) ที่สอดคล้องกับกฎต่อไปนี้:

  1. โปรแกรมของคุณใช้หนึ่งสายจาก stdin (ตัวอย่างCODEGOLF.STACKEXCHANGE.COM!)
  2. มันสร้างไฟล์ PBM ด้วยการเป็นตัวแทนบิตสตริง (อ่านได้) ของสตริง
  3. อักขระแต่ละตัวถูกสร้างเป็นตาราง 8x8
  4. คุณต้องสนับสนุนอักขระ [AZ] (ตัวพิมพ์ใหญ่ทั้งหมด) เว้นวรรคจุด ('.') และเครื่องหมายอัศเจรีย์ ('!')
  5. ไม่อนุญาตให้ใช้ไลบรารีภายนอก (ไม่เกี่ยวข้องกับ PBM)!
  6. ชุดอักขระที่ใช้ต้องไม่อยู่ภายนอกโปรแกรมของคุณ ส่วนหนึ่งของความท้าทายคือการเก็บตัวละครอย่างมีประสิทธิภาพ ...

การทดสอบความถูกต้องของรูปแบบ PBM สามารถทำได้ด้วย GIMP (หรืออื่น ๆ ) อย่าอวดตัวอย่างอินพุตและเอาท์พุต!

ทางออกที่สั้นที่สุดจะได้รับคะแนนคำตอบใน 2012-01-31

ขอให้สนุกกับการเล่นกอล์ฟ!

ป.ล. : ฉันได้เพิ่มความโปรดปราน (ชื่อเสียงเป็นเปอร์เซ็นต์ที่ยิ่งใหญ่ของชื่อเสียง codegolf ของฉัน) ให้กับ (หวังว่า) จะดึงดูดคู่แข่งมากขึ้น


คุณหมายถึงการนำเสนอตัวละครที่ใกล้เคียงกับบางสิ่งที่ดูเหมือนตัวอักษรหรือไม่ ใกล้แค่ไหน สิ่งที่ต้องการบิตแมปของรหัสไบนารีหรือรหัสอักษรเบรลล์หรือรหัสมอร์สจะได้รับอนุญาต?
Howard

@Howard: ความคิดคือการสร้างภาพ pbm ซึ่งมีข้อความอินพุตดั้งเดิมใน 'เรนเดอร์' (บิตแมป) แต่ยังคงรูปแบบที่มนุษย์อ่านได้ (ด้วยlettersคำอื่น ๆ ) ไม่เหมือนตัวอย่างที่เชื่อมโยงกับ
ChristopheD

ฉันเพิ่มแท็กkolmogorov-complexเพราะส่วนใหญ่ของโปรแกรมจะเป็น 30 บิตแมป
Peter Taylor

@ Peter Taylor: จุดดีขอบคุณ!
ChristopheD

ฉันรู้สึกว่าเราจะต้องถกเถียงกันอย่างยาวนานและเจ็บปวดในสิ่งที่ถือเป็น "ห้องสมุดภายนอก"
JB

คำตอบ:


9

GolfScript, 133 ไบต์

สิ่งนี้ขึ้นอยู่กับโซลูชัน Perl ขนาด 164 ไบต์ของฉันและใช้แบบอักษรขนาด 4 x 5 พิกเซลที่บรรจุด้วยแทะเดียว อีกครั้งฉันจะให้รุ่นที่อ่านได้ก่อน:

{91,65>"!. "+?}%:s"P4"\,8*8'FONT DATA HERE'{16base}%[3]/{:p;{[p=0]0=}s%}%]n*

ที่นี่FONT DATA HEREย่อมาจาก 71 ไบต์ของข้อมูลตัวอักษรไบนารีที่บรรจุ การเข้ารหัสแตกต่างจากรุ่น Perl เล็กน้อย: แทนที่จะแยกสตริงที่บรรจุในช่องว่างออกฉันขยายมันก่อนแล้วจึงแยกมันบนแทะ3(เลือกเพราะมันเพิ่งเกิดขึ้นไม่ได้เกิดขึ้นที่ใดก็ได้ในแบบอักษร)

เนื่องจากข้อมูลตัวอักษรในสคริปต์จริงมีอักขระที่ไม่สามารถพิมพ์ได้ฉันจึงให้ข้อมูลนี้เป็นฐานสิบหกด้านล่าง ใช้xxd -rเพื่อเปลี่ยนการถ่ายโอนข้อมูลเลขฐานสิบหกกลับไปเป็นรหัส GolfScript ที่ปฏิบัติการได้:

0000000: 7b39 312c 3635 3e22 212e 2022 2b3f 7d25  {91,65>"!. "+?}%
0000010: 3a73 2250 3422 5c2c 382a 3827 36e6 eff6  :s"P4"\,8*8'6...
0000020: 9219 8996 e6e7 7959 95f4 3999 9888 921a  ......yY..9.....
0000030: 8fd9 9998 2959 9514 3fe8 9eeb f21c 89b9  ....)Y..?.......
0000040: e9e6 2959 6564 3999 9889 929a 8999 8ba1  ..)Yed9.........
0000050: 295f 9283 9e6e f869 269f 9968 79e2 6299  )_...n.i&..hy.b.
0000060: 2f48 3327 7b31 3662 6173 657d 255b 335d  /H3'{16base}%[3]
0000070: 2f7b 3a70 3b7b 5b70 3d30 5d30 3d7d 7325  /{:p;{[p=0]0=}s%
0000080: 7d25 5d6e 2a                             }%]n*

ซึ่งแตกต่างจากสคริปต์ Perl รหัสนี้จะพิมพ์ตัวอักษรใดนอกชุดA- Z, !, ., spaceตลกมอง squiggles เล็ก ๆ น้อย ๆ แทนที่ squiggles ด้วยช่องว่างจะมีค่าใช้จ่าย 2 ตัวอักษรพิเศษ; การลบออกทั้งหมดจะมีค่าใช้จ่าย 4

นี่เป็นโปรแกรม GolfScript โปรแกรมแรกของฉันดังนั้นฉันจะไม่แปลกใจถ้ามีที่เหลือสำหรับการเพิ่มประสิทธิภาพ นี่คือวิธีการทำงาน:

  • {91,65>"!. "+?}%:sแผนที่ป้อนอักขระที่ถูกต้อง ( A- Z, !, ., space) เพื่อตัวเลข 0-28 sและกำหนดผลให้ อักขระใด ๆ นอกชุดที่ถูกต้องจะถูกแมปกับ -1 ซึ่งเป็นสิ่งที่สร้าง squiggles เมื่อพิมพ์

  • "P4"\,8*8ผลักค่า "P4", 8 เท่าของความยาวของอินพุตและ 8 ลงบนสแต็ก เมื่อพิมพ์ที่ส่วนท้ายสิ่งเหล่านี้จะสร้างส่วนหัว PBM

  • {16base}%[3]/ใช้เวลาสตริงก่อน ๆ ของข้อมูลตัวอักษรแยก byte 3ของมันในแต่ละเป็นสองแทะและแยกผลลงในบล็อกคั่นด้วยค่า {:p;{[p=0]0=}s%}%แล้วลูปมากกว่าบล็อกเหล่านี้เป็นครั้งแรกที่กำหนดแต่ละบล็อกให้กับตัวแปรpแล้ววนลูปในช่วงสายป้อน remapped แทนที่ตัวละครแต่ละตัวมีค่าที่สอดคล้องกันในการชดเชยs pสร้างตลกที่ดู[p=0]0=ไม่เหมือนกันเป็นp=ยกเว้นว่ามันกลับ 0 สำหรับการชดเชยใด ๆ ที่ผ่านมาในตอนท้ายของp; ฉันไม่ชอบมัน แต่ฉันไม่สามารถหาวิธีที่สั้นกว่านี้ในการจัดการกับมันได้

  • ในที่สุด]n*ใช้ทุกอย่างบนสแต็ค (ค่าส่วนหัวสามค่าและอาร์เรย์ข้อมูลรูปภาพ) และรวมเข้าด้วยกันด้วยการขึ้นบรรทัดใหม่สำหรับการพิมพ์


อย่างจริงจังสั้น ๆ (โดยตัวชี้วัดใด ๆ ) ดี!
ChristopheD

12

Perl, 164 ไบต์, ไม่มีการบีบอัด zlib / gzip

หลังจากนอนหลับกับปัญหาฉันจัดการเพื่อหาทางออกที่สั้นกว่าหนึ่งครั้งแรก เคล็ดลับคือการใช้ประโยชน์จากช่องโหว่เล็ก ๆ น้อย ๆ ในกฎ: อักขระต้องมีขนาดพอดีกับ 8 ถึง 8 พิกเซลแต่ละตัว แต่ไม่มีอะไรบอกว่าพวกเขาต้องเติมเต็มพื้นที่นั้น ดังนั้นฉันจึงดึงแบบอักษร 4 x 5 พิกเซลของฉันเองทำให้ฉันสามารถแพ็คอักขระสองตัวเป็น 5 ไบต์

ผลลัพธ์มีลักษณะดังนี้:

"สวัสดีชาวโลก!" (ปรับสัดส่วน x 4)

    "โอ้! สุนัขจิ้งจอกสีน้ำตาลกระโชกเร็วกว่าขี้เกียจ" (ขนาดดั้งเดิม)

ก่อนที่จะให้รหัสที่แท้จริงพร้อมกับข้อมูลแบบอักษรที่ฝังอยู่ให้ฉันแสดงเวอร์ชัน de-golfed:

y/A-Z!./\0-\033/ for @a = <> =~ /./g;
say "P4 " . 8*@a . " 8";
for $p (qw'PACKED FONT DATA') {
    print chr vec $p, ord, 4 for @a;
}

ในรหัสที่แท้จริงPACKED FONT DATAจะถูกแทนที่ด้วยสตริงไบนารีที่ประกอบด้วยแถวที่คั่นด้วยช่องว่างแปดแถว (สี่แถว 14 ไบต์และ 13 ไบต์หนึ่งรวมทั้งสามไบต์เดียวว่างสำหรับแถวว่าง) ฉันตั้งใจออกแบบตัวอักษรของฉันเพื่อให้ข้อมูลที่บรรจุไม่มีช่องว่างคำพูดเดี่ยวหรือแบ็กสแลชเพื่อให้สามารถเข้ารหัสqw'...'ได้

เนื่องจากสตริงฟอนต์ที่บรรจุมีอักขระที่ไม่สามารถพิมพ์ได้ฉันจึงจัดเตรียมสคริปต์จริงเป็นดัมพ์แบบฐานสิบหก ใช้xxd -rเพื่อเปลี่ยนกลับเป็นโค้ด Perl ที่รันได้:

0000000: 792f 412d 5a21 2e2f 002d 1b2f 666f 7240  y/A-Z!./.-./for@
0000010: 613d 3c3e 3d7e 2f2e 2f67 3b73 6179 2250  a=<>=~/./g;say"P
0000020: 3420 222e 382a 4061 2e22 2038 223b 666f  4 ".8*@a." 8";fo
0000030: 7224 7028 7177 2700 20e6 e6ff 9612 8999  r$p(qw'. .......
0000040: e6e6 7759 99f5 0420 9999 8898 128a df99  ..wY... ........
0000050: 9928 5999 1504 20ef 98ee fb12 8cb9 e9e9  .(Y... .........
0000060: 2659 6965 0420 9999 8899 928a 9989 ab21  &Yie. .........!
0000070: 599f 8220 e9e6 8f96 62f9 9986 972e 2699  Y.. ....b.....&.
0000080: f284 2000 2000 2729 7b70 7269 6e74 2063  .. . .'){print c
0000090: 6872 2076 6563 2470 2c6f 7264 2c34 666f  hr vec$p,ord,4fo
00000a0: 7240 617d                                r@a}

นี่คือวิธีการทำงาน:

  • บรรทัดแรก (ในรุ่น de-แข็งแรงเล่นกอล์ฟ) อ่านบรรทัดเดียวของการป้อนข้อมูลแยกลงในอาร์เรย์ของตัวอักษร (สิ่งอำนวยความสะดวกเลี่ยงการขึ้นบรรทัดใหม่ต่อท้าย) และแผนที่ตัวอักษรAไปZและตัวอักษร!และ.รหัสตัวอักษรที่ 0-28 ซึ่ง โดยปกติจะสอดคล้องกับอักขระควบคุมที่ไม่สามารถพิมพ์ได้ใน ASCII / Unicode (ผลข้างเคียงเล็กน้อยของสิ่งนี้คือแท็บใด ๆ ในอินพุตรับพิมพ์เป็นJs) อักขระเว้นวรรคจะไม่ได้รับการแมปเนื่องจากเอาต์พุตลูปจะเปลี่ยนรหัสใด ๆ ที่อยู่เหนือ 28 เป็นช่องว่าง

  • บรรทัดที่สองเพิ่งพิมพ์ส่วนหัว PBM มันใช้คุณสมบัติ Perl 5.10 sayดังนั้นคุณต้องเรียกใช้สคริปต์นี้perl -M5.010เพื่อให้สามารถใช้งานได้

  • ห่วงส่งออกใช้รายการช่องว่างที่คั่นแถวภาพบรรจุและกำหนดแต่ละของพวกเขาเข้าไป$pในทางกลับกัน (ฉันออกแบบตัวอักษรเพื่อให้ข้อมูลที่บรรจุจะไม่มีช่องว่างหรือ'ตัวอักษรใด ๆ) จากนั้นจะวนซ้ำอักขระอินพุตใน@aโดยใช้vecคำสั่งของ Perl เพื่อแยกแทป 4 บิตที่สอดคล้องกับรหัสอักขระที่แม็พจากแถวรูปภาพ แปะไปที่ไบต์ 8 บิตและพิมพ์


คำตอบเก่า 268 ไบต์:

นี่เป็นครั้งแรกที่รวดเร็วและสกปรก ฉันขโมยแบบอักษรของ PleaseStand และบีบอัดมันพร้อมกับซอร์สโค้ดของฉัน เนื่องจากสคริปต์ผลลัพธ์ส่วนใหญ่จะไม่สามารถพิมพ์ได้นี่เป็น hexdump; ใช้xxd -rเพื่อเปลี่ยนเป็นโค้ด Perl ที่รันได้:

0000000: 7573 6520 436f 6d70 7265 7373 275a 6c69  use Compress'Zli
0000010: 623b 6576 616c 2075 6e63 6f6d 7072 6573  b;eval uncompres
0000020: 7320 2778 da85 d03d 4b03 4118 85d1 452c  s 'x...=K.A...E,
0000030: b69c 72cb 7519 4894 552c 2c02 3319 ee5c  ..r.u.H.U,,.3..\
0000040: d7b8 5a89 6093 4634 7e82 c490 6c91 8597  ..Z.`.F4~...l...
0000050: 80fe 7267 d660 23ae e52d 0e0f dcd6 f8c3  ..rg.`#..-......
0000060: e9d1 5e6e ccec a15c ddb5 c5d5 495e 94a3  ..^n...\....I^..
0000070: 83b7 c7f9 73f3 5216 f9a8 787a 5fea 666c  ....s.R...xz_.fl
0000080: 9dd1 b763 dd98 76f8 2df6 0799 5811 7144  ...c..v.-...X.qD
0000090: 4acc ee9d b8b0 c90f 7e4a 8264 6016 cbd7  J.......~J.d`...
00000a0: 79f3 1b91 047c 4055 409e 9e54 1dda ed41  y....|@U@..T...A
00000b0: 9a20 8080 6adc 5c47 8488 7495 f621 01d7  . ..j.\G..t..!..
00000c0: 6b6c 902e b6c8 2a6a 6643 f56f e99c 115d  kl....*jfC.o...]
00000d0: 5c7a f1b2 13d0 3453 790f da74 c813 751d  \z....4Sy..t..u.
00000e0: 11ce d821 ad90 247f 2292 5b54 c14f 3c4e  ...!..$.".[T.O<N
00000f0: 49c5 4c53 a1a7 c478 391c 714c f113 0747  I.LS...x9.qL...G
0000100: ab6c 4482 9fd2 177a 5677 6327            .lD....zVwc'

รหัส Perl ที่คลายการบีบอัดประกอบด้วยคำนำดังต่อไปนี้:

y;A-Z.! ;;cd,say"P4 ",8*length," 8"for$t=<>

ตามด้วยการทำซ้ำแปดครั้งของรหัสต่อไปนี้:

;$_=$t;y(A-Z.! )'BITMAP DATA HERE';print

ด้วยBITMAP DATA HEREแทนที่ด้วย 29 ไบต์เข้ารหัสแบบอักษรหนึ่งแถว


โซลูชันที่ใหม่กว่านั้นดีมาก ไม่เคยคิดเลยว่าจะทำได้ใน 165 ตัวอักษร
ChristopheD

6

รหัสเครื่อง 8086

190 ไบต์ (122 ไบต์โดยใช้ BIOS)

นี่คือ Base64 ที่เข้ารหัสไฟล์ WinXP / MSDos .COM:

M8COwCaKDoUEitEmxD4MAaCAAP7IfliK8MHgA7cK9ve9egEAZ
vy0APb3AUb6iMi0APb3AUb+x0YACg2DxQK+ggCK7qz24YvYJo
ohswjQ5LAwFACIRgBF/st18v7NdeRH/sp10sZGACS6cAG0Cc0
hw1AxCg0wMDAgMDA=

(ใช้บางอย่างเช่นนี้ ) เพื่อถอดรหัสข้อความและบันทึกเป็น "pbm.com" จากนั้นที่พรอมต์คำสั่งให้พิมพ์:

ข้อความ pbm ที่จะเข้ารหัส> outputfilename.pbm

ฉันทดสอบสิ่งนี้บนเครื่อง WinXP ของฉันโดยใช้ทั้งพรอมต์คำสั่งมาตรฐานและ DosBox V0.74

UPDATE

รุ่นนี้มีขนาด 190 ไบต์และใช้ฟอนต์จิ๋วของ Ilmari Karonen (ไม่มีการเข้าถึงไบออสที่นี่!): -

voAArf7Iflq7YwG/vgG6Cg20Bfbk9vIAZfsy5PbyAUX5Vqw48HQoLEFzCDQG/sAMGSQfM8
nQ6NfA0QPS6IjEsQSwJtDsENCq4vewMKrr04DDEF6A+7N1ycYFJLqzAbQJzSHDdnb/loIZ
mXZ2flmZ9QAAIJmZEZGCFb+ZmSFZmYUPDy9/kXf9ghPZeXkmWWllAAAgmZkRmZIVmRldKF
mfEgAAAHl2H5Zi+ZkWnicmmfIAICBQMQoNMDAwIDUKDQ==

ทางออกที่ดีมาก ในขณะนี้ผู้แข่งขันสำหรับค่าหัวซึ่งจะได้รับภายใน 20 ชั่วโมง ทำได้ดี!
ChristopheD

คุณสามารถโพสต์รหัสการประกอบสำหรับสิ่งนี้ได้เช่นกัน?
Sir_Lagsalot

1
หลังจากดูที่การแยกส่วนและทดสอบรหัสมันจะปรากฏขึ้นคุณเพียงแค่ใช้ตัวอักษรบิตแมปที่ได้รับจากไบออส สิ่งนี้สามารถยืนยันได้ด้วยความจริงที่ว่าโปรแกรมของคุณสามารถแสดงตัวอักษรตัวพิมพ์เล็กสัญลักษณ์และเครื่องหมายวรรคตอนที่ไม่ต้องใช้ความท้าทาย ดังนั้นแบบอักษรภายนอกกับโปรแกรมของคุณและไม่ได้จัดเก็บโดย (อย่างน้อยในความคิดของฉัน)
Sir_Lagsalot

@Skizz: คุณยืนยันสิ่งนี้ได้ไหม มันยังคงทำให้เป็นทางออกที่ดีมาก แต่ก็เทียบกับสเป็คเล็กน้อย
ChristopheD

1
@ChristopheD: อืม JB แสดงความคิดเห็นว่า "ฉันรู้สึกว่าเราจะต้องถกเถียงกันมานานและเจ็บปวดในสิ่งที่ถือเป็นห้องสมุดภายนอก" - หนึ่งอาจโต้แย้งว่าputsใน Ruby เป็นห้องสมุดภายนอก ใช่มันใช้ฟอนต์ไบออสซึ่งเข้าถึงได้จากตัวชี้การลงทะเบียน (ไม่มีloadการดำเนินการเพื่อให้ฟอนต์เข้าสู่ RAM) การดัดกฏอาจจะไกลเกินไป ฉันจะได้ไปกับมันถ้ามันไม่ได้มีไว้สำหรับเด็กที่น่ารำคาญเหล่านั้น ;-)
Skizz

6

เชลล์สคริปต์ (รหัส + ข้อมูล = 295 ตัวอักษร)

ฉันหวังว่า tail, gzip และ dd จะไม่นับเป็น "ห้องสมุดภายนอก" echo -n 'YOUR TEXT HERE' | ./text.sh > out.pbmทำงานเป็น ตัวอักษรที่ฉันใช้คือตัวอักษรขนาดเล็กขนาด 7.5 ถึงแม้ว่าฉันจะต้องตัดส่วนที่ตัดออกจากคิว

ตัวอย่างผลลัพธ์

QUICK BROWN FOX สีน้ำตาลอย่างรวดเร็วเกินกว่าสุนัขที่ขี้เกียจ  จริงๆ!

รหัส (137 ตัวอักษร)

i=`od -tu1|cut -c9-`
echo P4
for a in {0..7}
do for b in $i
do tail -2 $0|zcat|dd bs=1 count=1 skip=$((8*b+a))
done
done>8
wc -c 8
cat 8

สคริปต์ที่สมบูรณ์

(ใช้xxd -rเพื่อสร้างไฟล์ต้นฉบับ)

0000000: 693d 606f 6420 2d74 7531 7c63 7574 202d  i=`od -tu1|cut -
0000010: 6339 2d60 0a65 6368 6f20 5034 0a66 6f72  c9-`.echo P4.for
0000020: 2061 2069 6e20 7b30 2e2e 377d 0a64 6f20   a in {0..7}.do 
0000030: 666f 7220 6220 696e 2024 690a 646f 2074  for b in $i.do t
0000040: 6169 6c20 2d32 2024 307c 7a63 6174 7c64  ail -2 $0|zcat|d
0000050: 6420 6273 3d31 2063 6f75 6e74 3d31 2073  d bs=1 count=1 s
0000060: 6b69 703d 2428 2838 2a62 2b61 2929 0a64  kip=$((8*b+a)).d
0000070: 6f6e 650a 646f 6e65 3e38 0a77 6320 2d63  one.done>8.wc -c
0000080: 2038 0a63 6174 2038 0a1f 8b08 0000 0000   8.cat 8........
0000090: 0000 ffed cdb1 0a83 3014 8561 910e 8e8e  ........0..a....
00000a0: 193b dca1 631f 2084 9353 6ba3 a3e0 e2a8  .;..c. ..Sk.....
00000b0: 2fe0 d8e1 22d8 276f 9a50 e813 940e fdb8  /...".'o.P......
00000c0: 70f9 a753 247f 7829 f0b5 b9e2 c718 2322  p..S$.x)......#"
00000d0: 1ba9 e9a8 9688 6895 892a 7007 f0fe 701e  ......h..*p...p.
00000e0: b879 ef48 6e8c aa4f 219c d984 750d 0d91  .y.Hn..O!...u...
00000f0: e9b2 8c63 d779 3fcf c3d0 f76d eb7c e2d2  ...c.y?....m.|..
0000100: 1880 d4d7 4b6e 9296 b065 49ab 75c6 cc92  ....Kn...eI.u...
0000110: 1411 63f6 7de7 3489 9031 847c 3c9a 531d  ..c.}.4..1.|<.S.
0000120: e9a1 aa8f 803e 01                        .....>.

คำอธิบาย

  • odเป็นโปรแกรมยูทิลิตี้ "octal dump" มาตรฐาน -tu1ตัวเลือกที่บอกในการผลิตการถ่ายโอนข้อมูลทศนิยมไบต์แต่ละแทน (วิธีแก้ปัญหาที่เพียงพอสำหรับการขาดทุบตีของ ASC (), อ๊อด () .charCodeAt () อื่น ๆ )
  • P4คือหมายเลขมายากลสำหรับไฟล์ PBM รูปแบบไบนารีซึ่งบรรจุแปดพิกเซลในแต่ละไบต์ (เทียบกับP1ไฟล์ PBM รูปแบบ ASCII) คุณจะเห็นว่าสิ่งนี้พิสูจน์ได้ว่ามีประโยชน์
  • ต่อแถวของผลผลิตสุดท้ายโปรแกรมดึงไบต์แปดพิกเซล (ตรงกับรหัส ASCII และจำนวนบรรทัด) จากส่วนข้อมูล gzip ddบีบอัดที่สิ้นสุดการใช้ ( tail -2 $0แยกสองบรรทัดสุดท้ายของสคริปต์ข้อมูลที่บีบอัดนั้นมีขนาด 0x0a linefeed ไบต์) เกิดขึ้นที่แปดพิกเซลคือความกว้างของอักขระหนึ่งตัว ไบต์ว่างที่เติมช่องว่างระหว่างตัวอักษรที่รองรับนั้นสามารถบีบอัดได้ง่ายเพราะมันเหมือนกันทั้งหมด
  • ทั้งหมดนี้เขียนไปยังไฟล์ชื่อ "8" เนื่องจากมีแปดแถวอย่างแน่นอน (และแปดพิกเซลต่อไบต์) จำนวนไบต์คือความกว้างของเอาต์พุตในหน่วยพิกเซล ความสูงของเอาต์พุตรวมอยู่ในที่wc -cพิมพ์ชื่อไฟล์อินพุต "8" หลังจากนับไบต์
  • เมื่อส่วนหัวเสร็จสมบูรณ์ข้อมูลภาพจะถูกพิมพ์ ทุบตีเพียงสังเกตว่าทั้งสองบรรทัดสุดท้ายไม่ใช่คำสั่งที่ถูกต้อง (อันสุดท้ายไม่ถูกต้องจริง ๆ UTF-8) หลังจากที่มันได้ดำเนินการทุกอย่างมาก่อน
  • ฉันใช้ KZIP เพียงเพื่อบีบอัดส่วนข้อมูลตามที่ Ilmari Karonen ทำเพื่อส่งให้กับความท้าทาย 12 วันแห่งคริสต์มาส ตามที่อธิบายไว้ที่นี่จำเป็นอย่างยิ่งที่จะต้องใช้ตัวแก้ไข hex เพื่อแทนที่รูปแบบส่วนหัว ZIP ด้วยส่วนหัว gzip การรวม CRC-32 และขนาดไฟล์จากส่วนหัว ZIP ต้นฉบับนั้นดูเหมือนจะไม่จำเป็น

2
ทางออกที่ดี (และสั้น) ดีจริงๆ! ในการเขียนสคริปต์การใช้งานของ dd ไม่ควรถือว่า tail และ gzip เป็น imho ภายนอก
ChristopheD

1
ใจเพิ่มคำอธิบายว่ามันทำงานอย่างไร? จะได้รับการชื่นชมมาก
นาย Llama

2
ดีมากขอบคุณมากสำหรับคำอธิบาย อย่างไรก็ตามการใช้รุ่น 'P4' คือไม่ได้จริงๆเคารพสิ่งที่ OP กล่าวว่า "ง่ายมากASCIIสีดำและรูปแบบบิตแมปสีขาว"
eregon

5

Python 2, 248 247 ไบต์

s=raw_input();k=len(s);print"P1",k*8,8
for i in range(k*24):a=s[i/3%k];j=max(".!".find(a)+1,ord(a)-62)*3;print int("00080084IMVAENBSIFERBSUF4UFQQEMVDT4NAP4MNDSI9MRTMRBARA4NBQRAMNBE4E94NURDARDNRDMLD95DSL7"[j:j+3],32)>>(i/3/k*3+i%3)&1," 0"*(i%3/2*5)

ใช้แบบอักษร 3x5 ที่บรรจุในสตริงที่พิมพ์ได้ 3 ไบต์ต่ออักขระ แบบอักษรนั้นอ่านได้ชัดเจนแม้ว่า n จะเป็นตัวพิมพ์เล็กและ v อาจผิดสำหรับ au หากไม่เห็นในบริบท

ขนาดที่แท้จริง:
ขนาดที่แท้จริง

ซูม x3:
ซูม x3

ผลลัพธ์เป็น PBM ชนิด P1 ตามตัวอย่างในการท้าทาย มันเป็นความท้าทายที่สนุก


4

Ruby 1.9, 346 ไบต์ (รหัส 122 และข้อมูล 224 ไบต์)

นี่คือผลลัพธ์:

CODEGOLF

(มันดีใช่มั้ยล่ะ?)

z=0..7;puts"P1\n#{(s=gets).size*8} 8",z.map{|i|s.bytes.flat_map{|o|z.map{|j|'DATA'.unpack('Q<*')[o>64?o-63:o/46][i*8+j]}}*' '}

แบบอักษรถูกสร้างโดยfiglet -f banner -w 1000 $LETTERSและสคริปต์นี้นี้

ทำงานด้วย echo -n 'CODEGOLF.STACKEXCHANGE.COM!' | ruby script.rb > image.pbmทำงานด้วย

สคริปต์สร้างแถวทั้งหมดและพิมพ์เพียงแถวเดียว

นี่คือ hexdump (ใช้xxd -r):

0000000: 7a3d 302e 2e37 3b70 7574 7322 5031 5c6e  z=0..7;puts"P1\n
0000010: 237b 2873 3d67 6574 7329 2e73 697a 652a  #{(s=gets).size*
0000020: 387d 2038 222c 7a2e 6d61 707b 7c69 7c73  8} 8",z.map{|i|s
0000030: 2e62 7974 6573 2e66 6c61 745f 6d61 707b  .bytes.flat_map{
0000040: 7c6f 7c7a 2e6d 6170 7b7c 6a7c 271c 1c1c  |o|z.map{|j|'...
0000050: 0800 1c1c 0000 0000 001c 1c1c 0008 1422  ..............."
0000060: 417f 4141 003f 4141 3f41 413f 003e 4101  A.AA.?AA?AA?.>A.
0000070: 0101 413e 003f 4141 4141 413f 007f 0101  ..A>.?AAAAA?....
0000080: 1f01 017f 007f 0101 1f01 0101 003e 4101  .............>A.
0000090: 7941 413e 0041 4141 7f41 4141 001c 0808  yAA>.AAA.AAA....
00000a0: 0808 081c 0040 4040 4041 413e 0042 2212  .....@@@@AA>.B".
00000b0: 0e12 2242 0001 0101 0101 017f 0041 6355  .."B.........AcU
00000c0: 4941 4141 0041 4345 4951 6141 007f 4141  IAAA.ACEIQaA..AA
00000d0: 4141 417f 003f 4141 3f01 0101 003e 4141  AAA..?AA?....>AA
00000e0: 4151 215e 003f 4141 3f11 2141 003e 4101  AQ!^.?AA?.!A.>A.
00000f0: 3e40 413e 007f 0808 0808 0808 0041 4141  >@A>.........AAA
0000100: 4141 413e 0041 4141 4122 1408 0041 4949  AAA>.AAAA"...AII
0000110: 4949 4936 0041 2214 0814 2241 0041 2214  III6.A"..."A.A".
0000120: 0808 0808 007f 2010 0804 027f 0027 2e75  ...... ......'.u
0000130: 6e70 6163 6b28 2751 3c2a 2729 5b6f 3e36  npack('Q<*')[o>6
0000140: 343f 6f2d 3633 3a6f 2f34 365d 5b69 2a38  4?o-63:o/46][i*8
0000150: 2b6a 5d7d 7d2a 2720 277d                 +j]}}*' '}

ใช้รหัส 93 ไบต์เมื่อใช้ goruby:

ps"P1\n#{(s=gt).sz*8} 8",8.mp{|i|s.y.fl{|o|8.mp{|j|'DATA'.ua('Q<*')[o>64?o-63:o/46][i*8+j]}}*' '}

การใช้ ZLib ตัดขนาดข้อมูลเป็น 142 ไบต์แทน 224 แต่เพิ่ม 43 ไบต์ในรหัสดังนั้น 307 ไบต์:

#coding:binary
require'zlib';z=0..7;puts"P1\n#{(s=gets).size*8} 8",z.map{|i|s.bytes.flat_map{|o|z.map{|j|Zlib.inflate("DATA").unpack('Q<*')[o>64?o-63:o/46][i*8+j]}}*' '}

ซึ่งจะให้ทั้งหมด 268 เมื่อใช้ goruby:

#coding:binary
rq'zlib';ps"P1\n#{(s=gt).sz*8} 8",8.mp{|i|s.y.fl{|o|8.mp{|j|Zlib.if("DATA").ua('Q<*')[o>64?o-63:o/46][i*8+j]}}*' '}

2

Java 862 826:

นี่คือวิธีการที่แตกต่างกัน ฉันคิดว่า 'awt' ไม่นับเป็น lib ภายนอก

import java.awt.*;
class B extends Frame{String s="ABCDEFGHIJKLMNOPQRSTUVWXYZ .!";int l=29;static Robot r;int[][][]m=new int[l][8][8];
public void paint(Graphics g){for(int y=0;y<8;++y){int py=(y<3)?y:y+1;for(int a=0;a<l;++a)
for(int x=0;x<8;++x)
m[a][x][y]=(r.getPixelColor(8*a+x+17+x/4,py+81)).getRGB()<-1?1:0;}
System.out.println("P1\n"+(getTitle().length()*8)+" 8");
for(int y=0;y<8;++y){for(char c:getTitle().toCharArray()){int a=s.indexOf(c);
for(int x=0;x<8;++x)System.out.print(m[a][x][y]);}
System.out.println();}
System.exit(0);}
public B(String p){super(p);
setBackground(Color.WHITE);
setSize(400,60);
Label l=new Label(s);
l.setFont(new Font("Monospaced",Font.PLAIN,13));
add(l);
setLocation(9,49);    
setVisible(true);}    
public static void main(String a[])throws Exception{r=new Robot();    
new B(a[0]);}}

และไม่ดี

import java.awt.*;

class PBM extends Frame
{
    String s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ .!";
    int l=29;
    Robot robot;
    int[][][] map = new int[l][8][8];

    static boolean init = false;

    public void paint (Graphics g)
    {    
        for (int y = 0; y < 8; ++y)    
        {    
            int py = (y < 3) ? y : y +1;    
            for (int a = 0; a < l; ++a)
            {    
                for (int x = 0; x < 8; ++x)    
                {    
                    map[a][x][y] = (robot.getPixelColor (8*a+x+17+x/4, py+81)).getRGB () < -1 ? 1 : 0;    
                }    
            }    
        }

        System.out.println("P1\n"+(getTitle().length()*8)+" 8");

        for (int y = 0; y < 8; ++y) {    
            for (char c : getTitle ().toCharArray ()) {    
                int a = s.indexOf (c);    
                for (int x = 0; x < 8; ++x) {    
                    System.out.print (map[a][x][y]);    
                }
            }
            System.out.println ();
        }
        System.exit (0);
    }   

    public PBM (String p) throws Exception    
    {    
        super (p);    
        robot = new Robot ();    
        setBackground (Color.WHITE);    
        setSize (400, 60);    
        Label l=new Label(s);    
        l.setFont (new Font ("Monospaced", Font.PLAIN, 13));
        add(l);
        setLocation (9,49);
        setVisible (true);
    }

    public static void main (String args[]) throws Exception
    {
        new PBM (args[0]);
    }    
}

Robot เป็นวิธีการที่แปลกประหลาดของ Java ที่จะเรียกใช้ getPixel ฉันสร้างป้ายกำกับที่มีตัวอักษรและวัดว่าแต่ละพิกเซลมีจุดใด

ในวิธีการทาสีint py = (y < 3) ? y : y +1;และ(8*a+x+17+x/4, py+81)เป็นวิธีที่ซับซ้อนในการปรับตำแหน่งในแบบอักษร Huuuh! มิฉะนั้นจะต้องมี 9 บรรทัดและทุกตัวอักษรตัวที่ 4 จะมีพิกเซลเพิ่มเติมในแนวนอน การทดลองและข้อผิดพลาดนำฉันมาที่โซลูชันนี้

จากนั้นจึงเขียนส่วนหัวของ PBM และแต่ละบรรทัดของข้อความ ข้อความถูกส่งผ่านเป็นหัวเรื่องของเฟรม

แค่นั้นแหละ. ไม่ใช่รหัสที่สั้นที่สุด แต่ไม่จำเป็นต้องวาดภาพตัวอักษรด้วยตนเอง

อาจจะสั้นลงใน BeanShell หรือ Scala

และตอนนี้ - มันมีลักษณะอย่างไร

java B "JAVA.CAFE BABE" > jcb.pbm

ใช้การซูมหลายครั้ง: java.cafe Babe PNG

Unzoomed: java.cafe Babe JPG

ไม่ว่าจำนวนตัวอักษรคือจำนวนตัวอักษรจากสารละลาย Perl ที่สับ

(golfed เพิ่มเติมเล็กน้อยทำหุ่นยนต์คงที่ซึ่งหลีกเลี่ยงการประกาศยกเว้นหนึ่ง)


วิธีดั้งเดิมทำได้ดีมาก!
ChristopheD

1
+1 สำหรับความคิดริเริ่ม แต่ eww ... หากคุณกำลังจะขยายบิตแมปให้ใช้การแก้ไขเพื่อนบ้านที่ใกล้ที่สุด
Ilmari Karonen

ฉันใช้eog(Eye of Gnome) และสกรีนช็อต ฉันจะอัปโหลดเวอร์ชันที่ไม่มีการปรับjpgสัดส่วน บางทีเบราว์เซอร์ของคุณอาจใช้การแก้ไขเพื่อนบ้านที่ใกล้ที่สุด :)
ผู้ใช้ที่ไม่รู้จัก

1

C ++ มากเกินไปที่จะชนะ

ฉันเขียนโปรแกรมวาด PPM ที่มีคุณลักษณะเต็มรูปแบบใน C ++ ด้วยตัวอักษรบิตแมปของฉันเอง แม้ว่าการแยกฟังก์ชั่นที่ไม่จำเป็นออกทั้งหมดนั้นยังคงมีขนาดใหญ่เมื่อเทียบกับคำตอบที่นี่เนื่องจากคำจำกัดความของแบบอักษร

อย่างไรก็ตามนี่คือผลลัพธ์สำหรับ HELLO WORLD: ป้อนคำอธิบายรูปภาพที่นี่

และรหัส:

ppmdraw.h

#ifndef PPMDRAW_H
#define PPMDRAW_H

#include <fstream>
#include <sstream>
#include <map>
#include <bitset>
#include <vector>

struct pixel{
    unsigned char r;
    unsigned char g;
    unsigned char b;

    bool equals(pixel p){
        return (r == p.r && g == p.g && b == p.b);
    }
};

class PPMDraw
{
    public:
        PPMDraw(int w, int h);

        virtual ~PPMDraw();

        void fill(unsigned char r, unsigned char g, unsigned char b);

        void set_color(unsigned char r, unsigned char g, unsigned char b);

        void draw_point(int x, int y);

        void draw_char(int x, int y, char c);
        void draw_string(int x, int y, std::string text);

        bool save(std::string file);

    private:

        int width;
        int height;

        pixel * image;

        std::vector<bool> checked;

        unsigned char red;
        unsigned char green;
        unsigned char blue;

        void init_alpha();
        std::map<char, std::bitset<48> > font;

};

#endif // PPMDRAW_H

ppmdraw.cpp

#include "PPMDraw.h"
#include <fstream>
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <cmath>
#include <map>
#include <bitset>
#include <vector>

// standard constructor
PPMDraw::PPMDraw(int w, int h){
    width = w;
    height = h;

    // make an array to hold all the pixels, r, g, b for each
    image = new pixel[width * height];

    // a bitset to use for functions that have to check which pixels have been worked on
    checked = std::vector<bool>();
    for(int i = 0; i < width * height; i++){
        checked.push_back(false);
    }

    init_alpha();
}


PPMDraw::~PPMDraw(){
    if(image != nullptr){
        delete[] image;
    }
}



void PPMDraw::fill(unsigned char r, unsigned char g, unsigned char b){
    for(int i = 0; i < width * height; i++){
        image[i + 0] = pixel{r, g, b};
    }
}

void PPMDraw::set_color(unsigned char r, unsigned char g, unsigned char b){
    red = r;
    green = g;
    blue = b;
}

void PPMDraw::draw_point(int x, int y){
    if(x >= 0 && x < width && y >= 0 && y < height){
        image[y * width + x] = pixel{red, green, blue};
    }
}

void PPMDraw::draw_char(int x, int y, char c){
    std::bitset<48> letter = font[c];
    int n = 47;
    for(int i = 0; i < 6; i++){
        for(int j = 0; j < 8; j++){
            if(letter[n]){
                draw_point(x + i, y + j);
            }
            n--;
        }
    }
}
void PPMDraw::draw_string(int x, int y, std::string text){
        for(unsigned int i = 0; i < text.length(); i++){
            draw_char(x + 6 * i, y, text[i]);
        }

}



bool PPMDraw::save(std::string file){
    std::ofstream save(file.c_str(), std::ios_base::out | std::ios_base::binary);
    if(save.is_open()){
        save << "P6" << std::endl;
        save << width << " " << height << std::endl;
        save << "255" << std::endl;
        unsigned char * temp = new unsigned char[height * width * 3];
        for(int i  = 0; i < height * width; i++){
            temp[i * 3 + 0] = image[i].r;
            temp[i * 3 + 1] = image[i].g;
            temp[i * 3 + 2] = image[i].b;
        }
        save.write(reinterpret_cast<const char *> (temp), height*width*3*sizeof(unsigned char));
        delete temp;
        save.close();
        return true;
    }else{
        return false;
    }


}

void PPMDraw::init_alpha(){
    // Define a simple font for drawing text
    font[' '] = std::bitset<48>  (std::string("000000000000000000000000000000000000000000000000"));
    font['!'] = std::bitset<48>  (std::string("000000000000000011110110000000000000000000000000"));
    font['"'] = std::bitset<48>  (std::string("000000001100000000000000110000000000000000000000"));
    font['#'] = std::bitset<48>  (std::string("001010001111111000101000111111100010100000000000"));
    font['$'] = std::bitset<48>  (std::string("001001000101010011111110010101000100100000000000"));
    font['%'] = std::bitset<48>  (std::string("000000100100110000010000011000001000010000000000"));
    font['&'] = std::bitset<48>  (std::string("000111001110001010110010110011000000001000000000"));
    font['\\'] = std::bitset<48>  (std::string("100000000110000000010000000011000000001000000000"));
    font['('] = std::bitset<48>  (std::string("000000000000000001111100100000100000000000000000"));
    font[')'] = std::bitset<48>  (std::string("000000001000001001111100000000000000000000000000"));
    font['*'] = std::bitset<48>  (std::string("010010000011000011100000001100000100100000000000"));
    font['+'] = std::bitset<48>  (std::string("000100000001000001111100000100000001000000000000"));
    font[','] = std::bitset<48>  (std::string("000000000000000000000110000000000000000000000000"));
    font['-'] = std::bitset<48>  (std::string("000100000001000000010000000100000001000000000000"));
    font['.'] = std::bitset<48>  (std::string("000000000000000000000100000000000000000000000000"));
    font['/'] = std::bitset<48>  (std::string("000000100000110000010000011000001000000000000000"));
    font['0'] = std::bitset<48>  (std::string("011111001000001010000010100000100111110000000000"));
    font['1'] = std::bitset<48>  (std::string("000000001000001011111110000000100000000000000000"));
    font['2'] = std::bitset<48>  (std::string("010011101001001010010010100100100111001000000000"));
    font['3'] = std::bitset<48>  (std::string("010001001000001010000010100100100110110000000000"));
    font['4'] = std::bitset<48>  (std::string("111100000001000000010000000100001111111000000000"));
    font['5'] = std::bitset<48>  (std::string("111001001001001010010010100100101001110000000000"));
    font['6'] = std::bitset<48>  (std::string("011111001001001010010010100100101000110000000000"));
    font['7'] = std::bitset<48>  (std::string("100000001000000010000110100110001110000000000000"));
    font['8'] = std::bitset<48>  (std::string("011011001001001010010010100100100110110000000000"));
    font['9'] = std::bitset<48>  (std::string("011000001001000010010000100100000111111000000000"));
    font[':'] = std::bitset<48>  (std::string("000000000000000001000100000000000000000000000000"));
    font[';'] = std::bitset<48>  (std::string("000000000000000001000110000000000000000000000000"));
    font['<'] = std::bitset<48>  (std::string("000000000001000000101000010001000000000000000000"));
    font['='] = std::bitset<48>  (std::string("001010000010100000101000001010000000000000000000"));
    font['>'] = std::bitset<48>  (std::string("000000000100010000101000000100000000000000000000"));
    font['?'] = std::bitset<48>  (std::string("010000001000000010001010100100000110000000000000"));
    font['@'] = std::bitset<48>  (std::string("011111001000001010111010101010100111001000000000"));
    font['A'] = std::bitset<48>  (std::string("011111101001000010010000100100000111111000000000"));
    font['B'] = std::bitset<48>  (std::string("111111101001001010010010100100100110110000000000"));
    font['C'] = std::bitset<48>  (std::string("011111001000001010000010100000100100010000000000"));
    font['D'] = std::bitset<48>  (std::string("111111101000001010000010100000100111110000000000"));
    font['E'] = std::bitset<48>  (std::string("111111101001001010010010100100101000001000000000"));
    font['F'] = std::bitset<48>  (std::string("111111101001000010010000100100001000000000000000"));
    font['G'] = std::bitset<48>  (std::string("011111001000001010000010100010100100110000000000"));
    font['H'] = std::bitset<48>  (std::string("111111100001000000010000000100001111111000000000"));
    font['I'] = std::bitset<48>  (std::string("100000101000001011111110100000101000001000000000"));
    font['J'] = std::bitset<48>  (std::string("000011000000001000000010000000101111110000000000"));
    font['K'] = std::bitset<48>  (std::string("111111100001000000010000001010001100011000000000"));
    font['L'] = std::bitset<48>  (std::string("111111100000001000000010000000100000001000000000"));
    font['M'] = std::bitset<48>  (std::string("111111101000000001100000100000001111111000000000"));
    font['N'] = std::bitset<48>  (std::string("111111100100000000100000000100001111111000000000"));
    font['O'] = std::bitset<48>  (std::string("011111001000001010000010100000100111110000000000"));
    font['P'] = std::bitset<48>  (std::string("111111101001000010010000100100001111000000000000"));
    font['Q'] = std::bitset<48>  (std::string("011111001000001010001010100001000111101000000000"));
    font['R'] = std::bitset<48>  (std::string("111111101001000010010000100110001111011000000000"));
    font['S'] = std::bitset<48>  (std::string("011000101001001010010010100100101000110000000000"));
    font['T'] = std::bitset<48>  (std::string("100000001000000011111110100000001000000000000000"));
    font['U'] = std::bitset<48>  (std::string("111111000000001000000010000000101111110000000000"));
    font['V'] = std::bitset<48>  (std::string("111110000000010000000010000001001111100000000000"));
    font['W'] = std::bitset<48>  (std::string("111111100000001000001100000000101111111000000000"));
    font['X'] = std::bitset<48>  (std::string("110001100010100000010000001010001100011000000000"));
    font['Y'] = std::bitset<48>  (std::string("110000000010000000011110001000001100000000000000"));
    font['Z'] = std::bitset<48>  (std::string("100001101000101010010010101000101100001000000000"));
    font['['] = std::bitset<48>  (std::string("000000001111111010000010100000100000000000000000"));
    font['\''] = std::bitset<48>  (std::string("100000000110000000010000000011000000001000000000"));
    font[']'] = std::bitset<48>  (std::string("000000001000001010000010111111100000000000000000"));
    font['^'] = std::bitset<48>  (std::string("001000000100000010000000010000000010000000000000"));
    font['_'] = std::bitset<48>  (std::string("000000100000001000000010000000100000001000000000"));
    font['`'] = std::bitset<48>  (std::string("000000001000000001000000000000000000000000000000"));
    font['a'] = std::bitset<48>  (std::string("000001000010101000101010001010100001111000000000"));
    font['b'] = std::bitset<48>  (std::string("111111100001001000010010000100100000110000000000"));
    font['c'] = std::bitset<48>  (std::string("000111000010001000100010001000100001010000000000"));
    font['d'] = std::bitset<48>  (std::string("000011000001001000010010000100101111111000000000"));
    font['e'] = std::bitset<48>  (std::string("000111000010101000101010001010100001101000000000"));
    font['f'] = std::bitset<48>  (std::string("000100000111111010010000100100000000000000000000"));
    font['g'] = std::bitset<48>  (std::string("001100100100100101001001010010010011111000000000"));
    font['h'] = std::bitset<48>  (std::string("111111100001000000010000000100000000111000000000"));
    font['i'] = std::bitset<48>  (std::string("000000000000000001011110000000000000000000000000"));
    font['j'] = std::bitset<48>  (std::string("000000100000000100000001010111100000000000000000"));
    font['k'] = std::bitset<48>  (std::string("111111100000100000010100001000100000000000000000"));
    font['l'] = std::bitset<48>  (std::string("000000000000000011111110000000000000000000000000"));
    font['m'] = std::bitset<48>  (std::string("000111100001000000001000000100000001111000000000"));
    font['n'] = std::bitset<48>  (std::string("001111100001000000010000000100000001111000000000"));
    font['o'] = std::bitset<48>  (std::string("000111000010001000100010001000100001110000000000"));
    font['p'] = std::bitset<48>  (std::string("001111110010010000100100001001000001100000000000"));
    font['q'] = std::bitset<48>  (std::string("000110000010010000100100001001000011111100000000"));
    font['r'] = std::bitset<48>  (std::string("000000000011111000010000000100000000000000000000"));
    font['s'] = std::bitset<48>  (std::string("000000000001001000101010001010100010010000000000"));
    font['t'] = std::bitset<48>  (std::string("000000000010000011111110001000000000000000000000"));
    font['u'] = std::bitset<48>  (std::string("000111000000001000000010000000100001110000000000"));
    font['v'] = std::bitset<48>  (std::string("000110000000010000000010000001000001100000000000"));
    font['w'] = std::bitset<48>  (std::string("000111100000001000000100000000100001111000000000"));
    font['x'] = std::bitset<48>  (std::string("001000100001010000001000000101000010001000000000"));
    font['y'] = std::bitset<48>  (std::string("001100000000100000000111000010000011000000000000"));
    font['z'] = std::bitset<48>  (std::string("010001100100101001010010011000100000000000000000"));
    font['{'] = std::bitset<48>  (std::string("000000000000000001101100100100100000000000000000"));
    font['|'] = std::bitset<48>  (std::string("000000000000000011111110000000000000000000000000"));
    font['}'] = std::bitset<48>  (std::string("000000000000000010010010011011000000000000000000"));
    font['~'] = std::bitset<48>  (std::string("000100000010000000010000000010000001000000000000"));
}

main.cpp

#include "PPMDraw.h"
#include <iostream>

int main(){
    // ask for input
    std::string input;
    std::cout << "ENTER YOUR TEXT" << std::endl;
    getline(std::cin, input);
   // get size for image
  int width = input.size() * 6;
   PPMDraw image = PPMDraw(width, 8);
   image.fill(255, 255, 255);
   image.set_color(0, 0, 0);
   image.draw_string(0, 0, input);
   image.save("text.ppm");
}

Makefile

CC = g++
CFLAGS = -Wall -c -std=c++11
LFLAGS = -Wall
OBJS = main.o PPMDraw.o

list: $(OBJS)
    $(CC) $(LFLAGS) $(OBJS) -o text2ppm

main.o: PPMDraw.h
    $(CC) $(CFLAGS) main.cpp

PPMDraw.o: PPMDraw.h
    $(CC) $(CFLAGS) PPMDraw.cpp

clean:
    rm *.o main

หากคุณสนใจห้องสมุด PPMDraw เต็มรูปแบบอยู่ที่นี่ :


1
ฉันพบว่าแบบอักษรของคุณมีประโยชน์มาก!
ลุดวิ

1

SmileBASIC ขนาด 231 ไบต์

LINPUT C$?"P1
?8,LEN(C$)*8WHILE""<C$A=ASC(SHIFT(C$))D=ASC("*N.JZ`;O:²ÞøäüÄho"[A-65+12*(A<34)+47*(A<47)])FOR I=0TO 4B$=BIN$(VAL("7535712074617252"[D>>5<<1OR 1AND D>>I]),8)WHILE""<B$?POP(B$),
WEND?NEXT?"0 "*24WEND

ป้อนคำอธิบายรูปภาพที่นี่

อักขระแต่ละตัวมีรูปแบบแถวที่แตกต่างกันเพียง 2 รูปแบบโดยเลือกจาก "ชุดสี" จำนวน 8 ชุด ข้อมูลสำหรับแต่ละสัญลักษณ์จะถูกเก็บไว้ใน 1 ไบต์โดยมีการจัดเก็บจานสีแยกต่างหาก

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.