Q:無序列表，如何去重

ids=[1,2,3,4,3,2,5] 
new_ids=list(set(ids)) 
print(new_ids)

Q:字符串轉為數字，比如 str="1234"，變成 int 1234，并測試這個程序。

def stoi(sr):
    current = 0
    for i in sr:
        sum = ord(i) - ord('0')
        current = current * 10 + sum
    return current

assert type(stoi('1234')) == int
assert stoi('1234') == 1234

Q:99乘法表

for i in range(1, 10):
    for j in range(1, i+1):
        print('{}x{}={}\t'.format(j, i, i*j), end='')
    print()

Q:實現階乘函數

def factorial(num):
    if num <=1:
        return 1
    else:
        return num*factorial(num-1)

Q:算出 100-1000 的質數

質數（prime number）又稱素數，有無限個。質數定義為在大于1的自然數中，除了1和它本身以外不再有其他因數的數稱為質數.

data = []
for i in range(100, 1000):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        data.append(i)

Q:字符串反轉，如果字符串有多個空格也需要處理

ss = 'SJD EJJF EJEF'
ss = re.sub(r'\s', '', ss)
print(ss[::-1])

ss = 'SJD EJJF EJEF'
ss = re.sub(r'\s', '', ss)
a = ''.join(reversed(ss))
print(a)

def rev(str):
    l = list(str)
    newstr = ""
    while len(l) > 0:
        newstr += l.pop()
    return newstr

Q: 找出第一個非重復字符在字符串中的位置

舉例：‘Google’返回l,4

def first_char(string):
    dict1 = {}
    for i in string:
        # 累計字符的出現次數
        if i in dict1:
            dict1[i] += 1
        # 只出現一次，key對應的value就記1次
        else:
            dict1[i] = 1
    for i in range(len(string)):
        if dict1[string[i]] == 1:
            return string[i], i

Q:實現斐波那契數列(?成器方式)

def fib(n):
    if n <= 1:
        return n
    return fib(n-1)+fib(n-2)
for i in range(1, 20):
    print(fib(i), end=',')

Q:字符串中找出連續最長的數字串。

import re
print(max(re.findall(r"\d*", input()), key=len))

def longest_continuous_digits(input_str):
    max_digit = ''
    current_digit = ''
    
    for char in input_str:
        if char.isdigit():
            current_digit += char
        else:
            if len(current_digit) > len(max_digit):
                max_digit = current_digit
            current_digit = ''

    # 檢查最后一個數字串
    if len(current_digit) > len(max_digit):
        max_digit = current_digit

    if max_digit:
        return max_digit
    else:
        return "沒有找到數字串"

Q:leetcode-409. 最長回文串

給定一個包含大寫字母和小寫字母的字符串，找到通過這些字母構造成的最長的回文串。

