轉載於：http://blog.csdn.net/smarttony/article/details/1478600
一、選擇題：15分 共10題
1. 在排序方法中，關鍵碼比較次數與記錄地初始排列無關的是 .
A. Shell排序 B. 歸併排序 C. 直接插入排序 D. 選擇排序
2. 以下多線程對int型變量x的操作，哪幾個需要進行同步：
A. x=y; B. x++; C. ++x; D. x=1;
3. 代碼
void func() {
static int val;
…
}
中，變量val的內存地址位於：
A. 已初始化數據段 B.未初始化數據段 C.堆 D.棧
4. 同一進程下的線程可以共享以下
A. stack B. data section
C. register set D. thread ID
5. TCP和IP分別對應了 OSI中的哪幾層？
A. Application layer
B. Data link layer
C. Presentation layer
D. Physical layer
E. Transport layer
F. Session layer
G. Network layer
6. short a[100]，sizeof(a)返回？
A 2 B 4 C 100 D 200 E 400
7. 以下哪種不是基於組件的開發技術_____。
A XPCOM B XP C COM D CORBA
8. 以下代碼打印的結果是（假設運行在i386系列計算機上）：
struct st_t
{
int status;
short* pdata;
char errstr[32];
};
st_t st[16];
char* p = (char*)(st[2].errstr + 32);
printf("%d", (p - (char*)(st)));
A 32 B 114
C 120 D 1112
9. STL中的哪種結構是連續形式的存儲
A map B set C list D vector
10. 一個棧的入棧序列是A，B，C，D，E，則棧的不可能的輸出序列是（ ）
A、EDCBA； B、DECBA； C、DCEAB； D、ABCDE
二、簡答題：20分，共2題
1. （5分）重複多次fclose一個打開過一次的FILE *fp指針會有什麼結果，並請解釋。
考察點：導致文件描述符結構中指針指向的內存被重複釋放，進而導致一些不可預期的異常。
2. （15分）下面一段代碼，想在調用f2(1)時打印err1，調用f2(2)時打印err4，但是代碼中有一些問題，請做盡可能少的修改使之正確。
1 static int f1(const char *errstr, unsigned int flag) {
2 int copy, index, len;
3 const static char **__err = {“err1”, “err2”, “err3”, “err4”};
4
5 if(flag & 0x10000)
6 copy = 1;
7 index = (flag & 0x300000) >> 20;
8
9 if(copy) {
10 len = flag & 0xF;
11 errstr = malloc(len);
12 if(errstr = NULL)
13 return -1;
14 strncpy(errstr, __err[index], sizeof(errstr));
15 } else
16 errstr = __err + index;
17 }
18
19 void f2(int c) {
20 char *err;
21
22 swtch(c) {
23 case 1:
24 if(f1(err, 0x110004) != -1)
25 printf(err);
26 case 2:
27 if(f2(err, 0x30000D) != -1)
28 printf(err);
29 }
30 }
三、編程題：30分 共1題
注意：要求提供完整代碼，如果可以編譯運行酌情加分。
1. 求符合指定規則的數。
給定函數d(n) = n + n的各位之和，n爲正整數，如 d(78) = 78+7+8=93。 這樣這個函數可以看成一個生成器，如93可以看成由78生成。
定義數A：數A找不到一個數B可以由d(B)=A，即A不能由其他數生成。現在要寫程序，找出1至10000裏的所有符合數A定義的數。
輸出：
1
3
…
四、設計題：35分 共1題
注意：請儘可能詳細描述你的數據結構、系統架構、設計思路等。建議多寫一些僞代碼或者流程說明。
1. 假設一個mp3搜索引擎收錄了2^24首歌曲，並記錄了可收聽這些歌曲的2^30條URL，但每首歌的URL不超過2^10個。系統會定期檢查這些URL，如果一個URL不可用則不出現在搜索結果中。現在歌曲名和URL分別通過整型的SONG_ID和URL_ID唯一確定。對該系統有如下需求：
1) 通過SONG_ID搜索一首歌的URL_ID，給出URL_ID計數和列表
2) 給定一個SONG_ID，爲其添加一個新的URL_ID
3) 添加一個新的SONG_ID
4) 給定一個URL_ID，將其置爲不可用
限制條件：內存佔用不超過1G，單個文件大小不超過2G，一個目錄下的文件數不超過128個。
爲獲得最佳性能，請說明設計的數據結構、搜索算法，以及資源消耗。如果系統數據量擴大，該如何多機分佈處理？
To: wchb0()
strncpy(*errstr, __err[index - 1], strlen(*errstr));
這句改改就行了吧：）
先做前10題
1，B
2，A,D
3，A
4，A,B
5，B,E
6，D
7，B
8，C
9，C
10，C
1 d
2 a c d
3 b
4 b d
5 a d e g
6 d
7 d
8 c
9 d
10 c
僅供參考
1D,
2ABD
3A
4BC
5BE
6D
7D
8C
9D
10C
1、C
2、ABC
3、A
4、B
5、E、G
6、D
7、B
8、C
9、D
10、C
1.d
2.abc
3.a
4.B
5.EG
6.D
7.b
8.B
9.d
10.c
static int f1(char **errstr, unsigned int flag) {
int copy = 0, index, len;
const static char *__err[4] = {"err1", "err2", "err3", "err4"};
if(flag & 0x10000)
copy = 1;
index = (flag & 0x300000) >> 20;
if(copy) {
len = flag & 0xF;
*errstr = (char*)malloc(len * sizeof(char));
if(*errstr == NULL)
return -1;
strncpy(*errstr, __err[index - 1], sizeof(errstr));
} else
*errstr = (char*)(*(__err + index));
}
void f2(int c) {
char **err = (char**)malloc(sizeof(char*));
switch(c) //dongguo
{
case 1:
if(f1(err, 0x110004) != -1)
printf(*err);
printf("n");
break;
case 2:
if(f1(err, 0x30000D) != -1)
printf(*err);
printf("n");
break;
}
free(err);
}
簡答第二題
2. 以下多線程對int型變量x的操作，哪幾個需要進行同步：
A. x=y; B. x++; C. ++x; D. x=1;
------------------------------------------------------------------
只有 D 不需要。
x = y;
00411A25 mov eax,dword ptr [y]
00411A28 mov dword ptr [x],eax
x++;
00411A2B mov eax,dword ptr [x]
00411A2E add eax,1
00411A31 mov dword ptr [x],eax
++x;
00411A34 mov eax,dword ptr [x]
00411A37 add eax,1
00411A3A mov dword ptr [x],eax
x = 1;
00411A3D mov dword ptr [x],1
1. 求符合指定規則的數
#include <stdio.h>
void get(int num,int a[])
{
int sum = num;
int n[4];
int i;
for(i=0;i<4;i++)
{
sum+= num%10;
num/=10;
if(num == 0) break;
}
if(sum<10000)
a[sum] = 1;
}
int main()
{
int a[10000]={0};
int i,j=0;
for(i=0;i<10000;i++)
{
get(i,a);
}
for(i=0;i<10000;i++)
{
if(a[i]==0)
{
printf("%d/t",i);
j++;
if(j%10 == 0) printf("/n");
}
}
return 0;
}
另:
3. 代碼
void func() {
static int val;
…
}
中，變量val的內存地址位於：
A. 已初始化數據段 B.未初始化數據段 C.堆 D.棧
應該選b吧
B
ABC
A
B
EG
E
CD
B
D
C
【 在 lifeistrue (lifeistrue) 的大作中提到: 】
:四、設計題：35分 共1題
注意：請儘可能詳細描述你的數據結構、系統架構、設計思路等。建議多寫一些僞代碼或者流程說明。
1. 假設一個mp3搜索引擎收錄了2^24首歌曲，並記錄了可收聽這些歌曲的2^30條URL，但每首歌的URL不超過2^10個。系統會定期檢查這些URL，如果一個URL不可用則不出現在搜索結果中。現在歌曲名和URL分別通過整型的SONG_ID和URL_ID唯一確定。對該系統有如下需求：
1) 通過SONG_ID搜索一首歌的URL_ID，給出URL_ID計數和列表
2) 給定一個SONG_ID，爲其添加一個新的URL_ID
3) 添加一個新的SONG_ID
4) 給定一個URL_ID，將其置爲不可用
限制條件：內存佔用不超過1G，單個文件大小不超過2G，一個目錄下的文件數不超過128個。
爲獲得最佳性能，請說明設計的數據結構、搜索算法，以及資源消耗。如果系統數據量擴大，該如何多機分佈處理？
:================================================
內存不夠存儲這些url，所以將數據寫入若干個文件中。
每一首歌曲對應的存儲在文件中的信息格式爲（url1, url2……）。
文件的總大小大約爲2^24*2^10*4 =2^36 =64GB.根據SongID即可計算出在哪個文件的哪個位置，那麼一個隨機的查詢操作耗時即是一次隨機打開文件啊並執行seek操作讀取數據的實際，大約是ms級別。
將每首歌曲的信息存入文件中，由於每首歌的url不超過2^10個，所以在文件中每首歌的存儲結構是2^10個int數，每個int數字標識着一個url。-1表示url不存在。初始化時將文件中每個int數初始化爲-1.
這樣每個SongID對應的信息佔用的空間爲2^10*4=4KB，設每個文件大小1G，那麼每個文件可存儲2^18=256K個Song的信息。總共需要64個文件，把這些文件編號從0-63.
對於任意一個SongID，他所對應的url信息所在的文件編號是：SongID>>18,在文件中的位置是：(SongID&0x3FFFF)<<12.
另外內存中用一個2^24大小的short int型數組來保存每一首歌曲對應的url的個數，計數組名爲urlCount[]，初始化時值爲-1,表示對應的Song_ID不存在。此數組佔用空間2^25Byte=32MB;
url是否可用的信息用位圖來標識。位圖保存在內存中，佔用的空間爲2^30/8=2^27 Byte=128MB.
對所要求的操作：
:1) 通過SONG_ID搜索一首歌的URL_ID，給出URL_ID計數和列表
通過SONG_ID計算出文件號和對應在文件中的位置，從urlCount[]中讀取url個數，讀出所有的url,並對每個url_ID查詢位圖看是否可用，若可用，將此url加入返回列表。
:2) 給定一個SONG_ID，爲其添加一個新的URL_ID
通過SONG_ID計算出文件號和對應在文件中的位置，設爲start，在通過urlCount[]得到url個數，假設有n個url,那麼將新的URL_ID寫入文件的start+sizeof(int)*n處。修改urlCount[SONG_ID]的值。
:3) 添加一個新的SONG_ID
檢查將對應的urlCount[SONG_ID]，若爲-1，則修改爲0,若大於等於0，則表明改Song_ID已經存在。
:4) 給定一個URL_ID，將其置爲不可用
修改url位圖，標識URL_ID對應的位，表示爲不可用。
一、選擇題：15分 共10題
1. 在排序方法中，關鍵碼比較次數與記錄地初始排列無關的是（AD）
A. Shell排序 B. 歸併排序 C. 直接插入排序 D. 選擇排序
2. 以下多線程對int型變量x的操作，哪幾個需要進行同步： （ABC?）
A. x=y; B. x++; C. ++x; D. x=1;
3. 代碼
void func() {
static int val;
…
}
中，變量val的內存地址位於： （B）
A. 已初始化數據段 B.未初始化數據段 C.堆 D.棧
4. 同一進程下的線程可以共享以下 （BC）
A. stack B. data section
C. register set D. thread ID
5. TCP和IP分別對應了 OSI中的哪幾層？（EG）
A. Application layer
B. Data link layer
C. Presentation layer
D. Physical layer
E. Transport layer
F. Session layer
G. Network layer
6. short a[100]，sizeof(a)返回？ (D)
A 2 B 4 C 100 D 200 E 400
7. 以下哪種不是基於組件的開發技術_____。(不清楚)
A XPCOM B XP C COM D CORBA
8. 以下代碼打印的結果是（假設運行在i386系列計算機上）：（C）有人試着運行過嗎？
struct st_t
{
int status;
short* pdata;
char errstr[32];
};
st_t st[16];
char* p = (char*)(st[2].errstr + 32);
printf("%d", (p - (char*)(st)));
A 32 B 114
C 120 D 1112
9. STL中的哪種結構是連續形式的存儲 （D）
A map B set C list D vector
10. 一個棧的入棧序列是A，B，C，D，E，則棧的不可能的輸出序列是（C ）
A、EDCBA； B、DECBA； C、DCEAB； D、ABCDE
to XINYONGHUCSDN(柯風):
和你做的不同的選擇題：
1。D
4。C
6。C
7。B
TO cpfly8421()
1.
歸併排序最根本的操作是將兩個排好序的文件合併成一個更大的排好序的文件，那麼出示輸入的數據對合並的影響是哪些數據比較的次數比較多，哪些少一定，對總體來說比較的次數是不變的（對一個特定的寫好的歸併程序來說）。歸併排序只與數據的數目有關，與順序無關。
因此我選(BD)
上面好像寫成了AD，筆誤了。是BD.
4.同一進程中的不同線程是共享數據段的，要不然線程相對於進程的線程間通信的優勢就沒有了。所以我選BD。
6.sizeof得到的是字節數。
7.我清楚。
8。C st[2].errstr + 32的地址p實際上與st[3]的地址相同， sizeof(st) = 4 + 4 + 32 = 40;
6。D sizeof（short）× 100 ＝ 200
三：求符合的數字
void main(void)
{
func(10000);
}
void func(int n)
{
for(int i = 1; i <= n; i++)
{
check(i);
}
}
void check(int n)
{
int i = 0, j = 0;
int sum = 0;
for(int i = 1; i < n; i++) //這個地方有沒有更好的辦法判斷退出，減少循環？
{
sum = i;
for(j = i; j > 0; j / 10)
{
sum += j % 10;
}
if(sum == n)
{
break;
}
}
if(sum != n)
{
printf("find one! n = %d", n);
}
}
if(sum != n)
{
printf("find one! n = %d", n);
}
}
1. 求符合指定規則的數。
給定函數d(n) = n + n的各位之和，n爲正整數，如 d(78) = 78+7+8=93。 這樣這個函數可以看成一個生成器，如93可以看成由78生成。
定義數A：數A找不到一個數B可以由d(B)=A，即A不能由其他數生成。現在要寫程序，找出1至10000裏的所有符合數A定義的數。
輸出：
1
3
…
//========================
#include <string.h>
#include <stdio.h>
int main()
{
return find_num();
}
int find_num()
{
#define N 10000
char num[N+1];
int sum=0, j=0, i=0;
memset(num, 0, sizeof num);
for(i=1; i<=N; ++i)
{
sum = j = i;
while(j!=0)
{
sum += j%10;
j /= 10;
}
if(sum <= N) num[sum] = 1;
}
for(i=1; i<=N; ++i)
if(num[i]==0) printf("%d/n", i);
return 0;
}
//==================
輸出結果：
1
3
5
7
9
20
31
42
53
64
75
86
97
108
110
121
132
143
154
165
176
187
198
……
#include <iostream>
using namespace std;
const int MAX = 10000;
int main()
{
bool result[MAX];
memset(result, 1, MAX);
int q = 0;
int b = 0;
int s = 0;
int g = 0;
for (q = 0; q < 10; ++q)
{
for (b = 0; b < 10; ++b)
{
for (s = 0; s < 10; ++s)
{
for (g = 0; g < 10; ++g)
{
int num = q * 1000 + b * 100 + s * 10 + g + q + b + s + g;
if (num > 0 && num < MAX)
{
result[num - 1] = false;
}
}
}
}
}
for (int i = 0; i < MAX; ++i)
{
if (result[i])
{
cout << i + 1 << endl;
}
}
return 0;
}
1 ?
2 a,d
3 a
4 b
5 e,g
6 d
7 b
8 c
9 d
10 c
程序題,我做的.
#include <stdio.h>
#include <stdlib.h>
//
#define total 200
int main(int argc, char* argv[])
{
int result[total];
for (int i = 1; i <= total; i++)
result[i] = i;
//
for (int j = 1; j <= total; j++)
{
int v = j;
unsigned int k = j;
while( k > 0 )
{
v += k % 10;
k = k / 10;
}
//
if ((v != j) && (v <= total))
{
result[v] = -1;
result[0]++;
}
}
int dd = 0;
for (int m = 1; m <= total; m++)
{
if(result[m] != -1)
{
if (dd % 10 == 0)
printf("%d/n", m);
else
printf("%d ", m);
}
}
return 0;
}
YeTimmy(啥時候才能爲國家做點貢獻-_-#) 的代碼不錯。只是這裏：
if (num > 0 && num < MAX)
{
result[num - 1] = false;
}
條件可以稍微改進一下。把數組大小整成MAX+1，然後把num>0去掉。
if (num <= MAX)
{
result[num] = false;
}
result[0]自然地成了FALSE，也就不會輸出了。多用一個空間，省掉兩個條件，划算！
求符合指定規則的數
int szElements[10045];
int szAddValue[] = { 2, 11, 101, 1001};
void Calculate(int iBaseValue, int iPos)
{
if ( iPos != 0)
{
Calculate( iBaseValue, iPos - 1);
for ( int i = 1; i <= 9; i ++)
{
iBaseValue += szAddValue[iPos];
szElement[iBaseValue] = 1;
Calculate(iBaseValue, iPos - 1);
}
}
}
void PrintResult()
{
for ( int i = 0; i < 10000; i ++)
{
if ( !szElement[i] )
{
cout << i << endl;
}
}
}
第二題:
我想了兩個小時,結果出來了但不知道考什麼,請高手指教!
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
static int f1(char * errstr, unsigned int flag)
{//字符串函數不支持常指針，故修改傳遞的指針errstr和__err
int copy = 0, index, len;
static char *__err[] = {"err1", "err2", "err3", "err4"};//VC支持此種定義
if(flag & 0x10000)
copy = 1;
index = (flag & 0x300000) >> 20;
if(copy) //copy表示要做什麼？？？請高手解釋哈！！！
{
len = flag & 0xF; //len是做下用途嗎？??
//重新從原堆開始的地方分配空間，以便f2讀取
//errstr = (char*)realloc(errstr, strlen(__err[index]) + len);
errstr = (char*)realloc(errstr, strlen(__err[index]) + 1);//請教高手是否更好？？？
if(errstr == NULL)
return -1;
strcpy(errstr, __err[index]);//strncpy不會在後邊添加'/0'
}
else
strcpy(errstr, __err[index]); //修改
}
void f2(int c) {
char *err = (char*)malloc(5); //不能指向棧空間！
switch(c)
{
case 1:
if(f1(err, 0x010004) != -1) //0x110004->0x010004第六位是數組__err的索引
printf("f(1)= %s",err);
printf("/n");
break;
case 2:
if(f1(err, 0x30000D) != -1)
printf("f(2)= %s",err);
printf("/n");
break;
}
free(err);
}
void main()
{
f2(1);
f2(2);
}
//是不是考察棧，堆與全局數據之間的操作???如用C++的string類實現就容易多了
三、解答
#include <iostream>
using std::cout;
using std::endl;
int main()
{
int a,b,c,d;//1~10000裏各個位數
int j=0;//計數器
for(int n=1;n<=10000;n++)
{
j=0;
for(int i=1;i<=n;i++)
{
a=i%10;
b=(i%100-a)/10;
c=(i%1000-b)/100;
d=(i-c)/1000;//求出各個數位
e=a+b+i;//c+d+i;//求出函數
if(e!=n)
j++;//統計不符合要求的個數
}
if(j==n)//當完全找不到符合要求的數打印數
cout<<n<<"/n";
}
cout<<endl;
return 0;
}
上面漏寫一行：
int a,b,c,d;//1~10000裏各個位數
/////////////////
int e;//所求函數數
/////////////////
int j=0;//計數器
在VC6.0下測試有效
綜合下選擇題，有意見請指出
1. 在排序方法中，關鍵碼比較次數與記錄地初始排列無關的是 . (BD,上面高手的意見)
A. Shell排序 B. 歸併排序 C. 直接插入排序 D. 選擇排序
2. 以下多線程對int型變量x的操作，哪幾個需要進行同步： （ABC，上面用匯編證明)
A. x=y; B. x++; C. ++x; D. x=1;
3. 代碼 B,沒有異議
void func() {
static int val;
…
}
中，變量val的內存地址位於：
A. 已初始化數據段 B.未初始化數據段 C.堆 D.棧
4. 同一進程下的線程可以共享以下 BC，也沒異議吧
A. stack B. data section
C. register set D. thread ID
5. TCP和IP分別對應了 OSI中的哪幾層？ EG，通常只用在傳輸與網絡層吧
A. Application layer
B. Data link layer
C. Presentation layer
D. Physical layer
E. Transport layer
F. Session layer
G. Network layer
6. short a[100]，sizeof(a)返回？ （D）
A 2 B 4 C 100 D 200 E 400
VC6下測試，不過這應該與編譯器有關，不一定都爲2字節
7. 以下哪種不是基於組件的開發技術_____。（B是說極限編程嗎，CORBA是LINUX下滴COM，算吧）
A XPCOM B XP C COM D CORBA
8. 以下代碼打印的結果是（假設運行在i386系列計算機上）：
struct st_t
{
int status;
short* pdata;
char errstr[32];
};
st_t st[16];
char* p = (char*)(st[2].errstr + 32);
printf("%d", (p - (char*)(st)));
A 32 B 114
C 120 D 1112
VC6下測試，答案爲120
個人理解：st[2].errstr + 32 這個就是st[3]的地址啊！
而st_t的大小爲 4+4+32 ＝ 30，所以st[3]的地址就爲 3*40 = 120
不正確請指出
9. STL中的哪種結構是連續形式的存儲 （D）
A map B set C list D vector
10. 一個棧的入棧序列是A，B，C，D，E，則棧的不可能的輸出序列是（ 不用說 C ）
A、EDCBA； B、DECBA； C、DCEAB； D、ABCDE
結合下自己的理解與上面各仁兄滴高見，請路過再指點
1. 歸併排序的比較次數可能不同，例如1 2 3 4， 需要比較4次（12 34 13 23），而1 4 2 3 需要比較5次（14 23 12 42 43），應該只有D
用動態規劃方法做的編程題
#include <iostream>
using namespace std;
int szElement[10036];
int szAddValue[] = { 2, 11, 101, 1001};
void CalculateElement( int iPos )
{
int iMaxElementPre = 0;
if ( iPos != 0)
{
iMaxElementPre = 10 * szAddValue[iPos - 1] + iPos * 9 - 11;
}
for ( int i = iMaxElementPre; i >= 0; i --)
{
if ( szElement[i] )
{
int iNewElement = i;
for ( int i = 1; i <= 9; i ++)
{
iNewElement += szAddValue[iPos];
szElement[iNewElement] = 1;
}
}
}
}
void PrintResult()
{
for ( int i = 0; i < 10000; i ++)
{
if ( !szElement[i] )
{
cout << i << endl;
}
}
}
int _tmain(int argc, _TCHAR* argv[])
{
for ( int i = 1; i < 10036; i ++)
{
szElement[i] = 0;
}
szElement[0] = 1;
for ( int i = 0; i < 4; i ++)
{
CalculateElement(i);
}
PrintResult();
return 0;
}
下面的程序更加簡潔：
#include <iostream>
using namespace std;
int szElement[10036];
int szAddValue[] = { 2, 11, 101, 1001};
int szAssist[9];
void CalculateElement( int iPos )
{
int iMaxElementPre = szAddValue[iPos] + iPos * 9 - 2;
szAssist[0] = szAddValue[iPos];
for ( int i = 1; i < 9; i ++)
{
szAssist[i] = szAssist[i-1] + szAddValue[iPos];
}
for ( int i = iMaxElementPre; i >= 0; i --)
{
if ( szElement[i] )
{
for ( int j = 0; j < 9; j ++)
{
szElement[i + szAssist[j]] = 1;
}
}
}
}
void PrintResult()
{
for ( int i = 0; i < 10000; i ++)
{
if ( !szElement[i] )
{
cout << i << endl;
}
}
}
int _tmain(int argc, _TCHAR* argv[])
{
for ( int i = 1; i < 10036; i ++)
{
szElement[i] = 0;
}
szElement[0] = 1;
for ( int i = 0; i < 4; i ++)
{
CalculateElement(i);
}
PrintResult();
return 0;
}
d
bc
a
ab
ge
d
b
c
d
c
YeTimmy(啥時候才能爲國家做點貢獻-_-#) 的思路很清晰，稍做修改：
void calcElement()
{
char a[10036] = {0, };
for (int q = 0; q < 10; q++)
{
for (int b = 0; b < 10; b++)
{
for (int s = 0; s < 10; s++)
{
for (int g = 0; g < 10; g++)
{
a[q * 1000 + b * 100 + s * 10 + g + q + b + s + g] = 1;
}
}
}
}
for (int i = 0; i < 10000; ++i)
{
if (!a[i])
{
cout << i << " ";
}
}
}
1 D （查了書籍，直接插入肯定不是，shell依賴直接插入，歸併排序與分組有關，書上指出直接選擇的算法與初始鍵值排序無關）
2 A B C （三者都有讀內存，然後寫內存的操作）
3 A （？不是很確定，但是VC編譯器是這樣的。如果是B的話，那麼在函數內部就沒有意義了）
4 B （線程都有獨立的寄存器、棧空間、線程ID）
5 E G
6 D (100*sizeof(short) => 200)
7 B (？不是很確定， XPCOM望文生義，應該給予COM。COM自身就是COM。COBRA是基於COM的）
8 C (細心算算應該沒問題）
9 D （應該考查的是對STL的理解）
10 C
大家有什麼不同的看法
1、C
2、ABC
3、A
4、B
5、E、G
6、D
7、B
8、C
9、D
10、C
很多題是應試教育的產物,下面給出一個1分鐘想出的最後一個問題的處理方法,但是如果不查資料,要把細節寫出來,那考的就不是技巧,而是背功了:
四、設計題：35分 共1題
注意：請儘可能詳細描述你的數據結構、系統架構、設計思路等。建議多寫一些僞代碼或者流程說明。
1. 假設一個mp3搜索引擎收錄了2^24首歌曲，並記錄了可收聽這些歌曲的2^30條URL，但每首歌的URL不超過2^10個。系統會定期檢查這些URL，如果一個URL不可用則不出現在搜索結果中。現在歌曲名和URL分別通過整型的SONG_ID和URL_ID唯一確定。對該系統有如下需求：
1) 通過SONG_ID搜索一首歌的URL_ID，給出URL_ID計數和列表
2) 給定一個SONG_ID，爲其添加一個新的URL_ID
3) 添加一個新的SONG_ID
4) 給定一個URL_ID，將其置爲不可用
限制條件：內存佔用不超過1G，單個文件大小不超過2G，一個目錄下的文件數不超過128個。
爲獲得最佳性能，請說明設計的數據結構、搜索算法，以及資源消耗。如果系統數據量擴大，該如何多機分佈處理？
本人認爲可以採用建立兩個 song_id 和 url_id 的 B-Tree 樹 ..., 其它的東西也許不需要細說了, 如那些放在內存中, 哪些放在文件中 .... , 熟悉軟件的人, 查一下數據結構和算法的書, 就可以了, 個人認爲這些東西只要理解就可以了, 不要去背, Donald.E.Knuth 做東西也是查找和推論出來的, ... [email protected]
8. 以下代碼打印的結果是（假設運行在i386系列計算機上）：
struct st_t
{
int status;
short* pdata;
char errstr[32];
};
st_t st[16];
char* p = (char*)(st[2].errstr + 32);
printf("%d", (p - (char*)(st)));
A 32 B 114
C 120 D 1112
大家注意一下,是在i386下 int變量應該是2字節吧~。覺得應該是B（114）
1. 求符合指定規則的數。
給定函數d(n) = n + n的各位之和，n爲正整數，如 d(78) = 78+7+8=93。 這樣這個函數可以看成一個生成器，如93可以看成由78生成。
定義數A：數A找不到一個數B可以由d(B)=A，即A不能由其他數生成。現在要寫程序，找出1至10000裏的所有符合數A定義的數。
輸出：
#include <stdio.h>
void get(int A)
{
int sum =0;
int i,j,k,X;
for(i=1;i<4;i++)
{
X=A;
A/=10;
if(A == 0) break;
}
/*備註1：此時i表示A是幾位數*/
if(i*9>=A)
k=1; /*備註2：當num<=它的位數*9時，讓k從1開始查找*/
else
k=A-(9*(i-1)+X); /*備註3：當num>它的位數*9時，讓k從A-(9*(i-1)+X) 開始查找*/
for(;k<=A;k++)
{
for(j=1;j<=i;j++)
{
sum+=k%10; /*求出此時k各個位數字的和*/
}
if(sum+k=A) /*發現k的各個位數的和+k=A時，既A可以找到d(B)=A中的B,此時B就是k*/
{
return();
}
}
printf("%d/n",A);
}
int main()
{
int i,
for(i=0;i<10000;i++)
{
get(i);
}
}
4 abc
編程求數：
abcde轉換後10000a+1000b+100c+10d+e+a+b+c+d+e
#define NUM_SAVE_MAX 2000
#define INTBYTES 4
static int save[NUM_SAVE_MAX];
void search(int *arr,int n)
{
for(int *p=arr;p<arr+INTBYTES*n;p++)
{
int x=*p;
x=x%10001;
x=x%1001;
x=x%101;
x=x%11;
x=x%2;
if(x!=0)
int savenum=0;
save[savenum]=x;
savenum++;
}
}
4 abc
編程求數：
abcde轉換後10000a+1000b+100c+10d+e+a+b+c+d+e
#define NUM_SAVE_MAX 2000
#define INTBYTES 4
static int save[NUM_SAVE_MAX];
void search(int *arr,int n)
{
for(int *p=arr;p<arr+INTBYTES*n;p++)
{
int x=*p;
int savenum=0;
x=x%10001;
x=x%1001;
x=x%101;
x=x%11;
x=x%2;
if(x!=0)
{
save[savenum]=x;
savenum++;
}
}
}
2. 以下多線程對int型變量x的操作，哪幾個需要進行同步：
A. x=y; B. x++; C. ++x; D. x=1;
我怎麼覺得是ACD
/*
Name: 編程題：求符合指定規則的數。
Copyright: 2006年
Author: 崔衛兵
Date: 11-10-06 14:36
Description: 求符合指定規則的數。
給定函數d(n) = n + n的各位之和，n爲正整數，如 d(78) = 78+7+8=93。 這樣這個函數可以看成一個生成器，如93可以看成由78生成。
定義數A：數A找不到一個數B可以由d(B)=A，即A不能由其他數生成。現在要寫程序，找出1至10000裏的所有符合數A定義的數。
輸出：
1
3
*/
#include <iostream>
using namespace std;
short NumSum(short);
int main(int argc, char *argv[])
{
short sArr[10000]={0};
short len=10000;//sizeof(sArr)/sizeof(short)
for(int i=1;i<len;i++){
short tmp=NumSum(i);
if(tmp<=10000){
sArr[tmp-1]=1;
}
}
for(int i=0;i<len;i++){
if(sArr[i]==0)
cout<<i+1<<endl;
}
system("PAUSE");
return EXIT_SUCCESS;
}
short NumSum(short num){
short newNum=num;
newNum+=num/1000+num%1000/100+num%100/10+num%10;
return newNum;
}
三、編程題：30分 共1題
1. 求符合指定規則的數。
class Program
{
static ArrayList allNum=new ArrayList();
static void Main(string[] args)
{
int buffer;
for (int i = 1; i <= 10000; i++)
{
buffer=jisuan(i);
if (check(buffer)) allNum.Add(buffer);
}
for (int j = 1; j <= 10000; j++)
{
if (check(j)) Console.WriteLine(j);
}
}
static bool check(int i)
{
foreach (int num in allNum)
{
if (i == num) return false;
}
return true;
}
static int jisuan(int i)
{
int sum = i;
foreach (char c in i.ToString().ToCharArray())
{
sum += int.Parse(c.ToString());
}
return sum;
}
}
三 1 POJ 1316
my code：
Source
Problem Id:1316 User Id:jiang5448
Memory:192K Time:0MS
Language:G++ Result:Accepted
Source
#include <iostream>
using namespace std;
bool e[10000];
int d (int n)
{
int s=n;
while (n)
{
s+=n%10;
n/=10;
}
return s;
}
int main()
{
int i;
for (i=0;i<10000;i++)
e[i]=false;
for (i=1;i<10000;i++)
if (d(i)<10000)
e[d(i)]=true;
for (i=1;i<10000;i++)
if (!e[i])
cout<<i<<endl;
return 0;
}
ans：
1
3
5
7
9
20
31
42
53
64
75
86
97
108
110
121
132
143
154
165
176
187
198
209
211
222
233
244
255
266
277
288
299
310
312
323
334
345
356
367
378
389
400
411
413
424
435
446
457
468
479
490
501
512
514
525
536
547
558
569
580
591
602
613
615
626
637
648
659
670
681
692
703
714
716
727
738
749
760
771
782
793
804
815
817
828
839
850
861
872
883
894
905
916
918
929
940
951
962
973
984
995
1006
1021
1032
1043
1054
1065
1076
1087
1098
1109
1111
1122
1133
1144
1155
1166
1177
1188
1199
1210
1212
1223
1234
1245
1256
1267
1278
1289
1300
1311
1313
1324
1335
1346
1357
1368
1379
1390
1401
1412
1414
1425
1436
1447
1458
1469
1480
1491
1502
1513
1515
1526
1537
1548
1559
1570
1581
1592
1603
1614
1616
1627
1638
1649
1660
1671
1682
1693
1704
1715
1717
1728
1739
1750
1761
1772
1783
1794
1805
1816
1818
1829
1840
1851
1862
1873
1884
1895
1906
1917
1919
1930
1941
1952
1963
1974
1985
1996
2007
2022
2033
2044
2055
2066
2077
2088
2099
2110
2112
2123
2134
2145
2156
2167
2178
2189
2200
2211
2213
2224
2235
2246
2257
2268
2279
2290
2301
2312
2314
2325
2336
2347
2358
2369
2380
2391
2402
2413
2415
2426
2437
2448
2459
2470
2481
2492
2503
2514
2516
2527
2538
2549
2560
2571
2582
2593
2604
2615
2617
2628
2639
2650
2661
2672
2683
2694
2705
2716
2718
2729
2740
2751
2762
2773
2784
2795
2806
2817
2819
2830
2841
2852
2863
2874
2885
2896
2907
2918
2920
2931
2942
2953
2964
2975
2986
2997
3008
3023
3034
3045
3056
3067
3078
3089
3100
3111
3113
3124
3135
3146
3157
3168
3179
3190
3201
3212
3214
3225
3236
3247
3258
3269
3280
3291
3302
3313
3315
3326
3337
3348
3359
3370
3381
3392
3403
3414
3416
3427
3438
3449
3460
3471
3482
3493
3504
3515
3517
3528
3539
3550
3561
3572
3583
3594
3605
3616
3618
3629
3640
3651
3662
3673
3684
3695
3706
3717
3719
3730
3741
3752
3763
3774
3785
3796
3807
3818
3820
3831
3842
3853
3864
3875
3886
3897
3908
3919
3921
3932
3943
3954
3965
3976
3987
3998
4009
4024
4035
4046
4057
4068
4079
4090
4101
4112
4114
4125
4136
4147
4158
4169
4180
4191
4202
4213
4215
4226
4237
4248
4259
4270
4281
4292
4303
4314
4316
4327
4338
4349
4360
4371
4382
4393
4404
4415
4417
4428
4439
4450
4461
4472
4483
4494
4505
4516
4518
4529
4540
4551
4562
4573
4584
4595
4606
4617
4619
4630
4641
4652
4663
4674
4685
4696
4707
4718
4720
4731
4742
4753
4764
4775
4786
4797
4808
4819
4821
4832
4843
4854
4865
4876
4887
4898
4909
4920
4922
4933
4944
4955
4966
4977
4988
4999
5010
5025
5036
5047
5058
5069
5080
5091
5102
5113
5115
5126
5137
5148
5159
5170
5181
5192
5203
5214
5216
5227
5238
5249
5260
5271
5282
5293
5304
5315
5317
5328
5339
5350
5361
5372
5383
5394
5405
5416
5418
5429
5440
5451
5462
5473
5484
5495
5506
5517
5519
5530
5541
5552
5563
5574
5585
5596
5607
5618
5620
5631
5642
5653
5664
5675
5686
5697
5708
5719
5721
5732
5743
5754
5765
5776
5787
5798
5809
5820
5822
5833
5844
5855
5866
5877
5888
5899
5910
5921
5923
5934
5945
5956
5967
5978
5989
6000
6011
6026
6037
6048
6059
6070
6081
6092
6103
6114
6116
6127
6138
6149
6160
6171
6182
6193
6204
6215
6217
6228
6239
6250
6261
6272
6283
6294
6305
6316
6318
6329
6340
6351
6362
6373
6384
6395
6406
6417
6419
6430
6441
6452
6463
6474
6485
6496
6507
6518
6520
6531
6542
6553
6564
6575
6586
6597
6608
6619
6621
6632
6643
6654
6665
6676
6687
6698
6709
6720
6722
6733
6744
6755
6766
6777
6788
6799
6810
6821
6823
6834
6845
6856
6867
6878
6889
6900
6911
6922
6924
6935
6946
6957
6968
6979
6990
7001
7012
7027
7038
7049
7060
7071
7082
7093
7104
7115
7117
7128
7139
7150
7161
7172
7183
7194
7205
7216
7218
7229
7240
7251
7262
7273
7284
7295
7306
7317
7319
7330
7341
7352
7363
7374
7385
7396
7407
7418
7420
7431
7442
7453
7464
7475
7486
7497
7508
7519
7521
7532
7543
7554
7565
7576
7587
7598
7609
7620
7622
7633
7644
7655
7666
7677
7688
7699
7710
7721
7723
7734
7745
7756
7767
7778
7789
7800
7811
7822
7824
7835
7846
7857
7868
7879
7890
7901
7912
7923
7925
7936
7947
7958
7969
7980
7991
8002
8013
8028
8039
8050
8061
8072
8083
8094
8105
8116
8118
8129
8140
8151
8162
8173
8184
8195
8206
8217
8219
8230
8241
8252
8263
8274
8285
8296
8307
8318
8320
8331
8342
8353
8364
8375
8386
8397
8408
8419
8421
8432
8443
8454
8465
8476
8487
8498
8509
8520
8522
8533
8544
8555
8566
8577
8588
8599
8610
8621
8623
8634
8645
8656
8667
8678
8689
8700
8711
8722
8724
8735
8746
8757
8768
8779
8790
8801
8812
8823
8825
8836
8847
8858
8869
8880
8891
8902
8913
8924
8926
8937
8948
8959
8970
8981
8992
9003
9014
9029
9040
9051
9062
9073
9084
9095
9106
9117
9119
9130
9141
9152
9163
9174
9185
9196
9207
9218
9220
9231
9242
9253
9264
9275
9286
9297
9308
9319
9321
9332
9343
9354
9365
9376
9387
9398
9409
9420
9422
9433
9444
9455
9466
9477
9488
9499
9510
9521
9523
9534
9545
9556
9567
9578
9589
9600
9611
9622
9624
9635
9646
9657
9668
9679
9690
9701
9712
9723
9725
9736
9747
9758
9769
9780
9791
9802
9813
9824
9826
9837
9848
9859
9870
9881
9892
9903
9914
9925
9927
9938
9949
9960
9971
9982
9993
編程題，算法複雜度爲O（lgn * lgn）
char szElements[10036];
int szAddValue[] = {2, 11, 101, 1001};
char szAssist[27];
void Calculate( int iPos )
{
int iCurAddValue = szAddValue[iPos];
int iMaxElementPre = iCurAddValue + iPos * 9 - 2;
int nMergeElements = iMaxElementPre - iCurAddValue + 1;
if ( nMergeElements > 0 )
{
memcpy(szAssist, szElements + iCurAddValue, nMergeElements);
memcpy(szElements + iCurAddValue * 10, szAssist, nMergeElements);
}
memcpy(szElements + iCurAddValue, szElements, iCurAddValue);
for ( int i = 0; i < nMergeElements; i ++)
{
if (szAssist[i])
{
szElements[i + iCurAddValue ] = 1;
}
}
for ( int i = 2, iOffset = 2 * iCurAddValue; i <= 9; i ++)
{
memcpy(szElements + iOffset, szElements + iCurAddValue, iCurAddValue);
}
}
void main()
{
memset( szElements, 0, 10036);
szElements[0] = 1;
for ( int i = 0; i < 4; i ++)
{
Calculate(i);
}
for ( int i = 1; i <= 10000; i ++)
{
if (!szElements[i])
{
printf("%d/n", i);
}
}
}
上面少寫了一句 for ( int i = 2, iOffset = 2 * iCurAddValue; i <= 9; i ++)
改爲 for ( int i = 2, iOffset = 2 * iCurAddValue; i <= 9; i ++， iOffset += iCurAddValue)
修改代碼的結果如下：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//#define DEBUG
static int f1( char **errstr, unsigned int flag) //change char *errstr -->char **errstr
{
int copy, index, len;
int i=0;
//const static char **__err = {"err1", "err2","err3","err4"}; //此行換爲下行
const char __err[4][10] = {"err1", "err2","err3","err4"};
if(flag & 0x10000)
copy = 1;
index = (flag & 0x300000) >> 20;
#ifdef DEBUG
printf("copy %u index:%u/n",copy,index);
#endif
if(copy)
{
len = flag & 0xf;
*errstr = malloc(len);
if(*errstr == NULL) //change = -> ==
return -1;
strncpy(*errstr, __err[index-1], len); //change -1 sizeof(errstr)=4 -->len
}
else
{
*errstr = __err + index;
}
}
void f2(int c)
{
char *err;
switch(c)
{
case 1:
if(f1(&err, 0x110004) != -1)
printf("%s/n",err);
break; //add
case 2:
if(f1(&err, 0x30000D) != -1) //change f2 ->f1
printf("%s/n",err);
break; //add
}
free(err); //add
}
int main(int argc,char *argv[])
{
f2(1);
f2(2);
return 0;
}
四、設計題：35分 共1題
注意：請儘可能詳細描述你的數據結構、系統架構、設計思路等。建議多寫一些僞代碼或者流程說明。
1. 假設一個mp3搜索引擎收錄了2^24首歌曲，並記錄了可收聽這些歌曲的2^30條URL，但每首歌的URL不超過2^10個。系統會定期檢查這些URL，如果一個URL不可用則不出現在搜索結果中。現在歌曲名和URL分別通過整型的SONG_ID和URL_ID唯一確定。對該系統有如下需求：
1) 通過SONG_ID搜索一首歌的URL_ID，給出URL_ID計數和列表
2) 給定一個SONG_ID，爲其添加一個新的URL_ID
3) 添加一個新的SONG_ID
4) 給定一個URL_ID，將其置爲不可用
限制條件：內存佔用不超過1G，單個文件大小不超過2G，一個目錄下的文件數不超過128個。
爲獲得最佳性能，請說明設計的數據結構、搜索算法，以及資源消耗。如果系統數據量擴大，該如何多機分佈處理？
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
一點想法
因爲“每首歌的URL不超過2^10個”，似乎在提示每個SONG_ID的URL_ID佔用同樣的內存，那麼1g內存每個SONG_ID僅有64byte，而2^10個URL_ID即使一個bit存一個，也需要128byte，顯然行不通的。
存2^30條URL_ID，即一個URL_ID最多1byte的內存。而由於每個SONG_ID佔用的內存不同，所以至少還得存儲這個信息。以最少信息論，假設每個URL_ID佔一個bit，則一個SONG_ID佔用內存的長度最大會有2^20bit（轉換成字節、字等佔用的內存更多，但計算會方便一些，快一些）...即長度最少要佔用21bit。
另外，需要一個bit存一個URL_ID，至少還需要存一個MIN_URL_ID(然後第nbit爲1代表MIN_URL_ID+n這個URL_ID也屬於這個SONG_ID)，SONG_ID因爲基本可以認爲不會刪除，所以不於保存，直接按index來。
也就是說，要存儲一個SONG_ID，至少需要內存 32＋21+URL_ID_CNT bits.所以總內存需:
（32＋21） × 2^24 + 2^30 > 1G
<汗一個，寫到這裏忽然發現1G內存存1g個URL_ID,很明顯直接就是不夠...>
所以，要佔用1g以下內存，基本上可以認爲需要用硬盤做數據交換，但似乎總感覺不爽，畢竟從題意上看，是不適合這樣的。當然了，1個文件2g最大，也不明白意思。直覺上認爲跟分佈運算有關。
PS:因爲URL_ID變化較大，（很可能隨時增加或者減少一個）所以不適合用連續存儲的方式。
假設有如下數據段，進行二路歸併：
A：1 2 3 4 5 6
B：7
比較次數：6次
A：1 2 3 4 5 6
B：0
比較次數：1次
看到那個求小於100000的那個題的沒一個對的！
看看14可以合成不？
f(a)=b;
f(a+1)=c;
b到c之間的都是不可合成的數。
原因：如果b與c間有d可以由合成即f(x)=d;
=> x>a && x<a+1
=> ...........
我覺得3.1應該倒着推！從0到1000，看看都可以生成什麼數，然後把生成的數標誌位置爲true，最後檢查一下有那些數仍然爲false就可以了。
#include <iostream>
using namespace std;
bool flag[2000]={false}; //1-2000
int main()
{
for(int i=0;i<10;++i)
for(int j=0;j<10;++j)
for(int k=0;k<10;++k)
flag[i*100+j*10+k*1 + i+j+k]=true;
for(int num=0;num<1000;++num)
if(flag[num]==false)
cout<<num<<" ";
return 0;
}
３。１題
以１００ 爲例子
一個容易看懂的：
#include <iostream>
#include <cmath>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>
using namespace std;
int main()
{
vector<int> a;
list<int> b;
for ( int n = 1; n < 100; ++n )
{
int j = ( (n%10) + (n/10) + n );
if ( j < 100 )
{
a.push_back(j);
}
}
sort( a.begin(), a.end() );
for ( int i = 1; i <= 100; ++i )
b.push_back(i);
for ( int j = 0; j < a.size(); ++j )
{
b.remove( a[j] );
}
ostream_iterator<int,char> out ( cout, "/n" );
copy( b.begin(), b.end(), out );
cout << " Done!" << endl;
return 0;
}
/////////
output:
>g++ baidu.C
> ./a.out
1
3
5
7
9
20
31
42
53
64
75
86
97
100
Done!
這樣就沒有１００啦
#include <iostream>
#include <cmath>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>
using namespace std;
int main()
{
vector<int> a;
list<int> b;
for ( int n = 1; n < 100; ++n )
{
int j = ( (n%10) + (n/10) + n );
if ( j <= 100 )
{
a.push_back(j);
}
}
sort( a.begin(), a.end() );
for ( int i = 1; i <= 100; ++i )
b.push_back(i);
for ( int j = 0; j < a.size(); ++j )
{
b.remove( a[j] );
}
ostream_iterator<int,char> out ( cout, "/n" );
copy( b.begin(), b.end(), out );
cout << " Done!" << endl;
return 0;
}
/////////
output:
>g++ baidu.C
> ./a.out
1
3
5
7
9
20
31
42
53
64
75
86
97
Done!
TO qdyongge:
=====================================================
||暈，看到那個求小於100000的那個題的沒一個對的！
||看看14可以合成不？
||f(a)=b;
||f(a+1)=c;
||b到c之間的都是不可合成的數。
||原因：如果b與c間有d可以由合成即f(x)=d;
||=> x>a && x<a+1
||=> ...........
=====================================================
你的說法不對噢!認真的思考一下: 14=7+7;
其次:你的這個理論:"(a)=b;f(a+1)=c;b到c之間的都是不可合成的數"有什麼數學根據嗎?
用一個簡單證僞:
f(999)=999+9+9+9=1026;
f(999+1)=1000+1=1001;
在1001--1026之間可合成的數很多,就列一個吧.如:1024=998+9+9+8