50

एक मिनी-गोल्फ कोर्स और स्विंग की शक्ति के साइड-व्यू को देखते हुए, यह निर्धारित करें कि क्या गेंद इसे छेद में बनाएगी।

इस प्रारूप में एक पाठ्यक्रम होगा:

      ____       ____ _   
   __/    \     /    U \  
__/        \   /        \_
            \_/

गेंद सीधे बाईं ओर जमीन के पहले टुकड़े से पहले शुरू होती है और पाठ्यक्रम के समोच्च का पालन करती है जब तक कि यह छेद तक नहीं पहुंचती ( Uजमीन के वर्तमान स्तर के नीचे एक ऊपरी मामला )। यदि यह छेद तक पहुँचता है, तो एक सत्य मूल्य का उत्पादन करता है। स्विंग की शक्ति गेंद की प्रारंभिक गति होगी। गेंद प्रत्येक पुनरावृत्ति पर दाईं ओर अगले चरित्र में जाती है, फिर उस चरित्र के आधार पर गति बदल दी जाती है जो अब है। यदि 0छेद से पहले गति कम या कम हो जाती है, तो एक गलत मूल्य का उत्पादन होता है।

_ द्वारा गति कम हो जाती है 1
/ द्वारा गति कम हो जाती है 5
\ द्वारा गति बढ़ाता है 4

पाठ्यक्रम वैकल्पिक रूप से रिक्त स्थान के साथ गद्देदार हो सकते हैं। स्विंग की शक्ति हमेशा एक सकारात्मक पूर्णांक होगी।

आपको छेद में प्रवेश करने, पीछे की ओर लुढ़कने या पहाड़ियों से कूदने / उछलने जैसी गेंद के बारे में चिंता करने की आवश्यकता नहीं है।

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

Input: 27
      ____       ____ _   
   __/    \     /    U \  
__/        \   /        \_
            \_/           
Output: true

----------

Input: 26
      ____       ____ _   
   __/    \     /    U \  
__/        \   /        \_
            \_/           
Output: false

----------

Input: 1

U
Output: true

----------

Input: 1
_ 
 U
Output: false

----------

Input: 22

     /U
    /  
   /   
  /    
\/     
Output: true

----------

Input: 999
_       _
 \     / 
  \   /  
   \ /   
    U    
Output: true

----------

Input: 5
  /
/U 
Output: false

----------

Input: 9

/\/\/\/\/U
Output: false

----------

Input: 16

_/\                                         _
   \      __       /\/\/\                  / 
    \    /  \     /      \                /  
     \__/    \   /        \____________ _/   
              \_/                      U     

Output: true

यह कोड मिनी-गोल्फ है, बाइट्स जीत में सबसे छोटा जवाब!

— user81655
स्रोत

1

यदि आपकी भाषा में निर्मित सरणी अच्छी है, तो आप इनपुट को संचालन की एक धारा में बदल सकते हैं ( \_/) निम्न चरणों के साथ: लाइनों की सरणी में विभाजित करें, घुमाएं, समतल करें, स्ट्रिप स्थान।

— साइओस

1

यह वास्तव में एक गोल्फ कोर्स की तुलना में एक निश्चित-ट्रैक तंत्र से अधिक है: पी

— ज़ैक गेट्स

24

मुझे लगता है कि \/\/\/\/\/की तुलना में अधिक कुशल पाठ्यक्रम है __________।

— ०१:०५ पर ०१

2

यही मैं सोच रहा था, 4 नीचे, 5 ऊपर, फिर .5 औसत होना चाहिए। ओह, फ्लैट 1 है?

— लीफ विलर्ट्स

क्या पाठ्यक्रम में प्रत्येक पंक्ति हमेशा एक ही लंबाई (छोटी लाइनों के अंत में रिक्त स्थान भरने वाले रिक्त स्थान के साथ) होगी?

— SnoringFrog

17

पायथ, 27 बाइट्स

.Am<sXsd"_\ /"[1_4Z5)Q._C.z

प्रदर्शन

यह कोड कुछ बहुत ही चतुर है और सभी प्रकार के साथ सुरक्षित नहीं है X। इसे नीचे देखें।

स्पष्टीकरण:

