Problems: string

Zara wants the longest word in Bob's trip notes, and its length. A word is any run of characters without a space, so a comma stuck to a word is part of it.

Input. Words separated by spaces or line breaks, until the input ends. No count comes first.

Output. One line: the longest word, a space, and its length. On a tie, the first of the longest words.

Constraints. 1 to 100000 words, each 1 to 100 ASCII characters; the input is at most 1000000 bytes.

Sample. Input Bob packs maps, snacks and a camera for the trip gives snacks 6.

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

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

    string word;
    while (cin >> word) {
        // Keep the longest word seen so far.
        // Replace it only when this word is strictly longer.
    }

    // Print the longest word, a space, and its length.

    return 0;
}

Alice needs every address on her club's sign-up list split in two: the user name before the @ and the domain after it.

Input. n, then n email addresses, one per line.

Output. For each address, one line: the part before the @, a space, and the part after it.

Constraints. 1 <= n <= 20000; each address has at most 100 ASCII characters, no spaces, exactly one @, and at least one character on each side of it.

Sample. Input 3, maria@school.example, bob.rahman@mail.example.com and z@x.io gives maria school.example, bob.rahman mail.example.com and z x.io on three lines.

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

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

    int n = 0;
    cin >> n;
    for (int i = 0; i < n; i++) {
        string email;
        cin >> email;

        // Find the '@'. Print the part before it, a space,
        // and the part after it, on one line.
    }

    return 0;
}

Amara's text editor needs find-and-replace. Replace every occurrence of from in the text with to, scanning left to right, and count the replacements. Never search inside a piece you have just put in, and resolve overlaps leftmost first: aaa with aa and b gives ba and 1.

Input. Line 1: the text, which may contain spaces. Line 2: from. Line 3: to.

Output. The new text on line 1, and the number of replacements on line 2.

Constraints. The text has 1 to 100000 ASCII characters; from and to each have 1 to 10 characters and no space.

Sample. Input I like cats. My cat likes catnip., cat and dog gives I like dogs. My dog likes dognip. and 3 on two lines.

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

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

    string text, from, to;
    getline(cin, text);
    getline(cin, from);
    getline(cin, to);

    // Replace every occurrence of from in text, left to right.
    // Never search inside a piece you have just put in.
    // Print the new text, then the number of replacements, on two lines.

    return 0;
}

David's account totals are hard to read. Print each number with a comma every three digits, counted from the right. A minus sign stays in front, as in -1,000, and 0 prints as 0.

Input. n, then n integers, one per line.

Output. Each number on its own line, with its commas.

Constraints. 1 <= n <= 20000, and each integer is between -10¹⁸ and 10¹⁸.

Sample. Input 5, 0, 999, 1000, -1234567 and 1000000000000000000 gives 0, 999, 1,000, -1,234,567 and 1,000,000,000,000,000,000 on five lines.

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

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

    int n = 0;
    cin >> n;
    for (int i = 0; i < n; i++) {
        long long x = 0;
        cin >> x;

        // Turn x into text with to_string. Print it with a comma
        // between every group of three digits, counted from the right.
        // A minus sign stays in front, with no comma after it.
    }

    return 0;
}

Maria wants to know which letters a text uses. Count the letters a to z, with a capital counted as its small letter. Digits, spaces and punctuation are not letters.

Input. A text of one or more lines, until the input ends.

Output. For each letter that appears, from a to z, one line: the letter, a space, its count. If no letter appears, the word none.

Constraints. The text is at most 1000000 bytes of ASCII.

Sample. Input Hello, World! and Zara 2026 gives nine lines: a 2, d 1, e 1, h 1, l 3, o 2, r 2, w 1 and z 1.

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

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

    vector<int> count(26, 0);
    string line;
    while (getline(cin, line)) {
        // For every letter of the line, turn a capital into a small
        // letter, then add 1 to count[letter - 'a'].
    }

    // For each letter from a to z that appears, print the letter,
    // a space and its count. Print "none" if no letter appears.

    return 0;
}

Kenji exported the class marks as CSV lines of the form name,mark1,mark2,mark3. A name can hold single spaces. Print the name with the best total, and the total.

Input. n, then n lines name,mark1,mark2,mark3.

Output. The best name on line 1 and its total on line 2. On a tie, the first of them.

Constraints. 1 <= n <= 20000. A name has 1 to 40 characters: letters, with single spaces inside, no comma and no space at either end. Each mark is from 0 to 100.

Sample. Input 4, Maria Rose,90,85,77, Bob,100,60,95, Zara Bell,88,95,72 and Kenji,70,70,70 gives Bob and 255 on two lines.

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

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

    int n = 0;
    cin >> n;
    string line;
    getline(cin, line); // finish the line that held n

    for (int i = 0; i < n; i++) {
        getline(cin, line);

        // Split the line at its commas: a name, then three marks.
        // Keep the name with the highest total; the first one wins a tie.
    }

    // Print the best name on one line and its total on the next.

    return 0;
}

David's chat app sends messages backwards. Print each line's words from the last to the first, with single spaces. A line can have extra spaces between words, and spaces at its start or end.

Input. n, then n lines, each with 1 to 1000 words of letters and digits separated by one or more spaces.

Output. Each line's words in reverse order, separated by single spaces.

Constraints. The whole input is at most 1000000 bytes.

Sample. Input 3, the quick brown fox, Zara tests edge cases and hello gives fox brown quick the, cases edge tests Zara and hello on three lines.

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

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

    int n = 0;
    cin >> n;
    string line;
    getline(cin, line); // finish the line that held n

    for (int i = 0; i < n; i++) {
        getline(cin, line);

        // Read the words of the line, then print them from the last
        // to the first, separated by single spaces.
    }

    return 0;
}

Zara keeps only the letters and digits of a line, in small letters, and asks whether that reads the same both ways. An empty result counts as a palindrome.

Input. n, then n lines.

Output. For each line, yes or no.

Constraints. Each line has 1 to 100000 printable ASCII characters, and the whole input is at most 1000000 bytes.

Sample. Input 5, A man, a plan, a canal: Panama, race a car, ?!, No 'x' in Nixon and 12321 gives yes, no, yes, yes and yes on five lines.

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

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

    int n = 0;
    cin >> n;
    string line;
    getline(cin, line); // finish the line that held n

    for (int i = 0; i < n; i++) {
        getline(cin, line);

        // Keep only the letters and digits, as small letters.
        // Print "yes" if what is left reads the same both ways, else "no".
    }

    return 0;
}

Kenji encodes a string of small letters: every maximal run of one letter becomes the letter followed by the run's length. So aaabccdddd becomes a3b1c2d4.

Input. One string of small letters.

Output. The encoded string on one line.

Constraints. The string has 1 to 500000 letters. The largest test, 500000 runs of length 1, runs out of time if you rebuild the answer with ans = ans + ...; it was measured on GCC 12.

Sample. Input aaabccdddd gives a3b1c2d4.

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

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

    string s;
    cin >> s;

    // For each run of equal letters, add the letter and the length
    // of the run to the answer. Print the answer on one line.

    return 0;
}

Amara's calculator must add two non-negative integers far too big for a long long. Read them as strings and print the sum.

Input. Two lines, each with one non-negative integer.

Output. The sum on one line.

Constraints. Each number has 1 to 100000 digits, with no leading zeros except the number 0 itself.

Sample. Input 958 and 67 gives 1025.

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

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

    string a, b;
    cin >> a >> b;

    // Add the two numbers digit by digit, from the right,
    // carrying 1 whenever a column reaches 10. Print the sum.

    return 0;
}