Kod (Mini) Golf

50

Biorąc pod uwagę widok z boku pola do minigolfa i siłę uderzenia, określ, czy piłka trafi do dołka.


Kurs będzie w tym formacie:

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

Piłka zaczyna się bezpośrednio przed pierwszym kawałkiem ziemi po lewej stronie i podąża za konturem pola aż do otworu (wielka litera Uponiżej aktualnego poziomu podłoża). Jeśli dojdzie do dziury, wypisz prawdziwą wartość. Mocą uderzenia będzie początkowa prędkość piłki. Podczas każdej iteracji piłka przesuwa się do następnej postaci po prawej, a następnie zmienia się prędkość w zależności od postaci, w której się znajduje. Jeśli prędkość osiągnie 0lub mniej przed dołkiem, wypisz wartość falsey.

  • _ zmniejsza prędkość o 1
  • / zmniejsza prędkość o 5
  • \ zwiększa prędkość o 4

Kursy mogą być opcjonalnie wypełnione spacjami. Moc huśtawki zawsze będzie dodatnią liczbą całkowitą.

Nie musisz się martwić, że piłka będzie zbyt szybka, aby wejść do dołka, przetoczyć się do tyłu lub skoczyć / odbić się od wzgórz.

Przypadki testowe

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

To jest kod do minigolfa, wygrywa najkrótsza odpowiedź w bajtach!

użytkownik 81655
źródło
1
Jeśli twój język ma dobre wbudowane tablice, możesz przekształcić dane wejściowe w strumień operacji ( \_/), wykonując następujące kroki: podziel na tablicę linii, obracaj, spłaszczaj, rozstawiaj spacje.
Cyoce,
1
To naprawdę bardziej mechanizm o stałym torze niż pole golfowe: P
Zach Gates
24
Podoba mi się, że \/\/\/\/\/jest to bardziej wydajny kurs niż __________.
ezrast
2
Tak myślałem, 4 w dół, 5 w górę, a następnie .5 musi być średnia. Och, mieszkanie to 1?
Leif Willerts 21.01.16
Czy każda linia w kursie będzie zawsze tej samej długości (z końcowymi spacjami wypełniającymi koniec krótszych linii)?
SnoringFrog,

Odpowiedzi:

17

Pyth, 27 bajtów

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

Demonstracja

Ten kod robi coś bardzo sprytnego i wcale nie jest bezpieczny dla typu X. Sprawdź to poniżej.

Wyjaśnienie:

.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.
isaacg
źródło
Mogę coś przeoczyć, ale czy to się kończy Q? Czyli ostatni przykład może powodować problemy?
flindeberg,
@flindeberg Nie tak to działa. Te < ... Qprace jako liczbowego porównania aż do otworu, a nie plaster. Po dołku liczy się tylko to, że wynik jest prawdziwy.
isaacg
14

Haskell, 111 109 bajtów

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

Przykład użycia:

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

Jak to działa:

                            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                                 

Edycja: @ user81655 znalazł 2 bajty do zapisania. Dzięki!

nimi
źródło
7

Ruby, 104 87 znaków

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

Przykładowy przebieg:

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 
człowiek w pracy
źródło
6

Japt, 38 bajtów

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

Try it here!

Pokonując CJam!

Wyjaśnienie

Zasadniczo pobiera ciąg znaków, obraca go o 90 stopni zgodnie z ruchem wskazówek zegara, usuwa spacje i znaki nowej linii, usuwa dziurę i wszystko po niej oraz dzieli wzdłuż znaków. Następnie sprawdza, czy piłka kiedykolwiek osiągnie zero lub mniej, używając everyfunkcji.

Mama Fun Roll
źródło
Myślę, że `` powinno być pozytywne (opis wygląda źle)
isaacg
Nie sądzę, żeby to działało. Wyobraź to sobie: seria stoków zwiększa prędkość piłki do -2, ale potem jest siatka +4 później. Suma odzwierciedla +2, więc piłka się udało. W rzeczywistości nigdy nie przejdzie do pozytywnej części po osiągnięciu negatywów.
Cyoce,
Myślę, że naprawiłem problem.
Mama Fun Roll
To fajny przycisk;)
J Atkin
Miły! Gra w golfa ... Podwójny ukośnik odwrotny można zastąpić %i >0można go zastąpić ¬, ponieważ sqrt liczby dodatniej jest zawsze fałszem ( 0 -> 0, -1 -> NaN).
ETHproductions
6

CJam, 40 39 bajtów

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

