笔记-1

字符串乱序

• 检查一个字符串是否为另一个字符串的乱序，是返回True,否则返回False

def anagramSolution1(s1,s2):
    alist = list(s2)
    pos1 = 0
    stillOK = True
    while pos1 < len(s1) and stillOK:
        pos2 = 0
        found = False
        while pos2 < len(alist) and not found:
            if s1[pos1] == alist[pos2]:
                found = True
            else:
                pos2 = pos2 + 1
        if found:
            alist[pos2] = None
        else:
            stillOK = False
        pos1 = pos1 + 1
    return stillOK

print(anagramSolution1('abcd','dcba'))

True

def func(s1,s2):
    L1 = sorted(list(s1))
    L2 = sorted(list(s2))
    return L1 == L2

func('abcdd', 'bacdd')

True

def func(s1, s2):
    '''采用计数的方式进行比较，复杂度为O(n)'''
    c1 = [0] * 26
    c2 = [0] * 26
    
    for i in range(len(s1)):
        pos = ord(s1[i]) - ord('a')
        c1[pos] = c1[pos] + 1
        
    for i in range(len(s2)):
        pos = ord(s2[i]) - ord('a')
        c2[pos] = c2[pos] + 1
    
    
#     print(c1,c2)
    j = 0
    stillOK = True
    while j < 26 and stillOK:
        if c1[j] == c2[j]:
            j += 1
        else:
            stillOK = False
    return stillOK

print(func('apple','pleap'))

True

ord('b') - ord('a')

1

列表操作

• 列表索引和赋值==》O(1)
• append()、pop() ==>O(1)
• pop(i)、insert(i,item)、in、reverse==>O(n)
• sort()==>O(nlogn)

def test1():
    l = []
    for i in range(1000):
        l += [i]

def test2():
    l = []
    for i in range(1000):
        l.append(i)
        
def test3():
    l = [i for i in range(1000)]
    
def test4():
    l = list(range(1000))

from timeit import Timer
t1 = Timer("test1()", "from __main__ import test1")
print("concat ",t1.timeit(number=1000), "milliseconds")
t2 = Timer("test2()", "from __main__ import test2")
print("append ",t2.timeit(number=1000), "milliseconds")
t3 = Timer("test3()", "from __main__ import test3")
print("comprehension ",t3.timeit(number=1000), "milliseconds")
t4 = Timer("test4()", "from __main__ import test4")
print("list range ",t4.timeit(number=1000), "milliseconds")

concat  0.08891579999999522 milliseconds
append  0.06390370000008261 milliseconds
comprehension  0.033479799999895477 milliseconds
list range  0.013431999999738764 milliseconds

popzero = Timer("x.pop(0)", "from __main__ import x")
popend = Timer("x.pop()", "from __main__ import x")
x = list(range(2000000))
popzero.timeit(number=1000)

2.1798671999999897

x = list(range(2000000))
popend.timeit(number=1000)

7.340000001931912e-05

popzero = Timer("x.pop(0)","from __main__ import x")
popend = Timer("x.pop()","from __main__ import x")
print("        pop(0)           pop()")
for i in range(1000000,10000001,1000000):
    x = list(range(i))
    pt = popend.timeit(number=1000)
    x = list(range(i))
    pz = popzero.timeit(number=1000)
    print("%15.5f, %15.5f" %(pz,pt))

        pop(0)           pop()
        0.74498,         0.00012
        2.29638,         0.00008
        3.40075,         0.00010
        5.23540,         0.00009
        6.31973,         0.00009
        6.93443,         0.00009
        8.10579,         0.00009
        9.65740,         0.00009
       10.94763,         0.00009
       12.39205,         0.00008

• 从上面的结果可以看出pop(0)会随着列表的增大变大，并呈现线形关系。
• pop()则基本上不会改变。

字典操作

• 字典复制==》O(n)
• D[key], D[key]=‘A’,del D[key]，in==>O(1)

栈

class Stack:
    def __init__(self):
        self.items = []
    def push(self,item):
        self.items.append(item)
    def pop(self):
        return self.items.pop()
    def peek(self):
        return self.items[-1]
    def size(self):
        return len(self.items)
    def isEmpty(self):
        return self.items == []
    

s = Stack()
s.push("a")
s.push('b')
s.push('C')
print(s.size())
print(s.pop())
print(s.size())
print(s.pop())

3
C
2
b

使用栈解决括号匹配问题

