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.

Source: codewars | Difficulty: EASY
Tags: Fundamentals

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):
	return s * 100000 // (60 * 60)


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


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):
	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):
	return int(s * 100000 // 3600)


def cockroach_speed(kph):
	mph = kph * 1000
	cph = mph * 100
	cpm = cph / 60
	cps = cpm / 60
	return int(cps)


def cockroach_speed(s):
	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 int(s * 1000 * 100 / 60 / 60)


from math import floor

def cockroach_speed(speed_km_per_h: float) -> int:
	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 = 0.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(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(27.77777777777778.__mul__(s))


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


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


def cockroach_speed(s):
	return int(s * 27.77777777778)
	print(cockroach_speed(s))


def cockroach_speed(s):
	temp_speed = 0.036
	end_speed = s / temp_speed
	return int(end_speed)


import math

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


import math

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


from math import floor

def cockroach_speed(s):
	x = 27.7777777778
	return floor(s * x)


import math

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


def cockroach_speed(s):
	cm = s * 27.7778
	return round(cm - 0.5)


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


def cockroach_speed(s):
	return int(s * 10 ** 5 / 3600)


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
	return s_new


import math

def cockroach_speed(s):
	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)


def cockroach_speed(s):
	return 1000 * s / 36 // 1


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


from math import floor

def cockroach_speed(s):
	conversion = 1 / 27.7778
	cmPerSec = s / conversion
	return floor(cmPerSec)


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):
	return int(s * 1000.0 / 3600 * 100)


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


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


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)


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


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


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


def cockroach_speed(s):
	result = int(s * (250 / 9))
	return result


cockroach_speed = lambda s: s * 100000 // 3600


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


import math

def cockroach_speed(s):
	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.77777777777778)