ความชั่วร้ายของการเขียนโปรแกรมภาษาลึกลับมีการดำเนินการที่น่าสนใจเกี่ยวกับค่าไบต์ซึ่งเรียกว่า "การทอผ้า" มันคือการเปลี่ยนรูปแบบของบิตที่แปดของไบต์ (มันไม่สำคัญว่าเราจะเริ่มนับจากจุดสิ้นสุดเนื่องจากรูปแบบสมมาตร):

• บิต 0 ถูกย้ายไปที่บิต 2
• บิต 1 ถูกย้ายไปที่บิต 0
• ย้ายบิต 2 ไปเป็นบิต 4
• บิต 3 ถูกย้ายไปยังบิต 1
• บิต 4 ถูกย้ายไปยังบิต 6
• ย้ายบิต 5 ไปเป็นบิต 3
• บิต 6 ถูกย้ายไปยังบิต 7
• ย้ายบิต 7 ไปเป็นบิต 5

เพื่อความสะดวกนี่เป็นอีกสองแนวทางของการเปลี่ยนแปลง เป็นวงจร:

(02467531)

และเป็นรายการคู่ของแผนที่:

[[0,2], [1,0], [2,4], [3,1], [4,6], [5,3], [6,7], [7,5]]

งานของคุณคือเพื่อให้มองเห็นการเปลี่ยนแปลงนี้โดยใช้ตัวอักษรที่กล่องวาดภาพ─, │, ┌, ┐, └, ┘, ┼(Unicode จุดรหัส: U + 2500 U + 2502, U + 250C, U + 2510 U + 2514 U + 2518 U + 253C) การสร้างภาพข้อมูลนี้ควรเป็นไปตามข้อ จำกัด ดังต่อไปนี้:

บรรทัดแรกและบรรทัดสุดท้ายคือ:

0 1 2 3 4 5 6 7

ระหว่างนั้นคุณสามารถใช้หลายบรรทัดตามที่คุณต้องการได้สูงสุด 15 อักขระแต่ละตัวเพื่อให้พอดีกับอักขระการวาดกล่องของคุณ (คุณจะต้องมีอย่างน้อย 4 บรรทัด) บรรทัดควรเริ่มต้นในแนวตั้งภายใต้หนึ่งในตัวเลขในแถวแรกและสิ้นสุดในแนวตั้งเหนือตัวเลขที่สอดคล้องกันในแถวสุดท้าย ต้องต่อสายแปดเส้นและสามารถข้ามผ่านได้เท่านั้น┼(ซึ่งเป็นจุดผ่านเสมอไม่ใช่เส้นเลี้ยวสองเส้นที่สัมผัส) เส้นทางที่แน่นอนของเส้นเหล่านั้นขึ้นอยู่กับคุณ ผลลัพธ์ที่ถูกต้องหนึ่งรายการคือ:

0 1 2 3 4 5 6 7
│ │ └─┼┐│ │ └┐│
└─┼─┐ ││└─┼─┐││
┌─┘ │ ││  │ │││
│ ┌─┼─┘│  │ │││
│ │ │ ┌┼──┘ │││
│ │ │ │└┐ ┌─┼┼┘
│ │ │ │ │ │ │└┐
0 1 2 3 4 5 6 7

อย่างไรก็ตามเค้าโครงอื่น ๆ ที่เชื่อมต่อตัวเลขที่ถูกต้องก็ใช้ได้เช่นกัน โปรดแสดงผลลัพธ์ที่คุณเลือกในคำตอบของคุณ

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

มีการใช้กฎมาตรฐานของgolf-golfดังนั้นรหัสที่สั้นที่สุด (เป็นไบต์) จะเป็นผู้ชนะ

ที่จริงแล้ว 69 ไบต์

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+8r' j;)

ลองออนไลน์! (การจัดตำแหน่งค่อนข้างสับสนในล่ามออนไลน์)

