那是最好的年代,也是最糟的年代。那是光明的時節,也是黑暗的時節。那是希望的春季,也是悲傷的冬日。

2019 我開始了自己的求職之旅。2個月以來，面試了10多家公司。外面整體形勢很差，比自己想象的還要差。一方面各大廠hc大大減少，要求也大大提升。總體感覺這次，自己很被動。所以，以后要做更好的計劃。

簡歷每3個月要進行一次更新。

時刻保持自己對leetcode題型的熟知程度，總之，時刻準備著....優秀是一種習慣

面試過程，一定注意編程題的細節，一定不要著急給自己挖坑，挖與不挖是智商與情商的雙重考驗

面試的時候，首先拿小廠積累經驗，彌補不足，循序漸進，厚積薄發。記住沒有沒有價值的面試。漲不了技術，就漲閱歷。不斷的面試練習，最后巔峰時刻，去面大廠。

面試中當和面試官意見不一致時，要保持沉默，不要據理力爭。同時還要注意面試官是不是給自己挖坑，不能啥都附和。總之，面試在緣分。

一定要給自己設置一個找工作的戰線區間，比如一個月，比如2個月，戰線千萬不要啦太長。無論如何，就是一個月，我必須在我拿到的offer里面挑一個去，有壓力才會有動力。

最佳的找工作時間還是3,4月，9,10月。其他時間機會相對較少。

總體面試經驗分享如下，

2019.2.22

瑞途科技

公司只要是對地鐵隧道中的墻壁裂縫，遺留物等檢測的。有自己的嵌入式設備。

技術leader主要聊了一些工作經驗。

?

2019.2.22

當當網

對方的崗位主要偏大數據方向，我主要是做cv方向，抱著試一試的態度面試。

面試主要5個環節。

1，做試卷

題型主要是選擇題，問答題，編程題。

問答題

PCA,LDA區別

PCA為非監督降維，LDA為有監督降維

PCA希望投影后的數據方差盡可能的大（最大可分性），因為其假設方差越多，則所包含的信息越多；而LDA則希望投影后相同類別的組內方差小，而組間方差大。LDA能合理運用標簽信息，使得投影后的維度具有判別性，不同類別的數據盡可能的分開。

AUC

機器學習的其他使用過的方法，評價指標

編程題

(1)給定一個輸入正整數N，輸出N的階乘的值。（N<512）

要考慮大整數乘法溢出的問題。

主要思想：

初始值為1.

然后把1放入數組存著，（按位存，比如999，即f[0]=9, f[1]=9, f[2]=9）

然后數組的每一位都乘以2，（注意還有進位）

然后數組的每一位都乘以3，…

然后數組的每一位都乘以n.

?

最后從后往前，輸出每一位即是結果。注意，數組后面從非0開始計算。即最高位就是第一個非0位。

#define Max 512 //最多存儲3000位 int main() {int n=3; //輸入的數int temp;int f[Max] = { 1, 0 }; //用于存儲結果的每一位數int i, j;for (i = 2; i <= n; i++){int flag = 0;//進位標志for (j = 0; j < Max; j++) //對于每一個數i，把f中的每一個數字(即下標j的數字)都剩以i，注意進位{temp = f[j] * i + flag;f[j] = temp % 10;flag = temp / 10;}}for (j = Max - 1; j >= 0; j--)if (f[j]) break;for (i = j; i >= 0; i--)std::cout << f[i];std::cout << std::endl;return 0; }

(2)給定一個input.txt，里面存著用戶購買的書的編號，可以理解為一行一個字符串，大概1000w行，輸出購買量前100的書的編號。

由于數據量大，需要將1000w的數據分成N份（這里為了保證相同的數據被分到同一個桶，得使用hash函數），每份取前100個，再對N份的前100進行排序，輸出最終的前100項。

