【C++笔试强训】第三天_char *ptr;char mystring[] = "abcdefg";ptr = mystri

选择题

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

#include <stdio.h>
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);
}
1
2
3
4
5
6
7
8

A 6
B 6789
C ‘6’
D 789

a是数组名，所以指向数组首元素；p=a+8：a向右偏移8个字节，指向‘9’。p - 3也就是向左偏移3个字节，对于%s打印：遇到\0停止打印，打印出6789

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

#include <iostream.h>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

A second third
B hello
C first second
D hellothird

看到case我们就需要注意break是否存在了，x%2 = 1，进入case1；y=3，进入default语句；把hello打印出来
default后没有break语句跳出循环，所以还是要执行case2，再打印出third，最后打印出来的是hellothird

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}};
1
2
3
4

二维数组初始化行可以省略，列不能省略，A中没有初始化列；C中多初始化了一行;D初始化必须是连续的，不能间隔

4.能把函数处理结果的二个数据返回给主调函数，在下面的方法中不正确的是（）

A return这二个数
B 形参用数组
C 形参用二个指针
D 用二个全局变量

return只能返回一个值，不能返回两个，选A

5.int *p[4] 与选择项中的（） 等价

A int p[4]
B int *p
C int *(p[4])
D int (*p)[4]

int *p[4] : p先和[]结合，是一个数组，存放4个int *类型的指针，所以是指针数组
A是整型数组 ；B是i指针；C是答案；D中p先和* 结合，指向一个大小为4的数组 ，是数组指针

6.设变量已正确定义，以下不能统计出一行中输入字符个数（不包含回车符）的程序段是（）

A n=0;while(ch=getchar()!=‘\n’)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中的ch=getchar（）只执行一次，不能获得每个字符。答案选D

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

char *ptr;
char myString[] = "abcdefg";
ptr = myString;
ptr += 5;
1
2
3
4

A Compiler error
B fg
C efg
D defg

题目解析：

ptr指向字符a，ptr是char类型，ptr+=5，所以向右偏移5个字节，指向的是fptr是字符指针，输出的是字符串，直到\0结尾，选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 都不一样

此类题型，还是常量指针和指针常量的问题：
（1）是常量指针，（2）也是常量指针；（3）是指针常量，主要区别在于const和*的位置，很明显，答案选C

9.32位系统中，定义**a[3][4],则变量占用内存空间为()

A 4
B 48
C 192
D 12

a先和[]结合，所以a实际上是一个三行四列的数组，存放的是**的指针类型，又是32位系统中，所以大小为4*12=48

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

#include <stdio.h>
int main(){
	long long a = 1, b = 2, c = 3;
	printf("%d %d %d\n", a, b, c);
	return 0;
}
1
2
3
4
5
6

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

大小端问题：对于大端：低位存放在高地址处，对于小端：低位存放在低地址出（简单理解为低低低）

选B

编程题

[字符串中找出连续最长的数字串](字符串中找出连续最长的数字串_牛客题霸_牛客网 (nowcoder.com))

我们可以定义两个字符串，cur存放遍历所遇到的数字字符串，ret保存结果。如果cur的size比ret的大就把结果交给ret，cur清除，，最终ret存放的就是最长的数字串。

#include <iostream>
#include <string>
using namespace std;
int main()
{
    string str;
    string ret;
    string cur;
    int count = 0;
    getline(cin,str);
    for(auto e : str)                
    {
        if(isdigit(e))
        {
            cur+=e;
        }
        else
        {
            cur.clear();
        }
        if(cur.size()>ret.size())
        {
            ret = cur;
        }
    }
    cout<<ret<<endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

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

普通的思路：排完序之后直接找中间位置。有人可能直接就认为中间位置就是所求结果了（好像测试用例也可以这样子直接通过），但是实际上不是的，因为中间的次数不一定超过数组长度的一半，所以我们还需要去统计一下出现次数是不是符合题意要求

class Solution {
public:
    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(auto e:numbers)
        {
            if(e==mid)
            {
                count++;
            }
        }
        if(count > numbers.size() / 2)
        {
            return mid;
        }
        else
        {
            return 0;
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

对于这种方法我们都是能想到的。此外，对于这道题目，还有另一种做法：

两数相消：

在有众数的情况下，遍历整个数组，如果两个数不相等，我们就消去这两个数，如果是在最坏的情况下，我们会每次消去一个众数和一个非众数，如果存在众数的话，最后留下的数肯定是众数

具体过程：result 和times 分别存放当前数与设定出现次数，times初始化为1。当后面的一个数与前一个数相同时，times++,否则就times–.当times为0时，result就重新更新为当前的nums[i],最后重新遍历一遍数组，判断是否为众数即可。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if(numbers.empty()) return 0;
        int result = numbers[0];
        int times = 1;
        //从第二个位置开始，也就是下标为1
        for(size_t i = 1;i<numbers.size();i++)
        {
            if(times!=0)
            {
                 if(numbers[i] != result)
                {
                    times--;
                }
                else
                {
                    times++;
                }
            }
            else
            {
                result = numbers[i];
                times = 1;
            }
        }
        //统计次数
        int count = 0;
        for(auto e:numbers)
        {
            if(result == e)
            {
                count++;
            }
        }
        if(count > numbers.size() / 2)
        {
            return result;
        }
        return 0;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42