Ezoterik programlama dili kötülüğü , "dokuma" olarak adlandırdığı bayt değerleri üzerinde ilginç bir işleme sahiptir. Esasen, baytın sekiz bitinin bir permütasyonu (desen simetrik olduğu için, hangi uçtan saymaya başladığımız önemli değil):

• Bit 0, bit 2'ye taşınır
• Bit 1, bit 0'a taşınır
• Bit 2, bit 4'e taşınır
• Bit 3, bit 1'e taşınır
• Bit 4, bit 6'ya taşınır
• Bit 5, bit 3'e taşınır
• Bit 6, bit 7'ye taşınır
• Bit 7, bit 5'e taşınır

Kolaylık sağlamak için işte permütasyonun diğer iki açıklaması. Bir döngü olarak:

(02467531)

Ve haritalama çiftlerinin bir listesi olarak:

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

Görev kutusu çekme karakterleri kullanarak, bu permütasyon görselleştirmek için ─, │, ┌, ┐, └, ┘, ┼(Unicode kod noktaları U + 2500, U +, 2502 U +, 250C, u + 2510 + 2514 U, U + 2518, U + 253C). Bu görselleştirme aşağıdaki kısıtlamaları sağlamalıdır:

İlk ve son satır tam olarak:

0 1 2 3 4 5 6 7

Bunlar arasında, kutu çizim karakterlerine uyması için her biri 15 karaktere kadar istediğiniz kadar çizgi kullanabilirsiniz (en az 4 satıra ihtiyacınız olacak). Satırlar, ilk satırdaki rakamlardan birinin altında dikey olarak başlamalı ve son satırdaki ilgili rakamın üzerinde dikey olarak bitmelidir. Sekiz hat bağlanmalıdır ve sadece çapraz geçmelidir ┼(bu her zaman bir geçiş, asla dokunmayan iki dönüş çizgisi). Çizgilerin tam yolları size kalmış (ve özellikle golf oynanabilir bir düzen bulmak bu zorluğun özüdür). Geçerli bir çıktı:

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

Ancak, doğru rakamları doğru şekilde bağlayan başka bir düzen de iyidir. Lütfen seçtiğiniz çıktıyı cevabınızda gösterin.

Bir program veya işlev yazabilirsiniz ve herhangi bir giriş yapmazsınız. Diyagramı ya STDOUT'a (ya da en yakın alternatife) ya da bir dizge ya da bir dizgelerin (her biri bir satırı temsil eden) şeklinde bir işlev dönüş değeri olarak verin.

Standart kod-golf kuralları geçerli olduğundan en kısa kod (bayt cinsinden) kazanır.

Aslında, 69 bayt

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

Çevrimiçi deneyin! (hizalama çevrimiçi çevirmende biraz dağıldı)

Aslında burada BÜYÜK bir avantaja sahip - kutu çizim karakterlerinin tümü CP437'de. Her karakter teorik olarak 4 bitte kodlanabilse de (sadece 9 benzersiz karakter olduğundan), dizgenin sıkıştırılmasıyla kaydedilen 31 bayt, gerçekte çok zayıf dize işleme yetenekleri nedeniyle kaybolacaktı. Bu ayrıca, herhangi bir 8x4 yapılandırmasının aynı skorla sonuçlanacağı anlamına gelir. 8x4 (dikey olarak) mümkün olan en kısa yapılandırma olarak göründüğü için, bu idealdir.

Martin'e 3 bayt için teşekkürler!

4 daha fazla bayt için TimmyD'ye teşekkürler!

Açıklama:

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"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 131 123 bayt (81 karakter)

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

Dokumayı daha fazla golf oynadım, satır içi kod blokları kullanarak birkaç değişkene olan ihtiyacı ortadan kaldırdım. Bu muhtemelen optimal bir kaç bayt içinde.

Boşluklarla birleştirilen $aaralığa eşit ayar yaparak başlarız 0..7. Bunun nedeni, $ofsbir dizinin varsayılan (Çıktı Alan Ayırıcı) bir boşluk olmasıdır, bu nedenle dizi ile dizilir ""+(bunun gibi bir operatörle PowerShell, sağdaki nesneyi soldaki nesne olarak dolaysız olarak kullanmaya çalışır), Sonuç, boşlukla ayrılmış aralıktır.

Parenslerde kapsüllenmiş, sonucu boru hattına ekler. Daha sonra bir yardımcı değişken $bhazırladık, ardından uygun değişkenle yerinde dört satır çıktı satırını hazırladık (değişmez yeni satırlarla bölündü) ve tekrar bölümleri için satır içi kod bloklarını kullanıp ardından $atekrar. Dört çizgi ve $aayrıca boru hattına yerleştirilir ve çıktı sonunda kapalıdır.

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 bayt

Düzenleme: Whoops, çıktı Bayt sayısı güncellendi, işlevi bir parçası olarak |U + 2502 yerine pipe char kullanıyordum │.

_=>((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`
`

Bir dize döndürür.

Çıktı:

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

Ekstra: @ TimmyD'nin metodunu kullanarak, başka bir 167 baytlık çözümüm var:

(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 bayt

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>

Bir zil sesi olarak bunu hemen Plain Hunt Major'ın ilk iki sırası olarak tanıdım (bağlantılı görüntünün 0-7 yerine 1-8 kullandığını unutmayın).

Pyth - 119 104 100 81 bayt

Son derece basit. (Aslında bu sefer bayt).

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

Burada çevrimiçi deneyin .

Ayrıca TimmyD'in çıktısını @ çaldım:

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

MS-DOS Toplu İş, 136 bayt

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

@ TimmyD'in çıktısını kullanarak. Bu, Windows Toplu İşinde de işe yarayabilir, ancak kod sayfamda CP850 değil, CP850 var.

MATLAB / Octave, 112 109 bayt

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]

Çıktı:

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

Kodum @Dendrobium ve @Neil'in çıkışlarına dayanıyor .

/// , 112 bayt (100 karakter)

/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

-3 byte için @ Martininder teşekkürler!
Teşekkürler @MartinEnder -9 bayt!
15-char kuralını dışladığın için teşekkürler @MartinEnder (OP)

Kullanımları TimmyD en @ Marco çıkışı @

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

Python3, 209 bayt

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

Bir dize döndürür.

2 byte tasarruf için @Mego teşekkürler!

Karakter gövdesinin kredisi @TimmyD!

Dağıtmalar , 99 bayt (87 karakter)

$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'nun çıktısını kullanır (her 16. karakteri bir yenisiyle değiştir (regex: (.{15}).-> \1\n)).

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

Bash + GNU sed, 140 bayt

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'

Çıktı:

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

@ TimmyD'nin çıkışını kullanarak : 142 bayt

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'

Çıktı:

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

Tcl , 205 bayt

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

Çevrimiçi deneyin!

çıktılar

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

SOGL V0.12 , 64 bayt

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

Burada dene!

Çalınan Desen powershell