嵌入式笔试算法题总结

已于 2023-09-14 23:49:53 修改
阅读量193 收藏 3
点赞数 2
分类专栏： 嵌入式学习笔记 文章标签： c++ 算法
于 2023-08-20 22:15:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45355603/article/details/132396692
版权

0.字符串定义

char str1[] = "123456"; // 存放在栈区，可读可写
// char *str2 = "12345"; // 存放在只读数据区，不可以进行修改，需要加const进行修饰
const char *str2 = "12345";
#include <iostream>
#include <string.h>
using namespace std;

char str1[] = "123456"; // 存放在栈区，可读可写
// char *str2 = "12345"; // 存放在只读数据区，不可以进行修改，需要加const进行修饰
const char *str2 = "12345";

int main()
{
    // 字符串定义：方法3
    char *str3 = (char *)malloc(128);
    strcpy(str3, "1234");
    cout << str3 << endl;
    free(str3); // 字符串使用完之后，立即进行释放

    return 0;
}

1.字符串翻转

#include <iostream>
#include <string.h>
using namespace std;

// 字符串逆序
void Reverse(char *str)
{
    int length = strlen(str);
    for (size_t i = 0; i < length / 2; i++)
    {
        char temp = str[i];
        str[i] = str[length - 1 - i];
        str[length - 1 - i] = temp;
    }
}

int main()
{
    char str1[] = "12345";
    Reverse(str1);
    cout << str1 << endl;  // 54321
    return 0;
}

2.字符串排序

描述：随便输入几个字母，按照a~z顺序排列，采用冒泡排序算法进行设计。

#include <iostream>
#include <string.h>
using namespace std;

// 冒泡排序
void BubbleSort(char arr[], int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        int flag = 0;
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                char temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;

                flag = 1;
            }
        }
        if (flag == 0)
        {
            break;
        }
    }
}

int main()
{
    char str[] = "AaBbcC";
    int n = strlen(str);
    BubbleSort(str, n);
    cout << str << endl; // ABCabc

    return 0;
}

3.统计汉字和字母的个数

注意：使用GBK编码，使用UTF-8编码，程序计算结果有误。

  • 在UTF-8编码中，一个汉字占3个字节
  • 在GBK编码中，一个汉字占2个字节
#include <iostream>
using namespace std;

// 统计汉字和字母的个数
void Count(char arr[])
{
    int i = 0;
    int zh = 0;
    int en = 0;
    while (arr[i]) // 执行到结束符\0
    {
        if (arr[i] < 0) // 一个汉字由两个小于0的字符组成
        {
            zh++;
            i += 2;
        }
        else
        {
            en++;
            i++;
        }
    }
    cout << "zh = " << zh << endl;
    cout << "en = " << en << endl;
    cout << "sum = " << zh + en << endl;
}

int main()
{
    char str[] = "C++汉字";
    Count(str);
    return 0;
}

4.打印9*9乘法表

#include <iostream>
using namespace std;

int main()
{
    for (short i = 1; i <= 9; i++)
    {
        for (short j = 1; j <= i; j++)
        {
            cout << i << "x" << j << "=" << i * j << "\t";
        }
        cout << endl; // 完成一行后，进行换行
    }
    return 0;
}

5.将字符串中的大写字母转化为小写字母

ASCII：A(65)、a(97)，a - A  = 32

#include <iostream>
#include <string.h>
using namespace std;

// 字符串中大小写切换
void Shift(char arr[], int n)
{

    for (int i = 0; i < n; i++)
    {
        // 大写转小写
        if (arr[i] >= 'A' && arr[i] <= 'Z')
        {
            arr[i] += 32;
        }

        // 小写转大写
        else if (arr[i] >= 'a' && arr[i] <= 'z')
        {
            arr[i] -= 32;
        }
    }
}

int main()
{
    char str[] = "ABab";
    int n = strlen(str);
    Shift(str, n);
    cout << str << endl;
    return 0;
}

