【模拟LeetCode项目】04 - 项目模块详解

最新推荐文章于 2022-10-16 11:44:12 发布
最新推荐文章于 2022-10-16 11:44:12 发布
阅读量388 收藏
点赞数 4
分类专栏： Project 文章标签： C++ Linux 项目 ctemplate json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45437022/article/details/114495743
版权

项目模块详解

1. http服务器模块

1.1 模块解析

该模块分为三部分：

  1. Get请求1：获取所有试题列表 请求，并将 完整试题列表 响应给客户浏览器
  2. Get请求2：获取单个试题信息 请求，并将 选定的试题信息 响应给客户浏览器
  3. Post请求：请求 返回编译运行结果，并将 编译运行结果 响应给客户浏览器

1.2 模块代码

oj_server.cpp

/*
 *  http 模块
 */
#include <stdio.h>
#include <iostream>
#include <jsoncpp/json/json.h>

#include "oj_model.hpp"
#include "httplib.h"
#include "oj_view.hpp"
#include "compile.hpp"

using namespace httplib;

int main()
{
	/* 
		1. 初始化httplib库的server对象
	*/
  Server svr;
  ojModel model;
  
  	/* 
		2. 提供三个接口，分别处理三个请求
	*/
    
	// 2.1 接口一：获取整个试题列表 
  svr.Get("/all_questions",[&model](const Request& req, Response& resp){
     // 1.返回试题列表
     std::vector<Question> questions;
     model.GetAllQuestion(&questions);
	 
     // 2.将试题列表渲染至html页面上去
     std::string html;
     OJView::DrawAllQuestions(questions, &html);
     resp.set_content(html, "text/html");	//设置响应体
     });

  // 2.2 接口二：获取单个试题
  //  如何表示浏览器想要获取的是哪一个试题？
  //  使用正则表达式解决点击题目后自动跳转至对应的URL
  //  \d表示数字0-9
  //  \d+表示多位数字
  svr.Get(R"(/question/(\d+))",[&model](const Request& req, Response& resp){
      // 1.获取url当中关于试题的数字 & 获取单个试题的信息
      // matches[1]返回的是题目id，并不是一个string
      //std::cout << req.matches[1] << std::endl;
      Question ques;
      // 通过试题数字(id)进而获取试题信息
      model.GetOneQuestion(req.matches[1].str(),&ques); 
      
      // 2.渲染模板的html文件
      std::string html;
      OJView::DrawOneQuestion(ques, &html);  
      
      resp.set_content(html, "text/html");	//设置响应体
      });

  // 2.3 接口三：解释运行
  // 目前还没有区分到底是提交的是哪一个试题
      // 1.获取试题编号
      // 2.通过 试题编号 进而获取 题目内容 填充到ques中
      // 3.用户点击submit后从浏览器获取代码，将代码进行decode -> code
      // 4.将代码与tail.cpp合并:code + tail.cpp -> src文件 
      // 5.编译模块进行编译：
      //  编译src文件的技术：子进程创建，使用子进程程序替换成为"g++"来编译源码文件
      //    成功:
      //    失败:
      //  运行变异后的文件技术:子进程创建，使用子进程程序替换成为编译出来的可执行程序
      //    成功：
      //    失败:
  svr.Post(R"(/compile/(\d+))",[&model](const Request& req, Response& resp){
      // 1.获取题目id ---> ques_id 
      std::string ques_id = req.matches[1].str();
      
      // 2.获取题目内容 ---> ques 
      Question ques;
      model.GetOneQuestion(ques_id,&ques); 

      // 3.获取代码内容 ---> code 
      /*  
      以下注释中的代码容错率较低，如果代码中用户代码中出现=，就无法处理 
      std::vector<std::string> vec;
      StringUtil::Split(UrlUtil::UrlDecode(req.body), "=", &vec);
      std::string code = vec[1]; 
      */
      std::unordered_map<std::string, std::string> body_kv;
      UrlUtil::PraseBody(req.body, &body_kv);
      
      // 4.获取完整源文件code + tail.cpp ---> src
      std::string src = body_kv["code"] + ques.tail_cpp_;

      /*
       * 构造JSON对象
       */ 
      Json::Value req_json;
      req_json["code"] = src;
      req_json["stdin"] = "";
      //std::cout << req_json["code"].asString() << std::endl;
      
      // 获取的返回结果都在resp_json中
      Json::Value resp_json;
      Compiler::CompileAndRun(req_json, &resp_json);
      std::string case_result = resp_json["stdout"].asString();
      std::string reason = resp_json["reason"].asString();
      
      std::string html;	//用于返回的响应内容
      OJView::DawCaseResult(case_result, reason, &html);	// 将case_result和reason填充入html中

      resp.set_content(html, "text/html");	//设置响应体
      });

  // LOG(INFO, "17878") << ":" << std::endl;
  svr.set_base_dir("./www");
  svr.listen("0.0.0.0",18989);
  return 0;
}

