Check iO：初學Python

The end of other

For language training our Robots want to learn about suffixes.

In this task, you are given a set of words in lower case. Check whether there is a pair of words, such that one word is the end of another (a suffix of another). For example: {"hi", "hello", "lo"} -- "lo" is the end of "hello", so the result is True.

Hints: For this task you should know how to iterate through set types and string data type functions. Read more about set type here and string functions here.

Input: Words as a set of strings.

Output: True or False, as a boolean.

 

題目大義：給出一個含有單詞的集合（set），如果某個單詞是另一個單詞的后綴，如"lo"是"hello"的后綴，則返回True，如果不存在則返回False。

 

一開始認為set可以使用index，就像數組般使用，可惜了，set並不支持。想想也合理，c++中的set也是不支持[]索引的，於是乎想到了for xx in xx形式，加上提示：str.endswith(suffix[, start[, end]])，恍然大悟，給出拙劣的Python代碼

 

def checkio(words_set):
    for words in words_set:
        for other_words in words_set:
            if other_words != words and other_words.endswith(words):
                return True
    
    return False

 

Common Words

Let's continue examining words. You are given two string with words separated by commas. Try to find what is common between these strings. The words are not repeated in the same string.

Your function should find all of the words that appear in both strings. The result must be represented as a string of words separated by commas in alphabetic order.

Tips: You can easily solve this task with several useful functions:str.split, str.join and sorted. Also try using the built-in type -- set.

Input: Two arguments as strings.

Output: The common words as a string.

 

題目大義：給出兩個字符串，找出在兩個字符串中同時出現的單詞，並按字典序輸出

 

當然使用了str.split方法，然后想到set有in方法，於是乎得到這么一段代碼

def checkio(first, second):
    first_str = first.split(',')
    words_set = set(first_str)
    
    second_str = second.split(',')

    result = []
    
    for each in second_str:
        if each in words_set:
            result.append(each)
        else:
            words_set.add(each)

    result.sort()


    return ','.join(result);

接下來看了別人的解答，發現其實可以把兩個字符串split后，轉化為set，再使用set的intersection方法即可得到相同單詞

 

Absolute sort

Let's try some sorting. Here is an array with the specific rules.

The array (a tuple) has various numbers. You should sort it, but sort it by absolute value in ascending order. For example, the sequence (-20, -5, 10, 15) will be sorted like so: (-5, 10, 15, -20). Your function should return the sorted list or tuple.

Hints: This task can be easily solved using these functions: sorted andabs. You should try to use the key parameter for sorting.

Precondition: The numbers in the array are unique by their absolute values.

Input: An array of numbers , a tuple..

Output: The list or tuple (but not a generator) sorted by absolute values in ascending order.

 

題目大義：按絕對值排序

還是C語言的思路，sorted中傳入cmp函數，如果x < y返回負值，x > y返回正值，x = y返回0

def cmp(numberA, numberB):
    return abs(numberA) - abs(numberB)

def checkio(numbers_array):
    return sorted(numbers_array, cmp)

不過既然用了Python如此高大上的語言，自然要顯擺下，sorted還有一個參數為key，實際上sorted(number_array, key=abs)即可

 

Non-unique Elements

 

You are given a non-empty list of integers (X). For this task, you should return a list consisting of only the non-unique elements in this list. To do so you will need to remove all unique elements (elements which are contained in a given list only once). When solving this task, do not change the order of the list. Example: [1, 2, 3, 1, 3] 1 and 3 non-unique elements and result will be [1, 3, 1, 3].

 

題目大義：將數組中唯一的元素清除

還是C語言的思想，直接粗暴，首先是遍歷求出唯一的元素，再使用數組的remove方法

 

def checkio(data):
    
    only = []

    for each in data:
        count = 0
        for other in data:
            if each == other:
                count += 1

        if count == 1:
            only.append(each)

    for each in only:
        data.remove(each)

    return data

 

