सभी दिशाओं में आयत के विपरीत कोने पर जाएं - हार्डर

Question

यह अनिवार्य रूप से एक ही चीज़ है इस कठिन छोड़कर सवाल है,। आप फिर से एक प्रोग्राम लिखने के लिए हैं जो आयत के निचले-बाएँ कोने से ऊपरी-दाएँ कोने तक जाता है। हालांकि, इस बार विकर्ण चालों की अनुमति है।

कार्यक्रम एक आदेशित जोड़ी को स्वीकार करेगा (width, height), और इन्हें एक आयत के आयाम के रूप में उपयोग करेगा। आपका कार्यक्रम तब समाधान का एक ASCII- कला ( .एक खाली वर्ग के लिए उपयोग, समाधान #के भाग के लिए और Xवर्ग शुरू करने के लिए) बनाएगा और अंतिम बिंदु तक पहुंचने के लिए ले जाने वाली संख्याओं की गणना करेगा।

उदाहरण

इनपुट: (5, 6)

आउटपुट:

....#
....#
...#.
..#..
.#...
X....
Move count: 5

बाइट्स जीत में सबसे छोटा जवाब!

Comments

ऐसा नहीं है, समाधानों में बहुत सारे संपादन की आवश्यकता होगी

— ब्लू

सुझाए गए डुप्लिकेट की तरह यह चुनौती, एक मामूली सरल समस्या है जो गोल्फ के लिए गैर-तुच्छ है, जो एक महान संयोजन है। समानता के बावजूद, इस चुनौती के लिए एक अलग दृष्टिकोण की आवश्यकता है और पिछली चुनौती के लिए अच्छी तरह से तैयार किए गए समाधानों को यहां प्रतिस्पर्धी होने के लिए तुच्छ रूप से संशोधित नहीं किया जा सकता है।

— ट्राइकोप्लाक्स

हालांकि यह अधिक विशिष्ट शीर्षक के साथ कर सकता है ...

— ट्राइकोप्लाक्स

हाँ, कोई विचार?

— ericw31415

@LuisMendo न्यूनतम संभव ग्रिड सबसे छोटा है; 1 बाय 1

— ericw31415

Answer 1

MATL , 38 बाइट्स

'.#X'!iSPXytf0)Jh1w(tzqDQI1()Gd0<?!]XP

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

व्याख्या

आज्ञा देना mऔर nहल किए गए इनपुट, जैसे कि mअधिक से अधिक या इसके बराबर है n। कोड शुरू में निम्नानुसार एक mx nमैट्रिक्स बनाता है:

• मान 2 मुख्य विकर्ण के साथ, और अंतिम स्तंभ के निचले भाग पर। यह चरित्र से मेल खाती है #। इन एंट्री माइनस 1 की संख्या मूव काउंट है।
• प्रविष्टि 3 पर मान (1,1), के अनुरूप X।
• शेष प्रविष्टियों में वर्ण के अनुरूप 1 होता है .

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

तब मैट्रिक्स को उल्टा फ़्लिप किया जाता है, जो कि Xपहले कॉलम के निचले भाग में दिखाई देता है, और इसकी प्रविष्टियों का उपयोग '.#X'वांछित 2D वर्ण सरणी बनाने के लिए स्ट्रिंग में सूचक के रूप में किया जाता है ।

'.#X'    % push this string
!        % transpose into a column
i        % input array
SP       % sort it in non-increasing order
Xy       % identity matrix with that size: fill diagonal with 1, rest entries are 0
tf0)     % linear index of last 1
Jh       % append 1j (imaginary unit): linear index of lowest part of last column
1w(      % fill those entries with 1
tzq      % duplicate. Number of nonzero entries minus 1: this is the move count
D        % display move count (and remove it from the stack)
Q        % add 1. Matrix now contains values 1 and 2
I1(      % set first entry (in linear order) to value 3
)        % use matrix as index into the initial string. Gives 2D char array
Gd0<     % push input array again. Is it decreasing?
?        % if so
  !      %   transpose char array
]        % end
XP       % flip upside down. Implicitly display

Comments

यह कदम गिनती नहीं कहते हैं ...?

— ericw31415

@ ericw31415 क्षमा करें। अब हल किया

— लुइस मेंडू

Answer 2

पायथ, 46 45 44 बाइट्स

eSKtMQjsM_mm?sJ,kd?q#J.umtWbbNeSKK\#\.\XhQeQ

इसे यहाँ आज़माएँ।

स्पष्टीकरण:

move-count-printing:

  K     assign K to...
     Q  the input, a 2-length array...
   tM   with each element decremented
eS      take the max and output it (this is the number of moves)


main path-finding logic:

    mm                     hQeQ  map over x-values and y-values...
        J,kd                     assign J to [x,y]
      ?s                         if both x and y are NOT zero (sum is truthy)...
            ?q#J[...]              if [x,y] is present in [...] (see below)...
                     \#            ... put a # at this position in the output
                       \.          ... else, put a . at this position
                         \X      ... else, put the X here (at [0,0])
jsM_                             reverse and output in the proper format


the [...] part in the code above, which finds positions where #s go:

.u      eSKK  cumulative reduce on <number of moves> elements, starting at K,
                which is [max_x, max_y] as assigned at the beginning
  m    N      map over x and y...
   tWbb       decrement, only if the value is > 0

Answer 3

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

2 बाइट्स संपादित करें thx @Neil को बचाया

