關於算法

面試題

def num():
          return [lambda x: i*x for i in range(4)]
print([m(2) for m in num()])     # 輸出: [6, 6, 6, 6]

思路：

這題涉及到了閉包延時綁定，當循環執行完了以後纔會執行傳參，循環四次，每一次循環完 i=3 而後再和x相乘 因此結果是6，6，6，6。 若是把 [ lambda x: ix for i in range(4) ] 改爲 （ lambda x: ix for i in range(4) ）這樣就變成了一個生成器 自動實現迭代器協議，一邊循環一邊計算的機制， 這樣結果就是 0，2，4，6.

---

兩數之和

給定 nums = [2, 7, 11, 15], target = 9
由於 nums[0] + nums[1] = 2 + 7 = 9
因此返回 [0, 1]

思路：

這裏可使用字典來解題，經過enumerate方法遍歷獲取數據的下標包括對應值，而後以key，value形式把該數據的下標和對應值存入字典，而後再出經過enumerate方法遍歷數據，每一次獲取數據就從字典拿出一個值，用目標值減去從字典拿出的這個值獲得一個結果值，若是結果值存在字典當中，那麼返回兩個數的下標，若是爲None，說明字典中沒有這個值。

實現代碼：

def get_index_list(nums, target):
​
    # Todo 做爲一個方法來實現，批量解決這個獲取索引的問題
    """
   :params nums：傳的參數的列表
   :params target: 目標值
   :return: 返回索引
   """
​
    dic = {}
​
    for a, b in enumerate(nums):  # a是下標 b是對應值
​
        dic[b] = a  # 對應值存入字典
​
    for i, b in enumerate(nums):
​
        j = dic.get(target-b)  # 從字典中拿出對應值 用目標值減去對應值
​
        if j is not None:  # 判斷若是減去的對應值不爲空，則返回下標
​
            return [i, j]

---

數組中重複的數字

示例：

輸入:
[2,3,1,0,2,5,3]
輸出: 2 或 3

思路：

這道題想到的是，使用列表中的count方法，定義一個空列表，遍歷數據而後進行判斷，若是數據值出現個數大於或等於2，說明該數據是重複的，而後把重複的篩取出來以後存入空列表，再進行返回輸出。

實現代碼：

def get_number(nums):
    """
   :params nums：傳的參數的數組
   :return: 返回重複數字
   """
    nub = []
​
    for i in nums:
        if nums.count(i) >= 2:
            if str(i) not in nub:
                nub.append(str(i))
​
    print('或'.join(nub))
​
​
if __name__ == "__main__":
    get_number([2, 3, 1, 0, 2, 5, 3])

隊列實現一個棧

思路：

使用一個隊列，實現棧的一些基本操做，棧（後進先出）的特性。

實現代碼：

# 隊列實現一個棧 （棧：後進先出）
class Stack(object):
​
    def __init__(self):
        # 定義一個隊列
        self.lst = []
​
    def is_None(self):
        # 判斷棧是否爲空 返回 ture false
        return self.lst == []
​
    def push(self, i):
        # 加入元素
        self.lst.append(i)
​
    def pop(self):
        # 出棧
        return self.lst.pop()
​
    def stack_top(self):
        # 返回棧頂元素
        return self.lst[-1]
​
    def size(self):
        # 棧的大小
        return len(self.lst)
​
​
if __name__ == "__main__":
​
    stack = Stack()
    print(stack.is_None())
    stack.push(1)
    stack.push(2)
    stack.push(3)
    print(stack.lst)
    print(stack.pop())
    print(stack.stack_top())
    print(stack.size())
​

---

 

迴文數

判斷一個整數是不是迴文數。迴文數是指正序（從左向右）和倒序（從右向左）讀都是同樣的整數。

示例1：

輸入: 121
輸出: true

示例2：

輸入: -121
輸出: false
解釋: 從左向右，爲 -121 。 從右向左讀，爲121- 。 所以它不是一個迴文數

示例3：

輸入: 10
輸出: false
解釋: 從右向左讀，爲 01 。 所以它不是一個迴文數