จริงๆแล้วมี ข้อได้เปรียบอย่างมากที่นี่ - ตัวละครวาดกล่องทั้งหมดอยู่ใน CP437 ดังนั้นพวกเขาจึงเป็นเพียงไบต์ละ แม้ว่าอักขระแต่ละตัวที่จำเป็นต้องใช้ในทางทฤษฎีจะถูกเข้ารหัสใน 4 บิต (เนื่องจากมีเพียง 9 ตัวอักขระที่ไม่ซ้ำกัน), 31 ไบต์ที่บันทึกไว้โดยการบีบอัดสตริงจะหายไปเนื่องจากความสามารถในการประมวลผลของสตริงที่แย่มากจริงๆ นอกจากนี้ยังหมายความว่าการกำหนดค่า 8x4 ใด ๆ จะส่งผลให้คะแนนเดียวกัน เนื่องจาก 8x4 ดูเหมือนจะเป็นการกำหนดค่าที่สั้นที่สุด (แนวตั้ง) จึงเป็นสิ่งที่ดีที่สุด

ขอบคุณ Martin สำหรับ 3 ไบต์!

ขอบคุณ TimmyD อีก 4 ไบต์!

คำอธิบาย:

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+8r' j;)
"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+         push the individual lines, using string multiplication to shorten repeated sections
                                                              8r' j   push the string "0 1 2 3 4 5 6 7" (range(8), join on spaces)
                                                                   ;)  make a copy and move it to the bottom of the stack

PowerShell v2 +, 172 153 148 145 142 131 123 ไบต์ (81 ตัวอักษร)

($a=""+0..7)
$b='┌┘'
"│$b$('┌┼─┘'*3)
└┼┐$('│└─┐'*3)
$b$('└┼─┐'*3)│
│ $($b*6)│"
$a

ฉันทำการทอผ้าต่อไปโดยไม่ต้องใช้ตัวแปรหลายตัวโดยใช้บล็อคโค้ดอินไลน์ นี่น่าจะเป็นจำนวนไบต์ที่เหมาะสมที่สุด

เราเริ่มต้นด้วยการตั้งค่า$aเท่ากับช่วง0..7ที่รวมเข้ากับช่องว่าง นี่เป็นเพราะค่าเริ่มต้น$ofs(ตัวคั่นฟิลด์ผลลัพธ์) สำหรับอาร์เรย์เป็นช่องว่างดังนั้นเมื่ออาร์เรย์ถูกทำให้เป็นสตริงด้วย""+ (ด้วยตัวดำเนินการเช่นนี้ PowerShell จะพยายามโยนวัตถุทางขวาเป็นวัตถุทางซ้าย) ผลที่ได้คือการเว้นวรรคช่วงคั่น

มันถูกห่อหุ้มด้วย parens ซึ่งจะเพิ่มผลลัพธ์ลงในไปป์ไลน์ จากนั้นเราจะตั้งค่าตัวแปรตัวช่วยหนึ่งตัว$bตามด้วยเอาต์พุตสี่บรรทัดพร้อมกับตัวแปรที่เหมาะสม (แยกด้วยตัวอักษรขึ้นบรรทัดใหม่) และใช้บล็อกโค้ดอินไลน์สำหรับส่วนที่ทำซ้ำตามด้วย$aอีกครั้ง สี่บรรทัดและ$aวางบนไพพ์ไลน์ด้วยและเอาต์พุตจะอยู่ที่ส่วนท้าย

PS C:\Tools\Scripts\golfing> .\visualize-bit-weaving.ps1
0 1 2 3 4 5 6 7
│┌┘┌┼─┘┌┼─┘┌┼─┘
└┼┐│└─┐│└─┐│└─┐
┌┘└┼─┐└┼─┐└┼─┐│
│ ┌┘┌┘┌┘┌┘┌┘┌┘│
0 1 2 3 4 5 6 7

Javascript ES6, 168 167 ไบต์

แก้ไข: อ๊ะปรากฎว่าฉันใช้ pipe |char แทน U + 2502 │ในส่วนของฟังก์ชั่นนับไบต์ที่อัปเดต

_=>((n=`0 1 2 3 4 5 6 7 `)+[...`6452301`].map(i=>`${(d=n=>`│ `.repeat(n))(i)}└┐│ ${r=d(6)}┌┼┘ ${r}│└┐ ${d(6-i)}`).join``+n).match(/.{16}/g).join`
`

ส่งคืนสตริง

เอาท์พุท:

