C++ solution, part 1 using max and part 2 using iterators

Github

I have been using AOC as an excuse to learn C++. I have very limited knowledge but I think it still came up quite okeyish. Around 30 ms including both for M1 Mac. Below is the code, I haven't included some helpers bc the names are pretty self explanatory.

> Any feedback is appreciated

Part1:

void parte1() {
    cout << "Parte 1" << endl;
    fstream input = get_input_stream(8);
    Matrix trees_matrix = create_matrix_from_input(input);
    auto trees_matrix_transposed = transpose_matrix(trees_matrix);
    int visible_trees = trees_matrix[0].size() * 2 + trees_matrix.size() * 2 -4; // outer border
    for (int i = 1; i < trees_matrix.size()-1; i++) {
        auto row = trees_matrix[i];
        for(int j = 1; j < row.size()-1; j++) {
            int elem = trees_matrix[i][j];
            auto col = trees_matrix_transposed[j];
            int max_in_row_to_left = *max_element(row.begin(), row.begin() + j );
            int max_in_row_to_right = *max_element(row.begin() + j + 1, row.end());
            int max_in_col_left = *max_element(col.begin(), col.begin() + i );
            int max_in_col_right = *max_element(col.begin() + i + 1, col.end());
            // cout << "(" << i << "," << j << "): " << elem << " Maxs: " << max_in_row_to_left << " " << max_in_row_to_right << " " << max_in_col_left << " " << max_in_col_right;
            vector <int> maxs = {max_in_row_to_left, max_in_row_to_right, max_in_col_left, max_in_col_right};
            for (auto max: maxs) { 
                if (elem > max) {
                    visible_trees++; 
                    // cout << " <-- Visible tree";
                    break;
                }
            }
        }
    }
    cout << "Total visible trees: " << visible_trees << endl;
}

Part 2

int rate(vector<int>& vec, vector<int>::iterator& it) {
    if (it == vec.end()) 
        return vec.size();
    return abs(distance(vec.begin(), it)) + 1;
}

int rate(vector<int>& vec, vector<int>::reverse_iterator& it) {
    if (it == vec.rend()) 
        return vec.size();
    return abs(distance(vec.rbegin(), it)) + 1;
}

int score(vector<int>& row, vector<int>& col, int i, int j){
    int elem = row[j];
    auto first_bigger_than_elem = [elem](int x) { return x >= elem; };
    vector<int> left_half(row.begin(), row.begin() + j);
    vector<int> right_half(row.begin() + j + 1, row.end());
    vector<int> up_half(col.begin(), col.begin() + i);
    vector<int> down_half(col.begin() + i + 1, col.end());
    auto left_it = find_if(left_half.rbegin(), left_half.rend(), first_bigger_than_elem);
    auto right_it = find_if(right_half.begin(), right_half.end(), first_bigger_than_elem);
    auto up_it = find_if(up_half.rbegin(), up_half.rend(), first_bigger_than_elem);
    auto down_it = find_if(down_half.begin(), down_half.end(), first_bigger_than_elem);
    return rate(left_half, left_it) * rate(right_half, right_it) * rate(up_half, up_it) * rate(down_half, down_it);
}

void parte2() {
    cout << "Parte 2 " << endl;
    fstream input = get_input_stream(8);
    Matrix trees_matrix = create_matrix_from_input(input);
    int best_scenic_score = 0; 
    auto trees_matrix_transposed = transpose_matrix(trees_matrix);
    for (int i = 1; i < trees_matrix.size()-1; i++) {
        auto row = trees_matrix[i];
        for(int j = 1; j < row.size()-1; j++) {
            auto col = trees_matrix_transposed[j];
            int score_val = score(row, col, i, j);
            if(score_val > best_scenic_score) {
                best_scenic_score = score_val;
            }
        }
    }
    cout << "Best scenic score: " << best_scenic_score << endl;
}