ASCII आरा पहेली

Question

यह एक 3x3ASCII पहेली है:

 _____ _____ _____
|    _|     |_    |
|   (_   _   _)   |
|_   _|_( )_|_   _|
| (_) |_   _| (_) |
|  _   _) (_   _  |
|_( )_|_   _|_( )_|
|    _| (_) |_    |
|   (_       _)   |
|_____|_____|_____|

यह भी एक 3x3ASCII पहेली है:

 _____ _____ _____
|     |_   _|     |
|  _   _) (_   _  |
|_( )_|_   _|_( )_|
|    _| (_) |_    |
|   (_   _   _)   |
|_   _|_( )_|_   _|
| (_) |_   _| (_) |
|      _) (_      |
|_____|_____|_____|

ASCII पहेली में प्रत्येक पंक्ति (किनारों के मामलों को छोड़कर अर्थात किनारों पर शाब्दिक रूप से टुकड़े) में निम्न पैटर्न होते हैं:

   _           _           _
 _( )_ _   _ _( )_ _   _ _( )_
|_   _| (_) |_   _| (_) |_   _|
 _) (_   _   _) (_   _   _) (_
|_   _|_( )_|_   _|_( )_|_   _| ...
  (_)         (_)         (_)

2 पूर्णांकों को देखते हुए Hऔर Wजहां Hऊंचाई (ऊर्ध्वाधर राशि) और Wचौड़ाई (क्षैतिज राशि) और है Hऔर Wकर रहे हैं >1उत्पादन एक संभव HxWASCII पहेली।

उदाहरण

टेस्ट केस 1

इनपुट: 2, 4

आउटपुट:

 _____ _____ _____ _____
|     |_   _|     |_    |
|  _   _) (_   _   _)   |
|_( )_|_   _|_( )_|_   _|
|    _| (_) |_   _| (_) |
|   (_       _) (_      |
|_____|_____|_____|_____|

टेस्ट केस 2

इनपुट: 4, 4

आउटपुट:

 _____ _____ _____ _____
|     |_   _|     |_    |
|  _   _) (_   _   _)   |
|_( )_|_   _|_( )_|_   _|
|    _| (_) |_   _| (_) |
|   (_   _   _) (_   _  |
|_   _|_( )_|_   _|_( )_|
| (_) |_   _| (_) |_    |
|  _   _) (_   _   _)   |
|_( )_|_   _|_( )_|_   _|
|    _| (_) |_   _| (_) |
|   (_       _) (_      |
|_____|_____|_____|_____|

टेस्ट केस 3

इनपुट: 3, 5

आउटपुट:

 _____ _____ _____ _____ _____
|     |_   _|     |_   _|     |
|  _   _) (_   _   _) (_   _  |
|_( )_|_   _|_( )_|_   _|_( )_|
|    _| (_) |_   _| (_) |_    |
|   (_   _   _) (_   _   _)   |
|_   _|_( )_|_   _|_( )_|_   _|
| (_) |_   _| (_) |_   _| (_) |
|      _) (_       _) (_      |
|_____|_____|_____|_____|_____|

टेस्ट केस 4

इनपुट: 2, 2

आउटपुट:

 _____ _____
|    _|     |
|   (_   _  |
|_   _|_( )_|
| (_) |_    |
|      _)   |
|_____|_____|

स्पष्टीकरण

• प्रत्येक पहेली टुकड़े के लिए ऊंचाई और चौड़ाई को ऊपर या नीचे नहीं बढ़ाया जाना चाहिए।
• के साथ Hऔर Wएक से अधिक होने के नाते, संभव सबसे छोटे आयाम हैं 2x2(देखें IO 4)।
• आप एक पूर्ण कार्यक्रम या एक समारोह हो सकता है।
• इनपुट H1 और 2 पर 2 लाइनें होगी Wयदि आप एक फ़ंक्शन का उपयोग कर रहे हैं तो आप उन्हें मापदंडों में रख सकते हैं।
• स्टडआउट (या कुछ इसी तरह) के लिए आउटपुट।
• यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे कम जवाब।

Comments

टुकड़ों की टैब बारी-बारी से दिशाओं में होनी चाहिए?

— जर्बद

क्या मुझे यादृच्छिक पर आउटपुट करना चाहिए या क्या मैं हर बार केवल एक पहेली का उत्पादन कर सकता हूं? यदि यादृच्छिक पर, सभी पहेलियाँ समान रूप से उपलब्ध होनी चाहिए?

— user48538

@Zgarb हाँ, मैं पहेली में प्रत्येक पंक्ति के मूल पैटर्न में संपादित किया गया है

— Bobas_Pett

@ zyabin101 आपको बस एक संभावित "ASCII पहेली" का उत्पादन करने की आवश्यकता है इसलिए 1 इनपुट के लिए केवल 1 आउटपुट

— Bobas_Pett

पहला प्रयास यह देख रहा है कि यह मेगाबाइट के बारे में समाप्त होने जा रहा है। अच्छा प्रश्न।

— एलपेड्रो

Answer 1

जावास्क्रिप्ट (ईएस 6) 272 277 271

बग फिक्स संपादित करें

संपादित 2 सहेजे गए 6 बाइट्स thx @ L.Serné

3 बग फिक्स को फिर से संपादित करें

(w,h,z=(s,q=3,i=h)=>'|  '.slice(0,q)+s.repeat(w).substr(i%2*6+q,w*6-q-~-q)+`  |
`.slice(~q))=>eval("t=z(' _____',0,0)+z('|_   _|     ',2,--h)+z(b=' _) (_   _  ')+z(c='|_   _|_( )_',0);for(a='|_   _| (_) ';--h;)t+=z(a,2)+z(b)+z(c,0)")+z(a,2)+z(' _) (_      ')+z('|_____',1)

कम गोल्फ वाला

(w,h,
  z=(s,q=3,i=h)=>'|  '.slice(0,q)+s.repeat(w).substr(i%2*6+q,w*6-q-~-q)+'  |\n'.slice(~q),
  a='|_   _| (_) ',
  b=' _) (_   _  ',
  c='|_   _|_( )_',
  t=z(' _____',0,0)+z('|_   _|     ',2,--h)+z(b)+z(c,0)
)=>{
  for(;--h;)
    t+=z(a,2)+z(b)+z(c,0);
  return t+z(a,2)+z(' _) (_      ')+z('|_____',1)
}

परीक्षा

F=
(w,h,z=(s,q=3,i=h)=>'|  '.slice(0,q)+s.repeat(w).substr(i%2*6+q,w*6-q-~-q)+`  |
`.slice(~q))=>eval("t=z(' _____',0,0)+z('|_   _|     ',2,--h)+z(b=' _) (_   _  ')+z(c='|_   _|_( )_',0);for(a='|_   _| (_) ';--h;)t+=z(a,2)+z(b)+z(c,0)")+z(a,2)+z(' _) (_      ')+z('|_____',1)

function update() {
  var w=+W.value,h=+H.value
  O.textContent=F(w,h)
}

update()

W<input id=W value=2 oninput='update()' type=number min=2>
H<input id=H value=2 oninput='update()' type=number min=2>
<pre id=O></pre>

Comments

बहुत अच्छा! गोल्फ संस्करण मुझे परेशानी दे रहा है, हालांकि: Nx2 काम नहीं करता है (जैसे 3x2 पैदावार अपरिभाषित | ( ) | _ | (_ _) (_ _) | _____ | _____ | _____ | और शीर्ष-दाएं में एक विषम ऊंचाई परिणाम सबमिट करना। टुकड़ा अपनी शीर्ष सीमा को याद कर रहा है। ऐसा लगता है कि गोल्फ-लेशन में कुछ खो गया है। संपादित करें: गोल्फ और गैर-गोल्फ कोड दोनों से "विषम ऊंचाई" बग परिणाम।

— बेंस जोफुल

@BenceJoful आखिरी गोल्फिंग के बाद पर्याप्त परीक्षण नहीं। अब नियत है

— edc65

आप अंतिम तर्क (t) की घोषणा और चौथे तर्क (a) को लूप के लिए ले जा सकते हैं (और b और c की घोषणा को इस तरह से t के घोषणा के अंदर ले जा सकते हैं: for(t=z(' _____',0,0)+z('|_ _| ',2,--h)+z(b=' _) (_ _ ')+z(c='|_ _|_( )_',0);--h;a='|_ _| (_) ')यह 4 अल्पविराम को बचाता है, इसलिए आप समाप्त करते हैं। केवल 273 अक्षर। EDIT: टेस्ट स्निपेट अभी भी खराब है ...

— लूका

@ L.Serné ने कैसे बदला? आप t=...इसके लिए अंदर नहीं डाल सकते , यह h == 2 के लिए विफल रहता है। यह ठीक है कि बग मैंने आज तय किया।

— edc65

एनपी, मैंने आपके कोड के साथ खेला, और लूप के अंतिम भाग में undefinedघोषित aहोने का कारण बना for। मैंने कोड को थोड़ा बदल दिया, और इसके साथ समाप्त हुआ। आप को एकीकृत करने में सक्षम होना चाहिए कि एक और 2 बी बचाने के लिए। (w,h,z=(s,q=3,i=h)=>'| '.slice(0,q)+s.repeat(w).substr(i%2*6+q,w*6-2*q+1)+' |\n'.slice(~q),a='|_ _| (_) ')=>{for(t=z(' _____',0,0)+z('|_ _| ',2,--h)+z(b=' _) (_ _ ')+z(c='|_ _|_( )_',0);--h;)t+=z(a,2)+z(b)+z(c,0);return t+z(a,2)+z(' _) (_ ')+z('|_____',1)}(276 बी)।

— ल्यूक

Answer 2

पायथन, 513 बाइट्स

def r(m,n):
 r=3*m
 c=6*n
 l=3-(n%2)*3
 z=[1,2,3,4,5,0]
 p=zip
 return"\n".join("".join(" |_()"[[[((j%6,i%3)in[(1,0),(5,0)])*2or((j%6,i%3)in[(0,1),(0,0)])or((j%4,i%6)in[(1,1),(1,2),(3,4),(3,5)])*2or((i%6,j%12)in p(z,[10,2,10,4,8,4]))*4or((i%6,j%12)in p(z,[8,4,8,2,10,2]))*3,1,0][j in[0,c]or((j,i%6)in p([1,1,2,2],[1,2]*2)+p([c-1,c-1,c-2,c-2],[1+l,2+l]*2)or(i,j%12)in[(1,8),(1,9),(1,10),(2,8),(2,9),(2,10),(r-1,9)]or(i,j%12)==(r-1,3+6*(m%2)))*2],2*(j%6>0)or i>0][i in[0,r]]]for j in range(c+1))for i in range(r+1))

गोल्फिंग की तुलना में शायद किसी अभ्यास में अधिक, यह इस बात को तय करके काम करता है कि प्रत्येक (x,y)समन्वय किस वर्ण में जाता है बजाय स्ट्रिंग द्वारा प्रत्येक पैटर्न को बनाने के लिए। अधूरा ऐसा दिखता है

char_codes = " |_()"
def base(row, col):
    if col % 6 in [5] and row % 3 in [0, 2]:
        return 1
    if col % 6 in [0, 4] and row % 3 in [2]:
        return 2
    return 0

def underscores(row, col):
    if col % 4 in [0] and row % 6 in [0, 1] or col % 4 in [2] and row % 6 in [3, 4]:
        return 2
    return 0

def parentheses(row, col):
    if (row % 6, col % 12) in [(0, 9), (1, 1), (2, 9), (3, 3), (4, 7), (5, 3)]:
        return 4
    if (row % 6, col % 12) in [(0, 7), (1, 3), (2, 7), (3, 1), (4, 9), (5, 1)]:
        return 3
    return 0

def value(row, col):
    return base(row, col) + underscores(row, col) + parentheses(row, col)

def new_value(last_row, last_col, row, column):
    if row in [0, last_row]:
        return 2*(column % 6 > 0) or row>0
    if column in [0, last_col]:
        return 1
    if column in [1,2] and row % 6 in [1, 2]:
        return 0
    if column in [last_col - 1, last_col - 2] and row % 6 in [[4,5],[1,2]][last_col%12>0]:
        return 0
    if row in [1, 2] and column % 12 in [8,9,10]:
        return 0
    if row == last_row - 1 and column % 12 == 9:
        return 0
    return value(row - 1, column - 1)

def puzzle(rows, cols):
    last_row = rows * 3
    last_col = cols * 6
    return "\n".join("".join(new_value(last_row, last_col, row, col) for col in range(last_col + 1)) for row in range(last_row + 1))

पैटर्न खुद की तरह दिखते हैं

हम इसे पूर्णांक से लुकअप तालिका के रूप में देख सकते हैं जिसमें मॉड 6 और पंक्तियाँ मॉड 3 लिया गया है

 012345
0     |
1
2_   _|

 0123
0_
1_
2
3  _
4  _
5

 0123456789AB
0       ( )
1 ) (
2       ( )
3 ( )
4       ) (
5 ( )

विभिन्न पैटर्नों के संयोजन की इस रणनीति ने मेरे लिए वास्तव में यहां काम नहीं किया है क्योंकि उन्हें व्यक्त करना काफी बोझिल है (हालांकि मुझे लगता है कि मैं और अधिक गोल्फ हो सकता था) और क्योंकि किनारे के मामलों को ठीक करने के लिए इतने सारे अक्षर लगते हैं। मैं इस पर ध्यान नहीं दे रहा हूं क्योंकि इसमें मुझे एक मिनट का समय लगा है और यह दिलचस्पी का हो सकता है।

Comments

सेमीकॉलन द्वारा अलग की गई 1 लाइन पर पूरी चीज़ लगाकर आप 7 बाइट्स बचा सकते हैं

— ब्लू

@ धन्यवाद धन्यवाद दोस्त, यह मेरे पिछले गोल्फ के बाद से एक समय हो गया है और मैं कुछ चालें भूल गया हूं।

— 18

Answer 3

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

(m=#~Mod~2&;a=#~Array~Y&;s=(h="   _  ")[o="|_( )_",z="|_   _",w=" _) (_",z,p="| (_) "];l="|  _  "[o,"|    _",u="|   (_",z,p];r=h[o,q="|_    ",t=" _)   ",z,p];{X,Y}=#;a[" _____"&]<>" \n"<>Join[{a[If[#<Y,z,q]["|     "][[m@#]]&]},Table[Which[y<2,l,y<Y,s,0<1,r][[Mod[x+3y,6]]],{x,3,3X-1},{y,1,Y}],{a[If[#<2,"|     "[u],"      "[If[#<Y,w,t]]][[m[X+#]]]&],a["|_____"&]}]~Riffle~"|\n"<>"|")&

अपने तर्क के रूप में पूर्णांकों की एक ऑर्डर की गई जोड़ी लेने का कार्य करते हैं, और एक स्ट्रिंग को वापस लेते हैं जिसमें उपयुक्त न्यूलाइन्स होते हैं। रिक्त स्थान और नए लिंक के साथ:

(m = Mod[#1, 2] &; a = Array[#1, Y] &; 
 s = (h = "   _  ")[o = "|_( )_", z = "|_   _", w = " _) (_", z, p = "| (_) "];
 l = "|  _  "[o, "|    _", u = "|   (_", z, p]; 
 r = h[o, q = "|_    ", t = " _)   ", z, p];
 {X, Y} = #1; 
 a[" _____" &] <> " \n" <>
 Riffle[
   Join[
     {a[If[#1 < Y, z, q]["|     "][[m[#1]]] &]}, 
     Table[
       Which[y < 2, l, y < Y, s, 0 < 1, r][[Mod[x + 3 y, 6]]],
       {x, 3, 3 X - 1}, {y, 1, Y}
     ],
     {a[If[#1 < 2, "|     "[u], "      "[If[#1 < Y, w, t]]][[m[X + #1]]] &],
     a["|_____" &]}
   ], "|\n"
 ] <> "|") &

Answer 4

बैच, 562 528 बाइट्स

@echo off
set t=!  !
set w=%2
set a= _) (_!_   _! (_) !        _  !_( )_!_   _ _) (_
call:d "!     !_   _" 2 " _____ _____" 4
for /l %%j in (2,1,%1)do call:t
call:d "!_____!_____" 1 "%a:~18,6%%a:~-6%" 3
exit/b
:t
set a=%a:~24%%a:~0,24%
call:d "%a:~6,6%%a:~30,6%" 1 "%a:~0,6%%a:~24,6%" 3
call:c "%a:~12,6%%a:~36,6%" 2
exit/b
:d
call:c %3 %4
:c
set s=
for /l %%i in (%w%,-2,1)do call set s=%~1%%s%%&if %%i==1 call set s=%%s:~6%%
if %2 lss 4 set s=%s%!&call set s=%%t:~0,%2%%%%s:~%2,-%2%%%%t:~-%2%%
echo %s:!=^|%

गोल्फ के लिए प्रतिरोधी साबित, के रूप में पुनरावृत्ति लागत को खत्म करने के लिए कई बाइट्स का खर्च करने के लिए, उदाहरण के लिए, मैं मैन्युअल रूप से लाइन नंबर 3 में गुजरता हूं क्योंकि यह गणना करना बहुत महंगा है। संपादित करें: इसके अलावा, मैंने अनजाने में |हर तीसरी पंक्ति में अतिरिक्त गोल्फिंग की थी, जो गलत है। इसे ठीक करने से वास्तव में मुझे 2 बाइट्स (मेरे मूल संस्करण पर 4 बाइट्स) की बचत हुई। स्पष्टीकरण: aआरा के विभिन्न बिट्स शामिल हैं। :tसमारोह स्वैप उन्हें तीन पंक्तियों के प्रत्येक सेट से अधिक है, तो आवश्यक सबस्ट्रिंग जो अर्क :cसमारोह तो जोड़े में दोहराता है, लेकिन पहले कॉलम को हटाने अगर wअजीब है। पंक्ति आउटपुट होने से पहले बाएं और दाएं किनारे के मामलों को संभाला जाता है। दूसरे किनारे का मामला पहली पहली पंक्ति है जिसमें !s को रिक्त स्थान के बजाय बदल दिया जाता है|s (कोड |s से बचता है क्योंकि वे बैच में संभाल करने के लिए मुश्किल हैं)।

Answer 5

Befunge, 263 243 बाइट्स

|_   _| (_)
 _) (_   _
|_   _|_( )_

|
|
|_____
 _____
>&:08p3*28p&:18p6*38pv
@#!`g82:,_v0+55+1p84:<_
\g82+g84<| `g83:+1,g\%*6-g852+*6/3+2g84\++%3+2\!:g84*4p85:!!+*`0%6\!*`
6/08g+2%^>>::::48g3/2%2*`\48g3/18g+2%!2*+38g\`*!48g3%0`*\::6/2%!48g\`\

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

जिस तरह से यह काम x, y के उस निर्देशांक से पुनरावृत्त होता है, जिस क्षेत्र में हम आउटपुट करना चाहते हैं, और उन x , y मानों को u मैपिंग करना चाहते हैं , v पहेली पैटर्न में निर्देशांक (playfield की पहली तीन पंक्तियों पर संग्रहीत)। यह मानचित्रण निम्नलिखित मूल सूत्रों के साथ प्राप्त किया जाता है:

u = (x+(y+2)/3*6) % 12
v = (y+2)%3 + (y==0)

यू समन्वय की जरूरत है 6 हर 3 पंक्तियों की भरपाई हो के लिए हर 12 कॉलम को दोहराता है, लेकिन यह भी। V दोहराता समन्वय हर 3 पंक्तियों, लेकिन हम जोड़ने के y==0मूल्य तो बहुत पहली पंक्ति एक विशेष मामले के रूप में प्रदान की जा सकती है, करने के लिए। हालांकि, किनारों को संभालने के लिए, हमें एक अतिरिक्त बूलियन मूल्य, ई , जो विभिन्न एज स्थानों के लिए सही है, और जो निम्नानुसार सूत्र समायोजित करता है, को पेश करने की आवश्यकता है:

u = (x+(y+2)/3*6) % (e?6:12)
v = (y+2)%3 + (y==0) + e*4

इस प्रकार यदि हम एक किनारे पर हैं, तो हम 5 से 7. की तर्ज पर सरल बढ़त पैटर्न का उपयोग करने के लिए 4 से v समन्वय में जोड़ते हैं और हमें इस किनारे के पैटर्न के बाद से अब यू को 6 के बजाय 12 से समन्वयित करने की आवश्यकता है। हर 6 कॉलम को दोहराता है।

ई मूल्य के लिए के रूप में , कि एक काफी जटिल सूत्र की आवश्यकता है, के बाद से बढ़त स्थानों पहेली सीमा के कुछ हद तक अनियमित क्षेत्र शामिल हैं।

elr = (x <= 2*y/3%2 or x >= w-2*!(y/3+cols)%2) and (y%3 > 0)
etb = (y <= !(x/6%2) or y >= h-(x/6+rows)%2) and (x%6 > 0)
e   = elr or etb

बहुत अधिक विस्तार में जाने के बिना, मूल ब्रेकडाउन यह है कि एल्र बाएं और दाएं सीमाओं के साथ किनारे के स्थानों से मेल खाता है, जबकि ईटीबी शीर्ष और नीचे की सीमाओं के साथ स्थानों से मेल खाता है।

Answer 6

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

f=
(h,w,a=` _) (_|_   _| (_)    _  |_( )_|_   _      |     |_____`.match(/.{6}/g),g=(l,r,j)=>a[7].slice(0,j)+(a[l]+a[r]).repeat(w).slice(j,w*6+1-j)+`  |`.slice(-j))=>[` _____`.repeat(w),g(1,7,2),...[...Array(--h*3)].map((_,i)=>g(i%6,(i+3)%6,"312"[i%3])),g(h=h%2*6,6-h,3),g(8,8,1)].join`
`

<div oninput=o.textContent=+h.value&&+w.value?f(h.value,w.value):''><input id=h type=number min=1><input id=w type=number min=1><pre id=o>

यह मेरे बैच उत्तर का एक बंदरगाह है, बस यह देखने के लिए कि क्या यह @ edc65 के उत्तर के साथ प्रतिस्पर्धा करता है। झुंझलाहट लंबे स्ट्रिंग में आरा टुकड़े होते हैं। पहले छह टुकड़े आरा के इंटीरियर के एक कॉलम की दो पंक्तियों का प्रतिनिधित्व करते हैं। चौथे टुकड़े के स्थान पर सातवें टुकड़े का उपयोग आरा की प्रायद्वीपीय रेखा के लिए किया जाता है। पांचवें टुकड़े के स्थान पर आरा की दूसरी पंक्ति में आठवें टुकड़े का उपयोग किया जाता है, और यह भी आरा के बाएं किनारे के रूप में दोहरा कर्तव्य करता है। नौवां टुकड़ा आरा की अंतिम पंक्ति है।