3月31日学校实验室二面题解

已于 2024-05-07 21:36:48 修改
阅读量681 收藏 12
点赞数 17
文章标签： c语言 算法 数据结构
于 2024-04-02 18:29:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc369_7/article/details/137281597
版权

二面题解

A.P1258 小车问题 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

考察知识点（特殊）

小学奥数题/物理题

分析

在这里插入图片描述

行程问题不画图，亲人鼻涕两行泪

  • 我们假设小车先带乙走，开了x米后把乙放下，折返回来找到一直在走的甲，载着他与行走的乙同时到达终点
  • 有了上面的图，可以很明显的算出这段走x米的时间为2x / (a + b)，车一直在走，甲也一直在走，可以看成一个相遇问题
  • 因为要求同时到达，那么基于最优的路线上面算出来的这段时间一定与把乙放下来走到终点的时间(s - x) / a相同
  • 有了上面两条的推理，就可以依据时间相等列方程解出x的的表达式，再以乙的视角，车速走了x米，人速走了s - x米算出总时间了

代码实现

#include <stdio.h>
int main() {
    int a, b, s;
    scanf("%d %d %d", &s, &a, &b);
    double x = (double)(a + b) * s / (3 * a + b);
    printf("%6lf", x / b + (s - x) / a);
    return 0;
}

B.[P1125 NOIP2008 提高组] 笨小猴 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

考察知识点（易）

哈希表的简单运用

分析

观察题目，映入眼帘的是判断质数的关键词，所以首先需要写出一个函数来实现相应功能

质数：一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数

这里就直接给出实现了

int judge(int n) {
    if (n <= 1) return 0;
    if (n == 2) return 1;
    for (int i = 3; i < sqrt(n); i += 2) {
        if (n % i == 0) {
            return 0;
        }
    }
    return 1;
}

  • 找到关键词出现最多和最少的字符，很显然可以用数组模拟一个简单的哈希表去实现，将数组中相应位数的字符进行统计即可

  • 最大次数maxn与最小值minn需要往反方向进行初始化，否则会导致比较时的错误

代码实现

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

int judge(int n) {//判断质数
    if (n <= 1) return 0;
    if (n == 2) return 1;
    for (int i = 3; i < sqrt(n); i += 2) {
        if (n % i == 0) {
            return 0;
        }
    }
    return 1;
}

int main() {
    char s[999];
    gets(s);
    if (s[0] == '\0') {
        return 0;
    }
    int maxn = 0, minn = 999;//反方向初始化
    int map[200];
    memset(map, 0, sizeof(map));
    for (int i = 0; i < strlen(s); i++) {
        map[s[i]]++;
    }
    for (int i = 0; i < 200; i++) {//模拟哈希表加入值2
        if (map[i] != 0) {
            maxn = fmax(maxn, map[i]);
            minn = fmin(minn, map[i]);
        }
    }
    if (judge(maxn - minn)) {
        printf("Lucky Word\n%d", maxn - minn);
    }
    else {
        printf("No Answer\n0");
    }
    return 0;
}

C.P1506 拯救oibh总部 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

考察知识点（难）

搜索dfs或bfs，这里给出dfs思路（染色问题）

分析

唉这道题真的很悲伤，我们需要知道两个基地点位是可能连着的，不能用简单的for逻辑去判断

for (int i = 1; i < x - 1; i++) {
        for (int j = 1; j < y - 1; j++) {
            if (map[i - 1][j] == '*' && map[i][j - 1] == '*' && map[i + 1][j] == '*' && map[i][j + 1] == '*' && map[i][j] == '0') {//左右或者上下都有可能有点位连着，而整体被围住，这种逻辑会判错
                t++;
            }
        }
    }

其实可以再加四个循环去找到相应的边界，想一想就收手吧，这种叠着一堆循环的东西，能想不到要用递归解都难

这道题本质上还是在找东西，还要用递归去解，搜索不就闻着味出来了

