编译原理lab3降重

最新推荐文章于 2024-10-18 20:14:18 发布
最新推荐文章于 2024-10-18 20:14:18 发布
阅读量234 收藏
点赞数 2
文章标签： 汇编 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64885905/article/details/139591864
版权

经降重。

三代编译器将一种语法类似 C 语言的语句序列翻译为等价的汇编程序，所输出的汇编程序符合X86汇编语言格式要求，可以在Linux环境下正常运行。词法分析和语法分析部分，可以使用类似Flex和Bison的工具实现，也可以手工实现。

#include <bits/stdc++.h>

using namespace std;

string curr_namespace_return = "";
map<string, int> vTable;
map<string, int> aTable;
map<string, pair<int,int>> fTable; 
int varibles = 0;

class Judge {
public:
    static int getPriority(const string& op) {
        if (op == "!" || op == "~" || op == "---")
            return 11;
        else if (op == "*" || op == "/" || op == "%")
            return 10;
        else if (op == "+" || op == "-")
            return 9;
        else if (op == "<" || op == ">" || op == "<=" || op == ">=")
            return 8;
        else if (op == "==" || op == "!=")
            return 7; 
        else if (op == "&")
            return 6;
        else if (op == "^")
            return 5;
        else if (op == "|")
            return 4;
        else if (op == "&&")
            return 3;
        else if (op == "||")
            return 2;
        else
            return 1; 
    }

    static bool isOp(const string& op) {
        return (op == "+" || op == "-" || op == "%" || op == ">" || op == ">=" ||
                op == "<" || op == "<=" || op == "*" || op == "/" ||  op == "==" || 
                op == "!=" || op == "&" || op == "^" || op == "|" || op == "=" ||
                op == "&&" || op == "||" || op == "!" || op == "~" || op == "---");
    }
};


class TokenClassifier {
public:
    std::regex identifier_regex;
    std::regex number_regex;
    std::regex operators_regex;
    std::smatch match;

    TokenClassifier() :
        identifier_regex("[a-zA-Z_][0-9a-zA-Z_]*"),
        number_regex("[-+]?[0-9]+"),
        operators_regex("[*/%+-><]|[><!=]=") {}

    int classify(const std::string& str) {
        if (str == "main")          return 1;
        if (str == "int")           return 2;
        if (str == "return")        return 3;
        if (str == ";" || str == "{" || str == "}" || str == "(" || str == ")") return 41;
        if (str == "^" || str == "|" || str == "&") return 51;
        if (str == "||" || str == "&&") return 61;
        if (std::regex_match(str, match, identifier_regex))  return 11;
        if (std::regex_match(str, match, number_regex))      return 21;
        if (std::regex_match(str, match, operators_regex))   return 31;

        return -1;
    }
};
TokenClassifier classifier;


deque<string> process(fstream& file){
    string sent;
    deque<string> code;
    while(file >> sent){
        string curr;
        for(int i = 0; i < sent.size(); i ++){
            curr += sent[i];
            if(classifier.classify(curr) == -1){
                int l = curr.size() - 1;
                curr.erase(l);
                if(curr == "-" && classifier.classify(string(1, sent[i])) == 11) curr = "---"; 
                code.push_back(curr);
                curr.clear();
                if(!isspace(sent[i])) curr += sent[i];
            }

            if(sent[i] == '+' || sent[i] == '-'){
                int flag = classifier.classify(code.back());
                if(flag == 11 || flag == 21){ 
                    int l = curr.size() - 1;
                    curr.erase(l);
                    code.push_back(string(1, sent[i]));
                }
            }
        }

        if (classifier.classify(curr) != -1) {
            code.push_back(curr);
        }
            
    }
    return code;
}

string getMemoryLoc(string& name){
    if(aTable.find(name) != aTable.end())
        return "+" + to_string((aTable[name] + 1)* 4);
    return "-" + to_string(vTable[name] * 4);
}