0 1 2 3 4 5 6 7 
│ │ │ │ │ │ └┐│ 
│ │ │ │ │ │ ┌┼┘ 
│ │ │ │ │ │ │└┐ 
│ │ │ │ └┐│ │ │ 
│ │ │ │ ┌┼┘ │ │ 
│ │ │ │ │└┐ │ │ 
│ │ │ │ │ └┐│ │ 
│ │ │ │ │ ┌┼┘ │ 
│ │ │ │ │ │└┐ │ 
│ │ └┐│ │ │ │ │ 
│ │ ┌┼┘ │ │ │ │ 
│ │ │└┐ │ │ │ │ 
│ │ │ └┐│ │ │ │ 
│ │ │ ┌┼┘ │ │ │ 
│ │ │ │└┐ │ │ │ 
└┐│ │ │ │ │ │ │ 
┌┼┘ │ │ │ │ │ │ 
│└┐ │ │ │ │ │ │ 
│ └┐│ │ │ │ │ │ 
│ ┌┼┘ │ │ │ │ │ 
│ │└┐ │ │ │ │ │ 
0 1 2 3 4 5 6 7 

พิเศษ: การใช้วิธีการของ @ TimmyD ฉันมีโซลูชันอีก 167 ไบต์:

(n=`0 1 2 3 4 5 6 7
`,a=`│┌┘ `,b=`└┼─┐`,d=`┌┼─┘`,f=` │└┐`)=>[n,a,a,a,a,`
`,b,b,b,`└┼┐
┌┘`,d,d,d,`│
│`,f,f,f,` │
`,n].join``

JavaScript (ES6), 137 134 ไบต์

f=
_=>`0
│2525252
1 1 1 1
24242423525252 3 1 1 1 3 242424│
0`.replace(/\d/g,d=>`0 1 2 3 4 5 6 7,└┼┐,┌┘,│
│,│ , │`.split`,`[d])  
;
o.textContent=f();

<pre id=o></pre>

ในฐานะผู้ส่งเสียงระฆังฉันจำได้ทันทีว่านี่เป็นสองแถวแรกของPlain Hunt Major (โปรดทราบว่ารูปภาพที่เชื่อมโยงใช้ 1-8 แทน 0-7)

Pyth - 119 104 100 81 ไบต์

ง่ายมาก (จริง ๆ แล้วมันเป็นจำนวนไบต์ในครั้งนี้)

