笔试强训48天——day2

一. 单选

1. 使用printf函数打印一个double类型的数据，要求：输出为10进制，输出左对齐30个字符，4位精度。以下哪个选项是正确的？

A %-30.4e
B %4.30e
C %-30.4f
D %-4.30f
正确答案：C

double：%f
%m.nf:右对齐
%-m.nf:左对齐

 

2.请找出下面程序中有哪些错误（）

int main(){
int i = 10;
int j = 1;
const int *p1;//(1)
int const *p2 = &i; //(2)
p2 = &j;//(3)
int *const p3 = &i;//(4)
*p3 = 20;//(5)
*p2 = 30;//(6)
p3 = &j;//(7)
return 0;
}

A 1,2,3,4,5,6,7
B 1,3,5,6
C 6,7
D 3,5
正确答案：C

常量指针：指针所指空间的值是一个常量，指针所指空间的值不能发生改变，不能通过指针解引用修改指针所指空间的值，但是指针的指向可以发生改变
指针常量：指针本身是一个常量，指针的指向不能发生改变，但是指针所指的空间的值是可以发生改变的，可以通过指针的解引用改变指针所指空间的值。
区分：
根据const * 的相对位置：

const在*的左边：常量指针 const int *p1 int const p2 = &i;
const在的右边：指针常量 int *const p3 = &i;
*p2 = 30;//(6)不能通过指针解引用修改指针所指空间的值
p3 = &j;//(7)指针的指向不能发生改变

 

3.下面叙述错误的是（）

char acX[]="abc";
char acY[]={'a','b','c'};
char *szX="abc";
char *szY="abc";

A acX与acY的内容可以修改
B szX与szY指向同一个地址
C acX占用的内存空间比acY占用的大
D szX的内容修改后，szY的内容也会被更改

正确答案：D

初始化的方式不同，第一个多了一个\0

 

4.在头文件及上下文均正常的情况下，下列代码的运行结果是（）

int a[] = {1, 2, 3, 4};
int *b = a;//指针指向数组首元素
*b += 2;//*b是1 1 += 2；就是3
*(b + 2) = 2;//将数组第三个元素改为2
b++;//指针指向数组第二个元素
printf("%d,%d\n", *b, *(b + 2));//数组第二个元素，第四个元素

A 1,3
B 1,2
C 2,4
D 3,2
正确答案：C

 

5. 下列关于C/C++的宏定义，不正确的是（）

A 宏定义不检查参数正确性，会有安全隐患
B 宏定义的常量更容易理解，如果可以使用宏定义常量的话，要避免使用const常量
C 宏的嵌套定义过多会影响程序的可读性，而且很容易出错
D 相对于函数调用，宏定义可以提高程序的运行效率
正确答案：B

宏定义没有预处理检测，无法进行调试，要尽量使用const常量
对于函数调用来说，宏定义没有创建函数栈帧和函数压栈的开销，所以可以提高效率

 

6.正确的函数调用形式是（）

有以下定义：

int a[10];
char b[80];

函数声明为：

void sss(char[],int[]);

A sss(a,b);
B sss(char b[],int a[]);
C sss(b[],a[]);
D sss(b,a);

正确答案：D

要按函数声明顺序来

 

7. 用变量a给出下面的定义:一个有10个指针的数组,该指针指向一个函数,该函数有一个整形参数并返回一个整型数（）

A int *a[10];
B int (*a)[10];
C int (*a)(int);
D int (*a[10])(int);
正确答案：D

A 指针数组
B 数组指针
C 函数指针，有一个int参数，返回值类型也是int
D 数组 里存放了函数指针，函数指针数组，有一个int参数并返回int

 

8.以下 C++ 函数的功能是统计给定输入中每个大写字母的出现次数（不需要检查输入合法性，所有字母都为大写），则应在横线处填入的代码为（）

void AlphabetCounting(char a[], int n) {
int count[26] = {}, i, kind = 10;
for (i = 0; i < n; ++i)
_________________;
for (i = 0; i < 26; ++i) {
printf("%c=%d", _____, _____);
}
}