void calBracket(string symbol, int& bracket){
    if(symbol == "(")bracket ++;
    else if(symbol == ")")bracket --;
}

void ExpressionProc(deque<string>& code_processed){
    if(code_processed.size() == 1){
        if (classifier.classify(code_processed[0]) == 21) {
            cout << "mov eax, " + code_processed[0] + "\n"; 
            cout << "push eax\n";
        }
        else if (classifier.classify(code_processed[0]) == 11) {
            cout << "mov eax, DWORD PTR [ebp" + getMemoryLoc(code_processed[0]) + "]\n"; 
            cout << "push eax\n\n";
        }
    }
    else{
        int n = code_processed.size();
        if(fTable.find(code_processed[0]) != fTable.end()){
            int idx = 1;
            vector<deque<string>> argList;
            int aNum = fTable[code_processed[0]].first;
            while(aNum){
                deque<string> sub;
                int bracket = 0;
                while(true){
                    idx ++;
                    if((code_processed[idx] == "," && bracket == 0) || (code_processed[idx] == ")" && aNum == 1 && bracket == 0)){
                        aNum --;
                        
                        argList.push_back(sub);
                        break;
                    }

                    calBracket(code_processed[idx], bracket);
                    sub.push_back(code_processed[idx]);
                }
            }
            reverse(argList.begin(), argList.end());
            for(auto al: argList){
                ExpressionProc(al);
            }

            cout << "call " + code_processed[0] + "\n";
            cout << "add esp, " + to_string(fTable[code_processed[0]].first * 4) + "\n";

            if(fTable[code_processed[0]].second == 1){
                cout << "push eax\n";
            }
        }
        else if(code_processed[0] == "println_int"){
            deque<string> expSub;
            int bracket = 1, idx = 1;
            while(true){
                idx ++;
                calBracket(code_processed[idx], bracket);

                if(code_processed[idx] == ")" && bracket == 0){
                    ExpressionProc(expSub);
                    break;
                }

                expSub.push_back(code_processed[idx]);
            }
            cout << "push offset format_str\n"; 
            cout << "call printf\n";
            cout << "add esp, 8\n";
        }
        else {
            deque<deque<string>> RPN;
            deque<string> ops;

            int idx = 0;
            bool isEquation = false;
            while(idx < n){
                if(Judge::isOp(code_processed[idx])){
                    while (!ops.empty() && Judge::getPriority(ops.back()) >= Judge::getPriority(code_processed[idx])) {
                        string op = ops.back();
                        ops.pop_back();
                        RPN.push_back({op});
                    }
                    if(code_processed[idx] == "=") isEquation = true;
                    ops.push_back(code_processed[idx]);
                }
                else if (code_processed[idx] == ")") {
                    while (ops.back() != "(") {
                        string op = ops.back();
                        ops.pop_back();
                        RPN.push_back({op});
                    }
                    ops.pop_back();
                }
                else if (code_processed[idx] == "(") {
                    ops.push_back(code_processed[idx]);
                }
                else if (fTable.find(code_processed[idx]) != fTable.end()) {
                    deque<string> sub;
                    int bracket = 0;
                    while(true){
                        sub.push_back(code_processed[idx]);
                        calBracket(code_processed[idx], bracket);

                        if(code_processed[idx] == ")" && bracket == 0) break;
                        idx ++;
                    }
                    RPN.push_back(sub);
                }
                else { 
                    RPN.push_back({code_processed[idx]});
                }
                idx ++;
            }

            while(!ops.empty()){
                string op = ops.back();
                ops.pop_back();
                RPN.push_back({op});
            }

            if (RPN.empty()) return;
            deque<deque<string>> results;
            for(auto rpn: RPN){
                string operatorName = rpn[0];
                int exp_len = rpn.size();
                if(exp_len == 1 && Judge::isOp(operatorName)){
                    results.pop_back();
                    if (operatorName == "+") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "add eax, ebx\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "-") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "sub eax, ebx\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "*") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "imul eax, ebx\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "/") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "cdq\n";
                        cout << "idiv eax, ebx\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "%") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "cdq\n";
                        cout << "idiv eax, ebx\n";
                        cout << "push edx\n";
                        cout << "mov eax, edx\n\n";
                        results.pop_back();
                    } else if (operatorName == "<") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "cmp eax, ebx\n";
                        cout << "mov eax, 0\n";
                        cout << "setl al\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "<=") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "cmp eax, ebx\n";
                        cout << "mov eax, 0\n";
                        cout << "setle al\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "==") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "cmp eax, ebx\n";
                        cout << "mov eax, 0\n";
                        cout << "sete al\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == ">") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "cmp eax, ebx\n";
                        cout << "mov eax, 0\n";
                        cout << "setg al\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == ">=") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "cmp eax, ebx\n";
                        cout << "mov eax, 0\n";
                        cout << "setge al\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "!=") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "cmp eax, ebx\n";
                        cout << "mov eax, 0\n";
                        cout << "setne al\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "|") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "or eax, ebx\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "^") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "xor eax, ebx\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "&&") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "test eax, eax\n";
                        cout << "setnz al\n";
                        cout << "cbw\n";
                        cout << "cwde\n";
                        cout << "test ebx, ebx\n";
                        cout << "setnz bl\n";
                        cout << "and al, bl\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "&") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "and eax, ebx\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "||") {
                        cout << "pop ebx\n";
                        cout << "pop eax\n";
                        cout << "test eax, eax\n";
                        cout << "setnz al\n";
                        cout << "cbw\n";
                        cout << "cwde\n";
                        cout << "test ebx, ebx\n";
                        cout << "setnz bl\n";
                        cout << "or al, bl\n";
                        cout << "push eax\n\n";
                        results.pop_back();
                    } else if (operatorName == "!") {
                        cout << "pop eax\n";
                        cout << "test eax, eax\n";
                        cout << "setz al\n";
                        cout << "cbw\n";
                        cout << "cwde\n";
                        cout << "push eax\n\n";
                    } else if (operatorName == "---") {
                        cout << "pop eax\n";
                        cout << "neg eax\n";
                        cout << "push eax\n\n";
                    } else if (operatorName == "~") {
                        cout << "pop eax\n";
                        cout << "not eax\n";
                        cout << "push eax\n\n";
                    } else if (operatorName == "=") {
                        cout << "pop eax\n";
                        cout << "mov DWORD PTR [ebp" + getMemoryLoc(results.back()[0]) + "], eax\n\n";
                        results.pop_back();
                    }
                    results.push_back({"pad"});
                    if (operatorName == "=") results.pop_back();
                }
                else{
                    if(operatorName != "") results.push_back(rpn);
                    if(!isEquation || rpn != RPN[0]) ExpressionProc(rpn);
                }
            }
            }
    }
    return;
}