.Am<sXsd"_\ /"[1_4Z5)Q._C.z
                               Implicit: Z = 0, Q = eval(input())
                               Q is the initial power.
                         .z    Take all input, as a list of lines.
                        C      Transpose, giving all columns.
                      ._       Form all prefixes.
  m                            Map over the prefixes.
      sd                       Concatenate the prefix.
     X  "_\ /"[1_4Z5)          Change '_' to 1, '\' to -4, ' ' to 0, and '/' to 5.
                               In particular, 'U' is left unchanged.
    s                          Reduce on addition.
                               If all elements were numbers,
                               this results in the total change in power.
                               If there was a 'U', it results in a string.
   <                 Q         If the previous result was a number, this compares
                               it with the initial input to see if the ball is
                               still rolling.
                               If the previous result was a string, this slices off
                               the first Q characters, which always has a truthy
                               result.
.A                             Test whether all of the prefixes mapped to a thruthy
                               result.

— isaacg
स्रोत

मुझे कुछ याद आ रहा है, लेकिन क्या यह रुकता है Q? यानी अंतिम उदाहरण कुछ मुद्दों का कारण हो सकता है?

— फ्लिंडबर्ग

@flindeberg यह काम नहीं करता है। < ... Qएक अंकीय तुलना अप छेद, नहीं एक टुकड़ा जब तक के रूप में काम करता है। छेद के बाद, यह सब मायने रखता है कि परिणाम सच्चाई है।

— isaacg

14

हास्केल, 111 109 बाइट्स

import Data.List
g"_"=1
g"/"=5
g _= -4 
f n=all(>0).scanl(-)n.map g.fst.span(/="U").(>>=words).transpose.lines

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

*Main> f 27 "      ____       ____ _   \n   __/    \\     /    U \\  \n__/        \\   /        \\_\n            \\_/           "
True
*Main> f 26 "      ____       ____ _   \n   __/    \\     /    U \\  \n__/        \\   /        \\_\n            \\_/           "
False

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

                            lines  -- split into list of lines at nl
                       transpose   -- transpose
                  (>>=words)       -- turn each line into words (i.e. remove spaces)  
            fst.span(/="U")        -- take all words up to but excluding "U"
         map g                     -- turn each word into the speed modifier
    scanl(-)n                      -- build list of partial sums starting with n
                                   --   note: speed modifiers are negative so we
                                   --   use (-) with scanl to build sums 
all(>0)                            -- return true if all sums are greater than 0

संपादित करें: @ user81655 को बचाने के लिए 2 बाइट्स मिले। धन्यवाद!

— nimi
स्रोत

7

रूबी, 104 87 वर्ण

->s,t{t.lines.map(&:bytes).transpose.map{|o|(c=o.max)==85||s<0?break: s+=c*3%14-6}
s>0}

नमूना रन:

2.1.5 :001 > track = '      ____       ____ _   
2.1.5 :002'>    __/    \     /    U \  
2.1.5 :003'> __/        \   /        \_
2.1.5 :004'>             \_/           
2.1.5 :005'> '
 => "      ____       ____ _   \n   __/    \\     /    U \\  \n__/        \\   /        \\_\n            \\_/           \n" 

2.1.5 :006 > ->s,t{t.lines.map(&:bytes).transpose.map{|o|(c=o.max)==85||s<0?break: s+=c*3%14-6};s>0}[27, track]
 => true 

2.1.5 :007 > ->s,t{t.lines.map(&:bytes).transpose.map{|o|(c=o.max)==85||s<0?break: s+=c*3%14-6};s>0}[26, track]
 => false

— आदमी काम पर है
स्रोत

6

जाप, 38 बाइट्स

Vz r"%s|U[^]*" ¬e@UµX¥'_?1:X¥'/?5:-4 ¬

Try it here!

धड़कन सीजाम!

व्याख्या

मूल रूप से स्ट्रिंग इनपुट लेता है, इसे 90deg दक्षिणावर्त घुमाता है, रिक्त स्थान और newlines स्ट्रिप्स, इसके बाद छेद और सब कुछ निकालता है, और चार्ट के साथ विभाजित करता है। फिर जांचता है कि क्या गेंद कभी everyफ़ंक्शन का उपयोग करके शून्य या उससे कम हो जाती है ।

— मामा फन रोल
स्रोत

मुझे लगता है कि `` सकारात्मक होना चाहिए (वर्णन गलत दिखता है)

— isaacg

