cpp-optimize-algorithm — human mapping

A painting is a person's account of this edit as text, recorded independently of the node mapping - a rendering often has several equally defensible answers where the mapping has one. Deletions and insertions carry no position on the opposite side in a painting, so that panel draws no caret for them.

Before1#include <vector>
2#include <algorithm>
3
4int findMin(const std::vector<int>& vec) {
5    if (vec.empty()) return 0;
6    int min = vec[0];
7    for (size_t i = 1; i < vec.size(); i++) {
8        if (vec[i] < min) {
9            min = vec[i];
10        }
11    }
12    return min;
13}
14
15int main() {
16    std::vector<int> numbers = {5, 2, 8, 1, 9};
17    return findMin(numbers);
18}
19

After1#include <vector>
2#include <algorithm>
3
4int findMin(const std::vector<int>& vec) {
5    if (vec.empty()) return 0;
6    return *std::min_element(vec.begin(), vec.end());
7}
8
9int main() {
10    std::vector<int> numbers = {5, 2, 8, 1, 9};
11    return findMin(numbers);
12}
13

Before1#include <vector>
2#include <algorithm>
3
4int findMin(const std::vector<int>& vec) {
5    if (vec.empty()) return 0;
6    int min = vec[0];
7    for (size_t i = 1; i < vec.size(); i++) {
8        if (vec[i] < min) {
9            min = vec[i];
10        }
11    }
12    return min;
13}
14
15int main() {
16    std::vector<int> numbers = {5, 2, 8, 1, 9};
17    return findMin(numbers);
18}
19

After1#include <vector>
2#include <algorithm>
3
4int findMin(const std::vector<int>& vec) {
5    if (vec.empty()) return 0;
6    return *std::min_element(vec.begin(), vec.end());
7}
8
9int main() {
10    std::vector<int> numbers = {5, 2, 8, 1, 9};
11    return findMin(numbers);
12}
13

Before1#include <vector>
2#include <algorithm>
3
4int findMin(const std::vector<int>& vec) {
5    if (vec.empty()) return 0;
6    int min = vec[0];
7    for (size_t i = 1; i < vec.size(); i++) {
8        if (vec[i] < min) {
9            min = vec[i];
10        }
11    }
12    return min;
13}
14
15int main() {
16    std::vector<int> numbers = {5, 2, 8, 1, 9};
17    return findMin(numbers);
18}
19

After1#include <vector>
2#include <algorithm>
3
4int findMin(const std::vector<int>& vec) {
5    if (vec.empty()) return 0;
6    return *std::min_element(vec.begin(), vec.end());
7}
8
9int main() {
10    std::vector<int> numbers = {5, 2, 8, 1, 9};
11    return findMin(numbers);
12}
13

Before

translation_unit

preproc_include

#include "#include"

system_lib_string "<vector>"

preproc_include

#include "#include"

system_lib_string "<algorithm>"

function_definition

primitive_type "int"

function_declarator (+21 nodes collapsed)

compound_statement

{ "{"

if_statement

if "if"

condition_clause

( "("

call_expression

field_expression

identifier "vec"

. "."

field_identifier "empty"

argument_list

( "("

) ")"

return_statement

return "return"

number_literal "0"

; ";"

declaration

primitive_type "int"

init_declarator

identifier "min"

= "="

subscript_expression

identifier "vec"

subscript_argument_list

[ "["

number_literal "0"

] "]"

; ";"

for_statement

for "for"

( "("

declaration

primitive_type "size_t"

init_declarator

identifier "i"

= "="

number_literal "1"

; ";"

binary_expression

identifier "i"

< "<"

call_expression

field_expression

identifier "vec"

. "."

field_identifier "size"

argument_list

( "("

) ")"

; ";"

update_expression

identifier "i"

++ "++"

) ")"

compound_statement

{ "{"

if_statement

if "if"

condition_clause

( "("

binary_expression

subscript_expression

identifier "vec"

subscript_argument_list

[ "["

identifier "i"

] "]"

< "<"

identifier "min"

) ")"

compound_statement

{ "{"

expression_statement

assignment_expression

identifier "min"

= "="

subscript_expression

identifier "vec"

subscript_argument_list

[ "["

identifier "i"

] "]"

; ";"

} "}"

return_statement

return "return"

identifier "min"

; ";"

} "}"

function_definition (+46 nodes collapsed)

After

translation_unit

preproc_include

#include "#include"

system_lib_string "<vector>"

preproc_include

#include "#include"

system_lib_string "<algorithm>"

function_definition

primitive_type "int"

function_declarator (+21 nodes collapsed)

compound_statement

{ "{"

if_statement

if "if"

condition_clause

( "("

call_expression

field_expression

identifier "vec"

. "."

field_identifier "empty"

argument_list

( "("

) ")"

return_statement

return "return"

number_literal "0"

; ";"

return_statement

return "return"

pointer_expression

* "*"

call_expression

qualified_identifier

namespace_identifier "std"

:: "::"

identifier "min_element"

argument_list

( "("

call_expression

field_expression

identifier "vec"

. "."

field_identifier "begin"

argument_list

( "("

) ")"

, ","

call_expression

field_expression

identifier "vec"

. "."

field_identifier "end"

argument_list

( "("

) ")"

; ";"

} "}"

function_definition (+46 nodes collapsed)

Keybindings

j / k: next / previous visible node (tree panels)
h / l: collapse / expand the focused node
g / G: jump to first / last visible node
Tab: switch focus between Before/After panels
/: search: jump to next node whose text contains a given string
a: jump the other panel to this node's mapped counterpart
i: hide identical matches, showing only inserted/deleted/updated nodes and their ancestors
v: cycle the view: split / code only / tree only
p: cycle what the code view renders: the node mapping, then each human painting
r: mark this fixture as reviewed, or forget the mark (kept in this browser only)
n: open a random fixture not yet marked as reviewed
?: toggle this help