Sagen Sie mir bei einer ascii-art Straße und der Zeit, die ich brauchte, um sie zu überqueren, ob ich beschleunigt habe.

Einheiten

Entfernung ist in der willkürlichen Einheit von d. Die Zeit ist in der willkürlichen Einheit von t.

Die Straße

Hier ist eine einfache Straße:

10=====

Das 10bedeutet 10 dper t. Das ist das Tempolimit für die Straße. Die Straße hat 5 =s, also dist es 5. Wenn ich diese Straße in 0,5 überquere t, bin ich 10 dpro gefahren t, weil 5 / 0,5 = 10. Das Tempolimit dieser Straße ist 10, also bin ich innerhalb des Tempolimits geblieben.

Aber wenn ich diese Straße in 0,25 überquere t, habe ich 20 dpro gefahren t, weil 5 / 0,25 = 20. Das Tempolimit dieser Straße ist 10, also bin ich 10 über das Tempolimit gefahren.

Beispiele und Berechnungen

Beachten Sie, dass Eingabe 1 die Zeit ist, die ich zum Befahren der Straße benötigt habe, und Eingabe 2 die Straße selbst ist.

Hier ist eine komplexe Straße:

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

Die schnellste, die ich (legal) auf der ersten Straße hätte fahren können (die ersten 5 =s), ist 5 dper t. Da 5 (Distanz) geteilt durch 5 (Geschwindigkeitsbegrenzung) 1 ist, ist die schnellste, die ich auf dieser Straße hätte fahren können, 1 t.

Auf der nächsten Straße ist das Tempolimit 10 und die Distanz 5, die schnellste, die ich überqueren konnte, ist 0,5 (5/10). Die Summe der Mindestzeiten ergibt 1,5, was bedeutet, dass ich genau das Tempolimit erreicht habe.

Hinweis: Ich weiß, dass ich auf einer Straße sehr schnell und auf einer anderen sehr langsam gefahren bin und immer noch die 1,5 überquert habe, aber nehme hier das Beste an.

Ein letztes Beispiel:

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

Die erste Straße ist 10 km lang und hat ein Tempolimit von 3, die Mindestzeit beträgt also 3.33333 ... (10 / 3.)

Die zweite Straße ist 3 lang und hat ein Tempolimit von 20, die Mindestzeit beträgt also 0,15 (3/20).

Die Summe der Zeiten ergibt 3.483333333 ... Ich habe es in 3.2 überschritten, also musste ich irgendwo beschleunigen.

Anmerkungen:

• Sie müssen einen eindeutigen Wert ausgeben, wenn ich zweifellos beschleunige, und einen anderen Wert, wenn ich nicht beschleunige.
• Für Ihr Programm oder Ihre Funktion ist möglicherweise eine Eingabe oder Ausgabe erforderlich, um einen nachgestellten Zeilenumbruch zu erhalten.
• Ihre erste Eingabe wird meine Geschwindigkeit sein. Es wird ein positiver Gleitkommawert oder eine Ganzzahl oder eine Zeichenfolge sein.
• Ihre zweite Eingabe wird die Straße sein. Es wird immer mit dem regulären Ausdruck übereinstimmen ^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$. Bei Interesse können Sie hier mögliche Eingaben testen.
• Sie können 2 Parameter einer Funktion oder eines Programms in 2 separaten Dateien, zweimal aus STDIN oder aus einer durch Leerzeichen getrennten Zeichenfolge, die an STDIN übergeben wird, einer Funktion, einer Datei oder einem Befehlszeilenparameter eingeben.
• Wenn Sie möchten, können Sie die Reihenfolge der Eingaben ändern.
• Irgendwelche Fragen? Fragen Sie unten in Kommentaren und glücklich Code- Golfing!

05AB1E , 24 22 Bytes

Gibt 1 zurück, wenn zweifellos zu schnell gefahren wird, und 0, wenn nicht.

2 Bytes dank Carusocomputing gespart .

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

Probieren Sie es online!

-§'-åweder sollte nicht mehr als ein einfacher Vergleich sein müssen, aber aus irgendeinem Grunde ›noch ‹scheint Arbeit zwischen dem berechneten Wert und dem zweiten Eingang.

Erläuterung

