คุณไม่พบหรือว่าการอ่านข้อความธรรมดา ๆ นั้นไม่น่าดึงดูดเพียงพอ? ลองของเรา

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

แฟนซีมากกว่านั้นใช่ไหม? แต่มันค่อนข้างยาวในการเขียนด้วยมือมันจะยอดเยี่ยมถ้ามีคนทำโปรแกรมที่ทำเพื่อฉัน!

งานของคุณถ้าคุณอาสาช่วยฉันจะเขียนโปรแกรมหรือฟังก์ชั่นที่รับสายที่บรรจุ[a-zA-Z\s\n]เท่านั้นและเอาท์พุท (หรือคืน) การเขียน ascii ของมัน!

คุณต้องใช้ตัวอักษรต่อไปนี้เพื่อจัดรูปแบบผลลัพธ์ของคุณ:

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

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

พื้นที่:

     |
     | it's a 5x5 square of spaces
     | but had to pad it with |s to make it appear in this post
     |
     |

เนื่องจากนี่เป็นแบบอักษรที่มีความกว้างคงที่อักขระเว้นวรรคจึงล้อมรอบด้วยช่องว่างทำให้เกิดช่องว่าง 7 ความกว้างระหว่างตัวอักษรสองตัว

a b
     1234567       -- these numbers are just for the example, you don't have to output them
#####       #### 
#   #       #   #
#####       ####
#   #       #   #
#   #       ####

a  b
     1234567890123
#####             #### 
#   #             #   #
#####             ####
#   #             #   #
#   #             ####

เมื่อคุณพบบรรทัดใหม่เช่นเดียวกับในอินพุต

ascii
text

เพียงตรวจสอบให้แน่ใจว่าได้แยกข้อความสองบล็อกด้วยบรรทัดว่างอย่างน้อยหนึ่งบรรทัด

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

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

นอกจากนี้คุณยังได้รับอนุญาตให้แทนที่#s ด้วยอักขระอื่นตราบเท่าที่อยู่ในช่วง ASCII ที่พิมพ์ได้และไม่ใช่ช่องว่าง ตัวอย่างเช่นคุณสามารถใช้As สำหรับตัวอักษร A Bสำหรับตัวอักษร B และอื่น ๆ

เนื่องจากนี่คือโคด- กอล์ฟ (และยิ่งกว่านั้นคือ kolmogorov-complex ) การส่งที่ชนะจะเป็นสิ่งที่แก้ปัญหานี้ได้อย่างน้อยไบต์ที่เป็นไปได้ขอให้สนุก!

Python 3, 375 ไบต์

f=lambda i:"\n\n".join("\n".join(map(" ".join,zip(*[[x.replace("0"," ")[a*5:a*5+5]for a in range(5)]for x in[["{:025b}".format(int(c,36))for c in'0 JPCFL J2UKE 92Y3Y J2KAM JOMCF JOMC0 92B72 AYP81 JFM3J JFMHO AZC7M AB6ZJ B5I5T B43N5 92YWE J2UJ4 92YY7 J2UQC 926UM JFM2S AYE5Q AY8G4 AYHKH AT6Q9 AT6KK AWU7'.split()][x!=" "and ord(x)-64]for x in j.upper()]])))for j in i.split("\n"))

ดูรหัสนี้ทำงานบน ideone.com

รหัสเดียวกัน แต่อย่างใดเยื้องอย่างรูปแบบและแสดงความคิดเห็น:

f = lambda i: \

    # join multiline strings together using an empty line as separator:
    "\n\n".join(

        # join the string lines of one big output line together: 
        "\n".join(

            # join the corresponding rows of the letters together using " ":
            map(" ".join, zip(*

                # make a list (output line) of list (output characters) 
                # of strings (single character's rows):
                [

                    # replace 0s with spaces and split the bit strings into
                    # chunks of 5 characters - the rows of each letter:
                    [x.replace("0", " ")[a*5 : a*5+5] for a in range(5)]

                    for x in [

                        # split the space separated character codes and
                        # convert them from base 36 to 
                        # base 2 strings of length 25:
                        ["{:025b}".format(int(c, 36)) for c in

                         # the encoded font data (reformatted):
                         '0 JPCFL J2UKE 92Y3Y J2KAM JOMCF JOMC0 92B72 '
                         'AYP81 JFM3J JFMHO AZC7M AB6ZJ B5I5T B43N5 92YWE '
                         'J2UJ4 92YY7 J2UQC 926UM JFM2S AYE5Q AY8G4 AYHKH '
                         'AT6Q9 AT6KK AWU7'.split()]

                        # select element 0 if we want a space, else find
                        # out the index from the ASCII code of the letter:
                        [x != " " and ord(x) - 64] 

                        # repeat for every character in the input line:
                        for x in j.upper()
                    ]
                ]
            ))

        # repeat for every line in the input
        ) for j in i.split("\n")
    )

