Yürüyen kareler algoritmasının her hücre için tanımlayacağı aşağıdaki 3x3 bloğu düşünün (0 tabanlı etiketli kimlikle):

0:
...
...
...

1:
...
...
\..

2:
...
...
../

3:
...
---
...

4:
..\
...
...

5:
/..
...
../

6:
.|.
.|.
.|.

7:
/..
...
...

8:
/..
...
...

9:
.|.
.|.
.|.

10:
..\
...
\..

11:
..\
...
...

12:
...
---
...

13:
...
...
../

14:
...
...
\..

15:
...
...
...

Bu zorluğun amacına blok kimlikleri 2D matrisi verilir, bu küçük hücreleri bir araya getirerek tam kontur grafiğini çizin. Tekrarlanan bazı durumlar olduğunu unutmayın (ör. 0 ve 15 görsel olarak aynıdır)

Giriş

Programınız / işleviniz, aralıktaki bir 2D dikdörtgen tamsayı matrisini girdi olarak almalıdır [0+a,15+a]( abu, seçtiğiniz rastgele bir tamsayı kaydırmasıdır; bu, bloklar için sıfır tabanlı indeksleme veya 1 tabanlı indeksleme kullanmanızı sağlar). Bu istenen herhangi bir kaynaktan olabilir (stdin, fonksiyon parametresi, vb.).

Çıktı

Programınız / işleviniz, tam kontur grafiğini temsil eden tek bir dize çıkarmalıdır. Fazladan öndeki / sondaki boşluk olmamalıdır, ancak tek bir sondaki yeni satıra izin verilir. Bitişik bloklar arasında dikey veya yatay bir ayrım olmamalıdır.

Bir "eyer" ile eşleşen bloklar için herhangi bir özel işlem yapmanız gerekmediğini unutmayın; verilen kimliğe sahip bloğu olduğu gibi çizmeniz yeterlidir.

Çıkış istenen herhangi bir lavaboya olabilir (stdout, dönüş değeri, vb.)

Örnekler

Aşağıdaki tüm örneklerde 0 tabanlı blok kimlikleri kullanılmıştır.

case 1:

2 1
4 8

......
......
../\..
..\/..
......
......

case 2:

15 13 12 14 15
13 8 0 4 14
11 1 0 2 7
15 11 3 7 15

...............
......---......
...../...\.....
.../.......\...
...............
../.........\..
..\........./..
...............
...\......./...
.....\.../.....
......---......
...............


case 3:

12 12 12 8 4
0 0 0 0 2
0 0 0 2 7
0 2 3 7 15

........./....\
---------......
...............
...............
...............
............../
............/..
...............
.........../...
........./.....
......---......
...../.........

case 4:

0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15

............
.........---
...\..../...
..\/...|./..
.......|....
...../.|....
/...|...\..\
....|.......
....|.\.....
............
---.........
...../\.....

case 5:

0 0 0 0 6 15 15
0 0 0 0 6 15 15
0 0 0 0 6 15 15
0 0 0 2 7 15 15
0 0 2 5 14 15 15
0 2 5 8 4 12 14
0 4 8 0 0 0 6
0 0 0 0 0 0 4

.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
............/........
.....................
.........../.........
........./...........
.....................
......../../\........
....../../....\......
...............---...
...../../.........\..
.....\/............|.
...................|.
...................|.
....................\
.....................
.....................

puanlama

Bu kod golf; bayt cinsinden en kısa kod kazanır. Standart boşluklar geçerlidir.

Mathematica, 353326 bayt