當然我們有更高級的方法list = [x for x in data if x.count > 1]，簡單明了，使用了數組的另一種構造方法，使用了數組count方法

 

def checkio(data):
    list = [x for x in data if data.count(x) > 1]
    return list

 

新技能get

The Most Wanted Letter

 

You are given a text, which contains different english letters and punctuation symbols. You should find the most frequent letter in the text. The letter returned must be in lower case.
While checking for the most wanted letter, casing does not matter, so for the purpose of your search, "A" == "a". Make sure you do not count punctuation symbols, digits and whitespaces, only letters.

If you have two or more letters with the same frequency, then return the letter which comes first in the latin alphabet. For example -- "one" contains "o", "n", "e" only once for each, thus we choose "e".

Input: A text for analysis as a string (unicode for py2.7).

Output: The most frequent letter in lower case as a string.

 

題目大義：找出出現次數最多的字母，不區分大小寫，如果出現次數相同，則取字典序最小的輸出

 

一開始想需要諸如'a' : 0，即字母到數字的對應，於是想到dict；查閱str手冊后，發現str.lower方法，將字符串轉換為小寫；最后是對dict的排序，需要先按字母排序，再按出現次序排序（ps：python中的排序是穩定的）

def checkio(text):
    lower_text = text.lower()

    appear_time = {}

    for each in lower_text:
        if each.islower():
            if each not in appear_time:
                appear_time[each] = 0
            else:
                appear_time[each] += 1


    array = appear_time.items();   
    array.sort(key=lambda x:x[0])
    array.sort(key=lambda x:x[1], reverse=True)

    return array[0][0]

不過呢，這是笨方法，沒有充分利用Python的豐富資源，給出大神bryukh的解答

import string
 
def checkio(text):
    """
    We iterate through latyn alphabet and count each letter in the text.
    Then 'max' selects the most frequent letter.
    For the case when we have several equal letter,
    'max' selects the first from they.
    """
    text = text.lower()
    return max(string.ascii_lowercase, key=text.count)

 學藝不精，現在想來key的意思是每個元素的順序由key決定吧，max的第一參數是ascii碼的小寫字母，相當於把26個字母算了個遍

 

Xs and Os Referee

def checkio(game_result):
    winner = 'D'

    for row in game_result:
        if row[0] == row[1] == row[2] and row[0] != '.':
            winner = row[0]

    for col in range(0, 3):
        if game_result[0][col] == game_result[1][col] == game_result[2][col] and game_result[0][col] != '.':
            winner = game_result[0][col]

    if game_result[0][0] == game_result[1][1] == game_result[2][2] and game_result[0][0] != '.':
        winner = game_result[0][0]

    if game_result[0][2] == game_result[1][1] == game_result[2][0] and game_result[0][2] != '.':
        winner = game_result[0][2]

    return winner

此題的結論是python支持形如此等模式的判斷: row[0] == row[1] == row[2], 即支持連等

再來看看大神代碼

 

def checkio(result):
    rows = result
    cols = map(''.join, zip(*rows))
    diags = map(''.join, zip(*[(r[i], r[2 - i]) for i, r in enumerate(rows)]))
    lines = rows + list(cols) + list(diags)
 
    return 'X' if ('XXX' in lines) else 'O' if ('OOO' in lines) else 'D'

 

zip函數可將兩個數組柔和在一起,如學生姓名name = ['bob', 'jenny'], 成績grade = [80, 90], zip(name, grade) = [('bob', 80), ('jenny', 90)], 在函數調用中使用*list/tuple的方式表示將list/tuple分開，作為位置參數傳遞給對應函數（前提是對應函數支持不定個數的位置參數）, 如test = ["XXX", "OOO", "..."], zip(*test) = [('X', 'O', '.'), ('X', 'O', '.'), ('X', 'O', '.')]

map函數接受兩個參數, 第一個為函數名, 第二個為可迭代對象, 如array = [1, 2, 3], map(str, array) = ['1', '2', '3'], 即對第二個對象應用第一函數

 