ฉันยังตัดสินใจที่จะเข้ารหัส36 ฐานเพราะนั่นเป็นฐานที่สนับสนุน Python ในตัวint()สูงสุด ต่อไปนี้เป็นสคริปต์ Python 3 สั้น ๆ ที่ฉันเขียน (ไม่ได้เขียน) ที่แปลงนิยามแบบอักษรเหมือนในคำถามเป็นรหัส 36 ฐาน: ตัวแปลงของฉันบน ideone.com

ผลลัพธ์ประกอบด้วยอักขระ1เป็นพิกเซลที่เปิดใช้งานและช่องว่างเป็นพิกเซลที่ปิดใช้งาน นี่คือตัวอย่างการเรียกใช้:

อินพุต (ตัวแบ่งบรรทัดเป็น\n):

Hello World
Python rocks

เอาท์พุท:

1   1 11111 1     1      111        1   1  111  1111  1     1111 
1   1 1     1     1     1   1       1   1 1   1 1   1 1     1   1
11111 1111  1     1     1   1       1 1 1 1   1 1111  1     1   1
1   1 1     1     1     1   1       11 11 1   1 11    1     1   1
1   1 11111 11111 11111  111        1   1  111  1 1   11111 1111 

1111  1   1 11111 1   1  111  1   1       1111   111   111  1   1  111 
1   1  1 1    1   1   1 1   1 11  1       1   1 1   1 1   1 1  1  1    
1111    1     1   11111 1   1 1 1 1       1111  1   1 1     111    111 
1       1     1   1   1 1   1 1  11       11    1   1 1   1 1 1       1
1       1     1   1   1  111  1   1       1 1    111   111  1  1   111 

Clojure 552 ไบต์

