Biorąc pod uwagę widok z boku pola do minigolfa i siłę uderzenia, określ, czy piłka trafi do dołka.

Kurs będzie w tym formacie:

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

Piłka zaczyna się bezpośrednio przed pierwszym kawałkiem ziemi po lewej stronie i podąża za konturem pola aż do otworu (wielka litera Uponiżej aktualnego poziomu podłoża). Jeśli dojdzie do dziury, wypisz prawdziwą wartość. Mocą uderzenia będzie początkowa prędkość piłki. Podczas każdej iteracji piłka przesuwa się do następnej postaci po prawej, a następnie zmienia się prędkość w zależności od postaci, w której się znajduje. Jeśli prędkość osiągnie 0lub mniej przed dołkiem, wypisz wartość falsey.

• _ zmniejsza prędkość o 1
• / zmniejsza prędkość o 5
• \ zwiększa prędkość o 4

Kursy mogą być opcjonalnie wypełnione spacjami. Moc huśtawki zawsze będzie dodatnią liczbą całkowitą.

Nie musisz się martwić, że piłka będzie zbyt szybka, aby wejść do dołka, przetoczyć się do tyłu lub skoczyć / odbić się od wzgórz.

Przypadki testowe

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

To jest kod do minigolfa, wygrywa najkrótsza odpowiedź w bajtach!

Pyth, 27 bajtów

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

Demonstracja

Ten kod robi coś bardzo sprytnego i wcale nie jest bezpieczny dla typu X. Sprawdź to poniżej.

Wyjaśnienie:

.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.

Haskell, 111 109 bajtów

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

Przykład użycia:

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

Jak to działa:

                            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                                 

Edycja: @ user81655 znalazł 2 bajty do zapisania. Dzięki!

Ruby, 104 87 znaków

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

Przykładowy przebieg:

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 

Japt, 38 bajtów

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

Try it here!

Pokonując CJam!

Wyjaśnienie

Zasadniczo pobiera ciąg znaków, obraca go o 90 stopni zgodnie z ruchem wskazówek zegara, usuwa spacje i znaki nowej linii, usuwa dziurę i wszystko po niej oraz dzieli wzdłuż znaków. Następnie sprawdza, czy piłka kiedykolwiek osiągnie zero lub mniej, używając everyfunkcji.

CJam, 40 39 bajtów

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

Wejście ma moc na pierwszej linii, a kurs zaczyna się na drugiej linii. Dane wyjściowe to 0lub 1.

Sprawdź to tutaj.

Wyjaśnienie

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.

Retina, 82 81 77 74 68 67 68 bajtów

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

^>*U

Wypróbuj online

• Dane wejściowe są reprezentowane w jednostkowej bazie , jak n >s - na przykład 4 to >>>>\n. (czy to legalne?)

• +`(?<=(.)*) (?=.*¶(?<-1>.)*(.)) $2 - spłaszcz kurs - zastąp spacje postacią pod nimi.

  Po tym etapie dane będą wyglądać następująco:

  >>>>>>>>>>>>>>>>>>>>>>>>>>
  __/__/____\\\_///____U_\\_
  __/__/    \\\_///    U \\_
  __/        \\_//        \_
              \_/           
  

  Możemy po prostu zignorować wszystko po pierwszym U, i tak tam nie dotrzemy.

• > reprezentują krok, który możemy zrobić, lub pozostałą energię.
• Zastąp każdy \z nich czterema >- nachylenie daje nam dodatkową energię.
• Pętla: kontrowersyjnie usuń >_lub >>>>>/dopóki nie pozostanie żadna. _y i /y zużywa energię.
• Na koniec spróbuj dopasować ^>*U- sprawdź, czy możemy osiągnąć Upozytywną energię (lub brak energii).
  Spowoduje to wygenerowanie 0lub 1.

Inną zamkniętą opcją z 91 79 bajtami jest:

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

Wypróbuj online

Jest to to samo podejście, ale z grupą równoważącą zamiast kontrowersyjnej wymiany.

Jestem pewien, że oba można dalej grać w golfa, więc każdy z nich może być krótszy.

ES6, 117 bajtów

(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

Nie golfowany:

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;
}

Edycja: Zapisano 4 bajty dzięki ՊՓԼՃՐՊՃՈԲՍԼ.

JavaScript (ES6), 108 107 106 bajtów

Oto rozwiązanie, które wymyśliłem, tworząc wyzwanie.

(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

Wyjaśnienie

Traktuje moc jako liczbę, a przebieg jako ciąg. Zwraca 1za truelub 0za false. Tor musi być wypełniony spacjami.

(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

Test

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>

Python (3.5) 169 160 bajtów

Rozwiązanie rekurencyjne bez funkcji transpozycji (zip)

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

Bez golfa

c dla kursu, p dla mocy, v dla prędkości, h dla wysokości

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

Stosowanie

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

Pyth, 35 bajtów

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

Wyjaśnienie

                                    - 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 ()

Ruby, 85 znaków

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

Dostosowano odpowiedź @ manatwork

JavaScript, 266 263 244 bajtów

(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}

Bez golfa

(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
}

Stosowanie

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

Java, 219 bajtów

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;}

• Spłaszcz kurs, ponieważ współrzędna y nie ma znaczenia, niestety Java nie ma pionowego wykończenia. Nie ma też transpozycji ciągów.

• Iteruj nad spłaszczonym kursem i śledź prędkość piłki.

Oktawa, 111 110 bajtów

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)))

Wyjaśnienie:

• Podziel dane wejściowe na nowe linie i przekonwertuj tę irytującą macierz komórek na macierz
• Spłaszcz macierz, znajdując maxdla każdej kolumny
• Zamapuj znaki '_/\'na [1, 5, -4](wszystkie inne znaki mniejsze niż '_'są zamapowane 0)
• Oblicz skumulowaną sumę wszystkich elementów odwzorowanej tablicy
• Wyjście, Truejeśli wszystkie sumy sumaryczne od początku kursu do kubka są mniejsze niż prędkość początkowa (w Falseprzeciwnym razie).

Oto przypadek testowy, który już opracowałem, podobny do drugiego zaproponowanego przez @Erwan i kilka wyników:

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

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

A oto pierwszy przypadek testowy:

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

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

C, 629 bajtów

#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;
}

Nie golfowany:

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;
    }
}

Zasadniczo wykonuję tylko jedno przejście, aby przekonwertować ciąg wejściowy, aby pasował do wszystkiego w jednym wierszu

Python, 212 201 188 143 bajtów

Duża część tej iteracji tego skryptu przypada @Erwan, który dał mi zupełnie inne podejście do próby i kilka wskazówek, które w końcu pozwoliły mi zaoszczędzić 55 bajtów.

Nie rekurencyjne, więc powinno znacznie różnić się od innych rozwiązań python.

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]

Ungolfed trochę:

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]