13

आपका काम एक प्रोग्राम लिखना है जो एक आयत के निचले-बाएँ कोने से ऊपरी-दाएं कोने तक सीधे जाने के लिए ले जाने वाली इष्टतम संख्या पाता है।

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

बाइट्स में सबसे छोटा कार्यक्रम जीतता है।

उदाहरण

इनपुट: (4, 5)

आउटपुट:

..##
..#.
.##.
.#..
X#..

मूव काउंट: 7

— ericw31415
स्रोत

तो क्या आउटपुट #में "इष्टतम समाधान" की संख्या शामिल होनी चाहिए (जो कि कोई भी समाधान है जो कभी बाएं या नीचे नहीं चलता है)?

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

12

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

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

@ मार्टिनबटनर हां, इस कदम की संख्या अनिवार्य रूप से है #क्योंकि यह बाईं या नीचे जाने के लिए अतार्किक है।

— ericw31415

क्या रिक्त स्थान के साथ प्रत्येक चार को अलग करना ठीक है?

— ब्लू

1

क्या हमें मूव काउंट और आस्की आर्ट का उत्पादन करना है? वास्तव में आउटपुट कैसा दिखना चाहिए?

— जेम्स

0

05AB1E , 27 24 बाइट्स

कोड:

+Í,¹<'.×'#¶J²<×'X'#¹<×J,

स्पष्टीकरण:

+                         # Add the length and the height.
 Í                        # Decrease by two.
  ,                       # Print this value with a newline.
   ¹<'.×                  # Take the first input, decrease by 1 and multiply with ".".
        '#¶               # Push a "#"-character and a newline character.
           J              # Join the string.
            ²<            # Take the second input and decrease by 1.
              ×           # Multiply the joined string with this value.
               'X         # Push the "X"-character.
                 '#¹<×J   # Multiply the "#"-character with (first input - 1).
                       ,  # Pop and print with a newline.

इसे ऑनलाइन आज़माएं! । CP-1252 एन्कोडिंग का उपयोग करता है ।

— अदनान
स्रोत

एक बाइट और एक चरित्र में क्या अंतर है?

— लीकी नून

2

@ केनीलाऊ मैं अपने पोस्ट में यह बताना भूल गया कि ... 05AB1E CP-1252 एन्कोडिंग का उपयोग करता है, यहाँ कोड में प्रयुक्त प्रत्येक वर्ण 1 बाइट है।

— अदनान

3

रेटिना , 54 53 बाइट्स

\d+
$*.
S_`(?<=(.+)¶.*).|\D
T`.`#`.¶|.*$
:m-1=`^#
X
#

एक लाइनफीड द्वारा अलग किए गए इनपुट को ले जाता है और हल की गिनती के बाद समाधान ग्रिड को आउटपुट करता है।

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

व्याख्या

\d+
$*.

दोनों पूर्णांकों को उस कई .s में बदल दें, अर्थात उन्हें एकात्मक में बदलें।

S_`(?<=(.+)¶.*).|\D

यह .एस की एक ग्रिड का निर्माण करता है , प्रत्येक .को एक ऊंचाई में मिलान करके और चौड़ाई के एकात्मक प्रतिनिधित्व को कैप्चर करता है। Sविभाजन मोड जो कब्जा कर लिया तार रिटर्न सक्रिय करता है, और |\Dऔर _एक साथ सुनिश्चित बाकी है कि सब कुछ स्ट्रिंग से हटा दिया है।

T`.`#`.¶|.*$

यह प्रत्येक पंक्ति के अंतिम चरित्र के साथ-साथ संपूर्ण अंतिम पंक्ति को बदल देता है #।

