一个字长为8位的整数的补码是1100 1001,则它的原码是( )。

A. 1100 1001

B. 1011 0110

C. 1011 0101

D. 1011 0111

原码 ：最高位是符号位，0是正数，1是负数，其他位位为该数字的二进制。

补码：正数的补码与原码一致，负数的补码是对原码按位取反加1，符号位不变。

反码：正数的反码与原码一致，负数的反码除符号位不变外，其余各个位数取反。

基于比较的排序时间复杂度的下限是(B) ，其中n表示待排序的元素个数。

A.O(n)

B.O(nlogn)

C.O(logn)

D.O(n​2​)(n​^2​)

计算机中的数值信息分为整数和实数（浮点数），实数之所以能够表示很大或者很小的数，是由于使用了（C）。

A. 反码

B. 补码

C. 阶码

D. 较长的尾数

#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int cnt[26];
char s[N];
int main(){
	scanf("%s",s);
	int len = strlen(s);
	for (int i=0;i<len;i++){
		cnt[s[i]-'a']++;
	}
	int maxcnt=0,ans=0;
	for (int i=0;i<26;i++){
		if (cnt[i]>maxcnt) {
			maxcnt=cnt[i];
			ans=i;
		}
	}
	printf("%c\n%d\n",ans+'a',maxcnt);
	return 0;
}

判断题

输入只能是小写字母。(正确)

如果输入的不为小写字符的话，则s[i]-'a'会超出0-25的范围。

将第11行的maxcnt = 0改为maxcnt = cnt[0]代码运行结果不变。(正确)

maxcnt是统计cnt数组中的最大值，初始时默认cnt[0]不会影响后面统计的结果。

将第12行中i=0改为i=1不会改变代码运行结果。(错误)

i如果等于1的话，那么cnt[0]有可能是最大值。

将第13行cnt[i]>maxcnt改为cnt[i]>=maxcnt不会改变程序结果。(错误)

如果变成<=那么就会输出最后一个出现在数组中出现最多的字符。

选择题

当输入是abcabd时，输出为(A)。

A.a 2

B. b 2

C. c 2

D.d 1

程序是输出在一个数组内，出现次数最多的字符。

将第13行cnt[i]>maxcnt改为cnt[i]>=maxcnt，当输入是”abcabd”时，输出为(B)。

A.a 2

B.b 2

C.c 2

D.d 1

#include <iostream>
using namespace std;
int main() {
	int n,x;
	scanf("%d",&n);
	int a[10];
	for (int i=0;i<10;i++){
		a[i]=n;
	}
	bool ok=true;
	for(x=1;ok;x++) {
		int y=x;
		while(y>0){
			if (--a[y%10]<0){
				cout<<x-1<<endl;
				ok=false;
			}
			y/=10;
		}
	}
	return 0;
}

判断题

将第7行改为memset(a, n, sizeof(a)); 程序运行结果不变。(错误)

memset是按字节初始化，通常只对数组元素全部初始为0或者-1时才使用。

将第12行的ok=false改为break程序可能会进入死循环。(正确)

如果不把ok变成false，那么for循环就会一直运行导致死循环。

程序可能会输出多行。(正确)

程序在while循环内可能会多次满足if条件，所以有可能会输出多行。

将第12行--a[y%10] < 0改为a[y%10]-- < 0程序运行结果不变。(错误)

前置--会先进行自减操作，在判断。

选择题

程序输入3时，输出(C)。

A. 2

B. 3

C. 10

D. 11

程序输入20是，输出（B）。

A. 20

B. 99

C. 100

D. 101

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int a[N][N], b[N][N];
int n,m,ans,trans;
int x[9]={0,0,0,-1,-1,-1,-2,-2,-3};
int y[9]={-1,-2,-3,0,-1,-2,0,-1,0};
int main() {
	cin>>n>>m;
	for(int i=1;i<=n;++i){
		for(int j=1;j<=m;++j){
			cin>>a[i][j];	
		}	
	}
	b[1][1]=a[1][1];
	for(int i=1;i<=n;++i){
		for(int j=1;j<=m;++j){
			int trans=INT_MIN;
			for(int t=0;t<9;++t){
				if(i+x[t]>0&&j+y[t]>0){
					trans=max(trans,b[i+x[t]][j+y[t]]);
				}
				if (trans!=INT_MIN){
					b[i][j]=trans+a[i][j];	
				}
			}
		}		
	}
	cout<<b[n][m]<<endl;
	return 0;
}

判断题

上述代码实现了在一个n*m的数字矩形中从(1,1)到(n,m)中选择一条路径，使得其路径上方格中数字和加起来最大，每个方格选择下一个方格只能向左或者向下走一格。(错误)

代码实现是在一个n*m的数字矩形中从(1,1)到(n,m)中选择一条路径，使得其路径上方格中数字和加起来最大，每个方格选择下一个方格有9种选择。

上述代码如果删除第4行的b数组定义，并将下面的b数组全部改成a数组，运行结果不变。(正确)

第20行去掉if(trans != INT_MIN)程序运行结果不变。(错误)

如果没有if判断，那么b[1][1]就会直接被赋值成INT_MIN+a[1][1]。

选择题

上述代码的时间复杂度为(B)。

A. O(n+m)

B. O(n*m)

C. O(min(n, m))

D. O(max(n, m))

代码使用了哪种算法思想(B)。

A. 贪心

B. 动态规划

C. 分治

D. 深度优先搜索

如果输入是

3 4

-4 -5 -10 -3

7 5 -9 3

10 -2 6 -10

输出为(C)。

A. 7

B. 8

C. 9

D. 10

#include <bits/stdc++.h>
using namespace std;
const int N=100010;
int n;
int instk[N],outstk[N],intop,outtop;
int stk[N],top;
int main(){
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&instk[i]);
	}
	for(int i=0;i<n;i++){
		scanf("%d",&outstk[i]);
	}
	intop=0;
	①;//初始化stk的栈顶指针
	bool ok=true;
	for (int i=0;i<n;i++) {
		int x=outstk[i];
		if(top>=0&&stk[top]==x){
			②;//弹出元素
		}else{
			while(③){//证明x不在中间栈里
				stk[top++]=instk[intop++];
			}
			if (④){
				ok=false;
				break;
			}else{
				⑤;
			}
		}
	}
	if(ok){
		puts("Yes");
	}else{
		puts("No");
	}
	return 0;
}

①处应填 (B)

A. top=0

B. top=-1

C. outtop=0

D. outtop=-1

②处应填 (C)

A. outstk[outtop++] = x

B. instk[intop++] = x

C. top--

D. intop--

③处应填 (C)

A. instk[intop] != x

B. instk[intop] == x

C. intop < n && instk[intop] != x

D. instk[intop] != x && intop < n

④处应填 (D)

A. top>n

B. top>=n

C. intop>n

D. intop>=n

⑤处应填 (A)

A. intop++

B. outop++

C. top++

D. top--

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n;
using ll=long long;
int main() {
	ll ans=0,n1,n2;
	int a[10],vis[10];
	for (int i=1;i<10;i++){
		1;
	}
	do {
		for (int j=1;2;j++){
			ll num1=0,num2=0;
			for (int k=1;k<=j;k++){
				num1=num1%10+a[k];
			}
			for (int k=j+1;k<=9;k++){
				num2=num2%10+a[k];
			}
			ll num3=num1%num2;
			int tmp=num3,cnt=0;
			bool ok=true;
			memset(vis,0,sizeof vis);
			while(num3>0){
				int t=num3%10;
				if(3){
					ok = false;
				}
				num3/=10;
				cnt++;
			}
			if(4){
				ans=tmp;
				n1=num1,n2=num2;
			}
		}
	}while(5);
	cout<<n1<<" "<<n2<<"="<<ans<<endl;
	return 0;
}

①处应填 (C)

A.a[i]=0

B.vis[i]=0

C.a[i]=i

D.vis[i]=i

②处应填 (B)

A.j<10

B.j<9

C.j<=10

D.a[j]>0

③处应填 (D)

A. vis[t]>1

B. ++vis[t]>1

C. t==0&&++vis[t]>1

D. t==0||++vis[t]>1

④处应填 (D)

A. cnt==9

B. cnt==9&&ok

C.cnt==9&&ok&&num3>ans

D. cnt==9&&ok&&tmp>ans

⑤处应填 (A)

A. next_permutation(a+1, a+10)

B. next_permutation(a, a+10)

C. next_permutation(a, a+9)

D. next_permuttion(a+1, a+9)

如果根结点的深度记为1，则一棵恰有2011个叶结点的二叉树的深度最少是（C）。

A．10

B．11

C．12

D．13

根节点深度为 0，一棵深度为 h 的满 k（k>1）叉树，即除最后一层无任何子节点外，每一层上的所有结点都有 k 个子结点的树，共有（A）个结点。

A. (k(h+1)-1)/(k-1)

B. K(h-1)

C. kh

D.(k(h-1))/(k-1)

假设k=2，h=2的话，(2(3+1)-1)/(2-1)=7。

在使用高级语言编写程序时，一般提到的“空间复杂度”中的“空间”是指（A）。

A．程序运行时理论上所占的内存空间

B．程序运行时理论上所占的数组空间

C．程序运行时理论上所占的硬盘空间

D．程序源文件理论上所占的硬盘空间

在程序运行过程中，如果递归调用的层数过多，会因为（A）引发错误。

A. 系统分配的栈空间溢出

B. 系统分配的堆空间溢出

C. 系统分配的队列空间溢出

D. 系统分配的链表空间溢出

双向链表中有两个指针域llink和rlink，分别指向该结点的前驱及后继。设p指向链表中的一个结点，它的左右结点均非空。现要求删除结点p，则下面语句序列中错误的是（ ）。

要让llink和rlink直接建立起联系，等于删除节点p，llink等于p的左边的节点，rlink等于p的右边的节点。

设简单无向图 G 有 16 条边且每个顶点的度数都是 2，则图 G 有（D）个顶 点。

A. 10

B. 12

C. 8

D. 16

  1. Language
  2. 兼容模式
  3. 主题
  3. Worker 0, 12ms
  4. Powered by Hydro v5.0.0-beta.13 Community