s=Table[".",3,3];z=Reverse;l@0=l@15=s;y=s;y[[3,1]]="\\";l@1=l@14=y;y=s;y[[3,3]]="/";l@2=l@13=y;y=s;y[[2,All]]="-";l@3=l@12=y;y=l@4=l@11=z/@z@l@1;y[[3,1]]="\\";l@10=y;y=s;y[[All,2]]="|";l@6=l@9=y;y=l@7=l@8=z/@z@l@2;y[[3,3]]="/";l@5=y;StringReplace[ToString@Grid@Map[Column,Map[StringJoin,Map[l,#,{2}],{3}],{2}],{"\n\n"->"\n"}]&

giriş

[{{15, 13, 12, 14, 15}, {13, 8, 0, 4, 14}, {11, 1, 0, 2, 7}, {15, 11, 3, 7, 15}} ]

JavaScript (ES6), 195 bayt

a=>a.map((r,y)=>r.map((i,x)=>[...s='76843210_'].map((_,j)=>(o[Y=y*3+j/3|0]=o[Y]||[])[x*3+j%3]='.\\/-\\/|/\\'[[0,64,256,56,4,257,146,1,68][k=s[i-8]||i]>>j&1&&k])),o=[])&&o.map(r=>r.join``).join`
`

Test senaryoları

let f =

a=>a.map((r,y)=>r.map((i,x)=>[...s='76843210_'].map((_,j)=>(o[Y=y*3+j/3|0]=o[Y]||[])[x*3+j%3]='.\\/-\\/|/\\'[[0,64,256,56,4,257,146,1,68][k=s[i-8]||i]>>j&1&&k])),o=[])&&o.map(r=>r.join``).join`
`

console.log(f([
  [ 2, 1 ],
  [ 4, 8 ]
]));

console.log(f([
  [ 15, 13, 12, 14, 15 ],
  [ 13,  8,  0,  4, 14 ],
  [ 11,  1,  0,  2,  7 ],
  [ 15, 11,  3,  7, 15 ]
]));

console.log(f([
  [ 12, 12, 12,  8,  4 ],
  [  0,  0,  0,  0,  2 ],
  [  0,  0,  0,  2,  7 ],
  [  0,  2,  3,  7, 15 ]
]));

console.log(f([
  [  0,  1,  2,  3 ],
  [  4,  5,  6,  7 ],
  [  8,  9, 10, 11 ],
  [ 12, 13, 14, 15 ]
]));

console.log(f([
  [  0,  0,  0,  0,  6, 15, 15 ],
  [  0,  0,  0,  0,  6, 15, 15 ],
  [  0,  0,  0,  0,  6, 15, 15 ],
  [  0,  0,  0,  2,  7, 15, 15 ],
  [  0,  0,  2,  5, 14, 15, 15 ],
  [  0,  2,  5,  8,  4, 12, 14 ],
  [  0,  4,  8,  0,  0,  0,  6 ],
  [  0,  0,  0,  0,  0,  0,  4 ]
]));

Mathematica, 173 bayt

StringRiffle[ArrayFlatten[ReplacePart[Table[".",16,3,3],{{2|11|15,3,1}|{5|11|12,1,3}->"\\",{3|6|14,3,3}|{6|8|9,1,1}->"/",{4|13,2,_}->"-",{7|10,_,2}->"|"}][[#]]&/@#],"\n",""]&

Wolfram sanal alanında deneyin!

" \n" Yerine gerçek bir yeni satır gelmelidir. Giriş 1 dizinli - örneğin, üçüncü test durumu olur {{13,13,13,9,5},{1,1,1,1,3},{1,1,1,3,8},{1,3,4,8,16}}. Çıktı bir dizedir.

Fikir temelde Jenny_mathy'nin cevabı ile aynıdır - 3x3 "."s ızgara alarak ve bazı karakterleri değiştirerek on altı kareyi yapın , ardından kareleri birleştirin - ancak bunu yapmak için biraz daha kısa fonksiyonlar kullanın. ( Var olduğunu hatırlattığı için alephalpha'ya teşekkürler ArrayFlatten!)

Bu, kareleri temelde zor kodlamak yerine akıllıca yaparak daha az baytta yapılabilir, ancak bu çok daha fazla çaba gerektirir ...

Retina , 165 bayt

T`d`L`1\d
 |\bB\B

.+
X$&¶Y$&¶Z$&
%{`[XYZ]$

([XYZ])[69]
.|.$1
X[^4-B]
...X
X[4AB]
..\X
X[578]
/..X
Y[^369C]
...Y
Y[3C]
---Y
Z[03478BCF]
...Z
Z[1AE]
\..Z
Z[25D]
../Z

Çevrimiçi deneyin! Bağlantı ikinci örneği içerir. Açıklama: İlk iki aşama, boşlukların silinmesine izin vererek ondalıktan onaltılıya dönüşür. Üçüncü aşama daha sonra her satırı üçe katlayarak her yeni satıra ayrı bir işaret verir. Bu işaretçiler daha sonra onaltılık basamakları hareket ettirerek, çizginin sonuna gelene kadar silindikleri kontur grafiğine dönüştürürler.

Python 2 , 247 bayt

J='...'
print'\n'.join(map(''.join,sum([[sum([f[i*3:][:3]for i in j],[])for f in map(list,[J*4+'..\\/...|./../...|...\\..\\'+J*4,J*3+'---.......|........|.......---'+J*3,'...\\..../......../.|........|.\\'+J*3+'./\\.....'])]for j in input()],[])))

Çevrimiçi deneyin!

LeakyNun sayesinde -1 bayt

SOGL V0.12 , 106 89 bayt

žj}² ³
ē0=?²
{ā;{"⁰9═‼pnk№Ο|╚φ;“2─6nwEX .9*3n²Xƨ.ƨ-¹╬-}²X"č7_#‘3n}² /33³\13³\31³/11žj}┼}O

Buradan Deneyin! ( →giriş kolaylığı için fazladan bir bayt vardır . Aksi takdirde dizinin zaten yığın üzerinde olması beklenir)

Piton 2, 196 191 181 176 bayt

Çevrimiçi deneyin!

Bir dizi diziyi alan ve bir dize döndüren bir işlev:

J=''.join;N='\n'.join
f=lambda I:N(N(J(J('\/|-.'[C/16-2]*(C%16)for C in map(ord,'o!j1cSe!f1g1aAbAbAa1h1iAbAbAc!c!d!iSk1f!k'))[c*9+3*j:][:3]for c in r)for j in[0,1,2])for r in I)

EDIT: J, N atayarak 5 bayt kaydetti; başka bir 10 bayt, çünkü girdinin zaten bir dizi dizisi olduğu varsayıldığından; ve daha akıllı dilimlemeyle kurtarılan 5 bayt daha ...

16 3x3 hücrenin birleştirilmiş dizesi (144 bayt, satır satırlarını atlayan) 41 bayt dizesine çalışma uzunluğu kodludur:

o!j1cSe!f1g1aAbAbAa1h1iAbAbAc!c!d!iSk1f!k

burada her RLE öğesi (cellType, length)karaktere kodlanır chr(32+16*cellType+length)(maksimum çalışmanın 15 olması ve ord(' ')==3216 ile bölünmesi kullanışlıdır ). Kod çözme '\/|-.'[cellType]sırasında yazdırılabilir karakter olarak kabul edilir.

Bundan sonra özellikle zekice bir şey yok ...

05AB1E , 61 bayt

v•2mßklJFΘõÿ|åU‚ιØØ•6B5¡∊¶¡110bTǝ.BJ3ô3ôyèøJ»}»4ÝJð«"\./-|."‡

Çevrimiçi deneyin!

Desenin ilk yarısı şu şekilde sıkıştırılabilir:

5
11111105
1111111125
1113335
1105
2111111125
141141145
25

İkinci yarının olması gerekir:

25
141141145
11011105
1105
1113335
1111111125
11111105
5

Biz sadece dikey olarak ilk yarıyı ayna ve ekleyebilirsiniz binary 110 (1101110)için de 2111111125.

Sonra bu deseni alıp beşe ayırıyoruz, sonra onlarla dolduruyoruz:

1 = 111111111
2 = 111111011
3 = 111111112
4 = 111333111
5 = 110111111
6 = 211111112
7 = 141141141
8 = 211111111
9 = 141141141
A = 110111011
B = 110111111
C = 111333111
D = 111111112
E = 111111111

Şimdi yapı taşlarımız var, son parçalar sadece matris girişlerini uygun yapı taşlarıyla değiştiriyor, satırları birbirine sıkıştırıyor ve değiştirilen sembollerle kullanıcıya yazdırıyor:

0 = .........
1 = ......\..
2 = ......../
3 = ...---...
4 = ..\......
5 = /......./
6 = .|..|..|.
7 = /........
8 = /........
9 = .|..|..|.
A = ..\...\..
B = ..\......
C = ...---...
D = ......../
E = .........

Herkes isterse resmi operasyon açıklama gönderebilir, teşekkürler.

Jöle , 64 bayt

“¡_ḟ5⁸ṫ⁺Y"⁷ƘzƬɼ¥@TR/ṖQ½3yİ>ẎḄT¥⁹iḟQ¬Ɠl¹µŒ’ṃ“/-\|.”s3s3ṙ9ị@³ZY$€Y

Çevrimiçi deneyin!

Bu, saf bir sıkıştırma kullanır ve muhtemelen çalışma uzunluğu kodlamasıyla birçok bayt kaydedebilir.

Nasıl çalışır

“¡_ḟ5⁸ṫ⁺Y"⁷ƘzƬɼ¥@TR/ṖQ½3yİ>ẎḄT¥⁹iḟQ¬Ɠl¹µŒ’ṃ“/-\|.”s3s3ṙ9ị@³ZY$€Y
“¡_ḟ5⁸ṫ⁺Y"⁷ƘzƬɼ¥@TR/ṖQ½3yİ>ẎḄT¥⁹iḟQ¬Ɠl¹µŒ’ encodes the integer 4591777158889232952973696500124538798606476761349931038636020730336909822188496590423586252520
ṃ“/-\|.”                   - convert to base 5 and index into the string to get "/......../.........|..|..|...\...\....\.........---.........../......\.................\........../...---.....\....../......./.|..|..|."
        s3s3               - split every 9 characters into a 3x3 square submatrix       
            ṙ9             - rotate left by 9 to line up the submatrix for 1 with index 1
              ị@³          - index the input into this
                 ZY$€Y     - format