2. 试题模块

2.1 模块解析

image-20210306093140377

  • oj_config.cfg：记录了所有试题的重要信息，可根据该文件能让找到对应试题

  • 试题的所有信息都被存储在文件中

2.2 模块代码

oj_model.hpp

/*
 *  试题模块
 */
#pragma once 
#include <iostream>
#include <string>
#include <unordered_map>
#include <fstream>
#include <vector>
#include <boost/algorithm/string.hpp>
#include "tools.hpp"


//一道试题需要哪些属性来描述？
struct Question
{
    std::string id_;    // 题目ID
    std::string title_;//题目名称
    std::string star_;//题目的难易程度
    std::string path_;//题目的路径

    std::string desc_;  //题目的描述
    std::string header_cpp_; //题目预定义的头
    std::string tail_cpp_; //题目的尾，包含测试用例以及调用逻辑
};

// 从磁盘中加载题目，给用户提供接口查询
class ojModel
{
    private:
    std::unordered_map<std::string, Question> ques_map_;  //题目ID和内容
    public:
    ojModel()
    {
        //从配置文件中获取试题信息
        load("./oj_data/oj_config.cfg"); 
    }
    ~ojModel()
    {

    }
    //从文件中获取试题信息
    bool load(std::string filename)
    {
        std::ifstream file(filename.c_str());
        if(!file.is_open())
        {
            std::cout << "config file open failed!" << std::endl;
            return false;
        }
        // 1.打开文件成功的情况
        //  1.1 从文件中获取每一行信息
        //    1.1.1 对于每一行信息，还需要 获取 题号、题目名称、题目难易程度、题目路径
        //    1.1.2 保存在Question结构体中
        // 2.把多个question组织在map中

        std::string line;
        while(std::getline(file, line))
        {
            //使用Boost库中的split函数:按照空格进行切割
            std::vector<std::string> vec;
            StringUtil::Split(line, "\t", &vec);
            // is_any_of:支持多个字符作为分隔符
            // token_compress_off:是否将多个分割字符看做是一个
            //boost::split(vec, line, boost::is_any_of(" "), boost::token_compress_off);
			
            Question ques;
            ques.id_ = vec[0];
            ques.title_ = vec[1];
            ques.star_ = vec[2];
            ques.path_ = vec[3];
            std::string dir = vec[3];
            FileUtil::ReadFile(dir + "/desc.txt",&ques.desc_);
            FileUtil::ReadFile(dir + "/header.cpp",&ques.header_cpp_);
            FileUtil::ReadFile(dir + "/tail.cpp",&ques.tail_cpp_);

            ques_map_[ques.id_] = ques;
        }
        file.close();
        return true;
    }
    // 提供给上层调用者一个获取所有试题的接口
    bool GetAllQuestion(std::vector<Question>* questions)
    {
        // 1.遍历无序的map,将试题信息返回给调用者
        // 对于每一个试题，都是一个Question结构体对象
        for(const auto& kv : ques_map_)
        {
            questions->push_back(kv.second);  // 此时，questions中保存的便是 所有的试题信息
        }
        // questions中试题的顺序并不是按顺序保存的，所以需要 调整顺序
        // 对试题进行 排序
        sort(questions->begin(),questions->end(),[](const Question& l, const Question& r){
            //升序:比较Question中的题目编号:将string->int
            return std::stoi(l.id_) < std::stoi(r.id_);
        });
    }
    // 提供给上层调用者一个获取单个试题的接口
    // id：待查找题目的id
    // ques：是输出参数，将查到的结果返回给调用者
    bool GetOneQuestion(const std::string& id, Question* ques)
    {
        auto it = ques_map_.find(id);
        if(it == ques_map_.end())
        {
            return false;
        }
        *ques = it->second;
        return true;
    }
};

