Problems: Just-Enough C++

Zara's step counter does not say how many readings it saved. It pours them out, some on one line and some on the next, until it runs out. She wants the total and how many there were.

Input. Zero or more integers, separated by spaces and newlines, until the end of the input.

Output. One line: the sum, one space, the count. With no integers at all, print 0 0.

Constraints. At most 80000 integers, each between -1000000000 and 1000000000.

Sample. Input 3 5 and -2 on two lines gives 6 3.

#include <iostream>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    // Read integers until the input ends. Print their sum and how many
    // there were, on one line, separated by one space.

    return 0;
}

Kenji logs the score of every game in a tournament. He wants the best score and which game it came from, games counted from 1. If the best score appears twice, he wants the first game.

Input. The first line holds n. The second holds n integers.

Output. One line: the largest score, one space, its first position.

Constraints. 1 <= n <= 80000. Each score is between -1000000000 and 1000000000.

Sample. Input 5 and 4 9 2 9 1 gives 9 2.

#include <iostream>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n = 0;
    std::cin >> n;

    // Read the n integers. Print the largest one and its position
    // (the first integer is position 1), separated by one space.
    // If the largest appears more than once, print its first position.

    return 0;
}

Maria lines up three parcels by weight, lightest on the left. Her only move is to swap two neighbours if the left one is heavier. Three such moves always do the job. The starter gives that move as void order(int& a, int& b).

Input. The first line holds t. Each of the next t lines holds three integers.

Output. t lines, each with its three integers in increasing order, separated by single spaces.

Constraints. 1 <= t <= 10000. Each integer is between -1000000000 and 1000000000.

Sample. Input 3, then 3 1 2, 5 5 1 and -1 -2 -3, gives 1 2 3, 1 5 5 and -3 -2 -1.

#include <iostream>

// Put a and b in order: after the call, a <= b.
void order(int& a, int& b)
{
    // your code
}

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 0;
    std::cin >> t;
    for (int i = 0; i < t; i++) {
        int a = 0;
        int b = 0;
        int c = 0;
        std::cin >> a >> b >> c;

        // Use order() to put a, b and c in increasing order,
        // then print them on one line, separated by single spaces.
    }
    return 0;
}

Amara marks a class test and writes each student's name and mark as she goes. The best mark wins a book; on a tie, the paper she marked first wins. Keep the winner so far in std::pair<std::string, int> best.

Input. The first line holds n. Each of the next n lines holds a name and a mark.

Output. One line: the winner's name and mark.

Constraints. 1 <= n <= 10000. A name is 1 to 20 lowercase letters; a mark is from 0 to 100.

Sample. Input 4, then alice 82, bob 91, zara 91 and kenji 75, gives bob 91.

#include <iostream>
#include <string>
#include <utility>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n = 0;
    std::cin >> n;

    std::pair<std::string, int> best;

    // Read n lines, each a name and a mark. Keep the best one in best:
    // the highest mark, and on a tie the one that came first.
    // Then print best's name and mark, separated by one space.

    return 0;
}

David is building an index for his notes: every word with the number of the line it is on. Some lines are empty, and some have extra spaces. A word is a run of characters that are not spaces.

Input. The first line holds n. Then n lines of text follow, possibly empty, possibly with leading, trailing or repeated spaces.

Output. One line per word, in order: the text line's number (from 1), one space, the word. Nothing for a line with no words.

Constraints. 1 <= n <= 1000. Each text line has at most 1000 characters, with no tabs.

Sample. Input 3, then the cat sat, an empty line and on the mat, gives 1 the, 1 cat, 1 sat, 3 on, 3 the and 3 mat.

#include <iostream>
#include <string>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n = 0;
    std::cin >> n;

    // Read the n lines of text that follow with std::getline.
    // For every word, print the number of its line (1 to n),
    // one space and the word, one word per output line.

    return 0;
}

Alice runs a book swap. Every book has a shelf number and a slot number. She wants the list in walking order: shelf by shelf, and slot by slot on a shelf. The starter reads the pairs into a std::vector<std::pair<int, int>>.

Input. The first line holds n. Each of the next n lines holds a shelf and a slot.

Output. n lines, sorted by shelf and then by slot; equal pairs as often as they appear.

Constraints. 1 <= n <= 40000. Each integer is between -1000000000 and 1000000000.