但因为博主还没有系统的学深过深搜和广搜，这道题就先略过了，以后有了更深的理解后再来补题解
——————————————————————

递归调用一直都是很难的东西，博主也是在完成了代码随想录的二叉树和回溯章节后才对这道题有所领悟

解这道题前至少我们要知道dfs的模板：

void dfs(参数) {
    if (退出条件) return;
    for (循环条件) {
        dfs(参数);
    }
}

dfs通常用递归实现比较合适，在这个板子里for循环进行横向遍历，for里面的递归调用进行纵向遍历

题目要求解不被淹没的基地个数，那我们就用dfs模拟洪水蔓延的过程，淹没掉外围的基地（在原数组中将基地直接变成障碍即可，当然也可以额外的设置一个标记数组进行记录），而有四面障碍保护的基地经过一轮模拟后就可以进行统计了

对应的这道题里for选择当前格洪水前进的四个方向，而里面的递归调用则将选择变为现实，至于退出条件限定边界的同时要注意当前位置是否为障碍来决定是否继续蔓延

现在剩下一个问题，我们把洪水放在哪让它开始蔓延，所有读入的位置都有可能有障碍物而导致洪水刚放下就没了，所以放洪水要放在一个读入不到的位置，那我们可以在读入就从（1，1）开始作为有效区域，这样直接让dfs从（0，0）处开始即可

代码实现

//下次一定QwQ

//这次一定！
#include<stdio.h>

int n, m;
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};//选择方向，这个东西等价于不要循环直接写四个dfs的写法，初见很容易懵，就是四个dfs语句模拟了四个方向
char map[501][501];

void dfs(int x, int y) {
    if (x < 0 || x > n + 1 || y < 0 || y > m + 1 || map[x][y] == '*') return;//因为从（0，0）开始了，所以边界要大一圈
    map[x][y] = '*';
    for (int i = 0; i < 4; i++) {
        dfs(x + dir[i][0], y + dir[i][1]);
    }
}

int main(){
    int res = 0;
    scanf("%d %d ", &n, &m);
    for(int i = 1; i <= n; i++) { 
        for (int j = 1; j <= m; j++) {
            scanf("%c ", &map[i][j]);//这个读入一定要加一个空格！！！！不然读入都是错的！！！！
        }
    }
    dfs(0, 0);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (map[i][j] == '0') res++;
        }
    }
    printf("%d", res);
    return 0;
}

D.P1160 队列安排 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

考察知识点（难）

链式结构的灵活实现

分析

当我们完成阅读理解后，会发现这个“队列”不是指数据结构里那个队列，完全就是一个链表的实现

下面有请基于该思路的四十分代码闪亮登场

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

typedef struct Deque {
    int val;
    struct Deque* next;
}*DEQUE;

DEQUE NewMum(int val) {
    DEQUE newMum = (DEQUE)malloc(sizeof(struct Deque));
    newMum->val = val;
    newMum->next = NULL;
    return newMum;
}

DEQUE Enque(int flag, DEQUE q, int pos, int newVal) {
    DEQUE newMun = NewMum(newVal);
    DEQUE move = q;
    if (flag == 1) {
        while (move != NULL) {
            if (move->val == pos) {
                break;
            }
            move = move->next;
        }
        if (move->next == NULL) {
            move->next = newMun;
            return q;
        }
        newMun->next = move->next;
        move->next = newMun;
    }
    else {
        DEQUE dummy = (DEQUE)malloc(sizeof(struct Deque));
        dummy->next = q;
        DEQUE pre = dummy;
        while (move != NULL) {
            if (move->val == pos) {
                break;
            }
            pre = move;
            move = move->next;
        }
        if (move != NULL) {
            pre->next = newMun;
            newMun->next = move;
            return dummy->next;
        }
    }
    return q;
}