3. 编译运行模块

3.1 模块解析

  • 将 从网页中获得的代码 和 头文件 和 测试文件 组装成一个 源文件
  • ,产生的源文件的命名方式为tmp_时间戳_变量值.cpp，
    • 时间戳是用于区分不同时间创建出来的文件
    • 变量值是用于区分 高并发情况 下产生的 时间戳相同 的情况下 区分文件
  • 使用进程程序替换对源文件进行编译和运行，对运行时间和资源限制以防止死循环等
  • 根据编译与运行结果，设置json对象，通过KV形式将错误码(K)和理由(V)返回给post请求的回调函数中

compile.hpp

/*
 *  编译运行模块
 */
#pragma once 
#include <atomic>
#include <iostream>
#include <string>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/resource.h>
#include <jsoncpp/json/json.h>
#include "tools.hpp"

enum errorno
{
    OK = 0,
    PRAM_ERROR,   //参数错误
    INTERNAL_ERROR, //内部错误
    COMPILE_ERROR,  //编译错误
    RUN_ERROR //运行错误
};

class Compiler{
    public:
    /* 参数解释：
     * Json::Value Req 请求的json
     *    { "code":"xxx", "stdin":"xxx" }
     *  Json::Value* Resp 出参，返回给调用者
     *    { "errorno":"xx", "reason":"xxx" }
     */ 
    static void CompileAndRun(Json::Value Req, Json::Value* Resp)
    {
        // 1.参数是否错误
        if(Req["code"].empty())
        {
            (*Resp)["errorno"] = PRAM_ERROR;
            (*Resp)["reason"] = "Pram error";
            return;
        }
        // 2.将代码写到文件里面 文件命名规则：tmp_时间戳_变量值.cpp
        //    时间戳：用于区分不同时间创建出来的文件
        //    变量值：用于区分 高并发情况 下产生的 时间戳相同 的情况下 区分文件
        std::string code = Req["code"].asString();
        std::string file_nameheader = WriteTmpFile(code); 
        if(file_nameheader == "") //写文件失败
        {
            (*Resp)["errorno"] = INTERNAL_ERROR;
            (*Resp)["reason"] = "write file failed";
            return ;
        }
        // 3.编译
        if(!Compile(file_nameheader))
        {
            (*Resp)["errorno"] = COMPILE_ERROR;
            std::string reason;
            FileUtil::ReadFile(CompileErrorPath(file_nameheader).c_str(),&reason);
            (*Resp)["reason"] = reason;
            return ;
        }

        // 4.运行
        // -1 -2   >0
        int ret = Run(file_nameheader);
        if(ret != 0)
        {
            (*Resp)["errorno"] = RUN_ERROR;
            std::string reason = "program exit by sig:" + std::to_string(ret);
            (*Resp)["reason"] = reason;
            return ;
        }

        // 5.构造响应
        (*Resp)["errorno"] = OK;
        (*Resp)["reason"] = "Compile and Run OK";

        std::string stdout_str;
        FileUtil::ReadFile(stdoutPath(file_nameheader).c_str(), &stdout_str);
        (*Resp)["stdout"] = stdout_str;

        std::string stderr_str; 
        FileUtil::ReadFile(stderrPath(file_nameheader).c_str(), &stderr_str);
        (*Resp)["stderr"] = stderr_str;

        // 6.删除临时文件
        clean(file_nameheader); 

        return ;
    }

    private:
    static void clean(const std::string& file_name)
    {
        unlink(SrcPath(file_name).c_str());
        unlink(CompileErrorPath(file_name).c_str());
        unlink(stdoutPath(file_name).c_str());
        unlink(stderrPath(file_name).c_str());
        unlink(ExePath(file_name).c_str());
    }

