Biorąc pod uwagę drogę ascii-art i czas, jaki musiałem, aby ją przekroczyć, powiedz mi, czy pędzę.

Jednostki

Odległość jest w dowolnej jednostce d. Czas jest w dowolnej jednostce t.

Droga

Oto prosta droga:

10=====

Te 10środki 10 dza t. To jest ograniczenie prędkości na drodze. Droga ma 5 =s, więc djest 5. Dlatego jeśli przejdę tę drogę w 0,5 t, przeszedłem 10 dna t, ponieważ 5 / 0,5 = 10. Ograniczenie prędkości na tej drodze wynosi 10, więc pozostałem w granicach prędkości.

Ale jeśli przejdę tę drogę w 0,25 t , poszedłem 20 dna t, ponieważ 5 / 0,25 = 20. Ograniczenie prędkości na tej drodze wynosi 10, więc przekroczyłem 10.

Przykłady i obliczenia

Zauważ, że wejście 1 to czas, który potrzebowałem na podróż drogą, a wejście 2 to sama droga.

Oto złożona droga:

Input 1: 1.5
Input 2: 5=====10=====

Najszybszy, jaki mogłem (legalnie) pojechać na pierwszej drodze (pierwsze 5 =s) to 5 dna t. Ponieważ 5 (odległość) podzielona przez 5 (ograniczenie prędkości) wynosi 1, najszybszy, jaki mogłem pojechać na tej drodze, to 1 t.

Na następnej drodze ograniczenie prędkości wynosi 10, a odległość wynosi również 5, najszybszy, jaki udało mi się przekroczyć, czyli 0,5 (5/10). Sumowanie minimalnych czasów daje wynik 1,5, co oznacza, że ​​poszedłem dokładnie do ograniczenia prędkości.

Uwaga: Wiem, mogłem jechać naprawdę szybko na jednej drodze, naprawdę wolno na innej i nadal przekraczać 1,5, ale zakładam, że tutaj jest najlepiej.

Ostatni przykład:

Input 1: 3.2
Input 2: 3.0==========20===

Pierwsza droga ma 10 długości i ma ograniczenie prędkości 3, więc minimalny czas to 3,33333 ... (10/3)

Druga droga ma 3 długości i ma ograniczenie prędkości do 20, więc minimalny czas to 0,15 (3/20).

Sumując czasy, otrzymałem 3,483333333 ... Przekroczyłem go w 3.2, więc musiałem gdzieś pędzić.

Uwagi:

• Musisz podać jedną wyraźną wartość, jeśli bez wątpienia pędzę, i inną inną wartość, jeśli tak nie jest.
• Twój program lub funkcja może wymagać wejścia lub wyjścia, aby mieć znak nowej linii, ale powiedz to w swoim zgłoszeniu.
• Twoim pierwszym wejściem będzie moja prędkość. Będzie to dodatnia liczba zmiennoprzecinkowa, liczba całkowita lub ciąg.
• Drugim wkładem będzie droga. Zawsze będzie pasować do wyrażenia regularnego ^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$. Jeśli jesteś zainteresowany, możesz przetestować potencjalne dane wejściowe tutaj.
• Możesz pobrać dane wejściowe w 2 parametrach funkcji lub programu, w 2 osobnych plikach, ze STDIN dwukrotnie lub z ciągu rozdzielanego spacjami przekazywanego do STDIN, funkcji, pliku lub parametru wiersza polecenia.
• Jeśli chcesz, możesz zmienić kolejność wejść.
• Jakieś pytania? Zapytaj poniżej w komentarzach i życzymy udanego golfa !

05AB1E , 24 22 bajtów

Zwraca 1, gdy niewątpliwie przyspiesza, a 0 w przeciwnym razie.

Zaoszczędzono 2 bajty dzięki carusocomputing .

'=¡õK¹S'=Q.¡O0K/O-§'-å

Wypróbuj online!

-§'-ånie powinno być niczym więcej niż prostym porównaniem, ale z jakiegoś powodu ani ›nie ‹wydaje się, aby działało między wartością obliczoną a drugim wejściem.

Wyjaśnienie

Używając 3.0==========20===, 3.2jako przykład