import hashlibdef hash_func(string_data,num_split=10):md5 = hashlib.md5()md5.update(string_data.encode('utf-8'))return sum(ord(x) for x in md5.hexdigest())%num_splitfile=open("input.txt","r",encoding="utf-8") lines=file.readlines() file.close()num_split=10 out_pre_num=100 lines_bucket=[] for i in range(num_split):lines_bucket.append({}) for line in lines:line=line.rstrip("\n")hash_num=hash_func(line,num_split)if line in lines_bucket[hash_num].keys():lines_bucket[hash_num][line]+=1else:lines_bucket[hash_num][line]=1bucket_pre_100_lists=[] for i in range(len(lines_bucket)):lines_bucket_sorted_lists=sorted(lines_bucket[i].items(),key=lambda x:x[1],reverse=True)bucket_pre_100_lists.extend(lines_bucket_sorted_lists[:out_pre_num])sorted_pre_100_lists=sorted(bucket_pre_100_lists,key=lambda x:x[1],reverse=True) print(sorted_pre_100_lists[:out_pre_num])

? ? 2.技術1面試

聊項目經驗+2道編程題

leetcode ,3Sum

思路，夾逼準則 S=[-1,0,1,2,-1,-4] sum_3=0 output=[] S=sorted(S,reverse=False)for i in range(len(S)):if i>0 and S[i]==S[i-1]:continuefore_index=i+1back_index=len(S)-1target=sum_3-S[i]print(i)while fore_index<back_index:if S[fore_index]+S[back_index]==target:output.append((S[i],S[fore_index],S[back_index]))fore_index+=1back_index-=1elif S[fore_index]+S[back_index]<target:fore_index+=1else:back_index-=1print(output)

? ? 2.給定2個字符串，判斷第一個字符串中是否按順序的包含第二個字符串中的每個字符。

例如，字符串A=”zcfdkwuy”，字符串B=”zku”,則A字符串按順序包含B字符串的每個元素，返回True，不包含返回False

A="zcfdkwuy" B="zku"index_A=0 index_B=0 while index_A<len(A) and index_B<len(B):if A[index_A]==B[index_B]:index_A+=1index_B+=1else:index_A+=1output=index_B>=len(B) print(output)

? ? 3.技術2面試

聊項目經驗+2道編程題

(1)給定一個排序后的數組A，輸出該數組中任意2個數的和為給定數X的索引

和Two Sum這道題的區別就是，Two Sum輸入的數組不要求是已經排序的。而這塊是已經排序的，我也沒鬧懂出題人的意思，直接就想了二分查找（時間復雜度o(n*log(n))），其實后來一想，基于hash的思路要比這個高效（時間復雜度o(n)）。

二分查找思路，

def binary_search(data_list,first,last,key):while first<=last:middle=int(first+(last-first)/2)if data_list[middle]==key:return middleif key<data_list[middle]:last=middle-1if data_list[middle]<key:first=middle+1print(first,last,key)return -1 A=[1,3,5,6,7,9] X=8output_list=[] for num,i in enumerate(A):out_index=binary_search(A,0,len(A)-1,X-i)if out_index!=-1 and out_index>num:output_list.append((num,out_index)) print(output_list) Hash思路， A=[1,3,5,6,7,9] X=8output_list=[] for num,i in enumerate(A):out_index=-1if X-i in A:out_index=A.index(X-i)if out_index>num:output_list.append((num,out_index)) print(output_list)

第二題忘了。

4，部門leader面試

5，hr面

?

上海歐拉：

new與malloc的區別：

（1）分配內存的位置，

new(自由存儲區)，malloc（堆）

（2）內存分配失敗返回值

new(完整類型指針)，malloc（void*指針）

（3）內存分配失敗返回值

new(默認拋出異常)，malloc（NULL）

（4）分配內存的大小

new(編譯器根據類型計算得出)，malloc（必須顯式指定字節數）

（5）已分配內存的擴充

new(無法直觀地處理)，malloc（使用realloc簡單完成）

（6）是否相互調用

new(可以調用malloc)，malloc（不可以調用new）

（7）函數重載

new(容許)，malloc（不容許）

（8）構造函數與析構函數

new(調用)，malloc（不調用）

?

虛函數：

虛函數可以在子類方法中進行重載，也可以不重載而沿用父類的方法。

純虛函數必須重載，因為聲明類中沒有函數的實現，virtual void func()=0;