मुझे नहीं लगता कि यह काम करता है। यह तस्वीर: ढलानों की एक श्रृंखला को गेंद की गति -2 तक मिलती है, लेकिन फिर बाद में शुद्ध +4 होते हैं। योग +2 को प्रतिबिंबित करेगा ताकि गेंद ने इसे बनाया। वास्तव में, यह नकारात्मक तक पहुंचने के बाद सकारात्मक खंड तक कभी नहीं पहुंचेगा।

— साइओस

मुझे लगता है कि मैंने समस्या को ठीक कर दिया है।

— मामा फन रोल

यह एक अच्छा बटन है;)

— जे एटकिन

अच्छा! तो, गोल्फिंग ... डबल बैकस्लैश के साथ बदली जा सकती है %, और >0इसके साथ प्रतिस्थापित किया जा सकता है ¬, क्योंकि गैर-सकारात्मक संख्या का वर्ग हमेशा गलत ( 0 -> 0, -1 -> NaN) होता है।

— ETHproductions

6

सीजेएम, 40 39 बाइट्स

liqN/:.e>'U/0="\_/"[4W-5]er{1$+}/]:e<0>

इनपुट में पहली लाइन पर पावर है और दूसरी लाइन पर शुरू होने वाला कोर्स है। आउटपुट 0या है 1।

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

व्याख्या

li    e# Read power and convert to integer.
qN/   e# Read course and split into lines.
:.e>  e# Flatten course by folding maximum over columns.
'U/   e# Split around the hole.
0=    e# Keep the first chunk.
"\_/"[4W-5]er
      e# Replace \, _, / with 4, -1, 5, respectively.
{     e# For each of those costs...
  1$+ e#   Copy the previous power and add the cost.
}/    e# This leaves all partial sums on the stack.
]     e# Wrap them in an array.
:e<   e# Find the minimum.
0>    e# Check whether it's positive.

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

5

रेटिना, 82 81 77 74 68 67 68 बाइट्स

+`(?<=(.)*) (?=.*¶(?<-1>.)*(.))
$2
\\
>>>>
+`>_|>{5}/|>¶

^>*U

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

इनपुट को यूनि बेस में दर्शाया गया है , जैसे n >s - उदाहरण के लिए, 4 है >>>>\n। (क्या यह कानूनी है?)
+`(?<=(.)*) (?=.*¶(?<-1>.)*(.)) $2 - पाठ्यक्रम को समतल करें - उनके नीचे चरित्र के साथ रिक्त स्थान बदलें।

इस चरण के बाद डेटा इस तरह दिखेगा:
```
>>>>>>>>>>>>>>>>>>>>>>>>>>
__/__/____\\\_///____U_\\_
__/__/    \\\_///    U \\_
__/        \\_//        \_
            \_/           
```
हम पहले के बाद सब कुछ अनदेखा कर सकते हैं U, हम वहां तक नहीं पहुंचेंगे।
> एक ऐसे कदम का प्रतिनिधित्व करें जिसे हमें बनाने की अनुमति है, या शेष ऊर्जा।
प्रत्येक \को चार से बदलें >- एक ढलान हमें अतिरिक्त ऊर्जा देता है।
लूप: विवादास्पद रूप से हटा दें >_या >>>>>/जब तक कोई भी न बचा हो। _s और /s ऊर्जा का उपभोग करते हैं।
अंत में, मिलान करने का प्रयास करें ^>*U- जांचें कि क्या हम Uसकारात्मक ऊर्जा (या कोई ऊर्जा) के साथ पहुंच सकते हैं ।
यह आउटपुट 0या होगा 1।

91 79 बाइट्स के साथ एक और करीबी विकल्प है:

+`(?<=¶(.)*) (?=.*¶(?<-1>.)*(.))
$2
^(>)+\n(?<-1>_|/(?<-1>){4}|\\(?<1>){5})+U

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

यह एक ही दृष्टिकोण है लेकिन एक विवादास्पद प्रतिस्थापन के बजाय एक संतुलन समूह के साथ।

मुझे यकीन है कि इन दोनों को और आगे बढ़ाया जा सकता है, इसलिए उनमें से कोई भी छोटा हो सकता है।

— कोबी
स्रोत

1

हां, संयुक्त इनपुट वैध है (जब तक कि चुनौती "दशमलव" निर्दिष्ट नहीं करता है), हालांकि मैं शायद उपयोग करूंगा 0या 1अंक के रूप में यदि कोई अतिरिक्त बाइट्स नहीं उठाएगा।

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