Unter Verwendung 3.0==========20===, 3.2als Beispiel

'=¡                        # 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 Bytes

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

Probieren Sie es online!

Pythons dynamisches Typensystem kann ziemlich viel Missbrauch vertragen.

Aufspalten des Eingabestring s.split('=')dreht kGleichheitszeichen in k-1leeren Zeichenfolge Listenelemente (außer am Ende, wo man abgeschnitten werden muss). Beispielsweise,

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

Der Code durchläuft diese Elemente und aktualisiert die aktuelle Geschwindigkeit sjedes Mal, wenn eine Zahl angezeigt wird. Das Update erfolgt wie s=float(c or s), wo , wenn ceine nicht leere Zeichenfolge ist, erhalten wir float(c)und sonst c or sausgewertet s, wo float(s)gerade hält s. Beachten Sie, dass ces sich um eine Zeichenfolge und seine Zahl handelt, für Python jedoch keine einheitlichen Eingabetypen erforderlich sind float.

Beachten Sie auch, dass die Variable, in sder die Geschwindigkeit gespeichert ist , mit der Variable identisch ist, die die Eingabezeichenfolge verwendet. Die Zeichenfolge wird ausgewertet, wenn die Schleife beginnt. Wenn Sie sie innerhalb der Schleife ändern, ändert sich auch nicht, worüber iteriert wird. Dieselbe Variable kann also zum Speichern einer Initialisierung wiederverwendet werden. Die erste Schleife hat immer ceine Zahl, daher ist s=float(c or s)die sursprüngliche Rolle der Schleife als Zeichenfolge unerheblich.

Bei jeder Iteration wird die aktuelle Geschwindigkeit von der zulässigen Geschwindigkeit abgezogen, die als Geschwindigkeitsbegrenzung beginnt. Am Ende wurde das Tempolimit verletzt, wenn dieses unterschritten wird 0.

Python 3 , 79 Bytes

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

Probieren Sie es online!

Beispielsweise wird die Eingabe 3.0==========20===in die Zeichenfolge konvertiert

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

ausgewertet und das Ergebnis mit der Eingangsgeschwindigkeit verglichen. Jedes -~erhöht sich um 1. Ich bin neu in Regexes, also gibt es vielleicht einen besseren Weg, als beide Substitutionen gleichzeitig zu machen. Vielen Dank an Jonathan Allan für den Hinweis, wie alles außer dem =Charakter zusammenpassen soll.

Javascript (ES6), 63 Byte

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

Verwendung

Weisen Sie diese Funktion einer Variablen zu und rufen Sie sie in der aktuellen Syntax auf. Das erste Argument ist die Zeit, das zweite ist die Straße.

Erläuterung

Stimmt mit allen aufeinanderfolgenden Zeichenfolgen überein, die keine Gleichheitszeichen sind, gefolgt von einer Folge von Gleichheitszeichen. Jede Übereinstimmung wird durch das Ergebnis der inneren Funktion ersetzt, die zwei Argumente verwendet: die Folge von Gleichheitszeichen (in Variable d) und die Zahl (Variable c). Die Funktion gibt die Länge der Straße zurück, die von der Zahl abweicht, der ein + vorangestellt ist.

Die resultierende Zeichenfolge wird dann ausgewertet und mit der ersten Eingabe verglichen.

Stapel-Snippet

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 Bytes

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

Behandelt auch nicht ganzzahlige Geschwindigkeitsbegrenzungen. #import<stdlib.h>wird benötigt, damit der Compiler nicht annimmt, dass atof()ein int.

t<s-.001wird benötigt, um den genauen Geschwindigkeitsbegrenzungstestfall zum Laufen zu bringen, da sonst Rundungsfehler den Eindruck erwecken, dass Sie beschleunigt haben. Wenn die Zeit jetzt 1.4999statt ist 1.5, wird diese Geschwindigkeit natürlich nicht berücksichtigt. Ich hoffe das ist okay.

Probieren Sie es online!

Perl 5 , 43 Bytes

42 Byte Code + -pFlag.

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

Probieren Sie es online!

