Mini golf sahasının yandan görünüşü ve vuruşun gücü göz önüne alındığında, topun deliğe girip girmeyeceğini belirleyin.

Bir kurs bu formatta olacak:

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

Top , soldaki ilk toprak parçasından hemen önce başlar ve deliğe ulaşana kadar ( Utoprağın mevcut seviyesinin altında bir büyük harf) rotanın dış çizgisini takip eder . Deliğe ulaşırsa, gerçek bir değer üretin. Salıncağın gücü, topun ilk hızı olacaktır. Top her yinelemede sağdaki bir sonraki karaktere geçer, sonra şimdiki karaktere bağlı olarak hız değiştirilir. Hız 0delikten önce veya daha az ulaşırsa , bir falsey değeri verin.

• _ hızını azaltır 1
• / hızını azaltır 5
• \ hızı arttırır 4

Kurslar isteğe bağlı olarak boşluklarla doldurulabilir. Salınımın gücü her zaman pozitif bir tamsayı olacaktır.

Topun deliğe girmesi, geriye doğru yuvarlanması veya tepelerden sıçraması / sıçraması için çok hızlı gitmesi konusunda endişelenmenize gerek yoktur.

Test Kılıfları

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

Bu kod mini-golf, bayt cinsinden en kısa cevap kazanır!

Pyth, 27 bayt

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

gösteri

Bu kod, çok akıllıca bir işlem yapar ve kesinlikle güvenli bir cihaz değildir X. Aşağıdan kontrol et.

Açıklama:

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

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

Kullanım örneği:

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

Nasıl çalışır:

                            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                                 

Düzenleme: @ user81655 kaydetmek için 2 bayt buldu. Teşekkürler!

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}

Örnek çalışma:

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 bayt

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

Try it here!

CJam'ı dövmek!

açıklama

Temel olarak string girişini alır, saat yönünde 90 derece döndürür, boşlukları ve yeni çizgileri çıkarır, deliği ve arkasındaki her şeyi çıkarır ve karakter boyunca böler. Ardından, everyişlevi kullanarak topun sıfıra veya altına düşüp düşmediğini kontrol edin .

CJam, 40 39 bayt

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

Giriş, ilk satırda ve ikinci satırda başlayan rotada güce sahiptir. Çıktı 0veya 1.

Burada test et.

açıklama

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 bayt

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

^>*U

Çevrimiçi deneyin

• Giriş, ns> - örneğin, 4 olduğu gibi , unary bazda temsil edilir >>>>\n. (bu yasal mı?)

• +`(?<=(.)*) (?=.*¶(?<-1>.)*(.)) $2 - rotayı düzleştirin - boşlukları altlarındaki karakterle değiştirin.

  Bu aşamadan sonra veriler şöyle görünecektir:

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

  İlkinden sonra her şeyi görmezden gelebiliriz U, oraya asla ulaşamayacağız.

• > yapmamıza izin verilen bir adımı veya kalan enerjiyi gösterir.
• Her birini \dört ile değiştirin >- bir eğim bize ek enerji sağlar.
• Döngü: tartışmalı bir şekilde kaldırın >_ya da kalanı >>>>>/kalmayıncaya kadar. _s ve /s enerji tüketir .
• Son olarak eşleştirmeye çalışın ^>*U- Upozitif enerjiyle (veya enerjisiz) ulaşıp ulaşamayacağımızı kontrol edin .
  Bu 0veya çıkacaktır 1.

91 79 baytlık bir başka yakın seçenek ise:

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

Çevrimiçi deneyin

Bu aynı yaklaşımdır, ancak tartışmalı bir ikame yerine dengeleyici bir gruba sahiptir.

Her ikisinin de daha fazla golf oynayabileceğinden eminim, bu yüzden herhangi biri daha kısa sürebilir.

ES6, 117 bayt

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

Düzenleme: thanks sayesinde 4 bayt kaydedildi.

JavaScript (ES6), 108 107 106 bayt

Bu, mücadeleyi yarattığımda karşılaştığım çözüm.

(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

açıklama

Gücü sayı olarak alır, kursu ip olarak alır. 1İçin trueveya 0için döner false. Tabii boşluklarla doldurulmalıdır.

(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

Ölçek

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 bayt

Devrik işlevi olmayan bir özyinelemeli çözüm (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

ders için c, güç için p, hız için v, yükseklik için 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

kullanım

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

Pyth, 35 bayt

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

açıklama

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

@ Manatwork'ın cevabı uyarlandı

JavaScript, 266 263 244 bayt

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

kullanım

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 Bayt

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

• Rotayı düzleştirin, çünkü y koordinatı önemli değil, maalesef Java'da dikey bir düzeltme yok. Aynı zamanda bir String-transpose'a sahip değildir.

• Düzleştirilmiş rota üzerinde yineleyin ve topun hızını takip edin.

Octave, 111 110 bayt

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

Açıklama:

• Girdiyi yeni satırlara böl ve bu sinir bozucu hücre dizisini bir matrise dönüştür
• maxHer sütunu bulmak için matrisi düzleştirin
• Karakterleri Harita '_/\'için [1, 5, -4](diğer tüm karakterler az '_'eşlenir 0)
• Eşlenen dizinin tüm öğelerinin kümülatif toplamını hesaplayın
• Çıktı Truefincan elbette başından itibaren tüm toplu toplamları başlangıç hızı (daha az ise Falsebaşka bir şekilde).

@ Erwan tarafından önerilen ikincisine benzer sonuçlar geliştirdiğim bir test durumu ve birkaç sonuç:

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

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

Ve işte ilk test durumu:

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

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

C, 629 Bayt

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

Temelde giriş dizesini her şeye tek bir satırda uyacak şekilde dönüştürmek için sadece bir geçiş yapıyorum.

Python, 212 201 188 143 bayt

Bu senaryonun bu yinelemesinin kredisinin büyük bir kısmı @Erwan'a gidiyor, bu da bana denemek için tamamen farklı bir yaklaşım ve sonunda beni 55 byte kazandıran bazı ipuçları verdi.

Özyinelemeli değil, bu yüzden diğer piton çözeltisinden büyük ölçüde farklı olmalıdır.

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 biraz:

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]