1

PPCG में भी आपका स्वागत है, मुझे आपको यहाँ देखकर बहुत खुशी हुई! :) (और साथ ही रेटिना का उपयोग कर रहे हैं।)

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

ज़रूर! यह गर्म प्रश्न सूची में था और मजेदार लग रहा था। मैंने सोचा कि मैं इसे

— आजमाऊंगा

3

ईएस 6, 117 बाइट्स

(c,p)=>c.split`
`.map(s=>[...s.slice(0,c.match(/^.*U/m)[0].length-1)].map(c=>p+=c=='/'?-5:'    \\'.indexOf(c)))&&p>0

Ungolfed:

function hole(course, power) {
    width = course.match(/^.*U/m)[0].length - 1; // calculate width to hole
    lines = course.split("\n");
    for (i = 0; i < lines.length; i++) {
        line = lines[i].slice(0, width); // ignore extraneous parts of the course
        for (j = 0; j < line.length; j++) {
            switch (line[j]) { // accumulate remaining power
            case '/': power -= 5; break;
            case '\\': power += 4; break;
            case ' ': break;
            default: power--; break;
            }
        }
    }
    return power > 0;
}

संपादित करें: सहेजे गए 4 बाइट्स to के लिए धन्यवाद।

— नील
स्रोत

@ @ धन्यवाद, मैं गति के लिए अनुकूलन करने की कोशिश कर रहा हूं ...

— नील

3

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

यही वह हल है, जब मैंने चुनौती बनाई।

(p,c)=>[...(l=c.split`
`)[w=0]].map((_,i)=>l.map(t=>(g=t[i])-1|p<=0?0:p-=g>"]"?1:g>"U"?-4:g>"/"?w=1:5))&&w

व्याख्या

एक संख्या के रूप में शक्ति और एक स्ट्रिंग के रूप में पाठ्यक्रम लेता है। के 1लिए trueया के 0लिए रिटर्न false। पाठ्यक्रम को रिक्त स्थान के साथ गद्देदार किया जाना चाहिए।

(p,c)=>
  [...(l=c.split`
`)                          // l = array of lines
  [w=0]]                    // w = true if the ball has entered the hole
.map((_,i)=>                // for each index i
  l.map(t=>                 // for each line t
    (g=t[i])                // g = the character at the current index
    -1|p<=0?0:              // do nothing if g is a space or the ball has no speed left
    p-=
      g>"]"?1               // case _: subtract 1 from p
      :g>"U"?-4             // case \: add 4 to p
      :g>"/"?w=1            // case U: set w to true (it doesn't matter what happens to p)
      :5                    // case /: subtract 5 from p
  )
)
&&w                         // return w

परीक्षा

var solution = (p,c)=>[...(l=c.split`
`)[w=0]].map((_,i)=>l.map(t=>(g=t[i])-1|p<=0?0:p-=g>"]"?1:g>"U"?-4:g>"/"?w=1:5))&&w

Power = <input type="number" id="power" value="16" /><br />
<textarea id="course" rows="6" cols="50">_/\                                         _
   \      __       /\/\/\                  / 
    \    /  \     /      \                /  
     \__/    \   /        \____________ _/   
              \_/                      U     </textarea><br />
<button onclick="result.textContent=solution(+power.value,course.value)">Go</button>
<pre id="result"></pre>

स्निपेट का विस्तार करें

— user81655
स्रोत

3

पायथन (3.5) 169 160 बाइट्स

ट्रांसपोज़ फ़ंक्शन (ज़िप) के बिना एक पुनरावर्ती समाधान

def f(c,p):c=c.splitlines();l=len(c);f=lambda x,h,v:v if'U'==c[h][x]or v<1 else f(x+(h==l-1),(h+1)%l,v+{"_":-1,"\\":4,"/":-5," ":0}[c[h][x]]);return f(0,0,p)>0

Ungolfed

सी के लिए, शक्ति के लिए पी, गति के लिए वी, ऊंचाई के लिए एच

def f(c,p):
    c=c.splitlines()
    l=len(c)
    tmp = {"_":-1,"\\":4,"/":-5," ":0}
    f=lambda x,h,v:v if'U'==c[h][x]or v<1 else f(x+(h==l-1),(h+1)%l,v+tmp[c[h][x]])
    return f(0,0,p)>0