void Deque(int val, DEQUE q) {
    DEQUE dummy = (DEQUE)malloc(sizeof(struct Deque));
    dummy->next = q;
    DEQUE pre = dummy;
    DEQUE move = q;
    while (move != NULL) {
        if (move->val == val) {
            break;
        }
        pre = move;
        move = move->next;
    }
    if (move == NULL) {
        return;
    }
    pre->next = move->next;
}

int main() {
    int n;
    scanf("%d", &n);
    DEQUE q = (DEQUE)malloc(sizeof(struct Deque));
    q->val = 1;
    q->next = NULL;
    int k, p;
    for (int i = 2; i <= n; i++) {
        scanf("%d %d", &k, &p);
        q = Enque(p, q, k, i);
    }
    int m;
    scanf("%d", &m);
    int x;
    for (int i = 1; i <= m; i++) {
        scanf("%d", &x);
        Deque(x, q);
    }
    DEQUE move = q;
    while (move != NULL) {
        printf("%d ", move->val);
        move = move->next;
    }
    return 0;
}

这毕竟是道算法题，每一个数据的删除都遍历一遍链表未免显得太抽象了，TLE也是必然的

链表不行，考虑考虑数组，查询的快，可一开始就因为这道题是要在中间插入数据的直接排除了数组的实现

倒也不是说不能用数组了，这道题要求插入的效率，而插入又要先进行查询，只有数组的O(1)才能满足需求

  • 看到这篇文章的相信都是学过链表操作的，而链表中有一种特殊的静态链表，这里贴一篇之前上传的一点拙见，以便对这种思想有一定的了解week4-CSDN博客（写的比较早了其实写的挺差的）
  • 静态链表的指针域用一个游标实现，在数组内实现了类似于用真指针那样的链式链接，本题解决的关键就在这里，每个人有两只手，自然要有两个游标进行连接
  • 为了方便各个数据的插入，本题的实现其实还有一点最简单的哈希思想，以数组下标为键key和值value插入具体的数据，键和值同时都是数组的下标，访问直接找下标即可
  • 有了这两点的明确，我们就可以实现一个在数组内的链式链接，查询有了哈希的O(1)，从而解决超时问题

实现的大致思路有了，下面来说说具体的插入和删除

  • 我们默认每个人都在那，即数组开多大就有多少人，添加的时候更改其左右游标的连接即可

举个例子，我们现在想把一个人插到目标人物的右边

我们现在有人群结构体数组Pos，目标Pos[pos]，需要插入的人Pos[num]，通过更改他们左右手牵的人即可实现插入

Pos[num].l = pos;//将插入人物的左手递给目标
Pos[num].r = Pos[pos].r;//将插入人物的右手递给目标右边的人
Pos[pos].r = num;//更改目标人物的右牵给插入人物
Pos[Pos[num].r].l = num;//这里与图中不一样，原因是代码中先更改了目标人物的右手指向，引用图中原来的关系会引用到插入人物身上，而上面几行我们已经将插入人物的右手给了目标右边的人，所以需要引用插入人物的右手才能找到原来那个人，并将他的左手给插入人物

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

而删除因为洛谷的模式要求输出的正确性，可以给每个人添加一个标记位，检查标记位的值决定是否输出即可

  • 接下来实现代码就行了？吗？输出怎么输出，按我们上面的逻辑插入后，怎么确定一个人右手边没人了，每个人在插入时都是基于原来两个人插入的，不停去找右边的人时总会返回到原点再来一遍进入死循环

所以在一切的开始前我们要标记一个不存在的0号人物，让最开始在队列的一号人物插到0号人物右边，最后输出的时候总会回来转一圈转到0号人物身上，这个时候停止即可，让他的左右手都牵着自己

for (int i = Pos[0].r; i; i = Pos[i].r) //输出的循环逻辑

代码实现

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

struct pos{
    int l;//左手
    int r;//右手
    int flag;//标记位
}Pos[100010] = {0};//后面数据比较多，数组（人数）开大一点

