autodesk 11.25笔试
写在前面，今年找工作参加的笔试不算太少了，不能怪别人，只能怪自己基础不好，每次笔试总好像脑子迟钝了一样，可是回来再做发现一点都不难。
比如今天的所谓智力题，应该不算的，都是很基本的几何、集合等题，可是我可能很害怕做智力题一样，感觉没作对几题，太遗憾了。
技术题觉得不难，但是纸上写程序可能我始终适应不了，因为我不可能一遍就写对程序，而一遍写下去纸上却不想用编辑器可以随时修改，所以经常想得是对的，却总是写出丢三落四的程序，太恨自己了！！
难道老天对我的所有努力就不屑一顾吗，难道我今年就真的找不到工作了吗？？天知道！要不给我机会有种就一直别给我机会！！！！！！！
智力题：
1. 一个集合运算
主要运用公式：
P(A 
B C)=P(A)+P(B)+P(C)-P(A 
B)-P(A C)-P(B C) +P(A B C)
2. 有2007个叶子的二叉树最多有多少个节点____4014__
3.已知一个圆桌靠近两墙，桌的边缘存在一点，此点到两墙距离分别为8cm，9cm，请问圆桌的半径__29__
4.有8个硬币，面都朝上，每次翻转时一定要一起翻转8个中的7个，请问要使8个硬币都朝下，至少需要几次_8__
5.洗相片的问题
8个人，每个人都要与其他人组合照相作为留恋，请问一共要洗多少张照片？
技术题：
不要在构造函数和析构函数中调用virtual函数
#include <iostream>
using namespace std;
class Base{public: virtual ~Base(){ foo(); }virtual void foo() { cout << "Base::foo() called"; }
};
class Derived : public Base
{public: virtual ~Derived(){}virtual void foo() { cout << "Derived::foo() called"; }
};
int main(){ Derived *d=new Derived;delete d;
system("PAUSE"); return 0;}
运行结果：Base::foo() called
总结：
1)对于一个派生类的对象来说，在其基类的构造函数调用的时候，这一对象的类型就是基类的。不仅仅虚函数会解析为基类的，而且 C++ 中使用运行时类型信息的部分（比如 dynamic_cast （参见第 27 条）和 typeid ）也会将这个对象的类型看作基类的。
2)当基类的析构函数被调用时，这个对象将成为一个基类对象， C++ 所 有的部分——包括虚函数、 dynamic_cast 等等——都会这样对待该对象。
今天autodesk笔试题出了很多在构造函数和析构函数中做手脚的题，掌握了上面两个规则，则无忧矣！
#include <iostream>
using namespace std;
class Base{public: Base(char a) : c(a){ cout << c << endl; }private: char c;};
class Derived : public Base
{public: Derived(char a) : Base(a+1), c(a) { cout << c << endl; }private: char c;};
int main(){ Derived d('X'); system("PAUSE"); return 0;}
运行结果：YX
释放内存方法：
1)
int *p=new int;
delete p;
2)
int *p=new int[1024];
delete [] p;
3)
char *p[2];p[0]=new char;
p[1]=new char;
delete p[0];
delete p[1];
4)
char **p=new char*[2];//如果写成：char **p=new (char*)[2], 语法上error
p[0]=new char[100];
p[1]=new char[200];
delete [] p[0];
delete [] p[1];
delete [] p;
十进制数转八进制数:
#include <iostream>
#include <vector>
using namespace std;
void convert(int N)
{ vector<int> v; while(N>0) {v.push_back(N%8);
N /= 8;
}
cout << "0"; while(!v.empty()) {cout << v.back();
v.pop_back();
}
}
int main(){ int num =110;cout << "(" << num << ")10 Octal num is: (";
convert(num);
cout << ")8"; system("PAUSE"); return 0;}
大题：
打印螺旋矩阵：
例如 N=4，矩阵为
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7
#include <iostream>
using namespace std;
void print_matrix(){ int N; cout << "Please Input the dimense: ";cin >> N;
//分配一个指针数组，其首地址保存在pMatrix中int **arr = new int*[N];
//为指针数组的每个元素分配一个数组for (int i = 0; i < N; i++)
arr[i] = new int[N];
int top=0, left=0; int bottom=N-1, right=N-1; int num=1; while(left<=right && top <= bottom) {for(int i=left; i<=right; ++i)
{arr[top][i]=num++;
}
++top;
for(int i=top; i<=bottom; ++i)
{arr[i][right]=num++;
}
--right;
for(int i=right; i>=left; --i)
{arr[bottom][i]=num++;
}
--bottom;
for(int i=bottom; i>=top; --i)
{arr[i][left]=num++;
}
++left;
}
//打印矩阵for(int i=0; i<N; ++i)
{for(int j=0; j<N; ++j)
{ cout << arr[i][j] << "\t";}
cout << "\n";}
//以下是释放动态分配的空间for (int i = 0; i < N; i++)
delete [] arr[i];
delete []arr;
}
int main(){print_matrix();
system("PAUSE"); return 0;}
遍历二叉树，并对于每个节点做如下操作：
将节点左指针指向其父节点，将其右指针指向其左子树
要求：非递归（原题没有这个条件）
已知：
struct Node{Node *left;Node *right;int data;};
我的做法：利用两个堆栈
#include <iostream>
#include <vector>
#include <cstdlib>
using namespace std;
struct Node{ char data;Node * left;
Node * right;
};
enum Tag{goLeft, goRight, goBack };void Traverse(Node *root){assert(root != NULL);
vector<Node *> vec_node;
vector<Tag> vec_flag;
//initvec_node.push_back(root);
vec_flag.push_back(goLeft);
while(!vec_node.empty()) {Node *curNode = vec_node.back();
Tag curFlag = vec_flag.back();
switch(curFlag) { case goLeft:vec_flag.pop_back();
vec_flag.push_back(goRight);
if(curNode->left != NULL) {vec_node.push_back(curNode->left);
vec_flag.push_back(goLeft);
}
break; case goRight:vec_flag.pop_back();
vec_flag.push_back(goBack);
if(curNode->right != NULL) {vec_node.push_back(curNode->right);
vec_flag.push_back(goLeft);
}
break; case goBack:vec_flag.pop_back();
vec_node.pop_back();
curNode->right=curNode->left;
curNode->left=vec_node.empty() ? NULL : vec_node.back();
//验证打印输出 cout << curNode->data << "\t"; if(curNode->left != NULL) { cout << curNode->left->data << "\t";}
else {cout << "NULL" << "\t";
}
if(curNode->right != NULL) { cout << curNode->right->data << "\t";}
else {cout << "NULL" << "\t";
}
cout << endl;
break; default: break; }//switch-end }//while-end}
int main(){Node root, b, c, d, e, f, g, h;
root.data='a';root.left=&b;
root.right=&e;
b.data='b';b.left=&c;
b.right=&d;
c.data='c';c.left=NULL;
c.right=NULL;
d.data='d';d.left=NULL;
d.right=NULL;
e.data='e';e.left=&f;
e.right=&g;
f.data='f';f.left=NULL;
f.right=NULL;
g.data='g';g.left=NULL;
g.right=&h;
h.data='h';h.left=NULL;
h.right=NULL;
cout << "Traverse:\n"; cout << "Node\tleft\tright\n---------------------------\n";Traverse(&root);
cout << "\n\n"; system("PAUSE"); return 0;}
输出结果：
更一般的二叉树非递归操作请参见我的总结：http://www.cnblogs.com/chio/archive/2007/10/24/935784.html
一个对象引用计数的问题：
这个题我觉得考的知识非常多，所以特别作为最后一个题来探讨：
涉及的知识点－
- 按值传递对象时到底怎样进行
- 按值返回对象时到底怎样进行
- NRV(Named Return Value)问题
- 临时对象生成
- 对象生命期
- 析构函数自动调用时机
虽然这个涉及问题比较多，而我也一时没有弄清楚。可能还与编译器相关..所以接下来的几天有时间再研究研究
浙公网安备 33010602011771号