Problems: vector

Amara typed in the marks from a pile of exam papers, in the order they came in. She never counted them. Print the marks from the last paper to the first. The starter reads them into vector<int> marks with push_back.

Input. One or more integers, separated by spaces or line breaks. No count comes first: read until the input ends.

Output. One line with the marks in reverse order, separated by single spaces.

Constraints. 1 to 200000 marks, each between -1000000000 and 1000000000.

Sample. Input 70 85 62 91 48 gives 48 91 62 85 70.

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    vector<int> marks;
    int x = 0;
    while (cin >> x) {
        marks.push_back(x);
    }

    // Print the marks from the last one back to the first,
    // on one line, separated by single spaces.

    return 0;
}

Kenji wrote down his score in each of n rounds, and some are negative. Find his best score and the round where he first reached it, counting rounds from 0.

Input. The first line holds n. The second holds the n scores.

Output. One line: the largest score, a space, and the index of its first occurrence.

Constraints. 1 <= n <= 200000, and each score is between -1000000000 and 1000000000.

Sample. Input 6 and 4 9 7 9 2 -3 gives 9 1.

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n = 0;
    cin >> n;
    vector<int> scores(n);
    for (int i = 0; i < n; i++) {
        cin >> scores[i];
    }

    // Print the largest score and the index of its first occurrence,
    // counting from 0, separated by a space.

    return 0;
}

Bob's step counter logs a negative number when its sensor fails. Remove every negative reading from vector<int> steps and print the rest in order. A reading of 0 is real and stays.

Input. The first line holds n. The second holds the n readings.

Output. One line with the readings that are 0 or more, separated by single spaces, or the word empty if none is left.

Constraints. 1 <= n <= 20000, and each reading is between -1000000000 and 1000000000.

Sample. Input 7 and 3 -1 4 -1 -5 9 2 gives 3 4 9 2.

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n = 0;
    cin >> n;
    vector<int> steps(n);
    for (int i = 0; i < n; i++) {
        cin >> steps[i];
    }

    // Remove every negative reading from steps, keeping the order of the rest.
    // Then print what is left on one line, or the word empty if nothing is.

    return 0;
}

Alice's reading list holds n book numbers. She adds book x so that it becomes the k-th book, counting from 1. So k = 1 puts it first, and k = n + 1 puts it last.

Input. n, then the n book numbers, then k and x.

Output. One line with the n + 1 book numbers after the insert, separated by single spaces.

Constraints. 1 <= n <= 200000, 1 <= k <= n + 1, and every number is between -1000000000 and 1000000000.

Sample. Input 5, 10 20 30 40 50 and 3 25 gives 10 20 25 30 40 50.

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n = 0;
    cin >> n;
    vector<int> books(n);
    for (int i = 0; i < n; i++) {
        cin >> books[i];
    }
    int k = 0;
    int x = 0;
    cin >> k >> x;

    // Insert x so that it becomes the k-th book, counting from 1.
    // Then print all n + 1 books on one line, separated by single spaces.

    return 0;
}

Maria marked n papers, each from 0 to 100. For every mark that appears, print how many students got it.

Input. The first line holds n. The second holds the n marks.

Output. One line for every mark that appears, from the smallest to the largest: the mark, a space, its count.

Constraints. 1 <= n <= 200000, and each mark is between 0 and 100.

Sample. Input 8 and 3 7 3 0 100 7 3 5 gives five lines: 0 1, 3 3, 5 1, 7 2 and 100 1.

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n = 0;
    cin >> n;
    vector<int> marks(n);
    for (int i = 0; i < n; i++) {
        cin >> marks[i];
    }

    // For every mark that appears, from the smallest to the largest,
    // print one line: the mark, a space, and how many students got it.

    return 0;
}

David has the sales of n days, and a day can be negative after refunds. He asks q questions: what were the total sales from day l to day r?

Input. n and q, then the n daily sales, then q lines, each with l and r.

Output. One line per question with the total of days l to r, both included.