    static int Run(const std::string& file_name)
    {
        // 1.创建子进程
        int pid = fork();
        // 2.父进程进行进程等待，子进程进行进程程序替换
        if(pid < 0)
        {
            return -1;
        }
        else if(pid > 0)
        {
            int status;
            waitpid(pid,&status,0);
            return status & 0x7f;
        }
        else 
        {
            // 注册一个定时器,防止用户提交的代码中含有死循环等长时间运行
            alarm(1);
            // 限制进程使用的资源
            struct rlimit rlim;
            rlim.rlim_cur = 30000 * 1024; // 3wk
            rlim.rlim_max = RLIM_INFINITY;
            setrlimit(RLIMIT_AS, &rlim);

            int stdout_fd = open(stdoutPath(file_name).c_str(), O_CREAT | O_WRONLY, 0666);
            if(stdout_fd < 0)
            {
                return -2;
            }
            dup2(stdout_fd,1);

            int stderr_fd = open(stderrPath(file_name).c_str(), O_CREAT | O_WRONLY, 0666);
            if(stderr_fd < 0)
            {
                return -2;
            }
            dup2(stderr_fd, 2);

            execl(ExePath(file_name).c_str(), ExePath(file_name).c_str(), NULL);
            exit(0);
        }
        return 0;
    }

    static bool Compile(const std::string file_name)
    {
        // 1.创建子进程 
        int pid = fork();
        // 2.父进程进行进程等待，子进程进行进程程序替换
        if(pid > 0)
        {
            waitpid(pid,NULL,0);
        }
        else if(pid == 0)
        {
            int fd = open(CompileErrorPath(file_name).c_str(), O_CREAT | O_WRONLY, 0666);
            if(fd < 0)
            {
                return false;
            }
            dup2(fd,2);// 将标准错误重定向为fd，标准错误的输出，将会被输出在文件当中

            // 进行进程程序替换成g++ SrcPath(file_name) -o ExePath(file_name) -std=c++11
            execlp("g++","g++",SrcPath(file_name).c_str(),"-o",ExePath(file_name).c_str(),"-std=c++11","-D","CompileOnline",NULL);

            close(fd);
            exit(0);
        }
        else 
        {
            return false;
        }
        // 如果替换失败了，就要返回false，判断失败的标准：是否产生了可执行文件
        // 使用stat函数查看可执行文件属性
        struct stat st;
        int ret = stat(ExePath(file_name).c_str(), &st);
        if(ret < 0)
        {
            return false;
        }
        return true;
    }


    static std::string stdoutPath(const std::string& filename)
    {
        return "./tmp_file/" + filename + "_stdout";
    }
    static std::string stderrPath(const std::string& filename)
    {
        return "./tmp_file/" + filename + "_stderr";
    }


    // 获取编译错误文件路径
    static std::string CompileErrorPath(const std::string& filename)
    {
        return "./tmp_file/" + filename + "_compil_err_info";
    }
    // 编译好的文件路径
    static std::string ExePath(const std::string& filename)
    {
        return "./tmp_file/" + filename + "_executable";
    }

    // 获取源文件路径和文件名 
    static std::string SrcPath(const std::string& filename)
    {
        return "./tmp_file/" + filename + ".cpp";
    }

    static std::string WriteTmpFile(const std::string& code)
    {
        // 1.组织文件名称，区分源码文件，以及后面生成的可执行文件
        static std::atomic_uint id(0);
        std::string tmp_filename = "tmp_" + std::to_string(TimeUtil::GetTimeStampMs()) + "_" + std::to_string(id);
        id++;
        // 2.将code写入文件中
        FileUtil::WriteFile(SrcPath(tmp_filename), code);
        return tmp_filename;
    }
};

4. 工具类模块

4.1 模块解析

工具类OJView：使用谷歌模板分离技术(ctemplate)将预定义好的html源码进行填充

  1. 将用户请求的 试题列表 渲染至响应界面上
  2. 将用户请求的 单个试题信息 渲染至响应界面上
  3. 用户请求的 代码运行结果 渲染至响应界面上

类FileUtil：根据文件名来读取文件或者写入文件

类StringUtil：用于字符串分割

类UrlUtil：用于对URL中Key1=Value1&Key2=Value2的字符串进行解码

类TimeUtil：获取时间戳

全局函数log：用于输出日志

4.2 模块代码

oj_view.hpp

/*
 *  工具类OJView：用于渲染HTML响应界面
 */
#pragma once 
#include <iostream>
#include <vector>
#include "ctemplate/template.h"
#include "oj_model.hpp"
// 该文件用于填充模板

