Bob needs a fast way to calculate the volume of a cuboid with three values: `length`, `width` and the `height` of the cuboid. Write a function to help Bob with this calculation.

```if:shell
In bash the script is ran with the following 3 arguments:
`length` `width` `height`
```

Difficulty: introductory

Starter code:

def getVolumeOfCubiod(length, width, height):
	

Solutions:
def get_volume_of_cuboid(length, width, height):
    return length * width * height


# PEP8: kata function name should use snake_case not mixedCase
getVolumeOfCubiod = get_volume_of_cuboid

def getVolumeOfCubiod(l, w, h):
    return l * w * h

def getVolumeOfCubiod(length, width, height):
    return length * width *height

getVolumeOfCubiod = lambda l,w,d : l*w*d


def getVolumeOfCubiod(length, width, height):
    return width*length*height

def getVolumeOfCubiod(l, w, h):
    return l * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h / w / h * w * h

getVolumeOfCubiod=lambda l,w,h:l*w*h

def getVolumeOfCubiod(a, b, H): return a*b*H

def getVolumeOfCubiod(length: int, width: int, height: int) -> int:
    """ Get the volume of the cuboid. """
    return length * width * height

getVolumeOfCubiod = lambda l, w, h: l * w * h

# def getVolumeOfCubiod(l, w, h):
#     return l * w * h


#!/usr/bin/env python3.6

def get_volume_of_cuboid(length, width, height):
    return length * width * height
    
getVolumeOfCubiod = get_volume_of_cuboid

def getVolumeOfCubiod(length, width, height):
    a = length
    b = width
    c = height
    return a * b * c

def getVolumeOfCubiod(a1, a2, a3):
    return a1*a2*a3

def getVolumeOfCubiod(length, width, height):
    vol = length*width*height
    return vol 


getVolumeOfCubiod = lambda length, width, height: length*width*height

def getVolumeOfCubiod(x,y,z):
    return x*y*z

def getVolumeOfCubiod(length, width, height):
    volume = length * width * height
    return volume

getVolumeOfCubiod = lambda a, b, c: a * b * c

def getVolumeOfCubiod(length, width, height):
    return length * width * height

print(getVolumeOfCubiod(3,2,1))

def getVolumeOfCubiod(length, width, height):
    return float(length) * int(width) * int(height)


def getVolumeOfCubiod(l, w, h):
    
    n = (l*w*h)
    return n

def getVolumeOfCubiod(length, width, height):
    # Code goes here...
    if length and width and height > 0:
        return length * width * height

from numpy import prod
def getVolumeOfCubiod(*a):
    return prod(a)

# Note: Cuboid was misspelled and camelCased in problem statement, tests, and
# required function signature.

import functools
import operator

def getVolumeOfCubiod(*dimensions):
    """Compute volume to an arbitrary dimension :)."""
    return functools.reduce(operator.mul, dimensions, 1)

from functools import reduce

getVolumeOfCubiod = lambda l,w,h: reduce(lambda x,y:x*y, [l,w,h])

getVolumeOfCubiod = lambda *d: ( (lambda ft, op: ft.reduce(op.mul, d)) (*[__import__(q) for q in ['functools', 'operator']]) )

getVolumeOfCubiod = lambda *d: ( (lambda ft, op: ft.reduce(op.mul, d))  (__import__('functools'), __import__('operator')))

def getVolumeOfCubiod(length, width, height):
    '''
    input: ints or floats (length, width, height)
    return: int or float => representing volume of cube
    '''
    return length*width*height


from functools import reduce

getVolumeOfCubiod = lambda *dimensions: reduce(lambda x,y: x*y, dimensions)

def getVolumeOfCubiod(a, aa, aaa):
    return a*aa*aaa

def getVolumeOfCubiod(length, width, height):
    result = (float(length) * float(width) * float(height))
    if float.is_integer(result) is True:  # Checking to see if I can convert the return a int
        return int(result)  # Returning int becuase it is possible
    else:
        return result  # Returning a float because the value isn't a whole number



