Dado un camino ascii-art y el tiempo que me llevó cruzarlo, dime si estaba acelerando.

Unidades

La distancia está en la unidad arbitraria de d. El tiempo está en la unidad arbitraria de t.

El camino

Aquí hay un camino simple:

10=====

Los 10medios 10 dpor t. Ese es el límite de velocidad de la carretera. El camino tiene 5 =s, entonces des 5. Por lo tanto, si cruzo ese camino en 0.5 t, fui 10 dpor t, porque 5 / 0.5 = 10. El límite de velocidad de ese camino es 10, así que me mantuve dentro del límite de velocidad.

Pero si cruzo esa carretera en 0.25 t , fui 20 dpor t, porque 5 / 0.25 = 20. El límite de velocidad de esa carretera es 10, así que fui 10 por encima del límite de velocidad.

Ejemplos y cálculos.

Tenga en cuenta que la entrada 1 es el tiempo que tardé en recorrer el camino, y la entrada 2 es el camino en sí.

Aquí hay un camino complejo:

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

Lo más rápido que podría (legalmente) haber ido en la primera carretera (los primeros 5 =s) es 5 dpor t. Dado que 5 (distancia) dividido por 5 (límite de velocidad) es 1, lo más rápido que pude haber recorrido ese camino es 1 t.

En la siguiente carretera, el límite de velocidad es 10 y la distancia también es 5, el más rápido que pude cruzar es 0.5 (5/10). Totalizar los tiempos mínimos resulta en 1.5, lo que significa que fui exactamente al límite de velocidad.

Nota: Lo sé, podría haber estado yendo muy rápido en un camino y realmente lento en otro y aún cruzar en 1.5, pero asumo lo mejor aquí.

Un último ejemplo:

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

La primera carretera tiene 10 largos y tiene un límite de velocidad de 3, por lo que el tiempo mínimo es 3.33333 ... (10 / 3.)

El segundo camino es de 3 largos y tiene un límite de velocidad de 20, por lo que el tiempo mínimo es de 0.15 (3/20).

Totalizando los tiempos resulta en 3.483333333 ... Lo crucé en 3.2, así que tuve que acelerar a alguna parte.

Notas:

• Debe generar un valor distinto si indudablemente estoy acelerando, y otro valor diferente si no lo estoy.
• Su programa o función puede requerir entrada o salida para tener una nueva línea final, pero por favor dígalo en su envío.
• Tu primera entrada será mi velocidad. Será un flotante positivo o entero o cadena.
• Su segunda entrada será el camino. Siempre coincidirá con la expresión regular ^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$. Puede probar entradas potenciales aquí si está interesado.
• Puede ingresar datos en 2 parámetros de una función o programa, en 2 archivos separados, desde STDIN dos veces, o desde una cadena separada por espacios pasada a STDIN, una función, un archivo o un parámetro de línea de comandos.
• Si lo desea, puede cambiar el orden de las entradas.
• ¿Alguna pregunta? Pregunte abajo en comentarios y feliz código de golf ing!

05AB1E , 24 22 bytes

Devuelve 1 cuando, sin duda, está acelerando y 0 en caso contrario.

Ahorro de 2 bytes gracias a carusocomputing .

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

Pruébalo en línea!

-§'-åNo debería ser más que una simple comparación, pero por alguna razón ›ni ‹parece funcionar entre el valor calculado y la segunda entrada.

Explicación

Usando 3.0==========20===, 3.2como ejemplo

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

Pruébalo en línea!

El sistema de tipo dinámico de Python puede soportar bastante abuso.

Al dividir la cadena de entrada, los signos iguales se s.split('=')convierten ken k-1elementos de la lista de cadenas vacías (excepto al final, donde se debe cortar uno). Por ejemplo,

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

El código itera sobre estos elementos, actualizando la velocidad actual scada vez que ve un número. La actualización se realiza como s=float(c or s), donde si ces una cadena no vacía, obtenemos float(c), y de lo contrario se c or sevalúa s, donde float(s)simplemente se mantiene s. Tenga en cuenta que ces una cadena y ses un número, pero Python no requiere no requiere tipos de entrada consistentes, y floatacepta cualquiera.