void add(int flag, int pos, int num) {
    if (flag == 1) {//加到右边
        Pos[num].l = pos;
        Pos[num].r = Pos[pos].r;
        Pos[pos].r = num;
        Pos[Pos[num].r].l = num;
    }
    else {//加到左边
        Pos[num].r = pos;
        Pos[num].l = Pos[pos].l;
        Pos[pos].l = num;
        Pos[Pos[num].l].r = num;
    }
    return;
}

int main() {
    Pos[0].l = 0;//设置0号人物作为输出结束的标志
    Pos[0].r = 0;
    add(1, 0, 1);
    int n;
    scanf("%d", &n);
    int k, p;
    for (int i = 2; i <= n; i++) {
        scanf("%d %d", &k, &p);
        add(p, k, i);//插入人物
    }
    int m, x;
    scanf("%d", &m);
    for (int i = 1; i <= m; i++) {
        scanf("%d", &x);
        Pos[x].flag = 1;//删除人物
    }
    for (int i = Pos[0].r; i; i = Pos[i].r) {
        if (Pos[i].flag != 1) {//根据标记位是否输出
            printf("%d ", i);
        }
    }
    return 0;
}

E.B3640 T3 句子反转 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

考察知识点（中等）

用双指针对字符串进行操作

分析

  • 首先题目要求整体上的逆序输出，自然遍历数组时应当从字符串末向头遍历
  • 其实数字部分要局部反转，而字母部分则是进行大小写的转化但单词不反转
  • 最后题目中还告诉我们每个词之间用空格隔开了

这是从题目中可以直接获取的关键信息，既然已经明确告诉我们用空格隔开了每一个词，第一反应一定是能不能依据这个特性把每一个分开成一个个单独的整体进行处理

当然也不用真的把这些全部一个个拿出来单独处理，这里可以使用双指针进行操作，倒序遍历时左指针找到前一个空格，而右指针在当前词的末尾即可

操控左右指针以及控制输出具体哪一端就可以完成不同的处理，题目保证数字和字母不会相邻，那就直接暴力去找就可以了

代码实现

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

int main() {
    char s[101000];//记得把数组开大不然会爆RE
    gets(s);
    int left = strlen(s) - 1;
    int right = strlen(s) - 1;
    for (int i = strlen(s) - 1; i >= 0; i--) {
            while (left >= 0 && s[left] != ' ') {
                left--;
            }
            int tep = left;
            left++;
            while (left <= right) {
                if (s[right] >= '0' && s[right] <= '9') {
                    printf("%c", s[right]);
                    right--;
                }
                else if (s[right] >= 'a' && s[right] <= 'z') {
                    printf("%c", s[left] - 32);//转大写
                    left++;
                }
                else if (s[right] >= 'A' && s[right] <= 'Z') {
                    printf("%c", s[left] + 32);//转小写
                    left++;
                }
            }
            left = tep - 1;
            right = tep - 1;
            i = tep;
            printf(" ");
    }
    return 0;
}

F.[P1059 NOIP2006 普及组] 明明的随机数 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

考察知识点（易）

排序

分析

  • 还是那句话，这道题在洛谷上不在力扣上，所以去重可以只在表面上去重，即不输出即可，不用真正的删掉

  • 题目要从小到大输出那就先排序，遍历确定重复的数量，输出时遇到相同时跳过即可

代码实现

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

void BubbleSort(int* s, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (s[j] > s[j + 1]) {
                int tep = s[j];
                s[j] = s[j + 1];
                s[j + 1] = tep;
            }
        }
    }
}

int main() {
    int n;
    scanf("%d", &n);
    int s[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &s[i]);
    }
    BubbleSort(s, n);
    int t = 0;
    for (int i = 1; i < n; i++) {
        if (s[i] == s[i - 1]) {
            t++;
        }
    }
    printf("%d\n", n - t);
    for (int i = 0; i < n; i++) {
        if (i > 0 && s[i] == s[i - 1]) {//表面去重
            continue;
        }
        printf("%d ", s[i]);
    }
    return 0;
}