Wejście ma moc na pierwszej linii, a kurs zaczyna się na drugiej linii. Dane wyjściowe to 0lub 1.

Sprawdź to tutaj.

Wyjaśnienie

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.
Martin Ender
źródło
5

Retina, 82 81 77 74 68 67 68 bajtów

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

^>*U

Wypróbuj online

  • Dane wejściowe są reprezentowane w jednostkowej bazie , jak n >s - na przykład 4 to >>>>\n. (czy to legalne?)
  • +`(?<=(.)*) (?=.*¶(?<-1>.)*(.)) $2 - spłaszcz kurs - zastąp spacje postacią pod nimi.

    Po tym etapie dane będą wyglądać następująco:

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

    Możemy po prostu zignorować wszystko po pierwszym U, i tak tam nie dotrzemy.

  • > reprezentują krok, który możemy zrobić, lub pozostałą energię.
  • Zastąp każdy \z nich czterema >- nachylenie daje nam dodatkową energię.
  • Pętla: kontrowersyjnie usuń >_lub >>>>>/dopóki nie pozostanie żadna. _y i /y zużywa energię.
  • Na koniec spróbuj dopasować ^>*U- sprawdź, czy możemy osiągnąć Upozytywną energię (lub brak energii).
    Spowoduje to wygenerowanie 0lub 1.

Inną zamkniętą opcją z 91 79 bajtami jest:

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

Wypróbuj online

Jest to to samo podejście, ale z grupą równoważącą zamiast kontrowersyjnej wymiany.

Jestem pewien, że oba można dalej grać w golfa, więc każdy z nich może być krótszy.

Kobi
źródło
1
Tak, jednoargumentowe wejście jest poprawne (chyba że wyzwanie określa „dziesiętny”), chociaż prawdopodobnie użyłbym 0lub 1jako cyfry, jeśli nie spowoduje to dodatkowych bajtów.
Martin Ender
1
Witamy również w PPCG, cieszę się, że cię tu widzę! :) (I także używając Retiny.)
Martin Ender
Pewnie! To było na liście gorących pytań i wyglądało zabawnie. Myślałem, że spróbuję :-)
Kobi
3

ES6, 117 bajtów

(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

Nie golfowany:

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

Edycja: Zapisano 4 bajty dzięki ՊՓԼՃՐՊՃՈԲՍԼ.

Neil
źródło
@ ՊՓԼՃՐՊՃՈԲՍԼ Dzięki, staram się optymalizować prędkość ...
Neil
3

JavaScript (ES6), 108 107 106 bajtów

Oto rozwiązanie, które wymyśliłem, tworząc wyzwanie.

(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

Wyjaśnienie

Traktuje moc jako liczbę, a przebieg jako ciąg. Zwraca 1za truelub 0za false. Tor musi być wypełniony spacjami.

(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

Test

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>

użytkownik 81655
źródło
3

Python (3.5) 169 160 bajtów

Rozwiązanie rekurencyjne bez funkcji transpozycji (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

Bez golfa

c dla kursu, p dla mocy, v dla prędkości, h dla wysokości

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

Stosowanie

f(16,"_/\                                         _\n   \      __       /\/\/\                  / \n    \    /  \     /      \                /  \n     \__/    \   /        \____________ _/   \n              \_/                      U     ")
f(9,"/\/\/\/\/U")
Erwan
źródło
2

Pyth, 35 bajtów

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

Wyjaśnienie

                                    - 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 ()
niebieski
źródło
1

Ruby, 85 znaków

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

Dostosowano odpowiedź @ manatwork

Connor Clark
źródło
1

JavaScript, 266 263 244 bajtów

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

Bez golfa

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

Stosowanie

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
użytkownik49328
źródło
Mój błąd; Myślałem, że skopiowałem w pierwszym przykładzie z „27” jako pierwszym argumentem. Poprawiłem to. Dziękuję Ci.
user49328,
1

Java, 219 bajtów

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;}
  • Spłaszcz kurs, ponieważ współrzędna y nie ma znaczenia, niestety Java nie ma pionowego wykończenia. Nie ma też transpozycji ciągów.

  • Iteruj nad spłaszczonym kursem i śledź prędkość piłki.

ECS
źródło
1

Oktawa, 111 110 bajtów

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

Wyjaśnienie:

  • Podziel dane wejściowe na nowe linie i przekonwertuj tę irytującą macierz komórek na macierz
  • Spłaszcz macierz, znajdując maxdla każdej kolumny
  • Zamapuj znaki '_/\'na [1, 5, -4](wszystkie inne znaki mniejsze niż '_'są zamapowane 0)
  • Oblicz skumulowaną sumę wszystkich elementów odwzorowanej tablicy
  • Wyjście, Truejeśli wszystkie sumy sumaryczne od początku kursu do kubka są mniejsze niż prędkość początkowa (w Falseprzeciwnym razie).

Oto przypadek testowy, który już opracowałem, podobny do drugiego zaproponowanego przez @Erwan i kilka wyników:

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

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

A oto pierwszy przypadek testowy:

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

>> g(11,s10)
ans = 0
>> g(12,s10)
ans =  1
zlewka
źródło
Myślę, że jeśli kurs jest jak "//_U\\\\\\\_wynik jest nieprawidłowy, ponieważ nie usunąć znak po Usame rzeczy, jeśli masz kurs z lokalnym maksimum podobnego_//\\\\\U
Erwan
@Erwan Ale należy usunąć znaki po U. To właśnie (1:find(m==85))robi; pobiera podrzędną tablicę z pierwszego indeksu do lokalizacji U. Sprawdzę twój test z kilkoma początkowymi prędkościami i skontaktuję się z tobą.
zlewka
Nie mogłem uruchomić twojego rozwiązania (nie mam Octave), dlatego po prostu pytam ... i ponieważ znajduję problem z lokalnymi maksimami w innym rozwiązaniu python :) w końcu twoje rozwiązanie działa z lokalnymi maksimami, ponieważ używasz sumumatu i nie tylko suma (nie widzę tego przy pierwszym czytaniu)
Erwan
@Erwan Dodałem dwa przypadki testowe, które zasugerowałeś. Proszę spojrzeć i zobaczyć, czy wyniki są zgodne z oczekiwaniami. Jeśli próbujesz tego w MATLAB, to nie będziesz w stanie go uruchomić, ponieważ wykorzystuje pewne indeksowanie, które działa tylko w Octave. Będziesz musiał przypisać wynik cumsumzmiennej pośredniej, a następnie użyć jej do ostatecznego porównania all(v>tmp(1:find(m==85))).
zlewka
Twoje rozwiązanie działa dobrze, brakuje wielu rzeczy przy pierwszym czytaniu (wystarczy przetestować w Matlabie tak wiele zmiennych pośrednich do dodania)
Erwan
0

C, 629 bajtów

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

Nie golfowany:

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

Zasadniczo wykonuję tylko jedno przejście, aby przekonwertować ciąg wejściowy, aby pasował do wszystkiego w jednym wierszu

samt1903
źródło
Witamy w Programowaniu Puzzle i Code Golf! Możesz (i powinieneś) być w stanie znacznie zmniejszyć rozmiar, eliminując większość białych znaków; możesz zmniejszyć część swojego if/ elsenp x+=*n==' ')?1:*n=='\n'?-x:(olc[x]=*n,1. Kolejna wskazówka: w C unsigned intmożna zapisać unsigned, oszczędzając od razu 4 bajty.
Toby Speight
0

Python, 212 201 188 143 bajtów

Duża część tej iteracji tego skryptu przypada @Erwan, który dał mi zupełnie inne podejście do próby i kilka wskazówek, które w końcu pozwoliły mi zaoszczędzić 55 bajtów.

Nie rekurencyjne, więc powinno znacznie różnić się od innych rozwiązań python.

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 trochę:

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]
SnoringFrog
źródło
jeśli potrzebujesz krótszego rozwiązania, możesz użyć końcówki Cyoce i skorzystać z wbudowanej funkcji transpozycji. coś takiego, o=[''.join(x).split()[0] for x in zip(*c.split('\n'))]że wygrywają 40 bajtów, myślę
Erwan
można również zastąpić breakprzez return p>0i usunąćif p...
Erwan
musisz dodać warunek, if"U"==v or p<1 jeśli istnieje lokalne maksimum, takie jak_//\\\\\U
Erwan
@Erwan Twoja pierwsza wskazówka nie działa, jeśli linie nie są tej samej długości (krótkie linie mają końcowe spacje, aby dopasować długie). Ponieważ w poście było napisane: „Kursy można opcjonalnie uzupełnić spacjami”, nie jestem pewien, czy możemy założyć, że to prawda. Zapytałem o to w komentarzu.
SnoringFrog,
tak, zakładam, że wszystkie linie mają tę samą długość (ujednolicone białą spacją) może się mylę w tym przypadku myślę, że moje rozwiązanie jest złe
Erwan