Sample. Input 4, then 3 1, 1 5, 3 0 and 1 2, gives 1 2, 1 5, 3 0 and 3 1.

#include <algorithm>
#include <iostream>
#include <utility>
#include <vector>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n = 0;
    std::cin >> n;

    // A vector is an array that knows its own size (Module 2 teaches it).
    std::vector<std::pair<int, int>> v(n);
    for (auto& p : v) {
        std::cin >> p.first >> p.second;
    }

    // Sort v by first, and by second when the firsts are equal.
    // Then print one pair per line: first, one space, second.

    return 0;
}

David checks a cold store's temperature log several times a day. Each check is a short list, and the report needs its coldest and warmest reading. The starter declares std::pair<int, int> minMax(const int a[], int k).

Input. The first line holds t. Each of the next t lines holds k, then k integers.

Output. t lines, each the smallest and the largest of its list.

Constraints. 1 <= t <= 1000 and 1 <= k <= 1000, at most 80000 integers in all, each between -1000000000 and 1000000000.

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

#include <iostream>
#include <utility>

const int MAX_K = 1000;

// Return the smallest and the largest of a[0] to a[k - 1], in that order.
std::pair<int, int> minMax(const int a[], int k)
{
    return {0, 0}; // replace this line
}

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 0;
    std::cin >> t;

    int a[MAX_K];
    for (int i = 0; i < t; i++) {
        int k = 0;
        std::cin >> k;
        for (int j = 0; j < k; j++) {
            std::cin >> a[j];
        }

        // Call minMax and print the smallest and the largest,
        // separated by one space.
    }
    return 0;
}

A shop doubles every price for one silly day, and Bob must update the list where it stands. The starter reads the prices into std::vector<long long> values. Double every value in place with a range-for, then print the list.

Input. The first line holds n. The second holds n integers.

Output. One line: the n values, each doubled, in order, separated by single spaces.

Constraints. 1 <= n <= 80000. Each integer is between -2000000000 and 2000000000.

Sample. Input 4 and 3 -1 0 2000000000 gives 6 -2 0 4000000000.

#include <iostream>
#include <vector>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n = 0;
    std::cin >> n;

    // A vector is an array that knows its own size (Module 2 teaches it),
    // so a range-for over it walks exactly the n values.
    std::vector<long long> values(n);
    for (long long& x : values) {
        std::cin >> x;
    }

    // Double every value in place with a range-for. Then print the
    // values on one line, separated by single spaces.

    return 0;
}

Kenji's sensor station sends batches of three kinds: whole-number counts, decimal temperatures and station names. The dashboard shows the largest value of each batch; for a word, the one a dictionary lists last.

Input. The first line holds t. Each of the next t lines starts with int, double or string, then k, then k values of that type.

Output. t lines, each the largest value of its batch, printed with plain std::cout <<: a double 2.50 prints as 2.5.

Constraints. 1 <= t <= 800 and 1 <= k <= 100. Ints are within ±10⁹, doubles within ±1000 with at most two decimals, strings 1 to 10 lowercase letters.

Sample. Input 3, then int 3 4 -2 7, double 2 2.5 1.25 and string 3 pear apple zebra, gives 7, 2.5 and zebra.

#include <algorithm>
#include <iostream>
#include <string>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 0;
    std::cin >> t;
    for (int i = 0; i < t; i++) {
        std::string type;
        int k = 0;
        std::cin >> type >> k;

        // type is "int", "double" or "string". Read the k values into
        // variables of that type, keep the largest with std::max,
        // and print it on its own line.
    }
    return 0;
}

Every evening, each branch of Amara's bakery sends one line of sales, refunds as negative numbers; a branch that sold nothing sends an empty line. Nobody says how many branches there are or how many sales are on a line. This is the biggest input in the module.

Input. One or more lines, until the end of the input, each holding zero or more integers separated by spaces. Every line ends with a newline.

Output. One line per input line with its total (0 for an empty line), then a last line: total, one space, and the total of everything.

Constraints. 1 to 20000 lines, at most 80000 integers in all, each between -1000000000 and 1000000000.

Sample. Input 120 80 -20, 45, an empty line and 7 7 7 gives 180, 45, 0, 21 and total 246.

#include <iostream>
#include <sstream>
#include <string>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    // Read the input line by line until it ends. Print the total of each
    // line on its own line, then one last line: the word total, one
    // space, and the total of every number in the input.

    return 0;
}