प्रयोग

f(16,"_/\                                         _\n   \      __       /\/\/\                  / \n    \    /  \     /      \                /  \n     \__/    \   /        \____________ _/   \n              \_/                      U     ")
f(9,"/\/\/\/\/U")

— एर्वान
स्रोत

2

पायथ, 35 बाइट्स

VC.z=-Q@(1_4 5)x"_\\/"JrN6IqJ\U>Q_5

व्याख्या

                                    - Autoassign Q = eval(input())
                                    - Autoassign .z = rest of input
VC.z                                - For N in zip(*.z)
    =-Q                             - Q -= ...
                      JrN6          - Autoassign J to N.strip() (get rid of spaces)
       @(1_4 5)x"_\\/"              - {"_":1, "\\": -4, "/": 5, "U":5}[J] ("U" isn't defined but that's what it is according to how str.index works)
                          IqJ\U     - If J == "U"
                               >Q_5 - print Q > -5 ()

— नीला
स्रोत

1

रूबी, 85 वर्ण

->i,s{s.lines.map(&:bytes).transpose.any?{|o|(c=o.max)==85||i<0||!(i+=c*3%14-6)};i>0}

@ मैनटवर्क का उत्तर दिया गया

— कॉनर क्लार्क
स्रोत

1

जावास्क्रिप्ट, ~~266~~ ~~263~~ 244 बाइट्स

(s,a)=>{var f=(e,x)=>{for(var i=1;D=e[i][x],i<e.length;i++)if(D!=" ")return D},o=a.split(`
`),l=o.reduce((a,b)=>Math.max(a.length||a,b.length)),b="";for(i=0;i<l;i)b+=f(o,i++);for(i=0;b[i]!="U"&&s>0;i++)s-=b[i]=="_"?1:b[i]=="/"?5:-4;return s>0}

Ungolfed

(s,a)=>{
    var f=(e,x)=>{
        for(var i=1;D=e[i][x],i<e.length;i++)
            if(D!=" ")
                return D
    },
    o=a.split(`
`),
    l=o.reduce((a,b)=>Math.max(a.length||a,b.length)),
    b="";
    for(i=0;i<l;)
        b+=f(o,i++);
    for(i=0;b[i]!="U"&&s>0;i++)
        s-=b[i]=="_"?1:b[i]=="/"?5:-4;
    return s>0
}

प्रयोग

var o = (s,a)=>{var f=(e,x)=>{for(var i=1;D=e[i][x],i<e.length;i++)if(D!=" ")return D},o=a.split(`
`),l=o.reduce((a,b)=>Math.max(a.length||a,b.length)),b="";for(i=0;i<l;)b+=f(o,i++);for(i=0;b[i]!="U"&&s>0;i++)s-=b[i]=="_"?1:b[i]=="/"?5:-4;return s>0}


o(27, `
      ____       ____ _   
   __/    \\     /    U \\  
__/        \\   /        \\_
            \\_/           `); // will return true

— user49328
स्रोत

मेरी गलती; मुझे लगा कि मैंने पहले तर्क के रूप में "27" के साथ पहले उदाहरण में नकल की थी। मैंने इसे ठीक किया। धन्यवाद।

— user49328

1

जावा, 219 बाइट्स

boolean p(int v,String c){int z=c.length(),f[]=new int[z],e,i,k;for(String r:c.split("\n"))for(i=-1;++i<r.length();)if((e=r.charAt(i))>32)f[i]=e;for(i=-1,e=0;++i<z&v>0;)v-=(k=f[i])>94?1:k>91?-4:k>84?(e=1):5;return 0<e;}

पाठ्यक्रम को समतल करें, क्योंकि y- समन्वय कोई फर्क नहीं पड़ता, दुर्भाग्य से जावा में एक ऊर्ध्वाधर ट्रिम नहीं है। इसमें स्ट्रिंग-ट्रांज़ोज़ भी नहीं है।
चपटा पाठ्यक्रम पर आइटरेट करें और गेंद की गति पर नज़र रखें।

— ईसीएस
स्रोत

1

ऑक्टेव, 111 110 बाइट्स

function g(v,s) A([95,47,92])=[1,5,-4];all(v>cumsum(A(m=max(cat(1,strsplit(s,'\n'){:}),[],1)))(1:find(m==85)))