Tenga en cuenta también que la variable que salmacena la velocidad es la misma que tomar la cadena de entrada. La cadena se evalúa cuando comienza el ciclo, y cambiarla dentro del ciclo no cambia lo que se repite. Por lo tanto, la misma variable se puede reutilizar para guardar en una inicialización. El primer bucle siempre tiene cun número, por lo que s=float(c or s)no le importa sel rol inicial de una cadena.

Cada iteración resta la velocidad actual de la asignación, que comienza como el límite de velocidad. Al final, el límite de velocidad ha sido violado si esto cae por debajo 0.

Python 3 , 79 bytes

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

Pruébalo en línea!

Por ejemplo, la entrada 3.0==========20===se convierte a la cadena

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

y evaluado, y el resultado se compara con la velocidad de entrada. Cada uno -~aumenta por 1. Soy nuevo en expresiones regulares, por lo que tal vez haya una mejor manera, como hacer ambas sustituciones a la vez. Gracias a Jonathan Allan por señalar cómo hacer coincidir a todos menos al =personaje.

Javascript (ES6), 63 bytes

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

Uso

Asigne esta función a una variable y llámela usando la sintaxis curry. El primer argumento es el tiempo, el segundo es el camino.

Explicación

Coincide con todas las series consecutivas de caracteres que no son signos iguales seguidos de una serie de signos iguales. Cada coincidencia se reemplaza por el resultado de la función interna, que utiliza dos argumentos: la ejecución de signos iguales (en variable d) y el número (variable c). La función devuelve la longitud del camino dividido por el número, precedido por un +.

La cadena resultante se evalúa y se compara con la primera entrada.

Fragmento de pila

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

Maneja límites de velocidad no enteros también. #import<stdlib.h>es necesario para que el compilador no asuma que atof()devuelve un int.

t<s-.001es necesario para que funcione el caso de prueba de límite de velocidad exacto, de lo contrario, los errores de redondeo hacen pensar que estaba acelerando. Por supuesto, ahora si el tiempo es en 1.4999lugar de 1.5, no considera que se acelere. Espero que esté bien.

Pruébalo en línea!

Perl 5 , 43 bytes

42 bytes de código + -pbandera.

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

Pruébalo en línea!

Para cada grupo de dígitos seguido de algunos signos de igual ( [^=]+(=+)), calculamos cuánto tiempo se necesita para cruzarlo (número de iguales dividido por la velocidad (length$1)/$&:) y sumamos esos tiempos en el interior $t. Al final, solo tenemos que verificar que $tsea ​​menor que el tiempo que tardó en cruzarlo ( $_=$t < <>). El resultado será 1(verdadero) o nada (falso).

Mathematica, 98 bytes

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

Función pura que toma dos argumentos, un número (que puede ser un número entero, fracción, decimal, par πo un número en notación científica) y una cadena terminada en nueva línea, y que devuelve Trueo False. Explicación a modo de ejemplo, utilizando las entradas 3.2y "3==========20===\n":

#2~StringSplit~"="produce {"3","","","","","","","","","","20","","","\n"}. Observe que el número de ""s consecutivos es uno menos que el número de =s consecutivos en cada ejecución.

//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}Es una regla de reemplazo repetitiva. Primero establece zla secuencia vacía, ato "3", bto "","","","","","","","",""(la ejecución más larga de ""s que pudo encontrar), y cto "20","","","\n"; el comando se (Length@{b}+1)/ToExpression@aevalúa y (9+1)/3, por lo tanto, el resultado del reemplazo es la lista {10/3, "20","","","\n"}.

A continuación, la regla de reemplazo establece za 10/3, ato "20", bto "",""y cto "\n". Ahora se (Length@{b}+1)/ToExpression@aevalúa como (2+1)/20, y entonces el resultado del reemplazo es {10/3, 3/20, "\n"}. La regla de reemplazo no puede encontrar otra coincidencia, por lo que se detiene.

