ให้มุมมองด้านข้างของสนามมินิกอล์ฟและพลังของการแกว่งพิจารณาว่าลูกจะทำให้มันเข้าไปในหลุมหรือไม่

หลักสูตรจะอยู่ในรูปแบบนี้:

      ____       ____ _   
   __/    \     /    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

นี่คือรหัส mini-golf คำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ!

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

Haskell, 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 ไบต์เพื่อบันทึก ขอบคุณ!

Ruby, 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 

Japtap, 38 ไบต์

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

Try it here!

เอาชนะ CJam!

คำอธิบาย

โดยทั่วไปแล้วจะใส่สายอักขระหมุนตามเข็มนาฬิกา 90deg, ช่องว่างออกและขึ้นบรรทัดใหม่เอาหลุมและทุกอย่างหลังจากนั้นและแยกตามตัวอักษร จากนั้นตรวจสอบว่าลูกบอลได้ถึงศูนย์หรือต่ำกว่าโดยใช้everyฟังก์ชัน

CJam, 40 39 ไบต์

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

ข้อมูลเข้ามีพลังในบรรทัดแรกและหลักสูตรเริ่มต้นที่บรรทัดที่สอง เอาท์พุทเป็นหรือ01

ทดสอบที่นี่

คำอธิบาย

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.

จอประสาทตา, 82 81 77 74 68 67 68 ไบต์

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

^>*U

ลองออนไลน์

• การป้อนข้อมูลเป็นตัวแทนในฐานเอกเป็น n >s - ตัวอย่างเช่น >>>>\n4 (เป็นกฎหมายหรือไม่)

• +`(?<=(.)*) (?=.*¶(?<-1>.)*(.)) $2 - แผ่หลักสูตร - แทนที่ช่องว่างด้วยอักขระด้านล่าง

  หลังจากขั้นตอนนี้ข้อมูลจะเป็นดังนี้:

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

  เราสามารถเพิกเฉยทุกอย่างหลังจากแรกUเราจะไม่ไปถึงที่นั่น

• > เป็นตัวแทนของขั้นตอนที่เราได้รับอนุญาตให้ทำหรือพลังงานที่เหลืออยู่
• แทนที่แต่ละอัน\ด้วยสี่>- ความชันให้พลังงานเพิ่มเติมแก่เรา
• วนซ้ำ: เอาออก>_หรือ>>>>>/จนกว่าจะไม่มีใครเหลือ _และ/s บริโภคพลังงาน
• สุดท้ายลองจับคู่^>*U- ตรวจสอบว่าเราสามารถเข้าถึงUด้วยพลังงานบวก (หรือไม่มีพลังงาน)
  ออกจะนี้หรือ01

ตัวเลือกปิดอื่นที่มี91 79 ไบต์คือ:

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

ลองออนไลน์

นี่เป็นวิธีการเดียวกัน แต่ใช้กลุ่มที่สมดุลแทนการแทนที่แบบแย้ง

ฉันแน่ใจว่าทั้งสองอย่างนี้สามารถตีกอล์ฟต่อไปได้ดังนั้นหนึ่งในนั้นอาจสั้นลง

ES6, 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

JavaScript (ES6), 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>

Python (3.5) 169 160 ไบต์

โซลูชันแบบเรียกซ้ำโดยไม่มีฟังก์ชั่นขนย้าย (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 สำหรับหลักสูตร, p สำหรับพลังงาน, v สำหรับความเร็ว, h สำหรับความสูง

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

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

Ruby, 85 ตัวอักษร

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

คำตอบของ Adapted @ manatwork

JavaScript, 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

Java, 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 ไม่สำคัญเสียดายที่ Java ไม่มีขอบตัดตามแนวตั้ง นอกจากนี้ยังไม่มี String-transpose

• วนซ้ำในแนวราบและติดตามความเร็วลูก

ระดับเสียงคู่111 111ไบต์

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

คำอธิบาย:

• แยกอินพุตบนบรรทัดใหม่และแปลงเซลล์อาร์เรย์ที่น่ารำคาญเป็นเมทริกซ์
• แผ่เมทริกซ์โดยการค้นหาmaxสำหรับแต่ละคอลัมน์
• แม็พอักขระ'_/\'กับ[1, 5, -4](อักขระอื่นทั้งหมดที่น้อยกว่า'_'ถูกแม็พกับ0)
• คำนวณผลรวมสะสมขององค์ประกอบทั้งหมดของอาร์เรย์ที่แมป
• เอาท์พุทTrueถ้าผลรวมสะสมทั้งหมดจากจุดเริ่มต้นของหลักสูตรไปยังถ้วยน้อยกว่าความเร็วเริ่มต้น ( Falseอย่างอื่น)

นี่เป็นกรณีทดสอบที่ฉันได้พัฒนาแล้วคล้ายกับกรณีที่สองที่เสนอโดย @Erwan และผลลัพธ์สองสามข้อ:

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

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

โดยพื้นฐานแล้วฉันเพิ่งผ่านการแปลงสตริงอินพุตให้พอดีกับทุกสิ่งในหนึ่งบรรทัดจากนั้น

Python, 212 201 188 143 ไบต์

เครดิตส่วนใหญ่สำหรับการทำซ้ำของสคริปต์นี้ไปที่ @Erwan ซึ่งให้วิธีการที่แตกต่างอย่างสิ้นเชิงกับฉันในการลองและเคล็ดลับบางอย่างที่ช่วยฉัน 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]

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]