'=¡                        # split first input on "="
   õK                      # remove empty strings
                           # STACK: ['3.0', '20']
     ¹S                    # split first input into a list of chars
       '=Q                 # compare each to "="
          .¡O              # split into chunks of consecutive equal elements and sum
                           # STACK: ['3.0', '20'], [0, 10, 0, 3]
             0K            # remove zeroes
                           # STACK: ['3.0', '20'], [10, 3]
               /           # element-wise division
                           # STACK: [3.3333333333333335, 0.15]
                O          # sum
                           # STACK: 3.4833333333333334
                 -         # subtract from second input
                           # STACK: -0.2833333333333332
                  §        # implicitly convert to string
                   '-å     # check if negative
                           # OUTPUT: 1

Python 2 , 71 bajtów

m,s=input()
for c in s.split('=')[:-1]:s=float(c or s);m-=1/s
print m<0

Wypróbuj online!

Dynamiczny system typów Pythona może znieść pewne nadużycia.

Rozdzielenie ciągu wejściowego s.split('=')zamienia kznaki równości w k-1elementy listy pustych ciągów (z wyjątkiem końca, na którym należy odciąć). Na przykład,

"3.0===20====".split('=')[:-1] == ['3.0', '', '', '20', '', '', '']

Kod iteruje te elementy, aktualizując bieżącą prędkość za skażdym razem, gdy widzi liczbę. Aktualizacja jest wykonywana w taki sposób s=float(c or s), że jeśli cciąg jest niepusty, otrzymujemy float(c)i w inny sposób c or soceniamy s, gdzie float(s)po prostu zachowuje s. Zauważ, że cjest to ciąg znaków i sliczba, ale Python nie wymaga, nie wymaga spójnych typów danych wejściowych i floatakceptuje oba.

Zauważ też, że zmienna sprzechowująca prędkość jest taka sama jak pobieranie ciągu wejściowego. Łańcuch jest oceniany na początku pętli, a zmiana go w pętli nie zmienia tego, co jest iterowane. Tak więc ta sama zmienna może zostać ponownie użyta do zapisania podczas inicjalizacji. Pierwsza pętla ma zawsze cliczbę, więc s=float(c or s)nie przejmuje się spoczątkową rolą łańcucha.

Każda iteracja odejmuje bieżącą prędkość od limitu, który zaczyna się jako ograniczenie prędkości. Na koniec ograniczenie prędkości zostało naruszone, jeśli spadnie poniżej 0.

Python 3 , 79 bajtów

import re;g=re.sub
lambda m,s:eval(g('=','-~',g('([^=]+)',r'0+1/\1*',s))+'0')>m

Wypróbuj online!

Na przykład dane wejściowe 3.0==========20===są konwertowane na ciąg

0+1/3.0*-~-~-~-~-~-~-~-~-~-~0+1/20*-~-~-~0 

i oceniane, a wynik jest porównywany z prędkością wejściową. Każdy -~przyrost o 1. Jestem nowy w wyrażeniach regularnych, więc być może istnieje lepszy sposób, na przykład dokonanie obu podstawień naraz. Podziękowania dla Jonathana Allana za wskazanie, jak dopasować wszystko oprócz =postaci.

JavaScript (ES6), 63 bajty

a=>b=>eval(b.replace(/([^=]+)(=+)/g,(_,c,d)=>'+'+d.length/c))>a

Stosowanie

Przypisz tę funkcję do zmiennej i wywołaj ją przy użyciu składni curry. Pierwszy argument to czas, drugi to droga.

Wyjaśnienie

Pasuje do wszystkich kolejnych serii znaków, które nie są znakami równości, po których następuje seria znaków równości. Każde dopasowanie jest zastępowane wynikiem funkcji wewnętrznej, która wykorzystuje dwa argumenty: ciąg znaków równości (w zmiennej d) i liczbę (zmienną c). Funkcja zwraca długość drogi podzieloną przez liczbę, poprzedzoną znakiem +.

Powstały ciąg jest następnie oceniany i porównywany z pierwszym wejściem.

Fragment kodu

let f=
a=>b=>eval(b.replace(/([^=]+)(=+)/g,(_,c,d)=>'+'+d.length/c))>a

