準備筆試的題目

●計算置信區間.

 
●服務器創建接收再多的鏈接，也只佔用一個端口，　理解錯誤的人要回去補充下基礎知識！

多項式 P(X)=a+bx+cx^2+dx^3 ，對於任意 x ，計算 P(X) 中最少須要用到乘法操做的次數是多少  答案3次  ??????????????????????

●進制的乘法:

k進制:

a*b=c  這種乘法都是用10進制來表示,本質是k進制.

例如3進制裏面2*2=11    

具體計算方法就是先當成10進制算,再轉化成k進制便可.

2*2=4,4轉化成3進制就是11.因此2*2=11

●若是某系統12*5=61成立，則系統採用的是()進制        

下面計算這個題目:

假設是k進制,那麼左邊都轉化成k進制後是 (k+2)*5=6*k+1  因此k=9

●先來先服務（FCFS, First Come First Serve）是最簡單的調度算法，按前後順序進行調度。

●

做業週轉時間（Ti）＝完成時間(Tei)－提交時間(Tsi)
做業平均週轉時間(T)＝週轉時間/做業個數
做業帶權週轉時間（Wi）＝週轉時間/運行時間
響應比＝（等待時間＋運行時間）/運行時間

●

現有4個同時到達的做業J1,J2,J3和J4,它們的執行時間分別是1小時，3小時，5小時，7小時，系統按單道方式運行且採用短做業優先算法，則平均週轉時間是（）小時  計算:1+4+8+16 再/4 =7.5

●Linux文件權限一共10位長度，分紅四段，第三段表示的內容是

文件全部者所在組的權限
進程所請求的一次打印輸出結束後，將使進程狀態從（    ）

等待態變爲就緒態
電子郵件服務器之間相互傳遞郵件一般使用的協議是（     ）

SMTP
在網絡協議中，定義控制信息格式的是（     ）

語法
3

下面對於關係數據庫中表的主鍵描述正確的是（      ）

在一個表中主鍵列的值是惟一的

一個類中的靜態方法的調用能夠：(         )

經過類名調用

某軟件公司欲開發一個圖像處理系統，在項目初期開發人員對需求並不明確的狀況下，採用（      ）方法比較合適

快速原型
若是兩我的只能經過打電話接觸，如何經過「打電話」實現「猜拳」？
找第三我的聽

2、HAVING

HAVING語句一般與GROUP BY語句聯合使用，用來過濾由GROUP BY語句返回的記錄集。

HAVING語句的存在彌補了WHERE關鍵字不能與聚合函數聯合使用的不足。

語法：

SELECT column1, column2, ... column_n, aggregate_function (expression)
FROM tables
WHERE predicates
GROUP BY column1, column2, ... column_n
HAVING condition1 ... condition_n;        因此有havign必須有group by 才能用.

 

SVM（支持向量機）與LR（邏輯迴歸）的數學本質上的區別是什麼？

 

損失函數
ROC曲線的橫、縱座標分別表示？

FPR, TPR
You are given a data set. The data set has missing values which spread along 1 standard deviation from the median. What percentage of data would remain unaffected?

～32%
複習經典題目: 感受這個思想 能夠說是雙移動指針.來控制數組下表

'''
[編程題] 排序次數
時間限制：1秒
空間限制：65536K
小摩有一個N個數的數組，他想將數組從小到大 排好序，可是萌萌的小摩只會下面這個操做：
任取數組中的一個數而後將它放置在數組的最後一個位置。
問最少操做多少次可使得數組從小到大有序？

輸入描述:
首先輸入一個正整數N，接下來的一行輸入N個整數。(N <= 50, 每一個數的絕對值小於等於1000)


輸出描述:
輸出一行操做數

輸入例子1:
4
19 7 8 25

輸出例子1:
2

例子說明1:
19放到最後，25放到最後，兩步完成從小到大排序
'''



while 1:
    try :
        
        tmp=int(input())
        list1=[int(i)for i in input().split()]
        a=sorted(list1)
        i=0
        j=0
        count=0
        while i<len(list1):
            tmp1=list1[i]
            tmp2=a[j]
            if tmp1!=tmp2:
                count+=1
                i+=1
            else:
                i+=1
                j+=1
        print(count)
                
            
        
    except:
        break

View Code

 

'''
[編程題] 字符串問題
時間限制：1秒
空間限制：65536K
小摩手裏有一個字符串A，小拜的手裏有一個字符串B，B的長度大於等於A，因此小摩想把A串變得和B串同樣長，這樣小拜就願意和小摩一塊兒玩了。
並且A的長度增長到和B串同樣長的時候，對應的每一位相等的越多，小拜就越喜歡。好比"abc"和"abd"對應相等的位數爲2，爲前兩位。
小摩能夠在A的開頭或者結尾添加任意字符，使得長度和B同樣。如今問小摩對A串添加完字符以後，不相等的位數最少有多少位？

輸入描述:
第一行 爲字符串A，第二行 爲字符串B，
A的長度小於等於B的長度，B的長度小於等於100。
字符均爲小寫字母。


輸出描述:
輸出一行整數表示A串添加完字符以後，A B 不相等的位數最少有多少位？

輸入例子1:
abe
cabc

輸出例子1:
1
'''




a=input()
b=input()
res=len(b)-len(a)
count=float('inf')
for i in range(res+1):
    tmp=b[i:len(a)+i]
    out=0
    for i in range(len(tmp)):
        if tmp[i]!=a[i]:
            out+=1
    if out<count:
                count=out
if len(a)==len(b):
    tmp=b
    out=0
    for i in range(len(tmp)):
        if tmp[i]!=a[i]:
            out+=1
    if out<count:
                count=out
print(count)
        

View Code

 

數據庫技術的根本目標是要解決數據共享的問題

儘管每一個進程都有本身的內存地址，不一樣的進程能夠同時將同一個內存頁面映射到本身的地址空間中，從而達到共享內存的目的

經典題目仍是不熟練

'''
53. 最大子序和
題目描述提示幫助提交記錄社區討論閱讀解答
隨機一題
給定一個整數數組 nums ，找到一個具備最大和的連續子數組（子數組最少包含一個元素），返回其最大和。

示例:

輸入: [-2,1,-3,4,-1,2,1,-5,4],
輸出: 6
解釋: 連續子數組 [4,-1,2,1] 的和最大，爲 6。
'''