6.计算2的1024次方

  • 在C语言中，int型占4个字节，4*8 = 32位，最大表示2的32次方-1。
  • 方法：定一个大的数组(初始化为1)，把数字当作字符串进行处理，模拟2进位的方法，最终得到的字符串进行逆序。
#include <iostream>
#include <string.h>
using namespace std;

// 字符串逆序
void Reverse(char *str)
{
    int length = strlen(str);
    for (size_t i = 0; i < length / 2; i++) // 由于要进行逆序，所以只需要交换前一半的字符即可
    {
        char temp = str[i];
        str[i] = str[length - 1 - i];
        str[length - 1 - i] = temp;
    }
}

// 计算2的N次方
void Index(int n, char *str)
{
    int i, j;
    for (i = 0; i < n; i++)
    {
        int temp = 0; // 用于保存进位的临时变量
        for (j = 0; j < strlen(str); j++)
        {
            int num = str[j] - '0';  // 将字符转换为对应的整数值
            num = (num << 1) + temp; // 将当前位的数乘以2，并加上进位
            temp = num / 10;         // 计算进位
            str[j] = num % 10 + '0'; // 将计算结果转换回字符型，并存储
        }
        if (temp > 0)
        {
            str[j] = temp + '0'; // 如果还有进位，存储在新的一位上
        }
    }
    Reverse(str); // 计算完成后，需要将字符串逆序，得到正确的结果
}

int main()
{
    int n = 16;
    char str1[n] = {'1'};
    Index(n, str1);
    cout << str1 << endl; // 65536
    return 0;
}

7.数组元素逆序

#include <iostream>
using namespace std;

// 数组元素逆序
void Reverse(int arr[], int n)
{
    for (int i = 0; i < n / 2; i++)
    {
        int temp = arr[i];
        arr[i] = arr[n - 1 - i];
        arr[n - 1 - i] = temp;
    }
}

int main()
{
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(int);
    Reverse(arr, n);

    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ",";
    }
    cout << endl;
    return 0;
}

8.宏定义

宏定义，防止头文件被重复编译

// 标识符可以自由命名，一般使用头文件名全部大写的方式，前面加_，把.改成_
#ifndef _LED_H  
#define _LED_H
// 代码段
#endif

宏定义函数，带参

#include <iostream>
using namespace std;

#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))

int main()
{
    int a = MAX(1, 2);
    cout << a;
    return 0;
}

通过宏定义的方式，计算数组的长度 

#include <iostream>
using namespace std;

#define Len(arr) (sizeof(arr) / sizeof(arr[0]))

int main()
{
    int a[] = {1, 2, 3};
    int b = Len(a);
    cout << b;
    return 0;
}

9.不使用sizeof判断操作系统是64位还是32位

#include <stdio.h>

int main() {
    if ((1L << 32) == 0) {
        printf("64位系统\n");
    } else {
        printf("32位系统\n");
    }
    
    return 0;
}

10.如何判断链表是否有环

正常的单向链表，最后一个节点的指针域应该是NULL，表示后面没有节点。

如果把最后一个节点的指针域，改为前面的某个节点的地址，这样的链表叫做有环的链表。

如何判断链表是否有环：

1.定义两个指针：慢指针(每次走一步)、快指针(每次走两步)

2.如果链表没有环，快的指针肯定最先到达终点

3.如果链表有环，那么两个指针迟早相遇

int fcn(Node *head)
{
    if (head == NULL)
    {
        return 0;
    }

    Node *fast = head;
    Node *slow = head;

    while (fast && slow) // 两个指针都不为空
    {
        // 如果某个指针为空，说明链表没有环
        if (fast->next && fast->next->next)
        {
            fast = fast->next->next; // 快指针每次走两步
        }
        else
            break;
        if (slow->next)
        {
            slow = slow->next; // 慢指针每次走一步
        }
        else
            break;
        if (fast == slow) // 如果快慢指针在某个时刻相等，说明链表有环
            return 1;     // 链表有环
    }
    return 0; // 链表没有环
}

 11.如何判断两个链表是否相交