:m-1=`^#
X

यह #पिछली पंक्ति में केवल पहली को बदलने के लिए विकल्पों में से एक टन का उपयोग करता है X(हमें यह सुनिश्चित करने की आवश्यकता है कि चौड़ाई -1 इनपुट के कारण केवल अंतिम पंक्ति प्रभावित होती है)। mमल्टी-लाइन मोड को सक्रिय करता है जो ^लाइनों की शुरुआत से मेल खाता है। -1=रेटिना को अंतिम मैच पर ही प्रतिस्थापन करने के लिए कहता है। अंत में, :डिफॉल्ट साइलेंट मोड को स्विच ऑफ कर देता है ताकि ग्रिड इंटरमीडिएट रिजल्ट के रूप में STDOUT में प्रिंट हो जाए।

अंत में, हम बस #स्ट्रिंग में संख्या की गणना करते हैं , जो चालों की संख्या से मेल खाती है।

— मार्टिन एंडर
स्रोत

हो सकता है कि एक बिल्ट इन यूरीटी को परिवर्तित करने के लिए रेटिना में जोड़ा जाए।

— साइओस

3

पाइके, 26 बाइट्स

DtQ+RtF; Q\.*t\#+)\X\#Qt*+

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

या एक अयोग्य 34 बाइट्स, एक नोड के साथ एप्लाई जोड़ें)

jUa]Dm!X|RZjht]q+".#X"R@)Fs
);jmts

यहाँ यह कोशिश करो!

या 30 बाइट्स यदि पैडिंग के रूप में रिक्त स्थान की अनुमति दें

jUa]Dm!X|RZjht]q+".#X"R@)Pjmts

— नीला
स्रोत

यह गैर-प्रतिस्पर्धी क्यों है?

— लीक

3

मैंने चुनौती पोस्ट होने के बाद भाषा बदल दी

— ब्लू

जब आप इसे यहाँ क्लिक करते हैं तो @muddyfish आंतरिक सर्वर त्रुटि

— Insane

@ इयान ने बग को तय किया (उम्मीद है) जब भी दिन बदला तो समय के लिए आंतरिक परीक्षण विफल हो रहा था।

— ब्लू

2

पायथ, 32 29 24 बाइट्स

AtMQVH+*\.G\#;+\X*\#G+GH

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

नमूना इनपुट:

(4, 5)

नमूना उत्पादन:

...#
...#
...#
...#
X###
7

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

AtMQVH+*\.G\#;+\X*\#G+GH
                           assign('Q',eval_input())
AtMQ                       assign('[G,H]',Pmap(lambda d:tail(d),Q))
    VH       ;             for N in range(H):
      +*\.G\#                  implicit_print(plus(times(".",G),"#"))
              +\X*\#G      implicit_print(plus("X",times("#",G)))
                     +GH   implicit_print(plus(G,H))

पिछला प्रयास:

JthQK@Q1+*++*\.J\#btK+\X*\#Jt+JK

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

नमूना इनपुट:

(4, 5)

नमूना उत्पादन:

...#
...#
...#
...#
X###
7

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

JthQK@Q1+*++*\.J\#btK+\X*\#Jt+JK
                                 assign('Q',eval_input())        --Q is now an official pair of numbers (4, 5)
JthQ                             assign("J",decrement(first(Q))) --gets the first element, and then take 1 from it, and assign it to J
    K@Q1                         assign("K",lookup(Q,1))         --K is now the second element (count from 0) of the pair.
        +            +\X*\#J     concat(-----------------------------------------------------------,concat("X",times("#",J)))
         *         tK                   repeat(--------------------------------------,decrement(K))
          +       b                            concat(-------------------------,"\n")
           +    \#                                    concat(-------------,"#")
            *\.J                                             repeat(".",J)
                            t+JK decrement(add(J,K)) <--- auto-print

— लीक नन
स्रोत

@ MartinBüttner शायद आप मुझे यह गोल्फ में मदद कर सकते हैं?

— लीकी नून

@ केनीलाऊ मैं किसी भी अजगर को नहीं जानता ...

— मार्टिन

@ मार्टिनबटनर यह पायथ के लिए शर्मनाक है, सही है

— लीक

आप पहले दो असाइनमेंट को जोड़ सकते हैं AtMQ। यह दो मान देता है Gऔर H।

— जकुबे

1

CJam, 35 33 बाइट्स

q~\(_2$(+p'.*a*'#f+)W%_"X#"era+N*

प्रपत्र में इनपुट लेता है width heightऔर पहली पंक्ति पर चाल गणना को हल करता है, उसके बाद समाधान ग्रिड।

इसका परीक्षण यहां करें।

यह भी एक ही बाइट गिनती के लिए काम करता है:

q~\('.*a*'#f+)W%_"X#"era+N*_'#e=p

— मार्टिन एंडर
स्रोत

थोड़ी देर में CJam समाधान नहीं देखा।

— साइओस

2

@Cyoce आपको कठिन दिखने की जरूरत है। ;)

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

1

रूबी, 48 बाइट्स

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

इनपुट दो तर्क हैं। वापसी मान एक सरणी है जिसमें ASCII कला स्ट्रिंग और #पथ की संख्या है ।

->w,h{[(?.*(w-=1)+'#
')*(h-=1)+?X+?#*w,w+h]}

परीक्षण कार्यक्रम में

f=->w,h{[(?.*(w-=1)+'#
')*(h-=1)+?X+?#*w,w+h]}

puts f[4,5]

उत्पादन

...#
...#
...#
...#
X###
7

यह सिर्फ w-1 डॉट्स की h-1 पंक्तियों की एक स्ट्रिंग है, इसके बाद a #और newline है। मैंने दोनों के लिए #एक सिंगल #\nशाब्दिक #और न्यूलाइन का उपयोग करने के लिए अंत में रखा है (कोड में एक एस्केप अनुक्रम के बजाय एक वास्तविक न्यूलाइन शामिल है।) अंतिम पंक्ति फिर Xw-1 के द्वारा पीछा किया जाता है #।

यह ASCII कला पीढ़ी के दौरान w और h के मूल्यों को घटाने के लिए कम था, ताकि अंतिम गणना सरल हो w+h।

— स्तर नदी सेंट
स्रोत

1

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

w=>h=>--w+--h+`
${"."[r="repeat"](w)}#`[r](h)+`
X`+"#"[r](w)

प्रयोग

f(4)(5)

7
...#
...#
...#
...#
X###

— user81655
स्रोत

1

MATL , 28 26 25 बाइट्स

+qq35IMwX"46 5Lt4$(88HG(c

EDIT (10 जून, 2016): नीचे दिए गए लिंक में भाषा में परिवर्तन के अनुकूल एक संशोधन ( 5Lद्वारा प्रतिस्थापित किया गया है IL) शामिल है

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

व्याख्या

+       % take two inputs. Add them
qq      % subtract 2
35      % push ASCII for '#'
IMw     % push the two inputs again. Swap them
X"      % 2D char array of '#'  repeated as indicated by inputs
46      % push ASCII for '.'
5Lt4$(  % fill all but last and row columns with that
88HG(   % fill 88 (ASCII for 'X') at linear index given by second input
c       % convert to char

— लुइस मेंडो
स्रोत

0

स्काला, 118 बाइट्स

(w:Int,h:Int)=>{print(Array.fill(h-1,w-1)('.')map(new String(_))mkString("","#\n","#\nX"));Seq.fill(w-1)(print("#"))}


(w:Int,h:Int)=>{...}           //define a function with 2 Ints as parameters
print(                        //print ...   
  Array.fill(h-1,w-1)('.')    //an array of arrays with dimensions (h-1,w-1)
                              //and fill it with a dot
  map(new String(_))          //map each inner array of chars to a string
  mkString("","#\n","#\nX")   //create a string from the array, with
                              //an empty string before the array,
                              //"#\n" as a seperator between the elements
                              //and "#\nX" at the end   
);
Seq.fill(w-1)(print("#"))     //w-1 times print "#"

— corvus_192
स्रोत

0

हास्केल, 64 बाइट्स

c!n=c<$[2..n]
w#h=unlines$('.'!w++"#")!h++['X':'#'!w,show$w+h-2]

उपयोग उदाहरण:

*Main> putStr $ 4 # 5
...#
...#
...#
...#
X###
7

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

c!n = c <$ [2..n]                       -- helper function: make (n-1) copies of c

                                        -- main function
                     !h                 -- (h-1) times
       ('.'!w ++ "#")                   --    (w-1) dots and a hash sign
                       ++[      ,     ] -- followed by
                          'X' : '#'!w   --    an 'X' and (w-1) hash signs
                            show$w+h-2  --    and the number of steps
unlines                                 -- join everything with newlines in-between

— nimi
स्रोत

0

जावा, 137 132 बाइट्स

w->h->{String s="";int i=0,j;for(;i<h;i++){for(j=1;j<w;j++)s+=".";s+="#\n";}s+="X";for(j=1;j<w;j++)s+=".";s+="\n"+(w+h-2);return s;}

— लीक नन
स्रोत

जावा वास्तव में एक मजाक नहीं है ...

— ericw31415

s + = के बजाय s = s + आपको

— ब्लू

0

लूआ, 81 बाइट्स

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

golfed:

w,h=(...)print((("."):rep(w-1).."#\n"):rep(h-1).."X"..("#"):rep(w-1))print(w+h-2)

Ungolfed:

w,h=4,5
print((("."):rep(w-1).."#\n"):rep(h-1).."X"..("#"):rep(w-1))
print(w+h-2)

— लीक नन
स्रोत

0

अजगर, ४ 48।

lambda w,h:('.'*(w-1)+'#\n')*(h-1)+'X'+'#'*(w-1)

इसका उपयोग करने के लिए, f=ऊपर दी गई लाइन से पहले जोड़ें और इसे इस तरह से कॉल करें:

f(4, 5)

परिणाम:

...#
...#
...#
...#
X###

— shooqie
स्रोत

एक आयत के विपरीत कोने में जाने के लिए इष्टतम समाधान

05AB1E , 27 24 बाइट्स

रेटिना , 54 53 बाइट्स

व्याख्या

पाइके, 26 बाइट्स

पायथ, 32 29 24 बाइट्स

CJam, 35 33 बाइट्स

रूबी, 48 बाइट्स

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

प्रयोग

MATL , 28 26 25 बाइट्स

व्याख्या

स्काला, 118 बाइट्स

हास्केल, 64 बाइट्स

जावा, 137 132 बाइट्स

लूआ, 81 बाइट्स

अजगर, ४ 48।