第1关：Python多进程-求素数个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import math
from multiprocessing import cpu_count
from multiprocessing import Pool

# 判断数字是否为质数
#********** Begin *********#
def isPrime(n):
    if n <= 1:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True
#********** End *********#

# 计算给定区间含有多少个质数
#********** Begin *********#
def howMany(T):
    sum = 0;
    for i in range(T[0], T[1] + 1):
        if isPrime(i):
            sum += 1
    return sum
#********** End *********#

# 对整个数字空间N进行分段CPU_COUNT
#********** Begin *********#
def separateNum(N, CPU_COUNT):
    list = [[i * (N // CPU_COUNT) + 1, (i + 1) * (N // CPU_COUNT)] for i in range(0, CPU_COUNT)]
    list[0][0] = 1
    if list[CPU_COUNT - 1][1] < N:
        list[CPU_COUNT - 1][1] = N
    return list
#********** End *********#

if __name__ == '__main__':
    N = int(input())
    # 多进程
    CPU_COUNT = cpu_count()  ##CPU内核数 本机为8
    pool = Pool(CPU_COUNT)
    sepList = separateNum(N, CPU_COUNT)
    result = []
    for i in range(CPU_COUNT):
        result.append(pool.apply_async(howMany, (sepList[i], )))
    pool.close()
    pool.join()
    ans = 0
    list = [res.get() for res in result]
    print(sum(list), end = '')

第2关：Python多线程-求合数个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import threading
import math
ans = 0
lock = threading.Lock()

# 判断数字是否为质数
#********** Begin *********#
def isPrime(n):
    if n <= 1:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True
#********** End *********#

#********** Begin *********#
# 计算给定区间含有多少个质数
def howMany(T):
    sum = 0;
    for i in range(T[0], T[1] + 1):
        if isPrime(i):
            sum += 1
    lock.acquire()
    try:
        global ans
        ans += sum
    finally:
        lock.release()
#********** End *********#

#********** Begin *********#
# 对整个数字空间N进行分段CPU_COUNT
def seprateNum(N, CPU_COUNT):
    list = [[i * (N // CPU_COUNT) + 1, (i + 1) * (N // CPU_COUNT)] for i in range(0, CPU_COUNT)]
    list[0][0] = 1
    if list[CPU_COUNT - 1][1] < N:
        list[CPU_COUNT - 1][1] = N
    return list
#********** End *********#

if __name__ == '__main__':
    N = int(input())
    threadNum = 32
    t = []
    sepList = seprateNum(N, threadNum)
    for i in range(0, threadNum):
        t.append(threading.Thread(target = howMany, args = (sepList[i], )))
        t[i].start()
    for i in range(0, threadNum):
        t[i].join()
    print(N - 1 - ans, end = '')

第3关：Python-ThreadLocal变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import threading
x = 10
data = threading.local()

def action():
    global x
    data.num = x
    for i in range(1000000):
        data.num += 1
        data.num -= 1
    x = data.num

x = int(input())
thread = []
for i in range(10):
    thread.append(threading.Thread(target = action))
    thread[i].start()
for i in range(10):
    thread[i].join()
print(x, end = '')

第4关：Python-进程 VS 线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import math
from multiprocessing import cpu_count
from multiprocessing import Pool
N = int(input())
a = list(map(int, input().split()))

def howMany(T):
    ans = 0;
    for i in range(T[0] - 1, T[1]):
        ans = max(ans, a[i])
    return ans

# 对整个数字空间N进行分段CPU_COUNT
def seprateNum(N, CPU_COUNT):
    list = [[i * (N // CPU_COUNT) + 1, (i + 1) * (N // CPU_COUNT)] for i in range(0, CPU_COUNT)]
    list[0][0] = 1
    if list[CPU_COUNT - 1][1] < N:
        list[CPU_COUNT - 1][1] = N
    return list

if __name__ == '__main__':
# 多进程
#********** Begin *********#
    CPU_COUNT = cpu_count()  ##CPU内核数 本机为8
    pool = Pool(CPU_COUNT)
    sepList = seprateNum(N, CPU_COUNT)
    result = []
    for i in range(CPU_COUNT):
        result.append(pool.apply_async(howMany, (sepList[i], )))
    pool.close()
    pool.join()
    ans = 0
    list = [res.get() for res in result]
    print(max(list), end = '')
#********** End *********#