Finalmente, Tr[...]-"\n"(ahorra un byte para usar una nueva línea real entre las comillas en lugar de "\n") agrega los elementos de la lista, obteniendo 10/3 + 3/20 + "\n", y luego resta "\n", lo que Mathematica está perfectamente feliz de hacer. Finalmente, <=#compara el resultado con la primera entrada ( 3.2en este caso), que produce False.

Jalea , 27 bytes

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

Pruébalo en línea!

Nota: se asume que la expresión regular dada en la pregunta debe ser tal que un límite de velocidad no puede ser 0.0, 0.00, etc. - al igual que no se puede 0( confirmado como una propiedad no intencional).

¿Cómo?

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

Salidas Truesi estás acelerando, Falsesi no lo estás. No requiere (pero funcionará con) nueva línea final.

A pesar de que no se ve como lo haría, maneja correctamente los flotadores tanto en el tiempo de entrada como en los límites de velocidad, porque la expresión regular solo se usa para separar los segmentos de la carretera.

MATL , 31 30 bytes

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

Las entradas son: una cadena (límites de velocidad y carreteras), luego un número (velocidad utilizada). La salida es, 1sin duda, a toda velocidad, 0si no.

Pruébalo en línea!

Explicación con ejemplo

Considere las entradas '3.0==========20==='y 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←⍵='='}

Esto toma el camino como una cadena como argumento derecho, y el tiempo tomado como argumento izquierdo, y regresa 1si estaba acelerando y 0si no, así:

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

Explicación:

• X←⍵='=': almacenar en Xun vector de bits de todas las posiciones ⍵que forman parte del camino.
• X≠¯1⌽X: marca cada posición Xque no es igual a su vecino derecho (envolviendo), dando las posiciones donde comienzan los números y las carreteras
• Y←⍵⊂⍨: dividir ⍵en estas posiciones (dando una serie de cadenas de números y carreteras alternas), y almacenarlo en Y.
• Y⊂⍨2|⍳⍴Y: dividido Yen pares consecutivos.
• {(≢⍵)÷⍎⍺}/¨: para cada par, divida la longitud de la parte del camino ( ≢⍵) por el resultado de evaluar la parte del número ( ⍎⍺). Esto le da el tiempo mínimo para cada segmento.
• +/: Suma los tiempos de todos los segmentos para obtener el tiempo mínimo total.
• ⍺<: Compruebe si el tiempo dado es inferior al mínimo o no.

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

La entrada es el camino como Str0y el tiempo como T. Asegúrese de preceder a la carretera con una cita, por ejemplo Str0=?"14========3===.

La salida es 0 si está acelerando, 1 si posiblemente no está acelerando.

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

Ejecutando como (por ejemplo) $ 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"` != -* ]]

Explicación

shopt -s extglob
r=$2

Habilite los operadores de coincidencia de patrones extendidos de bash y asigne el camino a una variable r.

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

Bucle hasta que resté vacío. Conjunto fpara rcon todos los signos de igual eliminan del extremo, utilizando la %% expansión de parámetro y el +()operador globbing extendida.

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

Asigne a suna suma continua de los tiempos mínimos para cada segmento de carretera. Esto puede reescribirse (quizás un poco) de manera más legible como:

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