如果两个链表相交，那么一定有重合的节点。

方法1：可以逐个判断第一个链表里面的节点，是否在第二个链表中。效率较低

方法2：相交的两个链表，他们的最后一个节点一定是重合的，所以只要让第一个链表的指针，指向最后一个节点。第二个链表的指针，也指向最后一个节点，判断这两个节点是否相同。

int is_cross(Node *head1, Node *head2)
{
    if (head1 == NULL || head2 == NULL)
    {
        return 0;
    }

    Node *p1 = head1, *p2 = head2;
    // 假设链表有头节点，两个指针分别移动到最后一个节点
    // 如果指针相同，那链表就是相交的
    while (p1->next)
    {
        p1 = p1->next;
    }
    while (p2->next)
    {
        p2 = p2->next;
    }
    if (p1 == p2)
    {
        return 1; // 链表相交
    }
    else
        return 0; // 链表不相交
}

 进阶：如何找出相交的那个节点

如果两个链表的长度一样，只要同时移动指针，最先相等的那个节点，一定就是相交的节点，所以可以先计算两个链表的长度差，然后先移动一个指针，保证长度一样后再同时向后走。 

 12. 手写链表的基本操作

链表的初始化、插入、遍历

链表相对于数组的优点：容量没有限制，插入删除的效率比较高。数组在内存中是一块连续的存储空间，链表在内存中不连续，由节点组成，每个节点包含两部分(数据域：存储数据，指针域：存储下一个节点的地址) 

链表的初始化：空链表，只有一个头节点，没有数据域

#include <iostream>
using namespace std;

typedef struct Node
{
    int data;
    struct Node *next;
} Node;

// 链表的初始化
int InitList(Node **h)
{
    if (h == NULL)
    {
        return 0;
    }
    (*h) = (Node *)malloc(sizeof(Node));
    if ((*h) == NULL)
        return 0;
    (*h)->next = NULL;
    return 1;
}

int main()
{
    Node *head = NULL; // 链表的初始化：形成一个空的链表

    int ret = InitList(&head);
    if (ret == 0)
        cout << "链表初始化失败" << endl;
    else
        cout << "链表初始化成功" << endl;

    return 0;
}

13.找出字符串中不含有重复字符的最长子串的长度

例如，abcabcbb的无重复字符的最长子串是“abc”

#include <iostream>
using namespace std;

int lengthofLongestSubstring(char *s)
{
    int exist[256] = {0};
    char *left = s;
    char *right = s;
    int max = 0;

    while (*right != 0)
    {
        if (exist[*right] == 1)
        {
            exist[*left++] = 0;
        }
        else
        {
            exist[*right++] = 1;
            int t = right - left;
            if (t > max)
                max = t;
        }
    }
    return max;
}

int main()
{
    char str[] = "abcabcdd";
    int a = lengthofLongestSubstring(str);
    cout << a << endl; // 输出4

    return 0;
}

14.将字符串转化为整数

#include <iostream>
#include <string.h>
using namespace std;

// 将字符串转换为整数
void Conver_Int(char str[], int &num)
{
    int len = strlen(str);
    cout << "str len = " << len << endl;

    for (int i = 0; i < len; i++)
    {
        if (str[i] > '0' && str[i] < '9')
        {
            // 将字符转换为整数
            int temp = str[i] - 48;  // 0的ASCII为48
            num = num * 10 + temp;
        }
    }
}

int main()
{

    char str[] = "123456";
    int num = 0;
    Conver_Int(str, num);
    cout << num + 1 << endl; // 输出123457
    return 0;
}

15.将整数转化为字符串

#include <iostream>
using namespace std;