js[KjdU8cX."sz¨ú¨ãÆhÆ?\ÕüÓ¼xFNøa"_G"│┌┘└┼─┐ "15K

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

ฉันยังขโมย @ TimmyD เอาท์พุท:

0 1 2 3 4 5 6 7
│┌┘ │┌┘ │┌┘ │ │
└┼─┐└┼─┐└┼─┐└┐│
┌┘┌┼─┘ └┐│┌┼─┼┘
│ │└┐ ┌─┼┘│└┐└┐
0 1 2 3 4 5 6 7

แบตช์ MS-DOS ขนาด 136 ไบต์

@echo 0 1 2 3 4 5 6 7
@echo ³ÚÙ ³ÚÙ ³ÚÙ ³ÚÙ
@echo ÀÅÄ¿ÀÅÄ¿ÀÅÄ¿ÀÅ¿
@echo ÚÙÚÅÄÙÚÅÄÙÚÅÄÙ³
@echo ³ ³À¿ ³À¿ ³À¿ ³
@echo 0 1 2 3 4 5 6 7

กำลังใช้เอาต์พุตของ @ TimmyD สิ่งนี้อาจทำงานใน Windows Batch ด้วย แต่หน้ารหัสของฉันมี CP850 ไม่ใช่ CP437

MATLAB / Octave, 112 109 ไบต์

a='0 1 2 3 4 5 6 7';d=['└┐│ ';'┌┼┘ ';'│└┐ '];e=repmat('│ ',3,1);[a;d d d d;e d d d e;a]

เอาท์พุท:

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

รหัสของฉันอยู่บนพื้นฐานเพื่อถ่ายทอดของ@Dendrobiumและ@Neil

/// , 112 ไบต์ (100 ตัวอักษร)

/8/0 1 2 3 4 5 6 7//9/│//A/└┐//B/┌┼┘/8/C/9 A9 A9 A9//D/9A 9A 9A 9/
AC
B B B B
DA
C 9
9 B B B 9
9 D
8

ขอบคุณ @MartinEnder สำหรับ -3 ไบต์!
ขอบคุณ @MartinEnder สำหรับ -9 ไบต์!
ขอบคุณ @MartinEnder (OP) สำหรับการชี้กฎ 15 ข้อ

ใช้เอาต์พุต @ @ TimmyD's @ Marco

0 1 2 3 4 5 6 7
└┐│└┐│└┐│└┐│
┌┼┘┌┼┘┌┼┘┌┼┘
│└┐│└┐│└┐│└┐
│└┐│└┐│└┐││
│┌┼┘┌┼┘┌┼┘│
││└┐│└┐│└┐│
0 1 2 3 4 5 6 7

Python3, 209 ไบต์

lambda s="0 1 2 3 4 5 6 7\n":s+"│┌┘ │┌┘ │┌┘ │ │\n└┼─┐└┼─┐└┼─┐└┐│\n┌┘┌┼─┘ └┐│┌┼─┼┘\n│ │└┐ ┌─┼┘│└┐└┐\n"+s

ส่งคืนสตริง

ขอบคุณ @Mego สำหรับการบันทึก 2 ไบต์!

เครดิตของตัวละครไปที่ @TimmyD!

Sprects , 99 ไบต์ (87 ตัวอักษร)

$8
AC
BE
DA
C 9
9E 9
9 D
8$E B B B$D9A 9A 9A 9$C9 A9 A9 A9$B┌┼┘$A└┐$9│$80 1 2 3 4 5 6 7

ใช้เอาต์พุตของ @ Marco (แทนที่อักขระที่ 16 ทุกบรรทัดด้วยบรรทัดใหม่ (regex: (.{15}).-> \1\n))

0 1 2 3 4 5 6 7
└┐│└┐│└┐│└┐│
┌┼┘┌┼┘┌┼┘┌┼┘
│└┐│└┐│└┐│└┐
│└┐│└┐│└┐││
│┌┼┘┌┼┘┌┼┘│
││└┐│└┐│└┐│
0 1 2 3 4 5 6 7

Bash + GNU sed, 140 ไบต์

sed 'h
s/$/nxxxacnb b b bnyyycanc xxxcnc b b b cnc yyyc/
:
s/x/ac /
s/y/ca /
s/a/└┐/
s/b/┌┼┘/
t
y/cn/│\n/
G'<<<'0 1 2 3 4 5 6 7'

เอาท์พุท:

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

กำลังใช้เอาต์พุต @ TimmyD : 142 ไบต์

sed 'h
s/$/npbcccnsurdddnbeeepnp bbbbbbp/
:
s/b/qt/
s/c/quot/
s/d/psor/
s/e/suor/
t
y/nopqrstu/\n─│┌┐└┘┼/
G'<<<'0 1 2 3 4 5 6 7'

เอาท์พุท:

0 1 2 3 4 5 6 7
│┌┘┌┼─┘┌┼─┘┌┼─┘
└┼┐│└─┐│└─┐│└─┐
┌┘└┼─┐└┼─┐└┼─┐│
│ ┌┘┌┘┌┘┌┘┌┘┌┘│
0 1 2 3 4 5 6 7

Tcl , 205 ไบต์

puts "[set B "0 1 2 3 4 5 6 7"]
│┌┘ │┌┘ │┌┘ └┐│
└┼┐ └┼─┐└┼──┐││
┌┘└─┐│ └┐│┌─┼┼┘
│ ┌─┼┘┌─┼┘│ │└┐
$B"

ลองออนไลน์!

เอาท์พุท

0 1 2 3 4 5 6 7
│┌┘│┌┘│┌┘└┐│
└┼┐└┼─┐└┼──┐││
┌┘└─┐│└┐│┌─┼┼┘
│┌─┼┘┌─┼┘││└┐
0 1 2 3 4 5 6 7

SOGL V0.12 , 64 ไบต์

└┼─┐³
┘┌┼─┘²
┐│└─┐¹
┌┘┌┘┌┘⁰
│┌²┌┼─²¶└┼¹│└─¹¶┌┘³³³│¶│ ⁰⁰│”8δ@∑Q;O

ลองที่นี่!

รูปแบบที่ถูกขโมยจากPowerShell