आइस गोल्फ चैलेंज

इस चुनौती का लक्ष्य एक प्रोग्राम या फ़ंक्शन लिखना है जो किसी दिए गए पाठ्यक्रम को पूरा करने के लिए आवश्यक हड़तालों की कम से कम राशि लौटाता है।

इनपुट

पाठ्यक्रम के लेआउट को किसी भी उपयुक्त तरीके से और प्रारूप में पारित किया जा सकता है जिसे आप पसंद करते हैं। (कंसोल से पढ़ा गया, इनपुट पैरामीटर के रूप में पारित किया गया, किसी फ़ाइल या किसी अन्य, मल्टीलाइन-स्ट्रिंग, स्ट्रिंग ऐरे, टू-डायमेंशनल कैरेक्टर / बाइट ऐरे से पढ़ा गया)।
गेंद और छेद की शुरुआत की स्थिति को इनपुट के रूप में भी पारित किया जा सकता है, इसे इनपुट से पार्स करने की आवश्यकता नहीं है। परीक्षण-मामलों में वे यह सुनिश्चित करने के लिए पाठ्यक्रम में शामिल हैं कि वास्तविक स्थिति के बारे में कोई भ्रम नहीं है।
जब तक वे अभी भी अलग-अलग वर्णों (जैसे मुद्रण योग्य ASCII वर्ण) के रूप में पहचानने योग्य हैं, तब तक आप इनपुट वर्णों को कुछ और के लिए फिर से तैयार कर सकते हैं।

उत्पादन

प्रोग्राम को सबसे कम संभव स्कोर (छेद तक पहुंचने के लिए आवश्यक कम से कम स्ट्राइक) को एक समझदार प्रारूप में इनपुट के रूप में पारित करना होगा (स्ट्रिंग, पूर्णांक, फ्लोट या हाइकु परिणाम का वर्णन करते हुए)
यदि पाठ्यक्रम को हरा पाना असंभव है, -1(या अपनी पसंद के किसी भी अन्य मिथ्या मूल्य को जो एक बीटेबल कोर्स के लिए वापस नहीं किया जाएगा)।

उदाहरण:

इस उदाहरण में स्थिति 0-आधारित, X / Y, बाएँ-से-दाएँ, ऊपर-नीचे - नोट की गई हैं, लेकिन आप किसी भी प्रारूप का उपयोग कर सकते हैं, क्योंकि परिणाम पूरी तरह से प्रारूप-स्वतंत्र वैसे भी है।

इनपुट:

###########
#     ....# 
#      ...# 
#  ~    . # 
# ~~~   . # 
# ~~~~    # 
# ~~~~    # 
# ~~~~  o # 
# ~~~~    # 
#@~~~~    # 
###########

Ball (Start-Position): 1/9
Hole (End-Position):   8/7

आउटपुट:

नियम और क्षेत्र

पाठ्यक्रम में निम्नलिखित क्षेत्र शामिल हो सकते हैं:

'@' गेंद - पाठ्यक्रम की शुरुआत
'o' छेद - पाठ्यक्रम का लक्ष्य
'#' दीवार - दीवार से टकराने पर बॉल रुकेगी
'~' पानी - बचना चाहिए
'.' रेत - गेंद रेत पर तुरंत बंद हो जाएगी
' ' आइस - बॉल तब तक स्लाइड करती रहेगी जब तक कि यह कुछ हिट न कर दे

खेल के बुनियादी नियम और प्रतिबंध:

गेंद तिरछे नहीं चल सकती, केवल बाएँ, दाएँ, ऊपर और नीचे।
गेंद पानी के सामने, केवल दीवारों के सामने, रेत पर और छेद में नहीं रुकेगी।
- पानी में शॉट्स अवैध / असंभव हैं
- गेंद छेद में रहेगी, इस पर नहीं छोड़ें जैसे कि यह बर्फ पर होगा
पाठ्यक्रम हमेशा आयताकार होता है।
पाठ्यक्रम हमेशा पानी या दीवारों से घिरा होता है (कोई सीमा जांच आवश्यक नहीं)।
हमेशा एक गेंद और एक छेद होता है।
सभी पाठ्यक्रमों को हरा पाना संभव नहीं है।
एक ही (सबसे कम) स्कोर के परिणामस्वरूप कई पथ हो सकते हैं।

खामियों और जीत की स्थिति

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

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

पाठ्यक्रम # 1 (2 हमले)

####
# @#
#o~#
####

पाठ्यक्रम # 2 (संभव नहीं)

#####
#@  #
# o #
#   #
#####

कोर्स # 3 (3 हमले)