Für jede Gruppe von Ziffern, gefolgt von Gleichheitszeichen ( [^=]+(=+)), berechnen wir, wie viel Zeit benötigt wird, um sie zu überqueren (Anzahl der Gleichheitszeichen geteilt durch die Geschwindigkeit:) (length$1)/$&und addieren diese Zeiten $t. Am Ende müssen wir nur überprüfen, ob dies $tweniger als die Zeit ist, die Sie benötigt haben, um es zu überqueren ( $_=$t < <>). Das Ergebnis ist 1(wahr) oder nichts (falsch).

Mathematica, 98 Bytes

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

Reine Funktion mit zwei Argumenten, einer Zahl (die eine Ganzzahl, ein Bruch, eine Dezimalzahl πoder eine Zahl in wissenschaftlicher Notation sein kann) und einer Zeichenfolge mit Zeilenende und Rückgabe von Trueoder False. Beispielhafte Erklärung anhand der Eingaben 3.2und "3==========20===\n":

#2~StringSplit~"="produziert {"3","","","","","","","","","","20","","","\n"}. Beachten Sie, dass die Anzahl der aufeinanderfolgenden ""s um eins niedriger ist als die Anzahl der aufeinanderfolgenden =s in jedem Lauf.

//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}ist eine sich wiederholende Ersetzungsregel. Zuerst setzt es zauf die leere Sequenz, aauf "3", bauf "","","","","","","","",""(die längste Folge von ""s, die es finden konnte) und cauf "20","","","\n"; Der Befehl wird zu (Length@{b}+1)/ToExpression@aausgewertet (9+1)/3, und das Ergebnis der Ersetzung ist die Liste {10/3, "20","","","\n"}.

Als nächstes setzt die Ersetzungsregel zauf 10/3, aauf "20", bauf "",""und cauf "\n". Wird nun zu (Length@{b}+1)/ToExpression@aausgewertet (2+1)/20, und so ist das Ergebnis der Ersetzung {10/3, 3/20, "\n"}. Die Ersetzungsregel kann keine andere Übereinstimmung finden, daher wird sie angehalten.

Schließlich werden die Elemente der Liste Tr[...]-"\n"hinzugefügt (es wird ein Byte gespart, um zwischen den Anführungszeichen einen tatsächlichen Zeilenumbruch zu verwenden "\n") 10/3 + 3/20 + "\n", und das wird erhalten und dann abgezogen "\n", was Mathematica vollkommen gerne tut. Schließlich <=#vergleicht das Ergebnis mit dem ersten Eingang ( 3.2in diesem Fall), der Ausbeuten False.

Gelee , 27 Bytes

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

Probieren Sie es online!

Hinweis: geht davon aus, dass der Regex in der Frage gegeben sollte so sein , dass eine Geschwindigkeitsbegrenzung nicht sein kann 0.0, 0.00usw. - so wie es nicht sein kann 0( bestätigt als unbeabsichtigte Eigenschaft).

Wie?

ṣ”=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 Bytes

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

Ausgänge, Truewenn Sie beschleunigen, Falsewenn Sie nicht sind. Benötigt keine nachgestellte Newline (funktioniert aber damit).

Obwohl es nicht so aussieht, wie es aussehen würde, behandelt es Schwebungen sowohl in der Eingabezeit als auch in den Geschwindigkeitsbegrenzungen korrekt, da die Regex nur zum Trennen der Straßensegmente verwendet wird.

MATL , 31 30 Bytes

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

Eingaben sind: eine Zeichenfolge (Geschwindigkeitsbegrenzungen und Straßen), dann eine Zahl (verwendete Geschwindigkeit). Die Ausgabe erfolgt, 1wenn zweifellos, 0wenn nicht.

Probieren Sie es online!

Erklärung mit Beispiel

Betrachten Sie Eingaben '3.0==========20==='und 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 Bytes

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

Dies nimmt die Straße als String als rechtes Argument und die Zeit als linkes Argument und gibt zurück, 1wenn Sie beschleunigt haben und 0wenn nicht, wie folgt:

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

Erläuterung:

