Two tortoises named ***A*** and ***B*** must run a race. ***A*** starts with an average speed of ```720 feet per hour```.
Young ***B*** knows she runs faster than ***A***, and furthermore has not finished her cabbage.

When she starts, at last, she can see that ***A*** has a `70 feet lead` but ***B***'s speed is `850 feet per hour`.
How long will it take ***B*** to catch ***A***?

More generally:
given two speeds `v1` (***A***'s speed, integer > 0) and `v2` (***B***'s speed, integer > 0) and a lead `g` (integer > 0)
how long will it take ***B*** to catch ***A***? 

The result will be an array ```[hour, min, sec]``` which is the time needed in hours, minutes and seconds (round down to the nearest second)
or a string in some languages.

If `v1 >= v2` then return `nil`, `nothing`, `null`, `None` or `{-1, -1, -1}` for C++, C, Go, Nim, `[]` for Kotlin or "-1 -1 -1".

## Examples:
(form of the result depends on the language)
```
race(720, 850, 70) => [0, 32, 18] or "0 32 18"
race(80, 91, 37)   => [3, 21, 49] or "3 21 49"
```

** Note: 

- See other examples in "Your test cases".

- In Fortran - as in any other language - the returned string is not permitted to contain any redundant trailing whitespace: you can use dynamically allocated character strings.

** Hints for people who don't know how to convert to hours, minutes, seconds:

- Tortoises don't care about fractions of seconds

- Think of calculation by hand using only integers (in your code use or simulate integer division)

- or Google: "convert decimal time to hours minutes seconds"

Difficulty: introductory

Starter code:

def race(v1, v2, g):
	

Solutions:
import math

def race(v1, v2, g):
    if v2 < v1: return None
    seconds = 0.1
    while (v1/3600) * seconds + g >= (v2/3600) * seconds:
        seconds += 0.05
    hours = seconds / 3600
    hoursRest = seconds % 3600
    minutes = hoursRest / 60
    seconds = hoursRest % 60
    return [math.floor(hours), math.floor(minutes), math.floor(seconds)]


from datetime import datetime, timedelta

def race(v1, v2, g):
    if v1 >= v2:
        return None
    else:
        sec = timedelta(seconds=int((g*3600/(v2-v1))))
        d = datetime(1,1,1) + sec
        
        return [d.hour, d.minute, d.second]

def race(v1, v2, g):
    if v2 <= v1:
        return None
    total = g / (v2 - v1)
    return [int(total), int(total * 60) % 60, int(total * 3600) % 60]

def race(v1, v2, g):
    if v1 >= v2: return None
    t = float(g)/(v2-v1)*3600
    mn, s = divmod(t, 60)
    h, mn = divmod(mn, 60)
    return [int(h), int(mn), int(s)]

def race(v1, v2, g):
    if v1 < v2:
        sec = g * 60 * 60 // (v2 - v1)
        return [sec // 3600, sec // 60 % 60, sec % 60]

def race(v1, v2, g):
    if v1>=v2:
        return None
    t = g / (v2 - v1) * 60 * 60
    return [int(t // 3600), 
            int((t // 60) % 60), 
            int(t % 60)]

def race(v1, v2, g):
    if v1 < v2:
        a = g * 3600 // (v2 - v1)
        return [a // 3600, a // 60 % 60, a % 60]