<input id="time" placeholder="time" type="number">
<input id="road" placeholder="road">
<button onclick="output.innerHTML=f(time.value)(road.value)">Process</button>
<div id="output"></div>

GNU C, 128 bajtów

#import<stdlib.h>
f(float t,char*r){float l,s=0;for(;*r;){for(l=atof(r);*(++r)-61;);for(;*r++==61;)s+=1/l;--r;}return t<s-.001;}

Obsługuje również ograniczenia prędkości niecałkowite. #import<stdlib.h>jest potrzebne, aby kompilator nie założył, że atof()zwraca an int.

t<s-.001jest potrzebny do uruchomienia dokładnego przypadku testowego ograniczenia prędkości, w przeciwnym razie błędy zaokrąglania powodują, że myślisz, że przekraczasz prędkość. Oczywiście, jeśli teraz jest czas1.4999 zamiast 1.5, nie bierze pod uwagę tego przyspieszenia. Mam nadzieję, że to w porządku.

Wypróbuj online!

Perl 5 , 43 bajtów

42 bajty kodu + -pflaga.

s%[^=]+(=+)%$t+=(length$1)/$&%ge;$_=$t<=<>

Wypróbuj online!

Dla każdej grupy cyfr, po której następuje kilka znaków równości ( [^=]+(=+)), obliczamy, ile czasu potrzeba na jej przekroczenie (liczba równych wartości podzielona przez prędkość (length$1)/$&:) i sumujemy te czasy w środku $t. Na koniec musimy tylko sprawdzić, czy $tjest to mniej niż czas potrzebny na jego przekroczenie ( $_=$t < <>). Wynik będzie 1(prawda) lub brak (fałsz).

Mathematica, 98 bajtów

