The cockroach is one of the fastest insects. Write a function which takes its speed in km per hour and returns it in cm per second, rounded down to the integer (= floored).

For example:

```python
cockroach_speed(1.08) == 30
```

Note! The input is a Real number (actual type is language dependent) and is >= 0. The result should be an Integer.

Difficulty: introductory

Starter code:

def cockroach_speed(s):
	

Solutions:
def cockroach_speed(s):
    return s // 0.036

def cockroach_speed(s):
    cm_per_km = 100000
    sec_per_hour = 3600
    return int(s * cm_per_km / sec_per_hour)

def cockroach_speed(s):
    cm_per_km = 100000
    sec_per_hour = 3600
    return s * cm_per_km // sec_per_hour


def cockroach_speed(s):
    return (s * 100000) // (60 * 60) 

def cockroach_speed(s):
    return int(s * 27.7778)
    # Good Luck!


ONE_KM_IN_METERS = 1000
ONE_METER_IN_CM = 100
ONE_HOUR_IN_MINUTES = 60
ONE_MINUTE_IN_SECONDS = 60

def cockroach_speed(s):
    cm = ONE_KM_IN_METERS * ONE_METER_IN_CM
    sec = ONE_HOUR_IN_MINUTES * ONE_MINUTE_IN_SECONDS
    return int((s * cm) / sec)


import math
def cockroach_speed(s):
    # Good Luck!
    cm = s*1000*100 / 3600
    return math.floor(cm)

import math
def cockroach_speed(s):
    return math.floor(s*100000/3600)

import math
def cockroach_speed(s):
    return math.floor(s * 27.778)

cockroach_speed = lambda s: int(27.7778*s)

def cockroach_speed(s):
    return int(s * (30/1.08))

def cockroach_speed(s):
  return int(27.78 * s)

import math
def cockroach_speed(s):
    return math.floor(((s*10000)/3600)*10)

