2022-09-02-oppo-笔试-78min-90左右

linux 岗

单选多选25min

24
1

单选 17*2‘

selinux (？)
A. 可以用 setenforce 命令关闭
B. 在oppo手机上是关闭的
C. 的规则在编译阶段检验，在运行时不做额外校验，因此对于网上下载的文件、手机中预装的任何程序包括系统服务，都可对其访问
D. 将文件权限设为777后，selinux 对其的限制将会失效

关闭方法：1、临时关闭，只需执行“setenforce 0”命令即可。2、永久关闭，需要执行“vi /etc/selinux/config”命令打开config文件，将“SELINUX”项的值改为“disabled”，保存文件并退出即可。

关于linux文件描述符不对的是（）
A. 是一种资源，在程序异常退出时不会被释放
B. 一般用整形变量表示
C. 某进程中不同文件描述符可以对应同一个文件
D. 0是一个特殊的文件描述符

android 广播
A. 接收者声明的优先级别在android：priority属性中声明，值越小优先级别越高
B. 只能在AndroidManifest.xml 中注册
C. 只能在代码中注册
D. 有序广播按优先级传播，可以随时被截断

图片说明

android 4大组件不包括：
content provider; context; broadcast receive; service

活动(Activity)、服务(Service)、广播接收器(Broadcast Receiver)和内容提供器(Content Provider)
B

which wrong
A. Cache 与主存统一编址，cache地址空间属于主存一部分
B. 在所有非抢占CPU调度算法中系统平均响应时间最短的是短任务优先算法
C. 耗时的操作使用线程提供程序响应
D. 内存抖动指频繁换页活动

A. 不是统一编址
which wrong D?
A. Binder 传输数据的数据大小太大的话可能导致通信失败
B. Binder 可以用来传输文件描述符，从而在不同进程中用同一个文件
C. Binder 可以单向通信，对端进程可以不用发送回复信息
D. Binder 是Android 提出的一个新型进程间通信机制，仅依靠userspace即可完成进程间通信
关于C语言头文件的说法不对的是
A. 可以include后缀不是".h"的头文件
B. 可以通过宏定义来避免被重复include
C. 可以在头文件中定义一个static变量，在多个C文件***享数据
D. 可以在头文件中实现static类型的函数

多选 3*2’

数字通信系统的特点
传输差错可控、抗干扰能力强、较大传输带宽、同步要求高

正确的是 BC
A. 如果只有一个线程写，其他线程读，不会出现线程不安全
B. 如果所有线程都读一个共享变量，不会出现线程不安全问题
C. 出现线程安全问题根本原因是线程抢占式执行
D. 两个线程修改同一个变量就会出现线程不安全问题

3个编程60‘

第一题前后做了36min差点放弃

/**
//      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//      *
//      * 输入参数是每个应用持有WakeLock的起始时间及结束时间，函数返回值是每个应用对总WakeLock时长的贡献值，
//        返回值vector里面的每个元素的数值累加即为手机总的持有WakeLock的时长。
//      * @param wakeLock int整型vector<vector<>> vector<vector<int>>的每个元素代表某个应用的持有WakeLock的信息，
//        内部的vector<int>，元素按照奇偶排列，偶数元素代表拿WakeLock的起始时间点，奇数代表释放WakeLock的时间点
//      * @return int整型vector
//      */

输入：[[1234,1235],[1236,1238]]
输出：[1,2]
解释：第一个应用的时间片长度是1，无重叠，第二个是2

