CN112148609A - Method for measuring codes submitted in online programming test - Google Patents
Method for measuring codes submitted in online programming test Download PDFInfo
- Publication number
- CN112148609A CN112148609A CN202011038003.6A CN202011038003A CN112148609A CN 112148609 A CN112148609 A CN 112148609A CN 202011038003 A CN202011038003 A CN 202011038003A CN 112148609 A CN112148609 A CN 112148609A
- Authority
- CN
- China
- Prior art keywords
- code
- nodes
- codes
- node
- same
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 32
- 238000012360 testing method Methods 0.000 title description 39
- 238000005259 measurement Methods 0.000 claims abstract description 32
- 238000001514 detection method Methods 0.000 claims abstract description 13
- 230000008569 process Effects 0.000 claims abstract description 12
- 238000007781 pre-processing Methods 0.000 claims abstract description 10
- 238000012545 processing Methods 0.000 claims abstract description 9
- 238000000691 measurement method Methods 0.000 claims abstract 2
- 238000004364 calculation method Methods 0.000 claims description 16
- 238000004458 analytical method Methods 0.000 claims description 11
- 230000001174 ascending effect Effects 0.000 claims description 3
- 238000010276 construction Methods 0.000 claims description 3
- 238000001914 filtration Methods 0.000 claims description 3
- 238000013442 quality metrics Methods 0.000 claims description 3
- 206010013911 Dysgeusia Diseases 0.000 claims description 2
- 230000001149 cognitive effect Effects 0.000 claims description 2
- 230000008676 import Effects 0.000 claims description 2
- 238000011161 development Methods 0.000 description 8
- 230000018109 developmental process Effects 0.000 description 8
- 230000006870 function Effects 0.000 description 8
- 238000011990 functional testing Methods 0.000 description 3
- 238000009877 rendering Methods 0.000 description 3
- 230000008859 change Effects 0.000 description 2
- 230000009467 reduction Effects 0.000 description 2
- 238000013459 approach Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 239000012141 concentrate Substances 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 239000012467 final product Substances 0.000 description 1
- 238000003780 insertion Methods 0.000 description 1
- 230000037431 insertion Effects 0.000 description 1
- 238000012966 insertion method Methods 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000002452 interceptive effect Effects 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000002085 persistent effect Effects 0.000 description 1
- 239000000047 product Substances 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000011524 similarity measure Methods 0.000 description 1
- 230000033772 system development Effects 0.000 description 1
- 238000010998 test method Methods 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3604—Software analysis for verifying properties of programs
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/194—Calculation of difference between files
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/20—Natural language analysis
- G06F40/253—Grammatical analysis; Style critique
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Physics & Mathematics (AREA)
- Artificial Intelligence (AREA)
- Health & Medical Sciences (AREA)
- Audiology, Speech & Language Pathology (AREA)
- Computational Linguistics (AREA)
- General Health & Medical Sciences (AREA)
- Quality & Reliability (AREA)
- Computer Hardware Design (AREA)
- Software Systems (AREA)
- Stored Programmes (AREA)
Abstract
A measurement method for codes submitted in an online programming examination utilizes SonarQube to measure the quality of the codes and obtain data results, and obtains the quality measurement data of a project through a packaged SonarQube API and displays the quality measurement data to a front-end page; comparing the code with other codes through a code similarity detection algorithm and displaying the repeated condition to a front-end page; the process of comparing the code with other codes is: preprocessing the acquired code, generating an abstract syntax tree for the processed code, processing the syntax tree and converting the syntax tree into a linear structure, calculating the similarity of the linear structure, displaying the result and the like.
Description
Technical Field
The invention belongs to the technical field of software code analysis, and particularly relates to code repetition rate measurement and code quality measurement aiming at Java language in code analysis. The method aims to provide a quality measurement result of the code and a code repetition rate check condition for a code writer (student) and a code detector (teacher), so that the quality of capability detection of the code writer is improved, and whether the code is plagiarized or not is judged.
Technical Field
In the existing online programming examination system, the feedback of the programming behavior of the student and the written code only judges the correctness of the programming behavior and the written code by combining test cases, and some quality attributes of the student code, such as maintainability, complexity and the like, cannot be measured. And the online examination enables the teacher not to participate in the examination reading process, and only pays attention to how many test cases the student passes, namely the final examination score. This makes it difficult to detect if there is code plagiarism in a student during an examination. Through code quality measurement, the quality attribute of the written code can be known in time, so that a good programming habit is developed, the programming skill and capability of the user are improved, and the examination becomes an important link of learning.
The code copied by the student can not effectively reflect the real level of the student in the programming examination on one hand, and is very unfavorable for the ability growth of the student on the other hand. Therefore, the code similarity measurement is also an extremely important link in the teaching process. Generally, in the process of performing similarity measurement, if n codes are submitted, two-by-two comparison, that is, n (n-1)/2 comparisons are performed to complete the code measurement. The number of people in one examination in a computer-related course usually reaches one or two hundred. This means that thousands or even tens of thousands of comparisons are required to check the similarity between all student codes in a test. In this case, it is time-consuming, labor-consuming and impractical to use manual alignment.
Disclosure of Invention
The invention aims to solve the existing problems: a method of code metrics includes a code quality metric and a code repetition rate metric. The invention mainly provides a measuring method for codes submitted in an online programming test.
The technical scheme of the invention is that a measuring method for codes submitted in an online programming examination and data result display mainly comprise the following processes: and performing code quality measurement by utilizing the SonarQube and acquiring a data result, and acquiring quality measurement data of the project by the packaged SonarQube API and displaying the quality measurement data to a front-end page.
And performing quality measurement on the code and acquiring a data result, namely performing similarity measurement on the code and acquiring the data result, namely comparing the code with other codes through a code similarity detection algorithm and displaying the repeated condition to a front-end page.
The process of comparing the code with other codes is: preprocessing the acquired code, generating an abstract syntax tree for the processed code, processing the syntax tree and converting the syntax tree into a linear structure, calculating the similarity of the linear structure, displaying the result and the like.
The invention has the characteristics that: 1. and performing code quality measurement by utilizing the SonarQube, acquiring quality measurement data of the project through a packaged SonarQube API, and displaying the quality measurement data to a front-end page and other 2 characteristics. 2. The method comprises the following steps of preprocessing the acquired code, generating an abstract syntax tree for the processed code, processing and converting the syntax tree into a linear structure, calculating the similarity of the linear structure, displaying the result and other 5 characteristics.
The invention has the beneficial effects that: the code writer can be guided to check various index metrics and quality attributes of the code, and the code is subjected to repetition rate measurement, so that code plagiarism is reduced.
Drawings
Fig. 1 is a flow chart of the present invention.
Fig. 2 is a schematic diagram illustrating that, except for the filtered leaf nodes, other nodes all participate in hash value calculation to obtain their own hash values;
as shown in fig. 3, all nodes of the abstract syntax tree are converted to hashmaps in the graph.
Fig. 4 is a flow chart of mass calculation according to the present invention.
Detailed Description
The key technologies involved in the invention are as follows: SonarQube tool, ANTLR tool, nuxt. js frame, Spring Boot frame. Some explanations are made next:
SonarQube：
the SonarQube is an open source platform for code quality management, and is mainly used for managing the quality of source codes. The method mainly measures the code quality from the dimensions of complexity, repeatability, annotation, architecture design, coding specification, potential bug, unit test quality and the like. Each dimension contains several scanning rules. The developer can adjust the configured scanning rules according to different scenes and requirements.
SonarQube excels in a plug-in mechanism so that it can integrate different code analysis tools, test tools, and persistent integration tools, among others. Its plug-ins provide support for most of the current mainstream programming languages, such as Java, Python, C + +, C #, PHP, and JavaScript, among others. Meanwhile, better support is provided for the documentation and internationalization of reports.
ANTLR：
ANTLR is an open source parsing tool that can be used to read, process, and execute and translate structured binary or text files. ANTLR provides a framework for languages including Java, C + +, C #, etc. to automatically construct recognizers, compilers, and interpreters of custom languages by syntactic descriptions. ANTLR uses a top-down approach to program analysis for ease of reading and understanding.
ANTLR has powerful functions, and can automatically generate lexical analyzer and grammar analyzer based on user defined grammar file and convert input text into visual grammar analysis tree, one kind of data structure describing the matching relation between input text and grammar. In addition, ANTLR can also automatically generate a tree walker, and developers can conveniently access nodes in the tree, thereby performing business logic processing. Meanwhile, the method is simple to use, ANTLR provides a grammar file template warehouse of most programming languages, and developers do not need to write grammar files of specific programming languages. Only a small amount of modification is needed in the provided grammar file to generate the corresponding lexical analyzer and syntax analyzer. Therefore, the use threshold is reduced, developers do not need to pay attention to a complicated compiling theory any more, and can concentrate on the processing of business logic more.
Nuxt.js：
Js is a common application framework based on vue.js and aiming to make Web development simpler and more efficient, mainly focusing on UI rendering of applications. It is itself based on a powerful modular architecture. The developer can select the module required by the developer from more than fifty modules for use without repeatedly manufacturing wheels, so that the development process of the developer is simpler and easier.
Js integrates multiple components and frameworks such as Vue2, Vue-Router, VueX and Vue service side rendering, and provides convenience for developing complete and powerful Web applications. Js also has quite a few useful properties such as automatic code layering, server-side rendering, powerful routing functions and support for asynchronous data loading, local development support for hot-loading, support for ES2015+ syntax, support for more style pre-processors and support for HTTP/2 push, etc.
Spring Boot：
The advent of Spring boots was primarily used to simplify the development, configuration, debugging, and deployment of Spring frameworks, which also integrated many practical and easy-to-use base frameworks into a project. The Spring boots follow the principle of convention superior to configuration, and can automatically provide corresponding configuration for common application functions, so that much time for template configuration can be saved.
The Spring Boot also reduces the complexity of dependence by using dependence of larger granularity, is dependence on functions, namely so-called starting dependence, and effectively solves the problems of instability of reference, version conflict of dependence packages and the like.
Use example
The steps of performing quality metrics on the code and obtaining metric data results are as follows:
1. and acquiring the corresponding SonarQube project name, and triggering code construction.
2. And performing a quality measurement on the code by executing a SonarQube project in the code construction process.
3. And acquiring code quality data from the corresponding SonarQube project address, wherein the code quality data comprises four parts of bad taste quantity, cognitive complexity, circle complexity and maintainability rating of the code.
4. The quality data is presented on the front end.
The steps of measuring the repetition rate of the code are as follows: 1)
1) and preprocessing the code file. The preprocessing stage mainly removes some information which is interfering or redundant to the code similarity detection, such as blank characters, tab characters, line feed characters, comments, printed statements and the like. According to the difference of the detected code language, some interference information with code language characteristics, such as an import statement and a package statement in Java code, can be further ignored in the preprocessing stage.
2) The portion of the character stream that is meaningful to the lexical analysis is analyzed. And performing lexical analysis on the character streams according to a defined token matching rule to obtain a token symbol stream. tokens in the token symbol stream are matched according to keywords, such as greater than symbols, less than symbols, equal numbers, or if-else keywords, while keywords, return keywords, etc.
3) And carrying out syntactic analysis and processing on the obtained token symbol stream according to a well-defined syntactic matching rule to obtain each node of the abstract syntactic tree. Tokens are linked according to the key structure statement syntax in the code, e.g., if branch statements are synthesized from compare tokens and syntax, loop branch statements are synthesized from while tokens and syntax, etc. Each node of the abstract syntax tree is the final structured statement.
4) And leaf nodes with the same filtering type but not belonging to the same code structure body optimize the nodes of the syntax tree. For example, leaf nodes which are named as variables, although belonging to the same type, do not belong to the same code structure, if the leaf nodes are included in comparison, many identical nodes appear, which increases the error rate, so that the leaf nodes need to be filtered.
5) And performing hash calculation on the generated abstract syntax tree, and then performing subsequent comparison by using the calculated hash value. Each node has a node type, the hash values of the nodes of the same type are the same, and the hash values of the nodes of different types are different. The total hash value of the node is the sum of the self hash value and the self hash values of all the child nodes. Because the subtree structures represented by the nodes with different numbers of the child nodes are different, each node needs to calculate the hash value and also needs to calculate the total number of the child nodes, so that when the same node is compared subsequently, the nodes with the same hash value and the same number of the child nodes are compared, and the calculation amount during comparison can be effectively reduced. As shown in fig. 2, other nodes except the leaf nodes that have been filtered out participate in the hash value calculation. The value at the lower left of the node in fig. 2, which is related to the hash value calculation, represents the self hash value, for example, the self hash value of the block-type node is 15. The value at the lower right of the node is the total hash value of the node, i.e. the sum of the self hash value and the self hash values of all the child nodes, e.g. the total hash value of the block is 15+10 ═ 25. By analogy, we can find that the total hash value of ifthensestatement is 30+20+15+10+15+10 equals to 100.
6) All nodes of the abstract syntax tree can be converted into HashMap with the hash value as key and the node list with the same hash value as value, and the nodes in the list are arranged according to the ascending order of the number of child nodes. As shown in fig. 3, all nodes of the abstract syntax tree are converted to hashmaps in the graph. Taking a key as 95 as an example, the value corresponding to the key indicates that the total hash value of five nodes in total is 95. These five nodes have 2, 4, 5 and 8 node nodes, respectively.
7) And carrying out syntactic analysis and processing on the obtained token symbol stream according to a well-defined syntactic matching rule to obtain each node of the abstract syntactic tree.
7-1) leaf nodes with the same filtering type but not belonging to the same code structure body, and optimizing the nodes of the syntax tree.
7-2) carrying out Hash calculation on the generated abstract syntax tree, and then carrying out subsequent comparison by using the calculated Hash value. Each node has a node type, the hash values of the nodes of the same type are the same, and the hash values of the nodes of different types are different. The total hash value of the node is the sum of the self hash value and the self hash values of all the child nodes. Because the subtree structures represented by the nodes with different numbers of the child nodes are different, each node needs to calculate the hash value and also needs to calculate the total number of the child nodes, so that when the same node is compared subsequently, the nodes with the same hash value and the same number of the child nodes are compared, and the calculation amount during comparison can be effectively reduced.
7-3) finally converting all nodes of the abstract syntax tree into HashMap with the hash value as key and the node list with the same hash value as value, wherein the nodes in the list are arranged according to the ascending order of the number of child nodes.
7-4) calculating the number of the same nodes in the source code and the comparison code. The same node means a node having the same hash value and the same number of child nodes. The similarity calculation formula is shown in formula (1), wherein a and B represent all abstract syntax tree nodes participating in hash calculation of the source code and the comparison code, respectively. The numerator represents the same node number between the two codes, and the denominator represents the minimum value between the total node number of the source code and the total node number of the comparison code.
And displaying the repetition rate measurement result on a front-end page.
Example results:
after the system development is completed, the method is correspondingly tested. The method mainly comprises two aspects, on one hand, the method mainly aims at the functional test after the method is deployed to a system, and aims to check whether the functions realized by the method can meet the requirements or not and ensure that the generation result of the method can meet the expectation. On the other hand, the validity test of the similarity measurement algorithm is aimed at, and the algorithm can measure most common student code plagiarism conditions.
The test environment of the system mainly uses a development environment application server, a development environment database server and an infrastructure server. The development environment application server deploys the front end of the system, original programming examination service, timing task service and similarity detection service. The development environment database server deploys the MySQL database used in the system. The infrastructure server deploys SonarQube, Gitlab, Jenkins and RabbitMQ.
The functional test is mainly designed according to a requirement case, and aims to ensure that the realized functions meet requirements, and the final product meets the specification and the behavior of the system can meet the expectation of the product.
Table 1 shows a case of the test for measuring the quality of the code, which is mainly designed for the UC1 case description, and tests whether the system can correctly measure the quality after the student submits the code.
TABLE 1 example table for measuring code quality
Table 2 shows a test case table for checking quality measurement results, which is mainly designed for the case description of UC2, and the main concern is whether the system can correctly display the code quality measurement results. Whether various clicking operations and mouse hovering operations of the students can make corresponding correct responses.
Table 2 example table for testing checking quality measurement result
Table 3 is a test case table for detecting code similarity. The main testing system is used for testing whether the code data can be correctly acquired and carrying out similarity measurement after a timing task initiates a callback request for requesting the similarity measurement.
TABLE 3 example table for measuring similarity of codes
| Test ID | TC3 |
| Name of test | Measuring code similarity |
| Testing function | System for measuring similarity of examination codes |
| Test procedure | 1. After the examination is finished, the timing task initiates a callback request |
| Expected result | 1. The system acquires examination codes and carries out similarity detection, and finally stores the detection result in a database |
Table 4 is an overview test case table looking at the similarity measure results. The main concern is to test whether the overview data is displayed normally to support the teacher's general understanding of the plagiarism on the test.
TABLE 4 example Table for overview test of checking similarity measurement result
Table 5 is an example table for testing checking the similar pair list, and mainly tests whether the similar pair list of the corresponding questions under different similarity values can be displayed in a pagination manner correctly, so as to support teachers to know the similar pair condition of specific questions.
Table 5 example table for testing by checking similar pair list
Table 6 is a test case table for viewing similar pair details, which mainly focuses on the display of similar pair details and source codes, and display of similarity texts of comparison codes, so as to support a teacher to visually see which codes and which specific lines between codes are similar.
Table 6 example table for examining details of similar pairs
The functional test results are as follows.
Table 7 function test case execution result table
| Test case ID | Test results |
| TC1 | By passing |
| TC2 | By passing |
| TC3 | By passing |
| TC4 | By passing |
| TC5 | By passing |
| TC6 | By passing |
In the testing process of the algorithm effectiveness, a variant insertion testing method is mainly used for reference. The core idea of the method is to artificially adjust codes in source codes, generate variant codes of different types, and then detect the code pairs. The method does not depend on any programming language or tool, and can objectively evaluate the detection result.
Since the code measurement is to judge whether plagiarism behavior exists according to the similarity measurement of the test codes, the test data should select the actual test codes of the students. The test selects 40 student examination source code files in total, and 87 variant codes of the type one, 92 variant codes of the type two, 61 variant codes of the type three and 57 variant codes of the type four are obtained through a variant insertion method. The codes are delivered to a similarity detection service for detection, and if code pairs with similarity greater than or equal to 90% are set to be plagiarism, then the detection conditions of the four types of plagiarism are shown in table 9.
From this table, it can be seen that the plagiarism codes for both type one and type two can be successfully detected. For the undetected case of type three, the code pair is carefully analyzed, and it is found that the source code has fewer rows, only 6 rows, and thus fewer nodes participating in the similarity calculation, while the added code will change the hash values of all parent nodes, thus resulting in a reduction of nodes with the same hash value, and thus a reduction in similarity. For the type four detection case, it can be found that the algorithm can detect most of the variant codes. And the undetected variant code can be analyzed to find that the nodes participating in similarity calculation are fewer due to the fact that the number of lines of the source code is less. Even if the loop structure or the selection structure is replaced, only the self node and all the father nodes in the abstract syntax tree are affected and cannot respond to the sibling nodes, so that if the number of code lines is not small and the number of unaffected sibling nodes is large, the variant code of the type four does not change greatly for the abstract syntax tree as a whole, and can be successfully detected.
TABLE 4 table of four plagiarism type test results
| Successfully detect out | Not detected out | |
| Type one | 87 | 0 |
| Type two | 92 | 0 |
| |
60 | 1 |
| Type four | 42 | 15 |
Through testing, the algorithm can detect all the variant codes of the type one and the type two, most of the type three can also be detected, and the variant code of the type four which meets specific conditions can also be detected.
Claims (3)
1. A measurement method for codes submitted in an online programming examination is characterized in that SonarQube is used for measuring the quality of the codes and obtaining data results, and quality measurement data of a project are obtained through a packaged SonarQube API and displayed to a front-end page;
performing quality measurement on the codes and acquiring a data result, namely comparing the codes with other codes through a code similarity detection algorithm and displaying repeated conditions to a front-end page;
the process of comparing the code with other codes is: preprocessing the acquired code, generating an abstract syntax tree for the processed code, processing the syntax tree and converting the syntax tree into a linear structure, calculating the similarity of the linear structure, displaying the result and the like.
2. A metrology method as claimed in claim 1 wherein the steps are as follows:
1) acquiring the name of the SonarQube project corresponding to the code, and constructing the code;
2) executing a SonarQube project to measure the quality of the code in the code construction process;
3) acquiring code quality data from the corresponding SonarQube project address, wherein the code quality data comprises four parts of bad taste quantity, cognitive complexity, circle complexity and maintainability rating of the code;
4) the corresponding code quality data is presented on the front end.
3. The method of claim 2, wherein the step of performing a quality metric, i.e., repetition rate metric, on the code is as follows:
1) the method mainly comprises the steps of preprocessing a code file, wherein some information which is interfered or redundant for detecting the similarity of the code, such as blank characters, tab characters, line feed characters, comments and printing statements, is mainly removed in the preprocessing stage, and according to the difference of detected code languages, some interference information with code language characteristics, such as import statements and package statements in Java codes, can be further omitted in the preprocessing stage.
2) The portion of the character stream that is meaningful to the lexical analysis is analyzed. And performing lexical analysis on the character streams according to a defined token matching rule to obtain a token symbol stream.
3) And carrying out syntactic analysis and processing on the obtained token symbol stream according to a well-defined syntactic matching rule to obtain each node of the abstract syntactic tree.
4) And leaf nodes with the same filtering type but not belonging to the same code structure body optimize the nodes of the syntax tree.
5) And performing hash calculation on the generated abstract syntax tree, and then performing subsequent comparison by using the calculated hash value. Each node has a node type, the hash values of the nodes of the same type are the same, and the hash values of the nodes of different types are different. The total hash value of the node is the sum of the self hash value and the self hash values of all the child nodes. Because the subtree structures represented by the nodes with different numbers of the child nodes are different, each node needs to calculate the hash value and also needs to calculate the total number of the child nodes, so that when the same node is compared subsequently, the nodes with the same hash value and the same number of the child nodes are compared, and the calculation amount during comparison can be effectively reduced.
6) And finally, converting all nodes of the abstract syntax tree into HashMap with the hash value as key and the node list with the same hash value as value, wherein the nodes in the list are arranged according to the ascending order of the number of child nodes.
7) And calculating the number of the same nodes in the source code and the comparison code. The same node means a node having the same hash value and the same number of child nodes. The similarity calculation formula is shown in formula (1), wherein a and B represent all abstract syntax tree nodes participating in hash calculation of the source code and the comparison code, respectively. The numerator represents the same node number between the two codes, and the denominator represents the minimum value between the total node number of the source code and the total node number of the comparison code:
8) and performing similarity measurement and data result display on the codes.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011038003.6A CN112148609A (en) | 2020-09-28 | 2020-09-28 | Method for measuring codes submitted in online programming test |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011038003.6A CN112148609A (en) | 2020-09-28 | 2020-09-28 | Method for measuring codes submitted in online programming test |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112148609A true CN112148609A (en) | 2020-12-29 |
Family
ID=73894630
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011038003.6A Pending CN112148609A (en) | 2020-09-28 | 2020-09-28 | Method for measuring codes submitted in online programming test |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112148609A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN118195563A (en) * | 2024-05-20 | 2024-06-14 | 成都数联云算科技有限公司 | Automatic interview system for programmers |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR20050065015A (en) * | 2003-12-24 | 2005-06-29 | (주) 뉴스텍시스템즈 | System and method for checking program plagiarism |
| CN103729580A (en) * | 2014-01-27 | 2014-04-16 | 国家电网公司 | Method and device for detecting software plagiarism |
| CN104636252A (en) * | 2015-01-04 | 2015-05-20 | 浪潮软件股份有限公司 | Online code reviewing method and system based on SonarQube |
| CN105159715A (en) * | 2015-09-01 | 2015-12-16 | 南京大学 | Python code change reminding method on basis of abstract syntax tree node change extraction |
| US10169208B1 (en) * | 2014-11-03 | 2019-01-01 | Charles W Moyes | Similarity scoring of programs |
| CN109344072A (en) * | 2018-10-12 | 2019-02-15 | 携程旅游信息技术（上海）有限公司 | Code quality detection method, server, system, equipment and storage medium |
| CN109542769A (en) * | 2018-10-25 | 2019-03-29 | 武汉精立电子技术有限公司 | A kind of automated testing method of continuous integrating |
| CN110347428A (en) * | 2018-04-08 | 2019-10-18 | 北京京东尚科信息技术有限公司 | A kind of detection method and device of code similarity |
-
2020
- 2020-09-28 CN CN202011038003.6A patent/CN112148609A/en active Pending
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR20050065015A (en) * | 2003-12-24 | 2005-06-29 | (주) 뉴스텍시스템즈 | System and method for checking program plagiarism |
| CN103729580A (en) * | 2014-01-27 | 2014-04-16 | 国家电网公司 | Method and device for detecting software plagiarism |
| US10169208B1 (en) * | 2014-11-03 | 2019-01-01 | Charles W Moyes | Similarity scoring of programs |
| CN104636252A (en) * | 2015-01-04 | 2015-05-20 | 浪潮软件股份有限公司 | Online code reviewing method and system based on SonarQube |
| CN105159715A (en) * | 2015-09-01 | 2015-12-16 | 南京大学 | Python code change reminding method on basis of abstract syntax tree node change extraction |
| CN110347428A (en) * | 2018-04-08 | 2019-10-18 | 北京京东尚科信息技术有限公司 | A kind of detection method and device of code similarity |
| CN109344072A (en) * | 2018-10-12 | 2019-02-15 | 携程旅游信息技术（上海）有限公司 | Code quality detection method, server, system, equipment and storage medium |
| CN109542769A (en) * | 2018-10-25 | 2019-03-29 | 武汉精立电子技术有限公司 | A kind of automated testing method of continuous integrating |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN118195563A (en) * | 2024-05-20 | 2024-06-14 | 成都数联云算科技有限公司 | Automatic interview system for programmers |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Nguyen et al. | Auto-locating and fix-propagating for HTML validation errors to PHP server-side code | |
| Gerpheide et al. | Assessing and improving quality of QVTo model transformations | |
| Zhang et al. | Practices and challenges of using github copilot: An empirical study | |
| Zheng et al. | Towards an understanding of large language models in software engineering tasks | |
| Letsholo et al. | TRAM: A tool for transforming textual requirements into analysis models | |
| Ndia et al. | A survey of cascading style sheets complexity metrics | |
| Zhang et al. | Demystifying practices, challenges and expected features of using github copilot | |
| CN112148609A (en) | Method for measuring codes submitted in online programming test | |
| Vince et al. | The effect of hoisting on variants of Hierarchical Delta Debugging | |
| Koivisto et al. | Evaluating CodeClusters for effectively providing feedback on code submissions | |
| CN117331836A (en) | Evaluation method based on code syntax tree analysis | |
| Jurkiewicz et al. | Automated events identification in use cases | |
| Miah et al. | User-centric evaluation of ChatGPT capability of generating R program code | |
| Mustafa et al. | Automated Natural Language Requirements Analysis using General Architecture for Text Engineering (GATE) Framework | |
| Abd Rahman et al. | The design of an automated c programming assessment using pseudo-code comparison technique | |
| Zhuo et al. | BigCodeBench: Benchmarking Code Generation with Diverse Function Calls and Complex Instructions | |
| Daka | Improving readability in automatic unit test generation | |
| Mahbub et al. | Bugsplainer: Leveraging Code Structures to Explain Software Bugs with Neural Machine Translation | |
| Mekterović et al. | Programmable Questions in Edgar | |
| Hansson et al. | Code Correctness and Quality in the Era of AI Code Generation: Examining ChatGPT and GitHub Copilot | |
| Saavedra et al. | Polyglot Code Smell Detection for Infrastructure as Code with GLITCH | |
| Harms et al. | Consistency of task trees generated from website usage traces | |
| Grilo | A case study of Reengineering of the CCCExplorer Tool | |
| Perera et al. | Analyzing the Impact of Code Commenting on Software Quality | |
| Cooper et al. | Perplexed: Understanding When Large Language Models are Confused |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| RJ01 | Rejection of invention patent application after publication | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20201229 |