คำในคำในคำที่อยู่ในคำ . .


17

ในฟอนต์ตัวหนังสือตัวอักษรตัวอักษรตัวพิมพ์ใหญ่ตัวอักษรทั้งหมดมีความกว้าง 5 หน่วยและสูง 5

 ███  ████   ███  ████  █████ █████  ████ █   █ █████     █ █   █ █     █   █
█   █ █   █ █   █ █   █ █     █     █     █   █   █       █ █  █  █     ██ ██
█████ ████  █     █   █ ████  ████  █  ██ █████   █       █ ███   █     █ █ █
█   █ █   █ █   █ █   █ █     █     █   █ █   █   █   █   █ █  █  █     █   █
█   █ ████   ███  ████  █████ █      ████ █   █ █████  ███  █   █ █████ █   █

█   █  ███  ████   ███  ████   ████ █████ █   █ █   █ █   █ █   █ █   █ █████
██  █ █   █ █   █ █   █ █   █ █       █   █   █ █   █ █   █  █ █   █ █     █ 
█ █ █ █   █ ████  █   █ ████   ███    █   █   █  █ █  █ █ █   █     █     █  
█  ██ █   █ █     █  ██ █  █      █   █   █   █  █ █  █ █ █  █ █    █    █   
█   █  ███  █      ████ █   █ ████    █    ███    █    █ █  █   █   █   █████

นอกจากนี้ยังมีช่องว่าง 1 หน่วยระหว่างตัวอักษรและระหว่างบรรทัดตามที่เห็น ดังนั้นตัวอักษรแต่ละตัวสามารถใช้พื้นที่ได้ถึง 6 × 6 หน่วย

สมมติว่าแทนการใช้บล็อกตัวอักษรเต็มรูปแบบ ( ) โดยตรงรูปทรงของตัวอักษรที่เราต้องการที่จะใช้ตัวอักษรอื่น ๆ ในตัวอักษรเดียวกัน สิ่งนี้เกี่ยวข้องกับการเพิ่มขนาดของข้อความ 6-fold เพื่อให้ตัวอักษรที่ทำจากบล็อกเต็มสามารถนำมาใช้แทนแบบเต็มบล็อกในข้อความขนาดใหญ่

หากไม่เหมาะสมหวังว่าตัวอย่างนี้จะ นี่คือ A ที่ทำจาก B โดยใช้ฟอนต์แบบพิกเซล:

      ████  ████  ████       
      █   █ █   █ █   █      
      ████  ████  ████       
      █   █ █   █ █   █      
      ████  ████  ████       
                             
████                    ████ 
█   █                   █   █
████                    ████ 
█   █                   █   █
████                    ████ 
                             
████  ████  ████  ████  ████ 
█   █ █   █ █   █ █   █ █   █
████  ████  ████  ████  ████ 
█   █ █   █ █   █ █   █ █   █
████  ████  ████  ████  ████ 
                             
████                    ████ 
█   █                   █   █
████                    ████ 
█   █                   █   █
████                    ████ 
                             
████                    ████ 
█   █                   █   █
████                    ████ 
█   █                   █   █
████                    ████ 

B ของทำจากบล็อกเต็มและ A ทำจาก B ของ โปรดสังเกตว่า B's ยังคงมีหนึ่งหน่วยระหว่างหน่วยแนวนอนและแนวตั้ง

เราสามารถขยายความคิดนี้โดยใช้คำแทนที่จะเป็นแค่ตัวอักษร นี่คือ "น้ำ" ที่ทำจาก "ไฟ":

█████                   █████             ████  █████ █████             █████ ████  █████ █████ █████       ████  █████ █████ █████ ████        █████ █████ █████ ████       
█                         █               █   █ █     █                   █   █   █ █     █       █         █   █ █     █       █   █   █       █     █       █   █   █      
████                      █               ████  ████  ████                █   ████  ████  ████    █         ████  ████  ████    █   ████        ████  ████    █   ████       
█                         █               █  █  █     █                   █   █  █  █     █       █         █  █  █     █       █   █  █        █     █       █   █  █       
█                       █████             █   █ █████ █                 █████ █   █ █████ █     █████       █   █ █████ █     █████ █   █       █████ █     █████ █   █      
                                                                                                                                                                             