int main(int argc, char* argv[]) {

    fstream file(argv[1], fstream::in);
    // fstream file("code_processed.txt", fstream::in);
    
    deque<string> code_processed = process(file);
    int n = code_processed.size();

    cout << ".intel_syntax noprefix\n";
    cout << ".global main\n";
    cout << ".extern printf\n";
    cout << ".data\n";
    cout << "format_str:\n";
    cout << "\t.asciz \"%d\\n\"\n";
    cout << ".text\n";
    cout << "\n";

    
    int i = -1;
    while(i < n){
        i ++; 
        while(i < n && code_processed[i] != ";"){
            if(code_processed[i] == "void"){
                curr_namespace_return = code_processed[i];
                i ++; 
                aTable.clear();

      
                int idx = i + 1; 
                int cnt = 0;
                while(idx < n && code_processed[idx] != ")"){
                    if(code_processed[idx] == "int"){
                        cnt ++;
                        idx ++;
                        aTable.insert({code_processed[idx], cnt});
                    } 
                    idx ++;
                }

                fTable.insert({code_processed[i], {cnt, 1}}); 
                cout << code_processed[i] + ":\n"; 
                cout << "push ebp\n"; 
                cout << "mov ebp, esp\n"; 
                cout << "sub esp, 0x100\n";

                for(; i < n; i ++)if(code_processed[i] == "{") break;
            }
            else if(code_processed[i] == "int"){
                if(code_processed[i + 1] == "main"){
                    curr_namespace_return = "main";
                    aTable.clear();
                    vTable.clear();
                    varibles = 0;
                    cout << "main:\n"; 
                    cout << "push ebp\n"; 
                    cout << "mov ebp, esp\n"; 
                    cout << "sub esp, 0x200\n";

                    for(; i < n; i ++)if(code_processed[i] == "{") break;
                }
                else if(code_processed[i + 2] == "("){ 
                    aTable.clear();
                    vTable.clear();
                    varibles = 0;
                    curr_namespace_return = code_processed[i];
                    i ++; 

                    int iter = i + 1; 
                    int args_cnt = 0;
                    while(iter < n && code_processed[iter] != ")"){
                        if(code_processed[iter] == "int"){
                            args_cnt ++;
                            iter ++;
                            aTable.insert({code_processed[iter], args_cnt});
                        } 
                        iter ++;
                    }
                
                    fTable.insert({code_processed[i], {args_cnt, 1}}); 
                    cout << code_processed[i] + ":\n"; 
                    cout << "push ebp\n"; 
                    cout << "mov ebp, esp\n"; 
                    cout << "sub esp, 0x100\n";

                    for(; i < n; i ++)if(code_processed[i] == "{") break;
                    
                }
                else{ 
                    int idx = i + 1, bracket = 0; 
                    deque<deque<string>> claimList;
                    deque<string> vl;
                    while(idx < n && code_processed[idx] != ";"){
                        calBracket(code_processed[idx], bracket);

                        if((code_processed[idx] == "," && bracket == 0)) {
                            claimList.push_back(vl);
                            vl.clear();    
                        }
                        else vl.push_back(code_processed[idx]);

                        idx ++;
                    }
                    if(!vl.empty())claimList.push_back(vl);

                    for(auto claim : claimList){
                        vTable.insert({claim[0], ++ varibles});
                        if(claim.size() > 1){
                            ExpressionProc(claim);
                        }
                    }
                    i = idx - 1;
                }
            }
            else if(code_processed[i] == "return"){
                deque<string> sub;
                while(i < n && code_processed[i + 1] != ";"){
                    i ++;
                    sub.push_back(code_processed[i]);
                }
        
                ExpressionProc(sub);   
                cout << "leave\nret\n\n";
            }
            else if(code_processed[i] == "}" && curr_namespace_return == "void"){
                cout << "leave\nret\n\n";
                curr_namespace_return = "";
            }
            else if(code_processed[i] == "}"){
                int doNothing;
            }
            else{ 
                deque<string> sub;
                while(i < n && code_processed[i] != ";"){
                    sub.push_back(code_processed[i ++]);
                }
                ExpressionProc(sub);
                i = i - 1;
            }
            i ++;
        }
    }
    file.close();

    return 0;
}

