Full Programs: Strings at Work

New here: the lines variant, and split(" ").filter(Boolean) on a whole line. The program reads n lines of a draft and reports the total number of words and the longest one. The inner loop is the for-of loop, which Module 4 teaches: it visits each word of the array in turn.

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 = [];

const n = nextInt();
let total = 0;
let longest = "";
for (let i = 0; i < n; i++) {
  const words = next().split(" ").filter(Boolean);
  total += words.length;
  for (const word of words) {
    if (word.length > longest.length) {
      longest = word;
    }
  }
}
out.push(`lines: ${n}`);
out.push(`words: ${total}`);
out.push(`longest: ${longest} (${longest.length} characters)`);

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

lines: 4
words: 8
longest: Template (8 characters)

That output is for the input 4, then four lines. They are a sentence with two spaces in the middle, an empty line, a line that starts with three spaces, and save time. The empty line counted 0 words and the leading spaces counted none. Template and literals both have 8 characters; the > keeps the first one found.

New here: split(""), reverse() and join("") as one chain, and the loop that compares position i with position length - 1 - i.

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 = [];

const phrase = next();
const clean = phrase.toLowerCase().split(" ").join("");
const reversed = clean.split("").reverse().join("");

let same = true;
for (let i = 0; i < clean.length / 2; i++) {
  if (clean[i] !== clean[clean.length - 1 - i]) {
    same = false;
  }
}

out.push(`cleaned:    ${clean}`);
out.push(`reversed:   ${reversed}`);
out.push(`by reverse: ${clean === reversed ? "yes" : "no"}`);
out.push(`by loop:    ${same ? "yes" : "no"}`);

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

cleaned:    neveroddoreven
reversed:   neveroddoreven
by reverse: yes
by loop:    yes

That output is for the input Never odd or even. split(" ").join("") removes the spaces: cut at each space, glue with nothing. With the input Kenji was here, both checks say no. The method chain is shorter to read. The loop builds no second string and only walks to the middle, an idea lesson 06 turns into the two-pointer pattern.

New here: charCodeAt and String.fromCharCode in a loop over every character, with capitals and small letters handled separately and everything else copied unchanged.

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 = [];

const n = nextInt();
for (let i = 0; i < n; i++) {
  const text = next();
  let result = "";
  for (let j = 0; j < text.length; j++) {
    const code = text.charCodeAt(j);
    if (code >= 65 && code <= 90) {
      result += String.fromCharCode((code - 65 + 13) % 26 + 65);
    } else if (code >= 97 && code <= 122) {
      result += String.fromCharCode((code - 97 + 13) % 26 + 97);
    } else {
      result += text[j];
    }
  }
  out.push(result);
}

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

Jul qvq Obo pebff gur ebnq?
To get to the other side!

That output is for the input 2, then a joke and its answer in ROT13. One program hid the question and revealed the answer. The spaces and the ? passed through, because their codes are outside both ranges.

A shift of 13 never goes below 0. A negative shift can, and Module 1's rule for % predicts what goes wrong. The brain teaser below asks you to find it, and Exercise 2 needs the fix.

New here: split(",") plus trim() on every field, and a record that this simple parser gets wrong.

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 = [];

const n = nextInt();
for (let i = 0; i < n; i++) {
  const parts = next().split(",");
  const fields = [];
  for (const part of parts) {
    fields.push(part.trim());
  }
  out.push(`${fields.length} fields: ${fields.join(" | ")}`);
}

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

3 fields: Zara | 14 | Dhaka
3 fields: Bob | 15 | Sylhet
4 fields: "Maria" | 15 | "Flat 3 | Green Road"

That output is for the input 3, then the three records shown. The first two are fine, extra spaces and all. The third is wrong. CSV puts a field in double quotes when it holds a comma, and split knows nothing about quotes, so Maria's address became two fields. Lesson 04 fixes it with a loop.

New here: a character loop that collects runs of letters and digits into words, then join("-"). The test ch >= "a" && ch <= "z" works because < on strings compares codes, as lesson 02 showed.

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 = [];

const title = next();
const lower = title.toLowerCase();

const words = [];
let word = "";
for (const ch of lower) {
  if ((ch >= "a" && ch <= "z") || (ch >= "0" && ch <= "9")) {
    word += ch;
  } else if (word !== "") {
    words.push(word);
    word = "";
  }
}
if (word !== "") {
  words.push(word);
}
const slug = words.join("-");

out.push(`title:     ${title}`);
out.push(`lowercase: ${lower}`);
out.push(`words:     ${words.join(" ")}`);
out.push(`slug:      ${slug}`);

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

title:     Amara's Top 10 Books (2026)!
lowercase: amara's top 10 books (2026)!
words:     amara s top 10 books 2026
slug:      amara-s-top-10-books-2026

That output is for the input Amara's Top 10 Books (2026)!. The last if saves the final word, which no character after it ends. Look at amara-s: our rule turned the apostrophe into a break. Many slug makers delete an apostrophe instead, which is one more rule, not a new idea.

New here: indexOf with a start position to find the second space, slice to cut the line into three parts, a long name shortened, and fixed-width columns.

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 = [];

const WIDTH = 34;
const n = nextInt();
let total = 0;
out.push("Amara's Book Corner".padStart(26));
out.push("-".repeat(WIDTH));
for (let i = 0; i < n; i++) {
  const line = next();
  const a = line.indexOf(" ");
  const b = line.indexOf(" ", a + 1);
  const qty = Number(line.slice(0, a));
  let name = line.slice(b + 1);
  const price = Number(line.slice(a + 1, b));
  if (name.length > 16) {
    name = name.slice(0, 15) + ".";
  }
  const cost = qty * price;
  total += cost;
  out.push(`${name.padEnd(16)}${`${qty} x ${price}`.padStart(10)}${String(cost).padStart(8)}`);
}
out.push("-".repeat(WIDTH));
out.push(`${"TOTAL (Tk)".padEnd(26)}${String(total).padStart(8)}`);

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

       Amara's Book Corner
----------------------------------
Notebook A5        2 x 120     240
Fountain pen       1 x 450     450
Encyclopedia of.  1 x 1250    1250
----------------------------------
TOTAL (Tk)                    1940

That output is for the input 3, then three items, each a quantity, a price in taka and a name. The name may hold spaces, so it is everything after the second space. `${qty} x ${price}` is a template inside another one's ${}: it builds the middle column, then pads it. The 26-character name was cut to 15 characters and a dot, so the columns still line up.