def cront(s):
  count = collections.Counter(s).values()
  x = sum([item//2*2 for item in count if(item//2>0)])
  return x if x==len(s)else x+1

Q:[-1,1,1,-2,3,-5,-6]?最少的時間、空間，將負數放在左邊、正數放右邊。

def sort_li(li):
    i = 0
    j = len(li) - 1
    while i <= j:
        if li[i] < 0:
            i += 1
        elif li[j] > 0:
            j -= 1
        else:
            li[i], li[j] = li[j], li[i]
    return li

Q: lintcode-144. 交錯正負數

給出一個含有正整數和負整數的數組，重新排列成一個正負數交錯的數組。
解題思路：先將負數放在左邊，正數放在右邊，然后隔一個數進行交換。（需考慮負數多，正數多和正負數一樣多的情況）

def rerange(a):
    if a is None or len(a) == 0:
        return a
    start, end = 0, len(a)-1
    while start < end:
        if a[end] > 0:
            end -= 1
        elif a[start] < 0:
            start += 1
        else:
            a[start], a[end] = a[end], a[start]
    # 計算負數的個數
    if a[start] < 0:
        start += 1
    # 負數更少，兩邊應是正數
    if start < len(a)-start:
        start, end = 0, len(a)-2
    # 正數更少，兩邊應是負數
    elif start > len(a)-start:
        start, end = 1, len(a)-1
    # 正數負數相同
    else:
        start, end = 0, len(a)-1

    while start < end:
        if a[start] > 0 or a[end] < 0:
            break
        a[start], a[end] = a[end], a[start]
        start += 2
        end -= 2

    return a

Q:字符串中最小的整數

class Solution(object):
    def FindMaxinStr(self, s):
        if not s:
            return 0
        result = []
        current = 0
        for c in s:
            num = ord(c) - ord('0')
            if 0 <= num <= 9:
                current = current*10+num
                result.append(current)
            else:
                current = 0
        return min(result)

Q: 劍指 Offer 50. 第一個只出現一次的字符

在字符串s中找出第一個只出現一次的字符。如果沒有，返回一個單空格。 s 只包含小寫字母。

def first(s: str):
    dic = {}
    for c in s:
        dic[c] = c not in dic
    for c in s:
        if dic[c]:
            return c
    return ''

Q:輸?一個字符串然后去掉空格，在統計每個字?出現的次數

from collections import Counter
a = a.replace(' ', '')
b = Counter(a)

def str_count(a):
    a = a.replace(' ', '')
    b = {}
    i = 0
    while i < len(a):
        if a[i] in b:
            b[a[i]] += 1
        else:
            b[a[i]] = 1
        i += 1
    return b

Q：leetcode-88.合并兩個有序數組

給你兩個有序整數數組 nums1 和 nums2，請你將 nums2 合并到 nums1 中，使 nums1 成為一個有序數組。

    n1 = len(nums1)
    n2 = len(nums2)
    k = n1 + n2 - 1
    i = n1 - 1
    j = n2 - 1
    for i in range(n2):
        nums1.append(0)
    while j >= 0:
        if i >= 0 and nums1[i] > nums2[j]:
            nums1[k] = nums1[i]
            i -= 1
        else:
            nums1[k] = nums2[j]
            j -= 1
        k -= 1
    return nums1

Q:leetcode-704. 二分法查找

給定一個 n 個元素有序的（升序）整型數組 nums 和一個目標值 target ，寫一個函數搜索 nums 中的 target，如果目標值存在返回下標，否則返回 -1。

def search(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums) - 1
        while left <= right:
            pivot = left + (right - left) // 2
            if nums[pivot] == target:
                return pivot
            if target < nums[pivot]:
                right = pivot - 1
            else:
                left = pivot + 1
        return -1

Q:leetcode-20. 有效的括號

給定一個只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判斷字符串是否有效。

def isvalid(self, s):
    stack = []
    mapping = {")": "(", "}": "{", "]": "["}
    for char in s:
        if char in mapping:
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:
            stack.append(char)
    return not stack

Q: 劍指Offer-40. 最小的k個數

輸入整數數組 arr ，找出其中最小的 k 個數。例如，輸入4、5、1、6、2、7、3、8這8個數字，則最小的4個數字是1、2、3、4。

def getLeastNumbers(arr: List[int], k: int):
    arr.sort()
    return arr[:k]

時間復雜度：O(n log n),其中 nn 是數組 arr 的長度.算法的時間復雜度即排序的時間復雜度。
空間復雜度：O(log n),排序所需額外的空間復雜度為O(logn)

def getLeastNumbers1(arr:List[int], k: int):
    if k == 0:
        return list()
    hp = [-x for x in arr[:k]]
    heapq.heapify(hp)
    for i in range(k,len(arr)):
        if -hp[0]>arr[i]:
            heapq.heappop(hp)
            heapq.heappush(hp, -arr[i])
    ans = [-x for x in hp]
    return ans

時間復雜度：O(nlogk)，其中 nn 是數組 arr 的長度。由于大根堆實時維護前 k小值，所以插入刪除都是 O(logk) 的時間復雜度，最壞情況下數組里 n 個數都會插入，所以一共需要 O(nlogk) 的時間復雜度。
空間復雜度：O(k)，因為大根堆里最多 k個數。

Q: leetcode-347. 前 K 個高頻元素

class Solution:
    def top(self,nums,k):
        lookup = Counter(nums)
        return [item[0] for item in lookup.most_common(k)]

def topKFrequent(nums, k):
    """
    給定一個非空的整數數組，返回其中出現頻率前 k 高的元素。
    :param nums:
    :param k:
    :return:
    """
    n = len(nums)
    dic = {}
    for i in range(n):
        if nums[i] not in dic:
            dic[nums[i]] = 1
        else:
            dic[nums[i]] += 1

    res = []
    while k > 0:
        tmp = 0
        for num in dic:
            if dic[num] > tmp:
                tmp = dic[num]
                cur = num
        dic[cur] = -1
        res.append(cur)
        k -= 1
    return res

Q:leetcode-560.和為K的子數組

class Solution:
    def subarraySum(self, nums, k: int):
        # num_times 存儲某“前綴和”出現的次數，這里用collections.defaultdict來定義它
        # 如果某前綴不在此字典中，那么它對應的次數為0
        num_times = collections.defaultdict(int)
        num_times[0] = 1  # 先給定一個初始值，代表前綴和為0的出現了一次
        cur_sum = 0  # 記錄到當前位置的前綴和
        res = 0
        for i in range(len(nums)):
            cur_sum += nums[i]  # 計算當前前綴和
            if cur_sum - k in num_times:  # 如果前綴和減去目標值k所得到的值在字典中出現，即當前位置前綴和減去之前某一位的前綴和等于目標值
                res += num_times[cur_sum - k]
            # 下面一句實際上對應兩種情況，一種是某cur_sum之前出現過（直接在原來出現的次數上+1即可），
            # 另一種是某cur_sum沒出現過（理論上應該設為1，但是因為此處用defaultdict存儲，如果cur_sum這個key不存在將返回默認的int，也就是0）
            # 返回0加上1和直接將其置為1是一樣的效果。所以這里統一用一句話包含上述兩種情況
            num_times[cur_sum] += 1
        return res

Q:leetcode-434. 字符串中的單詞數

class Solution:
    def countSegments(self, s):
        return len(s.split())

Q:字母統計并排序, 其中單詞用空格分隔，統計出現最多的3個單詞和它們出現的次數

def func(data):
    # 按空格對字符串進行切割
    data = data.split(' ')
    list_most=collections.Counter(data).most_common(3)
    print(list_most)

Q:快排

def quick_sort(li,start,end):
    if start >= end:
        return
    left = start
    right = end
    mid = li[left]
    while left < right:
        while left < right and li[right] >= mid:
            right -= 1
        li[left] = li[right]
        while left < right and li[left] < mid:
            left += 1
        li[right] = li[left]
    li[left] = mid
    quick_sort(li, start, left-1)
    quick_sort(li, left+1, end)

Q:冒泡排序

def bubble_sort(arr):
    length = len(arr)
    while length > 0:
        for i in range(length-1):
            if arr[i] > arr[i+1]:
                current = arr[i]
                arr[i] = arr[i+1]
                arr[i + 1] = current
        length -= 1