Diberi pandangan sisi lapangan golf mini dan kekuatan ayunan, tentukan apakah bola akan berhasil masuk ke dalam lubang.

Kursus akan berada dalam format ini:

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

Bola mulai langsung sebelum bagian pertama dari tanah di sebelah kiri dan mengikuti kontur jalur sampai mencapai lubang (huruf besar di Ubawah level saat ini dari tanah). Jika mencapai lubang, output nilai yang sebenarnya. Kekuatan ayunan akan menjadi kecepatan awal bola. Bola bergerak ke karakter berikutnya di sebelah kanan di setiap iterasi, kemudian kecepatan diubah tergantung pada karakter yang sekarang aktif. Jika kecepatan mencapai 0atau kurang sebelum lubang, hasilkan nilai falsey.

• _ mengurangi kecepatan oleh 1
• / mengurangi kecepatan oleh 5
• \ meningkatkan kecepatan 4

Kursus dapat diisi dengan spasi. Kekuatan ayunan akan selalu menjadi bilangan bulat positif.

Anda tidak perlu khawatir bola akan terlalu cepat masuk ke dalam lubang, berguling mundur atau melompat / memantul dari bukit.

Uji Kasus

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

Ini adalah kode mini-golf, jawaban terpendek dalam byte menang!

Pyth, 27 byte

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

Demonstrasi

Kode ini melakukan sesuatu yang sangat pintar dan tidak aman sama sekali X. Lihat di bawah.

Penjelasan:

.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

Contoh penggunaan:

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

Bagaimana itu bekerja:

                            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                                 

Sunting: @ user81655 ditemukan 2 byte untuk disimpan. Terima kasih!

Ruby, 104 87 karakter

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

Contoh dijalankan:

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!

Mengalahkan CJam!

Penjelasan

Pada dasarnya mengambil input string, memutarnya 90deg searah jarum jam, menghapus spasi dan baris baru, menghilangkan lubang dan semuanya setelahnya, dan membelah bersama karakter. Kemudian periksa apakah bola pernah mencapai nol atau di bawah menggunakan everyfungsi.

CJam, 40 39 byte

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

Input memiliki kekuatan pada baris pertama dan tentu saja mulai pada baris kedua. Output adalah 0atau 1.

Uji di sini.

Penjelasan

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 byte

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

^>*U

Cobalah online

• Input diwakili dalam basis unary , seperti n >s - misalnya, 4 adalah >>>>\n. (apakah ini legal?)

• +`(?<=(.)*) (?=.*¶(?<-1>.)*(.)) $2 - Ratakan jalurnya - ganti spasi dengan karakter di bawahnya.

  Setelah tahap ini, data akan terlihat seperti ini:

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

  Kita bisa mengabaikan semuanya setelah yang pertama U, kita tidak akan sampai di sana.

• > mewakili langkah yang diizinkan untuk kita lakukan, atau energi yang tersisa.
• Ganti masing \- masing dengan empat >- lereng memberi kita energi tambahan.
• Loop: menghapus secara kontroversial >_atau >>>>>/sampai tidak ada lagi _s dan /s mengkonsumsi energi.
• Akhirnya, cobalah untuk mencocokkan ^>*U- periksa apakah kita dapat mencapai Udengan energi positif (atau tanpa energi).
  Ini akan menampilkan 0atau 1.

Opsi tutup lainnya dengan 91 79 byte adalah:

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

Cobalah online

Ini adalah pendekatan yang sama tetapi dengan kelompok penyeimbang alih-alih pengganti yang kontroversial.

Saya yakin keduanya bisa di-pegolf lebih jauh, jadi salah satu dari mereka mungkin berakhir lebih pendek.

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

Tidak Disatukan:

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

Sunting: Disimpan 4 byte berkat to.

JavaScript (ES6), 108 107 106 byte

Ini adalah solusi yang saya buat ketika saya menciptakan tantangan.

(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

Penjelasan

Membawa kekuatan sebagai angka dan tentu saja sebagai string. Pengembalian 1untuk trueatau 0untuk false. Kursus harus diisi dengan spasi.

(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

Uji

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

Solusi rekursif tanpa fungsi transpose (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

Tidak disatukan

c untuk kursus, p untuk daya, v untuk kecepatan, h untuk tinggi

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

Pemakaian

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

Pyth, 35 byte

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

Penjelasan

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

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

Diadaptasi jawaban 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}

Tidak disatukan

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

Pemakaian

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

• Ratakan saja, karena koordinat y tidak penting, sayangnya Java tidak memiliki garis vertikal. Itu juga tidak memiliki String-transpose.

• Ulangi jalur yang rata dan catat kecepatan bola.

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

Penjelasan:

• Membagi input pada baris baru dan mengonversi susunan sel yang menjengkelkan itu menjadi matriks
• Ratakan matriks dengan menemukan maxuntuk setiap kolom
• Peta karakter '_/\'ke [1, 5, -4](semua karakter lain kurang dari '_'yang dipetakan ke 0)
• Hitung jumlah kumulatif semua elemen array yang dipetakan
• Keluaran Truejika semua jumlah kumulatif dari awal kursus ke cangkir kurang dari kecepatan awal ( Falsejika tidak).

Ini adalah test case yang sudah saya kembangkan mirip dengan yang kedua yang diusulkan oleh @Erwan dan beberapa hasil:

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

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

Dan inilah ujian pertama:

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

Tidak Disatukan:

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

Pada dasarnya saya hanya membuat satu pass untuk mengkonversi string input agar sesuai semuanya dalam satu baris, lalu

Python, 212 201 188 143 byte

Sebagian besar kredit untuk iterasi skrip ini jatuh ke @Erwan, yang memberi saya pendekatan yang sama sekali berbeda untuk mencoba dan beberapa tips yang menyelamatkan saya 55 byte pada akhirnya.

Tidak rekursif, jadi harus jauh berbeda dari solusi python lainnya.

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]

Tidak digabungkan sedikit:

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]