class Solution:
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """

        sum=nums[0]
        maxi=-float('inf')
        if sum>maxi:
            maxi=sum
        for i in range(1,len(nums)):

            if sum<0:
                sum=nums[i]


            else:
                sum=sum+nums[i]
            if sum>maxi:
                maxi=sum
        return maxi
        

View Code

 很難的走棋問題:思路是逆過來,考慮最後一步你進入時候須要多少糧食,從而能夠逆着走到開始

[編程題] 走格子游戲
時間限制：1秒
空間限制：10485760K
G社正在開發一個新的戰棋類遊戲，在這個遊戲中，角色只能向2個方向移動：右、下。移動須要消耗行動力，遊戲地圖上劃分M*N個格子，當角色移動到某個格子上時，行動力就會加上格子上的值K（-100~100），當行動力<=0時遊戲失敗，請問要從地圖左上角移動到地圖右下角至少須要多少起始行動力，注意（玩家初始化到起始的左上角格子時也須要消耗行動力） 
輸入描述:
第一行輸入格子行列數（格式爲 M N），第2~M+1行每行輸入N個數，做爲格子值K，中間以空格分割；0 < M, N < 1000，-100 < K < 100


輸出描述:
初始最小行動力

輸入例子1:
2 3
-2 -3 3
-5 -10 1

輸出例子1:
6









a=[int(i) for i in input().split()]
ppp=a

matrix=[]

for i in range(a[0]):
    tmp=[int(j) for j in input().split()]
    matrix.append(tmp)




memo={}
def main(a,b):#返回v,表示進入這個點a,b時候必須帶多少食物
    if (a,b) in memo:
        return memo[a,b]
    if a==ppp[0]-1 and b==ppp[1]-1:
        memo[a,b]= max(1,1-matrix[a][b])
        return memo[a,b]
      
    if a!=ppp[0]-1 and b!=ppp[1]-1:
        case1=main(a+1,b)-matrix[a][b]
        case1=max(1,case1)
        case2=main(a,b+1)-matrix[a][b]
        case2=max(1,case2)
        memo[a,b]=  min(case1,case2)
        return memo[a,b]
    if  b==ppp[1]-1:
        case1=main(a+1,b)-matrix[a][b]
        case1=max(1,case1)
        
        memo[a,b]=  case1
        return memo[a,b]
    if a==ppp[0]-1 :
        case1=main(a,b+1)-matrix[a][b]
        case1=max(1,case1)
        memo[a,b]=  case1
        return memo[a,b]
print(main(0,0))
    
    
    
    

View Code

 

[編程題] 被3整除
時間限制：1秒
空間限制：32768K
小Q獲得一個神奇的數列: 1, 12, 123,...12345678910,1234567891011...。
而且小Q對於可否被3整除這個性質很感興趣。
小Q如今但願你能幫他計算一下從數列的第l個到第r個(包含端點)有多少個數能夠被3整除。

輸入描述:
輸入包括兩個整數l和r(1 <= l <= r <= 1e9), 表示要求解的區間兩端。


輸出描述:
輸出一個整數, 表示區間內能被3整除的數字個數。

輸入例子1:
2 5

輸出例子1:
3

例子說明1:
12, 123, 1234, 12345...
其中12, 123, 12345能被3整除。




'''
菲薄拿起數列到底有多少個是3的倍數
'''
#通過試驗,容易看出規律是 是,是,否,循環.
#a=[int(i) for i in input().split()]


a=[int(i) for i in input().split()]

tmp=a[0]
num1=a[0]//3*2
res=a[0]-a[0]//3*3
if res==1:
    res=0
if res==2:
    res=1
if res==3:
    res=2
num1+=res









tmp=a[1]
num2=a[1]//3*2
res=a[1]-a[1]//3*3
if res==1:
    res=0
if res==2:
    res=1
if res==3:
    res=2
num2+=res
if a[0]%3==0 or a[0]%3==2:
    out=num2-num1+1
else:
    out=num2-num1
print(out)

View Code

 揹包神馬的最愛,果斷遞歸加轉tuple 字典記憶法便可.

[編程題] 牛牛的揹包問題
時間限制：1秒
空間限制：32768K
牛牛準備參加學校組織的春遊, 出發前牛牛準備往揹包裏裝入一些零食, 牛牛的揹包容量爲w。
牛牛家裏一共有n袋零食, 第i袋零食體積爲v[i]。
牛牛想知道在整體積不超過揹包容量的狀況下,他一共有多少種零食放法(整體積爲0也算一種放法)。

輸入描述:
輸入包括兩行
第一行爲兩個正整數n和w(1 <= n <= 30, 1 <= w <= 2 * 10^9),表示零食的數量和揹包的容量。
第二行n個正整數v[i](0 <= v[i] <= 10^9),表示每袋零食的體積。


輸出描述:
輸出一個正整數, 表示牛牛一共有多少種零食放法。

輸入例子1:
3 10
1 2 4

輸出例子1:
8

例子說明1:
三種零食整體積小於10,因而每種零食有放入和不放入兩種狀況，一共有2*2*2 = 8種狀況。






a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]

#a=[1,1]
#b=[2]
memo={}
def main(left,a):
    if (left,tuple(a)) in memo:
        return memo[(left,tuple(a))]
    if a==[]:
        return 1
    
    case1=main(left,a[1:])
    case2=0
    if a[0]<=left:
     case2=main(left-a[0],a[1:])
     
    memo[(left,tuple(a))]= case1+case2
    return memo[(left,tuple(a))]
print(main(a[1],b))

View Code

 

 

[編程題] 迷路的牛牛
時間限制：1秒
空間限制：32768K
牛牛去犇犇老師家補課，出門的時候面向北方，可是如今他迷路了。雖然他手裏有一張地圖，可是他須要知道本身面向哪一個方向，請你幫幫他。 
輸入描述:
每一個輸入包含一個測試用例。
每一個測試用例的第一行包含一個正整數，表示轉方向的次數N(N<=1000)。
接下來的一行包含一個長度爲N的字符串，由L和R組成，L表示向左轉，R表示向右轉。


輸出描述:
輸出牛牛最後面向的方向，N表示北，S表示南，E表示東，W表示西。

輸入例子1:
3
LRR

輸出例子1:
E


a=int(input())
b=input()
#a=3
#b='LRR'
count=0
for i in b:
    if i=='L':
        count-=1
    else:
        count+=1
out=['W','N','E','S']

print(out[(1+count)%4])

View Code

 請用文字描述 Hadoop 的 MapReduce 計算模型，能夠從任務的提交、運行、交互、結束等階段詳細描述。根據你所描述的過程模型，是否有能夠優化的空間？若是有，能夠羅列一些 hadoop 已經實現的優化點，同時提出你本身的優化方案。

高次冪的2進制求解法:

372. 超級次方
題目描述提示幫助提交記錄社區討論閱讀解答
隨機一題
你的任務是計算 ab 對 1337 取模，a 是一個正整數，b 是一個很是大的正整數且會以數組形式給出。

示例 1:

a = 2
b = [3]

結果: 8
示例 2:

a = 2
b = [1,0]

結果: 1024
致謝：

特別感謝 @Stomach_ache 添加這道題並建立全部測試用例。

class Solution:
    def superPow(self, a, b):
        """
        :type a: int
        :type b: List[int]
        :rtype: int
        """
        a1=''
        for i in range(len(b)):
             a1+=str(b[i])
        a1=int(a1)
        b=a1
        b=bin(b)[2:]
        
        c=[0]*len(b)
        tmp=a
        for i in range(0,len(b)):
            if i==0:
                c[-1]=a%1337
            else:
                tmp=tmp**2%1337
                c[-i-1]=tmp
        out=1
        for i in range(len(b)):
            if b[i]=='1':
                out*=c[i]
                out%=1337
        return out
        
        
        

View Code

 今日頭條很精彩的題目:  本身沒作出來,看了別人的方法. 學習了.若是取值範圍很小,能夠考慮遍歷取值範圍來找!!

[編程題] 編程題2
時間限制：3秒
空間限制：131072K
給定一個數組序列, 須要求選出一個區間, 使得該區間是全部區間中通過以下計算的值最大的一個：
區間中的最小數 * 區間全部數的和最後程序輸出通過計算後的最大值便可，不須要輸出具體的區間。如給定序列  [6 2 1]則根據上述公式, 可獲得全部能夠選定各個區間的計算值:
 
[6] = 6 * 6 = 36;
[2] = 2 * 2 = 4;
[1] = 1 * 1 = 1;
[6,2] = 2 * 8 = 16;
[2,1] = 1 * 3 = 3;
[6, 2, 1] = 1 * 9 = 9;
 
從上述計算可見選定區間 [6] ，計算值爲 36， 則程序輸出爲 36。
區間內的全部數字都在[0, 100]的範圍內;

輸入描述:
第一行輸入數組序列長度n，第二行輸入數組序列。
對於 50%的數據,  1 <= n <= 10000;
對於 100%的數據, 1 <= n <= 500000;


輸出描述:
輸出數組通過計算後的最大值。

輸入例子1:
3
6 2 1

輸出例子1:
36






#最小值爲tmp那麼,能擴多大

n=int(input())
list1=[int(i) for i in input().split()]



out=0
for tmp in range(101):
    
    sum=0
    
    list1.append(0)#爲了最後停下來
    for i in range(len(list1)):
        if list1[i]>=tmp:
            sum+=list1[i]
        else:
              out=max(sum*tmp,out)
              sum=0
print(out)

View Code

 奶牛題:

[編程題] 奶牛編號
時間限制：1秒
空間限制：32768K
牛牛養了n只奶牛,牛牛想給每隻奶牛編號,這樣就能夠垂手可得地分辨它們了。 每一個奶牛對於數字都有本身的喜愛,第i只奶牛想要一個1和x[i]之間的整數(其中包含1和x[i])。
牛牛須要知足全部奶牛的喜愛,請幫助牛牛計算牛牛有多少種給奶牛編號的方法,輸出符合要求的編號方法總數。 
輸入描述:
輸入包括兩行,第一行一個整數n(1 ≤ n ≤ 50),表示奶牛的數量 第二行爲n個整數x[i](1 ≤ x[i] ≤ 1000)


輸出描述:
輸出一個整數,表示牛牛在知足全部奶牛的喜愛上編號的方法數。由於答案可能很大,輸出方法數對1,000,000,007的模。

輸入例子1:
4
4 4 4 4

輸出例子1:
24



a=int(input())
b=[int(i) for i in input().split()]
b.sort()
out=1
for i in range(len(b)):
    out*=b[i]-i
print(out%int(1e9+7))

View Code

 又沒作出來,仍是基本技能不熟練,看的別人的啓發.  關鍵是重要技能 如何求解兩個子串的最長公共子序列不熟練.

[編程題] 平方串
時間限制：1秒
空間限制：32768K
若是一個字符串S是由兩個字符串T鏈接而成,即S = T + T, 咱們就稱S叫作平方串,例如"","aabaab","xxxx"都是平方串.
牛牛如今有一個字符串s,請你幫助牛牛從s中移除儘可能少的字符,讓剩下的字符串是一個平方串。換句話說,就是找出s的最長子序列而且這個子序列構成一個平方串。 
輸入描述:
輸入一個字符串s,字符串長度length(1 ≤ length ≤ 50),字符串只包括小寫字符。


輸出描述:
輸出一個正整數,即知足要求的平方串的長度。

輸入例子1:
frankfurt

輸出例子1:
4


a=input()
memo={}
def main(s1,s2,a,b):#返回嚴格以index a結尾的s1的子串和嚴格以index b結尾的s2的子串
    if (s1,s2,a,b) in memo:
        return memo[(s1,s2,a,b)]
    if a==0:
        if s1[0] in s2[:b+1]:
            return 1
        else:
            return 0
    if b==0:
        if s2[0] in s1[:a+1]:
            return 1
        else:
            return 0
    if s1[a]==s2[b]:
        case1=main(s1,s2,a-1,b-1)+1
    else:
        case1=0

    case2=main(s1,s2,a-1,b)
    case3=main(s1,s2,a,b-1)
    memo[(s1,s2,a,b)]=max(case1,case2,case3)
    return memo[(s1,s2,a,b)]
out=0
for i in range(len(a)-1):
    first=a[:i+1]
    second=a[i+1:]
    out=max(out,main(first,second,len(first)-1,len(second)-1))
print(out*2)

View Code

兩個子串的最長公共子序列不熟練.  這個代碼要多聯繫.當成經常使用的模塊來寫        效率N^2

'''
最長公共子序列
'''
def main(s1,s2,a,b):#返回嚴格以index a結尾的s1的子串和嚴格以index b結尾的s2的子串
    #的最長公共子序列的長度.
    if a==0:
        if s1[0] in s2[:b+1]:
            return 1
        else:
            return 0
    if b==0:
        if s2[0] in s1[:a+1]:
            return 1
        else:
            return 0
    if s1[a]==s2[b]:
        case1=main(s1,s2,a-1,b-1)+1
    else:
        case1=0

    case2=main(s1,s2,a-1,b)
    case3=main(s1,s2,a,b-1)
    return max(case1,case2,case3)
a='frank'
b='furt'

print(main(a,b,len(a)-1,len(b)-1))

View Code

兩個子串的最長公共子串.                   效率N^2            注意把握這2個代碼的區別,只是初始化時有區別:1.子序列的用in  2.子串的用==第二個數組最後一個判斷!

'''
最長公共子串
'''
a=input()
b=input()
def main(s1,s2,a,b):#返回嚴格以index a結尾的s1的子串和嚴格以index b結尾的s2的子串
    #的最長公共子序列的長度.
    if a==0:
        if s1[0] ==s2[b]:
            return 1
        else:
            return 0
    if b==0:
        if s2[0] in s1[a]:
            return 1
        else:
            return 0
    if s1[a]==s2[b]:
        case1=main(s1,s2,a-1,b-1)+1
    else:
        case1=0

    case2=main(s1,s2,a-1,b)
    case3=main(s1,s2,a,b-1)
    return max(case1,case2,case3)

print(main(a,b,len(a)-1,len(b)-1))

View Code

 補括號

[編程題] 缺失的括號
時間限制：1秒
空間限制：65536K
一個完整的括號字符串定義規則以下:
1、空字符串是完整的。
2、若是s是完整的字符串，那麼(s)也是完整的。
3、若是s和t是完整的字符串，將它們鏈接起來造成的st也是完整的。
例如，"(()())", ""和"(())()"是完整的括號字符串，"())(", "()(" 和 ")"是不完整的括號字符串。
牛牛有一個括號字符串s,如今須要在其中任意位置儘可能少地添加括號,將其轉化爲一個完整的括號字符串。請問牛牛至少須要添加多少個括號。 
輸入描述:
輸入包括一行,一個括號序列s,序列長度length(1 ≤ length ≤ 50).
s中每一個字符都是左括號或者右括號,即'('或者')'.


輸出描述:
輸出一個整數,表示最少須要添加的括號數

輸入例子1:
(()(()

輸出例子1:
2












data=input()

tmp=[]
for i in range(len(data)):
    if data[i]=='(':
        tmp.append(1)
    else:
        tmp.append(-1)
k=0
out=0
import copy
old=tmp
old=copy.deepcopy(tmp)
for i in range(len(old)):
    
    while k<len(tmp)-1:

        if tmp[k]==1 and tmp[k+1]==-1:
            tmp.pop(k)
            tmp.pop(k)
            
            out+=1
        else:
            k+=1
    k=0

print(len(old)-out*2)

View Code

 restful 

https://baijiahao.baidu.com/s?id=1605768542638539831&wfr=spider&for=pc

[編程題] 括號匹配
時間限制：1秒
空間限制：32768K
通常的括號匹配問題是這樣的：
給出一個字符串，判斷這個括號匹配是否是合法的括號匹配。
如"((" 和 "())"都不是合法的括號匹配，可是"()()()"，"(()())()"等就是合法的括號匹配。
這個問題解決起來很是簡單，相信你們都知道怎麼解決。
如今給出一個增強版的括號匹配問題： 給出n個由括號 '(' 和 ‘)’ 組成的字符串，請計算出這些字符串中有多少對字符串知足si + sj是合法的括號匹配。若是si + sj和sj + si都是合法的括號匹配(i ≠ j)，那麼這兩種搭配都須要計入答案；若是對於si，si + si是合法的括號匹配，那麼也須要計入答案。


輸入描述:
第一行是一個整數n，表示字符串的個數；
接下來n行是n個非空字符串，所有由'('和')'組成。
1 <= n <= 3 * 105，字符串的長度之和不超過3 * 105。


輸出描述:
一個整數，表示知足條件的字符串對的數量。

輸入例子1:
3
()
(
)

輸出例子1:
2

輸入例子2:
5
(()
)))))
()()()
(((
))

輸出例子2:
1

 驗證bst:

很是牛逼代碼:

class Solution(object):
    def ValidBST(self,root,min,max):
        if (root is None):
            return True
        elif (root.val <= min or root.val >= max):
            return False
        else:
            return (self.ValidBST(root.left,min,root.val) and self.ValidBST(root.right,root.val,max))
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.ValidBST(root,-2**62,2**62)

View Code

 【單選】在卷積神經網絡計算中，已知輸入特徵層大小爲32x32x64, 使用標準卷積計算，帶偏置項，卷積核大小爲3*3，輸出特徵層數目爲64，

請問卷積層的參數個數爲？

特徵是64 輸出64 中間是9 kernal 乘起來是64*64*9

偏執項是64 因此加起來36928 ,偏執項跟核大小,特徵多少無關,他們都共用.只跟輸出特徵有關.

 

42

【單選】對於非連續目標在深度神經網絡的優化過程當中，下面哪一種梯度降低方法是最好的？

正確答案: D   你的答案: 空 (錯誤)

AdaGrad

SGD

L-BFGS

Subgradient method

 次梯度降低法:就是用單側極限來代替極限,從而對不可導函數也能求導.

 

 

 

【單選】強化學習中，TD(lambda）算法中 lambda取值爲1時等價於如下哪一種模型

正確答案: B   你的答案: 空 (錯誤)

動態規劃

蒙特卡洛

Q- learning

Sarsa





算法競賽書的題目:

'''



算法競賽入門經典(第二版)
表達式樹:

class node():
    def __init__(self,a):
        self.left=None
        self.right=None
        self.val=a
print(node(3))
def build_tree(s):
    if s[0]=='(' and s[-1]==')':
        s=s[1:-1]
    if len(s)==1:
        a=node(s)
        return a
    if ')'in s:
        end=s.rindex(')')
        first=s.index('(')
        
        jiajian=[]
        chengchu=[]
        #下面狀況就沒有括號了
        for i in range(len(s)):
            if i in range(first,end):
                continue
            if s[i]=='+' or s[i]=='-':
                jiajian.append(i)
            if s[i]=='*' or s[i]=='/':
                chengchu.append(i)       
        
        if jiajian==[]:
            final=chengchu[-1]
        else:
            final=jiajian[-1]
        
        
        
        
        
        
    else:
        #無括號狀況.
        #好比s=a+b*c+d-e
        

        
        jiajian=[]
        chengchu=[]
        #下面狀況就沒有括號了
        for i in range(len(s)):
    
            if s[i]=='+' or s[i]=='-':
                jiajian.append(i)
            if s[i]=='*' or s[i]=='/':
                chengchu.append(i)       
        
        if jiajian==[]:
            final=chengchu[-1]
        else:
            final=jiajian[-1]
        
        
        
        
        
    #final就是最後須要的分割點
    
    print(final)
    print('#############')
    a=node(s[final])
    a.left=build_tree(s[:final])
    a.right=build_tree(s[final+1:])
    
    
    return a
        
    
    
    
    
    
    
    
s='a+b*(c-d)-c/f'
#效果還不錯
print(build_tree(s).val)
    












'''

View Code

 一個雙函數遞歸,加記憶體的題目

'''
程序員面試代碼指南

排成一條直線的紙牌博弈問題.

arr=[1,2,100,4] 返回101
arr=[1,100,2]   返回100

定義f(i,j)表示arr[i,j]這個拍若是先拿會得的分數
定義s(i,j)表示arr[i,j]這個拍若是後拿會得的分數
下面的區間表示包含端點.
若是i==j,那麼f(i,j)=arr[i]  s(i,j)=0.
若是j>i,那麼就有f(i,j)=max(s[i+1,j]+arr[i],arr[j]+s[i,j-1])
s(i,j)=min(f[i+1,j],f[i,j-1])

#由於s是當前步的後拿的那一我的,由於對方是聰明絕頂的,因此我只能去到min!!!!!
#這步很重要,我一開始取得max就錯了.

'''



def f(i,j):
    if i==j:
        return arr[i]
    else:
        return max(s(i+1,j)+arr[i],arr[j]+s(i,j-1))
def s(i,j):
    if i==j:
        return 0
    else:
        return min(f(i+1,j),f(i,j-1))

arr=[1,2,100,4]
print(max(f(0,len(arr)-1),s(0,len(arr)-1)))
print(s(0,len(arr)-1))

View Code

 上個題目改爲記憶體:

def f(i,j):
    if (i,j)in memo1:
        return memo1[(i,j)]
    if i==j:
        return arr[i]
    else:
        memo1[(i,j)]=max(s(i+1,j)+arr[i],arr[j]+s(i,j-1))
        return memo1[(i,j)]
def s(i,j):
    if (i,j)in memo2:
        return memo2[(i,j)]
    if i==j:
        return 0
    else:
        memo2[(i,j)]=min(f(i+1,j),f(i,j-1))
        return memo2[(i,j)]

arr=[1,2,1000,40]*250

memo1={}
memo2={}
print(max(f(0,len(arr)-1),s(0,len(arr)-1)))

View Code

 

程序員代碼面試指南的部分題目:

# -*- coding: utf-8 -*-
"""
Spyder Editor

