Z पर एक मार्कर के साथ उछाल-धार वाला XY बॉक्स

Question

लंबे समय बाद पहली बार यहां पोस्टर लचर।

एक प्रोग्राम लिखें जो 3 इनपुट लेता है: एक्स, वाई और जेड।

• X = पार (कॉलम)
• Y = नीचे (पंक्तियाँ)
• Z = स्थान मार्कर

प्रोग्राम को तब एक दृश्य ग्रिड X को प्रिंट करना चाहिए और Y नीचे। यह ग्रिड "+" को छोड़कर किसी भी वर्ण का बनाया जा सकता है। प्रत्येक 'लोकेशन' को एक इंडेक्स नंबर दिया जाता है, जो कि 1 से 1 तक, 1 के पार और फिर अंत तक नीचे गिना जाता है।

X और Y हमेशा कम से कम 3 होंगे और Z कभी भी इससे बड़ा नहीं होगा X * Y।

Z उस स्थान का प्रतिनिधित्व करेगा जो "+" के रूप में मुद्रित किया गया है, स्थान पर और साथ ही 1 वर्ण बाएँ, दाएँ, ऊपर और नीचे। उदाहरण के लिए:

 +
+++
 +

अंत में, अगर + अक्षर किनारों (सबसे ऊपर, सबसे बाएं, दाएं सबसे अधिक और / या सबसे नीचे वाले किनारे) को रोकते हैं, तो + को उसी अक्ष पर वापस उछालना चाहिए और दूसरी तरफ ओवरफ्लो करना चाहिए।

उदाहरण: इनपुट = ५, ५, १३

-----
--+--
-+++-
--+--
-----

इनपुट = 10, 10, 10

-------+++
---------+
---------+
----------
----------
----------
----------
----------
----------
----------

इनपुट = 10, 10, 21

----------
+---------
+++-------
+---------
----------
----------
----------
----------
----------
----------

संपादित करें: गैर वर्ग उदाहरण 16,3,32

---------------+
-------------+++
---------------+

मुझे लगता है कि मैंने सब कुछ कवर कर लिया है। इनपुट की कोई सीमा नहीं होनी चाहिए, लेकिन यदि आपके प्रोग्राम की आवश्यकता है, तो इसे 64 * 64 पर कैप करें।

बोनस बिंदु (क्या मैं ऐसा कर सकता हूं?): इनपुट Z> X * Y नहीं होना चाहिए, लेकिन यदि यह Y * Z से बड़ा है, तो केंद्र + को ग्रिड के मध्य में आउटपुट करें। EDIT: इनपुट Z X * Y से बड़ा नहीं हो सकता

2 संपादित करें:। X और Y में कुछ बदलाव करके उम्मीद की जा सकती है कि यह स्पष्ट हो

यह कोड गोल्फ, सबसे छोटा कोड जीत है।

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक अच्छी चुनौती है, लेकिन मैं सैंडबॉक्स को भविष्य की चुनौतियों को पोस्ट करने की सलाह देता हूं जहां वे मुख्य साइट पर पोस्ट किए जाने से पहले प्रतिक्रिया प्राप्त कर सकते हैं।

— 5

"बोनस बिंदु" के बारे में क्या है? उस सटीक सुविधा को लागू करने से आपकी बाइट-काउंट का लाभ मिलता है? यदि ऐसा होता है, तो आपको स्पष्ट रूप से ध्यान देना चाहिए कि यह कितना बड़ा बोनस है। (एक साइड नोट के रूप में, कोड-गोल्फ में बोनस आमतौर पर हतोत्साहित किया जाता है )

— जेम्स

@ लेटसेग - उफ़। क्षमा करें, उम्मीद है कि मैं कुछ महत्वपूर्ण कदम उठाने से चूक गया।

— जेक हैरी

@DrMcMoylex - धन्यवाद, धन्यवाद, अब बोनस हटा दिया है।

— जेक हैरी

आपको पोस्टिंग के पहले दिन में एक उत्तर स्वीकार नहीं करना चाहिए, मुझे पूरा विश्वास है कि MATL / Jelly / 05AB1E गोल्फर इसे देखेगा और इसे पायथन की तुलना में बहुत कम बाइट्स में हल करेगा। मुझे लगता है कि ज्यादातर लोग कम से कम एक सप्ताह इंतजार करते हैं।

— काडे

Answer 1

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

def f(x,y,z):A=[['-']*x for _ in' '*y];z-=1;X,Y=z%x,z/x;a=[2,-1];A[Y][X]=A[Y+a[Y>0]][X]=A[Y-a[Y<y-1]][X]=A[Y][X+a[X>0]]=A[Y][X-a[X<x-1]]='+';print'\n'.join(map(''.join,A))

संपादित करें: फ़ंक्शन को परिवर्तित करके 1 बाइट्स सहेजे गए।