class OJView
{
  public:
	/*
		DrawAllQuestions：渲染 试题列表 至响应页面上
	*/
    static void DrawAllQuestions(std::vector<struct Question>& questions, std::string* html)
    {
      // 1.创建template字典
      ctemplate::TemplateDictionary dict("all_questions");
      // 2.遍历vector，每一个试题构造成一个字典
      for(auto& ques : questions)
      {
        ctemplate::TemplateDictionary* sub_dict = dict.AddSectionDictionary("question");
        sub_dict->SetValue("id", ques.id_);
        sub_dict->SetValue("id",ques.id_);
        sub_dict->SetValue("title",ques.title_);
        sub_dict->SetValue("star",ques.star_);
      }
      // 3.填充
      ctemplate::Template* tl = ctemplate::Template::GetTemplate("./template/all_questions.html", ctemplate::DO_NOT_STRIP);
      // 4.渲染
      tl->Expand(html, &dict);
    }
    
	/*
		DrawOneQuestion：渲染 用户选中的单个试题信息 至响应页面上
	*/
    static void DrawOneQuestion(const Question& ques, std::string* html)
    {
      ctemplate::TemplateDictionary dict("question");
      dict.SetValue("id", ques.id_);
      dict.SetValue("title", ques.title_);
      dict.SetValue("star", ques.star_);
      dict.SetValue("desc", ques.desc_);
      dict.SetValue("id", ques.id_);
      dict.SetValue("code", ques.header_cpp_);
      // 填充
      ctemplate::Template* tl = ctemplate::Template::GetTemplate("./template/question.html", ctemplate::DO_NOT_STRIP);
      // 渲染
      tl->Expand(html, &dict);
    }
	
	/*
		DawCaseResult：渲染 提交运行返回信息 至响应页面上
	*/
    static void DawCaseResult(const std::string& q_result, const std::string& reason, std::string* html)
    {
      ctemplate::TemplateDictionary dict("question");
      dict.SetValue("compile_result", reason);
      dict.SetValue("case_result", q_result);
      ctemplate::Template* tl = ctemplate::Template::GetTemplate("./template/case_result.html", ctemplate::DO_NOT_STRIP);
      // 渲染
      tl->Expand(html, &dict);
    }

};//class end

tools.hpp

#pragma once 
#include <string>
#include <iostream>
#include <fstream>
#include <sys/time.h>
#include <string>
#include <vector>
#include <boost/algorithm/string.hpp>
#include <unordered_map>
class FileUtil
{
    public:
    // 读文件接口 + 写文件接口

    //filename:文件名称
    //content:读取到的内容，输出型参数
    static bool ReadFile(const std::string& file_name, std::string* content)
    {
        content->clear();
        std::ifstream file(file_name.c_str());
        if(!file.is_open())
        {
            return false;
        }
        std::string line;
        while(std::getline(file, line))
        {
            (*content) += line + "\n";
        }
        file.close();
        return true;
    }

    static bool WriteFile(const std::string& filename, const std::string data)
    {
        std::ofstream file(filename.c_str());
        if(!file.is_open())
            return false;
        file.write(data.c_str(), data.size());
        file.close();
        return true;
    }
};

class StringUtil{
    public:
    static void Split(const std::string& input, const std::string split_char, std::vector<std::string>* output)
    {
        boost::split(*output, input, boost::is_any_of(split_char), boost::token_compress_off);
    }
};

class UrlUtil
{
    public:

    //body从httplib.h当中的request类的成员变量获得
    //  body:
    //     key=value&key1=value1   ===> 并且是进行过编码
    //  1.先切割
    //  2.在对切割之后的结果进行转码
    static void PraseBody(const std::string& body, std::unordered_map<std::string, std::string>* body_kv)
    {
        std::vector<std::string> kv_vec;
        StringUtil::Split(body, "&", &kv_vec);

        for(const auto& t : kv_vec)
        {
            std::vector<std::string> sig_kv;
            StringUtil::Split(t, "=", &sig_kv);

            if(sig_kv.size() != 2)
            {
                continue;
            }

            //在保存的时候， 针对value在进行转码
            (*body_kv)[sig_kv[0]] = UrlDecode(sig_kv[1]);
        }
    }

    static unsigned char ToHex(unsigned char x)   
    {   
        return  x > 9 ? x + 55 : x + 48;   
    }  

    static unsigned char FromHex(unsigned char x)   
    {   
        unsigned char y;  
        if (x >= 'A' && x <= 'Z') y = x - 'A' + 10;  
        else if (x >= 'a' && x <= 'z') y = x - 'a' + 10;  
        else if (x >= '0' && x <= '9') y = x - '0';  
        else assert(0);  
        return y;  
    }  

