【C++】笔试训练（三）

一、选择题

1、以下程序的输出结果是（）

#include 
int main()
{
    char a[10] = { '1', '2', '3', '4', '5', '6', '7', '8', '9', 0 }, * p;
    int i;
    i = 8;
    p = a + i;
    printf("%s\n", p - 3);
}

A 6
B 6789
C ‘6’
D 789

答案：B

2、以下程序的输出结果是（）

#include 
int main()
{
    int x = 3, y = 3;
    switch (x % 2)
    {
        case 1:
        switch (y)
        {
        case 0:
            cout << "first";
        case 1:
            cout << "second";
            break;
        default:
            cout << "hello";
        }
    case 2:
        cout << "third";
    }
    return 0;
}

A second third
B hello
C first second
D hellothird

答案：D

3、以下能对二维数组a进行正确初始化的语句是（）
A int ta[2][]={{0,1,2},{3,4,5}};
B int ta[][3]={{0,1,2},{3,4,5}};
C int ta[2][4]={{0,1,2},{3,4},{5}};
D int ta[][3]={{0,2},{},{3,4,5}};

答案：B
解析：二维数组的行可以省略，列不可以省略

4、能把函数处理结果的二个数据返回给主调函数，在下面的方法中不正确的是（）
A return这二个数
B 形参用数组
C 形参用二个指针
D 用二个全局变量

答案：A
解析：return每次只能返回一个数据，但是放到数组或一个容器里面，可以return多个数据。全局变量作用域在整个文件都是有效的。

5、int * p[4] 与选择项中的（） 等价
A. int p[4]
B. int *p
C. int *(p[4])
D. int (*p)[4]

答案：C
解析：A是int类型数组，数组大小为4。B是int类型的指针。C是int类型的指针数组，数组大小为4，与题目等价。D是一个数组指针，数组大小为4，并且是int类型

6、设变量已正确定义，以下不能统计出一行中输入字符个数（不包含回车符）的程序段是
A. n=0;while(ch=getchar()!=‘\n’)
B. n=0;while(getchar()!=‘\n’)n++;
C. for(n=0;getchar()!=‘\n’;n++);
D. n=0;for(ch=getchar();ch!=‘\n’;n++);

答案：D
解析：for循环初始化部分只会执行一次，所以D选项只会获取一个字符。

7、以下代码，代码执行之后ptr指向的内容是？

char* ptr;
char myString[] = "abcdefg";
ptr = myString;
ptr += 5;

A Compiler error
B fg
C efg
D defg

答案：B

8、下面3段程序代码的效果一样吗（）

int b;
(1)const int *a = &b;
(2)int const *a = &b;
(3)int *const a = &b;

A (2)=(3)
B (1)=(3)
C (1)=(2)
D 都不一样

答案：C
解析：常量指针：所指空间的值是一个常量，能改变指针的指向。
指针常量：不能改变指针的指向，但是可以指针解引用改变所指空间的值
区分：const在 * 左边就是常量指针，在 * 右边就是指针常量

9、32位系统中，定义**a[3][4],则变量占用内存空间为()。
A 4
B 48
C 192
D 12

答案：B
解析：是一个三行四列的数组，指针类型，共有12个元素，所占空间大小为 12 * 4=48

10、假设在一个 32 位 little endian 的机器上运行下面的程序，结果是多少？

#include 
int main() 
{
    long long a = 1, b = 2, c = 3;
    printf("%d %d %d\n", a, b, c);
    return 0;
}

A 1,2,3
B 1,0,2
C 1,3,2
D 3,2,1

答案：B
解析：大端：低位存高地址
小端：低位存低地址
例如：int i = 1;
大端：00 00 00 01
小端：01 00 00 00
左边是低地址，右边是高地址
a：01 00 00 00 00 00 00 00
b：02 00 00 00 00 00 00 00
c：03 00 00 00 00 00 00 00

二、编程题

1、字符串中找出连续最长的数字串

入口：题目链接

题目描述：

解题思路：
遍历字符串，使用cur去记录连续的数字串，如果遇到不是数字字符，则表示一个连续的数字串结束了，则将
数字串跟之前的数字串比较，如果更长，则更新更长的数字串更新到ret。

代码展示：

#include 
#include 
using namespace std;
int main()
{
    string cur;
    string ret;
    string str;
    cin >> str;
    for (int i = 0; i <= str.length(); i++)
    {
        // 数字+=到cur
        if (str[i] >= '0' && str[i] <= '9')
        {
            cur += str[i];
        }
        else
        {
            // 找出更长的字符串，则更新字符串
            if (ret.size() < cur.size())
            {
                ret = cur;
            }
            else
            {
                cur.clear();
            }
        }
    }
    cout << ret << endl;
    return 0;
}

2、数组中出现次数超过一半的数字

入口：题目链接

题目描述：

解题思路1：
思路一：数组排序后，如果符合条件的数存在，则一定是数组中间那个数。这种方法虽然容易理解，但由于
涉及到快排sort，其时间复杂度为O(NlogN)并非最优；

代码展示：

int MoreThanHalfNum_Solution(vector<int>& numbers) {
    if (numbers.empty())
        return 0;
    sort(numbers.begin(), numbers.end());
    int mid = numbers[numbers.size() / 2];
    int count = 0;
    for (int i = 0; i < numbers.size(); i++)
    {
        if (numbers[i] == mid)
            count++;
    }
    if (count >= (numbers.size() / 2))
        return mid;
    return 0;
}

解题思路2：
众数：就是出现次数超过数组长度一半的那个数字
如果两个数不相等，就消去这两个数，最坏情况下，每次消去一个众数和一个非众数，那么如果存在众数，
最后留下的数肯定是众数。

代码展示：

int MoreThanHalfNum_Solution(vector<int>& numbers) {
    if (numbers.empty())
        return 0;
    int sul = numbers[0];
    int times = 1;
    for (int i = 1; i < numbers.size(); i++)
    {
        if (times != 0)
        {
            if (numbers[i] == sul)
            {
                times++;
            }
            else
            {
                times--;
            }
        }
        else
        {
            sul = numbers[i];
            times = 1;
        }
    }
    times = 0;
    for (int i = 0; i < numbers.size(); i++)
    {
        if (numbers[i] == sul)
        {
            times++;
        }
    }
    if (times > numbers.size() / 2)
        return sul;
    return 0;
}