包含純虛函數的類為抽象類，不能聲明對象，只能作為基類。

?

意銳新創：

技術面+leader面

直接聊經驗，公司主要做移動二維碼支付，小白盒

面試經驗收獲少，人生閱歷有收獲。

?

翔創科技：

京東人臉識別大賽第二名，主要做人工智能養豬。初創公司，直接聊技術。

?

卓視智通：

公司主要做安防，老板很年輕，初創公司，主要聊技術。

?

申哲伙伴：

面試題，

（1）1個箱子里有50個紅球，50個藍球。每次從里面取出2個。

如果是2個紅色，全部放回，

如果是2個藍色，全部取出藍色，

如果是一個紅色，一個藍色，取出1個紅色，放回一個藍色，

求，最后剩下紅色的概率。

單場懵逼，沒啥思路。可以模擬10000次試驗計算，但是肯定有更好的辦法，只是沒想到。結果應該是0.5。

取出，紅，藍	1/2（紅藍+藍紅兩種情況）
取出，紅，紅	1/4
取出，藍，藍	1/4

import random#求最后剩下紅球的概率 num_temp=0 num_all=num_all_copy=10000while num_all>0:num_all-=1red_ball_num=50#0表示blue_ball_num=50#1表示while True:num1=random.randint(0,1)num2=random.randint(0,1)if (num1==0 and num2==1) or (num1==1 and num2==0):red_ball_num-=1elif num1==0 and num2==0:passelif num1==1 and num2==1:blue_ball_num-=2else:passif blue_ball_num==0 and red_ball_num>0:num_temp+=1breakif blue_ball_num>0 and red_ball_num==0:breakperception=num_temp/num_all_copy print(perception)#0.5

(2)RPN網絡可不可以做多分類任務。

(3)項目經驗。

一起教育：

編程1，編輯距離，

