Problems: Strings

Amara's blog editor shows a word count under every paragraph. Bob's first version counted 5 words in a line with a double space, and 1 word in an empty line. Amara wants a counter that is right on every line, however the spaces fall. This problem uses the lines variant of the starter: const lines = input.split("\n"); replaces the token split. Then next() reads from lines and returns the next whole line, empty lines included. Read n with nextInt().

Input. The first line holds n, and n lines of text follow. A word is a maximal run of characters that are not spaces. A line may be empty, may start or end with spaces, and may hold several spaces in a row.

Output. n lines: the number of words on each line of text, in the input order.

Constraints. 1 <= n <= 20000. Each line of text has 0 to 300 printable ASCII characters (codes 32 to 126), and the last one is never empty. Every line ends with a newline.

Sample. Input 4, then Amara writes every day (two spaces after writes), an empty line, hello (two spaces before it) and one two three four, gives 4, 0, 1 and 4 on four lines.

const input = require("fs").readFileSync(0, "utf8");
const lines = input.split("\n");
let at = 0;
const next = () => lines[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
// Read n, then n lines. Per line: the number of words.

console.log(out.join("\n"));

Zara collects palindromes, words that read the same backwards, like noon. Her list mixes capitals and small letters, and she wants Level to count: to a reader, L and l are the same letter. Read the input with the starter's nextInt() and next().

Input. The first line holds n. The second line holds n words, separated by single spaces. Each word is made of the ASCII letters a to z and A to Z.

Output. n lines, one per word, in the input order: yes when the word reads the same backwards with capitals and small letters treated alike, else no.

Constraints. 1 <= n <= 20000. Each word has 1 to 50 letters.

Sample. Input 5 and Level noon Kenji Anna ab gives yes, yes, no, yes and no on five lines.

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
// Read n, then n words. Per word: yes or no.

console.log(out.join("\n"));

Alice and Zara pass notes in a Caesar code: every letter moves k places along the alphabet. The alphabet wraps around, so z is followed by a. Zara picks the shift, and she likes to pick it negative, or far past 26, to see what breaks. This problem uses the lines variant of the starter: const lines = input.split("\n"); replaces the token split. Then next() reads from lines and returns the next whole line, spaces included. Read k with nextInt().

Input. The first line holds the whole number k. The second line holds the text.

Output. One line: the text with every letter moved k places forward in the alphabet, or backward when k is negative. The move wraps around, from z to a going forward and from a to z going back. A capital stays a capital and a small letter stays small. Every other character, a space included, is unchanged.

Constraints. -1000 <= k <= 1000. The text has 1 to 100000 printable ASCII characters (codes 32 to 126). The last line of the input is never empty, and every line ends with a newline.

Sample. Input 3 and Hello, Zara! xyz gives Khoor, Cdud! abc.

const input = require("fs").readFileSync(0, "utf8");
const lines = input.split("\n");
let at = 0;
const next = () => lines[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
// Read k, then the text. Shift every letter k places.

console.log(out.join("\n"));

David prints name badges for a coding camp, and every badge carries the person's initials in one corner. People type their names in any mix of capitals: ada lovelace, ZARA, kEnJi. The badge always shows capitals. This problem uses the lines variant of the starter: const lines = input.split("\n"); replaces the token split. Then next() reads from lines and returns the next whole line, one full name. Read n with nextInt().

Input. The first line holds n, and n lines follow, one full name each. A name is 1 to 6 words of ASCII letters, separated by single spaces, with no space at either end.

Output. n lines, one per name: the first letter of every word as a capital, each followed by a dot, with nothing between them.

Constraints. 1 <= n <= 20000. Each word has 1 to 20 letters, in any mix of capitals and small letters. The last line of the input is never empty, and every line ends with a newline.

Sample. Input 3, then ada lovelace, Grace Brewster Murray Hopper and zara, gives A.L., G.B.M.H. and Z. on three lines.

const input = require("fs").readFileSync(0, "utf8");
const lines = input.split("\n");
let at = 0;
const next = () => lines[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
// Read n, then n names. Per name: the initials, each a capital and a dot.

console.log(out.join("\n"));

Amara's blog builds the web address of every post from its title: the post Hello, World! 2026 lives at /hello-world-2026. The part after the slash is called the slug. It holds only small letters, digits and single hyphens, so it reads well in any browser. This problem uses the lines variant of the starter: const lines = input.split("\n"); replaces the token split. Then next() reads from lines and returns the next whole line, one title. Read n with nextInt().

Input. The first line holds n, and n lines follow, one title each.

Output. n lines, one slug per title. To make a slug, write the title in small letters. Then turn every maximal run of characters that are not a to z or 0 to 9 into one hyphen. Remove a hyphen at the start or at the end. If nothing is left, print the word untitled.

Constraints. 1 <= n <= 10000. Each title has 1 to 200 printable ASCII characters (codes 32 to 126). The last line of the input is never empty, and every line ends with a newline.

Sample. Input 3, then Hello, World! 2026, --- Strings & Template Literals --- and !!!, gives hello-world-2026, strings-template-literals and untitled on three lines.

const input = require("fs").readFileSync(0, "utf8");
const lines = input.split("\n");
let at = 0;
const next = () => lines[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
// Read n, then n titles. Per title: its slug, or untitled.

console.log(out.join("\n"));

Kenji imports a contact list saved as CSV, a text format where commas separate the fields of a record. His first import split every record on its commas and turned the address "12, Lake Road" into two columns. A field in double quotes may hold commas, so the import has to read the quotes. This problem uses the lines variant of the starter: const lines = input.split("\n"); replaces the token split. Then next() reads from lines and returns the next whole line, empty lines included. Read n with nextInt().

Input. The first line holds n, and n lines follow, one record each. The fields of a record are separated by commas, and each field is unquoted or quoted. An unquoted field is any run of characters with no comma and no double quote, the empty run included. A quoted field starts with a double quote. It ends with the double quote that is followed by a comma or by the end of the record. Between the two, any character may appear, a comma included, and two double quotes in a row stand for one. Every record is well formed. Spaces belong to the field, so nothing is trimmed, and an empty record is one empty field.

Output. n lines, one per record: the number of fields, then the text of every field in square brackets, all separated by single spaces. A quoted field is printed without its outer quotes, and each pair of double quotes inside it as one.

Constraints. 1 <= n <= 10000. Each record has 0 to 500 printable ASCII characters (codes 32 to 126). The last line of the input is never empty, and every line ends with a newline.

Sample. Input 3, then Zara,14,Dhaka, "12, Lake Road",Amara,"She said ""hi""" and ,,, gives 3 [Zara] [14] [Dhaka], 3 [12, Lake Road] [Amara] [She said "hi"] and 3 [] [] [] on three lines.

const input = require("fs").readFileSync(0, "utf8");
const lines = input.split("\n");
let at = 0;
const next = () => lines[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
// Read n, then n records. Per record: the field count and every field in brackets.

console.log(out.join("\n"));

Maria's badge printer sized every badge by name.length, and her friend's Bangla name came out the wrong size. Before she fixes it, Maria wants two counts for every line: what length says, and how many code points the line holds. length counts UTF-16 code units, the boxes a JavaScript string is made of. A code point is one Unicode character number. Most characters take one code unit, but a character above U+FFFF, like most emoji, takes two code units and is still one code point. This problem uses the lines variant of the starter: const lines = input.split("\n"); replaces the token split. Then next() reads from lines and returns the next whole line, empty lines included. Read n with nextInt().

Input. The first line holds n, and n lines of text follow, in UTF-8. A line may be empty.

Output. n lines, one per line of text: its length in UTF-16 code units (what length gives), a space, and its number of code points.

Constraints. 1 <= n <= 10000. Each line has 0 to 1000 code points, no carriage return and no lone surrogate. The last line of the input is never empty, and every line ends with a newline.

Sample. Input 3, then Maria, মাহি 😀 and 👋🏽 hi, gives 5 5, 7 6 and 7 5 on three lines.

const input = require("fs").readFileSync(0, "utf8");
const lines = input.split("\n");
let at = 0;
const next = () => lines[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
// Read n, then n lines. Per line: code units, then code points.

console.log(out.join("\n"));

Kenji and Bob play a word game. Kenji says a word, and Bob must answer with an anagram of it: a word that uses exactly the same letters, each as many times. listen and silent are anagrams. aab and abb are not, because a appears twice in one and once in the other. Read the input with the starter's nextInt() and next().

Input. The first line holds n, and n lines follow, each with two words a and b, separated by a space. The words are made of the small letters a to z.

Output. n lines, one per pair: yes when b uses exactly the letters of a, each as many times, else no.

Constraints. 1 <= n <= 200000. Each word has 1 to 100000 letters, and all the words of the input together have at most 400000 letters.

Sample. Input 4, then listen silent, night thing, aab abb and a a, gives yes, yes, no and yes on four lines.

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
// Read n, then n pairs of words. Per pair: yes or no.

console.log(out.join("\n"));

Alice's word game gives one hint per secret word: the first letter of the word that appears in it exactly once, and where it sits. For swiss the hint is w at index 1, because s appears three times. Read the input with the starter's nextInt() and next().

Input. The first line holds n, and n lines follow, one word each. The words are made of the small letters a to z.

Output. n lines, one per word. Print the first letter, from the left, that appears exactly once in the word, then a space and its index counting from 0. When no letter appears exactly once, print none.

Constraints. 1 <= n <= 400000. Each word has 1 to 100000 letters, and all the words of the input together have at most 400000 letters.

Sample. Input 4, then swiss, level, aabb and z, gives w 1, v 2, none and z 0 on four lines.

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
// Read n, then n words. Per word: the first letter seen once and its index, or none.

console.log(out.join("\n"));

Kenji wants to shrink the level files of his game, which are full of long runs like aaaa. Run-length encoding writes each run as its letter and its length, so aaabcc becomes a3b1c2. It only helps when the result is shorter, so Kenji keeps the word as it is otherwise. Read the input with the starter's nextInt() and next().

Input. The first line holds n, and n lines follow, one word each. The words are made of the ASCII letters a to z and A to Z.

Output. n lines, one per word. Split the word into runs: a run is a maximal stretch of one letter repeated, and a capital and its small letter are different letters. Write every run as its letter followed by its length in decimal. Print that form when it is strictly shorter than the word, else the word itself.

Constraints. 1 <= n <= 400000. Each word has 1 to 100000 letters, and all the words of the input together have at most 400000 letters.

Sample. Input 4, then aaabccdddd, abc, aabb and zzzzzzzzzzzz, gives a3b1c2d4, abc, aabb and z12 on four lines.

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
// Read n, then n words. Per word: the run-length form if shorter, else the word.

console.log(out.join("\n"));