Tr[#2~StringSplit~"="//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}]-"
"<=#&

Czysta funkcja pobierająca dwa argumenty, liczbę (która może być liczbą całkowitą, ułamkową, dziesiętną, parzystą πlub liczbą w notacji naukowej) oraz ciąg zakończony znakiem nowej linii i zwracający Truelub False. Wyjaśnienie na przykładzie przy użyciu danych wejściowych 3.2i"3==========20===\n" :

#2~StringSplit~"="produkuje {"3","","","","","","","","","","20","","","\n"}. Zauważ, że liczba kolejnych ""s jest o jeden mniejsza niż liczba kolejnych= s w każdym przebiegu.

//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}to powtarzająca się zasada zastępowania. Najpierw ustawia go zdo pustego sekwencji, ado "3", bdo "","","","","","","","",""(najdłuższego biegu ""s mogło znaleźć), a cdo "20","","","\n"; polecenie (Length@{b}+1)/ToExpression@aocenia na (9+1)/3, więc wynikiem zamiany jest lista {10/3, "20","","","\n"}.

Następnie reguła zastępowania ustawia się zna 10/3, ana "20", bna "",""i cna "\n". Teraz (Length@{b}+1)/ToExpression@aocenia to (2+1)/20, a więc wynikiem zastąpienia jest{10/3, 3/20, "\n"} . Reguła wymiany nie może znaleźć innego dopasowania, więc się zatrzymuje.

Na koniec Tr[...]-"\n"(zapisuje bajt, aby zamiast rzeczywistej nowej linii między cudzysłowami wstawiać "\n"), dodaje elementy listy, uzyskując 10/3 + 3/20 + "\n", a następnie odejmuje to "\n", co Mathematica jest całkowicie szczęśliwy. Na koniec <=#porównuje wynik z pierwszym wejściem ( 3.2w tym przypadku), które daje False.

Galaretka , 27 bajtów

ṣ”=V€ḟ0
Œr”=e$ÐfṪ€ż⁸Ǥ÷/€S>

Wypróbuj online!

Uwaga: zakłada, że regex podane w pytaniu powinna być taka, że ograniczenie prędkości nie może być 0.0, 0.00itp - podobnie jak nie można 0( potwierdzone jako własność niezamierzonym).

W jaki sposób?

ṣ”=V€ḟ0 - Link 1, speed limits: road          e.g. "4.0===22=="
ṣ”=     - split by '='                             [['4','.','0'],[],[],['2','2'],[],[]]
   V€   - evaluate €ach as Jelly code              [4.0,0,0,22,0,0]
     ḟ0 - filter discard zero                      [4.0,22]

Œr”=e$ÐfṪ€ż⁸Ǥ÷/€S> - Main link: road, time   e.g. "4.0===22==", 0.84
Œr                  - run-length encode            [['4',1],['.',1],['0',1],['=',3],['2',2],['=',2]]
      Ðf            - filter keep:
     $              -     last two links as a monad:
  ”=                -         "="
    e               -         is an element of?    [['=',3],['=',2]]
        Ṫ€          - tail €ach                    [3,2]
             ¤      - nilad followed by link(s) as a nilad:
           ⁸        -     left argument (road)
            Ç       -     last link (1) as a monad [4.0,22]
          ż         - zip                          [[3,4.0],[2,22]]
              ÷/€   - reduce €ach by division      [0.75, 0.09090909090909091]
                 S  - sum                          0.8409090909090909
                  > - greater than time?           1 (would be 0 if maybe not speeding)

Python 3, 90 bajtów

import re
lambda t,r:sum(x.count("=")/eval(x.strip("="))for x in re.findall("\d+\D+",r))>t

Wyjścia True jeśli przekraczasz prędkość, Falsejeśli nie. Nie wymaga (ale będzie działał) końcowego znaku nowej linii.

Mimo że nie wygląda tak, to poprawnie obsługuje zmienne zarówno w zakresie czasu wejściowego, jak i ograniczeń prędkości, ponieważ wyrażenie regularne służy tylko do oddzielania odcinków drogi.

MATL , 31 30 bajtów

t61=TwFhhdfd1wY{1L&)o!oswcU!/s<

Dane wejściowe to: ciąg znaków (ograniczenia prędkości i drogi), a następnie liczba (używana prędkość). Wyjście jest, 1jeśli niewątpliwie przyspiesza, 0jeśli nie.

Wypróbuj online!

Objaśnienie z przykładem

Rozważ dane wejściowe '3.0==========20==='i 3.2.

1       % Push 1
        % STACK: 1
y       % Implicitly input string. Duplicate from below
        % STACK: '3.0==========20===', 1, '3.0==========20==='
61=     % Compare with 61 (ASCII for '=')
        % STACK: '3.0==========20===', 1, [0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1]
TwFhh   % Prepend true (1) and append false (0)
        % STACK: '3.0==========20===', 1, [1 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 0]
d       % Consecutive differences
        % STACK: '3.0==========20===', 1, [-1 0 0 1 0 0 0 0 0 0 0 0 0 -1 0 1 0 0 -1]
f       % Find: indices of nonzeros
        % STACK: '3.0==========20===', 1, [1  4 14 16 19]
d       % Consecutive differences. Gives length of substrings of numbers or roads
        % STACK: '3.0==========20===', 1, [3 10 2 3]
Y{      % Split string according to those lenghts. Gives a cell array of strings
        % STACK: {'3.0', '==========', '20', '==='}
1L&)    % Split into odd- and even-indexed subarrays
        % STACK: {'3.0', '20'}, {'==========', '==='}
o       % Convert to 2D numeric array. Right-pads with zeros
        % STACK: {'3.0', '20'}, [61 61 61 61 61 61 61 61 61 61; 61 61 61 0 0 0 0 0 0 0]
!gs     % Number of nonzeros in each row
        % STACK: {'3.0', '20'}, [10 3]
w       % Swap
        % STACK: [10 3], {'3.0', '20'}
c       % Convert to 2D char array. Right-pads with spaces
        % STACK: [10 3], ['3.0'; '20 ']
U       % Convert each row to a number
        % STACK: [10 3], [3.0; 20]
!       % Transpose
        % STACK: [10 3], [3.0 20]
/       % Divide, element-wise
        % STACK: [3.3333 0.15]
s       % Sum of array
        % STACK: 3.4833
<       % Implicitly input number. Less than? Implicitly display (true: 1; false: 0)
        % STACK: true

APL, 41 bajtów

{⍺<+/{(≢⍵)÷⍎⍺}/¨Y⊂⍨2|⍳⍴Y←⍵⊂⍨X≠¯1⌽X←⍵='='}

To traktuje drogę jako ciąg jako prawy argument, a czas jako lewy argument i zwraca, 1jeśli przekraczałeś prędkość, a 0jeśli nie, to tak:

      3.2{⍺<+/{(≢⍵)÷⍎⍺}/¨Y⊂⍨2|⍳⍴Y←⍵⊂⍨X≠¯1⌽X←⍵='='}'3.0==========20==='
1

Wyjaśnienie:

• X←⍵='=': przechowuj w Xwektorze bitowym wszystkich pozycji w⍵ które są częścią drogi.
• X≠¯1⌽X: zaznacz każdą pozycję, Xktóra nie jest równa prawemu sąsiadowi (owijając się), podając pozycje, od których zaczynają się liczby i drogi
• Y←⍵⊂⍨: podziel ⍵w tych pozycjach (podając tablicę na przemian liczb i ciągów znaków) i zapisz goY .
• Y⊂⍨2|⍳⍴Y: podzielić Y na kolejne pary.
• {(≢⍵)÷⍎⍺}/¨: dla każdej pary podziel długość części drogi ( ≢⍵) przez wynik oceny części liczbowej (⍎⍺ ). Daje to minimalny czas dla każdego segmentu.
• +/: Zsumuj czasy dla wszystkich segmentów, aby uzyskać całkowity minimalny czas.
• ⍺<: Sprawdź, czy podany czas jest krótszy niż minimum, czy nie.

TI-Basic, 168 165 bajtów

Prompt Str0,T
Str0+"0→Str0
0→I
1→A
While inString(Str0,"=",A
I+1→I
I→dim(L1
I→dim(L2
0→L
inString(Str0,"=",A→B
expr(sub(Str0,A,B–A→L1(I
While 1=expr("9"+sub(Str0,B,1)+"9
L+1→L
B+1→B
If B>length(Str0
Return
End
B→A
L→L2(I
End
T≥sum(seq(L2(X)/L1(X),X,1,I

Dane wejściowe to droga Str0i czas jako T. Pamiętaj, aby poprzedzić drogę cytatem, npStr0=?"14========3=== .

Wartość wyjściowa wynosi 0, jeśli przyspieszenie, 1, jeśli to możliwe, brak prędkości.

Prompt Str0,T                      # 6 bytes
Str0+"0→Str0                       # 9 bytes
0→I                                # 4 bytes
1→A                                # 4 bytes
While inString(Str0,"=",A          # 12 bytes
I+1→I                              # 6 bytes
I→dim(L1                           # 6 bytes
I→dim(L2                           # 6 bytes
0→L                                # 4 bytes
inString(Str0,"=",A→B              # 13 bytes
expr(sub(Str0,A,B–A→L1(I           # 16 bytes
While 1=expr("9"+sub(Str0,B,1)+"9  # 21 bytes
L+1→L                              # 6 bytes
B+1→B                              # 6 bytes
If B>length(Str0                   # 8 bytes
Return                             # 2 bytes
End                                # 2 bytes
B→A                                # 4 bytes
L→L2(I                             # 7 bytes
End                                # 2 bytes
T≥sum(seq(L2(X)/L1(X),X,1,I        # 21 bytes

Bash, 151 bajtów

Uruchomiony jako (na przykład) $ bash golf.sh .5 10=====:

shopt -s extglob
r=$2
while [ -n "$r" ];do
f=${r%%+(=)}
s=`dc<<<"9k$s $[${#r}-${#f}] ${f##*=}/+p"`
r=${f%%+([0-9.])}
done
[[ `dc<<<"$1 $s-p"` != -* ]]

Wyjaśnienie

shopt -s extglob
r=$2

Włącz rozszerzone operatory dopasowywania wzorców bash i przypisz drogę do zmiennej r.

while [ -n "$r" ];do
f=${r%%+(=)}

Pętla, aż rbędzie pusta. Ustaw fna rze wszystkimi znakami równości usuniętymi z końca, używając %% rozszerzenia parametru i +()rozszerzonego operatora globowania.

s=`dc<<<"9k$s $[${#r}-${#f}] ${f##*=}/+p"`

Przypisz do sbieżącej sumy minimalnych czasów dla każdego odcinka drogi. Można to przepisać (być może nieco) bardziej czytelnie jako:

s=$(dc <<< "9k $s $[${#r}-${#f}] ${f##*=} / + p")

Zasadniczo to, co się tutaj dzieje, polega na tym, że używamy ciągu tutaj, aby uzyskać dcpolecenie wykonania matematyki dla nas, ponieważ bash nie może sam wykonywać arytmetyki zmiennoprzecinkowej. 9kustawia precyzję, aby nasz podział był zmiennoprzecinkowy, i pdrukuje wynik, gdy skończymy. Jest to kalkulator odwrotnego polerowania, więc to, co naprawdę obliczamy, jest ${f##*=}dzielone przez $[${#r}-${#f}]plus naszą bieżącą sumę (lub, gdy po raz pierwszy przejdziemy i snie został jeszcze ustawiony, nic, co daje nam ostrzeżenie na stderr odc „ s jest pusty, ale nadal drukuje prawidłową liczbę, ponieważ i tak będziemy dodawać do zera).

Jeśli chodzi o rzeczywiste wartości, które dzielimy: ${f##*=}jest fz największym dopasowaniem wzorca *=usuniętym z przodu. Ponieważ fjest to nasza obecna droga ze wszystkimi znakami równości usuniętymi z końca, oznacza ${f##*=}to ograniczenie prędkości dla tego konkretnego odcinka drogi. Na przykład, jeśli nasza droga miałaby r„10 ===== 5 ===”, to fbyłaby to „10 ===== 5”, a więc ${f##*=}byłaby to „5”.

$[${#r}-${#f}]to liczba znaków równości na końcu naszego odcinka drogi. ${#r}jest długością r; ponieważ fjest po rusunięciu wszystkich znaków równości na końcu, możemy po prostu odjąć jego długość od, raby uzyskać długość tego odcinka drogi.

r=${f%%+([0-9.])}
done

Usuń ten odcinek ograniczenia prędkości drogi z końca f, pozostawiając wszystkie pozostałe odcinki drogi i ustaw rna to, kontynuując pętlę, aby przetworzyć kolejny kawałek drogi.

[[ `dc<<<"$1 $s-p"` != -* ]]

Sprawdź, czy czas potrzebny na przejechanie drogi (podany jako $1) jest krótszy niż minimalny dozwolony przez ograniczenie prędkości. To minimum smoże być zmiennoprzecinkowe, więc wrócimy do dcporównania. dcma operator porównania, ale faktycznie użycie go skończyło się o 9 bajtów więcej niż to, więc zamiast tego odejmuję nasz czas podróży od minimum i sprawdzam, czy jest ujemny, sprawdzając, czy zaczyna się od myślnika. Być może nieeleganckie, ale wszystko jest w porządku w miłości i korzeniach.

Ponieważ to sprawdzenie jest ostatnim poleceniem w skrypcie, jego wartość zwrotna również zostanie zwrócona przez skrypt: 0, jeśli to możliwe, przyspieszenie, 1, jeśli zdecydowanie przyspieszenie:

$ bash golf.sh .5 10===== 2>/dev/null && echo maybe || echo definitely
maybe
$ bash golf.sh .4 10===== 2>/dev/null && echo maybe || echo definitely
definitely

Python 3.6, 111 bajtów

Mój pierwszy golf golfowy!

import re
def f(a,b):
 t=0
 for c in re.split('(=+)',b)[:-1]:
  try:s=float(c)
  except:t+=len(c)/s
 return a<t

Wypróbuj online!

re.split('(=+)',b)[:-1] Dzieli drogę na kawałki =.

Następnie iteruje wynik, używając try:s=float(c)do ustawienia aktualnego ograniczenia prędkości, jeśli bieżącym elementem jest liczba, lub except:t+=len(c)/sdo dodania czasu do przemierzenia tego odcinka drogi do łącznej sumy.

Wreszcie zwraca czas zajęty do możliwie najszybszego czasu.

PHP5 207 202 bajtów

Pierwszy wysiłek na odpowiedź na pytanie w golfa, proszę, spokojnie. Jestem pewien, że jeden z was, geniusze, będzie w stanie znacznie to skrócić, wszelkie wskazówki dotyczące gry w golfa są mile widziane.

function s($c,$d){foreach(array_filter(split("[{$d}/=]",$c)) as $e){$f[]=$e;};return $f;}function x($a,$b){$c=s($b,"^");$d=s($b,"");for($i=0;$i<sizeof($c);$i++){$z+=strlen($c[$i])/$d[$i];}return $a<$b;}

Wywołaj z

x("1.5","3.0==========20===")

Zwraca wartość true, jeśli przekroczyłeś limit prędkości, w przeciwnym razie wartość false

Dyalog APL, 27 bajtów

<∘(+/(⍎'='⎕r' ')÷⍨'=+'⎕s 1)

'=+'⎕s 1jest funkcją, która identyfikuje ciągi '='za pomocą wyrażenia regularnego i zwraca wektor ich długości ( ⎕sprawy operand 0 oznaczałby przesunięcia; 1 - długości; 2 - wskaźniki pasujących wyrażeń regularnych)

'='⎕r' 'zastępuje '='s spacjami

⍎'='⎕r' ' wykonuje go - zwraca wektor prędkości

÷⍨w środku dzieli dwa wektory ( ⍨zamienia argumenty, więc odległość dzieli się przez prędkość)

+/ jest sumą

jak dotąd wszystko to 4 pociągi - funkcja bez wyraźnego argumentu

<∘komponuje „mniej niż” przed tą funkcją; więc funkcja będzie działać tylko na prawym argumencie, a jej wynik zostanie porównany z lewym argumentem

F # (165 bajtów)

let rec c t p l=
 match l with
 |[]->t<0.0
 |x::xs->
  match x with
  |""->c(t-p)p xs
  |_->c(t-p)(1.0/float x)xs
let s t (r:string)=r.Split '='|>Seq.toList|>c t 0.0

Nadal jestem nowy na F #, więc jeśli zrobiłem coś dziwnego lub głupiego, daj mi znać.

Metoda C # ( 137 122 bajtów)

Wymaga using System.Linqdodania 19 bajtów, zawartych w 122:

bool C(float t,string r,float p=0)=>r.Split('=').Aggregate(t,(f,s)=>f-(s==""?p:p=1/float.Parse(s)))<-p;

Wersja rozszerzona:

bool Check(float time, string road, float pace=0) => 
    road.Split('=')
        .Aggregate(time, (f, s) => f - (
            s == "" 
            ? pace 
            : pace = 1 / float.Parse(s))) 
        < -pace;

roadCiąg jest podzielony na =charakter. W zależności od tego, czy ciąg jest tablicą wynikową, jest pusty, funkcja agregująca ustawia pacezmienną dla segmentu (oznaczającą czas potrzebny na przejechanie pojedynczego =) i odejmuje ją od podanego czasu. Wykona to zbyt wiele odejmowań (dla końcowego odcinka drogi), więc zamiast porównywać 0, porównujemy-pace

R , 100 bajtów

function(S,R){s=strsplit(R,"=")[[1]]
s[s==""]=0
S<sum((1+(a=rle(as.double(s)))$l[!a$v])/a$v[a$v>0])}

Wypróbuj online!

Zwraca TRUEwartości jednoznacznie przyspieszające, a FALSEbyć może wartości nieprzydatne.

PowerShell , 71 bajtów

param($t,$r)$t-lt($r-replace'(.+?)(=+)','+($2)/$1'-replace'=','+1'|iex)

Wypróbuj online!

Skrypt testowy:

$f = {

param($t,$r)$t-lt($r-replace'(.+?)(=+)','+($2)/$1'-replace'=','+1'|iex)

}

@(
    ,(1.5, "5=====10=====", $false)
    ,(3.2, "3.0==========20===", $true)
) | % {
    $time,$road,$expected = $_
    $result = &$f $time $road
    "$($result-eq$expected): $result"
}

Wydajność:

True: False
True: True

Wyjaśnienie:

1. Skrypt pobiera elementy drogi 5=====10=====, zamienia elementy, dodaje nawiasy i operatory+(=====)/5+(=====)/10
2. Następnie skrypt zastępuje każdy =z +1:+(+1+1+1+1+1)/5+(+1+1+1+1+1)/10
3. Na koniec skrypt ocenia ciąg jako wyrażenie PowerShell i porównuje go z pierwszym argumentem.