(defn t[s](print(reduce #(str %1"\n"%2)(map #(apply str %)(let[a[:jpcfl :j2uke :92y3y :j2kam :jomcf :jomc0 :92b72 :ayp81 :jfm3j :jfmho :azc7m :ab6zj :b5i5t :b43n5 :92ywe :j2uj4 :92yy7 :j2uqc :926um :jfm2s :aye5q :ay8g4 :ayhkh :at6q9 :at6kk :je7mn :0]](map(fn[o](map #(str(.replace %"0"" ")"\n")(map(fn[w](reduce #(str %1(.substring %2 w(+ w 5))"0")""(map #(str(apply str(repeat(- 25(count %))"0"))%)(map #(Integer/toString(Integer/valueOf(name %)36)2)(map a(map #(if(= % \space)26(-(int %)97))(.toLowerCase o)))))))(range 0 25 5))))(.split s"\n")))))))

ตัวอักษรแต่ละตัวใน ascii จะแสดงเป็นสตริงเลขฐานสองที่มี # - 1 ช่องว่าง - 0 จากนั้นจะถูกแปลงเป็นฐาน 36 เพื่อที่จะใช้เวลาเพียง 5 ตัวอักษรในการจัดเก็บ + ":" เพื่อให้ Clojure ทราบว่าควรถือว่าเป็นสัญลักษณ์ จากนั้นอินพุตจะถูกแยกด้วยสัญลักษณ์ขึ้นบรรทัดใหม่และสำหรับแต่ละบรรทัดเราแปลงตัวอักษรใน 36 ฐานกลับไปเป็นฐานสองและรับสัญลักษณ์ [0: 5] แรกเพิ่มสัญลักษณ์ขึ้นบรรทัดใหม่รับสัญลักษณ์ [5:10] ต่อไปเรื่อย ๆ

คุณสามารถเห็นมันทำงานที่นี่ - https://ideone.com/y99ST5

SOGL , 137 ไบต์ (ไม่ใช่การแข่งขัน)

 °f`7-π⅛χ%sΤ↕ņLRΕ⅓9׀b∫rr(¶æKGTΧ3;■ΦΤg¼⁰¡Νg‽}○eΧ²Y∫Οαν⌡l′}¾(8╔ <%╤∙i.d↔ū∫Æo┌jyŗ▲δ⁶=╗$↑yōΛ3h¼╔◄┼)‘’«n.{5{ø}¹,uR{8+:Ahwha’#=?X’«@*}┼L@*┼}pøO

คำอธิบาย:

...‘’«n.{5{ø}¹,uR{8+:Ahwha’#=?X’«@*}┼L@*┼}pøO
...‘                                           push a string with the letter data                            ["..."]
    ’«n                                        split in lengths of 25                                        [[".", ".", ".",...]]
       .{                                      repeat input times                                            [[".", ".", ".",...]]
         5{ø}                                  push 5 empty strings                                          [[".", ".", ".",...], "", "", "", "", ""]
             ¹                                 wrap those in an array                                        [[".", ".", ".",...], ["", "", "", "", ""]]
              ,                                get a string input                                            [[".", ".", ".",...], ["", "", "", "", ""], "Hello World"]
               u                               lowercase it                                                  [[".", ".", ".",...], ["", "", "", "", ""], "hello world"]
                R{                       }     itirate over the ordinals of the string                       [[".", ".", ".",...], ["", "", "", "", ""], 104]
                  8+                           add 8 to the ordinal                                          [[".", ".", ".",...], ["", "", "", "", ""], 112]
                    :A                         save on variable A                                            [[".", ".", ".",...], ["", "", "", "", ""], 112]
                      h                        swap 2 items one below the stack                              [["", "", "", "", ""], [".", ".", ".",...], 112]
                       w                       get the ord+8th item of the letter data array (modulo length) [["", "", "", "", ""], [".", ".", ".",...], "-----  -    -    -  -----"]
                        h                      swap 2 items one below the stack                              [[".", ".", ".",...], ["", "", "", "", ""], "-----  -    -    -  -----"]
                         a                     load the variable A                                           [[".", ".", ".",...], ["", "", "", "", ""], "-----  -    -    -  -----", 112]
                          ’#=?     }           if equals to 40 then                                          [[".", ".", ".",...], ["", "", "", "", ""], "----- -     -     - -----"] (temporalily switching to space case; it incorrectly picks "N" for space) 
                              X                delete the string                                             [[".", ".", ".",...], ["", "", "", "", ""]]
                               ’«@*            push a string with 25 spaces                                  [[".", ".", ".",...], ["", "", "", "", ""], "                         "]
                                    ┼          add the string vertically-then-horizontally to the array      [[".", ".", ".",...], ["", "", "", "", ""], ["-   -", "-   -", "-----", "-   -", "-   -"]] (back to "H")
                                     L@*       push a string with 10 spaces                                  [[".", ".", ".",...], ["", "", "", "", ""], ["-   -", "-   -", "-----", "-   -", "-   -"], "          "]
                                        ┼      add the string vertically-then-horizontally to the array      [[".", ".", ".",...], ["", "", "", "", ""], ["-   -  ", "-   -  ", "-----  ", "-   -  ", "-   -  "]]
                                          p    output the resulted line                                      [[".", ".", ".",...], ["", "", "", "", ""]]
                                           øO  append to output an empty line                                

หมายเหตุ: ขณะนี้ภาษานี้ไม่สามารถรับสายป้อนหลายบรรทัดได้ดังนั้นฉันจึงขอหมายเลขและอ่านบรรทัด x ถัดไปเป็นอินพุต

สตริงแรกคือ

"------ -  - -  - -  ----------- - -- - -- - - - -  --- -   --   --   - - - ------   --   --   - --- ------ - -- - -- - --   ------- -  - -  - -  -     --- -   --   -- - -  -- -----  -    -    -  ------   --   -------   --   --  ---   -------    -    -----  -    --  -  --    -----    -    -    -    ------ -     -   -   ---------- -     -     - ----- --- -   --   --   - --- ------ -  - -  - -   -    --- -   --   --  -- ---------- -- - - -- -   -    -   - - -- - -- - -   - -    -    ------    -    ----     -    -    ----- --     --     -  -- --   -----   -   -     - ------   - - -   -   - - -   --     -     --- -   -    -   --  --- - ---  --   -"

บีบอัดโดยใช้พจนานุกรมที่กำหนดเองที่ใช้ "" และ "-" (การบีบอัดมีโหมดพิเศษที่มี "\ n - | / _" เพื่อการบีบอัดที่มากยิ่งขึ้น!)
มันมี 25 ตัวอักษรต่อ ascii ถ่านตามลำดับตัวอักษร พวกเขาถูกสั่งจากบนลงล่างขวา
ตัวอักษรไปเหมือน

16b
27c
38d . . .
49e
5af

และนั่นเป็นวิธีเดียวกับที่┼เพิ่มเข้าไปในอาร์เรย์

Powershell, 261 253 ไบต์

$args-split'
'|%{$s=$_
0..5|%{$l=$_
-join($s|% *per|% t*y|%{$c='_ONO__NQ__QAQQNONON_QQQQQ?QQQQAAAQDDIA[SQQQQADQQQJJ(_OAQOOY_DDGAUUQOQONDQJUDD$QQQQAAQQDEEAQYQAYCPDQJ[JD"QONO_ANQ_GI_QQNA^ENDNDQQD?'[$l*26+$_-65+222*!($_-32)]
0..5|%{' #'[(+$c-shr$_)%2]}})}}

สคริปต์ทดสอบ:

$f = {

$args-split'
'|%{$s=$_
0..5|%{$l=$_
-join($s|% *per|% t*y|%{$c='_ONO__NQ__QAQQNONON_QQQQQ?QQQQAAAQDDIA[SQQQQADQQQJJ(_OAQOOY_DDGAUUQOQONDQJUDD$QQQQAAQQDEEAQYQAYCPDQJ[JD"QONO_ANQ_GI_QQNA^ENDNDQQD?'[$l*26+$_-65+222*!($_-32)]
0..5|%{' #'[(+$c-shr$_)%2]}})}}

}

&$f "ascii art
text"

เอาท์พุท:

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

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

บันทึก:

$s|% *per|% t*y เป็นทางลัดสำหรับ$s|% toUpper|% toCharArray

เกี่ยวกับพื้นที่:

สำหรับตัวของสตริงแหล่งที่มาแต่ละสคริปต์ที่ต้องใช้สัญลักษณ์ (หน้ากากบิต) '_ONO__NQ...'จากสตริงมายากล อย่างไรก็ตามดัชนีนั้นเกินกว่าเวทย์มนตร์สำหรับช่องว่าง ในกรณีนี้บิตมาส์ก$cจะว่างเปล่า มันหมายถึงศูนย์สำหรับบิตทั้งหมด

เกี่ยวกับบรรทัดว่าง:

สคริปต์จะแสดง 6 แถวสำหรับแต่ละสัญลักษณ์แทน 5 ดัชนีนั้นเกินกว่าสายเวทย์มนตร์สำหรับบรรทัดว่างด้วย ดังนั้นแถว 6 มีช่องว่างเท่านั้น

จะเห็นได้ดีที่สุดถ้าคุณพิมพ์อักขระอื่นแทนที่จะเว้นวรรค ·เช่น

#####··###···###··#####·#####·······#####·####··#####·
#···#·#·····#···#···#·····#·········#···#·#···#···#···
#####··###··#·······#·····#·········#####·####····#···
#···#·····#·#···#···#·····#·········#···#·##······#···
#···#··###···###··#####·#####·······#···#·#·#·····#···
······················································
#####·#####·#···#·#####·
··#···#······#·#····#···
··#···####····#·····#···
··#···#······#·#····#···
··#···#####·#···#···#···
························

C (gcc) , 326 ไบต์

แทงครั้งแรกที่มัน ต้องรวม stdio.h และ string.h บน TIO แต่ไม่จำเป็นต้องใช้กับ MinGW

char*p=0,*q;(*X)()=putchar;i,j;f(char*s){for(;p=strtok(p?0:strdup(s),"\n");X(10))for(i=0;i<5;i++,X(10))for(q=p;*q;q++,X(32))for(j=0;j<5;j++)X(((*q==32?0:"OAOAA?A?A?>A1A>?AAA?O1?1OO1?11>1IA>AAOAAO444OO4457A97591111OAKEAAACCIA>AAA>?A?11>AAIN?A?35>1>@>O4444AAAA>AA::4AAEKAA:4:AA:444O842O"[(toupper(*q)-65)*5+i]-48)>>j)&1?35:32);}

ลองออนไลน์!

JavaScript (ES6), 292 287 278 ไบต์

s=>s.split`
`.map(s=>`vfefvvehvvh1hhefefevhhhhhv
hhhh111h4491rjhhhh14hhhaa8
vf1hffpv4471llhfhfe4hal444
hhhh11hh4551hph1p3g4hara42
hfefv1ehv79vhhe1u5e4e4hh4v`.replace(/.{26}/g,S=>s.replace(/./g,c=>'012345'.replace(/./g,x=>' #'[(P=parseInt)(S[P(c,36)-10]||0,36)>>x&1])))).join`

`

การสาธิต

let f =

s=>s.split`
`.map(s=>`vfefvvehvvh1hhefefevhhhhhv
hhhh111h4491rjhhhh14hhhaa8
vf1hffpv4471llhfhfe4hal444
hhhh11hh4551hph1p3g4hara42
hfefv1ehv79vhhe1u5e4e4hh4v`.replace(/.{26}/g,S=>s.replace(/./g,c=>'012345'.replace(/./g,x=>' #'[(P=parseInt)(S[P(c,36)-10]||0,36)>>x&1])))).join`

`

O.innerText = f('HELLO WORLD\nTHIS IS A TEST')

<pre id=O></pre>