█████                   █████       ████                    █████                   █████                   █████                               ████                    █████
█                         █         █   █                   █                       █                         █                                 █   █                   █    
████                      █         ████                    ████                    ████                      █                                 ████                    ████ 
█                         █         █  █                    █                       █                         █                                 █  █                    █    
█                       █████       █   █                   █████                   █                       █████                               █   █                   █████
                                                                                                                                                                             
█████       █████       ████        █████ █████ █████ ████  █████                   █████                   █████ ████  █████ █████             █████ ████  █████ █████      
█             █         █   █       █     █       █   █   █ █                       █                         █   █   █ █     █                   █   █   █ █     █          
████          █         ████        ████  ████    █   ████  ████                    ████                      █   ████  ████  ████                █   ████  ████  ████       
█             █         █  █        █     █       █   █  █  █                       █                         █   █  █  █     █                   █   █  █  █     █          
█           █████       █   █       █████ █     █████ █   █ █████                   █                       █████ █   █ █████ █                 █████ █   █ █████ █          
                                                                                                                                                                             
█████       █████       ████        █████                   █████                   █████                   ████                                █████             █████      
█             █         █   █       █                       █                         █                     █   █                               █                 █          
████          █         ████        ████                    ████                      █                     ████                                ████              ████       
█             █         █  █        █                       █                         █                     █  █                                █                 █          
█           █████       █   █       █████                   █                       █████                   █   █                               █████             █          
                                                                                                                                                                             
      █████       █████             ████                    █████                   █████                   █████ ████  █████ █████ █████       ████                    █████
      █             █               █   █                   █                       █                         █   █   █ █     █       █         █   █                   █    
      ████          █               ████                    ████                    ████                      █   ████  ████  ████    █         ████                    ████ 
      █             █               █  █                    █                       █                         █   █  █  █     █       █         █  █                    █    
      █           █████             █   █                   █████                   █                       █████ █   █ █████ █     █████       █   █                   █████

สังเกตว่า "ไฟ" ปรากฏซ้ำ ๆ ในแต่ละบรรทัดและเรียงตามลำดับเสมอไม่ว่าจะมีช่องว่างระหว่างตัวอักษรเท่าใด อินสแตนซ์ที่ถูกต้องที่สุดของสาม "FIRE" ถูกตัดออก แต่เนิ่นเนื่องจากวิธีการจัดรูปแบบของตัวอักษร "WATER"

ความคิดนี้สามารถขยายได้ดียิ่งขึ้นโดยใช้เหล่านี้คำพูดที่ทำจากคำพูดที่จะทำให้คำพูดที่ทำจากคำพูดที่ทำจากคำพูดหรือแม้กระทั่งคำพูดที่ทำจากคำพูดที่ทำจากคำพูดที่ทำจากคำพูด ไม่มีข้อ จำกัด ทางทฤษฎี

อีกตัวอย่างหนึ่งจะวางโพสต์นี้เกินขีด จำกัด อักขระ 30k แต่คุณสามารถดูความหมายโดย "คำที่ทำจากคำที่ทำด้วยคำว่า" โดยการเรียกใช้กองเล็กเกร็ดน้อยที่ดี เพียงแค่ปล่อยพารามิเตอร์ไว้ที่ค่าเริ่มต้นแล้วกด "ไปกันเลย" คุณควรเห็นคำว่า "DOG" ที่ทำจากคำว่า "CAT" ที่ทำจากคำว่า "MOUSE"

การพิมพ์ช่องว่างใด ๆ ที่คั่นรายการคำที่มีเพียงตัวพิมพ์ใหญ่ในกล่องข้อความจะสร้างคำแรกที่ทำจากคำที่สองที่สร้างจากคำที่สามที่ทำจากคำที่สามที่ทำจากที่สี่ที่ทำจาก ... ฯลฯ

คำเตือน: การป้อนมากกว่า 4 หรือ 3 คำจะสร้างข้อความจำนวนมากและใช้เวลานาน มันอาจทำให้เบราว์เซอร์ / คอมพิวเตอร์ / รถยนต์ของคุณขัดข้อง

ท้าทาย

เป้าหมายของการท้าทายนี้คือการสะท้อนสิ่งที่กองย่อยทำในจำนวนอักขระน้อยที่สุด

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

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