from functools import reduce
from operator import mul
def getVolumeOfCubiod(*n):
    return reduce(mul, n)


from operator import mul
from functools import reduce, partial

def getVolumeOfCubiod(*args):
    return partial(reduce, mul)(args)

import numpy
getVolumeOfCubiod = lambda *p : numpy.prod(p)

def getVolumeOfCubiod(length, width, height):
     vol=length*width*height
     return vol
vol=getVolumeOfCubiod(2, 3, 4)
print(vol)


getVolumeOfCubiod = lambda _,__,___: _*__*___

def getVolumeOfCubiod(ln, wd, hg):
    return ln * wd * hg

def getVolumeOfCubiod(length, width, height):
    return length*width*height
#pogchamp


getVolumeOfCubiod = lambda a,b,h: a*b*h

def getVolumeOfCubiod(length,
                      width,
                      height):

    return length * width * height


import numpy as np
def getVolumeOfCubiod(length, width, height):
    return np.prod([length, width, height])

from numpy import prod
def getVolumeOfCubiod(*s):
    return prod(s)

def getVolumeOfCubiod(length: int, width: int, height: int) -> float:
    return length * width * height

from functools import reduce
def getVolumeOfCubiod(*a):
    return reduce(lambda accum, next_item: accum * next_item, a)

# INVINCIBLE WARRIORS --- PARZIVAL

def getVolumeOfCubiod(length, width, height):
    return length * width * height

import math
def getVolumeOfCubiod(length, width, height):
    return length*width*height

def getVolumeOfCubiod(length, width, height):
    ergebnis = length * width * height 
    return ergebnis

print(getVolumeOfCubiod(1, 2, 2,))
print(getVolumeOfCubiod(6.3, 2, 5))

def getVolumeOfCubiod(*args):
    return args[0]*args[1]*args[2]

import numpy

def getVolumeOfCubiod(length, width, height):
    return numpy.prod([length, width, height])

def getVolumeOfCubiod(len, wi, he):
    return len * wi * he

def getVolumeOfCubiod(length, width, height):
    cub = Cubiod(length, width, height)
    return cub.getVolume()



class Cubiod:
    
    def __init__ (self, length, width, height):
        self.length = length
        self.width = width
        self.height = height
    
    def getVolume(self):
        return self.length * self.width * self.height
    
    def getSA(self):
        return (self.length * self.height * 2) + (self.length * self.width * 2) + (self.height * self.width * 2)
    
    def speedProb(self):
        return 9.87 * min(self.length, self.width, self.height)
        
    def damage(self):
        return self.getVolume() * 1900 * self.speedProb()
        
    def velocity(self):
        return self.speedProb() ** 2
    
    def crimeLevel(self):
        return self.velocity() * self.damage() + self.getSA()

def getVolumeOfCubiod(length, width, height):
    return eval(f"{length}*{width}*{height}")

def getVolumeOfCubiod(length, width, height):
    r = (length * width * height)
    return r

def getVolumeOfCubiod(length, width, height):
    length= float (length)
    width= float (width)
    height= float (height)
    volumen= ((length * width) * height)
    return (volumen)

def getVolumeOfCubiod(length, width, height):
    var = lambda x, y, z: x*y*z
    return var(length, width, height)

def getVolumeOfCubiod(length, width, height):
    return (length*width*height)
x = getVolumeOfCubiod(6.3, 2, 5)
print(x)

def getVolumeOfCubiod(d, w, h):
    return(w * d * h)

from functools import reduce
from operator import mul

getVolumeOfCubiod = lambda *ns: reduce(mul, ns)

def getVolumeOfCubiod(length, width, height):
    
    # =============================================================================
    #     This function calculates the volume of a cuboid with three values: 
    #     length, width and the height of the cuboid
    #     
    #     Example:
    #         
    #         getVolumeOfCubiod(1, 2, 2) ==> 4
    # =============================================================================
        
    return(length * width * height)

def getVolumeOfCubiod(l, w, h):
    x = lambda l, w, h: l*w*h
    return (x(l,w,h))

def getVolumeOfCubiod(length, width, height):
    return (length*width*height)
    
 # from Russia with love