输入 [[1234,1240],[[1236,1238],[1245,1250]]
输出 [5,6]
解释：1236到1238两个应用共享长为2的时间片，各分1个单位，第一个应用是 2+1+2，第二个应用是1+5=6

// 第一种 差分+前缀和 80%
// 26min 一遍80%*15' 3ms 428KB
// class Solution {
// public:
//     vector<int> getWakeLockContrib(vector<vector<int> >& wl) {
//         int n=wl.size();
//         if(n==0) return {};
//         int minv=wl[0][0],maxv=wl[0][0];
//         for(auto& i:wl)
//             for(auto&j :i)
//             {
//                 minv=min(minv,j);
//                 maxv=max(maxv,j);
//             }
//         vector<int> d(maxv-minv+1,0);
// //         for(int i=0;i<n;i++)
// //             wl[i].push_back(i);
// //         sort(wl.begin(),wl.end());
//         for(int i=0;i<n;i++){
//             for(int j=0;j<wl[i].size();j+=2){
//                 d[wl[i][j]-minv]++;
//                 d[wl[i][j+1]-minv]--;
//             }
//         }
//         vector<double> pd(d.size()+1,0);
//         for(int i=1;i<pd.size();i++)
//             pd[i]=pd[i-1]+d[i-1];
//         vector<int> a(n,0);
//         vector<double> af(n,0);
//         for(int i=0;i<n;i++){
//             for(int j=0;j<wl[i].size();j+=2){
//                 int fr=wl[i][j]-minv;
//                 while(fr<wl[i][j+1]-minv){
//                     fr++;
//                     af[i]+=1.0/pd[fr];
//                 }
//             }
//         }
//         for(int i=0;i<af.size();i++)
//             a[i]=af[i];
//         return a;
//     }
// };


//  第一题第二种 10min 100%*15' 3ms 576KB
// 本来还是按 1.0/c[s] 来算，还是80%，浮点数太精确了

class Solution {
public:
    vector<int> getWakeLockContrib(vector<vector<int> >& wl) {
        int n=wl.size();
        if(n==0) return {};
        unordered_map<int, int> c;
        for(int i=0;i<n;i++){
            for(int j=0;j<wl[i].size();j+=2){
                int s=wl[i][j];
                while(s<wl[i][j+1])
                    c[s++]++;
            }
        }
        vector<int> a(n,0);
        for(int i=0;i<n;i++){
            int d=0.0;
            for(int j=0;j<wl[i].size();j+=2){
                int s=wl[i][j];
                while(s<wl[i][j+1])
                {
                    int t=s+1, cnt=c[s];
                    while(t<wl[i][j+1]&&cnt==c[t])
                        t++;
                    d+=(t-s)/cnt;
                    s=t;
                }
            }
            a[i]=d;
        }
        return a;
    }
};

// 第二题 100%*20’ 9min 反反+暴力 一次过
// 字符串反向查找
// * 表示匹配任意字符
// 找最后一次匹配的起始位置

// 输入：“hello world" "ow"
// 输出：7

// 输入：“hello world" "l*o"
// 输出：9

// 输入：“hello world" "l**"
// 输出：2

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * findStr从反方向查找子串，返回最后一次匹配成功时，子串的偏移位置，如果没有匹配成功返回-1
     * @param str string字符串 待匹配的字符串
     * @param mod string字符串 匹配模式字符串
     * @return int整型
     */
    int findStr(string str, string mod) {
        reverse(mod.begin(),mod.end());
        for(int i=0;i<=str.length()-mod.length();i++){
            int b=0,j=i;
            while(b<mod.length()){
                if(mod[b]=='*'||mod[b]==str[j]){
                    b++,j++;
                }else break;
            }
            if(b==mod.length())
                return j-1;
        }
        return -1;
    }
};

// 第三题 25'*100% 8min 一遍过
// 反转链表

/**
 * struct ListNode {
 *    int val;
 *    struct ListNode *next;
 *    ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * #例如 
#输入 {1.2,3,4,5}
#输出 {5,4,3,2,1}
     * @param head ListNode类 链表的头节点
     * @return ListNode类
     */
    ListNode* reverseList(ListNode* h) {
        if(!h)return h;
        ListNode* last=nullptr,*nn;
        while(h->next){
            nn=h->next;
            h->next=last;
            last=h;
            h=nn;
        }
        h->next=last;
        return h;
    }
};

#笔试##OPPO##oppo秋招##Linux##23届秋招笔面经#