รายละเอียด

  • อินพุตควรมาจาก stdin, บรรทัดคำสั่งหรือคุณอาจจะเขียนฟังก์ชั่นที่รับสตริง

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

  • เอาต์พุตควรไปที่ stdout (หรือทางเลือกที่คล้ายกัน) หรือไปยังไฟล์ที่มีชื่อที่คุณเลือก

  • เอาท์พุทควรประกอบด้วยสิ้นเชิงของตัวละครที่ว่างเปล่าพื้นที่ , ตัวอักษรเต็มรูปแบบในพื้นที่และการขึ้นบรรทัดใหม่

    • ตัวละครที่ว่างเปล่า / เต็มพื้นที่ทั้งควรมีช่องว่างและบล็อกเต็ม ( , ) ตามลำดับหรือระยะเวลาและ X ( ., X) ตามลำดับ
  • เอาต์พุตไม่ควรมีคอลัมน์นำหน้าใด ๆ ที่มีเฉพาะอักขระช่องว่างแม้ว่าจะอนุญาตให้ใช้อักขระช่องว่างเว้นวรรคในบรรทัดใดก็ได้

    • ดังนั้นนี้ได้รับอนุญาต:

      X...X.XXXXX..
      X...X.X
      X.X.X.XXXX....
      X.X.X.X..
      .X.X..XXXXX..
      
    • แต่นี่ไม่ใช่:

      .X...X.XXXXX..
      .X...X.X
      .X.X.X.XXXX....
      .X.X.X.X..
      ..X.X..XXXXX..
      
  • ไม่ควรมีแถวนำหน้าหรือต่อท้ายที่มีอักขระเว้นวรรคเท่านั้น ขึ้นบรรทัดใหม่แบบลากเดียวก็ได้

นี่คือแบบอักษรที่เป็นมิตรกับสตริงมากขึ้น:

.XXX.
X...X
XXXXX
X...X
X...X

XXXX.
X...X
XXXX.
X...X
XXXX.

.XXX.
X...X
X....
X...X
.XXX.

XXXX.
X...X
X...X
X...X
XXXX.

XXXXX
X....
XXXX.
X....
XXXXX

XXXXX
X....
XXXX.
X....
X....

.XXXX
X....
X..XX
X...X
.XXXX

X...X
X...X
XXXXX
X...X
X...X

XXXXX
..X..
..X..
..X..
XXXXX

....X
....X
....X
X...X
.XXX.

X...X
X..X.
XXX..
X..X.
X...X

X....
X....
X....
X....
XXXXX

X...X
XX.XX
X.X.X
X...X
X...X

X...X
XX..X
X.X.X
X..XX
X...X

.XXX.
X...X
X...X
X...X
.XXX.

XXXX.
X...X
XXXX.
X....
X....

.XXX.
X...X
X...X
X..XX
.XXXX

XXXX.
X...X
XXXX.
X..X.
X...X

.XXXX
X....
.XXX.
....X
XXXX.

XXXXX
..X..
..X..
..X..
..X..

X...X
X...X
X...X
X...X
.XXX.

X...X
X...X
.X.X.
.X.X.
..X..

X...X
X...X
X.X.X
X.X.X
.X.X.

X...X
.X.X.
..X..
.X.X.
X...X

X...X
.X.X.
..X..
..X..
..X..

XXXXX
...X.
..X..
.X...
XXXXX

เกณฑ์การให้คะแนน

นี่คือเพื่อการส่งที่สั้นที่สุดในหน่วยไบต์ชนะ อินสแตนซ์ใด ๆ ของบล็อกแบบเต็ม ( ) สามารถนับเป็น 1 ไบต์แทน 3 เพื่อให้การส่งที่ใช้Xไม่มีข้อได้เปรียบ


5
คุณสามารถเรียกใช้ตัวอย่างโค้ด JavaScript ต่อไปนี้ (เช่นโดยพิมพ์javascript:ลงในแถบ URL และวาง) เพื่อทำให้งานศิลปะ ASCII อยู่ที่นี่มากมาก$('#question pre').css('line-height',1)ง่ายต่อการอ่าน: ผลลัพธ์: i.stack.imgur.com/XmB8C.png
Doorknob

1
หรือเพื่อรวมคำตอบ$('#question pre, .answer pre').css('line-height',1)
Martin Ender

ฉันรู้ว่ามันสายเกินไปที่จะสร้างเรื่องตลกนี้ แต่ฉันไม่สามารถต้านทานได้: i.imgur.com/vAZi1Zt.png i.imgur.com/vAZi1Zt.png
algorithmshark

ฉันพลาดความท้าทายนี้ได้อย่างไร!
Magic Octopus Urn