Básicamente, lo que está sucediendo aquí es que estamos usando una cadena aquí para obtener el dccomando para hacer cálculos matemáticos para nosotros, ya que bash no puede hacer aritmética de punto flotante por sí misma. 9kestablece la precisión para que nuestra división sea de punto flotante e pimprime el resultado cuando hayamos terminado. Es una calculadora de pulido inverso, por lo que lo que realmente estamos calculando se ${f##*=}divide por $[${#r}-${#f}], más nuestra suma actual (o, cuando corremos por primera vez y saún no se ha configurado, nada, lo que nos da un mensaje de advertencia en stderr sobre dc' s pila está vacía, pero todavía imprime el número correcto porque estaríamos sumando a cero de todos modos).

En cuanto a los valores reales que estamos dividiendo: ${f##*=}es fcon la coincidencia de patrón más grande *=eliminada del frente. Dado que fes nuestro camino actual con todas las señales iguales eliminadas del final, esto significa que ${f##*=}es el límite de velocidad para este tramo particular del camino. Por ejemplo, si nuestro camino rfuera '10 ===== 5 === ', entonces fsería '10 ===== 5', y entonces ${f##*=}sería '5'.

$[${#r}-${#f}]es el número de signos iguales al final de nuestro tramo de carretera. ${#r}es la longitud de r; dado fque solo se reliminan todos los signos de igual al final, podemos restar su longitud de la de rpara obtener la longitud de esta sección del camino.

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

Elimine esta sección del límite de velocidad de la carretera desde el final de f, dejando todas las otras secciones de la carretera, y configúrelo r, continuando el bucle para procesar el siguiente tramo de la carretera.

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

Pruebe para ver si el tiempo que tomamos para recorrer el camino (provisto como $1) es menor que el mínimo permitido por el límite de velocidad. Este mínimo, spuede ser un flotador, por lo que recurrimos dcnuevamente para hacer la comparación. dctiene un operador de comparación, pero en realidad su uso terminó siendo 9 bytes más que este, por lo que resto nuestro tiempo de viaje del mínimo y verifico si es negativo comprobando si comienza con un guión. Quizás poco elegante, pero todo es justo en el amor y el codegolf.

Dado que esta comprobación es el último comando en el script, el script también devolverá su valor de retorno: 0 si posiblemente está acelerando, 1 si definitivamente está acelerando:

$ 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

Mi primer código de 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

Pruébalo en línea!

re.split('(=+)',b)[:-1] Divide el camino por trozos de =.

Luego itera sobre el resultado, utilizando try:s=float(c)para establecer el límite de velocidad actual si el elemento actual es un número o except:t+=len(c)/spara agregar el tiempo para atravesar esta sección de la carretera al total acumulado.

Finalmente, devuelve el tiempo necesario al tiempo más rápido posible.

PHP5 207202 bytes

Primer esfuerzo en una respuesta de código de golf, por favor, sé fácil conmigo. Estoy seguro de que uno de ustedes, genios, podrá acortar esto significativamente, cualquier consejo de golf es bienvenido.

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

Invocar con

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

Devuelve verdadero si ha estado por debajo del límite de velocidad, falso de lo contrario

Dyalog APL, 27 bytes

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

'=+'⎕s 1es una función que identifica tramos de '='con una expresión regular y devuelve un vector de sus longitudes ( ⎕sel operando derecho 0 significaría desplazamientos; 1 - longitudes; 2 - índices de expresiones regulares que coinciden)

'='⎕r' 'reemplaza '='s con espacios

⍎'='⎕r' ' lo ejecuta: devuelve un vector de velocidades

÷⍨en el medio divide los dos vectores ( ⍨intercambia los argumentos, por lo que es la distancia dividida por la velocidad)

+/ es suma

hasta ahora todo es un tren de 4 - una función sin un argumento explícito

<∘compone "menos que" delante de esa función; entonces, la función actuará solo en el argumento correcto y su resultado se comparará con el argumento izquierdo

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

Todavía soy nuevo en F #, así que si hice algo extraño o estúpido, avíseme.

Método C # ( 137 122 bytes)

Requiere using System.Linqagregar 19 bytes, incluidos en el 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;

Versión ampliada:

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

La roadcadena se divide en el =personaje. Dependiendo de si una cadena es la matriz resultante está vacía, la función de agregado establece la pacevariable para el segmento (que indica el tiempo que tarda en viajar un solo =) y lo resta del tiempo suministrado. Esto hará demasiadas sustracciones (para el segmento final de la carretera), por lo que en lugar de comparar 0, comparamos con-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])}

Pruébalo en línea!

Retornos TRUEpara valores de velocidad inequívocamente, FALSEpara valores posiblemente sin velocidad .

PowerShell , 71 bytes

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

Pruébalo en línea!

Script de prueba:

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

Salida:

True: False
True: True

Explicación:

1. El script obtiene los elementos del camino 5=====10=====, intercambia elementos, agrega corchetes y operadores+(=====)/5+(=====)/10
2. Luego, el script reemplaza cada uno =con +1:+(+1+1+1+1+1)/5+(+1+1+1+1+1)/10
3. Finalmente, el script evalúa la cadena como una expresión de Powershell y la compara con el primer argumento.