G.P3817 小A的糖果 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

考察知识点（中等）

贪心算法

分析

  • 首先不要把题读错了，是一盒盒糖果相邻在一起进行进行处理，每次吃掉糖果不是说直接给当前位的糖果清零了
  • 贪就要吝啬一点，从左往右遍历一遍，每次相邻两位之和多于要求的x时，将相对右边的糖果数量减少，直到两盒糖果数刚好等于x即可，一次遍历中靠右的糖果数减少了，下一轮它就成为靠左边的糖果再继续判断（不要忘了把变化的糖果数加入结果中）
  • 但这样会有一个问题，遍历一定是从第二盒开始的，减少也是从第二盒开始，如果出现第一盒一盒的糖果数就直接多于x那就会暴毙，所以在开始一次遍历前需要对首盒糖果单独处理

代码实现

#include <stdio.h>

int main() {
    int n, x;
    scanf("%d %d", &n, &x);
    long long int a[n];
    for (int i = 0; i < n; i++) {
        scanf("%lld", &a[i]);
    }
    long long int res = 0;
    if (a[0] > x) {//处理第一盒的情况
        res = a[0] - x;
        a[0] = x;
    }
    for (int i = 1; i < n; i++) {//一次遍历
        if (a[i] + a[i - 1] > x) {
            res += a[i] + a[i - 1] - x;
            a[i] -= a[i] + a[i - 1] - x;
        }
    }
    printf("%lld", res);
    return 0;
}

个人本次总结

本次考核写的很难蚌，1400的总分斩获260，属于是我自己都看不下去的那种

  1. 写不出来说明我硬实力还是不够，菜就多练始终适用，A题数学问题卡思路，C题的深搜没怎么接触，D题算是比较活了，用了一个类似于静态链表的游标实现操作，没接触过还情有可原，不过考核时写的一个链表去操作也卡死在了虚拟头结点的处理上（后续考核完发现问题补完代码也是超时，更难蚌了），B题就纯属自身问题了，把初始化整错了，甚至判断质数的函数一开始也写错了，整个人感觉完全不在状态
  2. 长时间练习力扣的核心代码模式，重新写洛谷上的题像是残疾一样，比如C题的二维数组甚至读入错误，没有注意到换行符的影响（虽然注意到这点思路也是错的，但至少不会在这上面折了时间），以及D题里对虚拟头节点的操作，力扣上操作后通常是要将dummy->next作为返回值的，结果我是自己写的void返回值导致半天找不到错误，又消耗了一大段时间
  3. 时间分配不均以及勇气不够，值300分（最大分值）的G题看了一眼是贪心，就直接断定短时间内绝对写不出来，到最后连题看都没看完，结果难度也就那样，和ABCD纠缠了很久之后脑子直接糊了，E题也想不到是双指针去做，后续做出来了结果因为数组开的不够大一个测试点都没过（别太搞笑）

可秒的BF没秒出来，稍加思索能做的E也因为不熟悉洛谷的RE报错代表什么而败北，A题特殊暂且不谈，CD纯纯浪费时间了，自身太菜没能写出思路中可以运行的代码导致一直死揪着不放，没能及时止损，把G给扔了

种种迹象都指向唯一的结果，我太菜了，今后要加紧学习了

