今天收到暢遊的線上筆試，就打算來試試了，就當去校招前練練手，因為暢遊校招只招19屆…ORZ
  暢遊的題很奇怪，分為兩大類，第一類與遊戲相關的基礎題和閱讀理解（中間涉及一些小計算），第二類就是程式設計相關的單選題以及程式設計大題。
  不討論基礎題，只是論程式設計題的話，難度簡單，然鵝我還是沙比了，犯了很多錯誤，程式設計答題有兩道大題，第一題是計算最短路徑距離，第二題則是一個數值計算題。
程式設計大題1：
  這題也是我犯傻的地方，在看到第一題的簡介的時候（什麼玩家鴨NPC鴨），因為題沒看全，我第一時間想到的是ASTAR演算法，因為考慮到可能存在障礙物所以才打算採用，於是乎我就開始寫了一大段程式碼，以及回想ASTAR演算法距離計算以及更新路徑資訊，然後每個函式除錯一下，到最後看到測試用例以及說明就傻眼了，沒有障礙物設定，就給了玩家座標和NPC座標，讓你算和哪個NPC最近

int setNpcPos(char *pos,vector<int> &m_vec) {
	int x, y, count = 0;
	char *tmp = pos, *target;
	char buff[10];
	bool is = true;
	while (tmp) {
		target=strstr(tmp, ",");
		if (target!=NULL) {
			if (*target == '\0') {
				break;
			}
			*target = '\0';
			sprintf(buff, "%s", tmp);
			int t_tmp = atoi(buff);
			if (is) {
				x = t_tmp;
				is = false;
				m_vec.push_back(x);
			}
			else {
				y = t_tmp;
				is = true;
				count++;
				m_vec.push_back(y);
			}
			*target = ',';
			tmp = target+1;
		}
		else {
			y = atoi(tmp);
			count++;
			m_vec.push_back(y);
			break;
		}
	}
	return count;
}
void findNpc(size_t x, size_t y, size_t npcnum, char *npcpos) {
	int count = 0;
	vector<int> m_vec;
	int tmax = 128, maxx=0, maxy=0;
	//setPlayPos(x, y);
	count=setNpcPos(npcpos,m_vec);
	if (count != npcnum)
		return;
	for (int i = 0; i < 2*npcnum; i+=2) {
		int tx = m_vec[i] - x;
		int ty = m_vec[i + 1] - y;
		int tsum = pow(tx, 2) + pow(ty, 2);
		int tlen = sqrt(tsum);
		if (tlen < tmax) {
			tmax = tlen;
			maxx = m_vec[i], maxy = m_vec[i+1];
		}	
	}
	cout << "(" << maxx << "," << maxy<<")";
	
}

 

  
  
程式設計大題2：

  由於做到這的時候只剩10來分鐘（時間都浪費在第一題了…），因為時間很少，腦子有些犯渾了，第一時間打算分析其規律，很顯然，這是一個離散的數列（不知道可不可以這樣形容），與其瞎找規律，還不如按照題目說的去實現，於是我就把給出的例子想成如下步驟：
    1、當n=0時，返回1。
    2、n>0時，設有一個列表，{0}與序列{0}，將元素從1到k新增進入列表，每新增一個進入列表相應的就把該元素新增進入序列，然後再把新增的元素與集合中的每個元素的合新增進入序列，也就達到了題目的效果。
  由於時間不夠，這道題我沒有完成，所以與面試無緣了，本身作為18屆也沒機會去面試=_=
  PS：由於忘記截圖測試用例，我也不知道自己的程式碼對不對，只是測試了一下題目預設給的序列，目前是正確的。

程式碼：
  m_pow是為了解決重複計算pow，m_vec是存放序列，程式碼寫得很爛，這也是我目前暫時想到得方法。

vector<int> m_vec;
vector<int> m_pow;
int calsum(int num,int n) {
	static int flag = 1;
	if (n == 0) {
		return 1;
	}
	if (n == 1) {
		return num;
	}
	int sum = 0;
	int val;
	if (flag < m_pow.size())
		val = m_pow[flag+1];
	else {
		val = pow(num, flag);
	}
	m_vec.push_back(val);
	m_pow.push_back(val);
	flag++;
	for (int i = 0; i+1 < flag; i++) {
		int v = 0;
		if (i < m_pow.size()) {
			v = m_pow[i];
		}
		else {
			v = pow(num, i);
			m_pow.push_back(v);
		}
		int tmp = v + val;
		sum += v;
		m_vec.push_back(tmp);
	}
	if (flag != 2) {
		sum += val;
		m_vec.push_back(sum);
	}
	if (m_vec.size() >= n) {
		return m_vec[n - 1];
	}
	return calsum(num, n);
}

int main() {
	m_vec.push_back(1);
	m_pow.push_back(1);
	int sum = calsum(4, 10);
	cout << sum << endl;
	for (auto i : m_vec) {
		cout << i << " ";
	}
	return 0;
}

  
  
單選題
  就寫一些自己迷惑的題吧，記不太清題目了。。。
1、