คำตอบ:


8

CJam, 171 165 162 161ไบต์

qS/_0=,0a*a\{{W:I;{'[{RI):I=}?i65-"c¿»ÐòO*4Õ]%ÐÎ<à IX]{-ïèq=ô}s×o)½2~û³'é¨1ÃlØeúN!Ö3~4ÜË|ÕÇäaepý®"255b2b5/5/=}%z1af*}%R,1a*a*}fR2a*"█ 
"f=

ฉันถือว่า1 ไบต์ ส่วนที่เหลือของตัวละครทั้งหมดนั้นอยู่ในช่วง ASCII ดังนั้นจึงถือว่าเป็น 1 ไบต์เช่นกัน

คุณสามารถใช้pastebin นี้สำหรับรหัสที่แน่นอน

ตัวอย่างเอาต์พุตสำหรับอินพุต:

FIRST HELLO WORLD

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

มันทำงานอย่างไร

ก่อนอื่นเลย

"c¿»ÐòO*4Õ]%ÐÎ<à IX]{-ïèq=ô}s×o)½2~û³'é¨1ÃlØeúN!Ö3~4ÜË|ÕÇäaepý®"255b2b5/5/

เป็นเพียงลวดลายสำหรับอักขระ 27 ตัว (A-Zและช่องว่าง) ซึ่งประกอบด้วย0(ที่Xตำแหน่ง) และ1(ที่.ตำแหน่ง) หลังจากถอดรหัสแล้วสิ่งนี้จะให้อาร์เรย์ขององค์ประกอบ 27 รายการของอาร์เรย์ 2 มิติที่มี 5 แถวและ 5 คอลัมน์ที่แสดงXและ.สำหรับอักขระ 27 ตัวแต่ละตัว Lขอให้เราโทรอาร์เรย์นี้เป็น

ตอนนี้รหัสที่เหลืออยู่:

qS/                      "Read the input and split it on space to get array Q";
   _0=                   "Get a copy of the first element of the above array";
      ,0a*               "Create an array filled with 0 with length of the first element";
          a\             "Wrap that array in another array and swap to get Q on top";
{  ...  }fR              "This is a for each loop on the array Q with R having the";
                         "current element value in each loop";
 {...}%                  "In the first iteration, the 0 array we created will be the";
                         "only thing on stack, in subsequent iterations, the result";
                         "of previous iteration will be on stack";
  W:I;                   "Initialize variable I with -1";
      {...}%             "Run this block on each element of the current array";
{'[{RI):I=}?i65-L=}%     "This is the above code block. In each iteration, we figure";
                         "out what character needs to be be put at the current index";
                         "Then we get the pattern of 0 and 1 for that character";
 '[{      }?             "Stack contains either 0 or 1. If it is 1, we want to leave";
                         "that index blank, so we put pattern of '[ which is 5X5 spaces";
    RI_:I=               "When we do not want a blank character, we get the next"
                         "character from R to fill the non empty space";
            i65-         "Convert A-Z  to 0-27 notation";
                L=       "Get the corresponding pattern from the pattern array L";
z1af*                    "After the above iterations, for each line of the previous";
                         "iteration's output, we get a vertical 2D array for next";
                         "iteration. We transpose it and join each character in";
                         "this line using a space";
      R,1a*a*            "After getting all lines from current iteration, we join them";
                         "with one full line of space characters";

 2a*                     "After all iterations, we have the 0 1 based 2D array for the";
                         "final output ASCII with each row representing a line. We join";
                         "these lines with 2, to get a 0 1 2 based array";
     "█                  "A brick, a space and a newline. Mapping 1 to 1 with 0 1 2";
"                        "based array";
 f=                      "For each of the 0 1 2 based array element, convert them to";
                         "one of the brick, space and new line character";

ลองออนไลน์ได้ที่นี่


9

Python 3, 437 ไบต์

from numpy import*
s=input().split()
d=fromstring('NONO__^Q_PQAQQNONO^_QQQQQ_QQQQAAAQDPIA[SQQQQADQQQJJH_OAQOOY_DPGAUUQOQONDQJUDDDQQQQAAQQDQIAQYQAYIPDQJUJDBQONO_A^Q_NQ_QQNA^QODNDJQD_',byte)[:,None]>>arange(5)&1
b=0
x=1
y=len(s[0])
n=[[1]*y]
for w in s:
 g=n;b+=x;x*=6;n=zeros((x,x*y),int);i=-6
 for q in g:
  o=j=0;i+=6
  for p in q:n[i:i+5,j:j+5]|=d[ord(w[o%len(w)])-65::26]*p;o+=p;j+=6
for r in n[:-b]:print(''.join(' █'[x] for x in r))

รูปร่างของอักขระถูกเข้ารหัสใน ASCII ไบต์ ASCII แต่ละรายการสอดคล้องกับหนึ่งแถวของอักขระหนึ่งตัวพร้อมบิตที่แสดงถึงบล็อกหน่วย มันไม่ได้เป็นระบบที่มีประสิทธิภาพมากนัก แต่มันง่ายที่จะแกะลงใน bitmasks ของ NumPy สำหรับตัวละครแต่ละตัว

เราเริ่มด้วย array 2d ของ 1s มันมีหนึ่งคอลัมน์สำหรับตัวละครแต่ละตัวในคำแรกและแถวเดียว จากนั้นสำหรับแต่ละคำเราสร้างอาร์เรย์ใหม่เป็น 0s สูงขึ้นหกเท่าและกว้างกว่าอาร์เรย์ก่อนหน้าหกเท่า โดยที่อาร์เรย์ก่อนหน้ามี 1 ส่วน 6x6 ที่สอดคล้องกันของอาร์เรย์ใหม่จะเต็มไปด้วย bitmask ของอักขระที่เหมาะสม

นี่คือตัวอย่าง (ด้วยตัวอักษรขนาดเล็กมาก):

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


5

CJam, 181 174 170 ไบต์

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

"Á  :½A%õ­Íú£à˪ë8!Õ*j4¶fVËa¡ùÔ¯{+ÛyéâõKn#@?
9Ôia)(Ñç;~LÒª"257b2bYYb" █"er5/5/:L;lS/_0=,'█*a\{f{W:T;\{' ={S5*a5*}{T):T1$='A-L=}?\}%W<zSf*}Sa*}/N*

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

ทดสอบที่นี่

รับอินพุตผ่าน STDIN เป็นรายการคำที่คั่นด้วยช่องว่าง คำแรกคือขนาดที่ใหญ่ที่สุด ตัวอย่างเช่น

HOLISM REDUCTIONISM

อัตราผลตอบแทน

████                    █████             ████  █   █  ███              █████                               █████  ███  █   █ █████  ████             █   █ ████  █████ ████        █   █                    ███ 
█   █                   █                 █   █ █   █ █   █               █                                   █   █   █ ██  █   █   █                 ██ ██ █   █ █     █   █       █   █                   █   █
████                    ████              █   █ █   █ █                   █                                   █   █   █ █ █ █   █    ███              █ █ █ ████  ████  █   █       █   █                   █    
█  █                    █                 █   █ █   █ █   █               █                                   █   █   █ █  ██   █       █             █   █ █  █  █     █   █       █   █                   █   █
█   █                   █████             ████   ███   ███                █                                 █████  ███  █   █ █████ ████              █   █ █   █ █████ ████         ███                     ███ 

████                    █████       ████                    █   █        ███                                            █████                   █████                                ███  █   █       █████  ████
█   █                   █           █   █                   █   █       █   █                                             █                       █                                 █   █ ██  █         █   █    
████                    ████        █   █                   █   █       █                                                 █                       █                                 █   █ █ █ █         █    ███ 
█  █                    █           █   █                   █   █       █   █                                             █                       █                                 █   █ █  ██         █       █
█   █                   █████       ████                     ███         ███                                              █                     █████                                ███  █   █       █████ ████ 

████  █████ ████  █   █  ███        █████                   █████        ███                                            █   █                         █████  ████ █   █             ████        █████       ████ 
█   █ █     █   █ █   █ █   █         █                       █         █   █                                           ██  █                           █   █     ██ ██             █   █       █           █   █
████  ████  █   █ █   █ █             █                       █         █   █                                           █ █ █                           █    ███  █ █ █             ████        ████        █   █
█  █  █     █   █ █   █ █   █         █                       █         █   █                                           █  ██                           █       █ █   █             █  █        █           █   █
█   █ █████ ████   ███   ███          █                     █████        ███                                            █   █                         █████ ████  █   █             █   █       █████       ████ 

████                    █████       ████                    █   █        ███                                            █████                                           █████        ███                    █   █
█   █                   █           █   █                   █   █       █   █                                             █                                               █         █   █                   ██  █
████                    ████        █   █                   █   █       █                                                 █                                               █         █   █                   █ █ █
█  █                    █           █   █                   █   █       █   █                                             █                                               █         █   █                   █  ██
█   █                   █████       ████                     ███         ███                                              █                                             █████        ███                    █   █

████                    █████             ████  █   █  ███              █████ █████  ███  █   █ █████        ████ █   █ ████  █████ ████        █   █  ███  █████ █████              ███                    █   █
█   █                   █                 █   █ █   █ █   █               █     █   █   █ ██  █   █         █     ██ ██ █   █ █     █   █       █   █ █   █   █     █               █   █                   ██  █
████                    ████              █   █ █   █ █                   █     █   █   █ █ █ █   █          ███  █ █ █ ████  ████  █   █       █   █ █       █     █               █   █                   █ █ █
█  █                    █                 █   █ █   █ █   █               █     █   █   █ █  ██   █             █ █   █ █  █  █     █   █       █   █ █   █   █     █               █   █                   █  ██
█   █                   █████             ████   ███   ███                █   █████  ███  █   █ █████       ████  █   █ █   █ █████ ████         ███   ███    █   █████              ███                    █   █

คำอธิบาย

อันดับแรกเราเก็บตารางการค้นหาสำหรับรูปร่างตัวอักษรในL:

"Á  :½A%õ­Íú£à˪ë8!Õ*j4¶fVËa¡ùÔ¯{+ÛyéâõKn#@?
9Ôia)(Ñç;~LÒª"257b2bYYb" █"er5/5/:L;

สตริงแรกเป็นเพียงตัวเลขที่บีบอัด เราปฏิบัติต่อจุดรหัสเป็นฐาน 257 หลักจากนั้นเราแปลงจำนวนผลลัพธ์เป็นไบนารี YYbคือ 2 อยู่ในฐานที่ 2 [1 0]จึงให้ เราใช้การทดแทนองค์ประกอบด้วย" █"เพื่อเปลี่ยนตัวเลขให้เป็นช่องว่างและอักขระบล็อก สุดท้ายเราแยกสตริงออกเป็นแถว 5 ตัวและแบ่งออกเป็น 5 แถว ผลลัพธ์จะถูกเก็บไว้ในLและทิ้งจากสแต็ก

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

lS/_0=,'█*a\
lS/          "Read input, split on spaces.";
   _0=       "Duplicate and get first word.";
      ,'█*   "Get length repeat █ that many times.";
          a  "Wrap in array, to make the grid two-dimensional.";
           \ "Swap with word list.";

ลองดูโครงสร้างด้านนอกสุดของโปรแกรมที่เหลือก่อน บล็อกถัดไป{...}/จะทำงานสำหรับทุกคำและขยายอักขระบล็อกแต่ละตัว

{f{...}Sa*}/N*
{         }/   "Process each word in the input.";
 f{...}        "Map this block onto each line of the grid, passing in the current word as well.";
       Sa*     "Since each original line will be turned into 5 lines, the grid is still grouped
                into blocks of 5 lines. We join them together with empty lines as required.";
            N* "Join all lines together with newlines.";

สุดท้ายเรามาดูวิธีการขยายบรรทัดเดียว:

W:T;\{' ={S5*a5*}{T):T1$='A-L=}?\}%
W:T;                                "Store -1 in T.";
    \                               "Swap word with line.";
     {                           }% "Map this block onto each character.";
      ' =                           "Check if the character is a space.";
         {      }{            }?    "If it is, run the first block, otherwise the second.";
          S5*                       "Create a string of five spaces.";
             a5*                    "Create an array of five such strings.";
                  T):T              "Push T, increment, store in T.";
                      1$=           "Copy the word and access the T'th character, cyclically.";
                         'A-        "Subtract A from the letter.";
                            L=      "Use the result to get the character shape from L.";
                                \   "Swap resulting block with word.";

"At this point each character is replaced with a 5x5 array of new characters.
 So we actually have a 3D array right now. Since we used a map operation, the
 current word will also be at the end of the array, which we need to get rid off.";

W<zSf*
W<     "Discard last array element - the current word.";
  z    "Zip or transpose the top two levels of the array.";
   Sf* "Join each line together with spaces.";

ผลลัพธ์จะถูกพิมพ์โดยอัตโนมัติเมื่อสิ้นสุดโปรแกรม

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