    static std::string UrlEncode(const std::string& str)  
    {  
        std::string strTemp = "";  
        size_t length = str.length();  
        for (size_t i = 0; i < length; i++)  
        {  
            if (isalnum((unsigned char)str[i]) ||   
                (str[i] == '-') ||  
                (str[i] == '_') ||   
                (str[i] == '.') ||   
                (str[i] == '~'))  
                strTemp += str[i];  
            else if (str[i] == ' ')  
                strTemp += "+";  
            else  
            {  
                strTemp += '%';  
                strTemp += ToHex((unsigned char)str[i] >> 4);  
                strTemp += ToHex((unsigned char)str[i] % 16);  
            }  
        }  
        return strTemp;  
    }  

    static std::string UrlDecode(const std::string& str)  
    {  
        std::string strTemp = "";  
        size_t length = str.length();  
        for (size_t i = 0; i < length; i++)  
        {  
            if (str[i] == '+') strTemp += ' ';  
            else if (str[i] == '%')  
            {  
                assert(i + 2 < length);  
                unsigned char high = FromHex((unsigned char)str[++i]);  
                unsigned char low = FromHex((unsigned char)str[++i]);  
                strTemp += high*16 + low;  
            }  
            else strTemp += str[i];  
        }  
        return strTemp;  
    } 
};

//获取时间戳
class TimeUtil
{
    public:
    static int64_t GetTimeStampMs()
    {
        struct timeval tv;
        gettimeofday(&tv, NULL);
        return tv.tv_sec + tv.tv_usec / 1000;
    }

    // 获取年月日时分秒的时间戳
    static void GetTimeStamp(std::string* TimeStamp)
    {
        time_t st;
        time(&st);

        struct tm* t = localtime(&st);
        char buf[30] = {'\0'};
        snprintf(buf,sizeof(buf) - 1, "%04d-%02d-%02d %02d:%02d:%02d",t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min,  t->tm_sec);
        TimeStamp->assign(buf,strlen(buf));
    }
};

// 使用枚举值拿到对应字符串
enum logLevel
{
    INFO = 0,
    WARNING,
    ERROR,
    FATAL,
    DEBUG
};
const char* level[] = 
{
    "INFO",
    "WARNING",
    "ERROR",
    "FATAL",
    "DEBUG"
};

/*
 * lev : 日志等级
 * file：文件名称
 * line：行号
 * logmsg:想要记录的日志内容 
 */
std::ostream& log(logLevel lev, const char* file,int line, const std::string& logmsg)
{
    std::string level_info = level[lev];
    std::string TimeStamp;
    TimeUtil::GetTimeStamp(&TimeStamp);
    std::cout << "[" << TimeStamp << " " << level_info << " " << file << ":" << line << "]" << " " << logmsg;
    return std::cout;
}
#define LOG(lev, msg) log(lev, __FILE__, __LINE__, msg)

4.3 待填充html模板文件源码

HTML源码中{}中的字符串是可以使用ctemplate中的TemplateDictionary中的字段来进行替换的

all_questions.html

