autodesk 11.25笔试

写在前面，今年找工作参加的笔试不算太少了，不能怪别人，只能怪自己基础不好，每次笔试总好像脑子迟钝了一样，可是回来再做发现一点都不难。

比如今天的所谓智力题，应该不算的，都是很基本的几何、集合等题，可是我可能很害怕做智力题一样，感觉没作对几题，太遗憾了。

技术题觉得不难，但是纸上写程序可能我始终适应不了，因为我不可能一遍就写对程序，而一遍写下去纸上却不想用编辑器可以随时修改，所以经常想得是对的，却总是写出丢三落四的程序，太恨自己了！！

难道老天对我的所有努力就不屑一顾吗，难道我今年就真的找不到工作了吗？？天知道！要不给我机会有种就一直别给我机会！！！！！！！

智力题：

1. 一个集合运算

主要运用公式：

P(A union B union C)=P(A)+P(B)+P(C)-P(A JIAO B)-P(A JIAO C)-P(B JIAO C) +P(A JIAO B JIAO C)

2. 有2007个叶子的二叉树最多有多少个节点____4014__

3.已知一个圆桌靠近两墙，桌的边缘存在一点，此点到两墙距离分别为8cm，9cm，请问圆桌的半径__29__

cicle_wall

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;
    //init
    vec_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;
}
 
 

输出结果：

traverse

更一般的二叉树非递归操作请参见我的总结：http://www.cnblogs.com/chio/archive/2007/10/24/935784.html

 

一个对象引用计数的问题：

这个题我觉得考的知识非常多，所以特别作为最后一个题来探讨：

涉及的知识点－

  • 按值传递对象时到底怎样进行
  • 按值返回对象时到底怎样进行
  • NRV(Named Return Value)问题
  • 临时对象生成
  • 对象生命期
  • 析构函数自动调用时机

虽然这个涉及问题比较多，而我也一时没有弄清楚。可能还与编译器相关..所以接下来的几天有时间再研究研究

posted @ 2007-11-25 17:06  中土  阅读(668)  评论(0)  编辑  收藏  举报
©2005-2008 Suprasoft Inc., All right reserved.