def func(symbolStr):
    s = Stack()
    stillOK = True
    index = 0
    while index < len(symbolStr) and stillOK:
        symbol = symbolStr[index]
        if symbol == '(':
            s.push(symbol)
        else:
            if s.isEmpty():
                stillOK = False
            else:
                s.pop()
        index += 1
    if stillOK and s.isEmpty():
        return True
    else:
        return False

func('(((())))')

True

func("(((()))")

False

def func(symbolStr):
    s = Stack()
    stillOK = True
    index = 0
    while index < len(symbolStr) and stillOK:
        symbol = symbolStr[index]
        if symbol in '({[':
            s.push(symbol)
        else:
            if s.isEmpty():
                stillOK = False
            else:
                top = s.pop()
                if not match(top, symbol):
                    stillOK = False
        index += 1
    if stillOK and s.isEmpty():
        return True
    else:
        return False
    
def match(Open , Close):
    opens = "{[("
    closes = "}])"
    return opens.index(Open) == closes.index(Close)

print(func("{{([][])}()}"))
print(func('[{()]'))

True
False

def func(num):
    '''将一个数转换为二进制'''
    s = Stack()
    while num > 0:
        res = num % 2
        s.push(res)
        num = num // 2
    
    Str = ""
    while not s.isEmpty():
        Str = Str + str(s.pop())
    return Str

print(func(9))
print(func(14))
print(func(16))

1001
1110
10000

def func(num, base):
    '''将一个数转换为任意进制'''
    digits = "0123456789ABCDEF"
    s = Stack()
    while num > 0:
        res = num % base
        s.push(res)
        num = num // base
    
    Str = ""
    while not s.isEmpty():
        Str = Str + digits[s.pop()]
    return Str

print(func(25,2))
print(func(28,16))

11001
1C

队列

class Queue:
    def __init__(self):
        self.items = []
    def enqueue(self, item):
        self.items.insert(0,item)
    def dequeue(self):
        return self.items.pop()
        
    def size(self):
        return len(self.items)
    def isEmpty(self):
        return self.items == []

q = Queue()
q.enqueue('Dog')
q.enqueue('cat')
print(q.size())
print(q.isEmpty())
q.enqueue('china')
q.dequeue()
print(q.size())

2
False
2

def hotPotato(nameList,num):
    q = Queue()
    for name in nameList:
        q.enqueue(name)
    while q.size() > 1:
        for i in range(num):
            q.enqueue(q.dequeue())
        q.dequeue()
    return q.dequeue()

hotPotato(["A", "B", "C", "D", "E", "F"], 8)

'E'

双端队列Deque

class Deque:
    def __init__(self):
        self.items = []
    def addFront(self, item):
        self.items.insert(0, item)
    def addRear(self, item):
        self.items.append(item)
    def removeFront(self):
        return self.items.pop(0)
    def removeRear(self):
        return self.items.pop()
    def isEmpty(self):
        return self.items == []
    def size(self):
        return len(self.items)

def func(astring):
    d = Deque()
    for char in astring:
        d.addFront(char)
    stillOK = True
    while d.size() > 1 and stillOK:
        front = d.removeFront()
        last = d.removeRear()
        if front != last:
            stillOK = False
    return stillOK

print(func("lsdkjfskf"))
print(func("radar"))

False
True

递归