void Int_String(int num, char str[])
{
    int i = 0;
    int isNegative = 0;

    // 处理负数
    if (num < 0)
    {
        isNegative = 1;
        num = -num; // 如果是负数，将其转为正数
    }
    // 处理特殊情况：整数为0
    if (num == 0)
    {
        str[i++] = '0'; // 如果整数为0，将字符'0'存入字符串
    }

    // 将整数转换为字符串（从右到左）
    while (num > 0)
    {
        int digit = num % 10;   // 取出整数的最后一位数字
        str[i++] = '0' + digit; // 将数字字符存入字符串
        num /= 10;              // 移除最后一位数字
    }

    // 如果是负数，添加负号
    if (isNegative)
    {
        str[i++] = '-'; // 如果是负数，添加负号到字符串
    }

    str[i] = '\0'; // 在字符串末尾添加 null 终止字符

    // 反转字符串，因为上面的循环是从右到左构建的
    int len = i; // 计算字符串的长度
    for (int j = 0; j < len / 2; j++)
    {
        char temp = str[j]; // 交换字符的位置
        str[j] = str[len - j - 1];
        str[len - j - 1] = temp;
    }
}

int main()
{
    int num = -12345;
    char str[20];

    Int_String(num, str);
    cout << str << endl; // 输出字符串-12345

    return 0;
}

