Đưa ra một cái nhìn bên cạnh của một sân golf mini và sức mạnh của cú swing, xác định xem quả bóng sẽ làm cho nó vào lỗ.

Một khóa học sẽ có định dạng này:

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

Quả bóng bắt đầu trực tiếp trước mảnh đất đầu tiên bên trái và theo đường viền của khóa học cho đến khi nó chạm tới lỗ (một chữ hoa Udưới mức hiện tại của mặt đất). Nếu nó đạt đến lỗ, xuất ra một giá trị trung thực. Sức mạnh của cú swing sẽ là tốc độ ban đầu của quả bóng. Quả bóng di chuyển đến nhân vật tiếp theo bên phải ở mỗi lần lặp, sau đó tốc độ được thay đổi tùy thuộc vào nhân vật hiện tại. Nếu tốc độ đạt 0hoặc thấp hơn trước lỗ, xuất ra giá trị falsey.

• _ giảm tốc độ 1
• / giảm tốc độ 5
• \ tăng tốc độ bằng 4

Các khóa học có thể tùy chọn được đệm với không gian. Sức mạnh của cú swing sẽ luôn là một số nguyên dương.

Bạn không cần phải lo lắng về việc bóng đi quá nhanh để chui vào lỗ, lăn ngược hoặc nhảy / nảy khỏi đồi.

Các trường hợp thử nghiệm

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

Đây là mã mini-golf, câu trả lời ngắn nhất trong byte thắng!

Bình thường, 27 byte

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

Trình diễn, thuyết trình

Mã này làm một cái gì đó rất thông minh và hoàn toàn không an toàn với loại X. Kiểm tra nó dưới đây.

Giải trình:

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

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

Ví dụ sử dụng:

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

Làm thế nào nó hoạt động:

                            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                                 

Chỉnh sửa: @ user81655 tìm thấy 2 byte để lưu. Cảm ơn!

Ruby, 104 87 ký tự

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

Chạy mẫu:

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 byte

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

Try it here!

Đánh bại CJam!

Giải trình

Về cơ bản lấy đầu vào chuỗi, xoay 90deg theo chiều kim đồng hồ, loại bỏ khoảng trắng và dòng mới, loại bỏ lỗ và mọi thứ sau nó, và phân chia dọc theo ký tự. Sau đó kiểm tra xem bóng bao giờ về 0 hay thấp hơn bằng cách sử dụng everyhàm.

CJam, 40 39 byte

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

Đầu vào có sức mạnh trên dòng đầu tiên và khóa học bắt đầu trên dòng thứ hai. Đầu ra là 0hoặc 1.

Kiểm tra nó ở đây.

Giải trình

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.

Võng mạc, 82 81 77 74 68 67 68 byte

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

^>*U

Dùng thử trực tuyến

• Đầu vào được biểu diễn trong cơ sở đơn nguyên , như n >s - ví dụ: 4 là >>>>\n. (điều này có hợp pháp không?)

• +`(?<=(.)*) (?=.*¶(?<-1>.)*(.)) $2 - làm phẳng khóa học - thay thế khoảng trắng bằng ký tự bên dưới chúng.

  Sau giai đoạn này, dữ liệu sẽ trông như thế này:

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

  Chúng tôi chỉ có thể bỏ qua mọi thứ sau lần đầu tiên U, dù sao chúng tôi sẽ không đến đó.

• > đại diện cho một bước chúng ta được phép thực hiện, hoặc năng lượng còn lại.
• Thay thế mỗi \bằng bốn >- một độ dốc cho chúng ta thêm năng lượng.
• Vòng lặp: gỡ bỏ một cách hài lòng >_hoặc >>>>>/cho đến khi không còn lại. _s và /s tiêu thụ năng lượng.
• Cuối cùng, cố gắng khớp ^>*U- kiểm tra xem chúng ta có thể đạt được Uvới năng lượng tích cực (hoặc không có năng lượng).
  Điều này sẽ đầu ra 0hoặc 1.

Một tùy chọn đóng khác với 91 79 byte là:

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

Dùng thử trực tuyến

Đây là cách tiếp cận tương tự nhưng với một nhóm cân bằng thay vì một sự thay thế gây tranh cãi.

Tôi chắc chắn rằng cả hai thứ này có thể được chơi gôn hơn nữa, vì vậy bất kỳ một trong số chúng có thể kết thúc ngắn hơn.

ES6, 117 byte

(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

Ung dung:

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

Chỉnh sửa: Đã lưu 4 byte nhờ.

JavaScript (ES6), 108 107 106 byte

Đây là giải pháp tôi đã đưa ra khi tôi tạo ra thử thách.

(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

Giải trình

Lấy sức mạnh như một con số và khóa học như một chuỗi. Trả về 1cho truehoặc 0cho false. Khóa học phải được đệm với không gian.

(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

Kiểm tra

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 byte

Một giải pháp đệ quy không có chức năng chuyển vị (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

Ung dung

c cho khóa học, p cho sức mạnh, v cho tốc độ, h cho chiều cao

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

Sử dụng

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

Bình thường, 35 byte

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

Giải trình

                                    - 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 ký tự

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

Câu trả lời của @ manatwork

JavaScript, 266 263 244 byte

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

Ung dung

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

Sử dụng

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 byte

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

• Làm phẳng khóa học, vì tọa độ y không thành vấn đề, thật không may, Java không có phần cắt dọc. Nó cũng không có String-transpose.

• Lặp lại quá trình làm phẳng và theo dõi tốc độ bóng.

Octave, 111 110 byte

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

Giải trình:

• Tách đầu vào trên dòng mới và chuyển đổi mảng ô khó chịu đó thành ma trận
• Làm phẳng ma trận bằng cách tìm maxcho mỗi cột
• Ánh xạ các ký tự '_/\'đến [1, 5, -4](tất cả các ký tự khác ít hơn '_'được ánh xạ tới 0)
• Tính tổng tích lũy của tất cả các phần tử của mảng được ánh xạ
• Đầu ra Truenếu tất cả các khoản tiền tích lũy từ đầu khóa học đến cốc nhỏ hơn tốc độ bắt đầu ( Falsenếu không).

Đây là một trường hợp thử nghiệm mà tôi đã phát triển tương tự như trường hợp thứ hai được đề xuất bởi @Erwan và một vài kết quả:

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

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

Và đây là trường hợp thử nghiệm đầu tiên:

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

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

C, 629 byte

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

Ung dung:

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

Về cơ bản tôi chỉ thực hiện một lượt để chuyển đổi chuỗi đầu vào để phù hợp với mọi thứ trong một dòng, sau đó

Python, 212 201 188 143 byte

Phần lớn tín dụng cho lần lặp này của tập lệnh này được gửi đến @Erwan, người đã cho tôi một cách tiếp cận hoàn toàn khác để thử và một số mẹo giúp tôi tiết kiệm được 55 byte cuối cùng.

Không đệ quy, do đó, nên khác biệt đáng kể với các giải pháp trăn khác.

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]

Bực mình một chút:

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]