This is a temporary script file.
"""





# -*- coding: utf-8 -*-
"""
Created on Fri Jul 20 10:58:02 2018

#若是跑不了就是編碼問題,用記事本另存一下,把編碼改爲utf-8保存便可.
#3d圖片利用cmd跑這種畫圖程序,就能旋轉圖片了.spyder不能旋轉
@author: 張博
"""




'''
讀取csv最穩的方法:
import pandas as pd
f = open('/Users/michael/gbk.csv', 'r', encoding='gbk', errors='ignore')
data = pd.read_csv(f,header=None)



'''


'''
畫圖模板:
from matplotlib import pyplot
data=[]
pyplot.plot(data,color='black')
pyplot.show()

'''



'''
獲取當前時間:
import datetime
nowTime=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')#如今
nowTime=((nowTime)[:-3])
print(nowTime)
'''


'''
寫文件的模板
with open(r'c:/234/wucha.txt','w') as f:
      wucha=str(wucha)
      f.write(wucha)
'''



'''
手動加斷電的方法:raise 
'''


'''
excel表格實用技巧:
全選而後選開始-行和列-最適合的列寬.
這樣看錶格清晰多了!
'''


'''
時間序列畫圖
from matplotlib import pyplot
#畫布大小
pyplot.rcParams['figure.figsize'] = (300, 3) # 設置figure_size尺寸
import matplotlib.dates as mdates
ax=plt.gca()
pyplot.rcParams['image.cmap'] = 'gray' # 
xfmt = mdates.DateFormatter('%y-%m-%d %H:%M')
ax.xaxis.set_major_formatter(xfmt)
#下面這個是時間序列的間隔時間
plt.xticks(pd.date_range(data[0][0],data[-1][0],freq='2H'),rotation=90)
#樣式
pyplot.plot(data[:,0],data[:,1],color='red',linewidth = 0.7)

pyplot.show()
'''



'''
#畫3d
import  matplotlib.font_manager as fm
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D



from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (3, 3) # 設置figure_size尺寸


fig=plt.figure()

ax3d=Axes3D(fig)    #繪製3D圖形
ax3d.scatter(data[:,1],data[:,2],data[:,0],c='r',marker=".")

pyplot.show()
'''


'''
非數值編碼
#編碼
from sklearn.preprocessing import LabelEncoder

a=a.values #切換成ndarry

encoder = LabelEncoder()
for i in range(5):
 a[:,i] = encoder.fit_transform(a[:,i])
'''



'''
#標準化
from sklearn.preprocessing import MinMaxScaler



scaler = MinMaxScaler(feature_range=(0, 1))
a = scaler.fit_transform(a)
print(a)
'''




'''
降維可視化:


from sklearn.manifold import TSNE
#data能夠是多少維均可以,都能降成2維
tsne=TSNE()
tsne.fit_transform(data)  #進行數據降維,降成兩維
#a=tsne.fit_transform(data_zs) #a是一個array,a至關於下面的tsne_embedding_
tsne=pd.DataFrame(tsne.embedding_) #轉換數據格式

print(tsne)

tsne['聚類類別']=label_pred
print(tsne)
d=tsne[tsne[u'聚類類別']==0]
plt.plot(d[0],d[1],'r.')
 
d=tsne[tsne[u'聚類類別']==1]
plt.plot(d[0],d[1],'go')

d=tsne[tsne[u'聚類類別']==2]
plt.plot(d[0],d[1],'b*')

d=tsne[tsne[u'聚類類別']==3]
plt.plot(d[0],d[1],'y+')
plt.show()





#map基本用法:另一個就是reduce,把上一步的結果迭代到寫一個.比較花哨.不寫了


a=map(str,[1,2,3,4])
b=[print(type(i)) for i in a]
#從下面這個看出來若是列表生成式即List Comprehensions 裏面的套用函數是一個無返回值的,那麼就返回None
#b的觸發效果就是打印這些type,這個寫法很方便,比for循環方便多了.
print(b)



'''


'''
#sort基本用法

print(sorted([36, 5, -12, 9, -21], key=abs))
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower))
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True))


#lambda函數:
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

'''




'''

#裝飾器例子:給now函數加一個功能,調用以前打印這個函數的名字.

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    
    

    return wrapper


@log
def now():
    print('2015-3-25')
now()










#偏函數:把一個函數傳好參數以後定義爲一個新的函數
def int2(x, base=2):
    return int(x, base)
print(int2('1011010'))


'''

'''
給實例加一個方法和給類加一個方法:

class Student(object):
    pass
s = Student()



def set_age(self, age): # 定義一個函數做爲實例方法
  self.age = age



from types import MethodType



s.set_age = MethodType(set_age, s) # 給實例綁定一個方法

s.set_age(25) # 調用實例方法
print(s.age)

#下面是給類加一個方法,直接=賦值便可,一上這兩種動態加入方法的方法教動態方法.
def set_score(self, score):
   self.score = score

Student.set_score = set_score
s.set_score(100)
print(s.score)



#限制實例加入的方法:slot函數,只能加入name和age兩個函數
bb
    
class Student(object):
    __slots__ = ('name', 'age') # 用tuple定義容許綁定的屬性名稱

def set_score(self, score):
   self.score = score

Student.set_score = set_score
s=Student()
s.set_score(3)

print(s.score)
'''



'''
property函數:
   
    
    
    
class Student(object):

    @property  #利用property和 .setter,函數來實現對函數變量的檢查.
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value
a=Student()
a.score=324.4
print(a.score)

    
    
    
    

'''

'''


#json和字典互轉

import json
d = dict(name='Bob', age=20, score=88)
print(json.dumps(d))

json_str=json.dumps(d)
print(json.loads(json_str))
print(type(json.loads(json_str)))


'''





'''
總結一下就是，多任務的實現有3種方式：

多進程模式；
多線程模式；
多進程+多線程模式。

多進程
#奇怪用cmd就能跑這個程序,spyder就不行

from multiprocessing import Pool
import os, time, random

def long_time_task(name):
    print('Run task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Pool(4) #多個進程的書寫用pool管理更方便,否則須要不少的join很煩
    for i in range(5):
        p.apply_async(long_time_task, args=(i,))
    print('Waiting for all subprocesses done...')
    p.close() #必須在join前面寫上關閉pool
    p.join()  #表示Pool裏面的子進程都跑完了,纔開始運行下面的代碼.
    print('All subprocesses done.')




#用queue來作兩個進程之間的通訊.
from multiprocessing import Process, Queue
import os, time, random

def write(q):
    print('Process to write: %s' % os.getpid())
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())

# 讀數據進程執行的代碼:
def read(q):
    print('Process to read: %s' % os.getpid())
    while True:
        value = q.get(True)
        print('Get %s from queue.' % value)

if __name__=='__main__':
    # 父進程建立Queue，並傳給各個子進程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 啓動子進程pw，寫入:
    pw.start()
    # 啓動子進程pr，讀取:
    pr.start()
    # 等待pw結束:
    pw.join()
    # pr進程裏是死循環，沒法等待其結束，只能強行終止:
    pr.terminate()
'''



'''
#線程之間共用類,用xxx=threading.local()建立.


import threading


# 建立全局ThreadLocal對象:  本質是線程都共享這個類,而後每一個線程的對象是這個類的一個對象
#用字典實現的,對象=字典[線程號]
local_school = threading.local()

def process_student():
    # 獲取當前線程關聯的student:
    std = local_school.student
    print('Hello, %s (in %s)' % (std, threading.current_thread().name))
    print(threading.current_thread())

def process_thread(name):
    # 綁定ThreadLocal的student:
    local_school.student = name
    process_student()

t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A')

#好比t1這個線程:先進入process_thread函數,而後進入process_student函數.
#由於local_school是thread.local的資源,因此不一樣線程之間不共享.

t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()



'''






'''
用異步IO編程模型來實現多任務是一個主要的趨勢。

對應到Python語言，單線程的異步編程模型稱爲協程，有
了協程的支持，就能夠基於事件驅動編寫高效的多任務程序。咱們會在後面討論如何編寫協程。
'''




'''
對於未知編碼的bytes，要把它轉換成str，須要先「猜想」編碼。猜想的方式是先收集各類編碼的
特徵字符，根據特徵字符判斷，就能有很大機率「猜對」。

固然，咱們確定不能從頭本身寫這個檢測編碼的功能，這樣作費時費力。chardet這個第三方庫正好
就派上了用場。用它來檢測編碼，簡單易用。



import chardet

data = '離離原上草，一歲一枯榮'.encode('utf-8')
print(chardet.detect(data))
'''


'''
#python 運維

物理內存（RAM）指的是RAM（即內存條）提供的臨時數據存儲空間
交換區指Unix/Linux系統前臺與後臺之間數據交換的場所，即爲Unix/Linux系統的虛擬內存

虛擬內存泛指將臨時數據存儲於磁盤存儲器上的技術（簡單點說就是劃出一部分磁盤做爲臨時的R
AM），Windows系統的「虛擬內存」，Linux系統的「交換區」都是虛擬內存


import psutil
print(psutil.cpu_count()) # CPU邏輯數量)
print(psutil.cpu_count(logical=False))# CPU物理核心
print(psutil.cpu_times())
#再實現相似top命令的CPU使用率，每秒刷新一次，累計10次：
for x in range(1):
   print(psutil.cpu_percent(interval=1, percpu=True))


print(psutil.virtual_memory())
print(psutil.swap_memory())
print(psutil.disk_partitions())
print(psutil.disk_usage('/'))
print(psutil.disk_io_counters())
print(psutil.net_io_counters() )
print(psutil.net_if_addrs())
print(psutil.pids())
print(psutil.test())
'''




'''
網絡通訊:
    網絡通訊是兩臺計算機上的兩個進程之間的通訊。
端口有什麼做用？在兩臺計算機通訊時，只發IP地址是不夠的，由於同一臺計算機上跑着多個網絡
程序。一個TCP報文來了以後，究竟是交給瀏覽器仍是QQ，就須要端口號來區分。每一個網絡程序都向
操做系統申請惟一的端口號，這樣，兩個進程在兩臺計算機之間創建網絡鏈接就須要各自的IP地址和
各自的端口號。

#TCP,UDP就是用socket!來實現的.
#TCP編程服務端:

import threading
import socket
import time

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#SOCK_STREAM表示TCP

# 監聽端口:
s.bind(('127.0.0.1', 9999))  #跟下面的客戶端端口要一致.

s.listen(5)#傳入的參數指定等待鏈接的最大數量：
print('Waiting for connection...')





#每一個鏈接都必須建立新線程（或進程）來處理，不然，單線程在處理鏈接的過程當中，沒法接受其餘客戶端的鏈接：
def tcplink(sock, addr):
    print('Accept new connection from %s:%s...' % addr)
    sock.send(b'Welcome!')
    while True:
        data = sock.recv(1024)
        time.sleep(1)
        if not data or data.decode('utf-8') == 'exit':
            break
        sock.send(('Hello, %s!' % data.decode('utf-8')).encode('utf-8'))
    sock.close()
    print('Connection from %s:%s closed.' % addr)
while True:
    # 接受一個新鏈接:
    sock, addr = s.accept()
    # 建立新線程來處理TCP鏈接:
    t = threading.Thread(target=tcplink, args=(sock, addr))
    t.start()
    
    
#TCP配套客戶端:
import socket
    
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 創建鏈接:
s.connect(('127.0.0.1', 9999))
# 接收歡迎消息:
print(s.recv(1024).decode('utf-8'))
for data in [b'Michael', b'Tracy', b'Sarah']:
    # 發送數據:
    s.send(data)
    print(s.recv(1024).decode('utf-8'))
s.send(b'exit')
s.close()




UDP的通訊寫法:使用UDP協議時，不須要創建鏈接，只須要知道對方的IP地址和端口號，
            就能夠直接發數據包。可是，能不能到達就不知道了。
            
            


#UDP服務器的寫法.
import threading
import socket
import time
#SOCK_DGRAM表示UDP
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 綁定端口:
s.bind(('127.0.0.1', 9999))
print('Bind UDP on 9999...')
while True:
    # 接收數據:
    data, addr = s.recvfrom(1024)
    print('Received from %s:%s.' % addr)
    s.sendto(b'Hello, %s!' % data, addr)
#UDP客戶端
import threading
import socket
import time    
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
for data in [b'Michael', b'Tracy', b'Sarah']:
    # 發送數據:
    s.sendto(data, ('127.0.0.1', 9999))
    # 接收數據:
    print(s.recv(1024).decode('utf-8'))
s.close()
'''

















'''
數據庫
一行記錄能夠對應一個表.就叫關聯性數據庫.






import sqlite3
# 若是文件不存在，會自動在當前目錄建立:
conn = sqlite3.connect('test.db')
# 建立一個Cursor:
cursor = conn.cursor()
# 執行一條SQL語句，建立user表:
cursor.execute('create table user (id varchar(20) primary key, name varchar(20))')
# 繼續執行一條SQL語句，插入一條記錄:
cursor.execute('insert into user (id, name) values (\'1\', \'Michael\')')

# 經過rowcount得到插入的行數:
print(cursor.rowcount)

# 關閉Cursor:
cursor.close()
# 提交事務:
conn.commit()
# 關閉Connection:
conn.close()
conn = sqlite3.connect('test.db')
cursor = conn.cursor()

cursor.execute('select * from user where id=?', ('1',))

values = cursor.fetchall()

print(values)
'''



'''


#mysql安裝:pip install mysql-connector
import mysql.connector
#默認是沒有密碼的
conn = mysql.connector.connect(user='root', password='', database='test')

cursor = conn.cursor()

#簡歷一個叫user的表
cursor.execute('create table user (id varchar(20) primary key, name varchar(20))')

cursor.execute('insert into user (id, name) values (%s, %s)', ['1', 'Michael'])

print(cursor.rowcount)
conn.commit() #提交操做
cursor.close()

cursor = conn.cursor()


cursor.execute('select * from user where id = %s', ('1',))

values = cursor.fetchall()

print(values)

cursor.close()

conn.close()



'''


'''
在Python中，最有名的ORM框架是SQLAlchemy。咱們來看看SQLAlchemy的用法。

做用就是讀取數據的每一行爲一個object對象.







# 導入:
from sqlalchemy import Column, String, create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# 建立對象的基類:
Base = declarative_base()

# 定義User對象:
class User(Base):
    # 表的名字:
    __tablename__ = 'user'

    # 表的結構:
    id = Column(String(20), primary_key=True)
    name = Column(String(20))

# 初始化數據庫鏈接:
engine = create_engine('mysql+mysqlconnector://root:@localhost:3306/test')
# 建立DBSession類型:
DBSession = sessionmaker(bind=engine)
#添加操做
# 建立session對象:
session = DBSession()
# 建立新User對象:
new_user = User(id='5', name='Bob')
# 添加到session:
session.add(new_user)
# 提交即保存到數據庫:
session.commit()
# 關閉session:
session.close()

#查詢操做
# 建立Session:
session = DBSession()
# 建立Query查詢，filter是where條件，最後調用one()返回惟一行，若是調用all()則返回全部行:
user = session.query(User).filter(User.id=='5').one()
# 打印類型和對象的name屬性:
print('type:', type(user))
print('name:', user.name)
# 關閉Session:
session.close()
'''



'''
異步

看起來A、B的執行有點像多線程，但協程的特色在因而一個線程執行，那和多線程比，協程有何優點？
最大的優點就是協程極高的執行效率。由於子程序切換不是線程切換，而是由程序自身控制，所以，沒有
線程切換的開銷，和多線程比，線程數量越多，協程的性能優點就越明顯。
第二大優點就是不須要多線程的鎖機制，由於只有一個線程，也不存在同時寫變量衝突，在協程中控制共享
資源不加鎖，只須要判斷狀態就行了，因此執行效率比多線程高不少。











#異步io框架,兩個任務同時打印同時等待

import threading
import asyncio

@asyncio.coroutine
def hello():
    print('Hello world! (%s)' % threading.currentThread())
    yield from asyncio.sleep(1)
    print('Hello again! (%s)' % threading.currentThread())

loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()


'''

'''
經常使用的樹結構:
    
class node():
    def __init__(self,val):
        self.val=val
        self.left=None
        self.right=None  
        
        
        
#一個比較奇怪的是:a=b.right 那麼修改a的時候不會修改b.right的.
#修改b.right只能修改b.right=c 即修改樹的值只能從父節點修改,修改
#節點自身沒用.緣由就是python的=賦值修改是按照值來存儲的,不是地址
        
'''







'''
程序員面試代碼指南

排成一條直線的紙牌博弈問題.

arr=[1,2,100,4] 返回101
arr=[1,100,2]   返回100

定義f(i,j)表示arr[i,j]這個拍若是先拿會得的分數
定義s(i,j)表示arr[i,j]這個拍若是後拿會得的分數
下面的區間表示包含端點.
若是i==j,那麼f(i,j)=arr[i]  s(i,j)=0.
若是j>i,那麼就有f(i,j)=max(s[i+1,j]+arr[i],arr[j]+s[i,j-1])
s(i,j)=min(f[i+1,j],f[i,j-1])

#由於s是當前步的後拿的那一我的,由於對方是聰明絕頂的,因此我只能去到min!!!!!
#這步很重要,我一開始取得max就錯了.

'''








#跳躍遊戲

arr=[3,2,3,1,1,4]
count=0
def main(arr):
    global count
    first=arr[0]
    if first>=len(arr)-1:
        count+=1
        return 
    tmp=arr[1:first+1]
    for i in range(len(tmp)):
        tmp[i]+=i
    
    
    m=max(tmp)
    tmp=tmp[::-1]
    m=tmp.index(m)
    m=len(tmp)-m
    arr=arr[m:]
    count+=1
    print(arr)
    
    return main(arr)
main(arr)
print(count)
    
    


#n皇后問題
#程序員面試指南P239
#遞歸方法來解最簡單,不用回溯法.代碼很是漂亮
def valid(record ,i,j):
    #跟以前i-1行是否衝突
    for k in range(i):
        if j==record[k] or abs(record[k]-j)==abs(i-k):
            return False
    return True

def process(i,record,n):
    #函數表示第i行應該用多少來補,返回res
    if i==n:
        return 1
    res=0
    for j in range(n):
        if valid(record,i,j):
            record[i]=j
            res+=process(i+1,record,n)#這步進行遞歸
    return res

def num(n):
    if (n<1):
        return 0
    record=[0]*n
    return process(0,record,n)

print(num(10))





#字符串中數字子串的和
def main(s):
    save=''
    #掃描斷定便可
    for i in range(len(s)):
      if i!=0:
        if s[i-1] in '0123456789' and s[i]=='-':
            save+='*'
            save+='-'
        if s[i] in '0123456789' or s[i] =='-':
            save+=s[i]
        elif     s[i-1] in '0123456789' or s[i-1]=='-':
            save+='*'
      if i==0:
          if s[i] in '0123456789' or s[i] =='-':
              save+=s[i]
    #最後用try來轉化類型便可.
    return save#減號前面若是是數字也加*
print(main('1-----A1CD2huujoE--33--9'))






#去掉字符串中連續出現的k個0的子串
def main(s,k):
    #遍歷一遍,把須要剔除的子串的尾dex放入數組中
    out=[]
    count=0
    for i in range(len(s)):
        if s[i]=='0':
            count+=1
            if count==k and i==len(s)-1:
                out.append(i)
            elif count==k and s[i+1]!='0':
                out.append(i)
        else:
            count=0
    return  out
print(main('A000B00',2)) #看出已經找打了全部須要找到的index

#判斷兩個字符是否互相是旋轉詞
def main(s1,s2):
    save={}
    for i in range(len(s1)):
        tmp=s1[i+1:]+s1[:i+1]
        save[tmp]=1
    return s2 in save
print(main('cdab','abcd'))





        



#替換字符串中連續出現的指定字符串
def main(s,from1,to):
    s=s.replace(from1,to,1) #參數1表示只替換1次
    s=s.replace(from1,'')
    return s
print(main('123abcabc','abc','X'))

#字符串的統計字符串
def main(s):
    s+='*'  #填補一個最後的廢字符,來保證邊緣點的判斷
    out=[]
    for i in range(len(s)):
        
        if i==0:
            tmp=s[0]
            count=1
        else:
            if s[i]==s[i-1]:
                count+=1
            else:
                
                out.append((tmp,count))
                tmp=s[i]
                count=1
    return out
print(main('aaabbadddffc'))

#判斷字符串中全部字符是否只出現一次
def main(s):
    return len(set(s))==len(s)
print(main('abc'))

#翻轉字符串
def main(s):
    s=s.split()
    s=s[::-1]
    s=' '.join(s) #表示用空格來相連s這個數組
    return s
print(main('dog loves pig'))
#數組中兩個字符串的最小距離
def main(s,s1,s2):
    if s1=='null' or s2=='null' or s1 not in s or s2 not in s:
        return -1
    else:
        first=-float('inf')
        second=-float('inf')
        out=float('inf')
        #從s的頭開始掃描,每讀一個s1的字符就跟s2的比較.
        #每讀到一個s2的字符集跟s1的位置first比較
        for i in range(len(s)):
            if s[i]==s1:
                first=i
                out=min(out,abs(first-second))
            if s[i]==s2:
                second=i
                out=min(out,abs(first-second))                
        return out
print(main('1333200000031','1','2'))
        
        
        
#添加最少的字符使得字符串的總體都是迴文字符串
'''
例子:'ABA' 返回'ABA'   由於不用添加
'AB' 返回'ABA' 由於這是最少的添加方案只添加兩個一個字符.
注意能夠往任意位置添加字符.
''' 
def main(s):
    if s==s[::-1]:
        return s
    else:
        if len(s)==2:
            return s+s[0]
        else:
            if s[0]==s[-1]:
               case1=s[0]+main(s[1:-1])+s[-1]
               case2='0'*999999 #爲了下面取min時候不發生未定義變量的bug
               case3='0'*999999
               
            else:
                case1=s[0]+s[-1]+main(s[1:-1])+s[-1]+s[0]
                case2=s[0]+main(s[1:])+s[0]
                case3=s[-1]+main(s[:-1])+s[-1]
            m=min(len(case1),len(case2),len(case3))

            if len(case1)==m:
                return case1
            elif len(case2)==m:
                return case2
            else:
                return case3
'''
動態規劃:
    s[i,j] 
'''
#媽的各類亂寫竟然好像能夠.
print(main('acbcdax'))    
    
    
    
#括號字符串的有效性和最長有效長度
#下面求解有效長度,動態規劃,實際上是一個挺難的題目
def final(s):
 
 def main(s,j):#返回值表示s的子串裏面必須以j_index結尾的子串裏面最長的有效括號.
    if j==0:
        return 0
    if j==1:
        if   s[0]=='(' and s[1]==')':
            return 2
        else:
            return 0
    if s[j]=='(':
        return 0
    else:
        #上一個字符用了多長
        last=main(s,j-1)
        pre=j-last-1
        if pre>=0 and s[pre]=='(':
            if pre>0:
                return last+2+main(s,pre-1)
            else:
                return last+2
 out=[]
 for j in range(len(s)):
     out.append(main(s,j))
 return max(out)
print (final('()(()()('))    
    
    
    
    
#0的左邊必須有1的二進制字符串的數量
'''
例子:N表示字符串的長度
    N=1時,返回1
    N=2時,返回2  10,11
    N=3時,返回3  101,110,111
    分析:
        也就是0不能放第一個位置上.100不對,由於第二個0的緊貼的左邊必須是1,不能是0
        因此就是101010這種排列才能夠.也就是10這個字符是捆綁的其餘時候必須是1字符,
'''
def main(N):
    if N==1:
        return 1
    if N==2:
        return 2
    # 打算用動態規劃來作
    #第一種狀況表示開始位置用10來填充
    case1=main(N-2)
    #第二種狀況表示開始位置用11來填充
    case2=main(N-1)
    return case1+case2
print(main(5)) #本體答案就是相似斐波那契數列







#拼接全部字符串產生的字典順序最小的字符串
def main(l,dex):
    
    
    
#動態規劃,返回利用到dex指標的子數組返回的最小的字符串.而後後面的往直前的字符串裏面插便可.
    if dex==0:
        return [l[0]]
    old=main(l,dex-1)
    i=0
    new=old[:i]+[l[dex]]+old[i:]
    for i in range(1,dex+1):#全部插的可能性都插一遍便可.
        new2=old[:i]+[l[dex]]+old[i:]
        if ''.join(new2)<''.join(new):
            new=new2
    return new

def final(l):
    return main(l,len(l)-1)
print(main(['b','ba'],1))  #雖然這個題目是4星的寫起來還能夠
print(final(['b','ba']))  #簡單封裝一下而已






#找到字符串的最長的無重複子串.
def main(s):
    #顯然動態規劃啊
    def solve(s,i):
        #返回s從0到i的這個子問題的結果.必須取到i.
        #作了這麼多子串問題,經典的套路就是子問題加一個條件尾巴必須取到這個index
        if i==0:
            return s[0]
        old =solve(s,i-1)
        if s[i]  not in old:
            return old+s[i]
        else:
            old=old[old.index(s[i])+1:]
            return old+s[i]
    tmp=[]
    for i in range(len(s)):
        tmp.append(solve(s,i))
    out=tmp[0]
    for i in tmp:
        if len(i)>len(out):
            out=i
    return out
print(main('aabcbabcdefg'))
    
#書上給的方法:用相同字符出現的index相減便可.其實很是難懂.關鍵是這個pre,總之很是巧妙!!!!!!!!!!
#pre表達的是上一個無重複字符串的最後一個index的位置.
def main(s):
    map=[-1]*256
    len1=0
    pre=-1
    tmp=0
    for i in range(len(s)):

        tmp=ord(s[i])
        pre=max(pre,map[tmp])
        cur=i-pre
        len1=max(len1,cur)
        map[tmp]=i
    return len1
print(main('aabcbabcdefg'))
        
        
#最小包含子串的長度
def main(s1,s2):
    for i in range(len(s2)):
        if s2[i] not in s1:
            return 0
    #按照書上寫的:設置一個統計量的哈希表.而後滑動窗口.須要就右華東,多了就作滑動
    memo={}
    for i in s2:
      if i in memo:
          memo[i]+=1
      else:
       memo.setdefault(i,1)    
    left=0

    right=0
    match=len(s2)
    out=float('inf')
    while right<len(s1):
        if s1[right] in s2 and memo[s1[right]]>0:
            memo[s1[right]]-=1      
            match-=1
        if match==0:#用match來判斷是否已經匹配好了
            #這時候說明已經匹配好了開始left右移動
            while match==0:
                tmp=right-left
                out=min(out,tmp)
                left+=1
                
       
#後面太難了先不寫了
#第六章:大數據和空間限制

'''
認識布隆過濾器:
    想要實現一個網頁過濾系統,能夠查詢url是否出如今網絡的黑名單上.
    就是多個哈希函數取交
'''                
            
            
'''
只用2GB內存在20億個數裏面找到出現次數最多的數

2GB存多少32位的數一個數是4byte.2gb=2*2^30
存2^29次冪個數也就是5億.
哈希分桶法:
    20億個數取mod 10這個哈希函數,這樣就分好桶了.數字同樣確定會跑同一個桶
    裏面,這樣每個桶.裏面你統計次數便可,用一個哈希map來統計便可.以後,返回
    每個桶裏面頻率最高的數,在10個數裏面再比一次便可.
    
'''
            
'''
40億個非負整數裏面找到沒出現的數
內存1GB
用bitmap便可:
    32位無符號數是43億個,43億個位的這個整數須要43億/8/10^3 個GB
    也就是0.5個GB就夠了.
進階問題:
    內存只有10mb,10mb存bitmap能夠存多少位.
    10*10^6*8=8千萬位. (由於一個byte 8位)
    須要64個桶便可.
'''     
            
            
'''
一致性哈希算法:
    集羣的策略:
        在數據庫上面的應用:
            1.不管是添加刪除仍是查詢數據,都是先把數據的id哈希一下,變成一個
            哈希值.
            2.若是有N太計算機,就mod n以後,給這個標號的計算機來實現這個操做
        這個須要一致性哈希算法,使用這個算法,當添加刪除機器時候不用從新
        算哈希值.
'''            
            
'''
不用額外空間交換2個整數的值
'''    
            
def main(a,b):
    a=a^b
    b=a^b
    a=a^b
    return a,b
print(main(3,5))
#如何記憶這個代碼:a^b返回a和b不一樣的信息,也就是體現的是哪些位a和b不一樣
#b=a^b這個代碼表示把b跟上面的a和b不一樣信息再取不一樣.因此b返回的就是原始的a
#(上面這句話怎麼看?按照每個位來看才行.對於一個位咱們最後要的是
'''


若是a跟b這個位置不同,咱們就取1,b在這個位置取0,咱們就取1,也就是這個位置
取跟b不同的,那麼跟a同樣麼.a,b已經不同了,因此這個位置取得就是須要的1) 

反之,若是a和b這個位置取得同樣,那麼取得仍是a                     
   '''         
            






'''
在一個其餘數都出現k次的數組中找到只出現一次的數(這個數只有一個)

每個數都轉化爲k進制以後,作無進位的加法.也就是每一個數位分開累加
'''



'''
第八章:

轉圈打印矩陣
'''
#每次打印第一行,而後去掉第一行,左旋轉90度便可.(轉90度,轉置後,[::-1])
print('第八章')
def main(a):
    import numpy as np
    a=np.array(a)
    out=[]
    while len(a[0])>0:
        for i in a[0]:
            out.append(i)
        a=a[1:]
        a=a.T
        
        a=a[::-1]
    return out
        
print(main([[1,2,89],[22,5,65767],[5454,454,454]]))


#找到無序數組中最小的k個數
'''
用大根堆便可.比大根堆的堆定還大就扔了,比堆頂小就插入堆中
'''


#在數組中找到出現次數大於N/K的數

#用哈希表確定能夠可是這裏面用另一個技巧來解.
#這個方法在不看數組內容的狀況下斷定是否有這樣的數,投票問題.
def main(l):
    #先解決在數組中找到出現次數大於一半的數,這個問題
    #按照順序讀生成cand,若是下一個數根cand同樣就跳過,不同就改cand爲*
    cand=l[0]
    for i in range(1,len(l)):
        if cand=='*':
            cand=l[i]
            continue
        if l[i] !=cand:
            cand='*'
    #而後再遍歷一次看cand的數量便可
    if cand=='*':
        return 0
    else:
        count=0
        for i in range(len(l)):
                if l[i]==cand:
                    count+=1
        if count>len(l)//2:
            return cand
        else:
            return 0
print(main([1,2,3,3,3]))


#進階問題:若是是在數組中找到出現次數大於N/K的數怎麼作?
#斷定k次,




#最長的可整合子數組的長度.
def main(l):
    l.sort()
    #遇到間隔就加新開一個數組
    out=[]
    for i in range(1,len(l)):
        if l[i]-l[i-1]!=1:
            out.append(i)
    last=[0]
    
    out.append(len(l))
    last+=out
    out=[]
    for i in range(len(last)-1):
        out.append(l[last[i]:last[i+1]])
    outt=[]
    for i in out:
        if len(i)>len(outt):
            outt=i
    return outt
print(main([1,3,4,5,6,25,10,34,56,7]))

#爲排序正數數組中累加和爲指定值的最長子數組的長度.

print('888888888888')
'''
子數組問題動態規劃用雙指針來描述
'''
def main(arr,target):#子數組取left到right時候的答案
    left=right=0
    tmp=arr[left:right+1]
    out=0
    while left!=len(arr)-1 :
     tmp=arr[left:right+1]   
     #這題目的斷定很費勁
     if sum(tmp) < target and right<len(arr)-1:
        right+=1
        continue
     if sum(tmp)==target and right<len(arr)-1:
         now=right-left+1
         out=max(out,now)
         right+=1
         continue
     if sum(tmp)>target:
         left+=1
         continue
     if sum(tmp) < target and right>=len(arr)-1:
        break
     if sum(tmp)==target and right>=len(arr)-1:
         now=right-left+1
         out=max(out,now)
         left+=1
         continue
    return out
print(main([1,2,1,1,1,1,1,1,4,0.5,0.5,1,0.5,0.5],3))
         

#未排序數組中累加和爲特定值的最長子數組系列問題!很是經典的哈希表題目!!!!
'''
先構造一個sum數組.而後利用哈希表方法來找長度便可.
'''
def main(l,target):
    sum=[]
    tmp=0
    for i in range(len(l)):
        tmp+=l[i]
        sum.append(tmp)
    #對於sum中每個數值,簡歷一個字典,字典中key爲sum中值,value爲這個值第一次
    #出現對應的index,因此下面必須是找sum[i]-target便可.
    sum=[0]+sum #0表示什麼都不選
    dicme={}
    for i in range(len(sum)):
        if sum[i] in dicme:
            continue
        else:
            dicme[sum[i]]=i
    
    
    print(sum)
    print(dicme)
    #對於sum中每個數值,找數值-target是否存在,若是存在就是這兩個index相減+1便可.
    out=[]
    for i in range(len(sum)):
        if sum[i]-target in dicme and dicme[sum[i]-target]<=i:
            j=dicme[sum[i]-target]
            out.append(i-j)
    return max(out)
print(main([1,2,-1,-1,-1],-3)) #返回3



        
        
        
        
        
        
'''
這裏有人問孔子「以德報怨，何如？」等於提到道家的思想。孔子的答覆，也沒有直接反對，
只是在邏輯上做一個論辯。他說，別人對我不起，我對他好；那麼人家對我好，我又該怎樣
報答呢？因此他下面就主張「以直報怨」，以直道而行。是是非非，善善惡惡，
對我好的固然對他好，對我很差的固然不理他，這是孔子的思想。他是主張是非分明的。

偶然聽到詩詞大會朱熹說孔孟之道好的一個詩詞.又想到了這句話,這句常常被心靈雞湯曲解
的話.以德報怨顯得多迂腐,以直報怨纔是孔子推崇的.孔子強就強在不趨炎附勢於心靈雞湯,
而是真正講解處事道理.
說到狼性和羊性.一代一代的雞湯害了多少人處事的道理,還一直覺得本身是聖人,到死都不知道
爲何別人對本身怎麼老是不如本身對別人.你作事標準都沒有統一,對你好很差,你都同樣對我
我憑什麼對你好.中國幾千年文化,小學語文課本就一直給人洗腦要作聖人,到頭來我也只看到
中國屈辱史而已.在中國說實話很難,雞湯思想已經根深蒂固了,有些東西你懂了也不能說,由於
跟主流價值觀不一樣,你們會鄙視你不高尚.而事實是你們永遠記住的是你是否成功,而不是手段.
'''        
        
        
        
        
#在數組中找到一個局部最小的位置,效率logN
def main(s):
    #由於只須要找到一個位置便可.因此用二分法.
    if len(s)==2:
        if s[0]<s[1]:
            return 0
        if s[0]==s[1]:
            return False
        else:
            return 1
    if len(s)==1 or len(s)==0:
        return False
    else:
        
        first=0
        end=len(s)-1
        mid=(first+end)//2
        while mid !=0 and mid!=len(s)-1:
            
            if s[mid]<s[mid-1]:
                if s[mid]<s[mid+1]:
                    return mid
                else:
                    first=mid
                    
            else:
                
                    end=mid
            mid=(first+end)//2
        if mid==0:
            return 0
        else:
            return len(s)-1
print(main([20,4,-9,-97,0]))        
                
            
#雙函數交替遞歸的經典例題.


#數組中子數組的最大累乘積.#把下面代碼改爲動態規劃便可,或者記憶體也行.
def mainMax(l,a):#返回數組的子數組以index a爲結尾時候最大的累乘積.
    if a==0:
        return l[0]
    return max(l[a],mainMax(l,a-1)*l[a],mainMin(l,a-1)*l[a])
def mainMin(l,a):
    if a==0:
        return l[0]
    return min(l[a],mainMax(l,a-1)*l[a],mainMin(l,a-1)*l[a])
def mainn(l):
    a=len(l)-1
    out=[]
    for i in range(a):
        out.append(mainMax(l,i))
    return max(out)
print(mainn([-2.5,4,0,3,0.5,8,-1]))        
        
        
        
#不包含本位置的累乘數組
#不可使用除法.
'''
例如arr=[2,3,1,4] 返回[12,8,24,6]


輔助數組的方法:
'''

def main(l):
    if len(l)==1:
        return l
    else:
        l1=[1]
        for i in range(len(l)):
            l1.append(l1[-1]*l[i])
        l1=l1[1:]
        
        tmp=l[::-1]
        l2=[1]
        for i in range(len(tmp)):
            l2.append(l2[-1]*tmp[i])
        l2=l2[1:]     
    #l1,l2分別表示從左到右累乘,和從右到左累乘
    out=[]
    print(l1,l2)    
    for i in range(len(l)):
        if i==0:
            out.append(l2[-2])
            continue
        
        if i==len(l)-1:
            out.append(l1[-2])
            continue
        
        else:
            out.append(l1[i-1]*l2[i-1])
            continue
        
    return out
print(main([1,3,1,2]))





#第九章:其餘題目:
'''
從5隨機到7隨機.
'''
#答案很是牛逼,仍是看書吧!P391

#階乘問題:
#1.階乘有多少個0
def main(n):
    i=1
    out=0
    while n//5>=1:
        out+=n//5
        n=n//5
    return out
print(main(25))

#一個點是否在三角形內部

'''
如何判斷一個邊在另外一個邊的左邊仍是右邊,用向量積的正負來判斷.
'''

'''
摺紙問題:
'''




'''
關於ide問題:
寫腳本好比python程序,作題這種.仍是用sublime方便.
spyder的好處是能夠分塊運行#%%就能夠把程序切塊.這對於深度學習很方便.節約了時間
可是spyder對於多線程,多進程什麼的有bug.
調試仍是vs2017好,對於類對象都能清晰的顯示.
'''








print('郵局選址問題')
'''
郵局選址問題:

好比數軸上arr=[1,2,3,4,5,100], num=2
創建2個郵局那麼須要建在3,100這2個位置上才行.
'''


#首先解決一個問題:若是在arr[i...j]上只能建一個郵局,這個區域上的居民都前往這個郵局
#那麼應該建到什麼地方.

import copy
def main(arr,num):
    #ww的初始化
    w=[0]*(len(arr)+1)
    ww=[copy.deepcopy(w) for i in range(len(arr)+1)]
    #ww[i][j]表示arr[i...j]這個數組上若是隻放入一個郵局,那麼最短距離是多少.

    for i in range(len(arr)):
        for j in range(i+1,len(arr)):#只有對角線往上的纔有意義,因此從i+1開始算
            ww[i][j]=ww[i][j-1]+arr[j]-arr[(i+j)//2]
            #上面這個公式怎麼理解呢?
            '''
            證實:其實就是分類討論,這個問題選中位數顯然從i到j的中位數要選擇的是(i+j+1)//2
            這個點,由於這個點就是中間點偏右的這個點.(即偶數就是中間偏右的,奇數就是正好中間點)
            分兩種狀況看這個公式,第一種是新加入點arr[j]後,中心點不用移動,那麼顯然總體路程新
            加的距離就是arr[j]跟原來中間點的距離也就是arr[(i+j)//2].
            第二種狀況是新加入點arr[j]後,中心點須要右移動,這種狀況發生在j-1時候數組是奇數個
            元素,這時候以前的偶數個數組分佈是k個,1箇中心再k個元素,中心點移動以後左邊和中心每個都
            增長距離arr[舊中心點+1]-arr[舊中心點],而右邊k個數都減小arr[舊中心點+1]-arr[舊中心點]
            新加入的j點增長的距離是arr[j]-arr[舊中心點+1].
            綜合起來發現移動不移動中心點均可以用上面這個公式來計算w[i][j]
            證畢.
            '''

    #dp[a][b]表示若是在arr[0...b]上建設a+1個郵局,最短距離是多少.
    w=[0]*(len(arr))
    dp=[copy.deepcopy(w) for i in range(num)]  
      
    for i in range(len(w)): 
        dp[0][i]=ww[0][i]

    #動態規劃:
    for i in range(1,(num)):
        for j in range(i+1,len(arr)):
            dp[i][j]=float('inf')#先把全部點都改爲無窮
            for k in range(j):
                #k是新的郵局的切分點
                dp[i][j]=min(dp[i][j],dp[i-1][k]+ww[k+1][j])

    
    return dp[num-1][len(arr)-1]



print(main([1,2,3,4,5,1000],2)) #完美獲得6了





















        

View Code

 hebing 區間

'''
[編程題] 合併區間
時間限制：1秒
空間限制：131072K
用x,y表示一個整數範圍區間，如今輸入一組這樣的範圍區間(用空格隔開)，請輸出這些區間的合併。

輸入描述:
一行整數，多個區間用空格隔開。區間的逗號是英文字符。


輸出描述:
合併後的區間，用過空格隔開，行末無空格

輸入例子1:
1,3 2,5

輸出例子1:
1,5

輸入例子2:
1,3 2,5 8,10 11,15

輸出例子2:
1,5 8,10 11,15
'''








#可算過了,rstrip是由於測試用例裏面有bug,多給了一個空格.



a=input()
a=a.rstrip(' ').split(' ')

if a!=['']:
    for i in range(len(a)):
        tmp=a[i].split(',')
        a[i]=[int(tmp[0]),int(tmp[1])]
    a=sorted(a)
    
    def panding(a):
        for i in range(len(a)-1):
                j=i+1
                if a[i][1]>=a[j][0] and a[i][1]<a[j][1]:
                    tmp=a[:i]
                    tmp.append([a[i][0],a[j][1]])
                    tmp+=a[j+1:]
                    return tmp
                if a[i][1]>=a[j][1]:
                    return a[:j]+a[j+1:]
        return a
    while len(panding(a))!=len(a):
        a=panding(a)
    tmp=''
    for i in a:
        tmp+=str(i[0])+','+str(i[1])+' '
    print(tmp[:-1])
else:
    print('')    

View Code