皮球下落通过窗户的次数，RGB十数字转换成16进制

素颜马尾好姑娘i 2022-04-14 03:13 148阅读 0赞

A child is playing with a ball on the nth floor of a tall building. The height of this floor, *h*, is known.

He drops the ball out of the window. The ball bounces (for example), to two-thirds of its height (a bounce of 0.66).

His mother looks out of a window 1.5 meters from the ground.

How many times will the mother see the ball pass in front of her window (including when it's falling *and* bouncing?

# Three conditions must be met for a valid experiment: #

*  **Float parameter "h" in meters must be greater than 0**
 *  **Float parameter "bounce" must be greater than 0 and less than 1**
 *  **Float parameter "window" must be less than h.**

**If all three conditions above are fulfilled, return a positive integer, otherwise return -1.**

**Note:** The ball can only be seen if the height of the rebounding ball is stricty greater than the window parameter.

**Example:**

> h = 3, bounce = 0.66, window = 1.5, result is 3
> 
> h = 3, bounce = 1, window = 1.5, result is -1 (Condition 2) not fulfilled).

test.assert_equals(bouncingBall(3, 0.66, 1.5), 3)
    test.assert_equals(bouncingBall(30, 0.66, 1.5), 15)

def bouncingBall(h, bounce, window):
        if h<=0 or bounce<=0 or bounce>=1 or window>=h or window<0:
            return -1
        else:
            count=1
            h=h*bounce
            while(h>window):
                count+=2
                h=h*bounce
        return count

十进制转换成16进制

The rgb() method is incomplete. Complete the method so that passing in RGB decimal values will result in a hexadecimal representation being returned. The valid decimal values for RGB are 0 - 255. Any (r,g,b) argument values that fall out of that range should be rounded to the closest valid value.

The following are examples of expected output values:

rgb(255, 255, 255) # returns FFFFFF
    rgb(255, 255, 300) # returns FFFFFF
    rgb(0,0,0) # returns 000000
    rgb(148, 0, 211) # returns 9400D3

test.assert\_equals(rgb(0,0,0),"000000", "testing zero values")  
test.assert\_equals(rgb(1,2,3),"010203", "testing near zero values")  
test.assert\_equals(rgb(255,255,255), "FFFFFF", "testing max values")  
test.assert\_equals(rgb(254,253,252), "FEFDFC", "testing near max values")  
test.assert\_equals(rgb(-20,275,125), "00FF7D", "testing out of range values")

The following are examples of expected output values:

rgb(255, 255, 255) # returns FFFFFF
    rgb(255, 255, 300) # returns FFFFFF
    rgb(0,0,0) # returns 000000
    rgb(148, 0, 211) # returns 9400D3

def rgb(r, g, b):
        rgb=[r,g,b]
        dic={0:'0',1:'1',2:'2',3:'3',4:'4',5:'5',6:'6',7:'7',8:'8',9:'9',10:'A',11:'B',12:'C',13:'D',14:'E',15:'F'}
        result=''
        for i in rgb:
            if i<0:    result+='00'
            elif i>=255:  result+='FF'
            else:
                result=result+dic[int(i/16)]+dic[i%16]
        return result

def rgb(r, g, b):
        round = lambda x: min(255, max(x, 0))
        return ("{:02X}" * 3).format(round(r), round(g), round(b))

Create a function that takes a Roman numeral as its argument and returns its value as a numeric decimal integer. You don't need to validate the form of the Roman numeral.

Modern Roman numerals are written by expressing each decimal digit of the number to be encoded separately, starting with the leftmost digit and skipping any 0s. So 1990 is rendered "MCMXC" (1000 = M, 900 = CM, 90 = XC) and 2008 is rendered "MMVIII" (2000 = MM, 8 = VIII). The Roman numeral for 1666, "MDCLXVI", uses each letter in descending order.

Example:

solution('XXI') # should return 21

def solution(roman):
        ro = {1000:'M',
                          900: 'CM',
                          500: 'D',
                          400: 'CD',
                          100: 'C',
                          90: 'XC',
                          50: 'L',
                          40: 'XL',
                          10: 'X',
                          9: 'IX',
                          5: 'V',
                          4: 'IV',
                          1: 'I'    }
                          
        keys=list(ro.keys())
        values=list(ro.values())   
        
        ro=dict(map(lambda x,y:[x,y], values,keys))
        result=0
        i=0
        while(i<=len(roman)-2):
            if roman[i]+roman[i+1] in ro:
                result+=ro[roman[i]+roman[i+1]]
                i+=2
            else:
                result+=ro[roman[i]]
                i+=1
        if i==len(roman)-1:
            result+=ro[roman[i]]
        return result