def convertStr(num, base):
    '''进制转换'''
    Strs = "0123456789ABCDEF"
    if num < base:
        return Strs[num]
    else:
        return convertStr(num//base, base) + Strs[num % base]

convertStr(42, 16)

'2A'

import turtle
myturtle = turtle.Turtle()
myWin = turtle.Screen()
def draw(myturtle, length):
    if length > 0:
        myturtle.forward(length)
        myturtle.right(90)
        draw(myturtle, length-5)
draw(myturtle,100)  
myWin.exitonclick()

def move(n,a,b,c):   #n为圆盘数，a代表初始位圆柱，b代表过渡位圆柱，c代表目标位圆柱
    if n==1:
        print(a,'-->',c)
    else:
        move(n-1,a,c,b)  
        print(a,'-->',c)
 
        move(n-1,b,a,c)  
move(4,'A', 'B', 'C')

A --> B
A --> C
B --> C
A --> B
C --> A
C --> B
A --> B
A --> C
B --> C
B --> A
C --> A
B --> C
A --> B
A --> C
B --> C

def digui(num):
    print('$'+str(num))
    # 临界值
    if num >0:
        # 这里用的是调用本身的函数(递推关系)
        digui(num-1)
    else:
        print('='*20)
    print(num)
    
digui(3)

$3
$2
$1
$0
====================
0
1
2
3

def move(n, a, b, c):
    if n == 1:
        print(a, '==>', c)
    else:
        move(n-1, a, c, b)
        move(1, a, b, c)
        move(n-1, b, a, c)

move(4, "A", "B", "C")

A ==> B
A ==> C
B ==> C
A ==> B
C ==> A
C ==> B
A ==> B
A ==> C
B ==> C
B ==> A
C ==> A
B ==> C
A ==> B
A ==> C
B ==> C

找零钱

def recMC(coinValueList,change):
    '''该方法会存在大量的重复计算，耗时'''
    minCoins = change
    if change in coinValueList:
        return 1
    else:
        for i in [c for c in coinValueList if c <= change]:
            numCoins = 1 + recMC(coinValueList,change-i)
            if numCoins < minCoins:
                minCoins = numCoins
    return minCoins

print(recMC([1,5,21,25],63))

3

def recMC(coinValueList, change, knownResults):
    minCoins = change
    if change in coinValueList:
        knownResults[change] = 1
    elif knownResults[change] > 0:
        return knownResults[change]
    else:
        for i in [c for c in coinValueList if c < change]:
            numCoins = 1 + recMC(coinValueList, change - i, knownResults)
            if numCoins < minCoins:
                minCoins = numCoins
                knownResults[change] = minCoins
#     print(knownResults)
    return minCoins

print(recMC([1,5,21,25],63, [0]* 64))

7

动态规划找零钱

def dpMakeChange(coinValueList,change,minCoins,coinsUsed):
    for cents in range(change+1):
        coinCount = cents
        newCoin = 1
        for j in [c for c in coinValueList if c <= cents]:
            if minCoins[cents-j] + 1 < coinCount:
                coinCount = minCoins[cents-j]+1
                newCoin = j
        minCoins[cents] = coinCount
        coinsUsed[cents] = newCoin
    return minCoins[change]

def printCoins(coinsUsed,change):
    coin = change
    while coin > 0:
        thisCoin = coinsUsed[coin]
        print(thisCoin)
        coin = coin - thisCoin

def main():
    amnt = 65
    clist = [1,5,10,21,25]
    coinsUsed = [0]*(amnt+1)
    coinCount = [0]*(amnt+1)
    print("Making change for",amnt,"requires")
    print(dpMakeChange(clist,amnt,coinCount,coinsUsed),"coins")
    print("They are:")
    printCoins(coinsUsed,amnt)
    print("The used list is as follows:")
    print(coinsUsed)

main()

Making change for 65 requires
4 coins
They are:
5
10
25
25
The used list is as follows:
[1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 10, 1, 1, 1, 1, 5, 1, 1, 1, 1, 10, 21, 1, 1, 1, 25, 1, 1, 1, 1, 5, 10, 1, 1, 1, 10, 1, 1, 1, 1, 5, 10, 21, 1, 1, 10, 21, 1, 1, 1, 25, 1, 10, 1, 1, 5, 10, 1, 1, 1, 10, 1, 10, 21, 1, 5]

两个字符串的最大公共子串

方法1

C="abcdefhe"
D="abbcdefghe"
 
m=0
n=len(C)
E=[]
b=0
while(m<n):
    i=n-m
    while(i>=0):
        E.append(C[m:m+i])
        i-=1
    m+=1

for x in E:
    a=0
    if x in D:
        a=len(x)
        c=E.index(x)
    if a > b:#保存符合要求的最长字符串长度和地址
        b=a
        d=c

if b>0:
    print (E[d])

bcdef

方法2

s1='dcacbcbcef'
s2='avbcbce'
print(len(s1), len(s2))

10 7

def LongestCommonSubstring(s1,s2):
    if (len(s1) == 0)|(len(s2)) == 0:
        return 
    
    Longest = 0
    ComputeTimes = 0
    m = [[0 for i in range(len(s2) + 1)] for j in range(len(s1) + 1)]
    for i in range(len(s1)):
        for j in range(len(s2)):
            if s1[i] == s2[j]:
                ComputeTimes += 1
                m[i+1][j+1] = m[i][j]+1
                if m[i + 1][j + 1] > Longest:
                    ComputeTimes += 1
                    Longest,SecondStringStartPoint = m[i + 1][j + 1], j + 1
                    
    return Longest, s2[SecondStringStartPoint-Longest:SecondStringStartPoint], ComputeTimes,m

LongestCommonSubstring(s1,s2)

(5,
 'bcbce',
 19,
 [[0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 1, 0, 1, 0],
  [0, 1, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 1, 0, 1, 0],
  [0, 0, 0, 1, 0, 2, 0, 0],
  [0, 0, 0, 0, 2, 0, 3, 0],
  [0, 0, 0, 1, 0, 3, 0, 0],
  [0, 0, 0, 0, 2, 0, 4, 0],
  [0, 0, 0, 0, 0, 0, 0, 5],
  [0, 0, 0, 0, 0, 0, 0, 0]])

---

s1='dcacbcbcef'
s2='avbcbce'

def func(s1,s2):
    if (len(s1) == 0)|(len(s2)) == 0:
        return 
    
    Longest = 0
    ComputeTimes = 0
    m = [[0 for i in range(len(s2))] for j in range(len(s1))]
    for i in range(len(s1)):
        for j in range(len(s2)):
            if s1[i] == s2[j]:
                ComputeTimes += 1
                m[i][j] = m[i-1][j-1]+1
                if m[i][j] > Longest:
                    ComputeTimes += 1
                    Longest,SecondStringStartPoint = m[i][j], j + 1
                    
    return Longest, s2[SecondStringStartPoint-Longest : SecondStringStartPoint], ComputeTimes, m

func(s1,s2)

(5,
 'bcbce',
 19,
 [[0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 1, 0, 1, 0],
  [1, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 1, 0, 1, 0],
  [0, 0, 1, 0, 2, 0, 0],
  [0, 0, 0, 2, 0, 3, 0],
  [0, 0, 1, 0, 3, 0, 0],
  [0, 0, 0, 2, 0, 4, 0],
  [0, 0, 0, 0, 0, 0, 5],
  [0, 0, 0, 0, 0, 0, 0]])

---

mat1 = [[0,0,0,0,0,0,0,0],
       [0,0,0,0,0,0,0,0],
       [0,0,0,0,0,0,0,0],
       [0,0,0,0,0,0,0,0],
       [0,0,0,0,0,0,0,0],
       [0,0,0,0,0,0,0,0],
       [0,0,0,0,0,0,0,0]]
mat1

[[0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0]]

mat2 = [[0] * 8] * 7
mat2

[[0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0]]

mat1==mat2

True

for i in range(8):
    for j in range(7):
        if i == j:
            mat1[i][j] = 100
mat1

[[100, 0, 0, 0, 0, 0, 0, 0],
 [0, 100, 0, 0, 0, 0, 0, 0],
 [0, 0, 100, 0, 0, 0, 0, 0],
 [0, 0, 0, 100, 0, 0, 0, 0],
 [0, 0, 0, 0, 100, 0, 0, 0],
 [0, 0, 0, 0, 0, 100, 0, 0],
 [0, 0, 0, 0, 0, 0, 100, 0]]

for i in range(8):
    for j in range(7):
        if i == j:
            mat2[i][j] = 100
mat2

[[100, 100, 100, 100, 100, 100, 100, 0],
 [100, 100, 100, 100, 100, 100, 100, 0],
 [100, 100, 100, 100, 100, 100, 100, 0],
 [100, 100, 100, 100, 100, 100, 100, 0],
 [100, 100, 100, 100, 100, 100, 100, 0],
 [100, 100, 100, 100, 100, 100, 100, 0],
 [100, 100, 100, 100, 100, 100, 100, 0]]

mat3 = [[0 for i in range(8)] for i in range(7)]
mat3

[[0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0]]

mat2[0][0] = 1
mat2

[[1, 100, 100, 100, 100, 100, 100, 0],
 [1, 100, 100, 100, 100, 100, 100, 0],
 [1, 100, 100, 100, 100, 100, 100, 0],
 [1, 100, 100, 100, 100, 100, 100, 0],
 [1, 100, 100, 100, 100, 100, 100, 0],
 [1, 100, 100, 100, 100, 100, 100, 0],
 [1, 100, 100, 100, 100, 100, 100, 0]]

约瑟夫环问题

• 约瑟夫环是一个数学应用题：已知n个人（编号1、2、…n）围坐在一张圆桌周围。从编号为1的人开始报数，数到m的那个人出列；他的下一个又从1开始报数，数到m的那个人又出列；依次规律重复下去，直到圆桌周围的人全部出列。请编写一个程序，给定n、m计算出列人员先后顺序。

def YueSefu(n, m):
    Deque = list(range(1, n+1))
    while Deque != []:
        for i in range(1, m+1):
            Deque.append(Deque.pop(0))
        print(Deque.pop(), end ='  ') 

YueSefu(5,3)

3  1  5  2  4  

YueSefu(7,4)

4  1  6  5  7  3  2