미니 골프 코스의 측면과 스윙의 힘이 주어지면 공이 구멍에 들어갈 지 결정하십시오.

과정은 다음과 같은 형식으로 진행됩니다.

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

이것은 바이트 미니로 코드 미니 골프, 짧은 대답입니다!

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.

하스켈 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 바이트를 찾았습니다. 감사!

루비, 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 

apt, 38 바이트

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

Try it here!

CJam을 때리는!

설명

기본적으로 문자열 입력을 가져 와서 시계 방향으로 90도 회전하고 공백과 줄 바꿈을 제거하고 구멍과 그 이후의 모든 것을 제거하고 문자를 따라 나눕니다. 그런 다음이 every기능을 사용하여 공이 제로 또는 아래에 도달하는지 확인 합니다.

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

망막, 82 81 77 74 68 67 68 바이트

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

^>*U

온라인으로 사용해보십시오

• 입력은 n s 와 같이 단항 밑수 로 표시됩니다 ( >예 : 4는) >>>>\n. (이것이 합법적입니까?)

• +`(?<=(.)*) (?=.*¶(?<-1>.)*(.)) $2 -코스를 평평하게-공백을 아래 문자로 바꿉니다.

  이 단계가 끝나면 데이터는 다음과 같습니다.

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

  우리는 첫 번째 이후의 모든 것을 무시할 수 있습니다 U.

• > 우리가 할 수있는 단계 또는 남은 에너지를 나타냅니다.
• 각각 \을 4로 교체하십시오 >-경사는 추가 에너지를 제공합니다.
• 루프 : 논쟁 적으로 제거 >_하거나 >>>>>/남은 것이 없을 때까지. _S와 /S는 소비 에너지를.
• 마지막으로, 일치를 시도 ^>*U하십시오-우리 U가 긍정적 인 에너지 (또는 에너지가없는)에 도달 할 수 있는지 확인하십시오 .
  이 출력됩니다 0나 1.

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

언 골프 드 :

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 바이트가 절약되었습니다.

자바 스크립트 (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>

파이썬 (3.5) 169160 바이트

조옮김 기능이없는 재귀 솔루션 (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

언 골프

코스는 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 ()

루비, 85 자

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

@manatwork의 답변에 적응

자바 스크립트, 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}

언 골프

(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

자바, 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가 없습니다.

• 평평한 코스를 반복하고 볼 속도를 추적합니다.

옥타브, 111110 바이트

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

언 골프 드 :

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

기본적으로 한 줄로 모든 것을 맞추기 위해 입력 문자열을 변환하기 위해 한 번만 패스하면됩니다.

파이썬 212 201 188 143 바이트

이 스크립트의 반복에 대한 많은 신용은 @Erwan에게 전달됩니다.

재귀 적이 지 않으므로 다른 파이썬 솔루션과 실질적으로 달라야합니다.

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]