⁢稚子
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大华股份2014年嵌入式软件、算法类笔试题
10-25
2014年大华笔试题目，和以往2012、2013笔试题目出入很大，备考利器啊！
嵌入式笔试面试题目系列（汇总）
热门推荐
高空的博客
02-28 8万+
本系列按类别对题目进行分类整理，这样有利于大家对嵌入式的笔试面试考察框架有一个完整的理解。
用C语言实现2的次方运算
qq_37298688的博客
10-19 1万+
关于2的次方运算 笔者给出了两种最基本的C语言方法  第一种是使用for循环语句  #include"pch.h" #include &lt;stdio.h&gt; /* function main begins program execution */ int main(void) { int pro=1; int number;/* initialization */ int ...
C语言：关于实型精确度和取值范围的计算方法
cherish_xmm的专栏
02-12 5018
实型存储分为三部分：符号部分，小数部分和阶数部分。其中小数部分表示精确程度，阶数部分表示大小。 单精度规定用8位二进制表示阶数，即最大表示为2的128次方，把这个数算出来是3.4028236692093846346337460743177e+38 双精度规定用11位二进制表示阶数，即最大表示为2的1024次方，结果是1.797693134862315907729305190789e+308
20道嵌入式工程师面试题（附答案）
诗筱涵的博客
10-14 1万+
我发现boss直聘里面的嵌入式面试题和这差不多 摘自：https://zhuanlan.zhihu.com/p/99535738 20道嵌入式工程师面试题（附答案） Snail 生活不怕缓慢！只怕停滞不前！ 近期，我们根据以往的学员的面试经历，为大家整理了一些面试经常会遇到的题目，希望这些干货对大家面试有所帮助。 更多相关技术文章，自动化相关视频、学习资料请关注公众号“自动化部落”（←点我） 1.嵌入式系统中经常要用到无限循环，如何用C编写死循环 答：while(1){}或...
Python补充知识1
qq_61529681的博客
08-30 1620
First
C语言计算2的1024次方
学益得的博客
09-21 739
int类型虽然不好表示这么大的数，但是C语言中还有一种long double类型，具体的长度不同的编译器可能略有不同，10字节、12字节、16字节都有。我用的Ubuntu环境，long double类型确实能解决2的1024次方。C语言中的int类型一般占4字节，4个字节就是32位二进制，即使是无符号数，能表示的最大数字也就是2的32次方减一，离2的1024次方还差很远。来一个数组，数组尽量大一些，初始化成1，乘以2的结果分别是2 4 8。这种办法不仅能计算2的1024次方，再大一些，问题也不大。
计算2的n次方的三种方法（C语言实现）
weixin_30500663的博客
01-22 1万+
C代码如下： 1 #include <stdio.h> 2 3 int func1(int n) 4 { 5 return 1<<n; 6 } 7 8 int func2(int n) 9 { 10 11 if(n==0) 12 { 13 return 1; 1...
计算2的N次方（高精度实例） —— C++
点滴博客
08-09 6708
任意给定一个正整数N(N<=100)，计算2的n次方的值。 输入 输入一个正整数N。 输出 输出2的N次方的值。 样例输入 5 样例输出 32 思路：已知 2^0 ~ 2^64 具体值，遇到大于 64 的 N ，相当于 2^64 * 2^(N - 64) 这里用到了大整数乘法，而大整数乘法用到了大整数加法 代码： #include<string> #include<...
C语言——计算2的N次方
肥不溜秋大梅子
01-28 1万+
Description   任意给定一个正整数N（N≤100），计算2的N次方的值。 Input   输入只有一个正整数N。 Output   输出2的N次方的值。 Sample Input   5 Sample Output   32 Source #include&lt;stdio.h&gt; #include&lt;string.h&gt; int main(...
c语言实现输出2的1000次方
costeeer的博客
01-29 1200
//用数组来模拟它的进位#include int main(void) { int a[1000]; //先定义一个足够大的数组 int i,j; for(i=0; i<1000; i++) //先置零 { a[i] = 0; } a[0] = 1
嵌入式笔试题和一个数据结构算法软件
10-09
嵌入式笔试题大全 数据结构算法完美软件
嵌入式岗位笔试面试真题+讲解
09-18
lnux操作系统题目、网络编程题目、ARM裸机开发题目、进程与线程题目、基本的寄存器与存储器题目、C语言＆数据结构与算法题目、ARM处理器与中断题目、数据结构与算法题目、内存管理&编程题题目、.预处理&关键字题目、...
嵌入式软件面试笔试题汇总强烈推荐
01-11
嵌入式软件面试笔试题汇总，包括算法、数据结构、C语言等各个方面，在找工作时，提前阅读，有利于避坑。
2018宇视科技笔试试题
02-16
宇视科技2018年嵌入式软件开发/驱动开发笔试试题 该文本为第一手手敲资料，难免有输入错误，仅供应聘者参考，绝对真实！绝对完整！
2的任意次方
Keep Learning
10-21 9402
2的任意次方，能计算到2的1023次方。但在2的57次方后就不精确。     #include #include int main(void) { double x, y; printf("请输入需要计算2的次方:"); scanf("%lf",&x); for(y=1;y<=x;y=y+1){ printf("2的%.0lf次方是%.0lf\n", y, pow(2,y
C语言中递归实现幂运算
迷路的小绅士之家
05-12 838
递归是一种常用的解决问题的方法，通过将一个大问题分解成多个小问题，可以简化问题的解决过程。在实现递归函数时，需要明确递归公式，并注意递归结束的条件，避免出现死循环。在使用递归函数时，需要注意递归调用的开销和栈空间占用，避免出现栈溢出等问题。
计算2^N（高精度计算）C语言
weixin_43727125的博客
11-18 7685
计算2^N（高精度计算）C语言 总时间限制: 1000ms 内存限制: 65536kB 描述 任意给定一个正整数N(N&amp;lt;=100)，计算2的n次方的值。 输入 输入一个正整数N。 输出 输出2的N次方的值。 样例输入 5 样例输出 32 提示 高精度计算 分析 ： 2^100为31位数字，任何整型数据无法保存，而用double虽可保存但有误差，故考虑用数组，各位数用单独一个元素保存。 注...
初识C语言——第二十一天
最新发布
硬件菜鸟的成长之路
05-15 616
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
cvte嵌入式笔试题压缩算法
10-11
以下是我对CVTE嵌入式笔试题中压缩算法的回答。 在压缩算法中，常用的方法有有损压缩和无损压缩两种。有损压缩会在压缩过程中丢失一些数据，达到压缩的效果，适用于一些对数据准确性要求不高的场景，如图像压缩。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值