Speech Module

 

FIRST_TEN = ["one", "two", "three", "four", "five", "six", "seven",
             "eight", "nine"]
SECOND_TEN = ["ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
              "sixteen", "seventeen", "eighteen", "nineteen"]
OTHER_TENS = ["twenty", "thirty", "forty", "fifty", "sixty", "seventy",
              "eighty", "ninety"]
HUNDRED = "hundred"


def checkio(number):
    spoken = []
    
    hundred_bit = number / 100

    if hundred_bit > 0:
        spoken.append(FIRST_TEN[hundred_bit - 1])
        spoken.append(HUNDRED)

    remain = number % 100

    if remain >= 10 and remain <= 19:
        spoken.append(SECOND_TEN[remain % 10])
    else:
        decade = remain / 10
        if decade > 0:
            spoken.append(OTHER_TENS[decade - 2])

        unit = remain % 10
        if unit > 0:
            spoken.append(FIRST_TEN[unit - 1])

    return ' '.join(spoken)

python有個divmod函數, 即可返回商又可返回余數h, number = divmod(number, 100)

可以如此構造字符串 final_string = "%s%s%s" % (hundred_s, decade_s, unit_s)

使用strip去除字符,lstrip, rstrip; rstrip()去除右邊空格

 

The Flat Dictionary

原來的代碼沒處理dict為空的情況

def flatten(dictionary):
    #[] is a list
    #() is a tuple
    stack = [((), dictionary)]

    result = {} #result is a dict

    while stack:
        path, current = stack.pop() #get a tuple

        for k, v in current.items(): #dict::items return key and values tuple
            if isinstance(v, dict): #is a instance of dict
                stack.append((path + (k,), v)) #add key to tuple such as (xxx, yyy, zzz) and the element in stack is like ((xxx, yyy, zzz), value)
            else:
                result["/".join((path + (k,)))] = v

        if len(current) == 0: #when the dict is empty
            result["/".join(path)] = ""

    return result

(k,)一個元素的tuple

 

 Pawn Brotherhood

 

alpha_table = "abcdefgh"

def safe_pawns(pawns):
    safe_count = 0

    for spawn in pawns:
        if spawn[1] == '1':
            continue

        pos = alpha_table.find(spawn[0])
        str_row = str(int(spawn[1]) - 1)

        if pos == 0:
            if (alpha_table[1] + str_row) in pawns:
                safe_count += 1
            continue

        if pos == 7:
            if (alpha_table[6] + str_row) in pawns:
                safe_count += 1
            continue

        if (alpha_table[pos - 1] + str_row) in pawns or (alpha_table[pos + 1] + str_row) in pawns:
            safe_count += 1

    return safe_count

自定義了一個小寫字母表, 找出某字母的前后字母, 如b的(a, c)

另外可以使用chr(ord(pawn[0]) + 1), chr(ord(pawn[0]) - 1)獲得前后字母, ord相當於獲得字母的數碼(如ascii碼), chr是逆過程


 

How to find friends

 

思路簡單,編碼不易

def check_connection(network, first, second):
    link_dictionary = dict()

    for link in network:
        drones = link.split('-')

        link_dictionary.setdefault(drones[0], []).append(drones[1])
        link_dictionary.setdefault(drones[1], []).append(drones[0])

    future = []
    visited = []
    future.append(first)

    while future:
        current = future.pop()
        visited.append(current)

        extend = link_dictionary[current]

        if second in extend:
            return True

        for each in extend:
            if each not in visited:
                future.append(each)

    return False

使用dict存儲每個人的直接關系, 如{lyly : [lala, gege]}; 使用兩個list, 其中一個表示已遍歷過的人, 另一個表示即將遍歷的人;

另外python中的二維數組可以這么定義: connection = [[False for col in range(5)] for row in range(5)], 即一個5*5的數組, 原先嘗試過這么定義error = [[False] * 5] * 5, 發現只要修改了

