58同城算法工程师

判别式模型和生成式模型

https://blog.csdn.net/wolenski/article/details/7985426
简单而言判别式模型是求分类面。
生成式模型是求分布。

k为500以内的正整数，它加上整数a和b均为完全平方数，求k。比如a=100,b=200，则k=476。

def findk(a,b):
        gap=max(a,b)-min(a,b)
      
        if a&1 == b&1:
                x=(gap-4)//4+2
               
                        
        else:
                x=(gap-1)//2+1
        print(x)
        for i in range(x,-1,-1):
                if 0<=i*i-max(a,b)<=500:
                        for j in range(i-1,-1,-1):
                                print(i,j)
                                if i*i-max(a,b)==j*j-min(a,b):
                                        return i*i-max(a,b)
  
                
print(findk(1,-11))

完全平方数越靠后，它的间距越大。

解码，假如0对应a,25对应z，求一个数字的解码方式。比如12158有5种。

这个题其实是楼梯问题的变种，现在楼梯变成了数位：
递归版本：

def translateNum( num ):
        if not num:
            return 0
        if num<10:
            return 1
        s=str(num)
        def f(s):
            if not s:
                return 0
            if len(s)==1:
                return 1
            if int(s[:2])<26:
                return f(s[2:])+f(s[1:])
            else:
                return f(s[1:])

        return f(s)
print(translateNum(12158))

迭代版本：

def translateNum( num ):
        if not num:
            return 0
        if num<10:
            return 1
        s=str(num)
        i=1
        if int(s[:2])<26:
                j=2
        else:
                j=1
        for k in range(2,len(s)):
                if int(s[k-1:k+1])<26:
                        i,j=j,i+j
                else:
                        i,j=j,j
        return j
                        
print(translateNum(12158))

甚至可以认为是一种遍历：
bfs：

def translateNum( num ):
        if not num:
            return 0
        if num<10:
            return 1
        s=str(num)
        q=[]
        q.append(0)

        c=0
        while q:
                d=q.pop(0)
                if d==len(s)-1:
                        c+=1
                
                if d+1<=len(s)-1 :
                        q.append(d+1)
                        
                if d+2<=len(s)-1 and int(s[d:d+2])<26 :
                        q.append(d+2)
                    
                print(q)
        return c

dfs:

def translateNum( num ):
        if not num:
            return 0
        if num<10:
            return 1
        s=str(num)
        c=[0]
        def dfs(s):
                print(s)
                if not s:
                        c[0]+=1
                        return
                if len(s)>=2 and int(s[:2])<26:
                        dfs(s[2:])
                        dfs(s[1:])
                else:
                        dfs(s[1:])
        dfs(s)
                        
                
        return c[0]
                        
                        
                        
print(translateNum(12158))

还可以回溯：

def translateNum( num ):
        if not num:
            return 0
        if num<10:
            return 1
        s=str(num)
        track=[0]
        c=[0]
        ch=[1,2]
        def trackback(ch,track):
                if track[-1]>=len(s)-1:
                        c[0]+=1
                        return
                for i in ch:
                        if track[-1]+i in track:
                                continue
                        if track[-1]+i<len(s) and int(s[track[-1]:track[-1]+i])<26:
                                track.append(track[-1]+i)
                                trackback(ch,track)
                                track.pop()
                                
                                
        trackback(ch,track)
                
        return c[0]
                        
                        
                        
print(translateNum(12158))