(w,h)=>[...Array(--h)].map((_,i)=>R(w-i)+'#'+R(i),--w,R=(n,c='.')=>c.repeat(n>w?w:n>0&&n)).join`
`+`
x${R(w-h,'#')+R(h)}
`+(h>w?h:w)

परीक्षा

f=(w,h)=>[...Array(--h)].map((_,i)=>R(w-i)+'#'+R(i),--w,R=(n,c='.')=>c.repeat(n>w?w:n>0&&n)).join`
`+`
x${R(w-h,'#')+R(h)}
`+(h>w?h:w)

function test() {
  var w,h
  [w,h]=I.value.match(/\d+/g)
  O.textContent=f(w,h)
}  

test()

Test <input id=I value="4 5"><button onclick="test()">-></button>
<pre id=O></pre>

Comments

w--,R=... में जाकर 2 बाइट्स बचाएं map()।

— नील

Answer 4

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (235 बाइट्स)

जीज़ यह कठिन था! खैर ... मेरी लाइब्रेरी वास्तव में इस हाहा के लिए सही काम नहीं थी। लेकिन मुझे चुनौती पसंद आई

(x,y)=>{r=x-1;s=y-1;m=Math.max(r,s);n=Math.min(r,s);l=_.RangeDown(s,y).WriteLine(z=>_.Range(0,x).Write("",w=>z==0&&w==0?"X":(z==w||(z==s&&w>=n)||(w==r&&z>=n))?"#":"."));return l+"\r\nMove count: "+(l.length-l.split("#").join("").length)}

लिंक करने के लिए लिंक: https://github.com/mvegh1/Enumerable

कोड स्पष्टीकरण: 2 चर का कार्य बनाएँ। X-1 और y-1 को चर में स्टोर करें। स्टोर में अधिकतम और न्यूनतम चर। Y की गिनती के लिए (y-1) से संख्याओं की लंबवत अवरोही सीमा बनाएं। ऊर्ध्वाधर सीमा पर प्रत्येक तत्व के लिए, जटिल विधेय के अनुसार वर्तमान तत्व के लिए एक पंक्ति लिखें। यह विधेय x की गणना के लिए 0 से पूर्णांकों की एक आरोही सीमा बनाता है। उस श्रेणी के प्रत्येक तत्व के लिए, एक जटिल विधेय के अनुसार 1 स्ट्रिंग में संघनित करें। यह जाँच करता है कि यदि नीचे बाईं ओर है, तो जाँच करें कि क्या तिरछे पर, और जाँचता है कि हम X या Y बॉर्डर पर हैं। अंत में, वह सब एक चर में संग्रहीत किया गया था। फिर कदम की गिनती प्राप्त करने के लिए, हम मूल रूप से सिर्फ # गणना करते हैं। फिर उस संग्रहीत चर को संक्षिप्त करें, और परिणाम वापस करें

वह मुंहफट हाहा था। स्क्रीनशॉट में गलत बाइटकाउंट है क्योंकि मुझे इसे पोस्ट करते समय 4 बाइट बचाने का एक तरीका मिला

संपादित करें: मैं देख रहा हूं कि अन्य उत्तर उनके आउटपुट में "मूव काउंट:" नहीं डाल रहे हैं, लेकिन मेरा है। यदि वह आवश्यकता नहीं है, तो बाइट्स का एक समूह बिखरता है ...

Answer 5

पायथन 3, 161 156 बाइट्स

def f(w,h):
 x=[['.']*w for i in[0]*h];i=0
 while i<w or i<h:x[~min(i,h-1)][min(i,w-1)]=['#','X'][i<1];i+=1
 for i in x:print(''.join(i))
 print(max(w,h)-1)

एक फ़ंक्शन जो तर्क के माध्यम से इनपुट लेता है और एससीआई-कला को प्रिंट करता है, उसके बाद कदम गिनती, एसटीडीयूएसटी के लिए।

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

कार्यक्रम पहले सूचियों की एक सूची बनाता है, जहां प्रत्येक सूची ग्रिड की एक पंक्ति का प्रतिनिधित्व करती है और घटक सूचियों का प्रत्येक तत्व है .। प्रत्येक तत्व #में यह गुण होना चाहिए कि यदि आउटपुट ग्रिड चौकोर है, तो उसके स्थान का प्रतिनिधित्व करने वाले निर्देशांक बराबर होंगे; इसलिए, कुछ सूचकांक पर लूपिंग iऔर #स्थान पर डालने से (i, i)वांछित आउटपुट मिलेगा। हालाँकि, ग्रिड हमेशा वर्गाकार नहीं होता है, और इस प्रकार सूचकांक को न्यूनतम सूचकांक और चौड़ाई / ऊँचाई (शून्य-अनुक्रमण के कारण घटाया हुआ) के रूप में ग्रिड से जोड़ दिया जाता है। यदि सूचकांक शून्य है, तो वर्तमान स्थिति में नीचे-बाईं प्रविष्टि होनी चाहिए, और इस प्रकारXइसके बजाय डाला जाता है। इसके बाद, प्रत्येक पंक्ति के तत्व संक्षिप्त किए जाते हैं, और प्रत्येक पंक्ति को STDOUT में मुद्रित किया जाता है। चालों की संख्या चौड़ाई / ऊँचाई में कमी की अधिकतम संख्या है; यह भी छपा है।

Ideone पर इसे आज़माएं