zy2hb
关注
怎样成为一个优秀的架构师？
AI天才研究院
10-08 17万+
怎样才算是架构师？ 架构师是一个既能掌控整体又能洞悉局部瓶颈并依据具体的业务场景给出解决方案的团队领导型人物。看似完美的“人格模型”背后，是艰辛的探索。 架构师不是一个人，他需要建立高效卓越的体系，带领团队去攻城略地，在规定的时间内完成项目。 架构师的分类 从业界来看对于架构师的理解可以大概区分为： 企业架构师：专注于企业总体 IT 架构的设计。 IT 架构师-软件产品架构...
CSDN前1000名博主
无知人生，记录点滴
05-26 8万+
博主 简介 stpeace 排名：1 原创：2166 粉丝：7180 积分：181660 等级：10stpeace的专栏中国本博客供大家交流，欢迎各抒己见。博文中的内容禁止用 yuanmeng001 排名：2 原创：5286 粉丝：10660 积分：170616 等级：10袁萌专栏无穷小微积分倡导者–北大教授null老师 yjclsx 排名：3 原创：162...
关于操作系统设计的基本原理和设计原则
tugouxp的专栏
03-09 6941
操作系统设计的精妙之处就在于，在底层硬件之上创造了新的抽象， 对于系统初始化来说， 它呈现了执行流到线程转化这一概念，该概念远远比它的实现细节更加重要，处理器以“取指-执行”为周期开始串行执行指令，而初始化代码将自身转化为一个并发处理系统， 这里的关键之处在于，初始化代码并不是创建一个独立的并发系统，然后跳转到新的系统。
【已弃用】HNU-操作系统OS-实验Lab6
wolf的博客
05-20 845
- 理解操作系统的调度管理机制 - 熟悉 ucore 的系统调度器框架，以及缺省的Round-Robin 调度算法 - 基于调度器框架实现一个(Stride Scheduling)调度算法来替换缺省的调度算法
卷积神经网络超详细介绍
热门推荐
呆呆的猫的博客
09-19 61万+
海量的有标记的训练数据，也就是李飞飞团队提供的大规模有标记的数据集ImageNet计算机硬件的支持，尤其是GPU的出现，为复杂的计算提供了强大的支持算法的改进，包括网络结构加深、数据增强（数据扩充）、ReLU、Dropout等AlexNet之后，深度学习便一发不可收拾，分类准确率每年都被刷榜，下图展示了模型的变化情况，随着模型的变深，Top-5的错误率也越来越低，目前已经降低到了3.5%左右，同样的ImageNet数据集，人眼的辨识错误率大概为5.1%，也就是深度学习的识别能力已经超过了人类。
重学OpenCV3纪要(还差卡尔曼滤波+光流追踪代码,择机更新)
sinat_30065705的博客
06-04 7269
注：本书适合有一定图像处理基础的读者，本书也不是入门读物，没有背景知识也没有详尽的公式推导，只是OpenCV3的使用手册。 1.OpenCV3函数库头文件简介 （1）opencv2/opencv.hpp：包含了所有课能用到的头文件，但是会降低编译速度，最好单独指定； （2）opencv2/core/core.hpp：c++风格的结构及数学运算； （3）opencv2/imgproc/imgproc.hpp：c++风格的图像处理函数； （4）opencv2/highgui/highgui.h..
全日制英国硕士词汇篇V1.3（持续更新）
欢迎！欢迎来到17号城市！
03-05 6万+
下面的所有词汇与例句都是在英国留学期间， 学到的、听到的、见到的，都来自英语母语使用者，其中包括： 学校、同学、教授、教职人员、以及生活中形形色色的人， 这篇文章有助于还没去英国的同学提前掌握一些高频词汇， 以便于在日后的留学生活中更加游刃有余， 对于高频词汇一定要掌握它们的听说读写，形成肌肉记忆。
OpenPLC：符合IEC 61131-3标准的用于网络安全研究的开源工业控制器
m0_37818883的博客
03-06 1万+
OpenPLC: An IEC 61,131–3 compliant open source industrial controller for cyber security research【翻译】 摘要 在过去的十年中，多次网络攻击成功地破坏了SCADA系统和plc的正常运行。为了对付这些攻击，研究人员已经努力寻找能够保护网络和可编程逻辑控制器的防御机制。然而，由于供应商不提供有关其设备硬件...
图像处理知多少？准大厂算法工程师30+场秋招后总结的面经问题详解
3D视觉工坊
06-17 2347
点击上方“3D视觉工坊”，选择“星标”干货第一时间送达作者丨灯会来源丨极市平台编辑丨极市平台极市导读本篇主要包含了图像滤波、边缘检测相关常考内容等相关面试经验。作者灯会为21届中部985...
刚刚，阿里重磅发布机器学习平台PAI 3.0！
cpongo55
03-21 475
\u003cblockquote\u003e\n\u003cp\u003e3月21日，2019 阿里云峰会在北京召开，会上阿里巴巴重磅发布了机器学习平台PAI 3.0版本。距离PAI 2.0发布已经过去了2年，阿里巴巴对PAI 3.0可以说做了相当长时间的打磨。PAI 3.0新增了许多端到端智能应用，新推出算法模型市场，涵盖电商、社交、广告、金融、娱乐、传统零售、客服、物流等多个行业，数十种场景的...
gitLabCICD
m0_50575361的博客
04-24 692
传统应用发布模式 ​ 问题： 错误发现不及时 人工低级错误 团队工作效率低 开发运维对立 引入CI/CD CI(持续集成): 合并开发人员正在开发编写的所有代码的一种做法 通常一天内进行多次合并和提交代码 从此存储库或生产环境中进行构建和自动化测试，以确保没有集成问题 CD(连续交付) 通常可以通过将更改自动推送到发布系统来随时将软件发布到生产环境中 持续部署会更进一步，并自动将更改推送到生产中 代码版本管理-gitlab 代码审查 问题跟踪 动态订阅 易于扩展 项目wiki 多角色项目管理
[转]高负载并发网站架构分析
bluehire的专栏
12-23 2万+
由于自己正在做一个高性能大用户量的论坛程序，对高性能高并发服务器架构比较感兴趣，于是在网上收集了不少这方面的资料和大家分享。希望能和大家交流 msn: defender_ios@hotmail.com ——————————————————————————————————————— ? 初创网站与开源软件 6 ? 谈谈大型高负载网站服务器的优化心得! 8 ? Lighttpd+Squid+Apach
Linux mips架构链接库函数调用plt表汇编代码分析
xuyun0565的专栏
10-15 320
linux调用共享库中的函数时通过plt表和got表实现位置无关代码，过程中涉及到lazy binding，即在第一调用外部函数时解析被调用的函数地址并将地址写入到got表，后续调用则不需要解析函数地址。这一部分和硬件架构有关，具体的是和cpu指令集相关，下面分析龙芯3a4000芯片这一块的代码，3a4000采用的是mips指令集。使用gdb调试生成的可执行程序，打断点在mian函数的第一行。x /1xg 读取0x120019010-32640位置内存。使用info registers命令查看寄存器值。
汇编实现逆序复制数据
最新发布
weixin_74461129的博客
10-18 125
使其可以将10000H ～ 1000FH中的8个字，逆序复制到20000H ～ 2000FH中。以上表示数据从源地址10000H～1000FH逆序复制到目标地址20000H～2000FH。使用循环和寄存器操作，实现了数据的逆序存放。
【算法】深入了解 CRC 校验码的计算过程
qq_20623849的博客
10-16 536
CRC（循环冗余校验，Cyclic Redundancy Check）是一种常见的错误检测方法，它通过生成冗余码来确保数据传输的可靠性。在这篇文章中，我们将探讨 CRC 码的基本原理，并详细介绍其计算过程。通过对数据进行 CRC 校验，我们可以在传输过程中检测到潜在的错误并采取适当的纠正措施。这个新的数据包在传输时，如果接收方再次计算 CRC 校验码并与附带的校验码进行比较，可以确定数据是否在传输过程中出现了错误。：将附加了零位的数据通过生成多项式进行二进制除法运算，得出的余数就是 CRC 校验码。
【算法】双指针
2303_80828380的博客
10-13 773
力扣oj题之双指针算法
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 301
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 441
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1198
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值