एक ASCII समोच्च भूखंड ड्रा

Question

निम्नलिखित 3x3 ब्लॉकों पर विचार करें, जो मार्चिंग स्क्वायर एल्गोरिदम प्रत्येक सेल (0-आधारित लेबल आईडी के साथ) की पहचान करेगा:

0:
...
...
...

1:
...
...
\..

2:
...
...
../

3:
...
---
...

4:
..\
...
...

5:
/..
...
../

6:
.|.
.|.
.|.

7:
/..
...
...

8:
/..
...
...

9:
.|.
.|.
.|.

10:
..\
...
\..

11:
..\
...
...

12:
...
---
...

13:
...
...
../

14:
...
...
\..

15:
...
...
...

इस चुनौती का लक्ष्य ब्लॉक आईडी का 2 डी मैट्रिक्स दिया गया है, इन छोटी कोशिकाओं को एक साथ जोड़कर पूर्ण समोच्च साजिश तैयार करें। ध्यान दें कि कुछ दोहराया मामले हैं (उदाहरण: 0 और 15 नेत्रहीन समान हैं)

इनपुट

आपके प्रोग्राम / फ़ंक्शन को रेंज में पूर्णांक के 2 डी आयताकार मैट्रिक्स के इनपुट के रूप में लेना चाहिए [0+a,15+a](जहां aआपकी पसंद का एक मनमाना पूर्णांक है; यह आपको ब्लॉकों के लिए शून्य-आधारित अनुक्रमण या 1-आधारित अनुक्रमणिका का उपयोग करने की अनुमति देता है)। यह किसी भी स्रोत से वांछित (स्टड, फ़ंक्शन पैरामीटर, आदि) से हो सकता है।

उत्पादन

आपका कार्यक्रम / फ़ंक्शन पूर्ण समोच्च भूखंड का प्रतिनिधित्व करने वाले एकल स्ट्रिंग का उत्पादन करना चाहिए। कोई अतिरिक्त अग्रणी / अनुगामी व्हाट्सएप नहीं होना चाहिए, लेकिन एक एकल अनुगामी न्यूलाइन की अनुमति है। आसन्न ब्लॉकों के बीच लंबवत या क्षैतिज रूप से कोई अलगाव नहीं होना चाहिए।

ध्यान दें कि आपको उन ब्लॉकों के लिए किसी भी प्रकार का विशेष उपचार करने की आवश्यकता नहीं है जो "काठी" के लिए नक्शा करते हैं; बस दिए गए आईडी के रूप में ब्लॉक को ड्रा करें।

आउटपुट वांछित (स्टडआउट, रिटर्न वैल्यू, आदि) के लिए किसी भी सिंक में हो सकता है

उदाहरण

नीचे दिए गए सभी उदाहरण 0-आधारित ब्लॉक आईडी का उपयोग करते हैं।

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

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

स्कोरिंग

यह कोड गोल्फ है; बाइट्स में सबसे छोटा कोड जीतता है। मानक खामियां लागू होती हैं।

Comments

सम्बंधित।

— मार्टिन एंडर

क्या अंतिम परीक्षण के मामले में ऊर्ध्वाधर पट्टियों की 3 अधिक अग्रणी लाइनें नहीं होनी चाहिए?

— द्वीमा

हाँ, ठीक है। धन्यवाद!

— Helloworld922

हेक्सिडेसिमल इनपुट का उपयोग करना चाहिए।

— मैजिक ऑक्टोपस Urn

आंतरिक रूप से काटता है।

— मैजिक ऑक्टोपस Urn

Answer 1

गणितज्ञ, 353 326 बाइट्स

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"}]&

इनपुट

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

Comments

प्रभावशाली, मैथमेटिका में ऐसा करना कठिन है।

— मैजिक ऑक्टोपस Urn

Answer 2

जावास्क्रिप्ट (ईएस 6), 195 बाइट्स

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`
`

परीक्षण के मामलों

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 ]
]));

Answer 3

Mathematica, 173 बाइट्स

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",""]&

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं!

" \n" को एक वास्तविक न्यूलाइन द्वारा प्रतिस्थापित किया जाना चाहिए। इनपुट 1-अनुक्रमित है - उदाहरण के लिए, तीसरा परीक्षण मामला बन जाता है {{13,13,13,9,5},{1,1,1,1,3},{1,1,1,3,8},{1,3,4,8,16}}। आउटपुट एक स्ट्रिंग है।

यह विचार मूल रूप से जेनी_मैथी के उत्तर के समान है - "."एस के 3x3 ग्रिड लेने और कुछ पात्रों को बदलने के द्वारा सोलह वर्ग बनाते हैं , फिर वर्गों को एक साथ सिलाई करते हैं - लेकिन इसे करने के लिए थोड़ा कम कार्यों का उपयोग करना। ( मौजूद है कि मुझे याद दिलाने के लिए alephalpha के लिए धन्यवाद ArrayFlatten!)

यह संभव है कि यह कम बाइट्स में किया जा सकता है, क्योंकि चौराहों को चतुराई से बनाने के बजाय मूल रूप से उन्हें हार्डकोडिंग किया जा सकता है, लेकिन इसके लिए बहुत अधिक प्रयास की आवश्यकता होगी ...

Comments

@ जेनी_मथी: संपादित - क्या आप चाहते थे?

— पेड़ नहीं