int ary[]={1,2,3};
int *p=ary;
int ret=*p+*p+++*++p;

  在第一眼看到這個題，想起了網上說起的譚浩強C，雖然我沒看過，但是也聽說過，也知道這樣的寫法很不友好，但是我並沒有記下來，到底是從右邊向左邊運算呢，還是分析運算子優先順序什麼的呢？我有點方了。
  答案是6，雖然我第一時間也是選6，但是我犯渾了，後面又改成5，5是從左往右邊運算的過程orz，我覺得這種要分析的話，從彙編上看比較好…
  下面是語句的彙編程式碼，首先把p地址給eax，eax+4位元組，然後再把eax地址返回給p，也就是p++之後的操作就不解釋了，直到00A08255執行完後，也就是把值給ret後，再對P執行++語句，所以可以看出++p與p++的區別了，也知道其執行順序。

	int ret=*p+*p+++*++p;
00A0823D  mov         eax,dword ptr [p]  
00A08240  add         eax,4  
00A08243  mov         dword ptr [p],eax  
00A08246  mov         ecx,dword ptr [p]  
00A08249  mov         edx,dword ptr [ecx]  
00A0824B  mov         eax,dword ptr [p]  
00A0824E  add         edx,dword ptr [eax]  
00A08250  mov         ecx,dword ptr [p]  
00A08253  add         edx,dword ptr [ecx]  
00A08255  mov         dword ptr [ret],edx  
00A08258  mov         edx,dword ptr [p]  
00A0825B  add         edx,4  
00A0825E  mov         dword ptr [p],edx 

  
2、
  很久沒寫類繼承方面，忘了很多，當我看到這個的時候，猶豫了，我知道派生類繼承後，會存有一個類似於A的副本，畢竟要呼叫基類的建構函式，但是我這時候就糾結了，到底派生類中是否存在一個基類的物件，而這個物件是否會呼叫解構函式，忘乾淨了，於是乎就選了只輸出類B的解構函式。

class A {
public:
	~A() {
		cout << "this a\n";
	}
};

class B :public A {
public:
	~B() {
		cout << "this B";
	}
};
int main() {
	
	B t;
	return 0;
}

  答案是先輸出B的，再輸出A的，看看彙編就知道了（這兩個月沒白學…雖然拖得時間長了些…）
  再main函式中只顯示call B::_{B，沒看到}A！沒關係逐語句除錯進去看，就會發現除了呼叫_{B，之後還會呼叫}A，再詳細看就是下下面得彙編程式碼，也可以看到C++中的class大概佈局，執行完_{B後縮棧，然後再呼叫}A，似乎他們就是同步的，而其原因是其構造順序決定的。

B::~B:
01011A05  jmp         B::~B (01015FC0h)  
A::~A:
01011A0A  jmp         A::~A (01015CC0h)  

class B :public A {
	~B() {
01015FC0  push        ebp  
01015FC1  mov         ebp,esp  
01015FC3  push        0FFFFFFFFh  
01015FC5  push        1024610h  
01015FCA  mov         eax,dword ptr fs:[00000000h]  
01015FD0  push        eax  
01015FD1  sub         esp,0CCh  
01015FD7  push        ebx  
01015FD8  push        esi  
01015FD9  push        edi  
01015FDA  push        ecx  
01015FDB  lea         edi,[ebp-0D8h]  
01015FE1  mov         ecx,33h  
01015FE6  mov         eax,0CCCCCCCCh  
01015FEB  rep stos    dword ptr es:[edi]  
01015FED  pop         ecx  
01015FEE  mov         eax,dword ptr [__security_cookie (0102D014h)]  
01015FF3  xor         eax,ebp  
01015FF5  push        eax  
01015FF6  lea         eax,[ebp-0Ch]  
01015FF9  mov         dword ptr fs:[00000000h],eax  
01015FFF  mov         dword ptr [this],ecx  
01016002  mov         ecx,offset _749050E7_hello.cpp (0103000Dh)  
01016007  call        @[email protected] (010115C3h)  
		cout << "this B";
0101600C  push        offset string "this B" (01028C8Ch)  
01016011  mov         eax,dword ptr [[email protected]@@[email protected][email protected]@[email protected]@@[email protected] (0102E0CCh)]  
01016016  push        eax  
01016017  call        std::operator<<<std::char_traits<char> > (010114A1h)  
0101601C  add         esp,8  
	}
0101601F  mov         ecx,dword ptr [this]  
01016022  call        A::~A (01011A0Ah)  
01016027  mov         ecx,dword ptr [ebp-0Ch]  
0101602A  mov         dword ptr fs:[0],ecx  
01016031  pop         ecx  
01016032  pop         edi  
01016033  pop         esi  
01016034  pop         ebx  
01016035  add         esp,0D8h  
0101603B  cmp         ebp,esp  
0101603D  call        __RTC_CheckEsp (010115FFh)  
	}

  
3、
  繼承關係，這裡我忘記了一件事，私有繼承的話，所有成員都不可見，這裡忘了，的確不太應該，該好好回想C++了…emmmmmm
  
  
  
4、
  這個我好像沒選錯，但是值得記一下…

class A {
public:
	int a;
	A(int val = 0) {
		a = val;
	}
	friend  void operator++(A &m) {
		m.a++;
	}
};

  關於過載，好像記得題目給得不清，讓答題者選友元函式是怎麼呼叫的。
  因為++是單目運算子，一個引數即可，但這是前置++的寫法（++A），題目好像沒說明是後置還是前置++，還是我忘了= =
  如果後置的話，需要新增下面這種，有點類似於用友元函式過載輸入輸出運算子（二目），就可以使用A++了，相當於++從左邊傳入引數_{_}

friend  void operator++(A &m,int) {
		m.a++;
}

  
5、
好像沒有印象深刻的題了，想起在補充吧。