Code (Mini) Golf


50

Bestimmen Sie anhand der Seitenansicht eines Minigolfplatzes und der Schlagkraft, ob der Ball es in das Loch schafft.


Ein Kurs wird in diesem Format sein:

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

Der Ball beginnt direkt vor dem ersten Stück Boden links und folgt der Kontur des Platzes, bis er das Loch erreicht (ein Großbuchstabe Uunterhalb des aktuellen Bodenniveaus). Wenn es das Loch erreicht, geben Sie einen Wahrheitswert aus. Die Kraft des Schwungs ist die Anfangsgeschwindigkeit des Balls. Der Ball bewegt sich bei jeder Iteration zum nächsten Zeichen rechts, dann ändert sich die Geschwindigkeit in Abhängigkeit von dem Zeichen, auf dem er sich gerade befindet. Wenn die Geschwindigkeit 0vor dem Loch erreicht oder darunter liegt, geben Sie einen Falsey-Wert aus.

  • _ verringert die Geschwindigkeit um 1
  • / verringert die Geschwindigkeit um 5
  • \ erhöht die Geschwindigkeit um 4

Kurse können optional mit Leerzeichen aufgefüllt werden. Die Kraft des Swings wird immer eine positive ganze Zahl sein.

Sie brauchen sich keine Sorgen zu machen, dass der Ball zu schnell ins Loch geht, rückwärts rollt oder von Hügeln springt / hüpft.

Testfälle

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

Dies ist Code-Minigolf, die kürzeste Antwort in Bytes gewinnt!


1
Wenn in Ihrer Sprache ein gutes Array integriert ist, können Sie die Eingabe \_/mit den folgenden Schritten in einen Stream von Operationen ( ) umwandeln: In ein Array von Zeilen aufteilen, drehen, reduzieren, Leerzeichen entfernen.
Cyoce

1
Das ist wirklich eher ein Mechanismus mit fester Spur als ein Golfplatz: P
Zach Gates,

24
Ich mag das \/\/\/\/\/ist ein effizienter Kurs als __________.
Esrast

2
Das habe ich mir gedacht, 4 runter, 5 rauf, dann muss 0,5 durchschnittlich sein. Oh, Wohnung ist 1?
Leif Willerts

Wird jede Zeile in einem Kurs immer die gleiche Länge haben (mit Leerzeichen am Ende kürzerer Zeilen)?
SnoringFrog

Antworten:


17

Pyth, 27 Bytes

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

Demonstration

Dieser Code macht etwas sehr Cleveres und überhaupt nicht typsicheres mit X. Schau es dir unten an.

Erläuterung:

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

Ich vermisse vielleicht etwas, aber hört es damit auf Q? Dh das letzte Beispiel könnte einige Probleme verursachen?
Flindeberg

@flindeberg So funktioniert das nicht. Das < ... Qfunktioniert als numerischer Vergleich bis zum Loch, nicht als Scheibe. Nach dem Loch kommt es nur darauf an, dass das Ergebnis wahr ist.
isaacg

14

Haskell, 111 109 Bytes

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

Anwendungsbeispiel:

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

Wie es funktioniert:

                            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                                 

Edit: @ user81655 2 Bytes zum Speichern gefunden. Vielen Dank!


7

Ruby, 104 87 Zeichen

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

Probelauf:

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 

6

Japt, 38 Bytes

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

Try it here!

CJam schlagen!

Erläuterung

Nimmt im Grunde genommen die Zeichenketteneingabe, dreht sie um 90 Grad im Uhrzeigersinn, entfernt Leerzeichen und Zeilenumbrüche, entfernt das Loch und alles danach und teilt sich entlang der Zeichen. Überprüft dann mithilfe der everyFunktion , ob der Ball jemals auf Null oder darunter fällt .


Ich denke, `` sollte positiv sein (Beschreibung sieht falsch aus)
isaacg

Ich denke nicht, dass das funktioniert. Stellen Sie sich Folgendes vor: Bei einer Reihe von Steigungen wird die Geschwindigkeit des Balls auf -2 erhöht, aber später gibt es ein Netto +4. Die Summe würde +2 widerspiegeln, also hat der Ball es geschafft. In Wirklichkeit würde es nach Erreichen des Negativs niemals zum positiven Bereich gelangen.
Cyoce

Ich glaube, ich habe das Problem behoben.
Mama Fun Roll

Das ist ein cooler Knopf;)
J Atkin