@ जेनी_मैथी, यह मेरे लिए काम कर रहा है। मैं 1-इंडेक्सिंग का उपयोग कर रहा हूं, इसलिए आपको प्रत्येक संख्या में 1 जोड़ने की आवश्यकता है; परीक्षण का मामला बन जाता है {{16,14,13,15,16},{14,9,1,5,15},{12,2,1,3,8},{16,12,4,8,16}}। यदि आपने कोशिश की है और यह अभी भी काम नहीं कर रहा है, तो क्या आप मुझे बता सकते हैं कि आपको क्या समस्या है?

— एक पेड़ नहीं

Answer 4

रेटिना , 165 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक में दूसरा उदाहरण शामिल है। स्पष्टीकरण: पहले दो चरण दशमलव से हेक्साडेसिमल में परिवर्तित होते हैं, जिससे रिक्त स्थान को हटाया जा सकता है। तीसरा चरण तब प्रत्येक पंक्ति को तीन गुना करता है, प्रत्येक नई रेखा को एक अलग मार्कर देता है। ये मार्कर तब हेक्स अंकों को पार करते हैं, उन्हें समोच्च भूखंड में परिवर्तित करते हैं, जब तक वे लाइन के अंत तक नहीं पहुंच जाते, तब तक वे किस बिंदु पर हटाए जाते हैं।

Answer 5

पायथन 2 , 247 बाइट्स

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()],[])))

इसे ऑनलाइन आज़माएं!

-1 बाइट लिकेन के लिए धन्यवाद

Comments

कृपया ध्यान दें कि 10 और 5 अलग हैं।

— लीक

@ LeakyNun आह मुझे पता था कि मुझे कुछ गड़बड़ करनी होगी। जब तक मैं इसे ठीक नहीं करता, कल तक हटा सकता हूं।

— हाइपरन्यूट्रिनो

@LeakyNun मैंने कोड तय कर लिया है, हालांकि अब यह बहुत ही बदसूरत और अपवित्र हो गया है।

— हाइपरनेत्रिनो

Answer 6

SOGL V0.12 , 106 89 बाइट्स

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

यह कोशिश करो! (जिसमें →इनपुट में आसानी के लिए एक अतिरिक्त बाइट है । यह अन्यथा स्टैक पर पहले से ही सरणी की उम्मीद करेगा)

Comments

कृपया SOGL दुभाषिया का उपयोग मोनोस्पेस फॉण्ट> करें। <

— HyperNeutrino

10 स्लैश 10 अवधियों से अधिक व्यापक हैं।

— हाइपरन्यूट्रिनो

Answer 7

पायथन 2, 196 191 181 176 बाइट्स

इसे ऑनलाइन आज़माएं!

एक ऐसा फंक्शन, जो कि किलों की सारणियों की एक सरणी लेता है और एक स्ट्रिंग लौटाता है:

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 असाइन करके 5 बाइट्स बचाए; एक और 10 बाइट्स क्योंकि मैं भूल गया कि इनपुट पहले से ही ints के सरणियों की एक सरणी माना जाता है; और फिर एक और 5 बाइट्स चालाक टुकड़ा करने की क्रिया से बचाया ...

सभी 16 3x3 कोशिकाओं (144 बाइट्स, लाइनब्रीक को छोड़ना) का संक्षिप्त स्ट्रिंग रन-लंबाई-एन्कोडेड 41 बाइट स्ट्रिंग:

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

जहां प्रत्येक RLE तत्व (cellType, length)वर्ण से एन्कोड किया गया है chr(32+16*cellType+length)(यह आसान है कि अधिकतम रन 15 है; और यह ord(' ')==3216 से विभाज्य है)। डिकोडिंग करते समय, हम '\/|-.'[cellType]प्रिंट करने योग्य चरित्र के रूप में लेते हैं ।

उसके बाद विशेष रूप से चालाक कुछ भी नहीं ...

Answer 8

05AB1E , 61 बाइट्स

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

इसे ऑनलाइन आज़माएं!

---

पैटर्न के पहले आधे हिस्से को निम्न प्रकार से संकुचित किया जा सकता है:

5
11111105
1111111125
1113335
1105
2111111125
141141145
25

दूसरी छमाही की आवश्यकता होगी:

25
141141145
11011105
1105
1113335
1111111125
11111105
5

हम केवल पहली छमाही को लंबवत रूप से मिरर कर सकते हैं, और इसके लिए सम्मिलित binary 110 (1101110)कर सकते हैं 2111111125।

---

अगला हम इस पैटर्न को लेते हैं और फाइव्स पर विभाजित करते हैं, फिर इसे लोगों के साथ पैड करते हैं:

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

अब हमारे पास हमारे बिल्डिंग ब्लॉक हैं, अंतिम भाग बस मैट्रिक्स प्रविष्टियों को उपयुक्त बिल्डिंग ब्लॉकों के साथ बदलते हैं, पंक्तियों को एक साथ ज़िप करते हैं और प्रतिस्थापित प्रतीकों के साथ उपयोगकर्ता को प्रिंट करते हैं:

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

औपचारिक ऑपरेशन स्पष्टीकरण पोस्ट कर सकते हैं अगर कोई इसे चाहता है, धन्यवाद।

Answer 9

जेली , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह एक अनुभवहीन संपीड़न का उपयोग करता है और संभवतः रन-लंबाई एन्कोडिंग के साथ कई बाइट्स को बचा सकता है।

यह काम किस प्रकार करता है

“¡_ḟ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