<html>
    <head>
        <meta http-equiv="content-type" content="text/html;charset=utf-8">
    </head>
    <body>
        {{#question}}
        <div>
            <a href="/question/{{id}}">
                {{id}}.{{title}}({{star}})
            </a>
        </div>
        {{/question}}
    </body>
</html>

question.html

<html>
    <head>
        <meta http-equiv="content-type" content="text/html;charset=utf-8">
    </head>
    <body>
        <div>
            {{id}}.{{title}}({{star}})
        </div>
        <div>
            <pre>
            {{desc}}
            </pre>
        </div>
        <div>
            <form action="/compile/{{id}}" method="post">
                <textarea name="code" rows=30 cols=100>{{code}}</textarea>
                <br>
                <textarea name="stdin" rows=30 cols=100>hello</textarea>
                <input type="submit" value="Submit">
            </form>
        </div>
    </body>
</html>

case_result.html

<html>
    <head>
        <meta http-equiv="content-type" content="text/html;charset=utf-8">
    </head>
    <body>
        <div><pre>error_no : {{errno}}</pre></div>
        <div><pre>{{compile_result}}</pre></div>
        <div><pre>{{case_result}}</pre></div>
    </body>
</html>

5. 项目模块间调用逻辑结构

在这里插入图片描述

代码被吃掉了
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
离线和leetcode-leetcode-cli-2.6.1:leetcode-cli-2.6.1
07-06
leetcode-cli 一个享受 leetcode 的高效 cli 工具！ 非常感谢 leetcode.com，一个非常棒的网站！ ⦙⦙⦙⦙⦙⦙⦙⦙ 一个很打问题的方法。 问题来缓解离线思考。 编码前的源代码。 居住和与 leetcode.com。 下载你...
Boost::split
Guarder_7的博客
05-26 469
boost::split(temp_path, strExeOriginPath, boost::is_any_of("\"), boost::token_compress_on); 作用：将strExeOriginPath字符串进行分割，分割标识符为"\"，boost::token_compress_on的作用是除去由"\"分割产生的空格，默认情况下是boost::token_compress_off。 对于场景：string s = “123456”，用"3",“4"切分，默认情况下（boost::to
boost 字符串处理(1)
crazycooler的专栏
10-27 959
一.从split开始string str1("hello abc-*-ABC-*-aBc goodbye"); vector<string> SplitVec; //结果 split(SplitVec, str1, is_any_of("-*"), token_compress_on);1.首先讨论最简单的一个参数token_compress_on，为一个枚举类型namespace boost {
Boost中string的split用法
jianxiong1985的博客
11-25 1919
头文件 boost/algorithm/string/split.hpp 作用 string的split包括如下API find_all：在字符串string str中查找string sub，返回找到的所有的 sub。 ifind_all：在字符串string str中查找string sub，同时忽略大小，返回找到的所有的 sub。 split：将字符串按照某些条件，进行分割，返...
项目中一个模块的意思：一组功能的集合
weixin_47414034的博客
10-16 768
将项目分成几个模块，每个模块中有不同的功能：比如有五个模块：用户模块，商品模块，支付模块，消息模块，个人中心模块：主要提供用户注册功能、用户登录功能、获取验证码功能、忘记密码功能：商品交易支付功能：查看消息列表功能，与商品发布者/商品购买者即时聊天功能：个人信息管理功能，商品管理功能。
MAVEN项目模块化
w2865673691的专栏
08-13 4661
maven的最大的特点之一就是可以把项目模块化。 前面的一篇文章MAVEN创建并打包web项目已经创建了一个简单的webapp，注意这个webapp的打包方式是war。如果现在又要划分出来一个模块，而webapp依赖这个新划分的模块，应该怎么做呢，磨叽！ 首先创建一个maven module，它的parent是test，不能是其他的，因为只有test的打包方式是pom。如下图所示：
leetcode列表题目-leetcode-suggested-reading:通过标题相似度计算geeksforgeeks.org针对lee
06-30
该项目建议 geeksforgeeks.org 上的文章阅读 leetcode.com 上的每个问题。 这个怎么运作 它通过获得相似度得分来工作，更具体地说，是两个标题的余弦相似度。 来自两个站点的标题以 json 格式存储在data目录中。 ...
leetcode答案-Leetcode---DataBase:Leetcode---数据库
06-30
leetcode 答案Leetcode---数据库 我对 Leetcode 数据库问题的回答
leetcode-leetcode-cli-plugins:leetcode-cli的第3方插件
06-29
leetcode-cli-plugins leetcode-cli 的第 3 方插件。 什么是 如何使用 如何使用 插件 名称 描述 增强的命令 按公司或标签过滤问题 list 不要在同一台计算机上使 Chrome 的会话过期 login 不要在同一台计算机上使 ...
leetcode不会-leetcode-sprint-bot:leetcode-sprint-bot
06-30
不会leetcode-sprint-bot 简单的 Discord 机器人，它根据难度标签产生随机的 leetcode 问题。 当前时间表： 每个工作日一个简单的问题； 每周一和周三一道中等题； 每周一一道难题； 它还提供了在 leetcode 上评估...
leetcodepushfront-leetcode:我的leetcode项目
07-07
leetcode push front leetcode 68 - II. 二叉树的最近公共祖先 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 68 - I. 二叉搜索树的最近公共祖先 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 67. 把字符串转换成整数 写一个函数 StrToInt，实现把字符串转换成整数这个功能。不能使用 atoi 或者其他类似的库函数。 判断字符串是否为数字： s.isdigit() 66. 构建乘积数组 给定一个数组 A[0,1,…,n-1]，请构建一个数组 B[0,1,…,n-1]，其中 B 中的元素 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]。不能使用除法。 65. 不用加减乘除做加法 写一个函数，求两个整数之和，要求在函数体内不得使用 “+”、“-”、“*”、“/” 四则运算符号。 64. 求1+2+…+n 求 1+2+...+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。 $\color{red}{62}$. 圆
leetcode中文版-leetcode-cheat:leetcode-cheat的发布
06-29
leetcode-cheat 的发布 它是什么 ？ 这是一个chrome 扩展，可以帮助您更高效地使用 leetcode。您可以从 重要: leetcode-cheat 现在只支持中文版。 也就是说不完全支持leetcode.com，但是你可以用leetcode-cn.com代替...
leetcodepython001-leetcode-problems-crawler:leetcode-问题-爬虫
07-01
leetcode-问题-爬虫 目录由cd problems && npx leetcode-problems-crawler -r 1-10生成cd problems && npx leetcode-problems-crawler -r 1-10 用法 爬行问题1到5： $ npx leetcode-problem-crawler -r 1-5 爬行问题...
leetcode296-leetcode-in-python:leetcode-in-python
06-30
章leetcode-in-python 概述 这是一个 repo，包含我在项目中使用我的 python 解决方案得出的算法问题的实践。 : 算法题复习方法总结 力扣问题列表 非 LeetCode 问题列表 在此存储库中搜索 我通过向每个源文件添加元来...
leetcode答案--leetcode-:-leetcode-
06-30
leetcode 答案 -leetcode- leetcode刷题指南 不只是答案 更多的是过程 更重要的是纠错的过程
【输入输出篇】Leetcode算法刷题心得
轻舟的万重重山
06-14 1311
二、 A+B（2） 三、A+B（3） 四、A+B（4） 五、A+B（5） 六、A+B（6） 七、字符串排序（1） 八、字符串排序（2） 九、字符串排序（3）
boost 拆分字符串
火苗999℃的博客
11-09 953
boost 拆分字符串例子：Function template splitSynopsisDescriptionParameters:InputPredResulteCompressReturns: 例子： std::vector<std::string> ipsVec; ips="192.168.1.4;192.168.1.5;192.168.1.6;"; boost::split(ipsVec, ips, boost::is_any_of(";")); Function template
Java 6-1 项目模块化-概念
开发以大橘为重
06-05 689
Java项目模块化概念
算法有救了 leetcode上神仙项目手把手带你刷算法，Star数已破110k
m0_64435718的博客
03-05 176
算法有救了！！！ 前不久在leetcode出现了一个手把手带你刷 算法的项目：fucking-algorithm。该项目此前在leetcode开源后，连续多次霸榜首页，用了一周Star数便突破 110k，受欢迎程度由此可见一斑： 仓库作者 labuladong 最先提出「刷题要掌握模板和套路」的观点，刷题就是应对面试拿 offer，再也别整什么《算法导论》这种花里胡哨的了。 还在为动态规划的一系列问题发愁吗？书中给动态规划总结出了一套框架模板，还有整整一个章节教你如何套模板做题，这是用套路解决背包
leetcoder题目java_LeetCode算法题-Toeplitz Matrix（Java实现）
最新发布
05-29
好的，您的问题是关于 `Toeplitz Matrix` 这道 LeetCode 算法题的 Java 实现。这道题的题目描述是给定一个矩阵，判断该矩阵是否为 Toeplitz 矩阵。Toeplitz 矩阵指的是从左上角到右下角的对角线上的元素都相等。 下面是该题的 Java 实现代码： ```java class Solution { public boolean isToeplitzMatrix(int[][] matrix) { int m = matrix.length; int n = matrix[0].length; for (int i = 1; i < m; i++) { for (int j = 1; j < n; j++) { if (matrix[i][j] != matrix[i-1][j-1]) { return false; } } } return true; } } ``` 该代码的实现思路是对于矩阵中每个元素，判断其是否与左上角的元素相等，如果有一个元素不相等，则该矩阵不是 Toeplitz 矩阵。 希望可以帮到您。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值