牛客错题1

下面的说法那个正确？

#define NUMA 10000000
#define NUMB 1000
int a[NUMA], b[NUMB];

void pa()
{
    int i, j;
    for(i = 0; i < NUMB; ++i)
        for(j = 0; j < NUMA; ++j)
            ++a[j];
}
void pb()
{
    int i, j;
    for(i = 0; i < NUMA; ++i)
        for(j = 0; j < NUMB; ++j)
            ++b[j];
}`这里写代码片`

正确答案: C 你的答案: B (错误)

A. pa 和 pb 运行的一样快
B. pa 比 pb 快
C. pb 比 pa 快
D. 无法判断

测试时pb比pa快，数组a比数组b大很多，可能跨更多的页，缺页率高或者缓存命中更低，所以pb快

下列代码的输出为：

#include "iostream"  
#include "vector"  
using namespace std;

int main(void)
{
    vector<int>array;
    array.push_back(100);
    array.push_back(300);
    array.push_back(300);
    array.push_back(500);
    vector<int>::iterator itor;
    for (itor = array.begin(); itor != array.end(); itor++)
    {
        if (*itor == 300)
        {
            itor = array.erase(itor);
        }
    }
    for (itor = array.begin(); itor != array.end(); itor++)
    {
        cout << *itor << " ";
    }
    system("pause");
    return 0;
}

正确答案: B 你的答案: C (错误)
A. 100 300 300 500
B. 100 300 500
C. 100 500
D. 程序错误

vector在erase之后，指向下一个元素的位置，其实进行erase操作时将后面所有元素都向前移动，迭代器位置没有移动。itor=array.erase(itor)erase返回下一个元素的地址，相当于给itor一个新值。

---

下面有关回调函数的说法，错误的是？
正确答案: C 你的答案: B (错误)

A. 回调函数就是一个通过函数指针调用的函数
B. 回调函数可能被系统API调用一次，也可能被循环调用多次
C. 回调函数本身可以是全局函数 ，静态函数和某个特定的类的成员函数
D. 回调函数可用于通知机制

核心就是类成员函数需要this指针访问函数，而全局或者静态函数不需要this指针。

简言之，类的成员函数需要隐含的this指针 而回调函数没有办法提供。

基础概念:

     回调函数就是一个通过函数指针调用的函数。


     如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。


     回调函数不是由该函数的实现方法直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

参考讨论：

http://bbs.csdn.net/topics/380257801

http://baike.baidu.com/view/414773.htm

---

有1000个苹果，分别装在10个箱子里。任意给出1到1000之间的一个整数，都可以用某几个箱子中的苹果数量相加获得此数。请列出这10个箱子中分别有多少个苹果。
正确答案: B 你的答案: A (错误)

A. 1 2 4 8 16 32 64 128 256 512
B. 1 2 4 8 16 32 64 128 256 489
C. 3 5 7 15 31 63 127 255 494
D. 以上答案都不正确

1 1 1 1 1 1 1 1 1（二进制数）
00000001 000000010 000000011 000000100………………..111111111(511)
9个1 ，每个1 的位置表示1个数 第一个1 2^8=256 ……………………第九个1 就是1
相当于第一个盒子256 （100000000）
　　　 第二个盒子128（010000000）
…………………………………….
　　　 第九个盒子1（000000001）
这样得到的数为1——511
最后一个盒子放1000-511=（489）
得到512 -1000之间的数（暂时用x表示） 即在1—511 中找数x-489 均可找到
所以放在盒子中的苹果1 2 4 8 16 32 64 128 256 489 选B
选项A 和大于1000

---

一个不透明的箱子里共有红，黄，蓝，绿，白五种颜色的小球，每种颜色的小球大小相同，质量相等，数量充足。每个人从篮子里抽出两个小球，请问至少需要多少个人抽球，才能保证有两个人抽到的小球颜色相同？

答案：D
每个人要从敏感词中抽2个球，5种颜色的组合球的情况有：
两个球不同的情况：C5 2=5*4/2=10种情况
两球相同：5种情况
所以最坏的情况时，前15个人，抽的球都不同
则第16个肯定会抽的与前面的人有相同的

---

1,32,81,64,25,(),1

答案是6，因为1的6次方=1 2的5次方=32 3的4次方=81 4的3次方=64 5的2次方=25 6的1次方=6 7的0次方=1

---

关于Java和C/C++的比较，下列哪个描述是错误的？

Ａ. Java不支持指针，C/C++支持
B. Java程序不需要显式地关心内存释放，而C/C++需要
C. Java和C++一样，是纯编译型语言，因此它们的class都是在编译时静态联编(static binding)的
D. Java数组、字符串不可能溢出，C/C++数组、字符串则有可能溢出边界
正确答案: C D 你的答案: C (错误)

编译型语言和解释性语言：编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。
解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby。但是，随着Java等基于虚拟机的语言的兴起，我们又不能把语言纯粹地分成解释型和编译型这两种，用Java来举例，Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。
静态联编是指编译时多态，动态联编是指运行时多态，看网上多指C++。
java字符串可以拼接，这个溢出的限定不好判断，但是数组是一定可以溢出的。

---

求函数返回值，输入x=9999

int func(int x){
    int count=0;
    while (x)
    {
        count++;
        x=x&(x-1);//与运算
    }
    return count;
}

正确答案: A 你的答案: B (错误)

A. 8
B. 9
C. 10
D. 12

一个数与这个数减1的结果进行’&’按位与运算，结果为：这个数二进制数最右边的1变为0；
举例说明如下：
X=5；
5&（5-1） = 010 1 & （0100） = 010 0
经过上述计算，5的二进制最右边的1变为了0，由此可知，题目中count是用以统计x的二进制中1的个数的
9999的二进制表示为：10011100001111 共有8个1，显然，答案为A。

转载于:https://www.cnblogs.com/readlearn/p/10806474.html