Python题库

Date：2018-05-08

1、Given: an array containing hashes of names

Return: a string formatted as a list of names separated by commas except for the last two names, which should be separated by an ampersand.

Example:

namelist([ {'name': 'Bart'}, {'name': 'Lisa'}, {'name': 'Maggie'} ])
# returns 'Bart, Lisa & Maggie'

namelist([ {'name': 'Bart'}, {'name': 'Lisa'} ])
# returns 'Bart & Lisa'

namelist([ {'name': 'Bart'} ])
# returns 'Bart'

namelist([])
# returns ''

Best Practices:

def namelist(names):
    if len(names) > 1:
        return '{} & {}'.format(', '.join(name['name'] for name in names[:-1]),
                                names[-1]['name'])
    elif names:
        return names[0]['name']
    else:
        return ''

My solutions:

def namelist(names):
    #your code here
    if len(names) > 1:
        first_name = ', '.join(tmp_name['name'] for tmp_name in names[:-1])
        last_name = names[-1]['name']

        return first_name + ' & ' + last_name
    elif names:
        return names[0]['name']
    else:
        return ''

2、Complete the method/function so that it converts dash/underscore delimited words into camel casing. The first word within the output should be capitalized only if the original word was capitalized.

Examples

to_camel_case("the-stealth-warrior") # returns "theStealthWarrior"

to_camel_case("The_Stealth_Warrior") # returns "TheStealthWarrior"

Best Practices:

def to_camel_case(s):
    return s[0] + s.title().translate(None, "-_")[1:] if s else s

My solutions:

import re
def to_camel_case(text):
    result = ''
    tmp_re = re.split('[-_]',text)

    for i in range(1,len(tmp_re)):
        result += tmp_re[i].capitalize()

    return tmp_re[0] + result

3、In a small town the population is p0 = 1000 at the beginning of a year. The population regularly increases by 2 percent per year and moreover 50 new inhabitants per year come to live in the town. How many years does the town need to see its population greater or equal to p = 1200 inhabitants?

At the end of the first year there will be:

1000 + 1000 * 0.02 + 50 => 1070 inhabitants

At the end of the 2nd year there will be:

1070 + 1070 * 0.02 + 50 => 1141 inhabitants (number of inhabitants is an integer)

At the end of the 3rd year there will be:

1141 + 1141 * 0.02 + 50 => 1213

It will need 3 entire years.

Best Practices:

def nb_year(population, percent, aug, target):
    year = 0
    while population < target:
        population += population * percent / 100. + aug
        year += 1
    return year

My solutions:

def nb_year(p0, percent, aug, p):
    re = p0
    year = 0
    while p0 < p:
        p0 = p0*(1+percent/100) + aug
        year += 1

    return year 

4、You are given an array (which will have a length of at least 3, but could be very large) containing integers. The array is either entirely comprised of odd integers or entirely comprised of even integers except for a single integer N. Write a method that takes the array as an argument and returns this "outlier" N.

Examples

[2, 4, 0, 100, 4, 11, 2602, 36]

Should return: 11 (the only odd number)

[160, 3, 1719, 19, 11, 13, -21]

Should return: 160 (the only even number)

Best Practices:

def find_outlier(integers):
    parity = [n % 2 for n in integers]
    return integers[parity.index(1)] if sum(parity) == 1 else integers[parity.index(0)]

My solutions:

def find_outlier(intergers):
    ji = [x for x in intergers if x%2!=0]
    ou = [x for x in intergers if x%2==0]
    return ji[0] if len(ji)<len(ou) else ou[0]

Date：2018-05-010

1、There is an array with some numbers. All numbers are equal except for one. Try to find it!

findUniq([ 1, 1, 1, 2, 1, 1 ]) === 2

findUniq([ 0, 0, 0.55, 0, 0 ]) === 0.55

Best Practices:

def find_uniq(arr):
    a, b = set(arr)
    return a if arr.count(a) == 1 else b

My solutions:

def find_uniq(arr):
    if arr[0] != arr[1]:
        for i in arr[2:]:
            if i == arr[0]:
                n = arr[1]
            else:
                n = arr[0]
    else:
        for i in arr[2:]:
            if i != arr[0]:
                n = i

    return n

Date：2018-05-16

1、Implement the function unique_in_order which takes as argument a sequence and returns a list of items without any elements with the same value next to each other and preserving the original order of elements.

For example:

unique_in_order('AAAABBBCCDAABBB') == ['A', 'B', 'C', 'D', 'A', 'B']

unique_in_order('ABBCcAD') == ['A', 'B', 'C', 'c', 'A', 'D']

unique_in_order([1,2,2,3,3]) == [1,2,3]

Best Practices:

unique_in_order = lambda l: [z for i, z in enumerate(l) if i == 0 or l[i - 1] != z]

My solutions:

def unique_in_order(iterable):
    result = []
    pre = ''
    for x in iterable[0:]:
        if x != pre:
            result.append(x)
            pre = x
    return result

Date：2018-05-17

1、You probably know the "like" system from Facebook and other pages. People can "like" blog posts, pictures or other items. We want to create the text that should be displayed next to such an item.

Implement a function likes :: [String] -> String, which must take in input array, containing the names of people who like an item. It must return the display text as shown in the examples:

likes [] // must be "no one likes this"

likes ["Peter"] // must be "Peter likes this"

likes ["Jacob", "Alex"] // must be "Jacob and Alex like this"

likes ["Max", "John", "Mark"] // must be "Max, John and Mark like this"

likes ["Alex", "Jacob", "Mark", "Max"] // must be "Alex, Jacob and 2 others like this"

Best Practices:

def likes(names):
    n = len(names)
    return {
        0: 'no one likes this',
        1: '{} likes this',
        2: '{} and {} like this',
        3: '{}, {} and {} like this',
        4: '{}, {} and {others} others like this'
    }[min(4, n)].format(*names[:3], others=n-2)

My solutions:

def likes(names):
    if names:
        if 1 == len(names):
            return names[0] + ' likes this'
        elif 2 == len(names):
            return names[0] + ' and ' + names[1] + ' like this'
        elif 3 == len(names):
            return names[0] + ', ' + names[1] + ' and ' + names[2] + ' like this'
        else:
            l = len(names) - 2
            return names[0] + ', ' + names[1] + ' and ' + str(l) + ' others like this'
    else:
        return  'no one likes this'