1、N條直線最多將平面分成多少部分。
2、有2006個硬幣,正面圖案全部朝上,依其序號排列從1至2006。
第1次翻轉所有序號爲1的倍數的硬幣；
第2次翻轉所有序號爲2的倍數的硬幣；
第3次翻轉所有序號爲3的倍數的硬幣；
.......
第2006次翻轉所有序號爲2006的倍數的硬幣。
這時，正面朝下的硬幣還有幾個？
答案：是1-2006之間的完全平方數，
數的奇偶性，可以發現這個硬幣號碼的約數有幾個，就會被翻動幾次，翻動奇數次，硬幣正面向下，只有完全平方數的約數是奇數個，所以找到1-2006之間的完全平方數即可。
3、已知兩個數的異或與和，可以唯一確定這對數嗎？
4、二叉樹前序後序可以確定一個二叉樹嗎？
5、字符串所有不重複排列。
#include "stdafx.h"
inline void Swap(char& a, char& b)
{
char temp = a;
a = b;
b = temp;
}
void Perm(char list[], int k, int m)
{
/*生成list [k：m ]的所有排列方式*/
int i;
if (k == m)
{
for (i = 0; i <= m; i++)
putchar(list[i]);
putchar('\n');
}
/* list[k：m ]有多個排列方式
* 遞歸地產生這些排列方式
*/
else
for (i=k; i <= m; i++)
{
Swap (list[k], list[i]);
Perm (list, k+1, m);
Swap (list [k], list [i]);
}
}
int _tmain(int argc, _TCHAR* argv[])
{
char s[] = "abcd";
Perm(s,0,3);
return 0;
}
6、計算sizeof的結果
基本數據類型的sizeof
這裏的基本數據類型指short、int、long、float、double這樣的簡單內置數據類型，由於它們都是和系統相關的，所以在不同的系統下取值可能不同，這務必引起我們的注意，儘量不要在這方面給自己程序的移植造成麻煩。
一般的，在32位編譯環境中，sizeof(int)的取值爲4。
對於64位平臺上各種數據類型分別佔用多少字節，存在一些疑問，所以用C/C++中的sizeof分別在這兩種平臺上進行了測試。
運行結果如下：（分別用藍色和紅色標記了兩者的差異）
——————————————————————————
機器平臺：X86_64 處理器
操作系統：Red Hat 4.1.2-14
編譯器： gcc version 4.1.2 20070626
Size of char is: 1
Size of unsigned char is: 1
Size of signed char is: 1
Size of int is: 4
Size of short is: 2
Size of long is: 8
Size of long int is: 8
Size of signed int is: 4
Size of unsigned int is: 4
Size of unsigned long int is: 8
Size of long long int is: 8
Size of unsigned long long is: 8
Size of float is: 4
Size of double is: 8
Size of long double is: 16
Size of (void *) is: 8
Size of (char *) is: 8
Size of (int *) is: 8
Size of (long *) is: 8
Size of (long long *) is: 8
Size of (float *) is: 8
Size of (double *) is: 8
——————————————————————————
機器平臺： X86_32 處理器
操作系統： Windows XP SP2
編譯器： VS2005自帶的C++編譯器
Size of char is: 1
Size of unsigned char is: 1
Size of signed char is: 1
Size of int is: 4
Size of short is: 2
Size of long is: 4
Size of long int is: 4
Size of signed int is: 4
Size of unsigned int is: 4
Size of unsigned long int is: 4
Size of long long int is: 8
Size of unsigned long long is: 8
Size of float is: 4
Size of double is: 8
Size of long double is: 8
Size of (void *) is: 4
Size of (char *) is: 4
Size of (int *) is: 4
Size of (long *) is: 4
Size of (long long *) is: 4
Size of (float *) is: 4
Size of (double *) is: 4指針變量的sizeof 學過數據結構的你應該知道指針是一個很重要的概念，它記錄了另一個對象的地址。既然是來存放地址的，那麼它當然等於計算機內部地址總線的寬度。所以在32位計算機中，一個指針變量的返回值必定是4（注意結果是以字節爲單位）數組的sizeof 數組的sizeof值等於數組所佔用的內存字節數，如：char a1[] = "abc";int a2[3];sizeof( a1 ); // 結果爲4，字符 末尾還存在一個NULL終止符sizeof( a2 ); // 結果爲3*4=12（依賴於int） 一些朋友剛開始時把sizeof當作了求數組元素的個數，現在，你應該知道這是不對的，那麼應該怎麼求數組元素的個數呢Easy，通常有下面兩種寫法：int c1 = sizeof( a1 ) / sizeof( char ); // 總長度/單個元素的長度int c2 = sizeof( a1 ) / sizeof( a1[0] ); // 總長度/第一個元素的長度 寫到這裏，提一問，下面的c3，c4值應該是多少呢void foo3(char a3[3]){ int c3 = sizeof( a3 ); // c3 ==}void foo4(char a4[]){ int c4 = sizeof( a4 ); // c4 ==} 也許當你試圖回答c4的值時已經意識到c3答錯了，是的，c3!=3。這裏函數參數a3已不再是數組類型，而是蛻變成指針，相當於char* a3，爲什麼仔細想想就不難明白，我們調用函數foo1時，程序會在棧上分配一個大小爲3的數組嗎不會！數組是“傳址”的，調用者只需將實參的地址傳遞過去，所以a3自然爲指針類型（char*），c3的值也就爲4。
1.常規
char str1[] = “Hello” ;
char str2[5] = {'H','e','l','l','o'};
char str3[6] = {'H','e','l','l','o','\0'};
char *p1 = "Hello";
char *p2[]={"hello","world"};
int n = 10;
int *q = &n;
sizeof (str1 ) = 6 (自動加了'\0')
strlen (str1 ) = 5 (字符串的長度)
sizeof (str2 ) = 5 (字符數組的大小)
strlen (str2) = 未知 (該字符串缺少結束符'\0')
sizeof (str3) = 6 (字符數組的大小)
strlen (str3) = 5 (該字符串的長度爲5)
sizeof ( p1 ) = 4 (p1是一個指針，大小爲4)
sizeof ( p2 ) = 8 (p2是長度爲2的字符串數組)
sizeof ( n ) = 4 (整型大小爲4)
sizeof ( q ) = 4 (q是一個指針，大小爲4)
2.動態分配內存
int *p = (int *)malloc( 100 );
sizeof ( p ) = 4 (p是一個指針，大小爲4)
3.函數參數
void Function1( char p[],int num ){
sizeof ( p ) = 4 (數組在做爲函數參數時均化爲指針)
}
void Function2( int p[],int num ){
sizeof ( p ) = 4 (數組在做爲函數參數時均化爲指針)
}
4.多重繼承
class A{};
class B{};
class C:public A,public B{};
class D:virtual public A{};
class E:virtual public A,virtual public B{};
sizeof ( A ) = 1 (空類大小爲1,編譯器安插一個char給空類，用來標記它的每一個對象)
sizeof ( B ) = 1 (空類大小爲1,編譯器安插一個char給空類，用來標記它的每一個對象)
sizeof ( C ) = 1 (繼承或多重繼承後空類大小還是1)
sizeof ( D ) = 4 (虛繼承時編譯器爲該類安插一個指向父類的指針，指針大小爲4）
sizeof ( E ) = 8 (指向父類A的指針與父類B的指針，加起來大小爲8）
5.數據對齊
類(或結構)的大小必需爲類中最大數據類型的整數倍.CPU訪問對齊的數據的效率是最高的，因此通常編譯浪費一些空間來使得我們的數據是對齊的 整個結構體的總大小爲最寬基本類型成員大小的整數倍。 對齊模數的選擇只能是根據基本數據類型，所以對於結構體中嵌套結構體，只能考慮其拆分的基本數據類型。而對於對齊準則中的第2條，確是要將整個結構體看成是一個成員，成員大小按照該結構體根據對齊準則判斷所得的大小。 類對象在內存中存放的方式和結構體類似，這裏就不再說明。需要指出的是，類對象的大小隻是包括類中非靜態成員變量所佔的空間，如果有虛函數，那麼再另外增加一個指針所佔的空間即可。 VC中可用#pragma pack(k)（k爲對齊模數）來設置編譯器的內存對齊模數。
class A{
public:
int a;
};
class B{
public:
int a ;
char b;
};
class C{
public:
int a ;
char b;
char c;
};
sizeof(A) = 4 （內含一個int ，所以大小爲4）
sizeof(B) = 8 (int爲4，char爲1，和爲5，考慮到對齊，總大小爲int的整數倍即8)
sizeof(C) = 8 (同上)
6.函數與虛函數
編譯器爲每個有虛函數的類都建立一個虛函數表（其大小不計算在類中）,併爲這個類安插一個指向虛函數表的指針，即每個有虛函數的類其大小至少爲一個指針的大小4
class A{
public:
int a;
void Function();
};
class B{
public:
int a;
virtual void Function();
};
class C:public B{
public:
char b;
};
class D:public B{
public:
virtual void Function2();
};
class E{
public:
static void Function();
};
sizeof (A) = 4 (內含一個int,普通函數不佔大小)
sizeof (B) = 8 (一個int ,一個虛函數表指針)
sizeof (C) =12 (一個int ,一個虛函數表指針，一個char ,再加上數據對齊)
sizeof (D) = 8 (一個int ,一個虛函數表指針,多個虛函數是放在一個表裏的，所以虛函數表指針只要一個就行了)
sizeof (E) = 1 (static 函數不佔大小,空類大小爲1)
7.父類的私有數據
雖然在子類中不可用，但是是可見的，因此私有的數據還是要佔子類的大小
class A{
private:
int a;
};
class B:public A{};
sizof(B) = 4; (內含一個不可用的父類的int）
8.大概就這麼多了吧,想到再加吧。虛函數，多重繼承，空類是比較複雜的，大家大概記住知道就行了
Sizeof與Strlen的區別與聯繫(轉）
1.sizeof操作符的結果類型是size_t，它在頭文件中typedef爲unsigned int類型。
該類型保證能容納實現所建立的最大對象的字節大小。
2.sizeof是算符，strlen是函數。
3.sizeof可以用類型做參數，strlen只能用char*做參數，且必須是以''\0''結尾的。
sizeof還可以用函數做參數，比如：
short f();
printf("%d\n", sizeof(f()));
輸出的結果是sizeof(short)，即2。
4.數組做sizeof的參數不退化，傳遞給strlen就退化爲指針了。
5.大部分編譯程序 在編譯的時候就把sizeof計算過了 是類型或是變量的長度這就是sizeof(x)可以用來定義數組維數的原因
char str[20]="0123456789";
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;
6.strlen的結果要在運行的時候才能計算出來，時用來計算字符串的長度，不是類型佔內存的大小。
7.sizeof後如果是類型必須加括弧，如果是變量名可以不加括弧。這是因爲sizeof是個操作符不是個函數。
8.當適用了於一個結構類型時或變量， sizeof 返回實際的大小，
當適用一靜態地空間數組， sizeof 歸還全部數組的尺寸。
sizeof 操作符不能返回動態地被分派了的數組或外部的數組的尺寸
9.數組作爲參數傳給函數時傳的是指針而不是數組，傳遞的是數組的首地址，
如：
fun(char [8])
fun(char [])
都等價於 fun(char *)
在C++裏參數傳遞數組永遠都是傳遞指向數組首元素的指針，編譯器不知道數組的大小
如果想在函數內知道數組的大小， 需要這樣做：
進入函數後用memcpy拷貝出來，長度由另一個形參傳進去
fun(unsiged char *p1, int len)
{
unsigned char* buf = new unsigned char[len+1]
memcpy(buf, p1, len);
}
Sizeof與Strlen的區別與聯繫(轉）
1.sizeof操作符的結果類型是size_t，它在頭文件中typedef爲unsigned int類型。
該類型保證能容納實現所建立的最大對象的字節大小。
2.sizeof是算符，strlen是函數。
3.sizeof可以用類型做參數，strlen只能用char*做參數，且必須是以''\0''結尾的。
sizeof還可以用函數做參數，其結果是函數返回類型的大小，函數並不會被調用，比如：
short f();
printf("%d\n", sizeof(f()));
輸出的結果是sizeof(short)，即2。
4.數組做sizeof的參數不退化，傳遞給strlen就退化爲指針了。
5.大部分編譯程序 在編譯的時候就把sizeof計算過了 是類型或是變量的長度這就是sizeof(x)可以用來定義數組維數的原因
char str[20]="0123456789";
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;
6.strlen的結果要在運行的時候才能計算出來，時用來計算字符串的長度，不是類型佔內存的大小。
7.sizeof後如果是類型必須加括弧，如果是變量名可以不加括弧。這是因爲sizeof是個操作符不是個函數。
8.當適用了於一個結構類型時或變量， sizeof 返回實際的大小，
當適用一靜態地空間數組， sizeof 歸還全部數組的尺寸。
sizeof 操作符不能返回動態地被分派了的數組或外部的數組的尺寸
9.數組作爲參數傳給函數時傳的是指針而不是數組，傳遞的是數組的首地址，
如：
fun(char [8])
fun(char [])
都等價於 fun(char *)
在C++裏參數傳遞數組永遠都是傳遞指向數組首元素的指針，編譯器不知道數組的大小
如果想在函數內知道數組的大小， 需要這樣做：
進入函數後用memcpy拷貝出來，長度由另一個形參傳進去
fun(unsiged char *p1, int len)
{
unsigned char* buf = new unsigned char[len+1]
memcpy(buf, p1, len);
}
世上編譯器林林總總，但作爲一個規範，它們都會保證char、signed char和unsigned
char的sizeof值爲1，畢竟char是我們編程能用的最小數據類型。
7、宏定義求最大值、最小值、兩數交換
#define MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )
#define MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )
#define SWAP(a,b) (a)^=(b)^=(a)^=(b)
這個宏考慮到類型了，很好用~~
#define SWAP(type,a,b) {type tmp; tmp=a; a=b; b=tmp;}
#include
int main()
{
double a = 10.0, b = 20.0;
SWAP(double, a, b);
printf("%f %f\n",a,b);
int c = 10, d= 28;
SWAP(int, c, d);
printf("%d %d\n",c,d);
return 0;
}
下面這個在宏定義裏沒有考慮類型，但是，a b 之間交換數值的時候，沒有用到臨時變量，同種類型的變量在運算~
#define SWAP(a,b) {a=a+b; b=a-b; a=a-b;}
#include
int main()
{
double a=10.0, b=20.0;
SWAP(a,b);
printf("%f %f\n",a,b);
int c = 10, d= 28;
SWAP(c,d);
printf("%d %d\n",c,d);
return 0;
}
用內存拷貝的方法，貌似有點複雜：
#define SWAP(a, b)\
{\
int size = sizeof(a);\
char* temp = (char*)malloc(size);\
memcpy(temp, &a, size);\
memcpy(&a, &b, size);\
memcpy(&b, temp, size);\
free(temp);\
}
#include
#include
#include
int main()
{
double a=10.0, b=20.0;
SWAP(a,b);
printf("%f %f\n",a,b);
int c = 10, d= 28;
SWAP(c,d);
printf("%d %d\n",c,d);
return 0;
}