• X←⍵='=': In Xeinem Bitvektor alle Positionen speichern ⍵, die Teil der Straße sind.
• X≠¯1⌽X: Markieren Sie jede Position X, die nicht mit der Position des rechten Nachbarn übereinstimmt (umlaufend), und geben Sie die Positionen an, an denen Zahlen und Straßen beginnen
• Y←⍵⊂⍨: ⍵An diesen Positionen teilen (mit einer Reihe von abwechselnden Nummern und Strassenfolgen) und in speichern Y.
• Y⊂⍨2|⍳⍴Y: Yin aufeinanderfolgenden Paaren aufgeteilt.
• {(≢⍵)÷⍎⍺}/¨: Teilen Sie für jedes Paar die Länge des Straßenteils ( ≢⍵) durch das Ergebnis der Bewertung des Zahlenteils ( ⍎⍺). Dies gibt die minimale Zeit für jedes Segment an.
• +/: Summieren Sie die Zeiten für alle Segmente, um die minimale Gesamtzeit zu erhalten.
• ⍺<: Überprüfen Sie, ob die angegebene Zeit unter dem Mindestwert liegt.

TI-Basic, 168 165 Bytes

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

Eingabe ist die Straße als Str0und die Zeit als T. Stellen Sie sicher, dass Sie der Straße ein Zitat voranstellen, z Str0=?"14========3===.

Ausgang ist 0, wenn beschleunigt wird, 1, wenn möglicherweise nicht beschleunigt wird.

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 Bytes

Laufen als (zum Beispiel) $ 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"` != -* ]]

Erläuterung

shopt -s extglob
r=$2

Aktivieren Sie die erweiterten Mustervergleichsoperatoren von bash und weisen Sie die Straße einer Variablen zur .

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

Schleife bis rist leer. Mit der Parametererweiterung und dem erweiterten Globenoperator auf setzen f, rwobei alle Gleichheitszeichen am Ende entfernt sind.%% +()

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

Weisen Sie sfür jedes Straßensegment eine laufende Summe der Mindestzeiten zu. Dies kann (vielleicht etwas) besser lesbar umgeschrieben werden als:

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