[abcdem]
关注
  • 17
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
题解 | #用remove（元素值）就能删除列表中对应元素#
2301_79125431的博客
04-23 1202
本人西安女生，比较外向，目前手里两个offer，以后还是更想回西安工作生活，基本情况如图，请大家踊跃。后来刚好回学校路上，时间不合适推了。深信服在北京，不知道北京这边深信服的测开团队怎么样，好未来转正实习不包转正，佬们有了解的帮忙选选，薪。拿了东风的offer结果中车又来定岗电话，现在东风拖了一周了，中车还没签约消息，打电话问了好多次，那。投了简历过了初筛，收到线下机考邮件，说是考一道算法题，BFS/DFS相关，我对Python只是熟悉，拼多多海外市场部，严重缺人，hc多多，算法/工程/数据分析都要。
2024/5/6携程校招软件开发岗位第四题题解 换根树形DP
2301_78234743的博客
05-06 628
四月份开始找暑期实习，只面了腾讯美团淘天阿里，能拿到的面试不多，美团也没有复活赛，还有一些中小厂，没。今天算是正式上班的第二天，主管带我导师来找我聊天了，说他这个组比较复杂，我一年经验可能干不了，叫我随。暑假开始实习，300-400人，开发团队不到20人，3k包住，感觉咋样。求助，请大佬们帮忙选择一下offer！bg双九，去年的时候还想着要不找个开发的了，算法感觉太难卷了，没论文，导师不放日常，实在不好找。搜了好多基本都是跟销售，电商和市场相关的管培，蛮少人提到采购或者供应链管培的，有了解面试的吗？
算法（四）搜索
weixin_44788545的博客
07-25 1096
一、深度优先搜索（DFS） 1、概念 DFS（Depth First Search）是从初始结点开始扩展，扩展顺序总是先扩展最新产生的结点。这就使得搜索沿着状态空间某条单一的路径进行下去，直到最后的结点不能产生新结点或者找到目标结点为止。当搜索到不能产生新的结点的时候，就沿着结点产生顺序的反方向寻找可以产生新结点的结点，并扩展它，形成另一条搜索路径。 2、剪枝策略 剪枝就是通过一些判断，剪掉搜索树上不必要的子树。在采用DFS算法搜索时，有时候我们会发现某个结点对应的子树的状态都不是我们要的结果，这时候我们没
搜索（洛谷）
m0_62593364的博客
07-24 400
代码1dfs注意恢复现场。
题解 | #统计每个学校各难度的用户平均刷题数#
每天多一点干货
06-07 500
哎，到现在还没找到实习，基本上都是已读不回，要不就是面试被刷找不到实习怎么办 #正在实习的碎碎念#BAT三家公司市值对比:2010年，百度市值380亿美元，2010年，阿里估值100亿美元，2010。不是，我一直以为BAT里面掉队的只有曾经的搜索大佬百度，怎么两天没见，阿里也开始拉了？也太恶心人了，手撕撕出来了，一面面试官最后都问我进去以后考虑做什么，第二天就把我挂了。今天突然测开的暑期实习发面试通知了，之前开发的做完笔试筛选简历挂了，今天突然发第二志愿测开的面试了，
题解 | #查询每天刷题通过数最多的前二名用户id和刷题数#
每天多一点干货
06-03 803
引流：华为，字节跳动，美图，腾讯，京东，阿里巴巴，百度#我的实习求职记录##我的求职思考##互联网没。第一次找实习，想被拷打一下简历，好焦虑 #投递实习岗位前的准备# #最后再改一次简历# #投递实习。5.10号面完的快泡了一个月都，还能开出来吗 #华为开奖那些事# #华为实习# #华为求。5.30面试的南京的Java开发岗，一二面分别半个小时，当天晚上就显示二面挂了，记录一下。想问问大家 关于简历的一些修改问题 #最后再改一次简历# #简历被挂麻了，求建议# #写简历别走。
（2019年1月3日-2019年6月8日）
weixin_30332705的博客
03-06 1239
..................................................................... 6月8日《大扫除记》 　　对于活动室的卫生情况，曾有一位经验丰富的专家说过：“男生可以一直脏下去，而女生她总有一天会看不下去的。” 　　很荣幸，我就是那个女生。 　　在这个阳光明媚的早晨，我来到了活动室，活动室里一个人都没有，我放下包，喝了一大口饮料，...
题解 | #某宝店铺连续2天及以上购物的用户及其对应的天数#
han_xue_feng的博客
10-12 920
途虎养车Java 自我介绍结束就是项目，问算法问了挺多。然后一些多线程的八股，最后手撕，说给20分钟，10分钟就a了，然后反问环节数字时代的自我呈现：探索个人形象打造的创新工具 数字时代的自我呈现：探索个人形象打造的创新工具——FaceChain深度学习模型工具1.介绍FaceChain是一个可以用来打造个人数字形象的深度学习模型工具。小红书 Android社区技术 二面 时长：40分钟1、进程、线程、协程的区别2、进程的调度算法3
华二第一日题解的所有题面
07-31
【标题】：“华二第一日题解的所有题面”涉及的三个编程竞赛题目解析 【描述】：描述中提到这是一个模拟赛，遵循OI比赛规则，包括单次提交、离线评测，比赛时间、源程序提交方式、命名规范、评测环境等。此外，还...
计蒜客2月普及月赛题解
02-28
### 计蒜客2月普及月赛题解 #### 修剪花篱题解 本题主要考察了如何通过计算和比较来找到最优化的操作方法，最终实现让序列中的所有数值相等。 **题目概述：** - 题目要求通过一系列操作使得序列中的所有数字相等...
python-leetcode面试题解之第31题下一个排列-python题解.zip
03-12
在LeetCode的第31题中，通常要求找到一个数字序列的下一个字典序排列，比如序列[1,2,3]的下一个排列是[1,3,2]，而[2,1,3]的下一个排列是[2,3,1]。 综上所述，这个压缩包提供了一个使用Python解决LeetCode第31题“下...
计算机二级-计算机二级高频Python题+题解.zip
03-04
这个压缩包文件“计算机二级-计算机二级高频Python题+题解.zip”包含了针对这一考试的Python编程题目及解答，是备考者的重要参考资料。 【Python】是一种高级编程语言，以其简洁明了的语法和强大的功能受到广泛欢迎...
第十三届蓝桥杯青少赛省赛（2022年4月17日）C++中级组题解
11-06
二进制数`1101111`转换为十六进制，首先每四位一组，不足四位的在前面补零，得到`(1101 111)`，然后分别转换，`(1101)_2 = (D)_16`，`(1111)_2 = (F)_16`，所以最终结果是`(D F)_2 = (6F)_16`。 - **指针的用法**：...
C语言primitive
编程语言技巧经验分享
08-05 560
微风不燥，阳光正好，你就像风一样经过这里，愿你停留的片刻温暖舒心。助您在编程路上越走越好！
【C语言篇】数据在内存中的存储（超详细）
2301_79849925的博客
08-02 1000
数据在内存中是如何存储的呢，二进制十进制八进制十六进制之间的转换关系，整数和浮点数在内存中存储的方式有什么不同呢？一起来看看吧！
【C语言篇】猜数字游戏（赋源码）
最新发布
2301_79849925的博客
08-06 691
有趣的游戏！！！写一个猜数字游戏电脑⾃动⽣成1～100的随机数玩家猜数字，猜数字的过程中，根据猜测数据的⼤⼩给出⼤了或⼩了的反馈，直到猜对，游戏结束。
(leetcode学习)50. Pow(x, n)
m0_54888411的博客
08-05 216
快速幂，第一次写的时候用 n%2==1，这样不能处理负数的问题。
5力扣：最长回文子串
m0_75015083的博客
08-02 255
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。
Java语言程序设计题解与上机实验指南
此外，书内包含8个精心设计的上机实验指导，涵盖了实验目的、实验要求、实验内容和步骤，这些实验旨在帮助学生实际操作，提升动手能力，是教师组织课堂实验和学生自我实践的良好资源。 本书强调概念的清晰性和实用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值