error[0][0], 那么error[1][0], error[2][0] ...都修改了, 因為[False] * 5產生了一個一維數組, 而外面的*5只是產生了5個引用因此, 無論修改哪一個其余的均會改變.

 

觀摩下大神的代碼

def check_connection(network, first, second):
    setlist = []
    for connection in network:
        s = ab = set(connection.split('-'))
        # unify all set related to a, b
        for t in setlist[:]: # we need to use copy
            if t & ab:       # check t include a, b
                s |= t
                setlist.remove(t)
        setlist.append(s)    # only s include a, b

    return any(set([first, second]) <= s for s in setlist)

將每條關系作為set, 若關系間交集不為空, 則求關系間的並集, 即關系圈;

最后查看first與second是否在某個關系圈中;

充分利用了set的操作, &交, |並, <=子集;

還有第12行的語法特性

 

Roman numerals

羅馬數字的題目, 注意幾個關鍵的數字即可: (100, 400, 500, 900) -> ('C', 'CD', 'D', 'CM'); (10, 40, 50, 90)->('X', 'XL', 'L', 'XC')

 

def checkio(data):
    rel = ''

    thonsand = data / 1000
    rel += thonsand * 'M'

    data %= 1000

    table = [['C', 'CD', 'D', 'CM'], ['X', 'XL', 'L', 'XC']]
    
    pos = 100

    for i in range(0, 2):
        bit = data / pos
        if bit > 0:
            if bit < 4:
                 rel += bit * table[i][0]
            elif bit == 4:
                rel += table[i][1]
            elif bit == 5:
                rel += table[i][2]
            elif bit == 9:
                rel += table[i][3]
            else:
                rel += (table[i][2] + table[i][0] * (bit - 5))

        data %= pos
        pos /= 10

    if data > 0:
         unit = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X']
         rel += unit[data - 1]

    #replace this for solution
    return rel

另外還需注意沒有個位數的情況, 即第30行所示

觀摩JulianNicholls的代碼

elements = { 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' }
              
def checkio(data):
    roman = ''
     
    for n in sorted(elements.keys(), reverse=True):
        while data >= n:
            roman += elements[n]
            data -= n
 
    return roman

  sorted(elements.keys(), reverse=True), 按key從大到小排列; 思路不錯, 比數位對應的值大, 即加上該數位對應的字母, 並減去對應的數值, 直到data為0

 

Min and Max

需要處理不同數據類型; 另外*args, 表示的是位置參數, *kwargs表示的是key參數, args的類型為tuple類型, 參數為min(3, 2)時, args為(3, 2), 參數為min([3, 2])時, args為([3, 2], );

列表解析為[i for i in range(0, 1)], 而(i for i in range(0, 1))為generator, 通過.next()屬性獲取下一個元素, 它不像列表解析一次性生成所有元素, 每次調用next生成一個元素;

 

def min(*args, **kwargs):
    key = kwargs.get("key", None)

    sort_source = args if len(args) > 1 else args[0] #tuple comprehension

    if isinstance(sort_source, set):
        rel = sort_source.pop()
    elif type(sort_source) == type((i for i in range(0, 1))):
        rel = sort_source.next()
    else:
        rel = sort_source[0]

    if key != None:
        for each in sort_source:
            if key(each) < key(rel):
                rel = each
    else:
        for each in sort_source:
            if  each < rel:
                rel = each

    return rel

 

觀摩Cjkjvfnby的代碼

def get_first_from_sorted(args, key, reverse):
    if len(args) == 1:
        args = iter(args[0])
    return sorted(args, key=key, reverse=reverse)[0]
 
 
def min(*args, key=None):
    return get_first_from_sorted(args, key, False)
 
 
def max(*args, key=None):
    return get_first_from_sorted(args, key, True)

無他, 在len(arg) == 1的情況, 仍然需要提取出實際的對象, 如([1, 2], )中的[1, 2]; 高明的地方在於使用了sorted, 省去了自己判斷類型