autodesk 11.25笔试

最新推荐文章于 2024-05-24 21:52:30 发布
最新推荐文章于 2024-05-24 21:52:30 发布
阅读量65 收藏
点赞数
文章标签： 数据结构与算法 c/c++
原文链接：http://www.cnblogs.com/chio/archive/2007/11/25/971823.html
版权

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

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

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

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

智力题：

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)问题
  • 临时对象生成
  • 对象生命期
  • 析构函数自动调用时机

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

转载于:https://www.cnblogs.com/chio/archive/2007/11/25/971823.html

weixin_30549175
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
11.25字节一面
11-25
11.25字节一面
11.25
m0_56318844的博客
11-30 65
1111。大大大
11.25总结
m0_72618437的博客
11-25 289
总结
11.25 pyfolio
yueguoqing88的博客
11-25 615
11.25 pyfolio 处理return 文件
11.25补
awSolitude的博客
12-01 64
#!/usr/bin/env python # coding: utf-8 # # 22.函数 # ## （1）定义： # （1）是有特定功能可重复使用的代码块 # （2）作用是降低编程难度和代码复用。 # （3）先定义再调用最后才执行。 # （4）格式： # def<函数名>（参数（0个或多个））： # <函数体> # return 返回值或表达式 # （5）形式参数...
11.25笔记
niuguangxu的博客
12-18 168
23.参数 默认参数：给形参赋初值 位置参数：形参与实参顺序位置相一致 关键字参数：形参与实参变量名相同并赋值，顺序可以不相同 可变长度参数：参数个数可变，在参数前加一个*或两个* 一个*：多个位置参数放在一个元组中； 两个*：多个关键参数放在一个字典中； 序列解包参数（实参）：实参为列表或元组时进行解包 24.导入库函数 三种格式： （1）import 库名 库名.函数方法（参数） ...
11.25作业1
08-08
11.25作业1
zuoye11.25.zip
11-29
zuoye11.25.zip
11.25第二题.exe
12-16
11.25第二题.exe
力扣230. 二叉搜索树中第K小的元素
最新发布
LNsupermali的博客
05-24 235
力扣230. 二叉搜索树中第K小的元素
Day31 代码随想录打卡|二叉树篇---二叉树的递归遍历
m0_48909584的博客
05-19 468
因此我们递归函数的参数和返回值肯定是节点和返回结果的数组，终止条件是当遍历的节点为空，即遍历完时，单层遍历根据不同的遍历方式不同而确定。二叉树的前序遍历是中左右的顺序；中序遍历是左中右的顺序；后序遍历是左右中的顺序。利用递归写出二叉树的遍历时，我们一定要明确几个点，一是。利用递归的方式写出二叉树的前、中、后序遍历。
力扣HOT100 - 1143. 最长公共子序列
qq_61504864的博客
05-20 363
【代码】力扣HOT100 - 1143. 最长公共子序列。
堆与堆排序算法实现分享
Mrluo386的博客
05-22 291
在计算机科学中，堆是一种特殊的完全二叉树数据结构，常被用于实现优先队列等应用场景。本文将通过一个C语言示例，详细介绍如何实现一个基于数组的大顶堆及其基本操作——包括堆的创建、插入元素（入堆）、删除最大元素（出堆）以及利用这些操作实现堆排序算法。本代码实例主要涉及到了一个Heap结构体的定义、堆的创建、元素的插入与删除，以及堆排序的整个过程。
【动态规划】训练
m0_74183164的博客
05-21 240
这题硬币很像，就是判断条件不同。只有偶数才能转移。输入一个长为n的序列，输出这个序列最长上升子序列的长度。
近邻算法详解
智光工作室
05-24 393
它的基本思想是根据已知的样本数据，通过计算新样本与已知样本的距离，来判断新样本属于哪个类别。总结来说，KNN算法通过计算待分类样本与已知样本的距离，并根据距离选择离待分类样本最近的k个已知样本，来进行分类或回归。需要注意的是，KNN算法的性能受到k值的影响。在回归问题中，对于待预测样本，计算其与已知样本的距离，然后根据距离加权平均或者取平均值，得到待预测样本的预测结果。统计这k个已知样本中各个类别的数量，选择数量最多的类别作为待分类样本的类别。根据距离的大小，选择离待分类样本最近的k个已知样本。
链式结构二叉树的应用
Frenemy__的博客
05-21 985
本文将对链式结构二叉树的几种功能进行实现与讲解在链表结构二叉树中，递归的使用是必不可少的，在使用的过程中，要时常问问自己：这个递归结构可不可以这样用？具体的逻辑实现过程是怎样的？只有这样，才能学好链表结构二叉树。！！
二叉树的链式结构
SWsunlight的博客
05-24 522
二叉树的基础实现（包含遍历、查找节点、判断是否为完全二叉、计算结点个数、高度等）
PTA 6-18 循环链表的追加
LgdCjp的博客
05-20 695
其中rear是一个指针，所指的单元中存储有循环单链表的尾结点的地址（因每个结点均存储的是地址，还要通过指针返回内容，故而是指针的指针）。p拟添加到尾部的结点指针。要求添加新元素后，尾指针要指向新添加的元素。只需要完成上述函数，不需要考虑输入与输出部分,测试程序会调用它进行某些操作。
tan11.25用verilog语句编写
06-06
同样地，以下是一个可以计算tan(11.25)的Verilog模块： ``` module tan_11_25(output reg [31:0] result); reg [31:0] pi, rad, angle; reg [31:0] numerator, denominator, fraction; integer i; // Convert ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值