~~~
~@~
~.~
~ ~
~ ~
~ ~
~ ~
~.~
~o~
~~~

पाठ्यक्रम # 4 (2 हमले)

#########
#~~~~~~~#
#~~~@~~~#
##  .  ##
#~ ~ ~ ~#
#~. o .~#
#~~~ ~~~#
#~~~~~~~#
#########

पाठ्यक्रम # 5 (संभव नहीं)

~~~~~~~
~...  ~
~.@.~.~
~...  ~
~ ~ ~.~
~ . .o~
~~~~~~~

अधिक परीक्षण मामले:

https://pastebin.com/Azdyym00

— मैनफ़्रेड रैडलीमर
स्रोत

संबंधित: एक , दो ।

— AdmBorkBork

यदि हम इनपुट के रूप में द्वि-आयामी बाइट सरणी का उपयोग करते हैं, तो क्या हमें प्रतीकों के लिए एक कस्टम मैपिंग का उपयोग करने की अनुमति है?

— अरनुलद

@Arnauld निश्चित नहीं है कि इस बारे में आम सहमति क्या है, लेकिन मैं कहूंगा कि यह ठीक है जब तक इनपुट अभी भी पहचानने योग्य है। मैंने इनपुट अनुभाग अपडेट कर दिया है ।

— मैनड्रेड रेडलविमर

यदि गंतव्य को सीधे इनपुट करें, तो क्या हमें गंतव्य के स्थान की आवश्यकता 'रेत' के प्रतीक से हो सकती है?

— l4m2

@ l4m2 यकीन है, इस तरह यह अन्य सभी नियमों के अनुरूप रहेगा।

— मैनड्रेड रेडलविमर

जवाबों:

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

इनपुट ~~कर्लिंग~~ सिंटैक्स में इनपुट लेता है ([x, y])(a), जहां x और y शुरुआती स्थिति के 0-अनुक्रमित निर्देशांक हैं और [0 = ] पूर्णांकों का एक मैट्रिक्स है, जिसमें = बर्फ, 1दीवार, 2= रेत, 3= छेद और 4पानी है।

0अगर कोई समाधान नहीं है तो लौटाता है ।

p=>a=>(r=F=([x,y],n,R=a[y],c=R[x])=>R[c&(R[x]=4)|n>=r||[-1,0,1,2].map(d=>(g=_=>(k=a[v=Y,Y+=d%2][h=X,X+=~-d%2])||g())(X=x,Y=y)>3?0:k>2?r=-~n:F(k>1?[X,Y]:[h,v],-~n)),x]=c)(p)|r

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

टिप्पणी की गई

p => a => (                       // given the starting position p[] and the matrix a[]
  r =                             // r = best result, initialized to a non-numeric value
  F = (                           // F = recursive function taking:
    [x, y],                       //   (x, y) = current position
    n,                            //   n = number of shots, initially undefined
    R = a[y],                     //   R = current row in the matrix
    c = R[x]                      //   c = value of the current cell
  ) =>                            //
    R[                            // this will update R[x] once the inner code is executed
      c & (R[x] = 4) |            //   set the current cell to 4 (water); abort if it was
      n >= r ||                   //   already set to 4 or n is greater than or equal to r
      [-1, 0, 1, 2].map(d =>      //   otherwise, for each direction d:
        (g = _ => (               //     g = recursive function performing the shot by
          k = a[                  //         saving a backup (h, v) of (X, Y)
            v = Y, Y += d % 2][   //         and updating (X, Y) until we reach a cell
            h = X, X += ~-d % 2]) //         whose value k is not 0 (ice)
          || g()                  //   
        )(X = x, Y = y)           //     initial call to g() with (X, Y) = (x, y)
        > 3 ?                     //     if k = 4 (water -> fail):
          0                       //       abort immediately
        :                         //     else:
          k > 2 ?                 //       if k = 3 (hole -> success):
            r = -~n               //         set r to n + 1
          :                       //       else:
            F(                    //         do a recursive call to F():
              k > 1 ?             //           if k = 2 (sand):
                [X, Y]            //             start the next shots from the last cell
              :                   //           else (wall):
                [h, v],           //             start from the last ice cell
              -~n                 //           increment the number of shots
            )                     //         end of recursive call
      ), x                        //   end of map(); x = actual index used to access R[]
    ] = c                         // restore the value of the current cell to c
)(p) | r                          // initial call to F() at the starting position; return r

— Arnauld
स्रोत

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

def p(g,c,d,k=0):
	while 1>k:c+=d;k=g.get(c,9)
	return-(k==2)or c-d*(k==3)
