碼上歡樂
相關內容    簡體    繁體

蘇州大學2005-2019復試上機真題及保研期中期末習題

本文轉載自   查看原文   2020-05-26 14:05   713    language：Python

目錄

可以我的GitHub上直接下載： https://github.com/douzujun/Python-Foundation-Suda

上機常用代碼

(1) 輸入代碼

(2) 矩陣乘法 (np.dot(A, B))

def matrixMul(A, B):
    if len(A[0]) == len(B):  # A列數=B行數
        res = [[0] * len(B[0]) for i in range(len(A))]  # 生成 A行 x B列 的0矩陣
        for i in range(len(A)):
            for j in range(len(B[0])):
                for k in range(len(B)):
                    res[i][j] += A[i][k] * B[k][j]
        return res
    return ("輸入矩陣有誤!")
    
matrixMul(mat1, mat2)
Out[13]: [[19, 22], [43, 50]]
    
mat1
Out[14]: [[1, 2], [3, 4]]

mat2
Out[15]: [[5, 6], [7, 8]]

(2.2) 矩陣轉置

matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]

list(zip(*matrix))
Out[34]: [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
    
matrix
Out[42]: [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

[[row[i] for row in matrix] for i in range(4)]
Out[43]: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

(2.3) 獲得矩陣對角線元素

(1) 從左下向右上的對角線

B = [[0]*m for i in range(2*m-1)]
row = 2*m - 1

dic = collections.defaultdict(list)
for i,j in itertools.product(range(m), range(m)):
    dic[i - j].append(A[m-i-1][j])
    
# 法2
def nextitem():
    for j in range(2*m-1):
        j = 0
        while 0 <= i < m or 0 <= j < m:
            if 0<=i<m and 0<=j<m:
                yield A[i][j]
             i -= 1
             j += 1

nextnum = nextitem()
cur = 1
for i in range(2*m-1):
    for j in range(cur):
        B[i].append(next(nextnum))
	B[i].extend([0]*(m-cur))
	if i < m - 1:
        cur += 1
    else:
        cur -= 1
return B

(2) 從左上向右下的對角線

B = [[0]*m for i in range(2*m-1)]
row = 2*m - 1

dic = collections.defaultdict(list)
for i,j in itertools.product(range(m), range(m)):
    dic[i - j].append(A[i][j])
    
# 法2
m, n = len(mat), len(mat[0])
tmp = []
for line in range(m+n-1):
    i, j = m-1-line, 0
    tmp.clear()
    while j < n:
        if 0 <= i < m and 0 <= j < n:
            tmp.append(mat[i][j])
            i += 1
            j += 1
            print(tmp)

(3) 生成 nxn 的 空矩陣

# 生成 nxn 的 空矩陣
res = [[] for i in range(0, n)]

(4) 字典排序

# 按value排序(降序)，如果value相同則按key排序(字典序升序)
freq = sorted(freq.items(), key=lambda x:(-x[1], x[0]))

(5) 統計列表中所有元素出現的頻率

from collections import Counter

a = "i love love you you"

dict( Counter(list(a.split())) )

Out[103]: {'i': 1, 'love': 2, 'you': 2}

或者：

from collections import defaultdict
frequences = defaultdict(int)
print(frequences)
Out[37]: defaultdict(int, {})

for e in a.split():
    frequences[e] += 1
    
frequences
Out[39]: defaultdict(int, {'i': 1, 'love': 2, 'you': 2})
    
s + t - s
Out[112]: Counter({'c': 1, 'b': 2, 'a': 1, 'd': 1})
list((s + t - s).elements())
Out[115]: ['c', 'b', 'b', 'a', 'd']

(6) list和set相互轉換

set([1,2,3,4,4,5,5])
{1,2,3,4,5}
list(set([1,2,3,4,5,5]))
[1,2,3,4,5]

(7) 列表轉整數

a = [1,2,3]

int("".join(list(map(str, a))))
Out[109]: 123

(8) 數字字符串 轉整數

int('0e00', 16)    # 按照16進制轉換成10進制
int('001', 2)      # 按照二進制方式轉換成10進制
int('012', 8)      # 按照八進制方式轉換成10進制

img

(9) 讀取二進制文件

def main():
    res = [random.randrange(0, 9999, 1) for i in range(0, 32)]
#    print(res)
    
#    with open('./file/2010.txt', 'rb+') as f:
#        for i in res:
#            s = struct.pack('i', i)
#            f.write(s)
    
    # 寫多少數據，一定要弄清楚
    len1 = len(res)
    nums = []
    with open('./file/2010.txt', 'rb+') as f:
        for i in range(len1):
            data = f.read(4)
            elem = struct.unpack('i', data)[0]
            nums.append(elem)
   
    # 按照 16進制 轉換成 10進制        
    nums.sort(reverse=True)
    
    print("數據:", nums)

(9.1) 讀二進制文件

def read_data():
    data = []
    with open('./file/file_2017_2.txt', 'rb') as f:
        num = f.read(4)
        while num:
            data.append(int.from_bytes(num, byteorder='little'))
            num = f.read(4)
    return data

(10) 判斷素數 和 埃氏篩選法

def is_prime(num):
    if num < 2:
        return False    
    top = int(math.sqrt(num))
    i = 2
    while i <= top:
        if num % i == 0:
            return False
        i = i + 1        
    return True

# 埃氏篩選法
def judge():
    n = int(input())
    res = 0
    
    is_prime = [True]*(n+1)
    is_prime[0] = is_prime[1] = True
       
    # 篩選出所有素數 
    primes = []
    for i in range(2, n+1):
        if is_prime[i]:
            primes.append(i)
            j = 2*i
            while j <= n:             # 將 i 的倍數全部划去
                is_prime[j] = False
                j += i         
    
    for i in range(2, n - 1):
        if is_prime[i] and is_prime[i+2]:
            res += 1
    print(res)

judge()

(11) 最大公約數

def gcd(num1, num2):
    if num1 < num2:
        num1, num2 = num2, num1
    
    while (num1 % num2):
        temp = num1 % num2
        num1 = num2
        num2 = temp
        
    return num2

(12) format格式化輸出

    for i in range(0, wlen):
        print('{0:8}'.format(ascii_words[i]), end='')
        if (i+1) % 10 == 0:
            print('')

img

img

(13) 全排序

def permute(L):
    if not L:
        return [L]
    else:
        res = []
        for i in range(len(L)):
            # 任一元素 + 剩余n-1個元素的全排序
            rest = L[:i] + L[i+1:]
            for x in permute(rest):
                res.append(L[i:i+1] + x)
        return res
        

permute([1,2,3])
Out[9]: [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

或者：

def perm(L, cur):
    if cur == 3:
        print(L)
        return
    for i in range(1, 4):
        if not vis[i]:
            L[cur] = i
            vis[i] = True
            perm(L, cur + 1)
            vis[i] = False            
            

L = [0 for i in range(0, 3)]
vis = [0 for i in range(0,10)]
            
perm(L, 0)
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]

(13) 插入排序

# -*- coding: utf-8 -*-
import random

# 找插入位置，使L仍保持升序
def find_insert_index(L, t):
    for i, x in enumerate(L):
        if x > t:
            return i
    return len(L)

A = [random.randint(0, 100) for i in range(10)]
print(A)
L = []
for x in A:
    i = find_insert_index(L, x)
    L.insert(i, x)
print(L)

(14) 刪除list里面的重復元素 (位置不變)

l1 = ['b','c','d','c','a','a']
l2 = sorted(set(l1),key=l1.index)
print(l2)

l1 = ['b','c','d','c','a','a']
l2 = []
for i in l1:
    if not i in l2:
        l2.append(i)
print(l2)

(15) 遍歷列表時刪除元素的正確做法

21.Python-遍歷列表時刪除元素的正確做法
遍歷在新在列表操作，刪除時在原來的列表操作
a = [1,2,3,4,5,6,7,8]
print(id(a))
print(id(a[:]))
for i in a[:]:
    if i<5:
        a.remove(i)
    print(a)
print('-----------')
print(id(a))

(16) 集合操作

# 集合操作
a_set = set([1,2,3,4,7,8])
b_set = set([8,9,10,11,12,13])

print(a_set | b_set)       # 並集
print(a_set.union(b_set))  # 並集
print(a_set & b_set)       # 交集
print(a_set.intersection(b_set))  # 交集
print(a_set.difference(b_set))    # 差集
print(a_set - b_set)

print(a_set.symmetric_difference(b_set))   # 對稱差
print(a_set ^ b_set)      # 對稱差
{1, 2, 3, 4, 7, 8, 9, 10, 11, 12, 13}
{1, 2, 3, 4, 7, 8, 9, 10, 11, 12, 13}
{8}
{8}
{1, 2, 3, 4, 7}
{1, 2, 3, 4, 7}
{1, 2, 3, 4, 7, 9, 10, 11, 12, 13} n0
{1, 2, 3, 4, 7, 9, 10, 11, 12, 13}

(17) 分割連續字符串

data = 'TTTTThhiiiis isssss a   tesssst CAaaa as'

[i+j for i,j in re.findall(r'([a-zA-Z\s])(\1*)', data)]
Out[47]: 
['TTTTT', 'hh', 'iiii', 's', ' ', 'i', 'sssss', ' ', 'a', '   ', 't', 'e', 'ssss', 't',' ','C','A','aaa',' ','a','s']

data = '5T2h4is i5s a3 te4st CA3a as10Z'

re.findall('(\d*)([a-zA-Z\s])', data)
Out[50]: 
[('5', 'T'),('2', 'h'),('4', 'i'),('', 's'),('', ' '),('', 'i'),('5', 's'),('', ' '),
 ('', 'a'),('3', ' '),('', 't'),('', 'e'),('4', 's'),('', 't'),('', ' '),('', 'C'),
 ('', 'A'),('3', 'a'),('', ' '),('', 'a'),('', 's'),('10', 'Z')]

(18) 用 字符串 分割字符串

s = 'iloveappleclass'

s.partition('apple')
Out[80]: ('ilove', 'apple', 'class')

(19) maketrans, translate 【字符串對應地轉換】

table = ''.maketrans('abcdef123', 'uvwxyz@#$')
s = 'Python is a greate programming language. I like it!'
s.translate(table)
Out[92]: 'Python is u gryuty progrumming lunguugy. I liky it!'

(20) 日期計算

def staytime(etc_info):
    # 計算停留時間
    # 2016-06-11#21:48:50 時間格式
    in_time = datetime.datetime.strptime(etc_info[1], "%Y-%m-%d#%H:%M:%S")
    out_time = datetime.datetime.strptime(etc_info[2].strip(), "%Y-%m-%d#%H:%M:%S")
    delta = (out_time - in_time).seconds

(21) 方差

var = sum([(num - ave)**2 for num in nums]) / len(nums)

蘇大python習題

1. 給定整數m和n，如果m和n都大於1，則判定m和n是否互質，並返回判定結果。

相關說明
輸入條件 輸入參數m和n是整數。大小關系未知。
輸出要求 如果m和n中任何一個小於或等於1，則返回None，否則判定兩數是否互質。 如果m和n互質，則返回布爾值True，否則返回布爾值False。
其他要求 將代碼寫入函數func1

測試用例：

輸入 返回
2,3 True
4,8 False 
# -*- coding: utf-8 -*-

def func1():
    m = eval(input("輸入m:\n"))
    n = eval(input("輸入n:\n"))  
    if (m <= 1 or n <= 1):
        return None   
    if m < n:
        m, n = n, m       
    return m % n
print(bool(func1()))

2. 一個整數列表L=[a1, a2, …, an]中，如果一對數(ai, aj)滿足ai>aj 且 i<j，那么這對數就稱為一個逆序，列表L中逆序的數量稱為逆序數。求一個整數列表L的 逆序數。

相關說明
輸入條件 列表中的元素都是整數
輸出要求 如果L為空 或者 L中只有一個元素，返回0，否則返回L的逆序數。
其它要求 將代碼寫入函數func2

測試用例：

輸入 返回
[4,3,2,1] 6
[1,3,2,4] 1 
# -*- coding: utf-8 -*-
def fun2():
    li = list(eval(input("輸入列表: ")))  
    Len = len(li)
    cnt = 0  
    for i in range(0, Len):
        for j in range(i, Len):
            if (li[i] > li[j]):
                cnt = cnt + 1  
    print(cnt)    
fun2()

3. 矩陣相乘：

  • 輸入兩個整數類型的 矩陣mat1（m行d列）和 mat2（d行n列）.
  • 返回 矩陣相乘后 的結果 mat1 * mat2（m行n列）。矩陣 均用二維列表進行表示。
相關說明
輸入條件 兩個矩陣分別嚴格滿足 m*d 和 d*n 的形狀（m>=1, d>=1, n>=1，具體數值需要根據輸入確定），矩陣中的元素均為整數。
輸出要求 返回相乘后的矩陣，用二維列表表示，每一個元素均為整數
其他要求 將代碼寫入函數 func3

測試用例：

輸入 返回
[[1,2]] [[1],[2]] [[5]]
[[1,2],[1,3]] [[1,1],[1,0]] [[3,1],[4,1]]

代碼：

# -*- coding: utf-8 -*-
 

def matrixMul(A, B):
    if len(A[0]) == len(B):  # A列數=B行數
        res = [[0] * len(B[0]) for i in range(len(A))]  # 生成 A行 x B列 的 0矩陣
        for i in range(len(A)):
            for j in range(len(B[0])):                  
                for k in range(len(B)):                  # (A列)B行
                    res[i][j] += A[i][k] * B[k][j]       # 矩陣乘法
        return res
    return ("輸入矩陣有誤!")

def fun3():
    mat1 = eval(input("輸入矩陣mat1:"))
    mat2 = eval(input("輸入矩陣mat2:"))
    result = matrixMul(mat1, mat2)
    # 矩陣乘法 結果
    print(result)
    
fun3()

4. 一維列表轉成二維列表： 輸入一個長度為 n*n 的一維列表， 返回一個n行n列的二維列表。

相關說明
輸入條件 一維列表能保證長度是 n*n (n>=1，具體數值需要根據輸入確定)，且每個元素為整型。
輸出要求 轉換后的二維列表
其它要求 將代碼寫入函數 func4

測試用例：

輸入 返回
[1] [[1]]
[2,1,3,4] [[2,1],[3,4]]

簡易代碼：

import numpy as np

np.reshape([1,2,3,4,5,6,7,8,9], [3, 3])

Out[88]: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

詳細實現：

# -*- coding: utf-8 -*-
import math
import numpy as np

def fun4():
    # 輸入數據, 例如: [2,1,4,5]
    li = eval(input("輸入一個列表:"))
    print("list1:", li)
    
    cnt = len(li)
    print("長度數目n*n: ", cnt)
    
    n = int(math.sqrt(cnt))    # n x n
    
    # 生成 nxn 的 空矩陣
    res = [[] * n for i in range(0, n)]
    
    for i in range(0, n):
        for j in range(0, n):
            # 添加第i行,j列元素
            res[i].append(li[i * n + j])
    
    return res

res = fun4()
print(res)

5. 統計字符串

  • 給定一個字符串，包含了若干個以 空格分開 的單詞.

  • 統計 其中每個單詞出現的次數，以 列表的形式 返回其中 出現 次數最多的三個單詞。

  • 三者按照出現次數 降序排序，當出現次數相同時，對 單詞 按照字典序降序排序。

  • 如果不足三個單詞，則按照上述規則排序后全部返回。

相關說明
輸入條件 一個只包括西文字符的字符串。
輸出要求 返回一個元素是字符串的列表
其它要求 將代碼寫入函數func5

測試用例：

輸入 返回
'hello hi hello apple' ['hello', 'hi', 'apple']
'a' ['a']

代碼：

#-*- coding: utf8 -*-

import re
import collections

# 1. 統計單詞出現次數
# 2. 以列表的形式 返回其中 出現次數最多的三個單詞
# 3. 三者按照出現次數 降序排序。【次數相同，對單詞按照字典序降序排序】

# 統計單詞出現次數
def train(features):
    # 生成值為1的空字典
    model = collections.defaultdict(int)
    for f in features:
        model[f] += 1
    return model


def fun5():
    text = input("輸入字符串: ")  # 例: i love python
    print(text)
    freq = train(text.split())

    # 遍歷 freq
    print("\n打印字典: ")
    for key, value in freq.items():
        print(key, value)

    print("\n打印排序后結果:")
    # 按value排序(降序)，如果value相同則按key排序(字典序升序)
    freq = sorted(freq.items(), key=lambda x:(x[1], x[0]), reverse=True)
    print(dict(freq))

    # 將單詞添加到列表
    res = []
    for key in freq[:3]:
        res.append(key[0])

    # 輸出 自動
    print(res)

def main():
    fun5()

if __name__ == "__main__":
    fun5()

輸出：

輸入字符串: hello hi hello apple
hello hi hello apple

打印字典: 
hello 2
hi 1
apple 1

打印排序后結果:
{'hello': 2, 'hi': 1, 'apple': 1}
['hello', 'hi', 'apple']

或者代碼：

def func5(txt):
    counts = {}
    ls = txt.split()
    for word in ls:
        counts[word] = counts.get(word,0)+1
    items = list(counts.items())
    items.sort(key=lambda x:(x[1],x[0]),reverse=True)
    lst = []
    for i in range(len(items)):
        lst.append(items[i][0])
        if i >= 2:
            break
    return lst

6. Jaccard系數

  • 僅包含 小寫字母 的兩個單詞 S 和 T 的 Jaccard系數（記為J）由如下三個統計量來確定：

  • a：在兩個單詞中，都出現的字母的個數

  • b：在S中出現，但沒有在T中出現的字母的個數

  • c：在T中出現但沒有在S中出現的字母的個數

  • 那么 J = a / (a + b + c)。給定兩個單詞S和T，求確定其Jaccard系數的三個統計量a,b,c。

相關說明
輸入條件 兩個僅包含小寫字母的單詞
輸出要求 以元組形式返回三個統計量，即(a,b,c)
其它要求 將代碼寫入函數func6

測試用例：

輸入 返回
‘his’, ‘she’ (2,1,1)
‘hello, ‘python’ (2,2,4)

代碼：

#-*- coding: utf8 -*-

import re
# 僅包含 小寫字母 的兩個單詞 S 和 T 的 Jaccard系數（記為J）由如下三個統計量來確定：
# a：在兩個單詞中，都出現的字母的個數
# b：在S中出現，但沒有在T中出現的字母的個數     len(S) - a
# c：在T中出現，但沒有在S中出現的字母的個數     len(T) - a
# 那么J = a / (a + b + c)。給定兩個單詞S和T  
# 求確定其Jaccard系數的三個統計量a, b, c。

def fun6():
    S = input("輸入單詞S: ")
    T = input("輸入單詞T: ")
    # 分離字符 以及 生成集合[按字典序排序]
    sli = re.findall('[a-z]', S)
    slist = list(set(sli))
    tli = re.findall('[a-z]', T)
    tlist = list(set(tli))
    
    a = 0
    for i in range(0, len(slist)):
        for j in range(i, len(tlist)):
            if slist[i] == tlist[j]:
                a = a + 1
    
    b = len(slist) - a
    c = len(tlist) - a
    print((a, b, c))
    
def main():
    fun6()   

if __name__ == '__main__':
    main()

7. 統計最多的字符次數

  • 統計一個 非空字符串 中 出現 次數最多 的字符 及其 出現次數。

  • 其中英語字母不區分大小寫，全部統計為大寫字母， 如 ’a’ 和 ’A’ 在計數時進行合並為’A’。

  • 結果 以 包含字符 和 對應次數 的列表形式 進行返回。

  • 數據中 不存在 並列最多的情況，該情況不需要考慮。

相關說明
輸入條件 能保證目標字符串非空、且其中不存在出現次數並列最多的字符
輸出要求 結果以包含字符和對應次數的列表形式進行返回。
其它要求 將代碼寫入函數 func7

測試用例：

輸入 返回
'1aA' ['A',2]
'a' ['A',1]

代碼：

# -*- coding: utf-8 -*-
import re

# 統計一個非空字符串中
# 1. 出現 次數最多的字符 及其 出現次數
# 2. 全部統計為大寫字母
# 3. 結果 [字符, 對應次數]
def func7():
    s = input("輸入一個字符串: ")
    # 字母轉大寫
    sli = list(s.upper())
    print(sli)
    
    # 統計列表元素的 頻率
    sli = [(i, sli.count(i)) for i in sli]
    
    # 去重后，排序，返回列表
    sort_sli = sorted(set(sli), key=lambda x:-x[1])
    sort_sli = [list(i) for i in sort_sli]
    
    print("\n排序后去重的列表: ", sort_sli)
    
    print("\n次數最多: ", sort_sli[0])
    
    # 轉換成字典: {'A': 5, 'D': 2, '1': 1, 'B': 1, 'G': 1}
    print(dict(sort_sli))
    
def main():
    func7()
    
if __name__=='__main__':
    main()

輸出：

輸入一個字符串: 1231AAAsdbafg
['1', '2', '3', '1', 'A', 'A', 'A', 'S', 'D', 'B', 'A', 'F', 'G']

排序后去重的列表:  [['A', 4], ['1', 2], ['B', 1], ['2', 1], ['F', 1], ['D', 1], ['3', 1], ['S', 1], ['G', 1]]

次數最多:  ['A', 4]
{'A': 4, '1': 2, 'B': 1, '2': 1, 'F': 1, 'D': 1, '3': 1, 'S': 1, 'G': 1}

8. 數字和平均值

  • 一個字符串中存在多個正整數.

  • 請提取出 位數在[3,5] 之間的所有正整數，構成一個列表

  • 對此列表按照 數字和平均值 （各位數字的總和/位數）進行 降序排序， 並返回排序結果列表。

  • 數字和平均值 就是 各位數字的總和除以位數，例如2345的數字和平均值=(2+3+4+5)/4=3.5，12的數字和平均值=(1+2)/2=1.5。

相關說明
輸入條件 存在多個正整數的字符串
輸出要求 結果以滿足要求的列表形式進行返回。如原字符串中不存在滿足條件的正整數，返回None
其它要求 將代碼寫入函數func8

測試用例：

輸入 返回
'123a4567 1' [4567,123]
'1234' [1234]

代碼：

# -*- coding: utf-8 -*-

import re

def sumAve(x):
    tmp = x
    cnt = 0
    res = 0
    while tmp:
        res += tmp%10
        tmp = int(tmp / 10)
        cnt = cnt + 1
    return res / cnt

def func8():
    num = input("輸入字符串:")
    # 注意 [0-9]{3,5} 不要亂加空格，否則出錯
    li = re.findall('[0-9]+', num)
    print(li)
    li = [int(elem) for elem in li if len(elem) >= 3 and len(elem) <= 5]
    print(li)
    
#    print(sumAve(2345))
    # 按照 數字和平均值 排序
    li.sort(key=lambda x:sumAve(x), reverse=True)
    print(li)

def main():
    func8()
    
if __name__=='__main__':
    main()

輸出：

輸入字符串:123asd235 43 sdg535 35 345
[123, 235, 535, 345]
[535, 345, 235, 123]

蘇大真題[2005-2019]

2005. 把一個數表示成若干個素數的和.

# -*- coding: utf-8 -*-

import math

def is_prime(num):
    if num < 2:
        return False
    
    top = int(math.sqrt(num))
    i = 2
    while i <= top:
        if num % i == 0:
            return False
        i = i + 1
        
    return True
    
res = []
# 從大到小 繼續篩選
def split_prime(num):
    if num < 2:
        return
    
    if is_prime(num):
#        print(num)
        res.append(num)
        return
        
    for i in range(num, 1, -1):
        if (is_prime(i) and num - i > 1):
            res.append(i)
            split_prime(num - i)
            return  

def faction_prime():
    while True:
        num = int(input())
        split_prime(num)
        print(res)
        res.clear()
        
def main():
    faction_prime()
           
if __name__=='__main__':
    main()

輸出：

4
[2, 2]
6
[3, 3]
7
[7]
22
[19, 3]
45
[43, 2]

或者：

0 not in [n%d for d in range(2, n)]

2005.2 統計篇文章中各英文字母的個數，並排序.

2005_2.txt

Mr. Sherlock Holmes, who was usually very late in the mornings, 
sort which is known as a "Penang lawyer." Just under the head was a

代碼：

# -*- coding: utf-8 -*-

import re

def words(text):
    return re.findall('[a-z]', text.lower())
    
def train(features):
    model = {}
#    print(features)
    for f in features:
        model[f] = model.get(f, 0) + 1
    
    return model    
    
def main():
#    t = open("./file/2005_2.txt").read()
#    print(t)
#    print(words(t))
    statistic = train(words(open("./file/2005_2.txt").read()))
    statistic = list(statistic.items())
    print(statistic)
    statistic.sort(key=lambda x:(x[1], x[0]), reverse=True)
    print(dict(statistic))
    
if __name__=='__main__':
    main()

輸出：

[('m', 3), ('r', 7), ('s', 10), ('h', 8), ('e', 10), ('l', 6), ('o', 6), ('c', 2), ('k', 2), ('w', 6), ('a', 10), ('u', 4), ('y', 3), ('v', 1), ('t', 5), ('i', 4), ('n', 8), ('g', 2), ('p', 1), ('j', 1), ('d', 2)]
{'s': 10, 'e': 10, 'a': 10, 'n': 8, 'h': 8, 'r': 7, 'w': 6, 'o': 6, 'l': 6, 't': 5, 'u': 4, 'i': 4, 'y': 3, 'm': 3, 'k': 2, 'g': 2, 'd': 2, 'c': 2, 'v': 1, 'p': 1, 'j': 1}

2006. 找出 100 到 1000 內的不含 9 的素數，存到 result 文件中.

# -*- coding: utf-8 -*-

import math

def is_prime(num):
    if num < 2:
        return False
    top = math.sqrt(num)
    i = 2
    
    while i <= top:
        if num % i == 0:
            return False
        i = i + 1
    
    return True

# 不含9
def judge(num):
    a = list(str(num))
    return '9' not in a

def filterPrime(start, end):
    return [i for i in range(start, end + 1) if (is_prime(i) and judge(i))]

def save2file(text):
    print(text)
    
    with open('./file/2006.txt', 'w+', encoding='utf8') as f:
        f.write(text)

def main():
    res = []
    res = filterPrime(100, 1000)
    save2file(str(res))
        
if __name__=='__main__':
    main()

2006.txt

[101, 103, 107, 113, 127, 131, 137, 151, 157, 163, 167, 173, 181, 211, 223, 227, 233, 241, 251, 257, 263, 271, 277, 281, 283, 307, 311, 313, 317, 331, 337, 347, 353, 367, 373, 383, 401, 421, 431, 433, 443, 457, 461, 463, 467, 487, 503, 521, 523, 541, 547, 557, 563, 571, 577, 587, 601, 607, 613, 617, 631, 641, 643, 647, 653, 661, 673, 677, 683, 701, 727, 733, 743, 751, 757, 761, 773, 787, 811, 821, 823, 827, 853, 857, 863, 877, 881, 883, 887]

2007. 素數

  • 把 10 到 1000 之間滿足以下兩個條件的數，存到 result.txt 文件中.

  • 是素數.

  • 它的反數也是素數，如： 123 的反數是 321 .

# -*- coding: utf-8 -*-

# 把10 到 1000 之間滿足以下兩個條件的數，存搭配result.txt文件中
# 1. 是素數
# 2. 它的反數也是素數，如：123的反數是321
import math

def is_prime(num):
    if num < 2:
        return False
    top = math.sqrt(num)
    i = 2
    
    while i <= top:
        if num % i == 0:
            return False
        i = i + 1
    return True

# 123 的 反數是 321
def reverseNum(num):
    res = int(str(num)[::-1])
    return res

# 篩選素數
def filter_prime(start, end):
    return [i for i in range(start, end + 1) if is_prime(i) and is_prime(reverseNum(i))]

def saveFile(text):
    with open('./file/2007.txt', 'w', encoding='utf8') as f:
        f.write(str(text))
              
def main():
    res = filter_prime(10, 1000)
    print(res)
    saveFile(res)
    
if __name__=='__main__':
    main()

2007.txt

[11, 13, 17, 31, 37, 71, 73, 79, 97, 101, 107, 113, 131, 149, 151, 157, 167, 179, 181, 191, 199, 311, 313, 337, 347, 353, 359, 373, 383, 389, 701, 709, 727, 733, 739, 743, 751, 757, 761, 769, 787, 797, 907, 919, 929, 937, 941, 953, 967, 971, 983, 991]

2008. 文件讀取字符串，排除The

  • 用 IE 從 FTP 上下載 org.dat ，並保存在 D 盤的根目錄中.

  • 此文件中按文本方式存放了一段其他文章，其中有若干長度小於 15 的英文單詞，單詞之間用空格分開，無其他符號.

  • 順序讀取這段文章的不同的單詞(大小寫敏感)，同時在 讀取的過程中 排除所有的單詞 THE 以及變形，即這些單詞不能出現在讀取的結果中.

  • 將讀取的所有單詞的首字母轉大寫后，輸出 D 根目錄下 new.txt ，每個單詞一行.

# -*- coding: utf-8 -*-

import re

def words(text : str):
    return re.findall('[a-zA-Z]+', text)
#    return text.split()                  # 只匹配字符串

def train():
    with open("./file/2008.dat", 'r', encoding='utf8') as f:
        wds = f.read()
        
    wds = words(wds)
    print(wds)
    
    wds = [i.capitalize() for i in wds if i.lower() != "the"]
    print("\n", wds)
    
    with open("./file/2008_new.txt", 'w', encoding='utf8') as f:
        for word in wds:
            f.write(word+'\n')
     
train()

2008.dat

The constructor is used to initialize the object The destructor is used to delete the Object the
calling seqence of constructor is opposite to the calling sequence of destructor

2008_new.txt

Constructor
Is
Used
To
略

2009. 文件讀取字符串，轉數字【八進制/十進制】

  • 用 IE 瀏覽器從 FTP 上下載 org.dat ，並保存在 D 盤的根目錄下.
  • 此文件中按文本方式存放了一段其他文章，其中有 若干長度小於 15 的 **十進制 **或 八進制 數字，數字之間用 ,
    分開，數字內部 存在且 僅存在 空格.
  • 八進制數 以起始位 0 作為標示 與 十進制數區分.
  • 順序讀取這些數字 將他們 轉變為十進制數 后按 從大到小 的順序排序后，輸出到 D 盤根目錄下 new.txt ，每個數字一行.
    eg ： 235,34__2,043_1,1_3 ，分別是：十進制 235 ，十進制 342 ，八進制 431 ，十進制 13 ， _ 代表
    空格.
# -*- coding: utf-8 -*-

def int10(x):
    if x[0] == '0':
        return int(x, 8)
    return int(x)

def main():
    with open("./file/org.dat", 'r+', encoding='utf8') as f:
        wds = f.read()
    
    # 按照","分割字符串
    words = wds.split(',')
    # 去除空格, 數字字符串轉化成10進制整數
    words = [i.replace(" ","") for i in words]
    print(words)
    
    trans = list(map(int10, words))
    trans.sort(reverse=True)
    print(trans)
    
    with open('./file/2009_new.txt', 'w', encoding='utf8') as f:
        f.write(str(trans))
        
if __name__=='__main__':
    main()

org.dat

 235 ,34  2, 043 1 ,1 3

2009_new.txt

[342, 281, 235, 13]

2010. 讀取二進制文件 以及篩選素數

  • 從 FTP 上下載 make.exe 和 org.dat ，運行 make.exe 輸入准考證后三位

  • 生成 data.txt 文件為二進制編碼 data.txt ，內存有 2048 個整數.

  • 其中 前 n 個為非 0 數，后 2048 - n 個數為 0 ，將其讀入數組，計算 非零數 的 個數 n.

  • 選出 n 個數中 的 最大數 和 最小數，選出 n 個數中 最大素數.

  • 將 n 個數 從大到小排序，並 平均分成三段 (若 n 非 3 的整數倍，則不考慮最后的 1-2 個數)，

  • 選出中間段的最大數和最小數.

數據:

0800 0000 0600 0000 0200 0000 1900 0000
0500 0000 0200 0000 0300 0000 0900 0000
0100 0000 0d0a 0000 0022 0000 000c 0000
002d 0000 0053 0000 0066 0000 0007 0000
0005 0000 000d 0000 004f 0000 0000 0000
0000 0000 0000 0000 0000 0000 0000 0000
0000 0000 0000 0000 0000 0000 0000 0000
0000 0000 0000 0000 0000 0000 0000 0000
00

輸出：

26112 1
數據數: 16 [26112, 21248, 11520, 8704, 3072, 2573, 1792, 25, 9, 8, 6, 5, 3, 2, 2, 1]
最大素數:  5
2573 8

代碼：

# -*- coding: utf-8 -*-
import math
import random
import struct

def is_prime(num):
    if num < 2:
        return False
    top = int(math.sqrt(num))
    i = 2
    while i <= top:
        if num % i == 0:
            return False
        i = i + 1        
    return True  

def main():
    res = [random.randrange(0, 9999, 1) for i in range(0, 16)]
#    print(res)
    
#    with open('./file/2010.txt', 'rb+') as f:
#        for i in res:
#            s = struct.pack('i', i)
#            f.write(s)
    len1 = len(res)
    nums = []
    with open('./file/2010.txt', 'rb+') as f:
        for i in range(len1):
            data = f.read(4)
            elem = struct.unpack('i', data)[0]
            nums.append(elem)
    
    # 按照 16進制 轉換成 10進制        
    nums.sort(reverse=True)
    print(nums[0], nums[-1])
    
    print("數據數:", len1, nums)
    for i in nums:
        if (is_prime(i)):
            print("最大素數: ", i)
            break
    
    mid = nums[len1//3 : len1//3*2]
    print(mid[0], mid[-1])         

if __name__=='__main__':
    main()

2011. 篩選素數

  • 輸出 1000-9999 中滿足以下條件的所有數：
  • 該數是素數.
  • 十位數 和 個位數 組成的數是 素數， 百位數 和 個位數 組成的數是 素數.
  • 個位數 和 百位數 組成的數是 素數，個位數 和 十位數 組成的數是 素數。 比如 1991 ，個位 和 十位 組成的數就是 19 .
# -*- coding: utf-8 -*-

import math

def is_prime(num):
    if num < 2:
        return False
    top = int(math.sqrt(num))
    i = 2
    while i <= top:
        if num % i == 0:
            return False
        i = i + 1
    return True

def judge(num):
    unit = num % 10             # 個位
    decade = (num // 10) % 10   # 十位
    hund = (num // 100) % 10    # 百位
    return [unit, decade, hund]

def comb(a, b):
    return a * 10 + b

def filter_prime(start, end):
    res = [i for i in range(start, end + 1) if (is_prime(i)) and
           (is_prime(comb(judge(i)[1], judge(i)[0]))) and
           (is_prime(comb(judge(i)[2], judge(i)[0]))) and
           (is_prime(comb(judge(i)[0], judge(i)[1]))) and
           (is_prime(comb(judge(i)[0], judge(i)[2]))) ] 
    return res

def main():
    res = filter_prime(1000, 9999)
    print(res)
    
if __name__=='__main__':
    main()

輸出：

[1117, 1171, 1997, 2111, 2113, 2131, 2137, 2311, 2371, 2711, 2713, 2731, 2917, 3137, 3331, 3371, 3779, 3917, 4111, 4337, 4397, 4937, 5113, 5171, 5197, 5711, 5779, 6113, 6131, 6173, 6197, 6311, 6317, 6337, 6397, 6779, 6917, 6997, 7331, 7937, 8111, 8117, 8171, 8311, 8317, 8713, 8731, 8779, 9137, 9173, 9311, 9337, 9371, 9397]

2012. 讀取二進制文件 以及 左標

  • 從服務器上下載數據文件 org.dat 文件以 二進制方式 存放一系列整數，每個整數占 4 個字節.

  • 從 第一個整數 開始，第一個整數 和 第二個整數 構成一個坐標點，以此類推，數據文件 中保存了 許多 坐標點數據.

  • 規定處於 第一象限的坐標點 為 有效點，請問 數據文件 中 所有點的個數 n 為多少？ 有效點的個數 k 為多少？

  • 每個 有效點 與 坐標原點 構成一個的 矩形，請問 k 個有效點 與 坐標原點 構成的 k 個矩形 的 最小公共區域面積為多少？

  • 尋找 有效點 中 符合下列條件的點：

    • 以該點為 坐標原點， 其它 有效點 ：
      • 仍然是 有效點， 即 處於第一象限 (不包括坐標軸上的點).
      • 輸出這些點，對 所有有效點 進行分組，每個有效點 有且只有 屬於一個分組，分組內的點 符合下列規則：
        • 若 對組內所有點的 x，坐標進行排序。
        • 點 p1(x1, y1) 在點 p2(x2, y2) 后面，即 x1 > x2 那么 y1 > y2 ，請輸出所有的分組。
# -*- coding: utf-8 -*-

import struct

# 讀取未知數字個數的二進制文件
def readFile(url):
    ans = []
    with open(url, 'rb+') as f:
        while True:
            data = f.read(4)
            if not data:
                break
            elem = struct.unpack('i', data)[0]
            ans.append(elem)
            
        return ans

# 將讀取到的數構成坐標
def point(data):
    res = []
    len_data = len(data)
    for i in range(0, len_data, 2):
        comb = [data[i], data[i + 1]]
        res.append(comb)
    return res

# 有效點的個數
def validPoint(point):
    res = [elem for elem in point if (elem[0] > 0 and elem[1] > 0)]
    return res

# 橫坐標的最小值 和 縱坐標的最小值 組成的矩陣
def minSquare(point):
    px, py = point[0][0], point[0][1] 
    len_p = len(point)
    for i in range(len_p):
        if px > point[i][0]:
            px = point[i][0]
        if py > point[i][1]:
            py = point[i][1]    
    return px * py
        
# 橫坐標最小的同時縱坐標也是最小(取最小值的下標是否一致)，返回滿足條件的點
def minPoint(point):
    minx, miny = 0, 0
    len_p = len(point)
    for i in range(len_p):
        if point[minx][0] > point[i][0]:
            minx = i
        if point[miny][0] > point[i][1]:
            miny = i
    if minx == miny:
        return point[minx]
    else:
        return '不存在這樣的點'

# 分組
def groupX(point : list):
    # 先按坐標x軸升序排列
    point.sort(key=lambda x : x[0])
    print(point)
    
    count = 0
    flag = [0 for i in range(len(point))]  # 標記數組初始化為0
    p_len = len(point)
    for i in range(p_len):
        if flag[i] == 0:                   # 首次被標記，歸為下一個分組
            count += 1
            # 組數:count
            print('\ncount = ', count)
            print(point[i], end='')
            flag[i] = 1                    # 標志着已經使用過
            # t 為 第 t 組
            t = i
        for j in range(i + 1, p_len):
            if (flag[j] == 0) and (point[j][1] > point[t][1]) and (point[j][0] > point[t][0]):
                print(point[j], end='')
                flag[j] = 1
                t = j            
            
def main():
    data = readFile("./file/file_2012.txt")
#    print(data, "\n")
    
    p_point = point(data)
#    print(p_point)
  
    # 有效點的個數
    vapoint = validPoint(p_point)
    print(vapoint)
    print("有效點的個數 = {0}\n".format(len(vapoint)))   
    print("最小公共區域面積 = {0}".format(minSquare(vapoint)))   
    print("符合條件的點: ", minPoint(vapoint)) 
    groupX(vapoint)
      
if __name__ == '__main__':
    main()

輸出：

[[20, 9], [1, 1], [8, 9], [90, 2], [6, 8], [80, 3], [20, 3], [4, 3], [22, 77], [90, 10], [8, 6], [8, 90], [77, 99], [8, 9]]
有效點的個數 = 14

最小公共區域面積 = 1
符合條件的點:  [1, 1]
[[1, 1], [4, 3], [6, 8], [8, 9], [8, 6], [8, 90], [8, 9], [20, 9], [20, 3], [22, 77], [77, 99], [80, 3], [90, 2], [90, 10]]

count =  1
[1, 1][4, 3][6, 8][8, 9][22, 77][77, 99]
count =  2
[8, 6][20, 9][90, 10]
count =  3
[8, 90]
count =  4
[8, 9]
count =  5
[20, 3]
count =  6
[80, 3]
count =  7
[90, 2]

2013. 圖論：兩頂點間存在長度為k的路徑

PathInput.txt

6
[PVG, CAN]
[CAN, PEK]
[PVG, CTU]
[CTU, DLC]
[DLC, HAK]
[HAK, LXA]

PathRequest.txt

2
[PVG, DLC, 2]
[PVG, LXA, 2]

Output.txt

[PVG, DLC, YES]
[PVG, LXA, NO]

代碼：

# -*- coding: utf-8 -*-
# 1. PVG -> PEK
# 即：PVG -> CAN -> PEK
# PathInput.txt
# 6
# [PVG, CAN]
# [CAN, PEK]
# [PVG, CTU]
# [CTU, DLC]
# [DLC, HAK]
# [HAK, LXA]
# PathRequest.txt
# 2
# [PVG, DLC, 2]
# [PVG, LXA, 2]
import re

# 讀文本文件內容，以換行分隔單詞，返回字符串列表
def readFile(url): 
    with open(url, 'r+', encoding='utf8') as f:
        wds = f.readlines()
        return wds

# 兩頂點間 存在 長度為k的路徑
# countLine: Line的長度
# 遞歸判斷起點為: start
# 終點為: end
# 長度為k的路徑是否存在
def check(Line, countLine, start, end, k):
    flag = 0
    # 遍歷所有 Line 的數據
    # [['PVG', 'CAN'], ['CAN', 'PEK'], ['PVG', 'CTU'], ['CTU', 'DLC'], ['DLC', 'HAK'], ['HAK', 'LXA']] 
    for i in range(countLine):
        # 找到路徑
        if k == 0 and Line[i][0] == start and Line[i][1] == end:
            flag = 1
            break
        elif k > 0 and Line[i][0] == start and Line[i][1] != end:
            k -= 1
            # 改變 起點             
            flag = check(Line, countLine, Line[i][1], end, k)
        
    return flag
    
# Line: Line的數據
# Path: Path的數據
def writeFile(url, Line, countLine, Path, countPath):
    with open(url, 'w', encoding='utf8') as f:
        # 操作次數
        for i in range(countPath):
            # 起點, 終點, step=2
            # 兩頂點間 存在 長度為k的路徑
            if check(Line, countLine, Path[i][0], Path[i][1], Path[i][2]):
                f.write('[{0}, {1}, Yes]\n'.format(Path[i][0], Path[i][1]))
            else:
                f.write('[{0}, {1}, No]\n'.format(Path[i][0], Path[i][1]))   

def main():
    dataLine = readFile('./file/file_2013_line.txt')
    dataPath = readFile('./file/file_2013_plan.txt')
    countLine, countPath = int(dataLine[0]), int(dataPath[0])
#    print(countLine, countPath)
    
    Line, Path = [], []
    for i in range(1, countLine + 1):
        Line.append([dataLine[i][1:4], dataLine[i][6:9]])
#        print(dataLine[i])
        
    for i in range(1, countPath + 1):
        Path.append([dataPath[i][1:4], dataPath[i][6:9], int(dataPath[i][11])])
#        print(dataPath[i])
    
    # 輸出 Line 的數據    
    print(dataLine, "\n")
    print(Line, "\n")
    # 輸出 Path 的數據
    print(dataPath, "\n")
    print(Path)
    
    writeFile('./file/file_2013_output.txt', Line, countLine, Path, countPath)               
if __name__=='__main__':
    main()

2014. 坐標距離

  • 從網頁上下載 input.dat 文件，里面是用二進制編寫的，里面放了一堆 int 型的數，

  • 每個數占 4 個字節，每次讀取兩個，這兩個數構成一個坐標.

  • 規定處於第一象限的數是有效點(即 x>0, y>0 的坐標)，問這么多點中有效點有多少個？

  • 現在用戶從鍵盤輸入一個坐標和一個數字 k ，設計算法輸出 k 個離該坐標距離最近的點的坐標和每個坐標到

    該點的距離，寫入到 output.txt 文件中

# -*- coding: utf-8 -*-
import struct
import math

def readFile(url):
    res = []
    with open(url, 'rb+') as f:
        while True:
            data = f.read(8)
            if not data:
                break
            elem = struct.unpack('2i', data)
            res.append(elem)            
    return res
        
def validPoint(data):
    res = [elem for elem in data if (elem[0] > 0 and elem[1] > 0)]
    return res

def distance(a, target):
    return math.pow(abs(a[0]-target[0]), 2) + math.pow(abs(a[1]-target[1]), 2)
    
def main():
    data = readFile('./file/file_2014.txt')
    print(data)
    
    vapoint = validPoint(data)
    print("\n有效點: ", vapoint)
    print("有效點數目: ", len(vapoint))
    
    k = int(input("輸入k:"))
    x = int(input("輸入坐標x:"))
    y = int(input("輸入坐標y:"))
    target = [x, y]
    print(target)
    
    sorted_vap = sorted(vapoint, key=lambda x:distance(x, target))
    print(sorted_vap)
     
    print("k個坐標距離target的距離：")
    for i in range(0, k):
        print("{0} -> 目標{1} 距離: {2:.2f}".format(sorted_vap[i], target, math.sqrt(distance(sorted_vap[i], target)) ))
    

if __name__=='__main__':
    main()

2015. 二進制坐標距離

  • 從網頁上下載 input.dat 文件，里面是用二進制編寫的，里面放了一堆 int 型的數，每個數占 4 個字節，每
    次讀取兩個，這兩個數構成一個坐標.
  • 規定處於第一象限的數是有效點(即 x>0, y>0 的坐標)，問這么多點中有效點有多少個？
  • 從鍵盤上輸入 k 和 n ，從第一問中的有效點中找出距離小於 n ，距離小於 n 的點的個數要大於 k ，將它們
    以文本格式輸出到文件中.
# -*- coding: utf-8 -*-

import struct
import math

def readFile(url):
    res = []
    with open(url, 'rb+') as f:
        while True:
            data = f.read(8)
            if not data:
                break
            elem = struct.unpack('2i', data)
            res.append(elem)
    return res

def validPoint(points):
    res = [elem for elem in points if (elem[0] > 0 and elem[1] > 0)]
    return res

def distance(a, target):
    return math.pow(abs(a[0] - target[0]), 2) + math.pow(abs(a[1] - target[1]), 2) 
    

def writeFile(sorted_vap, target, k):
    with open("./file/file_2015_output.txt", 'w', encoding='utf8') as f:
        for i in range(0, k):
             f.write("{0} -> 目標{1} 距離: {2:.2f}\n".format(sorted_vap[i], target, math.sqrt(distance(sorted_vap[i], target))))


def main():
    points = readFile("./file/file_2015.txt")
    vapoints = validPoint(points)
    print(vapoints)
    valen = len(vapoints)
    print("有效點的個數: ", valen)
    
    k = int(input("輸入k:"))
    n = int(input("輸入n:"))
    x = int(input("輸入坐標x:"))
    y = int(input("輸入坐標y:"))
    target = [x, y]
    
    sorted_vap = sorted(vapoints, key=lambda x:(distance(x, target)))
    print("k個坐標距離target的距離：")
    for i in range(0, valen):
        dis = math.sqrt(distance(sorted_vap[i], target))
        if dis < n:
            print("{0} -> 目標{1} 距離: {2:.2f} 小於{3}".format(sorted_vap[i], target,  dis, n))
    
    writeFile(sorted_vap, target, valen)
    
    
if __name__=='__main__':
    main()

輸出：

[(20, 9), (1, 1), (8, 9), (90, 2), (6, 8), (80, 3), (20, 3), (4, 3), (22, 77), (90, 10), (8, 6), (8, 90), (77, 99), (8, 9)]
有效點的個數:  14

輸入k:3

輸入n:16

輸入坐標x:4

輸入坐標y:4
k個坐標距離target的距離：
(4, 3) -> 目標[4, 4] 距離: 1.00 小於16
(1, 1) -> 目標[4, 4] 距離: 4.24 小於16
(6, 8) -> 目標[4, 4] 距離: 4.47 小於16
(8, 6) -> 目標[4, 4] 距離: 4.47 小於16
(8, 9) -> 目標[4, 4] 距離: 6.40 小於16
(8, 9) -> 目標[4, 4] 距離: 6.40 小於16

2016. 詞頻統計

file_2016_in.txt

Mr. Sherlock Holmes, who was usually very late, 
略

file_2016_out.txt

the, 15
night, 9
略

代碼：

# -*- coding: utf-8 -*-
# 文本文件 input.txt 由若干英文單詞和分隔符(空格，回車，換行)構成. 
# 根據如下說明編寫程序：
# 統計不同單詞出現的次數(頻度). 
# 將統計結果按出現頻度從高到低排序，並將出現頻度大於 5 的單詞及其頻度輸出到文件 output.txt
# 中. 文件格式如圖所示
# 多個連續的分隔符被視為一個分隔符.
# 大小寫敏感.
# 每個單詞的長度不超過 20 個字符.
import re

def readFile(url):
    with open(url, 'r+', encoding='utf8') as f:
        data = f.read()
    return data

def train(words):
    freq = {}
    for word in words:
        freq[word] = freq.get(word, 0) + 1
        
    return freq

def writeFile(sorted_freq):
    with open('./file/file_2016_output.txt', 'w', encoding='utf8') as f:
        for elem in sorted_freq:
            if elem[1] > 5:
                f.write("{0}, {1}\n".format(elem[0], elem[1]))
    

def main():
    data = readFile('./file/file_2016_in.txt')
    words = re.findall('[a-zA-Z]+', data)
    print(words)
    
    freq = train(words)
    sorted_freq = sorted(freq.items(), key=lambda x:(x[1]), reverse=True)
    print("\n", sorted_freq, "\n")
    for elem in sorted_freq:
        if elem[1] > 5:
            print("{0}, {1}".format(elem[0], elem[1]))
            
    writeFile(sorted_freq)


if __name__=='__main__':
    main()

2017. 坐標問題

已知：二進制數據文件 data.bin 中存放了若干個整數，請編寫程序完成如下功能：
編寫程序讀取所有數據.

  • 以每相鄰兩個整數為一對按順序構成二維平面上的坐標點. 例如：有數據 12 ， 34 ， 53 ， 25 ， 61 ，
    28 ， 78 等，則構成六個坐標點如下： (12, 34) 、 (34, 53) ， (53, 25) , (25, 61) , (61, 28) , (28,
    78) ；

  • 以 每個坐標點為圓心，以 該點 與 其后面第一個點 的 歐氏距離為半徑 r . 計算 最后一個點 時 以其 和第一個點 的歐氏距離為半徑。

  • 計算 **每個圓包含的坐標點數 **。

  • 例如：
    坐標點 (12, 34) 的圓半徑\(r=\sqrt{(12-34)^2+(34-53)^2}​\)是坐標點 (12, 34) 與 (34, 53) 的歐式距離.
    坐標點 (28, 78) 的圓半徑\(r=\sqrt{(28-12)^2+(78-34)^2}​\)是坐標點 (28, 78) 與 (12, 34) 的歐式距離.

  • 計算所有圓的點密度值，然后輸出 點密度值 最大的 5 個坐標點以及 相應圓中包含的 點數 和 點密度值. 輸出格式
    要求：req

  • 上述文字部分不需要顯示.
    其中：圓的點密度 為 圓包含的點數 /圓面積，如果點在圓上，則也算圓包含該點，在計算點密度時，圓心也算一個點. 計算圓面積時\(\pi=3.14​\). 例如：坐標點 (2, 1) ，則該坐標點也屬該坐標點的圓內的一個點.

# -*- coding: utf-8 -*-
import struct
import math

def readFile(url):
    # 測試用例
    wds = """2 88 59 83 87 65 38 72 70 76 50 62 4 76 68 70 50 60 13 74 66 60 8 28 97 94 99 52 6 90 69 60 54
83 76 89 64 73 48 69 83 28 84 67 14 50 99 86 35 36 5 82 67 36 92 99 44 27 53 76 24 45 27 19 14
65 86 69 47 80 96 96 10 68 60 91 87 25 15 50 8 18 3 15 85 88 14 8 2 64 63 62 70 58 62 93 51 66
62 73 75 6"""
    # 寫文件
    with open(url, 'wb+') as f:
        line = wds.split()
        for i in line:
            elem = struct.pack('i', int(i))
            f.write(elem)
    
    res = []
    # 讀文件
    with open(url, 'rb+') as f:
        while True:
            data = f.read(8)
            if not data:
                break
            elem = struct.unpack('2i', data)  # 讀一個元組(x,y)
            res.append(elem)
    return res

# 計算歐式距離
def distance(a, target):
    return math.sqrt(math.pow(abs(a[0] - target[0]), 2) + math.pow(abs(a[1] - target[1]), 2))

# 計算 圓的點密度
def density(count, r):
    return count / (r*r*math.pi)

def main():
    points = readFile('./file/file_2017.txt')   
    polen = len(points)
    
    circle_radius = []   # 存儲距離(當作圓半徑)
    # 以每個坐標點為圓心，以 該點 與 其后面第一個點 的歐氏距離為半徑 r
    # 計算每個圓包含的坐標點數. 計算 最后一個點 以其和 第一個點 的歐氏距離為半徑.
    for i in range(0, polen):
        circle_radius.append( distance(points[i], points[(i+1)%polen]) )
       
    # 計算 每個圓包含的 坐標點數
    count = [0 for i in range(0, polen)]   # 圓包含的點數
    for i in range(0, polen):
        for j in range(0, polen):
            # 坐標i 和 其他坐標j 距離 
            if (distance(points[i], points[j]) - circle_radius[i] <= 1e-8):
                count[i] += 1              # 圓心為i,radius[i]的圓, 包含的坐標 數
    
    # 計算所有圓的點密度值，然后輸出 點密度值 最大的 5 個坐標點
    # 圓的點密度：圓包含的點數 / 圓面積
    densitys = []
    for i in range(0, polen):
        densitys.append( density(count[i], circle_radius[i]) )
        
    # 輸出 點密度值 最大的 5 個坐標點
    combine = []
    for i in range(0, polen):
        combine.append([points[i], count[i], densitys[i]])
    
    # 根據點密度排序
    combine.sort(key=lambda x:(x[2]), reverse=True)
    # 輸出格式:
    # 坐標點(x,y)  包含點數(占5列,右對齊)  點密度(占7列，右對齊，保留2位小數)
    for i in range(0, 5):
        print("坐標點:{0}, 包含點數:{1:>5}, 點密度:{2:>7.2f}".format(combine[i][0], combine[i][1], combine[i][2]))
       
if __name__=='__main__':
    main()

輸出：

坐標點:(63, 62), 包含點數:    4, 點密度:   0.02
坐標點:(8, 18), 包含點數:    2, 點密度:   0.02
坐標點:(64, 73), 包含點數:   13, 點密度:   0.02
坐標點:(68, 70), 包含點數:   18, 點密度:   0.01
坐標點:(51, 66), 包含點數:    7, 點密度:   0.01

2016. 保研 查字典匹配句子

  • 請從服務器將兩個數據文件 input.txt 和 words.txt 下載到本地電腦的 D 盤根文件夾。
  • 在 D 盤根文件夾的 words.txt 中存儲了不超過 30000 條的英文單詞，每個單詞占一行。單詞的最大長度為
    20 ，且單詞內部沒有空格，文件中無重復單詞。
  • 在D盤根文件夾的 input.txt 中存儲了一個「丟失」了空格和標點符號的英文文章。每行不超過 128 個字
    符，請編寫程序把該文章中第一行和最后一行顯示在屏幕上。
  • 編寫程序：將 words.txt 中的最后三行顯示在屏幕上；
  • 編寫程序：利用 words.txt 中的單詞作為詞典，采用正向最大匹配切分單詞算法對 input.txt 中的文本進行單詞切分。切分時單詞區分大小寫，切分分割標記采用空格，並將切分后的結果寫入到 out.txt 中。
  • 所謂正向最大匹配切分就是從左向右掃描待切分字符串，盡量取長詞。
  • 下面舉一個簡單例子：現有待切分字符串 ABCDEFGHIJ ，設詞典中最大單詞長度為 5 。那么按照算法首先取
    出 ABCDE 判斷是否是單詞，如果是則切分到一個單詞，否則舍棄最后一個字母接着判斷，也就是判斷 ABCD
    是否是單詞，依此類推，當只有一個字母時可以直接認定為是單詞。在成功切分出一個單詞后對待切分字符
    串余下的部分再次執行上述過程。
  • 編寫程序實現步驟 2 、 3 描述的要求，並通過如下所示的主函數對進行驗證，注意：除了指定添加的代碼之
    外，不得修改 main 函數其余部分。對 main 函數每修改一處，總分扣 3 分，最多扣 10 分。

file_input_2016.txt

whenIwasyoung
ithinkth

file_word_2016.txt

apple
love

output

['apple', 'love', 'dog', 'competitive', 'judge', 'man', 'people', 'when', 'I', 'was', 
dic: appl time
input: whenIwasyoung Totaltimeapple
['when', 'I', 'was', 'young', 'i', 'think', 'competitive', 'mechanism',

代碼：

# -*- coding: utf-8 -*-
def readFile(url):
    with open(url, 'r+', encoding='utf8') as f:
        data = f.read()
        txt = data.split('\n')   
    return txt

def splitEssay(sentence, words):
    
    start, sen_len = 0, len(sentence)
    res = []
    while start <= sen_len:
        for k in range(20, 0, -1):
            if sentence[start:start+k] in words:
                res.append(sentence[start:start+k])
                break
        start += k
    return res

def main():
    words = readFile('./file/file_word_2016.txt')
    print("詞典: ", words, "\n")
    essay = readFile('./file/file_input_2016.txt')
    print("無空格文章: ", essay, "\n")
    
    for word in words[-3:]:
        print(word)
        
    # 顯示文章的第一行 和 最后一行
    first = splitEssay(essay[0], words)
    last = splitEssay(essay[-1], words)
    
    print("\n文章第一行: {0}\n".format(' '.join(first))) 
    print("文章最后一行: {0}\n".format(' '.join(last)))
    
if __name__=='__main__':
    main()

2018. 真題 最大公約數

  • 有20000個數存儲於二進制文件中，讀取出來-

  • 然后求一個最大子集，其中兩兩互相不為倍數，不為約數，最大公約數為1

  • 然后滿足的數據輸出到指定文件中。

# -*- coding: utf-8 -*-
import struct
import random
import math

def GenerateData(url):
    random.seed(100)
#    res = (random.randint(2,20000) for i in range(0, 20000))
#    res = [11, 3, 5, 7, 9, 12, 33, 31, 4, 11]
    res = [2,3,5,7,13,17,23,29,31,37,41,43, 9]
#    res = [i for i in range(1, 500)]
    with open(url, 'wb+') as f:
        for elem in res:
            s = struct.pack('i', elem)
            f.write(s)                        

def readFile(url):
    with open(url, 'rb+') as f:
        res = []
        while True:
            data = f.read(4)
            if not data:
                break
            elem = struct.unpack('i', data)[0]
            res.append(elem)
        return res
           
def writeFile(data, length):
    with open("./file/file_2018_output.txt", 'w+', encoding='utf8') as f:
        for i in range(0, length, 5):
            if data[i:i+5]:
                f.write(str(data[i:i+5]) + "\n")         

def gcd(num1, num2):
    if num1 < num2:
        num1, num2 = num2, num1
    
    while (num1 % num2):
        temp = num1 % num2
        num1 = num2
        num2 = temp
        
    return num2

def filter_list(data, length): 
    res = []
    print(data)
    
    flag = [1 for i in range(0, length)]
    for i in range(0, length):
        for j in range(i+1, length):
#            print(data[i], data[j])
            if gcd(data[i], data[j]) != 1:
                flag[j] = 0          # flag設置為0，標志為不可用
                flag[i] = 0          
                break
        if flag[i] and (j == length - 1) and (gcd(data[i], data[j-1]) == 1):
            res.append(data[i])
            print("res:", res)    
            
    res = list(set(res))             # 去重
    print(res, len(res))
    return res

def main():
    url = './file/file_2018_input.txt'
   
    GenerateData(url)    
    data = readFile(url)
    
    length = len(data)
    res = filter_list(data, length)
    
    writeFile(res, length)

    
main()

2018. 保研

1、編寫一個函數，首先，產生一個100至200之間的隨機整數rnd；然后，再產生rnd個100至500以內的隨機整數，將這些整數保存在列表numberLst中。

2、編寫一個函數，找出numberLst中所有包含數字2或數字6的整數，保存到列表num26Lst中。

3、將num26Lst中所有元素輸出到屏幕，要求每行輸出8個整數，每個整數占5列，右對齊。

4、編寫一個函數，求出num26Lst中所有整數的因子，其中因子不包括1和整數本身，存放到另一個新的列表resultLst中。

5、編寫一個函數，統計resultLst中每個因子出現的次數。

6、編寫一個函數，將第5步的統計結果輸出到屏幕，要求每行一個統計結果，只輸出出現次數最多的5個因子。

7、編寫一個函數，刪除resultLst中每個因子的重復因子，每個因子只保留一份。

8、編寫一個函數，將刪除重復因子的resultLst列表輸出到D盤文件result.txt中，要求每行輸出8個整數，每個整數占5列，右對齊。

if __name__ == "__main__":
    # ----產生隨機整數-------
    numberLst = productRndNum()
    # ----找出包含數字2或6的整數，其中digLst包含數字2和6-----
    num26Lst = getDigNumber(numberLst, digLst=[2， 6])
	printOut(num26Lst, 8)
    #-----找出所有整數的因子-----
    resultLst = getDivisorNum(num26Lst)
    #-----統計每個因子出現的次數-----
    resultStatic = staticResult(resultLst)
    printMax5Out(resultStatic)
    # ----刪除resultLst中重復因子的多余份數，只保留一份-----
    delMultiDivisor(resultLst)
    print("===出現次數最多的數字===")
    printDivisorToFile("d:\\result.txt", resultLst)

代碼：

# -*- coding: utf-8 -*-
import random
# 產生一個100-200之間的隨機整數 rmd
# 再產生rmd個100至500以內的隨機整數，保存到numberLst
def productRndNum():
    random.seed(100)
    rmd = random.randint(100, 200)  # [100,200]
    numberLst = [random.randint(100, 500) for i in range(rmd)]
    return numberLst

# ----找出包含數字2或6的整數，其中digLst包含數字2和6-----
def getDigNumber(numberLst, digLst):
    num26Lst = []
    for nb in numberLst:
        nstr = str(nb)
        for e in digLst:
            if str(e) in nstr:
                num26Lst.append(nb)
                break
    return num26Lst

# 每行輸出8個整數，每個整數占5列，右對齊
def printOut(num26Lst, cnt):
    nlen = len(num26Lst)
    for i in range(nlen):
        print("{0:>5}".format(num26Lst[i]), end=' ')
        if (i + 1) % cnt == 0:
            print('')
    print('')

#-----找出所有整數的因子, 因子不包括1和整數本身-----
def getDivisorNum(num26Lst):
    resultLst = []
    for numb in num26Lst:
        t = numb
        i = 2
        while i < t:
            if t % i == 0:
                resultLst.append(i)
            i = i + 1
    return resultLst

# 統計resultLst中每個因子出現的次數
def staticResult(resultLst):
    freq = {}
    for num in resultLst:
        freq[num] = freq.get(num, 0) + 1
    return freq

def printMax5Out(resultStatic):
    resultStatic = sorted(resultStatic.items(), key=lambda x:(x[1]), reverse=True)
    for elem in resultStatic[:5]:
        print("{0} : {1}".format(elem[0], elem[1]))

def delMultiDivisor(resultLst):
    tmp = sorted(set(resultLst), key=resultLst.index)
    resultLst.clear()
    resultLst.extend(tmp)

# 將刪除重復因子的resultLst列表輸出到D盤文件result.txt中，
# 要求每行輸出8個整數，每個整數占5列，右對齊
def printDivisorToFile(url, resultLst):
    with open(url, 'w', encoding='utf8') as f:
        rlen = len(resultLst)
        for i in range(rlen):
            f.write('{0:>5}'.format(resultLst[i]))
            if (i + 1) % 8 == 0:
                f.write('\n')

if __name__ == "__main__":
    # ----產生隨機整數-------
    numberLst = productRndNum()
    # ----找出包含數字2或6的整數，其中digLst包含數字2和6-----
    num26Lst = getDigNumber(numberLst, digLst=[2, 6])
    printOut(num26Lst, 8)
    #-----找出所有整數的因子-----
    resultLst = getDivisorNum(num26Lst)
    # -----統計每個因子出現的次數-----
    resultStatic = staticResult(resultLst)
    printMax5Out(resultStatic)
    # ----刪除resultLst中重復因子的多余份數，只保留一份-----
    delMultiDivisor(resultLst)
    print("===出現次數最多的數字===")
    printDivisorToFile("./file/file_yan2018_result.txt", resultLst)

2019. 真題 因子拆分

請各位考生從考試信息發布網站下載數據文件data.txt。

已知：數據文件data.txt是一個文本文件，其中存放了 100個 不超過32768 的 非負整數。

請編寫程序完成如下功能：

(1) 編寫函數 read_file 從文件中 讀取數據，將 所有的整數 按照 其 在文件中出現的順序 依次存儲到數組arr中；

(2) 編寫函數print：將數組arr顯示在屏幕上， 每行顯示n個數， 每個整數占6列；

(3) 編寫函數count： 統計數字0至9 在數組arr所有整數中的出現次數，將結果放入數組res中（即res[0]存儲數字0的出現次數，res[1]存儲數字1的出現次數，其余以此類推）；

(4) 編寫函數print_res：將數組res顯示在屏幕上，每行顯示5個數，可以復用步驟(2)中print函數；

(5) 編寫函數sort_array ：將數組arr中的整數 按照 因子和 從小到大排序，如果兩個整數的因子和相等，則按照它們的自然大小排序（注意：計算一個整數的因子和時 包括1和其本身）；

(6) 編寫函數filter_array： 對數組arr中的整數 進行 篩選，結果繼續保存在arr中，篩選規則如下：

  • 保留所有的偶數，同時保證這些偶數按照從小到大排序。
  • 說明：完成篩選之后，數組arr中的元素可以分成兩部分：
    • 前半部分是有效內容，即所有的偶數
    • 后半部分則是無效內容，參數size記錄了數組arr中有效內容的長度（注意：篩選要求在原數組上進行）；

(7) 編寫函數 write_file 對 數組arr中的有效內容（即所有偶數）進行質因數分解，並將 結果輸出到屏幕和文本文件output.txt中。輸出要求：每一個整數的質因數分解結果占一行，具體顯示格式如下圖所示：

ouput

代碼：

# -*- coding: utf-8 -*-
import random
import re

def generateData(url):
    random.seed(1)
#    res = [random.randint(0, 10) for i in range(0, 10)]   # 測試
    res = [random.randint(0, 2768) for i in range(0, 100)]   
    with open(url, 'w', encoding='utf8') as f:
        for elem in res:
            f.write(str(elem) + " ")
            if (res.index(elem) + 1) % 10 == 0:
                f.write('\n')
                
# 讀文件
def read_file(url):
    with open(url, 'r+', encoding='utf8') as f:
        data = f.read().split()
        data = list(map(int, data))
    return data
        
# 打印數組
def print_arr(alist, n):
    length = len(alist)
    for i in range(0, length):
        if i == 0:
            pass
        elif i % n == 0:
            print("")
        print("{0:6}".format(alist[i]), end='')
    
    print('\n')
   
# 統計數字0至9  在數組arr所有整數中的出現次數
def count(alist):
    res = [0 for i in range(0, 10)]
    length = len(alist)
    
    for i in range(0, length):
        num = list(str(alist[i]))    # 例: 123--> ['1', '2', '3']
        n_len = len(num)
        for j in range(0, n_len):
            res[int(num[j])] += 1
#    print(res)
    return res
    
# 因子和
def factor(n):
    res = 0
    for i in range(1, n+1):
        if n % i == 0:
            res += i
    return res

# 按照 因子和  從小到大排序，如果兩個整數的因子和相等，則按照它們的自然大小排序
def sort_array(alist):
    alist.sort(key=lambda x:(factor(x), x))
    return alist

def filter_array(alist):
    arr = list(filter(lambda x:x%2==0, alist))
    arr.sort()
    arr.append(len(arr))
    return arr

def filter_fac(n):
    i = 2
    res = []
    while i <= n:
        if n % i == 0:
           res.append(i)
           n /= i
        else:
           i = i + 1
#    print(res)
    return res          
    
def write_file(arr):
    with open('./file/file_2019_out.txt', 'w', encoding='utf8') as f:
        for elem in arr:
            fac = filter_fac(elem)
            fac = list(map(str, fac))
            print("{0}={1}".format(elem, "*".join(fac)))
            f.write("{0}={1}\n".format(elem, "*".join(fac)))

def main():
    url = './file/file_2019_in.txt'
    generateData(url)
    # 第一問
    data = read_file(url)
    print_arr(data, 10)    
    # 第二問
    res = count(data)           # 統計數字0至9  在數組arr所有整數中的出現次數
    print_arr(res, 5)   
    # 第(5)問
    data = sort_array(data)
    print(data)
    # 第(6)問
    arr = filter_array(data)
    print(arr)    
    # 第(7)問
    write_file(arr)
        
main()

輸出：

   550  2331   258  1044   482  2029  1841  1934  2668  1554
略
    38   103    92    23    37
[8, 88, 104, 116, 118, 178, 258, 354, 384, 418, 442, 482, 550, 670, 690, 708, 896, 908, 
略
8=2*2*2
88=2*2*2*11
略

2019. 保研 正則表達式拆分字符串

按以下要求編寫程序

代碼：

# -*- coding: utf-8 -*-

# 現有一個文本文件data.txt，其中記錄了車輛進出校園時在自動收費系統ETC中記錄下的ETC編號和時間信息。
# 每個ETC編號唯一地對應於一輛機動車。試用python語言編寫程序，按要求從該數據文件中提取所需的信息。
#
# 說明：
# 1. 一個ETC編號由5部分構成，本別是：兩個大寫字母、一個短橫線、三位數字、一個短橫線、三位數字。
#    如：“FG-102-934”、“BA-724-433”等都是合法的ETC編號。
# 2. 時間信息的記錄格式為：2016-01-08#07:21:31。
# 3. 整條ETC記錄的格式由5部分構成，分別是：ETC編號、字符“|”、入校時間、字符“|”，離校時間。
#    如：“BA-724-433|2016-01-08#07:21:31|2016-01-08#17:01:09”就是一條結構完整的ETC記錄。
# 4. 數據文件中每一行為一個ETC記錄。
# 5. 車輛進入校園后都是在當天離開校園的，即每條ETC記錄中出入校園的日期是相同的。
# 6. ETC記錄中出現的字符都是英文符號，無漢字和中文標點符號。
#
# 要求：
# 1. 從文件中識別ETC記錄，計算總的ETC記錄的條數。提示：讀取文件，並將ETC記錄放入列表中。
# 2. 計算ETC記錄中共有多少輛不同的車。提示：通過正則表達式（或字符串分片）識別每條ETC記錄中的ETC編號，
#    並將ETC編號放入集合中。
# 3. 找出進出校園次數最多的5輛車。提示：構建ETC編號和出現次數的字典。
# 4. 找出在校園中累計停留時間最長的5輛車。提示：構建ETC編號和累計停留時間的字典。
#    可通過正則表達式（或字符串分片）識別時間字符串及其中的時、分、秒信息。
#    為簡化計算，可將時間轉化成以零點開始計算的秒數。可以把計算時間差作為一個獨立的函數。
#5.	 將上述計算結果按“report.txt文件內容示例”（見最后一頁）所示的要求輸出到report.txt文件中。

import re

# 讀文件，獲取全部ETC記錄，構成列表
def get_record(url):
    with open(url, 'r+', encoding='utf8') as f:
        data = f.read()
        data = data.split('\n')
    return data[:-1]
 
# 獲取全部不同的ETC編號，構成集合
def get_v(vehicle_lst): 
    veh_set = set()
    for elem in vehicle_lst:
        veh = elem.split('|')[0]
        veh_set.add(veh)

    # 共有多少輛不同的車
#    print(len(veh_set))
    return veh_set

# 構造車輛進出校園次數的字典  
def count_v(vehicle_lst, vehicle_set):
    vehicles = {}
    for elem in vehicle_lst:
        veh = elem.split('|')[0]
        vehicles[veh] = vehicles.get(veh, 0) + 1      # 遇到一次編碼, 次數+1, 默認為0
    vehicles = sorted(vehicles.items(), key=lambda x:(x[1]), reverse=True)[:10]
    
    # 進出校園次數最多的5輛車
    print(dict(vehicles[:5]))
    return vehicles[:5]

# 問題4: 
# 時間 轉化成 秒
def time2int(time : str):
    time = time.split(':')
    hour = int(time[0])*3600
    minu = int(time[1])*60
    sec = int(time[2])
    return hour + minu + sec

# 得到秒后，再 轉化成 時間
def sec2time(seconds):
    m, s = divmod(seconds, 60)
    h, m = divmod(m, 60)
    return "{0}:{1:02d}:{2:02d}".format(h, m, s)

# 計算時間差
def calcTimeDiff(start, end):
    return int(time2int(end) - time2int(start))
    
# 構造車輛累計停留時間的字典
def count_t(vehicle_lst, vehicle_set):
    vehicles = {}
    for elem in vehicle_lst:
        veh = elem.split('|')[0]
        time = re.findall('[0-9]+:[0-9]+:[0-9]+', elem)
        diff = calcTimeDiff(time[0], time[1])
        vehicles[veh] = vehicles.get(veh, 0) + diff   # 累加停留的所有時間
    
    vehicles = sorted(vehicles.items(), key=lambda x:(x[1]), reverse=True)
    # 如果要把 秒 轉化成 時:分:秒
#    vehicles = [(elem[0], sec2time(elem[1])) for elem in vehicles]

    # 累計停留時間最長的5輛車
    print(vehicles[:5])
    return vehicles[:5]
        

# vehicle_lst: 總的ETC記錄的條數
# fre_dict: 進出校園次數最多的5輛車
# inter_dict: 進出校園次數最多的5輛車
def write_to_file(vehicle_lst, fre_dict, inter_dict, url):
    with open(url, 'w+', encoding='utf8') as f:
        # 總的 ETC記錄的 條數
        f.write("記錄條數: " + str(len(vehicle_lst)) + '\n')
        # 共有多少輛不同的車
        f.write("車輛數: " + str(len(get_v(vehicle_lst))) + '\n')
        # 進出校園次數最多的5輛車
        f.write("進校次數最多的5輛車（單位：次）\n")
        for elem in fre_dict:
            f.write("{0}, {1}\n".format(str(elem[0]), str(elem[1])))
        # 在校園中累計停留時間最長的5輛車
        f.write("累計停留時間最長的5輛車（單位：秒）\n")
        for elem in inter_dict:
            f.write("{0}, {1}\n".format(str(elem[0]), str(elem[1])))
    

def main():
    # 讀文件，獲取全部ETC記錄，構成列表
    vehicle_lst = get_record("./file/file_2019_input.txt")	
    # 獲取全部不同的ETC編號，構成集合
    vehicle_set = get_v(vehicle_lst)
    # 構造車輛進出校園次數的字典
    fre_dict = count_v(vehicle_lst, vehicle_set)	
    # 構造車輛累計停留時間的字典
    inter_dict = count_t(vehicle_lst, vehicle_set)		             
    # 輸出結果到文件中
    write_to_file(vehicle_lst, fre_dict, inter_dict, "./file/file_2019_report.txt")	
    return

main()	# 調用main函數

輸出：

記錄條數: 645
車輛數: 103
進校次數最多的5輛車（單位：次）
BR-189-680, 20
SX-733-715, 19
QC-621-143, 18
VI-487-543, 17
TR-445-782, 16
累計停留時間最長的5輛車（單位：秒）
QC-621-143, 828417
BR-189-680, 756757
UI-370-311, 722708
SX-733-715, 701937
TR-445-782, 697439

2016. 期中考試 提取字符串 坐標問題

1

2

3

代碼：

# -*- coding: utf-8 -*-
import math
import re
import random

# 判斷素數
def is_prime(n):
    if n < 2:
        return False
    top = math.sqrt(n)
    i = 2
    while i <= top:
        if n % i == 0:
            return False
        i = i + 1
    return True

# 判斷數中是否包含 3或7
def judge(n):
    li = list(n)
    return '3' in li or '7' in li

# 讀文件
def readFile(url):
    with open(url, 'r+', encoding='utf8') as f:
        data = f.read()
        return data
        
# 生成坐標 A
def generateA():
    random.seed(100)
    a = random.uniform(0, 101)
    b = random.uniform(0, 101)
    return (a, b)
        
# 計算坐標點之間的距離
def distance(a, b):
    return math.sqrt(math.pow(a[0]-b[0], 2) + math.pow(a[1]-b[1], 2))

# 將單詞轉換成整數
def ASCII(word):
    w = list(word)
    res = 0
    for e in w:
        res += ord(e)
    return res 

def main():
    data = readFile('./file/file_midterm.txt')
    print(data)
    
    # 提取所有整數
    num = re.findall('[0-9]+', data)
    # 判斷素數 and 判斷素數包含數字3或7
    primes = [int(elem) for elem in num if is_prime(int(elem)) and judge(elem)]
    for elem in primes:
        # 每個值占10列、右對齊、每行顯示2個數
        print("{0:>10}".format(elem), end=' ')
        if (primes.index(elem)) % 2:
            print('')
    
    print('')
    # 排序坐標
    primes.sort()
#    print(primes)
    
    plen = len(primes)
    plen = plen if (plen % 2 == 0) else plen - 1
    
    points = [(primes[i], primes[i+1]) for i in range(0, plen-1, 2)]
#    print(points)
    
    # 隨機數構成的坐標點輸出格式
    A = generateA()
    print("({0:>10.2f}, {1:10.2f})".format(A[0], A[1]))
    
    # 計算所有坐標點到A之間的歐式距離之和
    dis = []
    for i in range(0, plen//2):
        d = distance(points[i], A)
        dis.append(d)
    print("距離之和: {0:.2f}".format(sum(dis)))
    print("平均距離為:{0:10.2f}, 素數構成坐標點數為:{1:10.2f}".format(sum(dis) / len(dis), plen//2))
    
    # 提取所有單詞
    words = re.findall('[a-zA-Z]+', data)
    print(words)
    
    print("單詞轉化成整數:")
    wlen = len(words)
    ascii_words = [ASCII(elem) for elem in words]
    for i in range(0, wlen):
        print('{0:8}'.format(ascii_words[i]), end='')
        if (i+1) % 10 == 0:
            print('')
  
main()

輸出：

       563        773 
       379        631 
略
(     14.71,      45.95)
距離之和: 2203.42
平均距離為:    550.85, 素數構成坐標點數為:      4.00
['Regular', 'expression', 'patterns', 'are', 'compiled', 'into', 'a', 'series', 'of', 'bytecodes', 'which', 'are', 'then', 'executed', 'by', 'a', 'matching', 'engine', 
單詞轉化成整數:
     722    1104     881     312     845     442      97     651     213     962
     531     312     431     855     219      97     843     630     781     215
略

2017. 期中考試

現在有一文本文件data.txt，請將文本文件拷貝到D盤根目錄，文本文件中包含多行字符串，每行字符串中包含若干用空格、逗號、句號分隔的單詞，請編寫程序完成如下功能：

  • 編寫一個函數，從data.txt文件中讀取所有單詞，並保存到單詞列表wordlst中。

  • 編寫一個函數，找出wordlst中存在某個字母 至少出現num次 的單詞，字母不區分大小寫，將符合要求的單詞保存到列表 wordResultLst 中，其中num由參數給出。

  • 編寫一個函數，刪除wordResultLst中重復單詞多余份數，只保留一份，非重復單詞保持不變。將結果仍然保存在列表wordResultLst中。

  • 編寫一個函數，輸出wordResultLst中所有單詞，要求每個單詞占20列，每行輸出count個單詞，其中count由參數給出。

  • 編寫一個函數，將wordResultLst中的每一個單詞轉換成一個整數，保存到列表numLst中。轉換規則：整數為單詞的所有字母的ASCII值的累加和，例如：sum對應的整數就是s、u、m三個字母的ASCII值之和。

  • 編寫一個函數，對numLst中的所有整數按整數的數字累加和進行降序排序，例如整數:923,456,134對應的整數數字累加和為14，15，8，則排序結果456，923，134。

  • 編寫一個函數，輸出排序后的numLst，要求每個整數占8列，每行輸出count個整數，其中count由參數給出。

  • 編寫一個函數，統計numLst中每個數字出現的次數，將統計結果保存到字典resultDic中。

  • 編寫一個函數，將統計結果resultDic中出現次數最多的數字及其出現次數輸出到D盤根目錄的文本文件result.txt中

    • 輸出格式：數字(占2列,左對齊) ：出現次數(占3列，右對齊)
測試程序如下(不允許修改測試程序，修改一處扣2分，直到扣滿10分)：
if __name__ == "__main__":
    # ----從data.txt文件中讀取所有單詞-------
    wordlst = readWordsFromFile("d:\\data.txt")
    print("文件中單詞個數:", len(wordlst))  # 輸出單詞個數

5

# -*- coding: utf-8 -*-
import re

def readWordsFromFile(url):
    with open(url, 'r+', encoding='utf8') as f:
        data = f.read()
        words = re.findall('[a-zA-Z]+', data)
    return words

def findMultiAlphaWords(wordlst, cnt):
    wordResultLst = []
    for word in wordlst:
        w = list(word.lower())
        for e in w:
            if w.count(e) >= cnt:
                wordResultLst.append(word)
                break
    print(wordResultLst)
    return wordResultLst

def delMultiData(wordResultLst):
    tmp = wordResultLst[::]
    for elem in tmp:
        if wordResultLst.count(elem) > 1:
            wordResultLst.remove(elem)
    
def printWordLst(wordResultLst, cnt):
    wlen = len(wordResultLst)
    for i in range(0, wlen):
        print('{0:20}'.format(wordResultLst[i]), end='')
        if (i + 1) % cnt == 0:
            print('')
    print('')
    
def ASCII(word):
    ans = 0
    for w in word:
        ans += ord(w)
    return ans
    
def getNumberOfWords(wordResultLst):
    numlst = []
    for word in wordResultLst:
        numlst.append(ASCII(word))
    return numlst

def numSum(x):
    li = str(x)
    res = 0
    for e in li:
        res += int(e)
    return res

def sortByDigitalSum(numlst):
    numlst.sort(key=lambda x:numSum(x), reverse=True)
    return numlst        

def printNumLst(numlst, cnt):
    wlen = len(numlst)
    for i in range(0, wlen):
        print('{0:8}'.format(numlst[i]), end='')
        if (i + 1) % cnt == 0:
            print('')
    print('')

# ----統計數字出現的次數----------
def staticDigitalTimes(numlst):
    resultDic = {}
    for e in numlst:
        num = str(e)
        for w in num:
            resultDic[w] = resultDic.get(w, 0) + 1
    print(resultDic)
    return resultDic
    
def printDicToFile(url, resultDic):
    resultDic = sorted(resultDic.items(), key=lambda x:x[1], reverse=True)
    with open(url, 'w', encoding='utf8') as f:
        print('{0:<2}:{1:>3}'.format(resultDic[0][0], resultDic[0][1]))
        f.write('{0:<2}:{1:>3}'.format(resultDic[0][0], resultDic[0][1]))

if __name__ == "__main__":   
    # ----從data.txt文件中讀取所有單詞-------
    wordlst = readWordsFromFile("./file/file_midterm_2017.txt")
    print("文件中單詞個數:", len(wordlst))  # 輸出單詞個數
    # ----找出單詞中，存在某個字母重復num次的單詞-----
    wordResultLst = findMultiAlphaWords(wordlst, 2)
    print("至少含有重復2次的字母的單詞：", len(wordResultLst))
#​
    # ----刪除wordResultLst中重復單詞的多余份數，只保留一份-----
    delMultiData(wordResultLst)
    print("===刪除重復單詞的多余單詞后的結果===")
    printWordLst(wordResultLst, 4)  # 輸出所有單詞，每行輸出4個單詞
    
    # ----將wordResultLst中的所有單詞轉換為整數------
    numlst = getNumberOfWords(wordResultLst)
    
    # ----對numlst中的所有整數進行根據數字累加和進行降序排序----
    sortByDigitalSum(numlst)
    print("===整數降序排序的結果===")
    printNumLst(numlst, 5)    #輸出整數列表，每行輸出5個整數 
    
    # ----統計數字出現的次數----------
    resultDic = staticDigitalTimes(numlst)
    
    print("===出現次數最多的數字===")
    printDicToFile("./file/file_midterm_2017.out", resultDic)

2018. 期中考試

1.1588264301748

代碼：

# -*- coding: utf-8 -*-
import math
from functools import reduce
def is_prime(num):
    if num < 2:
        return False
    top = int(math.sqrt(num))
    i = 2
    while i <= top:
        if num % i == 0:
            return False
        i = i + 1
    return True

def solve():
    li = eval(input())    # [1, 234, 5, 6, 70, 890], [12,34,56,78,90]
    rli = []
    for elem in li:
        estr = str(elem)
        rli.append(int(estr[0]))
        rli.append(int(estr[-1]))
    
    rlen = len(rli)
    flag = [0] * rlen
    ans = []
    for i in range(rlen):
        ps = []              # 是prime
        notps = []           # 不是prime
        if flag[i] == 0 and is_prime(rli[i]):
            for j in range(i, rlen):
                if flag[j] == 0 and is_prime(rli[j]):
                    ps.append(rli[j])
                    flag[j] = 1
                else:
                    break
            if ps:
                ans.append(ps)
        elif flag[i] == 0:
            for j in range(i, rlen):
                if flag[j] == 0 and not is_prime(rli[j]):
                    notps.append(rli[j])
                    flag[j] = 1
                else:
                    break
            if notps:
                ans.append(notps)
    
    res = []
    for elem in ans:
        comb = reduce(lambda x,y:x*10+y, elem)
        res.append(comb)
    print(res)
    
solve()

1590203987095

代碼：

# -*- coding: utf-8 -*-
import collections
import itertools

def func4(mat):
    m=len(mat)
    mm=[[0 for i in range(m)] for j in range(2*m-1)]    
    for i in range(m):
        for j in range(m):
            if i+j<m:
                mm[i+j][j]=mat[i][j]
            else:
                mm[i+j][m-i-1]=mat[i][j]
    return mm

def solve():
    A = eval(input()) # [[1,2,3], [4,5,6], [7,8,9]]
    m = len(A)
    B = [[0]*m for i in range(2*m-1)]
    row = 2*m - 1
    
    dic = collections.defaultdict(list)
    for i,j in itertools.product(range(m), range(m)):
        dic[i - j].append(A[m-i-1][j])

    dic = sorted(dic.items(), key=lambda x:x[0], reverse=True)   
    for i in range(row):
        rlen = len(dic[i][1])
        for j in range(rlen):
            B[i][j] = dic[i][1][j]          
    print(B)
    
solve()
print(func4([[1,2,3], [4,5,6], [7,8,9]]))

1588432579986

# -*- coding: utf-8 -*-

# 字母表中字幕出現的次數 >= 單詞的字幕出現次數
def contains(charCount, wordCount):
    print(charCount, wordCount)
    for key in wordCount.keys():
        print(charCount.get(key, 0) , wordCount.get(key))
        if charCount.get(key, 0) < wordCount.get(key):
            return False
    return True

def solve(words, chars):
    from collections import Counter
    charCount = dict(Counter(chars))
    res = 0
    wlen = len(words)
    for i in range(0, wlen):
        wordCount = dict(Counter(words[i]))
        if contains(charCount, wordCount):
            res += 1
    return res

print(solve(['cat', 'bt', 'hat', 'tree'], 'atach'))
print(solve(['hello', 'world', 'soochow'], 'welldonehoneyr'))

期末考試

題目1 數組每個數出現次數

  • 給你一個整數列表lst，請你幫忙統計數組中每個數的出現次數。
  • 如果每個數的出現次數都是獨一無二的，就返回 true；否則返回 false。
  • 輸入：lst = [1,2,2,1,1,3]
    輸出：true
    解釋：在該數組中，1 出現了 3 次，2 出現了 2 次，3 只出現了 1 次。沒有兩個數的出現次數相同。

代碼：

# -*- coding: utf-8 -*-
def func2(lst : list):
    flag = {}
    for e in lst:
        flag[e] = flag.get(e, 0) + 1
        
    res = []
    for e in flag.values():
       res.append(e)
       
    rlen = len(res)
    for i in range(0, rlen):
        for j in range(i+1, rlen):
            if res[i] == res[j]:
                return False
    return True

def main():
    print(func2([1,2,2,1,1,3]))
    print(func2([1,2,2,1,1,3,3]))
    print(func2([1,2,2,1,1,3, 4,4,4]))
    print(func2([1,2,2,1,1,3, 4,4,4,4,4]))
    
main()

輸出：

True
False
False
True

題目2 奇數在前 偶數在后

  • 給定一個非負整數列表 lst，返回 lst 的排序結果，排序要求 首先是 奇數在前，偶數在后

  • 然后，按照數字從大到小排序

  • 示例：
    輸入：lst = [1,2,3,4,5,6]
    輸出： [1,3,5,2,4,6]

# -*- coding: utf-8 -*-
def fun2(lst):
    length = len(lst)
    i = 0
    j = length - 1
    while i < j:
        while i < j and lst[j] % 2 == 0:   # 后面是偶數
            j = j - 1
        if i < j:
            t = lst[j] 
        while i < j and lst[i] % 2 == 1:   # 前面是奇數
            i = i + 1
        if i < j:
            lst[j] = lst[i]
            lst[i] = t 
    print(lst)

def main():
    fun2([1,2,3,4,5,6])
    fun2([1, 2, 3, 6, 7, 10, 11])
    fun2([2, 3, 4, 5, 1, 3, 5, 7, 9])
    
main()

輸出：

[1, 5, 3, 4, 2, 6]
[1, 11, 3, 7, 6, 10, 2]
[9, 3, 7, 5, 1, 3, 5, 4, 2]

題目3 查找添加的字母

  • 給定兩個字符串 s 和 t，它們 只包含小寫字母。
  • 字符串 t 由字符串 s 隨機重排，然后在隨機位置添加一個字母。請找出在 t 中被添加的字母。
  • 示例:
輸入：
s = "abcd"
t = "abcde"
輸出：
e
解釋：
'e' 是那個被添加的字母。

代碼：

# -*- coding: utf-8 -*-
# 給定兩個字符串 s 和 t，它們只包含小寫字母。字符串 t 由字符串 s 隨機重排，
# 然后在隨機位置添加一個字母。請找出在 t 中被添加的字母。
def func4(str1, str2):
    s = sorted(str1)
    t = sorted(str2)
    slen = len(s)
    tlen = len(t)
    
    for i in range(0, slen):
        if s[i] != t[i]:
            return t[i]     
    return t[tlen - 1]        
    
def main():
    print(func4('abcd', 'abcde'))
    print(func4('abcd', 'aebcd'))   
    print(func4('abcd', 'abecd'))  
    print(func4('abbcd', 'abbecb'))
       
main()

蘇州大學python課程組習題

1. 因子和

編寫一個函數，計算一個整數的所有因子之和，其中因子不包括整數本身，並編寫測試程序，在測試程序中輸入整數和輸出整數的所有因子之和。例如：輸入 8，調用該函數之后，得到結果為 7。

代碼：

# -*- coding: utf-8 -*-
def factor(num):
    i = 1
    res = 0
    while i < num:
        if num % i == 0:
            res += i
        i = i + 1
    return res


def main():
    while True:
        n = int(input("輸入n:"))
        print(factor(n))

if __name__=='__main__':
    main()

2. 反素數

(反素數)反素數：指一個素數將其逆向拼寫后也是一個素數的非回文數。 例如：17 和 71 都是素數且都不是回文數，所以 17 和 71 都是反素數。請編寫一個函數判斷一個數是否是反素數？並編寫測試程序找出前 30 個反
素數輸出到屏幕上，要求每行輸出 8 個數，每個數占 5 列，右對齊。

代碼：

# -*- coding: utf-8 -*-
# (反素數)反素數指一個素數將其逆向拼寫后也是一個素數的非回文數。
# 例如：17 和 71 都是素數且都不是回文數，所以 17 和 71 都是反素數。
# 請編寫一個函數判斷一個數是否是反素數？並編寫測試程序找出前 30 個反
# 素數輸出到屏幕上，要求每行輸出 8 個數，每個數占 5 列，右對齊。

import math
# 素數
def is_prime(num):
    if num < 2:
        return False
    top = math.sqrt(num)
    i = 2
    while i <= top:
        if num % i == 0:
            return False
        i = i + 1
    return True

def Reverse(num):
    return int(str(num)[::-1])

def print_res(res, length):
    for i in range(0, length):
        print("{0:>5}".format(res[i]), end='')
        if (i+1)%8 == 0:
            print('')
    print('')

def main():
    cnt = 0
    cur = 2
    res = []
    while cnt < 30:
        if is_prime(cur) and is_prime(Reverse(cur)):
            res.append(cur)
            cnt = cnt + 1
        cur = cur + 1
        
    print_res(res, len(res))
    
if __name__=='__main__':
    main()

3. 梅森素數

【函數】 (梅森素數) 如果一個素數 可以 寫成 \(2^{p}-1\) 形式，其中 p 是一個正整數，那么該數就稱作梅森素數。請編寫一個函數：

  • 判斷一個素數是否是梅森素數，如果是，則返回 p 的值，否則返回-1。

  • 並編寫測試程序找出 1000 以內的所有梅森素數輸出到屏幕上，要求輸出格式如下：

  • P(占 3 列右對齊) \(2^{p} - 1\) (占 4 列右對齊) # 此行不需要輸出

2 3       2^2-1
3 7       2^3-1
5 31      2^5-1

代碼：

# -*- coding: utf-8 -*-
import math

def is_prime(num):
    if num < 2:
        return False
    top = math.sqrt(num)
    i = 2
    while i <= top:
        if num % i == 0:
            return False
        i = i + 1
    return True

def is_MalPrime(num):
    return is_prime(num) and is_prime(2**num-1)

def filter_prime():
    cur = 2
    res = []
    # 注意是 2^cur <= 1000
    while math.pow(2,cur) <= 1000:
        if is_MalPrime(cur):
            res.append(cur)
        cur = cur + 1    
    return res

def print_res(res, length):
    for i in range(0, length):
        print("{0:>3} {1:>4}".format(res[i], 2**res[i]-1))

def main():
    res = filter_prime()
    print_res(res, len(res))
    
if __name__=='__main__':
    main()

輸出：

  2    3
  3    7
  5   31
  7  127

4. 加密函數

編寫一個加密函數：

  • 實現對一個給定字符串 中的字母，轉變 為其后 n個字符，如果遇到 超過字母邊界，則 從最小字母繼續計數
  • 連續 的 數字字符，作為一個整數 擴大 n 倍之后，替換到對應位置，其中 n 默認為 5。
  • 再編寫一個解密函數： 實現對上述加密字符串進行解密。
  • 編寫測試程序，在測試程序中輸入字符串，並**輸出加密 **和 解密后 的字符串。
例如：
字符串 str1: avbV125av1, n 默認為 5
則新的字符串 str2: fagA625fa5

代碼：

# -*- coding: utf-8 -*-
import re
# 生成字母
def generateAlpha():
    alpha_up = []
    alpha_low = []
    for i in range(26):
        alpha_up.append(chr(ord('A') + i))
    for i in range(26):
        alpha_low.append(chr(ord('a') + i))
        
    return [alpha_low, alpha_up]
    
# 加密
def encrapy(str1, n, alpha):
    alpha_low = alpha[0]      # 小寫字母表
    alpha_up = alpha[1]       # 大寫字母表
    length = len(str1)
    res = ""
    
    i = 0
    while i < length:
        num = ""
        if str1[i].isupper():
            res += alpha_up[(alpha_up.index(str1[i]) + n)%26]
            
        elif str1[i].islower():
            res += alpha_low[(alpha_low.index(str1[i]) + n)%26]
            
        elif str1[i].isnumeric():
            num += str1[i]
            i = i + 1
            while i < length and str1[i].isnumeric():
                num += str1[i]
                i = i + 1
            # 字符后退一個
            i = i - 1
            # 數字*n
            res += str(int(num)*n)
        i = i + 1
        
    return res

# 解密
def decode(str1, n, alpha):
    alpha_low = alpha[0]      # 小寫字母表
    alpha_up = alpha[1]       # 大寫字母表
    length = len(str1)
    res = ""
    
    i = 0
    while i < length:
        num = ""
        if str1[i].isupper():
            res += alpha_up[(alpha_up.index(str1[i]) - n)%26]
            
        elif str1[i].islower():
            res += alpha_low[(alpha_low.index(str1[i]) - n)%26]
            
        elif str1[i].isnumeric():
            num += str1[i]
            i = i + 1
            while i < length and str1[i].isnumeric():
                num += str1[i]
                i = i + 1
            # 字符后退一個
            i = i - 1
            res += str(int(num)//n)  
        i = i + 1
        
    return res

def main():
    alpha = generateAlpha()
    
    str1 = 'avbV125av1'
    n = 5
    print("字符串:{0}, n默認為:{1}".format(str1, n))
    
    str2 = encrapy(str1, n, alpha)
    print("加密后:{0}".format(str2))
    
    str1 = decode(str2, n, alpha)
    print("解密后:{0}".format(str1))

if __name__=='__main__':
    main()

方式2：

# -*- coding: utf-8 -*-
import re

# 加密
def encrapy(str1, n):
    words = re.findall('\d+|[a-zA-Z]+', str1)
    res = ''
    
    for word in words:
        if word.isnumeric():
            res += str(int(word)*n)
        elif word.isalpha():
            for c in word:
                k = ord(c) + n
                if ord('Z') < k < ord('a') or k > ord('z'):
                    res += chr(k - 26)
                else:
                    res += chr(k)
        
    return res

# 解密
def decode(str1, n):
    words = re.findall('\d+|[a-zA-Z]+', str1)
    res = ''
    
    for word in words:
        if word.isdigit():
            res += str(int(word)//n)
        elif word.isalpha():
            for c in word:
                k = ord(c) - n
                if k < ord('A') or ord('Z') < k < ord('a'):
                    res += chr(k + 26)
                else:
                    res += chr(k)
    return res

def main():
    
    str1 = 'avbV125av1'
    n = 5
    print("字符串:{0}, n默認為:{1}".format(str1, n))
    
    str2 = encrapy(str1, n)
    print("加密后:{0}".format(str2))
    
    str1 = decode(str2, n)
    print("解密后:{0}".format(str1))

if __name__=='__main__':
    main()

輸出：

字符串:avbV125av1, n默認為:5
加密后:fagA625fa5
解密后:avbV125av1

5. 正則表達式

請利用正則表達式寫一個簡單的拼寫檢查程序。實現以下功能：
a) 兩個或兩個以上的空格出現時將其壓縮為一個。
b) 在標點符號后加上一個空格，如果這個標點符合之后還有字母。
例：給定字符串："Thisisveryfunnyandcool.Indeed!"
輸出："Thisisveryfunnyandcool.Indeed!"
其中“”代表一個空格。

代碼：

# -*- coding: utf-8 -*-
import re
def readFile(url):
    with open(url, 'r+', encoding='utf8') as f:
        data = f.read()
        return data

def lessSpace(s):
    words = re.findall('[a-zA-Z]+|[.?!]', s)
    print(words)
    res = ''
    for word in words:
        if word.isalpha():
            res += word + ' '
        else:
            res = res[:-1]
            res += word + ' '
            
    if not res[-2].isalpha():
        return res[:-1]
    else:
        return res

def main():
    data = readFile('./file/file10_space.txt')
    words = lessSpace(data)    
    print(words)
    
if __name__=='__main__':
    main()

['This', 'is', 'very', 'funny', 'and', 'cool', '.', 'Indeed', '!', 'I', 'love', 'you', '.']
This is very funny and cool. Indeed! I love you.

6. 正則表達式 findall

請利用正則表達式寫一個 Python 程序以嘗試解析 XML/HTML 標簽。現有
如下一段內容：

<composer>Wolfgang Amadeus Mozart</composer>
<author>Samuel Beckett</author>
<city>London</city>
希望自動格式化重寫為：
composer: Wolfgang Amadeus Mozart
author: Samuel Beckett
city: London

代碼：

# -*- coding: utf-8 -*-
import re

def readFile(url):
    with open(url, 'r', encoding='utf8') as f:
        data = f.read()
    return data

def parseXML(s):
    res = re.findall('<(.*)>(.*)</.*>', s)
    for word in res:
        print("{0}: {1}".format(word[0], word[1]))

def main():
    data = readFile('./file/file11_parse.txt')
    print(data)
    parseXML(data)
 
if __name__=='__main__':
    main()

輸出：

<composer>Wolfgang Amadeus Mozart</composer>
<author>Samuel Beckett</author>
<city>London</city>

composer: Wolfgang Amadeus Mozart
author: Samuel Beckett
city: London
  1. 文件：有一個 100G 的文件 largefile.txt（這個文件目前沒有100G，只是做模擬）。實現一個程序，首先輸出 largefile.txt 的行數，然后無限循環，每次要求用戶鍵盤輸入一個行號，然后立刻輸出對應行的文本。由於文件很大，不允許將文件內容全部放到內存中； 同時也不允許從頭掃描文件，得到對應行的文本，因為這樣速度太慢。（提示：用二進制模式打開文件，使用 tell, seek 等方法）
# -*- coding: utf-8 -*-
def readFile(url):
    with open(url, 'rb') as f:
        print("行號", len(f.readlines()))
        while True:
            line = ''
            f.seek(0)
            cur = 0
            n = int(input("input: "))
            while cur < n - 1:
                f.readline()
                cur += 1
            line = f.readline()
            if not line:
                break
            else:
                print(line)
            
def readFile1(url):
    count = 1
    with open(url, 'rb') as f:
        while True:
            buff = f.read(8192*1025)
            buff = buff.decode('utf8')
            print(buff)
            count += buff.count('\n')
            if not buff:
                break
    print(count)
        
def main():
#    readFile('./file/file15_largefile.txt')
    readFile1('./file/file15_largefile.txt')

if __name__=='__main__':
    main()

MOOC測驗

5.1 小朋友排隊

"""
小明將學生排隊  學號小到大排一排  然后進行多次調整     
一次調整可能讓一名同學出隊 向前或先后移動一段距離再入隊

例： 學生人數8人
0）初始 1，2，3，4，5，6，7，8
1）第一次調整 3號向后移動2   1，2，4，5，3，6，7，8
"""
class Solution():
    def MovingResult(self, m, lst):
        """
        m: 學生的數量
        lst: 每一個元素是一個元組: 元組的第一個元素是學號 第二個是移動的數量 負數表示向前
        返回一個列表 按照順序存儲了當前位置上學生的學號[1,2,3,4,5,6,7,8]
        """
        nums = [i for i in range(1, m+1)]
        nlen = len(lst)
        for i in range(nlen):
            op = lst[i]
            t = op[0]
            idx = nums.index(op[0])
            if op[1] > 0:
                for j in range(idx+1, idx + op[1]+1):
                    # print('nums[j] -> nums[j-1]', nums[j], nums[j-1])
                    nums[j-1] = nums[j]
            else:
                for j in range(idx-1, idx+op[1]-2, -1):
                    # print('nums[j] -> nums[j+1]', nums[j], nums[j+1])
                    nums[j+1] = nums[j]
           
            nums[idx + op[1]] = t 
            # print('nums:', nums)
        return nums

s = Solution()
print(s.MovingResult(m = 8, lst = [(3, 2), (8, -3), (3, -2)]))

5.2 小朋友出隊

  • n個小朋友圍一圈，小朋友從1~n編號。順時針方向123...n12
  • 游戲開始從1號開始順時針報數，每個小朋友報上個小朋友數+1
  • 若一個小朋友的數為k的倍數或其個位數為k，則該小朋友出去，不再參加以后的報數
  • 當游戲中只剩下一個小朋友的時候該小朋友獲勝
class Solution:
    def Circleplay(self, n, k):
        player = [i for i in range(n)]   # 0 ~ n-1
        cur = 0     # 當前報號
        num = 0
        while len(player) > 1:
            num += 1
            if num % k == 0 or num % 10 == k:
                del player[cur]
                cur = cur % len(player)    # 小朋友走的時候，不需要移動 cur
            else:
                cur = (cur + 1) % len(player)
        
        return player[0] + 1

s = Solution()
print(s.Circleplay(5, 2))
print(s.Circleplay(7, 3))


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 浙江大學軟件學院2020年保研上機 浙江大學2016數學專業復試真題 清華大學保研筆試題 計算機歷年考研復試上機基礎題(一) 物理層習題與真題 東華大學計算機軟件工程 復試最后一百題 數據鏈路層習題與真題 我的2019計算機保研夏令營/預推免經歷【中南，北理工，北航，南大，浙大】 西安郵電大學計算機學院夏令營上機考核練習題 哈工深保研經驗分享
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM