【C/C++笔试练习】CPU字长、linux、进程优先级、CPU利用率、中断请求、内核对象、权限掩码、编译过程、标签、多线程、求正数数组的最小不可组成和、有假币

C/C++笔试练习

选择部分

（1）CPU字长

  某台微机安装的是64位操作系统，“64位”指的是（）

  A.CPU的运算速度，即CPU每秒钟能计算64位二进制数据
  B.CPU的字长，即CPU每次能处理64位二进制数据
  C.CPU的时钟主频
  D.CPU的型号

  答案：B

  64位操作系统指的是 CPU的字长，也就是说每次可以处理64位二进制数据，内存地址是64位。 与之相对的是32位操作系统，也就是说每次可以处理32位二进制数据，内存地址是32位。

  

（2）linux

  对于Linux说法，下列说法正确的是（）

  A.线性访问内存非法时，当前线程会进入信号处理函数
  B.用mv命令移动文件时，文件的修改时间会发生变化
  C.ulimit -c 设置的是函数调用栈的大小
  D.malloc函数是操作系统最底层申请内存的接口

  答案：A

  A选项：当内存访问越界的时候，线程会收到信号，进而进行信号处理，调用信号处理函数

  B选项：
  Linux下文件的三个时间参数:

  （1）modification time(mtime)：内容修改时间这里的修改时间指的是文件的内容发生变化，而更新的时间

  （2）change time(ctime)：状态修改时间这里的修改时间指的是文件的属性或者权限发生变化，而更新的时间。

  （3）access time(atime)：最后访问时间这里的访问时间是指文件被读取，而更新的时间。

  我们会发现修改的是状态修改时间，并非是内容修改时间，

  C选项：ulimit -c是更改coredump文件大小钓命令，coredump文件也就是核心转储文件。

  D选项：malloc是库函数，操作系统申请内存的接口指的是系统调用，库函数中封装了系统调用库函数与系统调用是两个不同的概念。

  

（3）进程优先级

  以下哪个命令可以改变进程的优先级

  A. twice
  B. chnice
  C.nice
  D. renice

  答案：D

  A twice: linux当中没有这个命令。

  B chnice: linux当中没有这个命令。

  C nice: 设置进程优先级的谦让值(修正值)为N，niceness值为负时，表示高优先级，能提前执行和获得更多的资源，对应低友善度;反之，则表示低优先级，高友善度。

  D renice: renice指令可重新调整程序执行的优先权等级。

  

（4）CPU利用率

  单任务系统中两个程序A和B，其中
  A程序：CPU:10s -> 设备1:5s -> CPU:5s -> 设备2:10s -> CPU:10s；
  B程序：设备1:10s-> CPU:10s -> 设备2:5s -> CPU:5s -> 设备2:10s；
  执行顺序为A->B，那么CPU的利用率是（）

  A.30%
  B. 40%
  C.50%
  D.60%

  答案：C

  单任务系统告诉我们A程序和程序不能并行执行，只能并发执行。

  A程序，CPU时间为10+5+10=25s，程序运行总时间为10+5+5+10+10=40s。

  B程序，CPU时间为10+5=15s，程序运行总时间为10+10+5+5+10=40s;CPU总时间为40s，两个进程的总时间为80s，CPU的利用为40/80=0.5。

  

（5）中断请求

  下述哪种情况会提出中断请求（）

  A.在键盘输入过程中，每按一次键
  B.两数相加结果为零
  C.计算结果溢出
  D.一条系统汇编指令执行完成

  答案：A

  程序中断：是指计算机执行现行程序的过程中，出现某些急需处理的异常情况和特殊请求，cpu暂时终止现行程序，而转去对随机发生的更紧迫的事件进行处理，在处理完毕后，cpu将自动返回原来的程序继续执行。

  A 选项: 当我们键盘输入的时候，进程需要中断进行10读取，所以会导致程序中断运行，转而进行IO，比较典型的就是scanf。

  B 选项: 两个数相加结果为0，这个是正常的程序运行时可能产生的结果，并不会导致程序中断运行。

  C 选项:计算结果溢出就会截断，并不会导致程序中断运行。

  D 选项:汇编指令的完成也是程序在运行的体现，并不会导致程序中断运行。

  

（6）内核对象

  以下哪些不是内核对象（）

  A.进程
  B.线程
  C.互斥器
  D.临界区

  答案：D

  A选项: 进程在内核当中是一个进程控制块，task_struct结构体。

  B选项: 线程在内核当中也是一个进程控制块在描述。

  C选项: 互斥器(mutex)也是在内核创建出来，保护多线程程序运行时不会产生二义性结果。

  D选项: 临界区指的是多个执行流都能访问到的临界资源对应的代码区域，程序员定义。

  

（7）权限掩码

  在Linux中，如果系统的umask设置为244，创建一个新文件它的权限是（）

  A.–w-r–r-
  B.-r-xr–r-
  C.-r—w–w-
  D.-r-x-wx-wx

  答案：C

  umask：

  功能说明:指定在建立文件时预设的权限掩码

  语法:umask[-S][权限掩码]

  补充说明:umask可用来设定[权限掩码]。[权限掩码]是由3个八进制的数字所组成，将现有的存取权限减掉权限掩码后，即可产生建立文件时预设的权限。

  创建时，文件 默认666，目录默认777

  所以，对于新建文件 权限 666-244得到422

  linux系统中权限rwx对应数值为422，故文件权限为r- - -w- -w- -

  

（8）编译过程

  由源代码生成可执行文件需要经过预编译，编译，汇编，链接等阶段，错误：unresolved external symbol BeginScene属于()阶段错误。

  A.预编译
  B.编译
  C.汇编
  D.链接

  答案：D

  无法解析的外部符号BeginScene，i说明单个文件已经编译通过，在链接时，查找外部符号没有找到，无法解析，所以是发生在链接阶段。

  

（9）标签

  程序出错在什么阶段（）?

int main(void) 
{
   http://www.taobao.com 
    cout << "welcome to taobao" << endl; 
    return 0; 
} 

  A.预处理阶段出错
  B.编译阶段出错
  C.汇编阶段出错
  D.链接阶段出错
  E.运行阶段出错
  F.程序运行正常
  答案：F

  双斜杠之后的www.taobao.com被当做注释了，那么前面的http:是否合法?

  这就是C++中一个几乎不会被用到的语法，标签。

  带标签的语句是一种特殊的语句，在语句前面有一个标识符(即标签，上段代码中的http)和一个冒号。 使用goto label就可以跳到标签处执行，比如可以在代码中写goto http，这样就会执行cout语句了。

  

（10）多线程

  有一个变量int a=0；两个线程同时进行+1操作，每个线程加100次，不加锁，最后a的值是（）？
  A.200
  B.<=200
  C.>=200
  D.都有可能
  答案：B

  （1）如果两个线程并发的执行，线程A执行完毕，线程B执行，则最终的值为200。

  （2）如果两个线程并行的执行，有可能就会导致程序结果的二义性，则最终的结果值有可能是小于200。

            

编程题 day29

求正数数组的最小不可组成和

求正数数组的最小不可组成和

  解题思路：根据承重和已有的重量种类阶段性计算当前承重时能够放入的重量
当数组中只有2重量的时候，背包承重从2-10都可以放入2的数值 当数组中放入2和3重量的时候，背包承重从5-10可以放入5，3-4放入3，2只能放入2 当数组中放入2，3，5重量时，背包承重10放入10，8-9放入8，7放入7，5-6放入5…
  w 2 3 4 5 6 7 8 9 10
   2 2 2 2 2 2 2 2 2 2 3 2 3 3 5 5 5 5 5 5 5 2 3 3 5 5 7 8 8 10
  最终当每个承重与放入的重量不同时，这个承重就是最小不可求和—4。

#include <iostream>
#include <vector>

class Solution {
  public:
    int getFirstUnFormedNum(std::vector<int>& arr, int length) 
    {
        int sum = 0, min = arr[0];
        int i, j;
        for (int i = 0; i < length; i++) 
        {
            sum += arr[i];
            min = arr[i] < min ? arr[i] : min;
        }
        std::vector<int> dp(sum + 1, 0);
        for (i = 0; i < length; i++) 
        { 
        	//有length个数据--有length个阶段
			//{2， 3， 5}
			//i=0--d[10]=2 d[9]=2 d[8]=2 d[7]=2...d[2]=2
			//i=1--d[10]=5 d[9]=5...d[5]=5 d[4]=3 d[3]=3
			//i=2--d[10]=10 d[9]=8 d[8]=8 d[7]=7 d[6]=5 d[5]=5
            for (j = sum; j >= arr[i]; j--) 
            {
				//逆序判断背包承重中能够放入的数据
				//当数组中只有2的时候，背包承重从2-10都可以放入2的数值
				//当数组中放入2和3的时候，背包承重从5-10可以放入5，3-4放入3，2只能放入2
				//当数组中放入2，3，5时，背包承重10放入10，8-9放入8，7放入7，5-6放入5...
				//dp[j-arr[i]]意思是背包承重为j时，如果已经放置了arr[i]的重量后还能放置的最大重量
                if (dp[j] < dp[j - arr[i]] +
                        arr[i])//对每个承重计算当前最大能放置重量
                    dp[j] = dp[j - arr[i]] + arr[i]; //更新背包中能够放入的最大值
                else
                    dp [j] = dp[j];
            }
        }
		//最后当承重为n时，放入的重量不为n则认为是最大不可求和
        for (i = min; i <= sum; i++) 
        {
            if (i != dp[i])
                return i;
        }
        return sum + 1;
    }
};

  

有假币

有假币

  解题思路：平均分三份是最快的方法，两份进行称重（对比出三个的重量 ），后对最重的那份再次进行称重，直到称重。的个数不足2个时则结束，获得假币 如果无法平均分3分则余数要么是1要么是2，因为是要最多称几次，n=n/3+1满足每次取最大 分称3份，取两份一样多的过秤，然后把三份中最多的那份继续分，直到硬币剩余0或1时截至。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main() 
{
    long long n;
    int cnt;
    while ((scanf("%lld", &n)) != EOF) 
    {
        if (n == 0)
            break;
        cnt = 0;
        while (n >= 2) 
        {
            if (n % 3) 
            {
                //不可以整除则取最差情况：最重的一份是 n/3 + 1个金币
                n=n/3+1;
            } 
            else 
            {
                //可以整除在直接整除，能够获取到最重的一份
                n /= 3;
            }
            cnt++;
        }
        printf("%d\n", cnt);
    }
    return 0;
}