def f(g):
	c={q for q in g if g.get(q,9)>4};I=0;s=[c]
	while all(g.get(q,9)-4for q in c):
		c={k for k in{p(g,k,1j**q)for k in c for q in range(4)}if-~k}
		if c in s:return-1
		s+=[c];I+=1
	return I

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

-41 बाइट्स धन्यवाद,
जोनाथन फ्रीच के लिए ओट्स -1 बाइट की बदौलत

— HyperNeutrino
स्रोत

किया जा सका if k+1नहीं हो if-~k?

— जोनाथन फ्रीच

— जोनाथनफ्रेच

सी #, 461 418 बाइट्स

यह इस चुनौती को पुनर्जीवित करने के लिए (उम्मीद है) एक गैर-प्रतिस्पर्धी संदर्भ कार्यान्वयन है:

केविन क्रूज़सेन द्वारा गोल्फ

int P(string[]C){int w=C[0].Length,i=0,l=c.Length;var c=string.Join("",C);var h=new int[l];for(var n=new List<int>();i<l;n.Add(i++))h[i]=c[i]!='@'?int.MaxValue:0;for(i=1;;i++){var t=n;n=new List<int>();foreach(int x in t){foreach(int d in new[]{-1,1,-w,w}){for(int j=x+d;c[j]==' ';j+=d);if(c[j]=='#'&h[j-d]>s){h[j-d]=s;n.Add(j-d);}if(c[j]=='.'&h[j]>s){h[j]=s;n.Add(j);}if(c[j]=='o')return s;}}if(n.Count<1)return -1;}}

Ungolfed

int IceGolf(string[] course)
{
    // Width of the course
    int w = course[0].Length;

    // Course as single string
    var c = string.Join("", course);

    // Array of hits per field
    var hits = new int[c.Length];

    // Fields to continue from
    var nextRound = new List<int>();

    // Initialize hits
    for (int i = 0; i < hits.Length; i++)
    {
        if (c[i] != '@')
            // All fields start with a high value
            hits[i] = Int32.MaxValue;
        else
        {
            // Puck field starts with 0
            hits[i] = 0;
            nextRound.Add(i);
        }
    }

    for (int s = 1; ; s++)
    {
        // clear the fields that will be used in the next iteration
        var thisRound = nextRound;
        nextRound = new List<int>();

        foreach (int i in thisRound)
        {
            // test all 4 directions
            foreach (int d in new[] { -1, 1, -w, w })
            {
                int j = i+d;

                // ICE - slide along
                while (c[j] == ' ')
                    j += d;

                // WALL - stop on previous field
                if (c[j] == '#' && hits[j-d] > s)
                {
                    hits[j-d] = s;
                    nextRound.Add(j-d);
                }

                // SAND - stop
                if (c[j] == '.' && hits[j] > s)
                {
                    hits[j] = s;
                    nextRound.Add(j);
                }

                // HOLE return strikes
                if (c[j] == 'o')
                    return s;
            }
        }

        // No possible path found
        if (nextRound.Count == 0)
            return -1;
    }
}

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

— मैनफ़्रेड रैडलीमर
स्रोत

थोड़ा और अधिक गोल्फ:

int P(string[]C){int w=C[0].Length,i=0,l=c.Length;var c=string.Join("",C);var h=new int[l];for(var n=new List<int>();i<l;n.Add(i++))h[i]=c[i]!='@'?int.MaxValue:0;for(i=1;;i++){var t=n;n=new List<int>();foreach(int x in t){foreach(int d in new[]{-1,1,-w,w}){for(int j=x+d;c[j]==' ';j+=d);if(c[j]=='#'&h[j-d]>s){h[j-d]=s;n.Add(j-d);}if(c[j]=='.'&h[j]>s){h[j]=s;n.Add(j);}if(c[j]=='o')return s;}}if(n.Count<1)return -1;}}

(418 बाइट्स)। इसके अलावा, क्या आप शायद टेस्ट कोड के साथ एक टीआईओ-लिंक जोड़ सकते हैं ?

— केविन क्रूज़सेन

TIO लिंक के लिए धन्यवाद। मेरे द्वारा ऊपर दिया गया कोड काम नहीं कर रहा था, इसलिए मैंने इसे ठीक कर दिया, और तीन और बाइट्स को गोल किया। इसे ऑनलाइन 415 बाइट्स आज़माएं । (आपको अपने वर्तमान TIO से फिर से अपने विशाल परीक्षण मामले को फिर से जोड़ना होगा। मैं इस टिप्पणी में लिंक पेस्ट नहीं कर सका क्योंकि लिंक उस परीक्षण मामले के साथ बहुत बड़ा था; पी)

— केविन क्रूज़सेन