स्पष्टीकरण:

इनपुट को newlines पर विभाजित करें और उस कष्टप्रद सेल सरणी को मैट्रिक्स में बदलें
maxप्रत्येक स्तंभ के लिए खोज कर मैट्रिक्स को समतल करें
पात्रों के मानचित्र '_/\'को [1, 5, -4](सभी अन्य पात्रों के कम से कम '_'करने के लिए मैप की जाती हैं 0)
मैप किए गए सरणी के सभी तत्वों की संचयी राशि की गणना करें
आउटपुट Trueअगर कप के पाठ्यक्रम की शुरुआत से सभी संचयी रकम शुरू वेग ( Falseअन्यथा) से कम हो ।

यहाँ एक परीक्षण मामला है कि मैं पहले से ही विकसित किए गए दूसरे के समान है जो @ इरावन द्वारा प्रस्तावित है और कुछ परिणाम हैं:

s9 =
   /\
  /  \
_/    \
       \
        \
         U

g(11,s9) %False
ans = 0
g(17,s9) %True
ans =  1

और यहाँ पहला परीक्षण मामला है:

s10 = 
  _
 / U\
/    \
      \
       \
        \
         \
          \_

>> g(11,s10)
ans = 0
>> g(12,s10)
ans =  1

— बीकर
स्रोत

मुझे लगता है कि यदि पाठ्यक्रम "//_U\\\\\\\_परिणाम की तरह है, तो गलत है क्योंकि आप Uएक ही चीज़ के बाद चरित्र को नहीं हटाते हैं यदि आपके पास स्थानीय अधिकतम के साथ एक कोर्स है जैसे_//\\\\\U

— एरवान

@Erwan लेकिन मैं है के बाद पात्रों को दूर U। यही तो (1:find(m==85))करता है; यह पहली अनुक्रमणिका के स्थान से सबर्रे लेता है U। मैं आपके परीक्षण के मामले को शुरू करने वाले एक जोड़े के साथ जाँच करूँगा और आपको वापस प्राप्त करूँगा।

— बीकर

मैं आपका समाधान नहीं चला सका (मेरे पास ऑक्टेव नहीं है) कि मैं बस क्यों पूछ रहा हूं ... और क्योंकि मैं दूसरे अजगर समाधान में स्थानीय मैक्सिमा के साथ जारी करता हूं :) आखिरकार आपके समाधान का उपयोग स्थानीय मैक्सिमा के साथ करते हैं क्योंकि आप कम् यूसमेट का उपयोग करते हैं और सिर्फ योग (पहले पढ़ने पर यह मत देखिए)

— एरवन

@ इरान मैंने आपके द्वारा सुझाए गए दो परीक्षण मामलों को जोड़ा है। कृपया एक नज़र डालें और देखें कि क्या परिणाम आपके द्वारा अपेक्षित हैं। यदि आप MATLAB में यह कोशिश कर रहे हैं, तो आप इसे चलाने में सक्षम नहीं होंगे क्योंकि यह कुछ अनुक्रमण का उपयोग करता है जो केवल ओक्टेव में काम करता है। आपको cumsumएक मध्यवर्ती चर के परिणाम को असाइन करना होगा और फिर अंतिम तुलना के लिए इसका उपयोग करना होगा all(v>tmp(1:find(m==85)))।

— बीकर

आपका हल काम पहले पढ़ने में बहुत सारी चीजों को याद करता है (सिर्फ मैटलैब में इतने सारे इंटरमीडिएट वेरिएबल्स को टेस्ट करने के लिए)

— इरवान

0

सी, 629 बाइट्स

#include <string.h>
#include <stdlib.h>
#include <string.h>

bool swing(char *c, unsigned int p)
{
    char *olc = calloc(strlen(c), 1);
    int x = 0;
    char *n = c;

    while(1) {
        if(*n == '\0')  break;
        else if(*n == ' ') x += 1;
        else if(*n == '\n') x = 0;
        else {
            olc[x] = *n;
            x += 1;
        }
        n++;
    }

    int hd = 0;
    for(char *i = olc; i != strchr(olc, 'U'); i++) {
        if(*i == '_') hd += 1;
        else if(*i == '/') hd += 5;
        else hd -= 4;
    }

    free(olc);
    if(hd < p) return 1;
    return 0;
}

Ungolfed:

bool swing(char *course, unsigned int power)
{
    const size_t course_len = strlen(course);
    char *one_line_course = calloc(course_len, sizeof(char));
    assert(one_line_course);
    int x_pos = 0;
    char *next = course;

    //Convert to one line representation
    while(1) {
        if(*next == '\0') {
            break;
        }
        else if(*next == ' ') {
            x_pos += 1;
        }
        else if((*next == '\n') || (*next == '\r')) {
            x_pos = 0;
        }
        else {
            one_line_course[x_pos] = *next;
            x_pos += 1;
        }
        next++;
    }

    //Calculate power vs distance
    const char *hole_location = strchr(one_line_course, 'U');
    int hole_distance = 0;
    for(char *i = one_line_course; i != hole_location; i++) {
        if(*i == '_') {
            hole_distance += 1;
        }
        else if(*i == '/') {
            hole_distance += 5;
        }
        else {
            hole_distance -= 4;
        }
    }

    free(one_line_course);
    if(hole_distance < power) {
        return true;
    }
    else {
        return false;
    }
}

मूल रूप से मैं सिर्फ एक लाइन में सब कुछ फिट करने के लिए इनपुट स्ट्रिंग को परिवर्तित करने के लिए एक पास बनाता हूं, फिर

— samt1903
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! आप अधिकांश व्हाट्सएप को समाप्त करके आकार को कम करने में सक्षम हो सकते हैं (और होना चाहिए); आप अपने कुछ if/ elseजैसे कम कर सकते हैं x+=*n==' ')?1:*n=='\n'?-x:(olc[x]=*n,1। एक और टिप: सी में unsigned intलिखा जा सकता है unsigned, जिससे अभी 4 बाइट बचती हैं।

— टोबे स्पाइट

0

पायथन, 212 201 188 143 बाइट्स

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

पुनरावर्ती नहीं, इसलिए अन्य अजगर समाधान से काफी भिन्न होना चाहिए।

def g(c,p):
 o=[''.join(x).split()[0] for x in zip(*c.split('\n'))]
 t={"_":1,"/":5,"\\":-4}
 for v in o:
    if v=="U" or p<1:return p>0
    p-=t[v]

थोड़ा बढ़ा:

def g(course,power):
  course=course.split('\n') # split into lines
  course=zip(*course) 

  #transpose and flatten course, then remove spaces
  one_line_course=[''.join(x).split[0] for x in zip(*course)] 

  terrain_values={"_":1,"/":5,"\\":-4}
  for char in one_line_course:
    if char=="U" or power<1: 
      return power>0 # true when power remains, false otherwise
    power-=terrain_values[char]

— SnoringFrog
स्रोत

यदि आप एक छोटा समाधान चाहते हैं, तो आप साइओस टिप का उपयोग कर सकते हैं और अंतर्निहित फ़ंक्शन का उपयोग कर सकते हैं। इस तरह somethings o=[''.join(x).split()[0] for x in zip(*c.split('\n'))]कि 40 बाइट्स जीतने मुझे लगता है कि

— एर्वान

आप भी बदल सकते हैं breakद्वारा return p>0और हटानेif p...

— एर्वान

if"U"==v or p<1 यदि कोई स्थानीय अधिकतम_//\\\\\U

— Erwan

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

— SnoringFrog

हाँ, मुझे लगता है कि सभी लाइन की लंबाई समान है (सफेद स्थान के साथ समरूप) शायद मैं इस मामले में गलत हूं, मुझे लगता है कि मेरा समाधान खराब है

— एरवान

कोड (मिनी) गोल्फ

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

पायथ, 27 बाइट्स

हास्केल, 111 109 बाइट्स

रूबी, 104 87 वर्ण

जाप, 38 बाइट्स

व्याख्या

सीजेएम, 40 39 बाइट्स

व्याख्या

रेटिना, 82 81 77 74 68 67 68 बाइट्स

ईएस 6, 117 बाइट्स

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

व्याख्या

परीक्षा

पायथन (3.5) 169 160 बाइट्स

Ungolfed

प्रयोग

पायथ, 35 बाइट्स

रूबी, 85 वर्ण

जावा, 219 बाइट्स

ऑक्टेव, 111 110 बाइट्स

स्पष्टीकरण:

सी, 629 बाइट्स

पायथन, 212 201 188 143 बाइट्स