Bestimmen Sie anhand der Seitenansicht eines Minigolfplatzes und der Schlagkraft, ob der Ball es in das Loch schafft.

Ein Kurs wird in diesem Format sein:

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

Der Ball beginnt direkt vor dem ersten Stück Boden links und folgt der Kontur des Platzes, bis er das Loch erreicht (ein Großbuchstabe Uunterhalb des aktuellen Bodenniveaus). Wenn es das Loch erreicht, geben Sie einen Wahrheitswert aus. Die Kraft des Schwungs ist die Anfangsgeschwindigkeit des Balls. Der Ball bewegt sich bei jeder Iteration zum nächsten Zeichen rechts, dann ändert sich die Geschwindigkeit in Abhängigkeit von dem Zeichen, auf dem er sich gerade befindet. Wenn die Geschwindigkeit 0vor dem Loch erreicht oder darunter liegt, geben Sie einen Falsey-Wert aus.

• _ verringert die Geschwindigkeit um 1
• / verringert die Geschwindigkeit um 5
• \ erhöht die Geschwindigkeit um 4

Kurse können optional mit Leerzeichen aufgefüllt werden. Die Kraft des Swings wird immer eine positive ganze Zahl sein.

Sie brauchen sich keine Sorgen zu machen, dass der Ball zu schnell ins Loch geht, rückwärts rollt oder von Hügeln springt / hüpft.

Testfälle

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

Dies ist Code-Minigolf, die kürzeste Antwort in Bytes gewinnt!

Pyth, 27 Bytes

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

Demonstration

Dieser Code macht etwas sehr Cleveres und überhaupt nicht typsicheres mit X. Schau es dir unten an.

Erläuterung:

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

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

Anwendungsbeispiel:

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

Wie es funktioniert:

                            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                                 

Edit: @ user81655 2 Bytes zum Speichern gefunden. Vielen Dank!

Ruby, 104 87 Zeichen

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

Probelauf:

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 Bytes

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

Try it here!

CJam schlagen!

Erläuterung

Nimmt im Grunde genommen die Zeichenketteneingabe, dreht sie um 90 Grad im Uhrzeigersinn, entfernt Leerzeichen und Zeilenumbrüche, entfernt das Loch und alles danach und teilt sich entlang der Zeichen. Überprüft dann mithilfe der everyFunktion , ob der Ball jemals auf Null oder darunter fällt .

CJam, 40 39 Bytes

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

Der Eingang hat die Leistung in der ersten Zeile und der Kurs beginnt in der zweiten Zeile. Ausgang ist 0oder 1.

Teste es hier.

Erläuterung

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 Bytes

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

^>*U

Probieren Sie es online aus

• Die Eingabe wird in einer unären Basis dargestellt , wie ns >- zum Beispiel 4 ist >>>>\n. (Ist das legal?)

• +`(?<=(.)*) (?=.*¶(?<-1>.)*(.)) $2 - Kurs abflachen - Leerzeichen durch das Zeichen darunter ersetzen.

  Nach dieser Phase sehen die Daten folgendermaßen aus:

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

  Wir können einfach alles nach dem ersten ignorieren U, wir werden es sowieso nicht erreichen.

• > stellen einen Schritt dar, den wir machen dürfen, oder die verbleibende Energie.
• Ersetze jedes \durch vier >- eine Steigung gibt uns zusätzliche Energie.
• Schleife: Umstritten entfernen >_oder >>>>>/bis keine mehr vorhanden sind. _s und /s verbrauchen Energie.
• Versuchen Sie schließlich, eine Übereinstimmung zu ^>*Uerzielen - prüfen Sie, ob wir Umit positiver Energie (oder ohne Energie) erreichen können.
  Dies gibt 0oder aus 1.

Eine weitere Option zum Schließen mit 91 bis 79 Bytes ist:

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

Probieren Sie es online aus

Dies ist der gleiche Ansatz, jedoch mit einer Bilanzgruppe anstelle eines umstrittenen Ersatzes.

Ich bin sicher, dass beide weiter Golf spielen können, so dass jeder von ihnen möglicherweise kürzer wird.

ES6, 117 Bytes

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

Bearbeiten: 4 Bytes dank ՊՓԼՃՐՊՃՈԲՍԼ gespeichert.

JavaScript (ES6), 108 107 106 Bytes

Dies ist die Lösung, die ich gefunden habe, als ich die Herausforderung erstellt habe.

(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

Erläuterung

Nimmt die Kraft als Zahl und den Kurs als Zeichenfolge. Rückgabe 1für trueoder 0für false. Die Strecke muss mit Leerzeichen aufgefüllt sein.

(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

Prüfung

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 Bytes

Eine rekursive Lösung ohne Transponierfunktion (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

Ungolfed

c für Kurs, p für Leistung, v für Geschwindigkeit, h für Höhe

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

Verwendungszweck

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

Pyth, 35 Bytes

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

Erläuterung

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

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

Angepasste @ manatworks Antwort

JavaScript, 266 263 244 Bytes

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

Verwendungszweck

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 Bytes

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

• Den Kurs abflachen, da die y-Koordinate keine Rolle spielt, hat Java leider keine vertikale Trimmung. Es hat auch keine String-Transponierung.

• Iterieren Sie über den abgeflachten Kurs und verfolgen Sie die Ballgeschwindigkeit.

Oktave, 111 110 Bytes

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

Erläuterung:

• Teilen Sie die Eingabe in Zeilenumbrüche und konvertieren Sie das lästige Zellenarray in eine Matrix
• Glätten Sie die Matrix, indem Sie maxfür jede Spalte die finden
• Ordnen Sie die Zeichen '_/\'zu [1, 5, -4](alle anderen Zeichen, denen weniger als zugeordnet '_'sind 0)
• Berechnen Sie die kumulative Summe aller Elemente des zugeordneten Arrays
• TrueWird ausgegeben, wenn alle kumulierten Summen vom Beginn des Kurses bis zum Cup kleiner als die Startgeschwindigkeit sind ( Falseansonsten).

Hier ist ein Testfall, den ich bereits ähnlich wie den zweiten von @Erwan vorgeschlagenen entwickelt habe, und ein paar Ergebnisse:

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

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

Und hier ist der erste Testfall:

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

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

C 629 Bytes

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

Im Grunde genommen mache ich nur einen Durchgang, um die Eingabezeichenfolge so zu konvertieren, dass alles in eine Zeile passt

Python, 212 201 188 143 Bytes

Ein Großteil des Verdienstes für diese Iteration dieses Skripts geht an @Erwan, der mir einen völlig anderen Ansatz und einige Tipps gegeben hat, mit denen ich am Ende 55 Bytes gespart habe.

Nicht rekursiv, sollte sich also wesentlich von der anderen Python-Lösung unterscheiden.

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]

Ein bisschen Ungolfed:

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]