def cockroach_speed(s):
    '''
    (number) -> int
    s is the number of kilometers that the cockroach travels per hour. 
    Return the equivalent integer(rounded down) of centimeters per second.
    '''
    #convert kilometer(per hour) to centimeters(per hour)
    #convert centimeters(per hour) to centimeters(per second)
    #convert the final result as an integer.
    return int((s * 100000) // 3600)
    


def cockroach_speed(kph):
    # 1000 m in km
    mph = kph * 1000
    # 100 cm in m
    cph = mph * 100
    # 60 min in hour
    cpm = cph / 60
    # 60 sec in min
    cps = cpm / 60
    return int(cps)

# I'm just tired of oneliners =)


def cockroach_speed(s):
    '''
    (int) -> int
    
    preconditions: input is real number >= 0
    
    takes speed in km per hour as input and returns it in cm per second        
    '''
    return int(s * 1000/36)

from math import floor

def cockroach_speed(s):
    return floor(s * 250 / 9)

import math

def cockroach_speed(s):
    return math.floor(s * 1000 / 36)

import math
def cockroach_speed(s):
    return (math.floor(s*27.7778))

def cockroach_speed(s):
    return s * 100000 // 3600

def cockroach_speed(s):
    return int(((s*1000)*100/60)/60)

def cockroach_speed(s):
    return int(s / 0.036)

def cockroach_speed(s):
    return round(s // 0.036)

from math import floor

def cockroach_speed(speed_km_per_h: float) -> int:
    """ Get a speed of the cockroach in cm/s based on its speed in km/h. """
    return floor(speed_km_per_h * (100000/3600))

def cockroach_speed(s):
    return s * 250 // 9

cockroach_speed = lambda x: x/0.036//1

cockroach_speed = lambda s: s * 27.778 // 1

cockroach_speed=.036 .__rfloordiv__

def cockroach_speed(s):
    return 10 ** 5 * s // 60 ** 2

cockroach_speed = lambda s: 10 ** 3 * s // 36

import math
def cockroach_speed(s):
    return math.floor(s * (30/1.08))

def cockroach_speed(s):
    return s * 100_000 // 3600

def cockroach_speed(speed):
    ratio = 27.7778
    return speed * ratio // 1

def cockroach_speed(s):
    return s*5//0.18

def cockroach_speed(s):
    return s*1000/6//6

cockroach_speed = lambda s: __import__('math').floor(s*1000*100/60/60)

cockroach_speed=lambda x:__import__('math').floor(x*(30/1.08))

#cockroach_speed=lambda s:int(s*27.77777777777778)
cockroach_speed = lambda s:int(27.77777777777778.__mul__(s))

def cockroach_speed(km_per_h):
    return(km_per_h * (1000 * 100) // (60 * 60))

def cockroach_speed(s):
    return ((s * 100 * 1000) / 60) // 60

def cockroach_speed(s):
    import math as  m
    a=s*(1000*100)/3600
    return(int(m.floor(a)))

import math
def cockroach_speed(s):
    newSpd=s*27.778
    newSpd = math.floor(newSpd)
    return newSpd

def cockroach_speed(s):
    # Good Luck!
    return int(s*27.77777777778)
    print(cockroach_speed(s))

def cockroach_speed(s):
    temp_speed = 0.036 #1 sm/sec = 0.036 km/h
    end_speed = s / temp_speed
    return int(end_speed)

import math
def cockroach_speed(s):
    speed=math.floor(s*27.77777778)
    return speed

def cockroach_speed(s):
    import math
    a = 27.778 * s
    a = math.floor(a)
    return a

import math 
def cockroach_speed(s):
    a = s * 1000 * 100 / 60 /60
    b = math.floor(a)
    return b 

import math


def cockroach_speed(s):
    s_cm = s * 27.778
    return math.floor(s_cm)

from math import floor
def cockroach_speed(s):
    x = 27.7777777778 #1 km per hour converted to cm per second
    return floor(s * x)

import math

def cockroach_speed(s):
    return math.floor(s*27.777777777777777)

def cockroach_speed(s):
    cm = s*27.7778
    return round(cm-0.5)
    # Good Luck!



import math 

def cockroach_speed(s):
    
    speed = s * 27.777778
    
    return math.floor(speed)


def cockroach_speed(s):
    new_s = 27.7777778 * s
    new_s = int(new_s)
    return new_s
    
    
    # Good Luck!


def cockroach_speed(s):
    # 1.08 km ... 3600
     # x ......... 1 s
     #   x=108000 cm
       return int(s*(10**5) / 3600)

def cockroach_speed(s):
    # converts velocity from km/h to cm / s
    return int(s / 0.036)

def cockroach_speed(s):
    return int(5*s*100/18)


def cockroach_speed(s):
    x = s / 60 / 60 *100000
    return int(x)

import math

def cockroach_speed(s):
    
    cm = s *27.77778

    return math.floor(cm)


def cockroach_speed(s):
    return int(s*1000000/36000)

def cockroach_speed(s):
    import math
    if s == 0:
        return 0
    else:
        meter_per_sec = s / 3.6
        cm_per_sec = meter_per_sec * 100
        return math.floor(cm_per_sec)

def cockroach_speed(s):
    s_new = ((250 / 9) * s ) // 1 # Convertion into cm/s floored
    return s_new

import math
def cockroach_speed(s):
    # Good Luck!
    p = s * 10000 / 360 
    p = math.floor(p)
    return p

from math import ceil
def cockroach_speed(s):
    y = ceil(int(s*100000/3600))
    return y


import math

def cockroach_speed(s):
    metri = s * 27.7777778
    return math.floor(metri)


def cockroach_speed(s):
    cmps = 3600
    kmph = 100000
    cms = s * kmph / cmps 
    
    return int(cms)


import math
def cockroach_speed(s):
    s = s*27.777778
    return math.floor(s)

def cockroach_speed(s):
    # 1 km = 1,000m = 100,000 cm
    # 1 hr = 3600 s
    # 1 km/hr = 1000/36 cm/s
    
    return (1000*s/36)//1

def cockroach_speed(s): return int(s*(27+7/9))

import math
def cockroach_speed(s):
    cms = (s / 3600) * 100000
    return(math.floor(cms))

from math import floor

def cockroach_speed(s):
    # Good Luck!
    conversion = 1/27.7778
    cmPerSec = s/conversion
    return floor(cmPerSec)

def cockroach_speed(s):
    x = (s*1000*100/(60*60))
    x = int(x)
    return x
    # Good Luck!


import math
def cockroach_speed(s):
    a = math.floor(s*27.778)
    return(a)

import math
def cockroach_speed(s):
    converted_speed = (s * 100000)/(3600)
    return math.floor(converted_speed)


import math

def cockroach_speed(s):
    to_minutes =s/60
    to_secs = to_minutes/60
    return math.floor(to_secs*100000)


def cockroach_speed(s):
    cm_s=s*100000/3600
    return int(cm_s)


def cockroach_speed(s):
    
    result = (s*100000)/3600
    return int (result)

def cockroach_speed(s):
    return int((s*1000.0)/3600*100)

#import math 
def cockroach_speed(s):
    # Good Luck!
    return (s//(0.036))

def cockroach_speed(s):
    
    s = int(s*10000/360) 
    return s


from math import floor
def cockroach_speed(s):
    return floor((s/36)*1_000)

def cockroach_speed(speed):
    from math import floor
    speed = floor((speed/3600)*100000)
    return speed
    
    # Good Luck!


import math
def cockroach_speed(s):
    temp = (s * 1000 * 100) / 3600
    result = math.floor(temp)
    return result

import math

def cockroach_speed(s):
    seconds = 60*60
    cm = 1000*100
    new_speed = s * cm / seconds
    return math.floor(new_speed)

import math
def cockroach_speed(s):
    value = s * 27.7778
    return math.floor(value)

def cockroach_speed(speed):
    a = speed/0.036
    return int(a)

def cockroach_speed(s):
    try:
        return ((100000 / 3600) * s) // 1
    except:
        return 0

from math import floor

def cockroach_speed(s):
    speed_cm = floor(s*27.7777778)
    return speed_cm

from math import floor
def cockroach_speed(s):
    speed = s * 100000
    return floor(speed / 3600)

cockroach_speed = lambda s: int(100000*s/3600)

import math
def cockroach_speed(s):
    val=0
    val=math.floor(s*10**5/3600)
    return(val)
    # Good Luck!


def cockroach_speed(s):
    speed = float(s) / 360 * 10000
    return int(speed)

import math
def cockroach_speed(s):
    speed = math.floor(s * 27.77777777778)
    
    return (speed)

import math
def cockroach_speed(s):
    result = math.floor(s * 1000 / 36)
    return result


def cockroach_speed(s):
    # Good Luck!
     result=int(s*(250/9))
     return result

cockroach_speed = lambda s: s * 100_000 // 3_600

def cockroach_speed(s):
    # Cockroaches just seem fast because time slows when they fly toward you...
    return (int(s * 100000 / 3600))

def cockroach_speed(s):
    if s<=0:
        return 0
    else:
        return int(s*(100000/3600))
    # Good Luck!


import math
def cockroach_speed(s):
    
    # Good Luck!
    cm = 100000
    sec = 3600
    s = math.floor(s*(cm/sec))
    return s               


def cockroach_speed(s):
    import math
    conversion = (1000 * 100)/(60*60)
    speed = math.floor(s*conversion)
    return speed

def cockroach_speed(s):
    return int(s*27.777777777777777777777777)
#pogchamp


import math
def cockroach_speed(s):
    
    s = s * 100_000 / 3600
    return math.floor(s)