Im Grunde genommen verwenden wir hier einen Here-String, um den dcBefehl zu erhalten, Mathe für uns auszuführen, da Bash keine Fließkomma-Arithmetik alleine ausführen kann. 9kLegt die Genauigkeit so fest, dass unsere Division Gleitkomma ist, und gibt pdas Ergebnis aus, wenn wir fertig sind. Es ist ein Umkehrpoliturrechner, also wird das, was wir wirklich berechnen ${f##*=}, durch $[${#r}-${#f}]plus unsere aktuelle Summe (oder, wenn wir das erste Mal durchlaufen und) geteilts noch nicht festgelegt wurden, nichts, was uns eine Warnmeldung über stderr gibt dc). s Stack ist leer, gibt aber trotzdem die richtige Zahl aus, da wir sowieso auf Null addieren würden).

Was die tatsächlichen Werte anbelangt, die wir teilen, ${f##*=}ist dies so, dass fdie größte Musterübereinstimmung *=von vorne entfernt ist. Da funsere aktuelle Straße am Ende alle Gleichheitszeichen entfernt hat, ist dies ${f##*=}die Höchstgeschwindigkeit für diesen bestimmten Straßenabschnitt. Wenn unsere Straße rzum Beispiel '10 ===== 5 === 'wäre, dann fwäre sie '10 ===== 5' und so weiter${f##*=} wäre auch '5'.

$[${#r}-${#f}]ist die Anzahl der Gleichheitszeichen am Ende unseres Straßenabschnitts. ${#r}ist die Länge von r; Da am Ende fnur ralle Gleichheitszeichen entfernt sind, können wir seine Länge von rder Länge dieses Straßenabschnitts subtrahieren .

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

Entfernen Sie diesen Abschnitt der Geschwindigkeitsbegrenzung vom Ende der Straße f, lassen Sie alle anderen Abschnitte der Straße übrig, und stellen Sie ihn rauf diese ein. Setzen Sie die Schleife fort, um den nächsten Abschnitt der Straße zu verarbeiten.

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

Prüfen Sie, ob die Zeit, die wir für die Fahrt auf der Straße benötigt haben (angegeben als $1), unter dem von der Geschwindigkeitsbegrenzung zugelassenen Minimum liegt. Dieses Minimum skann ein Schwimmer sein, also wenden wir uns zudc erneut dem Vergleich zu. dcEs gibt zwar einen Vergleichsoperator, der jedoch 9 Bytes mehr enthält. Stattdessen subtrahiere ich unsere Reisezeit vom Minimum und überprüfe, ob er negativ ist, indem ich prüfe, ob er mit einem Bindestrich beginnt. Vielleicht unelegant, aber alles ist fair in Liebe und Codegolf.

Da diese Prüfung der letzte Befehl im Skript ist, wird auch sein Rückgabewert vom Skript zurückgegeben: 0, wenn möglicherweise eine Geschwindigkeitsüberschreitung vorliegt, 1, wenn definitiv eine Geschwindigkeitsüberschreitung vorliegt:

$ 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 Bytes

Mein erster Code Golf!

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

Probieren Sie es online!

re.split('(=+)',b)[:-1] Teilt die Straße in Stücke von = .

Anschließend wird das Ergebnis durchlaufen , wobei try:s=float(c)das aktuelle Tempolimit festgelegt wird, wenn es sich bei dem aktuellen Element um eine Zahl handelt, oder except:t+=len(c)/sdie Zeit zum Durchlaufen dieses Straßenabschnitts zur kumulierten Summe hinzugefügt wird.

Schließlich wird die Zeit zurückgegeben, die zur schnellstmöglichen Zeit benötigt wird.

PHP5 207 202 Bytes

Erster Versuch bei einer Code Golf Antwort, bitte schont mich. Ich bin mir sicher, dass ein Genie von Ihnen dies erheblich verkürzen kann. Golftipps sind willkommen.

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

Mit aufrufen

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

Gibt true zurück, wenn Sie unter dem Tempolimit waren, andernfalls false

Dyalog APL, 27 Bytes

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

'=+'⎕s 1ist eine Funktion, die Strecken '='mit einer Regex identifiziert und einen Vektor ihrer Länge zurückgibt ( ⎕sder rechte Operand 0 würde Offsets bedeuten; 1 - Längen; 2 - Indizes von Regexen, die übereinstimmen).

'='⎕r' 'Ersetzt '='s durch Leerzeichen

⍎'='⎕r' ' führt es aus - gibt einen Geschwindigkeitsvektor zurück

÷⍨in der Mitte werden die beiden Vektoren geteilt ( ⍨die Argumente werden vertauscht, sodass die Entfernung durch die Geschwindigkeit geteilt wird)

+/ ist Summe

alles ist bisher ein 4-Zug - eine Funktion ohne explizites Argument

<∘komponiert "kleiner als" vor dieser Funktion; Daher wird die Funktion nur auf das rechte Argument angewendet und das Ergebnis wird mit dem linken Argument verglichen

F # (165 Bytes)

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

Ich bin noch neu in F #. Wenn ich also etwas Seltsames oder Dummes getan habe, lass es mich wissen.

C # -Methode ( 137 122 Bytes)

Erfordert das using System.LinqHinzufügen von 19 Bytes, die in den 122 enthalten sind:

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

Erweiterte Version:

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

Die roadZeichenfolge wird auf das =Zeichen aufgeteilt. Abhängig davon, ob ein String das resultierende Array leer ist, legt die Aggregatfunktion die paceVariable für das Segment fest (was die Zeit angibt, die zum Durchlaufen eines einzelnen Segments benötigt wird =) und subtrahiert sie von der angegebenen Zeit. Dies führt zu einer zu großen Anzahl von Subtraktionen (für das endgültige Straßensegment). Anstatt mit zu vergleichen 0, vergleichen wir mit-pace

R , 100 Bytes

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

Probieren Sie es online!

Gibt TRUEfür eindeutig beschleunigende Werte zurück, FALSEfür möglicherweise nicht schnelle.

PowerShell , 71 Byte

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

Probieren Sie es online!

Testskript:

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

Ausgabe:

True: False
True: True

Erläuterung:

1. Das Skript ruft die Elemente der Straße ab 5=====10=====, tauscht Elemente aus, fügt Klammern und Operatoren hinzu+(=====)/5+(=====)/10
2. Dann ersetzt das Skript jedes =durch +1:+(+1+1+1+1+1)/5+(+1+1+1+1+1)/10
3. Schließlich wertet das Skript die Zeichenfolge als Powershell-Ausdruck aus und vergleicht sie mit dem ersten Argument.