def getVolumeOfCubiod(length, width, height):
    # Why is the percentage clear rate so low for this?
    return length * width * height

def getVolumeOfCubiod(l, w, h):
   a = l*w*h
   return a


def getVolumeOfCubiod(length, width, height):
    # volume of a cuboid: V=a⋅b⋅c 
    return length * width * height

def getVolumeOfCubiod(length, width, height):
    """Return volume of cuboid"""
    return length * width * height

from functools import reduce
from operator import mul

def getVolumeOfCubiod(*a):
    return reduce(mul, a, 1)


def getVolumeOfCubiod(length, width, height):
    a = length * width
    b = a * height
    return b

def getVolumeOfCubiod(length, width, height):
    x=length*width
    return x*height

def getVolumeOfCubiod(length, width, height):
    # Code goes here...
    return(length * width * height)
getVolumeOfCubiod(3, 4, 8)

def getVolumeOfCubiod(length, width, height):
    return length * width * height
    # Code goes here...! I will put the code where I want.


def getVolumeOfCubiod(length, width, height):
     p = lambda l,w,h : l * w * h
     return p(length,width,height)

def getVolumeOfCubiod(length, width, height):
    
    volume= height*width*length
    return volume

def getVolumeOfCubiod(length, width, height):
    if length > 0 and width > 0 and height > 0:
        return length * width * height
    else:
        return False

def getVolumeOfCubiod(length, width, height):
    volume_of_cuboid = length*width*height
    return volume_of_cuboid

def getVolumeOfCubiod(length, width, height):
    VolumeOfCubiod = length * width * height
    return VolumeOfCubiod

def getVolumeOfCubiod(length, width, height):
      f=length*width*height
      return f

def getVolumeOfCubiod(length, width, height):
    # Code goes here...
    return length * width * height
    
    
getVolumeOfCubiod(10,15,17)

getVolumeOfCubiod = lambda l, w, h: l * h * w


def getVolumeOfCubiod(leng, wid, hei):
    return leng*wid*hei

from numpy import prod
def getVolumeOfCubiod(*args):
    return prod(args)

def getVolumeOfCubiod(length, width, height):
    # Code goes here...
    return length*width*height
print(getVolumeOfCubiod(6.3,5,2))

getVolumeOfCubiod = lambda *a: a[0]*a[1]*a[2]

''' 
    Volume = lwh
'''

def getVolumeOfCubiod(length, width, height):
    return length * width * height


def getVolumeOfCubiod(length, width, height):
    # Code goes here...
    CubiodVolume=length*width*height
    return (CubiodVolume)

def getVolumeOfCubiod(h, l , w):
    return h*l*w

def getVolumeOfCubiod(l, w, h):
    return (w * h) * l


def getVolumeOfCubiod(length, width, height):
   length * width * height 
   return  length * width * height 

def getVolumeOfCubiod(length, width, height):
    """___"""
    return length*width*height

def getVolumeOfCubiod(length, width, height):
    length*height*width
    return length*height*width

''' 
    Volume = lwh
'''

'''
lenght = int(input('Qual é o comprimento?'))
width = int(input('Qual é a largura?'))
height = int(input('Qual é o altura?'))

'''

def getVolumeOfCubiod(length, width, height):
    return length * width * height


def getVolumeOfCubiod(length, width, height):
    val = (length * width * height)
    return (val)

def getVolumeOfCubiod(length, width, height):
    result =length*width*height
    return result
    
getVolumeOfCubiod(2,2,2)

def getVolumeOfCubiod(length, width, height):
    # Code goes here
    return length*width*height

def getVolumeOfCubiod(length, width, height):
    a = length
    b = width
    c = height
    volume = (a*b*c)
    return volume

def getVolumeOfCubiod(length, width, height):
    cuboid = length * width * height
    return(cuboid)

def getVolumeOfCubiod(length, width, height):
    volume = length*width*height
    return volume
    
length,width,height = 1,2,2
print((getVolumeOfCubiod(length, width, height)))
    # Code goes here...