A ++count[a[i]-‘Z’];
‘Z’-i,count[‘Z’-i]
B ++count[‘A’-a[i]]
;‘A’+i,count[i]
C ++count[i]
;i, c
ount[i]
D ++count[‘Z’-a[i]]
;‘Z’-i
,count[i]
正确答案：D

ab减出来都是负的
c越界访问

 

9.在32位cpu上选择缺省对齐的情况下，有如下结构体定义：则sizeof（struct A）的值为（）

struct A{
unsigned a : 19;
unsigned b : 11;
unsigned c : 4;
unsigned d : 29;
char index;
};

A 9
B 12
C 16
D 20
正确答案：C

注意：一次只能放32个，够的继续放，超出要重新开空间，不同类型的不能放一起也需要重新开空间
4（32）：19+11
4（32）：4
4（32）：29
1（8）：index
总的：4+4+4+1=13
内存对齐之后：16（4的整数倍）

 

10.下面代码会输出()

int main(){
int a[4]={1,2,3,4};
int *ptr=(int*)(&a+1);
printf("%d",*(ptr-1));
} 

A 4
B 1
C 2
D 3
正确答案：A

&a代表的是整个数组的大小+1就是跳过整个数组，所以ptr指向的是数组最后一个元素的下一个位置

 

 

二. 编程

1. 排序子序列

做题链接
题目：

牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为n的整数数组A,他现在有一个任务是把数组A分为若干段排序子序列,牛牛想知道他最少可以把这个数
组分为几段排序子序列.
如样例所示,牛牛可以把数组A划分为[1,2,3]和[2,2,1]两个排序子序列,至少需要划分为2个排序子序列,所以输出2

输入描述：

输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)
第二行包括n个整数A_i(1 ≤ A_i ≤ 10^9),表示数组A的每个数字。
输出描述：
输出一个整数表示牛牛可以将A最少划分为多少段排序子序列

示例1:

输入
6 1
2 3 2 2 1
输出
2

正确答案：

#include<iostream>
#include<vector>
using namespace std;

int main()
{
    int n;
    cin>>n;
    vector<int> a;
    //多开一个空间，防止越界访问
    a.resize(n+1);
    a[n] = 0;
    
    //数组输入
    for(int i = 0;i<n;++i)
    {
        cin>>a[i];
}
    int i = 0;
    int count = 0;
    while(i<n)
    {
        if(a[i] < a[i+1])
        {
            while(i<n && a[i] <= a[i+1])
            {
                i++;
            }
            count++;
            i++;
        }
         else if(a[i] == a[i+1])
         {
             i++;

         }
            else{
                 while(i<n && a[i] >= a[i+1])
            {
                i++;
            }
            count++;
            i++;
            
}
}
    cout<<count<<endl;
    return 0;
}

 
 

2.倒置字符串
做题链接
题目：

将一句话的单词进行倒置，标点不倒置。比如 I like beijing. 经过函数后变为：beijing. like I

输入描述：

每个测试输入包含1个测试用例： I like beijing. 输入用例长度不超过100

输出描述：

依次输出倒置之后的字符串,以空格分割

示例1:

输入
I like beijing.
输出
beijing. like I

思路：

整体逆置
单词逆置

正确答案：

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int main()
{
    string s;
    getline(cin,s);

    reverse(s.begin(),s.end());

    auto start = s.begin();
  

    while(start != s.end())
    {
          auto end = start;
        while(end != s.end() && *end != ' '  )
        {
            end++;
        }
            reverse(start,end);
            if(end != s.end())
                start = end + 1;

            else
                start = end;
            
        
    }

cout<<s<<endl;
    
    return 0;
}

 

解题思路2：

第二思路是一个比较讨巧的思路，直接利用cin>>s接收输入，遇到空格就结束了，自然就分割开了每个单词，其次将每次接收到的单词拼接到之前串的前面就逆置过来了

#include <iostream>
#include <string>
using namespace std;
// cin读取string时自动会被空格分隔开，用另一个字符串存储进行逆序输出
int main()
{
string s1, s2;
cin >> s2;
while (cin >> s1)
s2 = s1 + " " + s2;
cout << s2 << endl;
return 0;
}