पिछला (अधिक पठनीय):

x,y,z=inputtt
A=[['-']*x for _ in' '*y]
z-=1
X,Y=z%x,z/x
a=[2,-1]
A[Y][X]=A[Y+a[Y>0]][X]=A[Y-a[Y<y-1]][X]=A[Y][X+a[X>0]]=A[Y][X-a[X<x-1]]='+'
print'\n'.join(map(''.join,A))

Comments

अच्छा काम, मुझे लगता है कि मैंने इसे 10,100,300 के साथ तोड़ दिया। दूर सही सीमा पर व्यवहार नहीं लगता है?

— जेक हैरी

@JakeHarry मेरे लिए काम करता है: ideone.com/G2fwV1

— TFeld

आह, मैं एक अचेत हूँ, मैंने जिस विचारधारा का इस्तेमाल किया है वह निश्चित चौड़ाई नहीं थी इसलिए यह तकनीकी रूप से सही था, न कि आँखों के लिए।

— जेक हैरी

Answer 2

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

(x,y,z,a=[...Array(y)].map(_=>Array(x).fill`-`))=>a.map(a=>a.join``,a[b=--z/x|0][c=z%x]=a[b?b-1:2][c]=a[b][c?c-1:2]=a[y+~b?b+1:y-3][c]=a[b][++c<x?c:x-3]=`+`).join`\n`

Answer 3

Befunge, 175 बाइट्स

>&:10p60p&:00p&1-:10g%:20p\10g/:30p::1+00g-!-\!+2-50p::1+1v
vg02g01*`\4\`0:-g05\!-g03:g00p01-1<g06+p00-1<p04-2+!\-!-g0<
>-!*\10g40g-:0`\4\`**+!2*"+"+10g:#^_$5500g:#^_$$$>:#,_@

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

पहली पंक्ति (और दूसरी पंक्ति पर एक छोटी सी निरंतरता) वह जगह है जहाँ मापदंडों को पढ़ा जाता है और कुछ स्थिरांक की गणना की जाती है - स्थान ( lx , ly ) के निर्देशांक, साथ ही समायोजित निर्देशांक जो उछलते हुए बंद होने के लिए खाते हैं किनारों:

ax = lx - (lx+1==w) + (lx==0) - 2 
ay = ly - (ly+1==h) + (ly==0) - 2

दूसरी और तीसरी पंक्तियों में ग्रिड की ऊंचाई और चौड़ाई पर मुख्य लूप होते हैं, निष्पादन की राह शुरू में दायीं से बायीं ओर जाती है, तीसरी पंक्ति बायीं ओर घूमने से पहले शुरू होती है। ग्रिड ( gx , gy ) में प्रत्येक समन्वय के लिए हम निम्नलिखित स्थिति की गणना करते हैं:

(gx==lx && gy>ay && gy<ay+4) || (gy==ly && gx>ax && gx<ax+4)

यदि वह स्थिति सत्य है, तो हम "+"स्टैक पर धक्का देते हैं , यदि असत्य हम एक धक्का देते हैं "-"। यहां शाखा लगाने से बचने के लिए, हम वास्तव में केवल धक्का दे रहे हैं 43 + 2 * !condition(43 प्लस के ASCII मूल्य और 45 शून्य से कम)।

एक बार छोरों के समाप्त होने के बाद, कोड का अंतिम बिट सिर्फ एक मानक आउटपुट रूटीन है जो स्टैक पर सब कुछ प्रिंट करता है।

Answer 4

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

अभी भी गोल्फ है

(w,h,z,t=--z%w,u=z/w|0,r='-'.repeat(w),S=(f,j)=>(r+f+r).substr(w-j,w))=>[...Array(h)].map((q=u-!!u-!(u+1-h),y)=>y-u?y>=q&y<q+3?S('+',t):r:S('+++',t-!!t-!(t+1-w))).join`
`

कम गोल्फ वाला

(w, h, z
, t=--z%w
, u=z/w|0
, r='-'.repeat(w)
, S=(f,j)=>(r+f+r).substr(w-j,w)
) => [...Array(h)].map(
    (q = u-!!u-!(u+1-h), 
     y) => y-u?y>=q&y<q+3?S('+',t):r:S('+++',t-!!t-!(t+1-w))
).join`\n`

परीक्षा

F=
(w,h,z,t=--z%w,u=z/w|0,r='-'.repeat(w),S=(f,j)=>(r+f+r).substr(w-j,w))=>[...Array(h)].map((q=u-!!u-!(u+1-h),y)=>y-u?y>=q&y<q+3?S('+',t):r:S('+++',t-!!t-!(t+1-w))).join`
`

function update() {
  var [x,y,z] = I.value.match(/\d+/g)
  O.textContent = F(+x,+y,+z)
}

update()

<input value='5 6 10' oninput='update()' id=I>
<pre id=O>