思路：

這題可使用字符串 雙指針的方法 將數據轉化爲字符串 首先定義好第一個元素下標和最後一個元素下標，while循環 只要條件不知足 一直循環 循環判斷第一個和最後一個元素是否相等 不相等返回false 相等繼續循環，若是循環條件知足以後都相等，返回 false

實現代碼：

def palindromic_number(x):
​
    """
   :params x：傳的參數的列表
   :return: 返回Ture False
   """
​
    lst = list(str(x))
    print(lst)
    L, R = 0, len(lst)-1
​
    while L <= R:
        print(L, R)
        if lst[L] != lst[R]:
            return False
​
        L += 1
        R -= 1
    return True
​
​
if __name__ == "__main__":
    print(palindromic_number(1231))

---

分別用生成器和迭代器生成斐波那契數列

示例：

輸出: 1 1 2 3 5 8 13

# 使用迭代器生成斐波那契數列
class Fibonacii(object):
    def __init__(self,all_num):
        self.all_num = all_num
        self.cur_idx = 0
        self.a = 0  
        self.b = 1
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.cur_idx >= self.all_num:
            raise StopIteration
        ret = self.a
        
        self.a, self.b = self.b, self.a + self.b
        self.cur_idx += 1
        return ret
 
fibo = Fibonacii(10)
for i in fibo:
    print(i)

# 使用生成器生成斐波那契數列
def fibnacii(count):
    num = 0
    a, b = 0, 1
    while num < count:
        yield a
        a, b = b, a+b
        num += 1
​
​
fi = fibnacii(10)
for i in fi:
    print(i)

反轉字符數組

思路：

直接使用反轉

實現代碼：

# 反轉字符串
def reverseString(s):
    s[0::] = s[::-1]
    print(s)
​
​
if __name__ == "__main__":
    reverseString(['b', '', 'a', 'r'])

---

# 一球從100米高度自由落下，每次落地後反跳回原高度的一半；再落下，求它在第10次落地時，共通過多少米？第10次反彈多高？
# 思路
# 根據題意， 須要計算10次反彈的距離， 因此進行循環10次， 可是第一次他是直接落下去距離爲100米，若是他是第一次落下去就把第一次距離添加到
# 列表中， 由於落下去彈回來是以前距離的一半， 因此須要除以二來計算距離， 知道循環結束， 而後統計10次的總和， 此時height的高度爲第10次的高度

def ballBounce():

    height = 100
    ball_bounce = []
    # num = 0
    # while num < 10:
    #     if num == 0:
    #         ball_bounce.append(height)
    #     else:
    #         ball_bounce.append(height*2)
    #     height = height / 2
    #     num += 1
    # return sum(ball_bounce), height
    for i in range(10):
        if i == 0:
            ball_bounce.append(height)
        else:
            ball_bounce.append(height*2)
        height = height / 2
    print(sum(ball_bounce))
    print(height)


# if __name__ == '__main__':
#     ballBounce()
   # print(ballBounce())

---

# 冒泡排序
def bubbleSort(arr):
    n = len(arr)
    # 遍歷全部數組元素
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

arr = [64, 34, 25, 12, 22, 11, 90]
if __name__ == '__main__':

    bubbleSort(arr)
    print(arr)
    for i in arr:
        print(i)

---

# "Let's take LeetCode contest"
# 輸出: "s'teL ekat edoCteeL tsetnoc"

# 思路
# 先把字符串按照空格切割(字符串切割後變成列表)，把切割後的列表進行反轉   輸出  ['contest', 'LeetCode', 'take', "Let's"]  類型爲list
# 反轉後的列表按照空格進行拼接， 而後進行反轉 輸出  s'teL ekat edoCteeL tsetnoc

s = "Let's take LeetCode contest"
a = s.split(' ')[::-1]
b = ' '.join(a)
c = b[::-1]
print(a)
print(b)
print(c)
#
# def reverseStr(s):
#     return ' '.join(s.split(' ')[::-1])[::-1]
# if __name__ == '__main__':
#     print(reverseStr(s))

​