int minDistance(const string &word1, const string &word2) { const size_t n = word1.size(); const size_t m = word2.size(); // 長度為 n 的字符串，有 n+1 個隔板 int f[n + 1][m + 1]; for (size_t i = 0; i <= n; i++) f[i][0] = i; for (size_t j = 0; j <= m; j++) f[0][j] = j; for (size_t i = 1; i <= n; i++) { for (size_t j = 1; j <= m; j++) {if (word1[i - 1] == word2[j - 1])f[i][j] = f[i - 1][j - 1];else {int mn = min(f[i - 1][j], f[i][j - 1]);f[i][j] = 1 + min(f[i - 1][j - 1], mn);}} } return f[n][m]; }

編程2，kmeans

#!/usr/bin/python # coding=utf-8 import numpy as np import random import math import copy import matplotlib.pyplot as plt dataMat=[[1.658995,4.285136], [-3.453687,3.424321], [4.838138,-1.151539], [-5.379713,-3.362104], [0.972564,2.924086], [-3.567919,1.531611], [0.450614,-3.302219], [-3.487105,-1.724432], [2.668759,1.594842], [-3.156485,3.191137], [3.165506,-3.999838], [-2.786837,-3.099354], [4.208187,2.984927], [0.704199,-0.479481], [-0.392370,-3.963704], [2.831667,1.574018], [-0.790153,3.343144], [2.943496,-3.357075] ] # 計算歐幾里得距離 def distEclud(centroids, datai):dis=[]for i in range(len(centroids)):dis.append(math.sqrt((centroids[i][0] - datai[0])**2+(centroids[i][1] - datai[1])**2))return dis# 構建聚簇中心，取k個(此例中為4)隨機質心 def randCent(dataSet, k):min_x = min(dataSet[:][0])max_x = max(dataSet[:][0])min_y = min(dataSet[:][1])max_y = max(dataSet[:][1])centroids = []for i in range(k):centroids.append([random.uniform(min_x,max_x),random.uniform(min_y,max_y)])return centroids #centroids = set()#while len(list(centroids))<k:# centroids.add(random.randint(0,len(dataSet)))#return list(centroids)# k-means 聚類算法 def kMeans(dataSet, k):m = len(dataSet)# clusterAssment第一列存放該數據所屬的中心點，第二列是該數據到中心點的距離centroids = randCent(dataSet, k)pre_centroids=copy.copy(centroids)while True:clusterAssment = [] # 用于存放該樣本屬于哪類及質心距離for i in range(m): # 把每一個數據點劃分到離它最近的中心點distJI = distEclud(centroids, dataSet[i])clusterAssment.append([distJI.index(min(distJI)),min(distJI)])minDst=0for j in range(k): # 重新計算中心點sum_k_x=0sum_k_y=0num_k=0for n in range(len(clusterAssment)):if clusterAssment[n][0]==j:sum_k_x+=dataSet[n][0]sum_k_y+=dataSet[n][1]num_k+=1centroids[j]=[sum_k_x/(num_k+0.0001),sum_k_y/(num_k+0.0001)]minDst+=math.sqrt((centroids[j][0]-pre_centroids[j][0])**2+(centroids[j][1]-pre_centroids[j][1])**2)if minDst<0.5:breakelse:pre_centroids=copy.copy(centroids)return centroids, clusterAssment # --------------------測試---------------------------------------------------- # 用測試數據及測試kmeans算法 myCentroids,clustAssing = kMeans(dataMat,4) print (myCentroids) print (clustAssing)c_lists=['b','g','k','y'] marker_lists=['x','1','2','s'] fig = plt.figure() axis = fig.add_subplot(111) for i in range(len(dataMat)):axis.scatter([dataMat[i][0]], [dataMat[i][1]], c = c_lists[clustAssing[i][0]],marker = marker_lists[clustAssing[i][0]]) axis.scatter([myCentroids[i][0] for i in range(len(myCentroids))], [myCentroids[i][1] for i in range(len(myCentroids))], c = 'r',marker = 'o') plt.show()

微店：

3個技術面，1個hr

程序題，

一個貝葉斯的英文題，沒細看，直接說了不會。

給定2個數組，判斷另外一個數組是否是由第一個數組中的元素進行打亂得到的。

例如，數組，A=[1,3,5,4,7],B=[1,5,7,4,3]，則數組B中元素和數組A中元素相等，返回True。

方法1，可以將2個數組分別進行排序，然后看排序后結果是否相等。o（nlogn）時間

方法2，遍歷A數組，將其中的元素進行哈希存儲，然后遍歷B數組，判斷哈希表中的數值。o（n）時間

?

智力題，

一個固定大小的桌子，有無數的固定大小的硬幣。A,B兩人一人每次放一枚，不容許重疊的放。直到不能再放為止，輪到誰不能再放，就算誰輸，假設A先放，A怎么樣保證自己一定贏。

放中心位置。因為桌子是關于中心對稱的，只有中心位置只有1個。只要占了中心位置。這樣不管B怎么放，A都可以放在B的放的位置的對稱位置。

邏輯回歸，假設有100個特征向量，將其中的一個特征復制100次，生成200個維度的特征向量，問這樣訓練和原來的100維的訓練會有區別嗎？

不會有區別，假設復制的那個向量的分數為p，這樣最記得假設，復制后每個向量的分數為p/101，和原來的向量還是一樣的。

58同城：

聊項目經驗

?

小鵬汽車：

聊項目經驗

問了一些構造函數的多態。

Lstm手寫公式，

Svm推導

Face++:

(1)NMS

import numpy as np def nms(dets, thresh):#dets[x1,y1,x2,y2,p] dets=sorted(dets,key=lambda x:x[4],reverse=True) delete_lists=[] for n,xy in enumerate(dets): if dets [n][4]=0:continuefor num,xxyy in enumerate(dets[n+1:]): if dets [n+1+num][4]=0:continuexx1 = np.maximum(xy[0], xxyy[0]) yy1 = np.maximum(xy[1], xxyy[1]) xx2 = np.minimum(xy[2], xxyy[2]) yy2 = np.minimum(xy[3], xxyy[3]) w = np.maximum(0.0, xx2 - xx1 + 1) h = np.maximum(0.0, yy2 - yy1 + 1) inter = w * hunion= (xy[2]-xy[0])*(xy[3]-xy[1])+(xxyy[2]-xxyy[0])*(xxyy[3]-xxyy[1])ovr = inter / (union - inter+0.00001) if ovr >= thresh:dets [n+1+num][4]=0delete_lists.append(n+1+num)dets=np.delete(dets,delete_lists,axis=0)return dets

(2)單鏈表反轉

struct ListNode {int val;struct ListNode *next;ListNode(int x) :val(x), next(NULL) {} };ListNode* ReverseList(ListNode* pHead) {ListNode *root=pHead; ListNode *pre=NULL; ListNode *next=NULL;if(pHead==NULL) return NULL; while(root->next){ next=root->next; root->next=pre; pre=root; root=next; } root->next=pre; return root; }

美圖：

3個技術面，1個hr面，

（1）線性回歸和邏輯回歸區別。

線性回歸用來預測，邏輯回歸用來分類。

線性回歸是擬合函數，邏輯回歸是預測函數

線性回歸的參數計算方法是最小二乘法，邏輯回歸的參數計算方法是梯度下降

?

（2）偏差和方差區別

偏差: 描述模型輸出結果的期望與樣本真實結果的差距。?
方差: 描述模型對于給定值的輸出穩定性。?

泛化性能=偏差+方差+noise

[高方差]?(過擬合)解決思路：

采集更多的樣本數據，減少特征數量，去除非主要的特征，增加正則化參數?λ

[高偏差]?(欠擬合)解決思路：

引入更多的相關特征，采用多項式特征，減小正則化參數?λ

（3）類似百度的相似圖片查找

KNN，KD Tree，矩陣運算加速等。

（4）分類和回歸的區別。

分類是離散的，定性的，回歸是連續的，定量的

編程題，

兩個list轉化為一個dict,

list1 = ['key1','key2','key3'] list2 = ['1','2','3'] dict(zip(list1,list2))

支付寶：

神經網絡訓練，很多時候彩色圖訓練和灰度圖訓練效果差不多，比如人臉識別中，那么顏色到底是不是一種特征？

當時被問到這個，自己也是左右糾結，傳統算法中，顏色確實是一個特征，比如itti。人臉識別訓練確實是灰度圖和彩圖沒啥區別，有些ocr中甚至灰度圖效果更好。

于是自己pytorch路了個簡單的例子驗證。

?

造圖片程序：

import cv2 import numpy as np import randomimage_shape=56 shape_type=["triangle","rectange","circle"] color_shape=[(0,0,255),(0,255,0),(255,0,0)] color_shape_name=["red","green","blue"] image_class_num=20 dataset_folder="data/"for cn,color_type in enumerate(color_shape):for ic_num in range(image_class_num):image=np.ones((image_shape,image_shape,3), np.uint8)*255shape=shape_type[random.randint(0,2)]if (shape=="triangle"):pts = np.array([[random.randint(5,image_shape),random.randint(5,image_shape)],[random.randint(5,image_shape),random.randint(5,image_shape)],[random.randint(5,image_shape),random.randint(5,image_shape)]], np.int32)pts = pts.reshape((-1,1,2))image = cv2.polylines(image,[pts],True,color_type,1)image=cv2.fillPoly(image, [pts], color_type);elif (shape=="rectange"):x1=random.randint(1,image_shape-10)y1=random.randint(1,image_shape-10)x2=x1+random.randint(5,image_shape-x1)y2=y1+random.randint(5,image_shape-y1)image=cv2.rectangle(image,(x1,y1),(x2,y2),color_type,-1)elif (shape=="circle"):center_x=random.randint(5,image_shape-5)center_y=random.randint(5,image_shape-5)radius=random.randint(5,min(min(center_x,center_y),min(image_shape-center_x,image_shape-center_y)))image=cv2.circle(image,(center_x,center_y), radius, color_type, -1)else:passcv2.imwrite(dataset_folder+color_shape_name[cn]+"_"+shape+"_"+str(ic_num)+".jpg",image)

圖片大小56*56，形狀分為三角形，圓形，四邊形，顏色分為紅，綠，藍。每一個顏色都包含這三種形狀。也就是說顏色是唯一的分類特征。

訓練和測試程序：

#dataset.py import os from PIL import Image import cv2 import torch from torch.utils import data from torchvision import transforms from torchvision.transforms import functional as F import numbers import numpy as np import randomclass ImageData(data.Dataset):def __init__(self,train_root):self.image_root = train_rootself.image_list = os.listdir(self.image_root)self.image_num=len(self.image_list)self.label_dict={"red":0,"green":1,"blue":2}def __getitem__(self, item):im_name = self.image_root+self.image_list[item % self.image_num]image = load_image(im_name)image = cv_random_flip(image)label = self.label_dict[self.image_list[item % self.image_num].split("_")[0]]#彩圖注釋該行image= np.expand_dims(np.sum(image,axis=0)/3,axis=0)sample = {'image': image, 'label': label}return sampledef __len__(self):return self.image_numdef get_loader(mode='train'):if mode == 'train':shuffle = Truedataset = ImageData("./data/train/")data_loader = data.DataLoader(dataset=dataset, batch_size=100, shuffle=shuffle, num_workers=2)else:shuffle = Falsedataset = ImageData("./data/test/")data_loader = data.DataLoader(dataset=dataset, batch_size=100, shuffle=shuffle, num_workers=2)return data_loaderdef load_image(path):if not os.path.exists(path):print('File {} not exists'.format(path))im = cv2.imread(path,1)in_ = np.array(im, dtype=np.float32)in_ -= np.array((104.00699, 116.66877, 122.67892))in_ = in_.transpose((2,0,1))return in_def cv_random_flip(img):flip_flag = random.randint(0, 1)if flip_flag == 1:img = img[:,:,::-1].copy()return img #train_test.py import os import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torch.autograd import Variable from dataset import get_loader print(torch.__version__)os.environ["CUDA_VISIBLE_DEVICES"] = '0'EPOCHS=50 # 總共訓練批次 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 讓torch判斷是否使用GPU，建議使用GPU環境，因為會快很多class ConvNet(nn.Module):def __init__(self):super().__init__()self.conv0=nn.Conv2d(1,20,5) # 10, 24x24#彩圖修改輸入為3self.conv1=nn.Conv2d(20,20,5) self.conv2=nn.Conv2d(20,40,3) self.fc1 = nn.Linear(1960,100)self.fc2 = nn.Linear(100,3)def forward(self,x):in_size = x.size(0)out = self.conv0(x)out = F.max_pool2d(out, 2, 2) out = self.conv1(out) out = F.relu(out)out = self.conv1(out)out = F.relu(out)out = F.max_pool2d(out, 2, 2) out = self.conv2(out)out = F.relu(out)out = out.view(in_size,-1)out = self.fc1(out)out = F.relu(out)out = self.fc2(out)out = F.log_softmax(out,dim=1)return outmodel = ConvNet().to(DEVICE) optimizer = optim.Adam(model.parameters(),lr = 0.0001) criterion = nn.CrossEntropyLoss()def train(model, device, train_loader, optimizer, epoch):model.train()for batch_idx, data_target in enumerate(train_loader):data, target = Variable(data_target['image']).to(device), Variable(data_target['label']).to(device)optimizer.zero_grad()output = model(data)loss = F.nll_loss(output, target)#loss = criterion(output, target)loss.backward()optimizer.step()if(batch_idx+1)%10 == 0: print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(epoch, batch_idx * len(data), len(train_loader.dataset),100. * batch_idx / len(train_loader), loss.item()))def test(model, device, test_loader):model.eval()test_loss = 0correct = 0with torch.no_grad():for data_target in test_loader:data, target = data_target['image'].to(device), data_target['label'].to(device)output = model(data)test_loss += F.nll_loss(output, target, reduction='sum').item() # 將一批的損失相加pred = output.max(1, keepdim=True)[1] # 找到概率最大的下標correct += pred.eq(target.view_as(pred)).sum().item()test_loss /= len(test_loader.dataset)print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(test_loss, correct, len(test_loader.dataset),100. * correct / len(test_loader.dataset)))for epoch in range(1, EPOCHS + 1):train(model, DEVICE, get_loader(mode='train'), optimizer, epoch)test(model, DEVICE, get_loader(mode='test'))

灰度圖訓練結果：

彩圖訓練結果：

最終結論，

灰度圖的準確性略高于平均準確性33%，彩圖準確性基本100%。。可見顏色也是一種神經網絡可以學習的特征。所以可以根據實際應用場景，增加或者去掉顏色特征。

?

?

高德

1面電話聊項目經驗

2面現場面，項目經驗為主，一些基本框架

3面現場面，主要編程，

編程1，IOU,需要定義結構體

編程2，二叉樹翻轉，求深度

int maxDepth(TreeNode *root) {if (root == nullptr) return 0;return max(maxDepth(root->left), maxDepth(root->right)) + 1; } void exchange(TreeNode *root) {if (root == nullptr) return;TreeNode *temp=root->right; root->right=root->left; root->left=temp; exchange(root->left); exchange(root->right);}

編程3，2sum，o(n)的怎么處理，o(n*log(n))怎么處理？

Hashmap，二分查找，左右夾逼。

?

京東：

1面，2面，聊項目經驗，以及一些遇到的問題怎么處理

3面，leader聊一些工作情況

4面，hr

?

作業幫：

1面，2面聊項目經驗。3面，hr小姐姐面。

筆試題，

檢測惡意訪問的服務IP。假設一個服務訪問，可以得到IP，訪問時間，假設連續的10秒內，同一個IP的訪問超過10次，就算該IP為惡意訪問的IP。假設沒有大量的并發情況。

思路，定義一個queue，每次來了訪問服務，就加入該queue。定義一個hashmap，里面存儲所有的IP。如果超過10秒，就將該hash對應的訪問次數值清零。否則就加1。如果超過10次就證明是惡意訪問。

#include <iostream> #include <queue> #include <utility> #include <string> #include <unordered_map> using namespace std;struct MALICE{float time;int count;MALICE(float t, int c) :time(t), count(c){}; };int main() {float time_gap = 10.0;int count_gap = 10;unordered_map<string, queue<MALICE>> umap;//初始化int a = 0, b = 0, c = 0, d = 0;int max_num = 4;while (true){queue<MALICE> malice;malice.push(MALICE(0.0, 0));string temp = to_string(a) + "." + to_string(b) + "." + to_string(c) + "." + to_string(d);umap.insert(make_pair(temp, malice));d += 1;if (d > max_num){d = 0;c += 1;if (c > max_num){c = 0;b += 1;if (b > max_num){b = 0;a += 1;}if (a > max_num)break;}}}//新來的訪問umap["0.0.0.0"].back().count = 10;float time = 5;string ip = "0.0.0.0";while (time - umap[ip].front().time >= time_gap){umap[ip].pop();}if (umap[ip].size() == 0){umap[ip].push(MALICE(time, 0));}else{if (time - umap[ip].front().time < time_gap){umap[ip].push(MALICE(time, umap[ip].back().count + 1));if (umap[ip].back().count > count_gap){umap[ip].back().count = 0;cout << "malice ip:" << ip << endl;}}}return 1; }

?

好未來：

1面，主要還是聊項目經驗。實際遇到的問題。

筆試，快排的思想講解，不需要寫代碼。

?

其他題型：

題目1：

給定不同面額的硬幣 coins 和一個總金額 amount。編寫一個函數來計算可以湊成總金額所需的最少的硬幣個數。如果沒有任何一種硬幣組合能組成總金額，返回 -1。

?

示例 1:

輸入: coins = [1, 2, 5], amount = 11

輸出: 3

解釋: 11 = 5 + 5 + 1

示例 2:

?

輸入: coins = [2], amount = 3

輸出: -1

說明:

你可以認為每種硬幣的數量是無限的。

int coinMinWays(vector<int>& coins, int amount) {vector<int> dp(amount+1, amount+1);dp[0] = 0;for (int i = 1; i <= amount; ++i) {for (int j = 0; j < coins.size(); ++j) {if (coins[j] <= i) {dp[i] = min(dp[i], dp[i - coins[j]] + 1);}}}return (dp[amount] > amount) ? -1 : dp[amount];

題目2：

有1，2，5，10等不同零錢各若干，問如果要組合成N元，有多少種不同的組合方式？假設有m種零錢，具體面值存在arr中，要找的錢為n。

例如：arr=[1, 2, 5, 10], n=5, 則有4種組合方式,分別為：

1,1,1,1,1

1,1,1,2

1,2,2

5

提示：不需要給出具體的組合，只需要找出組合的數量

int countWays(vector<int>&coins, int amount) {vector<int> dp(amount+1 , 0);dp[0] = 1;for (int i = 0; i < coins.size(); ++i){for (int j = coins[i]; j <= amount; ++j){dp[j] = (dp[j] + dp[j - coins[i]]);}}return dp[amount]; }int main() {vector<int> coins;coins.push_back(1);coins.push_back(2);coins.push_back(5);coins.push_back(10);int amount = 5;cout << coinMinWays(coins, amount) << endl;cout<<countWays(coins, amount) << endl; }

題目3，

取1000w正整數的前100個輸出。

思路，堆排序，

bool compare(int a, int b) {return a > b; } int main() {int MAX_NUM = 10;int pre_num = 5;int input;vector<int> small_top_heap;int index = 0;while (cin >> input){small_top_heap.push_back(input);index += 1;if (index == pre_num){make_heap(small_top_heap.begin(), small_top_heap.end(), compare);}if (index > pre_num){push_heap(small_top_heap.begin(), small_top_heap.end(), compare);pop_heap(small_top_heap.begin(), small_top_heap.end(), compare);small_top_heap.pop_back();}if (index >= MAX_NUM)break;}sort_heap(small_top_heap.begin(), small_top_heap.end(), compare);for (int i = 0; i < small_top_heap.size(); i++)cout << small_top_heap[i] << " ";cout << endl;return 0; }

?

Tensorflow學習筆記——Summary用法

tf.summary.scalar用來顯示標量信息

tf.summary.histogram一般用來顯示訓練過程中變量的分布情況

tf.summary.distribution分布圖，一般用于顯示weights分布

tf.summary.text將文本類型的數據轉換為tensor寫入summary中

tf.summary.image輸出圖像

tf.summary.audio展示訓練過程中記錄的音頻?

tf.summary.merge_all

tf.summary.FileWriter指定一個文件用來保存圖

?

?

最后，分享一下本人的leetcode筆記。

想想來北京3年了，從最開始的不被認可，被釣魚，到現在，感覺收貨也蠻多的，至少到現在還是得到好多公司的認可。有時候收了別人的offer最后又拒絕了別人，心里也挺難過的。最后感謝一下，曾經認可自己的公司和人。

其他建議：

（1）明確目前階段的自己最需要的是什么。是鍍金，是money，是帶團隊經驗，是提升自己能力，是安穩......，在沒有一個offer滿足所有優點的時候，選擇自己最需要的那個。

（2）寒冬中的跳槽，無非是從一個坑到另一個坑。很多時候，從脈脈上得到的消息，你會感覺所有你面上的公司都有負面新聞。這時候就根據自己的面試感受做選擇了。做到，既來之，則安之。

（3）還有一個感觸就是，在AI算法這方面，每年都有好多新的東西更新，知識保值性太差了。新人永遠比老人有優勢。想想當年這個時候的自己，和現在的應屆生比，差距確實很大。或許這就是知識進步太快了。就好比，從SVM提出，到第一個程序實現，中間經歷了好長時間，那個年代就沒有牛人嗎？但是，現在面試應屆生，隨便都可以將SVM說個很不錯。牛頓窮其一生發現了3個定律，現在的學生，也許不需要一學期就都學會了。愛迪生，特斯拉，瓦特......泡沫終將退去，也許在算法和工程的抉擇中，工程才是最終的勝利者。

?

后記：

魯迅說過，人只要又錢，煩惱就會減掉90%以上，情商和智商也會提高，更不會亂發火。錢從哪里來，魯迅沒說，但是，褚老說了，

?

總結

以上是生活随笔為你收集整理的记在2019，winter is coming的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。