Nett! Also, Golf spielen ... Der doppelte Backslash ist austauschbar mit %und >0kann ersetzt werden ¬, da die sqrt einer nicht-positive Zahl immer falsy ist ( 0 -> 0, -1 -> NaN).
ETHproductions

6

CJam, 40 39 Bytes

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

Der Eingang hat die Leistung in der ersten Zeile und der Kurs beginnt in der zweiten Zeile. Ausgang ist 0oder 1.

Teste es hier.

Erläuterung

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.

5

Retina, 82 81 77 74 68 67 68 Bytes

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

^>*U

Probieren Sie es online aus

  • Die Eingabe wird in einer unären Basis dargestellt , wie ns >- zum Beispiel 4 ist >>>>\n. (Ist das legal?)
  • +`(?<=(.)*) (?=.*¶(?<-1>.)*(.)) $2 - Kurs abflachen - Leerzeichen durch das Zeichen darunter ersetzen.

    Nach dieser Phase sehen die Daten folgendermaßen aus:

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

    Wir können einfach alles nach dem ersten ignorieren U, wir werden es sowieso nicht erreichen.

  • > stellen einen Schritt dar, den wir machen dürfen, oder die verbleibende Energie.
  • Ersetze jedes \durch vier >- eine Steigung gibt uns zusätzliche Energie.
  • Schleife: Umstritten entfernen >_oder >>>>>/bis keine mehr vorhanden sind. _s und /s verbrauchen Energie.
  • Versuchen Sie schließlich, eine Übereinstimmung zu ^>*Uerzielen - prüfen Sie, ob wir Umit positiver Energie (oder ohne Energie) erreichen können.
    Dies gibt 0oder aus 1.

Eine weitere Option zum Schließen mit 91 bis 79 Bytes ist:

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

Probieren Sie es online aus

Dies ist der gleiche Ansatz, jedoch mit einer Bilanzgruppe anstelle eines umstrittenen Ersatzes.

Ich bin sicher, dass beide weiter Golf spielen können, so dass jeder von ihnen möglicherweise kürzer wird.


1
Ja, unäre Eingaben sind legitim (es sei denn, die Abfrage gibt "dezimal" an), obwohl ich wahrscheinlich 0oder 1als Ziffer verwenden würde, wenn keine zusätzlichen Bytes anfallen.
Martin Ender

1
Willkommen auch bei PPCG, ich freue mich sehr, Sie hier zu sehen! :) (Und mit Retina auch.)
Martin Ender

Sicher! Es stand auf der heißen Fragenliste und sah lustig aus. Ich dachte, ich würde es versuchen :-)
Kobi

3

ES6, 117 Bytes

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

Bearbeiten: 4 Bytes dank ՊՓԼՃՐՊՃՈԲՍԼ gespeichert.


@ ՊՓԼՃՐՊՃՈԲՍԼ Danke, ich versuche immer wieder, die Geschwindigkeit zu optimieren ...
Neil

3

JavaScript (ES6), 108 107 106 Bytes

Dies ist die Lösung, die ich gefunden habe, als ich die Herausforderung erstellt habe.

(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

Erläuterung

Nimmt die Kraft als Zahl und den Kurs als Zeichenfolge. Rückgabe 1für trueoder 0für false. Die Strecke muss mit Leerzeichen aufgefüllt sein.

(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

Prüfung

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

Python (3.5) 169 160 Bytes

Eine rekursive Lösung ohne Transponierfunktion (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 für Kurs, p für Leistung, v für Geschwindigkeit, h für Höhe

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

Verwendungszweck

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

2

Pyth, 35 Bytes

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

Erläuterung

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

1

Ruby, 85 Zeichen

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

Angepasste @ manatworks Antwort


1

JavaScript, 266 263 244 Bytes

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

Verwendungszweck

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

Mein Fehler; Ich dachte, ich hätte im ersten Beispiel mit "27" als erstes Argument kopiert. Ich habe das korrigiert. Danke.
user49328

1

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;}
  • Den Kurs abflachen, da die y-Koordinate keine Rolle spielt, hat Java leider keine vertikale Trimmung. Es hat auch keine String-Transponierung.

  • Iterieren Sie über den abgeflachten Kurs und verfolgen Sie die Ballgeschwindigkeit.


1

Oktave, 111 110 Bytes

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

Erläuterung:

  • Teilen Sie die Eingabe in Zeilenumbrüche und konvertieren Sie das lästige Zellenarray in eine Matrix
  • Glätten Sie die Matrix, indem Sie maxfür jede Spalte die finden
  • Ordnen Sie die Zeichen '_/\'zu [1, 5, -4](alle anderen Zeichen, denen weniger als zugeordnet '_'sind 0)
  • Berechnen Sie die kumulative Summe aller Elemente des zugeordneten Arrays
  • TrueWird ausgegeben, wenn alle kumulierten Summen vom Beginn des Kurses bis zum Cup kleiner als die Startgeschwindigkeit sind ( Falseansonsten).

Hier ist ein Testfall, den ich bereits ähnlich wie den zweiten von @Erwan vorgeschlagenen entwickelt habe, und ein paar Ergebnisse:

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

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

Und hier ist der erste Testfall:

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

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

Ich denke, wenn der Kurs so ist, dass "//_U\\\\\\\_das Ergebnis falsch ist, da Sie nicht nach Udenselben Dingen Zeichen entfernen, wenn Sie einen Kurs mit lokalem Maximum wie_//\\\\\U
Erwan

@Erwan Aber ich kann die Zeichen nach dem entfernen U. Das ist, was der (1:find(m==85))macht; Es dauert Subarray vom ersten Index zum Speicherort der U. Ich überprüfe Ihren Testfall mit ein paar Startgeschwindigkeiten und melde mich bei Ihnen.
Becher

Ich konnte deine Lösung nicht ausführen (ich habe keine Oktave), deswegen frage ich nur ... und weil ich das Issu mit lokalen Maxima in der anderen Python-Lösung finde :) Schließlich funktioniert deine Lösung mit lokalen Maxima, da du Cumsum verwendest und nicht nur die Summe (sehen Sie das nicht beim ersten Lesen)
Erwan

@ Erwan Ich habe die beiden von Ihnen vorgeschlagenen Testfälle hinzugefügt. Bitte schauen Sie nach, ob die Ergebnisse Ihren Erwartungen entsprechen. Wenn Sie dies in MATLAB versuchen, können Sie es nicht ausführen, da es eine Indizierung verwendet, die nur in Octave funktioniert. Sie müssten das Ergebnis von cumsumeiner Zwischenvariablen zuweisen und diese dann für den endgültigen Vergleich verwenden all(v>tmp(1:find(m==85))).
Becher

Ihre Lösung funktioniert gut, viele Dinge beim ersten Lesen verpassen (einfach in Matlab so viele Zwischenvariablen zum Hinzufügen testen)
Erwan

0

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

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

Im Grunde genommen mache ich nur einen Durchgang, um die Eingabezeichenfolge so zu konvertieren, dass alles in eine Zeile passt


Willkommen bei Programming Puzzles & Code Golf! Sie können (und sollten) in der Lage sein, die Größe erheblich zu reduzieren, indem Sie die meisten Leerzeichen entfernen. Sie können einige Ihrer if/ elsezB reduzieren x+=*n==' ')?1:*n=='\n'?-x:(olc[x]=*n,1. Ein weiterer Tipp: In C unsigned intkann geschrieben werden unsigned, wodurch sofort 4 Bytes gespart werden.
Toby Speight

0

Python, 212 201 188 143 Bytes

Ein Großteil des Verdienstes für diese Iteration dieses Skripts geht an @Erwan, der mir einen völlig anderen Ansatz und einige Tipps gegeben hat, mit denen ich am Ende 55 Bytes gespart habe.

Nicht rekursiv, sollte sich also wesentlich von der anderen Python-Lösung unterscheiden.

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]

Ein bisschen 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]

Wenn Sie eine kürzere Lösung wünschen, können Sie Cyoce tip und die integrierte Transponierungsfunktion verwenden. so etwas o=[''.join(x).split()[0] for x in zip(*c.split('\n'))]gewinnt meiner meinung nach 40 bytes
erwan

Sie können auch ersetzen breakdurch return p>0und entfernenif p...
Erwan

Sie müssen eine Bedingung hinzufügen, if"U"==v or p<1 wenn es ein lokales Maximum gibt wie_//\\\\\U
Erwan

@Erwan Ihr erster Tipp funktioniert nicht, wenn die Zeilen nicht alle gleich lang sind (kurze Zeilen mit nachgestellten Leerzeichen für lange). Da in dem Post "Kurse können optional mit Leerzeichen aufgefüllt werden" steht, bin ich mir nicht sicher, ob das stimmt. Ich habe darüber in einem Kommentar gefragt.
SnoringFrog

ja ich nehme an all Zeilen die gleiche Länge haben (egalisierte mit weißen Raum) vielleicht ich in diesem Fall falsch bin ich denke , dass meine Lösung ist schlecht
Erwan
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.