Constraints. 1 <= n, q <= 200000, each day's sales are between -1000000000 and 1000000000, and 1 <= l <= r <= n, with days numbered from 1.

Sample. Input 5 3, 4 -2 7 1 3, 1 3, 2 5 and 4 4 gives 9, 9 and 1 on three lines.

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n = 0;
    int q = 0;
    cin >> n >> q;
    vector<int> sales(n);
    for (int i = 0; i < n; i++) {
        cin >> sales[i];
    }

    // Anything you want to prepare before the questions goes here.

    for (int k = 0; k < q; k++) {
        int l = 0;
        int r = 0;
        cin >> l >> r;
        // Print the total sales of days l to r, both included.
        // Days are numbered from 1.
    }
    return 0;
}

Kenji's tournament table is a grid: a row per player, a column per round, and a cell holds that round's points, negative for a penalty. Print every row's total and every column's total.

Input. r and c, then r lines of c integers.

Output. Line 1 holds the r row sums, and line 2 the c column sums, each separated by single spaces.

Constraints. 1 <= r, c <= 500, and each integer is between -1000000000 and 1000000000.

Sample. Input 2 3, 1 2 3 and 4 5 6 gives 6 15 and 5 7 9 on two lines.

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int r = 0;
    int c = 0;
    cin >> r >> c;
    vector<vector<int>> points(r, vector<int>(c));
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            cin >> points[i][j];
        }
    }

    // Line 1: the sum of each row, from the first row to the last.
    // Line 2: the sum of each column, from the first column to the last.

    return 0;
}

Amara tests the undo list of a drawing app with a script. push x adds stroke x at the end. pop removes the last stroke, or does nothing on an empty list. print prints the list.

Input. n, then n lines, each one operation.

Output. For every print, one line: the strokes separated by single spaces, or the word empty.

Constraints. 1 <= n <= 200000, 1 <= x <= 1000, and all the prints together print at most 100000 strokes.

Sample. Input 7, push 5, push 8, print, pop, pop, pop and print gives 5 8 and empty on two lines.

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n = 0;
    cin >> n;
    vector<int> strokes;
    for (int i = 0; i < n; i++) {
        string op;
        cin >> op;
        if (op == "push") {
            int x = 0;
            cin >> x;
            // Add x at the end of strokes.
        } else if (op == "pop") {
            // Remove the last stroke, or do nothing if there is none.
        } else {
            // op is "print": print the strokes on one line,
            // or the word empty if there are none.
        }
    }
    return 0;
}

Zara sorted her thermometer's n readings, and many repeat. Print how many different readings there are, and the readings themselves, each once.

Input. n, then n integers in non-decreasing order.

Output. Line 1 holds k, the number of distinct readings. Line 2 holds them in increasing order, separated by single spaces.

Constraints. 1 <= n <= 200000, and each reading is between -1000000000 and 1000000000.

Sample. Input 8 and 1 1 2 3 3 3 7 7 gives 4 and 1 2 3 7 on two lines.

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n = 0;
    cin >> n;
    vector<int> readings(n);
    for (int i = 0; i < n; i++) {
        cin >> readings[i];
    }

    // The readings are in non-decreasing order.
    // Line 1: how many distinct readings there are.
    // Line 2: the distinct readings in order, separated by single spaces.

    return 0;
}

Maria deals n numbered cards in a row, and some numbers are negative. Two cards win when their numbers add up to exactly t. Count the winning pairs of positions.

Input. n and t, then the n card numbers, in any order.

Output. One line with the number of pairs of positions i < j whose numbers add up to t.

Constraints. 1 <= n <= 200000, each number is between -1000000000 and 1000000000, and -2000000000 <= t <= 2000000000.

Sample. Input 6 10 and 3 7 5 5 2 8 gives 3.

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n = 0;
    long long t = 0;
    cin >> n >> t;
    vector<int> cards(n);
    for (int i = 0; i < n; i++) {
        cin >> cards[i];
    }

    // Print how many pairs of positions i < j have
    // cards[i] + cards[j] equal to t.

    return 0;
}