Learn C++ STL

lesson ā§­ / ⧝ ¡ string: āϝ⧇ text āύāĻŋāĻœā§‡āϰ length āύāĻŋāĻœā§‡āχ āϜāĻžāύ⧇

Module ā§Š ¡ string: āϝ⧇ text āύāĻŋāĻœā§‡āϰ length āύāĻŋāĻœā§‡āχ āϜāĻžāύ⧇

Problem: string

FreeProblem

āĻāχ lesson-āĻ āϝāĻž āĻļāĻŋāĻ–āĻŦ⧇

  • cin >> āĻĻāĻŋāϝāĻŧ⧇ word āφāϰ getline āĻĻāĻŋāϝāĻŧ⧇ āĻĒ⧁āϰ⧋ āϞāĻžāχāύ āĻĒāĻĄāĻŧāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĒāϰ⧇ āφāϏāĻž āϞāĻžāχāύāĻ“āĨ¤
  • find, substr, += āφāϰ to_string āĻĻāĻŋāϝāĻŧ⧇ text āĻ­āĻžāĻ™āϤ⧇ āφāϰ āωāĻ¤ā§āϤāϰ āĻ—āĻĄāĻŧāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āĻĒā§āϰāϤāĻŋāϟāĻž āĻ–ā§‹āρāϜ string::npos-āĻāϰ āϏāĻžāĻĨ⧇ āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇āĨ¤
  • āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϜāĻ¨ā§āϝ long long āύāĻžāĻ•āĻŋ digit-āĻāϰ āĻāĻ•āϟāĻž string, āϏ⧇āϟāĻž āĻŦāĻžāĻ›āϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ āϞāĻŽā§āĻŦāĻž āωāĻ¤ā§āϤāϰ āϏāĻŽāϝāĻŧ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻ—āĻĄāĻŧāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤

āĻĻāĻļāϟāĻž problem, hidden test āĻĻāĻŋāϝāĻŧ⧇ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āĻāχ module-āĻāϰ lesson 01 āĻĨ⧇āϕ⧇ 06-āĻāϰ āϕ⧋āύ⧋ āĻāĻ•āϟāĻž idea-āϰ āĻ…āύ⧁āĻļā§€āϞāύāĨ¤ Problem 1, 2 āφāϰ 5 āĻĢā§āϰāĻŋāĨ¤ āĻŦāĻžāĻ•āĻŋ āϏāĻžāϤāϟāĻž āĻ–ā§‹āϞ⧇ Learn Pro āĻŦāĻž track āĻ•āĻŋāύāϞ⧇āĨ¤

Bob sample āĻĒāĻĄāĻŧ⧇, āĻāĻ•āϟāĻž loop āϞ⧇āϖ⧇, āφāϰ submit āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧāĨ¤ Zara āφāϗ⧇ āϚāĻžāϞāĻŋāϝāĻŧ⧇ āĻĻ⧇āϖ⧇ āĻāĻ•āϟāĻž word, āϕ⧋āύ⧋ āĻŽāĻŋāϞ āύāĻž āĻĨāĻžāĻ•āĻž, space āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧁āϰ⧁ āĻšāĻ“āϝāĻŧāĻž āϞāĻžāχāύ āφāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ inputāĨ¤ Text āύāĻŋāϝāĻŧ⧇ āĻāχ set-āĻ Zara-āϰ āĻ…āĻ­ā§āϝāĻžāϏāϟāĻžāχ āύāĻŽā§āĻŦāϰ āφāύ⧇āĨ¤

āĻĒā§āϰāϤāĻŋāϟāĻž starter text āĻĒāĻĄāĻŧ⧇ āϤāĻŋāύāϟāĻž āϧāĻžāρāĻšā§‡āϰ āĻāĻ•āϟāĻžāϝāĻŧ

āĻĒā§āϰāϤāĻŋāϟāĻž starter ios::sync_with_stdio(false); āφāϰ cin.tie(nullptr); āĻĻāĻŋāϝāĻŧ⧇ fast input āφāϰ output āϚāĻžāϞ⧁ āĻ•āϰ⧇, Module 1 āĻĨ⧇āϕ⧇āĨ¤ āϤāĻžāϰāĻĒāϰ input āĻĒāĻĄāĻŧ⧇ āϤāĻŋāύāϟāĻž āϧāĻžāρāĻšā§‡āϰ āϕ⧋āύ⧋ āĻāĻ•āϟāĻžāϝāĻŧāĨ¤ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ test āĻĒā§āϰāĻžāϝāĻŧ 1 MB text, āϤāĻžāχ āĻĒāĻĄāĻŧāĻžāϰ āĻ—āϤāĻŋ āĻāĻ–āĻžāύ⧇ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖāĨ¤

āĻ•āĻŋāϛ⧁ problem āĻĻ⧇āϝāĻŧ word: cin >> word space āĻ›āĻžāĻĄāĻŧāĻž character-āĻāϰ āĻāĻ•āϟāĻž āϟāĻžāύāĻž āϏāĻžāϰāĻŋ āĻĒāĻĄāĻŧ⧇, āφāϰ āϤāĻžāϰ āφāϗ⧇āϰ āϏāĻŦ space āφāϰ āύāϤ⧁āύ āϞāĻžāχāύ āĻĒāĻžāϰ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ āĻ•āĻŋāϛ⧁ āĻĻ⧇āϝāĻŧ āϞāĻžāχāύ: getline(cin, line) āĻĒ⧁āϰ⧋ āĻāĻ•āϟāĻž āϞāĻžāχāύ āĻĒāĻĄāĻŧ⧇, space-āϏāĻš, āφāϰ āĻļ⧇āώ⧇āϰ āύāϤ⧁āύ āϞāĻžāχāύāϟāĻž āĻĢ⧇āϞ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āφāϰ āĻ•āĻŋāϛ⧁ āφāϗ⧇ āĻāĻ•āϟāĻž count āĻĻ⧇āϝāĻŧ, āϤāĻžāϰāĻĒāϰ āϞāĻžāχāύāĨ¤ āĻāχ āϤ⧃āϤ⧀āϝāĻŧ āϧāĻžāρāĻšā§‡āϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻāĻ•āϟāĻž āĻĢāĻžāρāĻĻ āφāϛ⧇, āĻĻ⧁āχ section āĻĒāϰ⧇āĨ¤

Judge āĻ•āĻ–āύ⧋ āϤ⧋āĻŽāĻžāϰ string-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āϤāĻžāĻ•āĻžāϝāĻŧ āύāĻžāĨ¤ āĻ“ āĻāĻ•āϟāĻž hidden input āĻĻāĻŋāϝāĻŧ⧇ āĻĒ⧁āϰ⧋ program āϚāĻžāϞāĻžāϝāĻŧ, āφāϰ program āϝāĻž print āĻ•āϰ⧇ āϏ⧇āϟāĻž āϞāĻžāχāύ āϧāϰ⧇ āϧāϰ⧇ āĻŽā§‡āϞāĻžāϝāĻŧāĨ¤ āϞāĻžāχāύ⧇āϰ āĻļ⧇āώ⧇ āĻŦāĻžāĻĄāĻŧāϤāĻŋ space judge āϧāϰ⧇ āύāĻž, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϞāĻžāχāύ⧇āϰ āĻ­āĻŋāϤāϰ⧇āϰ space āϧāϰ⧇āĨ¤ yes, no āφāϰ none-āĻāϰ āĻŽāϤ⧋ āĻļāĻŦā§āĻĻ āϝ⧇āĻŽāύ āϞ⧇āĻ–āĻž, āĻšā§āĻŦāĻšā§ āϤ⧇āĻŽāύ print āĻ•āϰ⧋āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ āĻļ⧇āώ āĻ•āϰ⧋ '\n' āĻĻāĻŋāϝāĻŧ⧇āĨ¤

āĻļ⧁āϧ⧁ ASCII, āϤāĻžāχ size() āĻŽāĻžāύ⧇āχ character āĻ•āϝāĻŧāϟāĻž

Lesson 01 āĻĻ⧇āĻ–āĻŋāϝāĻŧ⧇āϛ⧇, string āĻšāϞ⧋ byte-āĻāϰ āĻāĻ•āϟāĻž āϏāĻžāϰāĻŋāĨ¤ UTF-8-āĻ āĻāĻ•āϟāĻž āĻŦāĻžāĻ‚āϞāĻž āĻ…āĻ•ā§āώāϰ āύ⧇āϝāĻŧ 3 byte, āϤāĻžāχ āĻāĻ•āϟāĻž āĻŦāĻžāĻ‚āϞāĻž word-āĻāϰ size() āĻ“āϰ āĻ…āĻ•ā§āώāϰ⧇āϰ āϏāĻ‚āĻ–ā§āϝāĻž āύāĻžāĨ¤ āĻāχ set-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻž input ASCII: 32 āĻŽāĻžāύ⧇ space āĻĨ⧇āϕ⧇ 126 āĻŽāĻžāύ⧇ tilde ~ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ character, āϏāĻžāĻĨ⧇ āύāϤ⧁āύ āϞāĻžāχāύāĨ¤ āĻāĻĻ⧇āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āĻāĻ• byteāĨ¤

āϤāĻžāχ āĻāĻ–āĻžāύ⧇ s.size() āĻŽāĻžāύ⧇āχ character āĻ•āϝāĻŧāϟāĻž, āφāϰ s[i] āĻšāϞ⧋ position i-āĻāϰ character, 0 āĻĨ⧇āϕ⧇ āϗ⧁āύ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž statement āĻ•āĻĨāĻžāϟāĻž āφāĻŦāĻžāϰ āĻŦāϞ⧇, āϝ⧇āύ āϕ⧋āύ⧋ āωāĻ¤ā§āϤāϰ text-āĻāϰ encoding-āĻāϰ āωāĻĒāϰ āύāĻŋāĻ°ā§āĻ­āϰ āύāĻž āĻ•āϰ⧇āĨ¤ āĻ…āĻ•ā§āώāϰāϗ⧁āϞ⧋ āĻŦāϏ⧇ āĻĻ⧁āχāϟāĻž āϟāĻžāύāĻž āϏāĻžāϰāĻŋāϤ⧇, 'A' āĻĨ⧇āϕ⧇ 'Z' āφāϰ 'a' āĻĨ⧇āϕ⧇ 'z', āφāϰ digit-āϗ⧁āϞ⧋ '0' āĻĨ⧇āϕ⧇ '9'āĨ¤

cin >> n-āĻāϰ āĻĒāϰ⧇ āϞāĻžāχāύ āĻĒāĻĄāĻŧāϤ⧇ āφāϗ⧇ āĻāĻ•āϟāĻž getline āϞāĻžāϗ⧇

cin >> n āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āĻĒāĻĄāĻŧ⧇, āφāϰ āĻĨāĻžāĻŽā§‡ āĻ āĻŋāĻ• āĻ“āϰ āĻļ⧇āώ digit-āĻāϰ āĻĒāϰ⧇āĨ¤ āϝ⧇ āύāϤ⧁āύ āϞāĻžāχāύ āĻĻāĻŋāϝāĻŧ⧇ āĻ“āχ āϞāĻžāχāύāϟāĻž āĻļ⧇āώ āĻšāϝāĻŧ⧇āĻ›āĻŋāϞ, āϏ⧇āϟāĻž āϤāĻ–āύ⧋ input-āĻ āĻ…āĻĒ⧇āĻ•ā§āώāĻž āĻ•āϰāϛ⧇āĨ¤ āĻĒāϰ⧇āϰ getline āĻĒāĻĄāĻŧ⧇ āĻ“āχ āύāϤ⧁āύ āϞāĻžāχāύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ, āϤāĻžāχ āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ āĻāĻ•āϟāĻž āĻĢāĻžāρāĻ•āĻž āϞāĻžāχāύāĨ¤

āĻāχ āĻ•āĻžāϰāϪ⧇āχ āύāĻŋāĻšā§‡āϰ āϤāĻŋāύāϟāĻž starter count āĻĒāĻĄāĻŧāĻžāϰ āĻĒāϰ⧇ āĻāĻ•āĻŦāĻžāϰ getline(cin, line); call āĻ•āϰ⧇, āĻĒāĻžāĻļ⧇ comment "finish the line that held n"āĨ¤ āĻ“āχ āϞāĻžāχāύāϟāĻž āϰ⧇āϖ⧇ āĻĻāĻžāĻ“āĨ¤ āĻ“āϟāĻž āύāĻž āĻĨāĻžāĻ•āϞ⧇ āϤ⧁āĻŽāĻŋ āĻĒā§āϰāĻĨāĻŽā§‡ check āĻ•āϰāĻŦ⧇ āĻĢāĻžāρāĻ•āĻž āϞāĻžāχāύāϟāĻž, āφāϰ āĻļ⧇āώ⧇āϰ āφāϏāϞ āϞāĻžāχāύāϟāĻž āĻ•āĻ–āύ⧋ āĻĒāĻĄāĻŧāĻžāχ āĻšāĻŦ⧇ āύāĻžāĨ¤ āύāĻŋāĻšā§‡āϰ āϭ⧁āϞ 1 output-āϟāĻž āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤

find āϖ⧁āρāĻœā§‡ āύāĻž āĻĒ⧇āϞ⧇ āĻĻ⧇āϝāĻŧ npos, āĻ•āĻ–āύ⧋ -1 āύāĻž

s.find(t) āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ āϏ⧇āχ index, āϝ⧇āĻ–āĻžāύ⧇ s-āĻāϰ āĻ­āĻŋāϤāϰ⧇ t āĻĒā§āϰāĻĨāĻŽ āĻļ⧁āϰ⧁ āĻšāϝāĻŧāĨ¤ āϕ⧋āύ⧋ āĻŽāĻŋāϞ āύāĻž āĻĨāĻžāĻ•āϞ⧇ āĻĻ⧇āϝāĻŧ string::npos, āĻāĻ•āϟāĻž size_t-āĻ āϝāϤ āĻŦāĻĄāĻŧ āĻŽāĻžāύ āϧāϰ⧇, āϤāĻžāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧāϟāĻžāĨ¤ āϤāĻžāχ check āϏāĻŦāϏāĻŽāϝāĻŧ pos == string::npos, āĻ•āĻ–āύ⧋ pos == -1 āĻŦāĻž pos < 0 āύāĻžāĨ¤

āĻĢāϞāϟāĻž āϰāĻžāĻ–ā§‹ āĻāĻ•āϟāĻž size_t-āĻ, find āϝ⧇ type āĻĻ⧇āϝāĻŧ āϏ⧇āϟāĻžāϤ⧇āχāĨ¤ s.find(t, from) āĻ–ā§‹āρāϜāĻž āĻļ⧁āϰ⧁ āĻ•āϰ⧇ index from āĻĨ⧇āϕ⧇, āφāϰ āĻāĻ­āĻžāĻŦ⧇āχ āĻāĻ•āϟāĻž loop āϏāĻŦ āĻŽāĻŋāϞ āϖ⧁āρāĻœā§‡ āĻĒāĻžāϝāĻŧāĨ¤ substr(pos, len) pos āĻĨ⧇āϕ⧇ len-āϟāĻž character āύ⧇āϝāĻŧ, āφāϰ substr(pos) āύ⧇āϝāĻŧ pos āĻĨ⧇āϕ⧇ āĻļ⧇āώ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻŦāĻ•āĻŋāϛ⧁āĨ¤ āϤāĻžāχ find āφāϰ substr āĻŽāĻŋāϞ⧇ āĻāĻ•āϟāĻž string-āϕ⧇ āϝ⧇āϕ⧋āύ⧋ character-āĻ āĻ•āĻžāϟāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āϏāĻ‚āĻ–ā§āϝāĻž āϝāĻ–āύ long long-āϕ⧇āĻ“ āĻ›āĻžāĻĄāĻŧāĻŋāϝāĻŧ⧇ āϝāĻžāϝāĻŧ

āĻāĻ•āϟāĻž long long-āĻ āϧāϰ⧇ 9223372036854775807 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ, āĻŽāĻžāύ⧇ 9 x 1018-āĻāϰ āĻāĻ•āϟ⧁ āĻŦ⧇āĻļāĻŋāĨ¤ thousands-separator āĻāϰ āĻ­āĻŋāϤāϰ⧇āχ āĻĨāĻžāϕ⧇: āĻ“āϰ āϏāĻ‚āĻ–ā§āϝāĻž āϝāĻžāϝāĻŧ 1018 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ, āφāϰ -1018-āĻ“ āϧāϰ⧇ āϝāĻžāϝāĻŧāĨ¤ to_string(x) āĻāĻŽāύ āϏāĻ‚āĻ–ā§āϝāĻžāϕ⧇ text āĻŦāĻžāύāĻžāϝāĻŧ, āφāϰ stoi āφāϰ stoll text-āϕ⧇ āφāĻŦāĻžāϰ āϏāĻ‚āĻ–ā§āϝāĻž āĻŦāĻžāύāĻžāϝāĻŧāĨ¤

big-add āφāϞāĻžāĻĻāĻžāĨ¤ āĻ“āϰ āϏāĻ‚āĻ–ā§āϝāĻžāϝāĻŧ 100000 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ digit, āφāϰ āϕ⧋āύ⧋ built-in type-āĻ 20āϟāĻž digit-āĻ“ āϧāϰ⧇ āύāĻžāĨ¤ āĻāĻŽāύ āϏāĻ‚āĻ–ā§āϝāĻž string āĻšāϝāĻŧ⧇āχ āĻĨāĻžāϕ⧇, āφāϰ āϤ⧁āĻŽāĻŋ āĻ“āϟāĻž āϝ⧋āĻ— āĻ•āϰ⧋ āĻ–āĻžāϤāĻžāϝāĻŧ āϝ⧇āĻ­āĻžāĻŦ⧇ āĻ•āϰ⧋, āĻāĻ• āĻ•āϞāĻžāĻŽ āĻ•āϰ⧇āĨ¤ āĻ›āĻŦāĻŋāϤ⧇ sample-āϟāĻž, 958 āϝ⧋āĻ— 67āĨ¤

958 āφāϰ 67 āĻāĻ• āĻ•āϞāĻžāĻŽ āĻ•āϰ⧇ āϝ⧋āĻ—, āĻšāĻžāϤ⧇āϰ āϏāĻ‚āĻ–ā§āϝāĻžāϏāĻš big-add: 958 + 67, āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻĄāĻžāύ⧇āϰ āĻ•āϞāĻžāĻŽ āĻĨ⧇āϕ⧇ āĻšāĻžāϤ⧇ a b āϝ⧋āĻ—āĻĢāϞ 1 1 1 9 5 8 + 6 7 1 0 2 5 āĻāĻ•āĻ•: 8 + 7 = 15, āϞ⧇āĻ–ā§‹ 5, āĻšāĻžāϤ⧇ 1 āĻĻāĻļāĻ•: 5 + 6 + 1 = 12, āϞ⧇āĻ–ā§‹ 2, āĻšāĻžāϤ⧇ 1 āĻļāϤāĻ•: 9 + 1 = 10, āϞ⧇āĻ–ā§‹ 0, āĻšāĻžāϤ⧇ 1 āĻļ⧇āώ⧇āϰ āĻšāĻžāϤ⧇āϰ 1 āύāϤ⧁āύ āĻ•āϞāĻžāĻŽ Digit āĻŦ⧇āϰ āĻšāϝāĻŧ āĻāĻ•āĻ• āĻĨ⧇āϕ⧇, āϤāĻžāχ program āĻ“āĻĻ⧇āϰ āĻĒāϰāĻĒāϰ āĻŦāϏāĻžāϝāĻŧ, āϤāĻžāϰāĻĒāϰ string-āϟāĻž āĻāĻ•āĻŦāĻžāϰ āωāĻ˛ā§āĻŸā§‡ āĻĻ⧇āϝāĻŧāĨ¤

āĻāĻ•āϟāĻž āĻ•āϞāĻžāĻŽ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻāĻ•āϟāĻž digit āφāϰ āĻšāĻžāϤ⧇āϰ āϏāĻ‚āĻ–ā§āϝāĻž āϝ⧋āĻ— āĻ•āϰ⧇āĨ¤ āĻ“āϰ āĻļ⧇āώ digit-āϟāĻž āϞ⧇āĻ–āĻž āĻšāϝāĻŧ, āφāϰ āĻĻāĻļāϕ⧇āϰ āĻ…āĻ‚āĻļāϟāĻž āĻšāϝāĻŧ āĻĒāϰ⧇āϰ āĻšāĻžāϤ⧇āϰ āϏāĻ‚āĻ–ā§āϝāĻžāĨ¤ āĻĻ⧁āχāϟāĻž āĻ•āĻŋāύāĻžāϰāĻž, āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āφāϗ⧇ āĻĢ⧁āϰāĻŋāϝāĻŧ⧇ āϗ⧇āϞ⧇ āϕ⧀ āĻšāϝāĻŧ āφāϰ āĻļ⧇āώ⧇ āĻšāĻžāϤ⧇ āĻ•āĻŋāϛ⧁ āĻĨāĻžāĻ•āϞ⧇ āϕ⧀ āĻšāϝāĻŧ, āϏ⧇āϟāĻž problem-āϟāĻžāϰ āĻ•āĻžāϜāĨ¤

āωāĻ¤ā§āϤāϰ āĻŦāĻžāĻĄāĻŧāĻžāĻ“ += āĻĻāĻŋāϝāĻŧ⧇, ans = ans + piece āĻĻāĻŋāϝāĻŧ⧇ āύāĻž

āĻĒā§āϰāϤāĻŋāϟāĻž problem āĻāĻ•āϟāĻž test-āĻ āϏāĻŽāϝāĻŧ āĻĻ⧇āϝāĻŧ 1 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ, āĻĒ⧁āϰ⧋ program-āĻāϰ āϜāĻ¨ā§āϝ, input āĻĒāĻĄāĻŧāĻžāϏāĻšāĨ¤ run-length-āĻ āĻāĻ• āĻ…āĻ•ā§āώāϰ⧇āϰ 500000āϟāĻž āĻĻāϞ⧇āϰ āωāĻ¤ā§āϤāϰ 1000000 character āϞāĻŽā§āĻŦāĻžāĨ¤ āĻ“āϟāĻž āϕ⧀āĻ­āĻžāĻŦ⧇ āĻŦāĻžāĻĄāĻŧāĻžāĻšā§āĻ›, āϤāĻžāϰ āωāĻĒāϰāχ āύāĻŋāĻ°ā§āĻ­āϰ āĻ•āϰ⧇ āϤ⧁āĻŽāĻŋ āĻĒāĻžāĻļ āĻ•āϰāĻŦ⧇ āĻ•āĻŋ āύāĻžāĨ¤

ans += piece āϟ⧁āĻ•āϰ⧋āϟāĻž āĻŦāϏāĻžāϝāĻŧ ans-āĻāϰ āĻļ⧇āώ⧇, āĻ“ āϝ⧇āĻ–āĻžāύ⧇ āφāϛ⧇ āϏ⧇āĻ–āĻžāύ⧇āχāĨ¤ āϕ⧇āύ āĻāϤ⧇ āĻĒā§āϰāϤāĻŋ character-āĻ amortised O(1) āĻ–āϰāϚ, āϏ⧇āϟāĻž lesson 05 āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤ ans = ans + piece āφāϗ⧇ āĻāĻ•āĻĻāĻŽ āύāϤ⧁āύ āĻāĻ•āϟāĻž string āĻŦāĻžāύāĻžāϝāĻŧ: āĻĒ⧁āϰ⧋ ans-āĻāϰ āĻāĻ•āϟāĻž copy, āϤāĻžāϰāĻĒāϰ āϟ⧁āĻ•āϰ⧋āϟāĻžāĨ¤ Loop-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āĻāϟāĻž āĻĒā§āϰāϤāĻŋāϟāĻž āĻĻāϞ⧇āϰ āϜāĻ¨ā§āϝ āĻĒ⧁āϰ⧋ āωāĻ¤ā§āϤāϰāϟāĻž āĻāĻ•āĻŦāĻžāϰ āĻ•āϰ⧇ copy āĻ•āϰ⧇āĨ¤

āφāĻŽāϰāĻž āĻĻ⧁āχāϟāĻžāχ āĻŽā§‡āĻĒ⧇āĻ›āĻŋ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ test-āĻ, āĻŽāĻžāύ⧇ length 1-āĻāϰ 500000āϟāĻž āĻĻāϞ⧇, āφāϰ āĻ“āϰ āĻĒā§āϰāĻĨāĻŽ 10000 āĻĨ⧇āϕ⧇ 200000 āĻ…āĻ•ā§āώāϰ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž program chrono::steady_clock āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧁āϧ⧁ encode āĻ•āϰāĻžāϰ loop-āĻāϰ āϏāĻŽāϝāĻŧ āĻŽā§‡āĻĒ⧇āϛ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž Compiler Explorer-āĻ GCC 12.2, g++ -O2 -std=c++17 āĻĻāĻŋāϝāĻŧ⧇ āϚāĻžāϞāĻžāύ⧋, Playground-āĻāϰ flag-āĻ“ āĻāϗ⧁āϞ⧋āχāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻžāϰāĻŋ āĻĻ⧁āχāϟāĻž session-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻžāϝāĻŧ āĻ…āĻ¨ā§āϤāϤ āϤāĻŋāύāĻŦāĻžāϰ āϚāϞ⧇āϛ⧇, āφāϰ table-āĻ āφāϛ⧇ āĻĒāϰāĻŋāϏāϰāĨ¤ Compiler Explorer āĻĒā§āϰāĻžāϝāĻŧ 20 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒāϰ⧇ program āĻĨāĻžāĻŽāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤

āωāĻĒāĻžāϝāĻŧInputāϏāĻŽāϝāĻŧ, āĻĻ⧁āχ session-āĻ
ans = ans + piece10000 āĻ…āĻ•ā§āώāϰ2.7 āĻĨ⧇āϕ⧇ 5.8 ms
ans = ans + piece25000 āĻ…āĻ•ā§āώāϰ36 āĻĨ⧇āϕ⧇ 50 ms
ans = ans + piece50000 āĻ…āĻ•ā§āώāϰ289 āĻĨ⧇āϕ⧇ 475 ms
ans = ans + piece100000 āĻ…āĻ•ā§āώāϰ1988 āĻĨ⧇āϕ⧇ 4325 ms
ans = ans + piece200000 āĻ…āĻ•ā§āώāϰāϚāĻžāϰāϟāĻž run-āĻ 12642 āĻĨ⧇āϕ⧇ 14958 ms; āĻĻ⧁āχāϟāĻž run āĻĒā§āϰāĻžāϝāĻŧ 20 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒāϰ⧇ āĻĨāĻžāĻŽāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧ⧇āϛ⧇
ans = ans + piece500000 āĻ…āĻ•ā§āώāϰ, āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ testāĻ›āϝāĻŧāĻŦāĻžāϰāχ āĻĒā§āϰāĻžāϝāĻŧ 20 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒāϰ⧇ āĻĨāĻžāĻŽāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧ⧇āϛ⧇
ans += piece500000 āĻ…āĻ•ā§āώāϰ, āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ test5.6 āĻĨ⧇āϕ⧇ 12.8 ms
run-length: āωāĻ¤ā§āϤāϰ āĻ—āĻĄāĻŧāĻž ans = ans + piece āĻŦāύāĻžāĻŽ += āĻĻāĻŋāϝāĻŧ⧇, log scale-āĻ āϏāĻŽāϝāĻŧ, log scale (āĻĒā§āϰāϤāĻŋ grid āϞāĻžāχāύ⧇ āĻĻāĻļ āϗ⧁āĻŖ), GCC 12.2 -O2, āĻĻ⧁āχ session 1 ms 10 ms 100 ms 1 s āϏ⧀āĻŽāĻž 10 s 100 s ans = ans + piece 10000 āĻ…āĻ•ā§āώāϰ 2.7 āĻĨ⧇āϕ⧇ 5.8 ms 25000 āĻ…āĻ•ā§āώāϰ 36 āĻĨ⧇āϕ⧇ 50 ms 50000 āĻ…āĻ•ā§āώāϰ 289 āĻĨ⧇āϕ⧇ 475 ms 100000 āĻ…āĻ•ā§āώāϰ 1988 āĻĨ⧇āϕ⧇ 4325 ms 200000 āĻ…āĻ•ā§āώāϰ 12642 ms āĻĨ⧇āϕ⧇ 20 s+ 500000 āĻ…āĻ•ā§āώāϰ āĻĨāĻžāĻŽāĻžāύ⧋, 20 s+ ans += piece 500000 āĻ…āĻ•ā§āώāϰ 5.6 āĻĨ⧇āϕ⧇ 12.8 ms āĻ…āĻ•ā§āώāϰ āĻĻā§āĻŦāĻŋāϗ⧁āĻŖ āĻšāϞ⧇ āϏāĻŽāϝāĻŧ āĻŦ⧇āĻĄāĻŧ⧇āϛ⧇ āĻĒā§āϰāĻžāϝāĻŧ 4 āĻĨ⧇āϕ⧇ 13 āϗ⧁āĻŖ: copy āĻ•āϰāĻžāϰ āĻ•āĻžāϜ input-āĻāϰ āĻšā§‡āϝāĻŧ⧇ āĻ…āύ⧇āĻ• āĻĻā§āϰ⧁āϤ āĻŦāĻžāĻĄāĻŧ⧇āĨ¤

āĻĻ⧁āχāϟāĻž version-āχ āĻāĻ•āχ āĻ āĻŋāĻ• āωāĻ¤ā§āϤāϰ print āĻ•āϰ⧇āĨ¤ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ test-āĻ ans += piece-āĻāϰ āϞāĻžāϗ⧇ 5.6 āĻĨ⧇āϕ⧇ 12.8 ms, āφāϰ āĻ…āĻ¨ā§āϝ āωāĻĒāĻžāϝāĻŧāϟāĻž Compiler Explorer-āĻ āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰāχ āϏāĻŽāϝāĻŧ āĻĢ⧁āϰāĻŋāϝāĻŧ⧇ āĻĢ⧇āϞ⧇āĨ¤ āĻ“āχ test run-length-āĻāϰ hidden set-āĻ āĻĨ⧇āϕ⧇ āϝāĻžāϝāĻŧ, āϤāĻžāχ ans = ans + piece āĻĒāĻžāĻļ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤ Loop-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āĻŦāĻžāĻĄāĻŧāϤ⧇ āĻĨāĻžāĻ•āĻž āϝ⧇āϕ⧋āύ⧋ āωāĻ¤ā§āϤāϰ⧇āϰ āĻŦ⧇āϞāĻžāϝāĻŧ āĻāĻ•āχ āĻ•āĻĨāĻžāĨ¤

āĻāχ āĻĻāĻļāϟāĻž problem-āĻ āϝ⧇ āϰ⧂āĻĒāϗ⧁āϞ⧋ āϞāĻžāϗ⧇

cin >> word;                     one word: no spaces; false at the end of the input
getline(cin, line);              a whole line, spaces kept, the line break dropped
cin >> n; getline(cin, line);    finish the line that held n, then read lines
s.size()   s[i]   s.empty()      length in bytes (ASCII: characters), char i, "is it empty?"
s.find(t)   s.find(t, from)      first index of t (from index from), or string::npos
s.substr(pos, len)               len characters from pos; substr(pos) runs to the end
s += c;   s += t;                append at the end, where s already lives
to_string(x)   stoi(t)   stoll(t)   number to text; text to int or long long
istringstream in(line);          a line read like cin: in >> w gives its words
getline(in, part, ',');          read up to the next comma, and drop the comma
isalnum((unsigned char)c)   tolower((unsigned char)c)   letters and digits; small letters
reverse(s.begin(), s.end());     the characters in the opposite order
  • āύāĻŋāĻšā§‡āϰ āĻĒā§āϰāϤāĻŋāϟāĻž starter āφāϗ⧇ āĻĨ⧇āϕ⧇āχ input āĻĒāĻĄāĻŧ⧇ āϰāĻžāϖ⧇āĨ¤ āĻ“āχ āϞāĻžāχāύāϗ⧁āϞ⧋ āϝ⧇āĻŽāύ āφāϛ⧇ āϤ⧇āĻŽāύ āϰāĻžāĻ–ā§‹, āφāϰ āύāĻŋāĻœā§‡āϰ code āϞ⧇āĻ–ā§‹ comment āϝ⧇āĻ–āĻžāύ⧇ āĻŦāϞ⧇ āϏ⧇āĻ–āĻžāύ⧇āĨ¤
  • istringstream-āĻāϰ āϜāĻ¨ā§āϝ āϞāĻžāϗ⧇ <sstream>, isalnum āφāϰ tolower-āĻāϰ āϜāĻ¨ā§āϝ <cctype>, āφāϰ reverse-āĻāϰ āϜāĻ¨ā§āϝ <algorithm>āĨ¤ Starter-āĻ āύāĻž āĻĨāĻžāĻ•āϞ⧇ include-āϟāĻž āϝ⧋āĻ— āĻ•āϰ⧋āĨ¤
  • Sample-āĻāϰ āφāϗ⧇ āĻ•āĻŋāύāĻžāϰāĻžāϗ⧁āϞ⧋ test āĻ•āϰ⧋: āĻāĻ•āϟāĻž word, āĻāĻ•āϟāĻž character, āϕ⧋āύ⧋ āĻŽāĻŋāϞ āύāĻž āĻĨāĻžāĻ•āĻž, āĻļ⧁āϧ⧁ space-āĻāϰ āĻāĻ•āϟāĻž āϞāĻžāχāύ, āφāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ inputāĨ¤
Example 1: āφāϗ⧇ āĻāĻ•āϟāĻž count, āϤāĻžāϰāĻĒāϰ āĻĒ⧁āϰ⧋ āϞāĻžāχāύ

Alice āĻĻā§‹āĻ•āĻžāύ⧇āϰ āϏāĻžāχāύāĻŦā§‹āĻ°ā§āĻĄ āφāρāϕ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āĻŦā§‹āĻ°ā§āĻĄā§‡āϰ āϜāĻ¨ā§āϝ āĻ“āϰ āϜāĻžāύāĻž āĻĻāϰāĻ•āĻžāϰ character āĻ•āϝāĻŧāϟāĻž, āφāϰ space āĻ•āϝāĻŧāϟāĻžāĨ¤

#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);
        int spaces = 0;
        for (char c : line) {
            if (c == ' ') {
                spaces++;
            }
        }
        // ASCII text: size() is the number of characters.
        cout << line.size() << " chars, " << spaces << " spaces\n";
    }
    return 0;
}
13 chars, 2 spaces
13 chars, 3 spaces
3 chars, 0 spaces

āĻ“āχ output-āϟāĻž āϏ⧇āχ input-āĻāϰ āϜāĻ¨ā§āϝ, āϝ⧇āĻ–āĻžāύ⧇ āφāϗ⧇ 3, āϤāĻžāϰāĻĒāϰ āϤāĻŋāύāϟāĻž āĻŦā§‹āĻ°ā§āĻĄ: OPEN 24 HOURS, āϏāĻžāĻŽāύ⧇ āĻĻ⧁āχāϟāĻž space-āϏāĻš Fresh bread, āφāϰ TeaāĨ¤

getline āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āĻŦā§‹āĻ°ā§āĻĄā§‡āϰ āϏāĻžāĻŽāύ⧇āϰ āĻĻ⧁āχāϟāĻž space āϰ⧇āϖ⧇ āĻĻ⧇āϝāĻŧ, āϤāĻžāχ āĻ“āϰāĻžāĻ“ āĻ—ā§‹āύāĻž āĻšāϝāĻŧ: 13āϟāĻž character āφāϰ 3āϟāĻž spaceāĨ¤ cin >> āĻšāϞ⧇ āĻ“āϗ⧁āϞ⧋ āĻĒāĻžāϰ āĻšāϝāĻŧ⧇ āϝ⧇āϤāĨ¤ āĻĒā§āϰāĻĨāĻŽ getline-āϟāĻž āĻŽā§āϛ⧇ āĻĻāĻŋāϞ⧇ program āφāϗ⧇ 0 character-āĻāϰ āĻāĻ•āϟāĻž āĻĢāĻžāρāĻ•āĻž āĻŦā§‹āĻ°ā§āĻĄā§‡āϰ āĻšāĻŋāϏāĻžāĻŦ āĻĻ⧇āϝāĻŧ, āϤāĻžāϰāĻĒāϰ Tea āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āφāϰ āĻĒ⧌āρāĻ›āĻžāϝāĻŧāχ āύāĻžāĨ¤

Run in Compiler
Example 2: find, npos āφāϰ substr

Zara āĻ“āϰ āĻĻ⧌āĻĄāĻŧ⧇āϰ āϏāĻŽāϝāĻŧ āϞāĻŋāϖ⧇ āϰāĻžāϖ⧇ minutes:seconds āφāĻ•āĻžāϰ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻŽāϝāĻŧ āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡ print āĻ•āϰ⧋, āφāϰ āϕ⧋āύ⧋ āϏāĻŽāϝāĻŧ⧇ colon āύāĻž āĻĨāĻžāĻ•āϞ⧇ badāĨ¤

#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 t;
        cin >> t;
        // find returns a size_t: an index, or string::npos for no match.
        size_t colon = t.find(':');
        if (colon == string::npos) {
            cout << "bad\n";
            continue;
        }
        int minutes = stoi(t.substr(0, colon));
        int seconds = stoi(t.substr(colon + 1));
        cout << minutes * 60 + seconds << '\n';
    }
    return 0;
}
245
750
bad

āĻ“āχ output-āϟāĻž āϏ⧇āχ input-āĻāϰ āϜāĻ¨ā§āϝ, āϝ⧇āĻ–āĻžāύ⧇ āφāϗ⧇ 3, āϤāĻžāϰāĻĒāϰ āĻāĻ• āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻž āĻ•āϰ⧇ 4:05, 12:30 āφāϰ 90āĨ¤

4:05-āĻ colon āφāϛ⧇ index 1-āĻāĨ¤ substr(0, colon) āύ⧇āϝāĻŧ āĻ“āϰ āφāϗ⧇āϰ 1āϟāĻž character, āφāϰ substr(colon + 1) āύ⧇āϝāĻŧ 05, āϝ⧇āϟāĻž stoi āĻĒāĻĄāĻŧ⧇ 5 āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ 90-āĻ āϕ⧋āύ⧋ colon āύ⧇āχ, āϤāĻžāχ find āĻĻ⧇āϝāĻŧ string::npos, āφāϰ program āĻāĻŽāύ āĻāĻ•āϟāĻž position-āĻ āĻ•āĻžāϟāϤ⧇ āϝāĻžāϝāĻŧ āύāĻž āϝ⧇āϟāĻžāϰ āĻ…āĻ¸ā§āϤāĻŋāĻ¤ā§āĻŦāχ āύ⧇āχ, āĻŦāϰāĻ‚ āĻŦāϞ⧇ badāĨ¤

Run in Compiler
Example 3: āĻĒā§āϰāϤāĻŋāϟāĻž āωāĻ¤ā§āϤāϰ += āĻĻāĻŋāϝāĻŧ⧇ āĻ—āĻĄāĻŧāĻž

David āĻ“āϰ āĻĻā§‹āĻ•āĻžāύ⧇āϰ page online āĻĻāĻŋāĻšā§āϛ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž page-āĻāϰ āύāĻžāĻŽ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ web address-āĻāϰ āĻāĻ•āϟāĻž āĻ…āĻ‚āĻļ: āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ, word-āϗ⧁āϞ⧋ - āĻĻāĻŋāϝāĻŧ⧇ āĻœā§‹āĻĄāĻŧāĻž, āĻŦāĻžāĻĄāĻŧāϤāĻŋ space āĻŦāĻžāĻĻāĨ¤

#include <cctype>
#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);
        istringstream in(line);
        string word;
        string slug;
        while (in >> word) {
            if (!slug.empty()) {
                slug += '-';
            }
            for (char c : word) {
                slug += (char)tolower((unsigned char)c);
            }
        }
        cout << slug << '\n';
    }
    return 0;
}
fresh-bread-today
tea-and-cake

āĻ“āχ output-āϟāĻž āϏ⧇āχ input-āĻāϰ āϜāĻ¨ā§āϝ, āϝ⧇āĻ–āĻžāύ⧇ āφāϗ⧇ 2, āϤāĻžāϰāĻĒāϰ Fresh Bread Today āφāϰ Tea and CAKEāĨ¤

in >> word space-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻž āĻĻāϞ āĻĒāĻžāϰ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āϤāĻžāχ āĻŦāĻžāĻĄāĻŧāϤāĻŋ space āĻ•āĻ–āύ⧋ slug-āĻ āĻĒ⧌āρāĻ›āĻžāϝāĻŧ āύāĻžāĨ¤ Dash āĻŦāϏ⧇ āĻļ⧁āϧ⧁ āϤāĻ–āύ, āϝāĻ–āύ slug-āĻ āφāϗ⧇ āĻĨ⧇āϕ⧇āχ āĻāĻ•āϟāĻž word āφāϛ⧇, āϤāĻžāχ āĻļ⧁āϰ⧁āϤ⧇ āϕ⧋āύ⧋ dash āĻĨāĻžāϕ⧇ āύāĻžāĨ¤ tolower āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ āĻāĻ•āϟāĻž int, āϤāĻžāχ āφāĻŦāĻžāϰ char-āĻ cast āĻ•āϰāϞ⧇ += āĻāĻ•āϟāĻž āĻ…āĻ•ā§āώāϰāχ āϝ⧋āĻ— āĻ•āϰ⧇, āϕ⧋āύ⧋ āϏāĻ‚āĻ–ā§āϝāĻž āύāĻžāĨ¤

Run in Compiler

āĻāϟāĻž āϕ⧋āĻĨāĻžāϝāĻŧ āĻ•āĻžāĻœā§‡ āϞāĻžāϗ⧇

  • Unix-āĻāϰ sed commandāĨ¤ sed 's/cat/dog/g' āĻŦāĻžāρ āĻĨ⧇āϕ⧇ āĻĄāĻžāύ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž āĻŽāĻŋāϞ āĻŦāĻĻāϞāĻžāϝāĻŧ, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻžāϰ āĻĒāϰ⧇ āϏāĻžāĻŽāύ⧇ āĻāĻ—ā§‹āϝāĻŧ, āύāĻŋāĻœā§‡āϰ āĻŦāϏāĻžāύ⧋ āĻ…āĻ‚āĻļ⧇ āφāϰ āĻ–ā§‹āρāĻœā§‡ āύāĻžāĨ¤ āĻāϟāĻžāχ replace-word-āĻāϰ āύāĻŋāϝāĻŧāĻŽ, āφāϰ GNU sed sample-āϟāĻžāϕ⧇ āĻ āĻŋāĻ• āĻāĻ•āχ āϞāĻžāχāύ⧇ āĻŦāĻĻāϞāĻžāϝāĻŧāĨ¤
  • Python-āĻāϰ āϏāĻ‚āĻ–ā§āϝāĻž format āĻ•āϰāĻžāĨ¤ format(1234567, ",") āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ 1,234,567, āĻŽāĻžāύ⧇ thousands-separator-āĻāϰ outputāĨ¤ format(-1000, ",") sign-āϟāĻž āϏāĻžāĻŽāύ⧇āχ āϰāĻžāϖ⧇: -1,000āĨ¤
  • BMP image formatāĨ¤ āĻ“āϰ RLE8 compression pixel-āĻāϰ āĻāĻ•āϟāĻž āϟāĻžāύāĻž āĻĻāϞāϕ⧇ āϰāĻžāϖ⧇ āĻĻ⧁āχāϟāĻž byte-āĻ: āĻ•āϝāĻŧāϟāĻž pixel, āϤāĻžāϰāĻĒāϰ āĻ“āĻĻ⧇āϰ āϏāĻŦāĻžāϰ āϰāĻ‚āĨ¤ āĻāϟāĻž run-length-āχ, āĻļ⧁āϧ⧁ count-āϟāĻž āĻĻāĻļāĻŽāĻŋāĻ• digit āύāĻž āĻšāϝāĻŧ⧇ āĻāĻ•āϟāĻž byteāĨ¤
  • CPython-āĻāϰ integerāĨ¤ Python āϝ⧇āϕ⧋āύ⧋ āĻŽāĻžāĻĒ⧇āϰ integer āϝ⧋āĻ— āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ CPython āĻāĻ•āϟāĻž āĻŦāĻĄāĻŧ integer āϰāĻžāϖ⧇ 30-bit digit-āĻāϰ āĻāĻ•āϟāĻž array āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ āĻĻ⧁āχāϟāĻž āϝ⧋āĻ— āĻ•āϰ⧇ āĻ•āϞāĻžāĻŽ āϧāϰ⧇ āϧāϰ⧇, āĻšāĻžāϤ⧇āϰ āϏāĻ‚āĻ–ā§āϝāĻžāϏāĻš, āĻ āĻŋāĻ• āϝ⧇āĻ­āĻžāĻŦ⧇ big-add āĻ•āϰ⧇ 10-āĻ­āĻŋāĻ¤ā§āϤāĻŋāϤ⧇āĨ¤

āϝ⧇ āϭ⧁āϞāϗ⧁āϞ⧋ āϏāĻŦāĻžāχ āĻ•āϰ⧇

ā§§. cin >> n-āĻāϰ āĻ āĻŋāĻ• āĻĒāϰ⧇āχ āϞāĻžāχāύ āĻĒāĻĄāĻŧāĻžāĨ¤

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

āϕ⧋āύ⧋ command line-āĻāχ āĻŦāĻžāĻ°ā§āϤāĻž āύ⧇āχāĨ¤ āĻĒā§āϰāĻĨāĻŽ getline āĻĒāĻĄāĻŧ⧇ n-āĻ“āϝāĻŧāĻžāϞāĻž āϞāĻžāχāύ⧇āϰ āĻŦāĻžāĻ•āĻŋāϟāĻž, āϝ⧇āϟāĻž āĻĢāĻžāρāĻ•āĻžāĨ¤ reverse-words-āĻāϰ sample-āĻ Compiler Explorer-āĻ āĻāĻ•āĻŦāĻžāϰ āϚāĻžāϞāĻžāϤ⧇ print āĻšāϝāĻŧ⧇āϛ⧇ āĻāĻ•āϟāĻž āĻĢāĻžāρāĻ•āĻž āϞāĻžāχāύ, āϤāĻžāϰāĻĒāϰ fox brown quick the āφāϰ cases edge tests ZaraāĨ¤ āĻĢāĻžāρāĻ•āĻž āϞāĻžāχāύāϟāĻž āĻĒā§āϰāĻĨāĻŽ āϞāĻžāχāύ⧇āϰ āĻĢāĻžāρāĻ•āĻž āĻŦāĻžāĻ•āĻŋ āĻ…āĻ‚āĻļ⧇āϰ, āφāϰ hello āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒ⧌āρāĻ›āĻžāύ⧋āχ āĻšāϝāĻŧāύāĻŋāĨ¤ āφāϗ⧇ āĻāĻ•āϟāĻž getline(cin, line); āĻĻāĻŋāϝāĻŧ⧇ āϞāĻžāχāύāϟāĻž āĻļ⧇āώ āĻ•āϰ⧋āĨ¤

⧍. Minus āϚāĻŋāĻšā§āύāϕ⧇ digit āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ—ā§‹āύāĻžāĨ¤

string s = to_string(x);
int len = (int)s.size();
for (int j = 0; j < len; j++) {
    if (j > 0 && (len - j) % 3 == 0) {
        out += ',';
    }
    out += s[j];
}

āϕ⧋āύ⧋ command line-āĻāχ āĻŦāĻžāĻ°ā§āϤāĻž āύ⧇āχ, āφāϰ 1000 āφāϰ -1000 āĻĻ⧁āχāϟāĻžāχ āĻ āĻŋāĻ• āφāϏ⧇āĨ¤ -123-āĻāϰ āϜāĻ¨ā§āϝ Compiler Explorer-āĻ āĻāĻ•āĻŦāĻžāϰ āϚāĻžāϞāĻžāϤ⧇ print āĻšāϝāĻŧ⧇āϛ⧇ -,123, āφāϰ -123456-āĻāϰ āϜāĻ¨ā§āϝ -,123,456āĨ¤ - length-āϕ⧇ āĻāĻ• āĻŦāĻžāĻĄāĻŧāĻŋāϝāĻŧ⧇ āĻĻāĻŋāϝāĻŧ⧇āϛ⧇, āϤāĻžāχ āĻ āĻŋāĻ• āĻ“āϰ āĻĒāϰ⧇āχ āĻāĻ•āϟāĻž comma āĻŦāϏ⧇ āϗ⧇āϛ⧇āĨ¤ āφāϗ⧇ sign āφāϞāĻžāĻĻāĻž āĻ•āϰ⧋, digit-āϗ⧁āϞ⧋āϤ⧇ comma āĻŦāϏāĻžāĻ“, āϤāĻžāϰāĻĒāϰ sign āφāĻŦāĻžāϰ āϏāĻžāĻŽāύ⧇ āĻĻāĻžāĻ“āĨ¤

ā§Š. 100000 digit-āĻāϰ āϏāĻ‚āĻ–ā§āϝāĻžāϝāĻŧ stollāĨ¤

cout << stoll(a) + stoll(b) << '\n';

āϕ⧋āύ⧋ āĻ•āĻĨāĻž āĻ›āĻžāĻĄāĻŧāĻžāχ compile āĻšāϝāĻŧ, āφāϰ sample, 958 āφāϰ 67, āĻĒāĻžāĻļāĻ“ āĻ•āϰ⧇āĨ¤ āĻĒā§āϰāĻĨāĻŽ āϏāĻ‚āĻ–ā§āϝāĻž āĻŦāĻŋāĻļāϟāĻž 9 āĻšāϞ⧇ Compiler Explorer-āĻ āĻāĻ•āĻŦāĻžāϰ āϚāĻžāϞāĻžāϤ⧇ program āĻĨ⧇āĻŽā§‡āϛ⧇ stderr-āĻ āĻāϟāĻž āϞāĻŋāϖ⧇: terminate called after throwing an instance of 'std::out_of_range', āϤāĻžāϰāĻĒāϰ what(): stollāĨ¤ Text āĻāĻ•āϟāĻž long long-āĻāϰ āϜāĻ¨ā§āϝ āĻŦ⧇āĻļāĻŋ āĻŦāĻĄāĻŧ āĻšāϞ⧇ stoll throw āĻ•āϰ⧇āĨ¤ Digit-āϗ⧁āϞ⧋ āύāĻŋāĻœā§‡ āϝ⧋āĻ— āĻ•āϰ⧋, āĻāĻ• āĻ•āϞāĻžāĻŽ āĻ•āϰ⧇āĨ¤

ā§Ē. āĻāχāĻŽāĻžāĻ¤ā§āϰ āĻŦāϏāĻžāύ⧋ āϟ⧁āĻ•āϰ⧋āϰ āĻ­āĻŋāϤāϰ⧇āχ āφāĻŦāĻžāϰ āĻ–ā§‹āρāϜāĻžāĨ¤

size_t pos = text.find(from);
while (pos != string::npos) {
    text.replace(pos, from.size(), to);
    count++;
    pos = text.find(from, pos + 1);
}

āϕ⧋āύ⧋ command line-āĻāχ āĻŦāĻžāĻ°ā§āϤāĻž āύ⧇āχ, āφāϰ cat āφāϰ dog-āĻāϰ sample āĻĒāĻžāĻļ āĻ•āϰ⧇āĨ¤ banana-āϤ⧇ a āφāϰ aa āĻĻāĻŋāϞ⧇, āĻĒā§āϰāϤāĻŋāϟāĻž āĻŦāϏāĻžāύ⧋ aa-āϰ pos + 1-āĻ āĻāĻ•āϟāĻž āύāϤ⧁āύ a āĻĨāĻžāϕ⧇, āϤāĻžāχ text āĻŦāĻžāĻĄāĻŧāϤ⧇āχ āĻĨāĻžāϕ⧇āĨ¤ Compiler Explorer-āĻ āĻāĻ•āĻŦāĻžāϰ āϚāĻžāϞāĻžāϤ⧇ āĻ•āĻŋāϛ⧁āχ print āĻšāϝāĻŧāύāĻŋ, āφāϰ āĻĒā§āϰāĻžāϝāĻŧ 6 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒāϰ⧇ program-āϟāĻž kill āĻšāϝāĻŧ⧇āϛ⧇āĨ¤ āφāĻŦāĻžāϰ āĻ–ā§‹āρāĻœā§‹ pos + to.size() āĻĨ⧇āϕ⧇, āύāϝāĻŧāϤ⧋ āĻāĻ•āϟāĻž āύāϤ⧁āύ string āĻ—āĻĄāĻŧā§‹ āφāϰ āĻ–ā§‹āρāĻœā§‹ āĻļ⧁āϧ⧁ āĻĒ⧁āϰāύ⧋āϟāĻžāϝāĻŧāĨ¤

āĻŽāĻžāĻĨāĻž āĻ–āĻžāϟāĻžāĻ“

thousands-separator-āĻ sample-āĻāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž āϞāĻžāχāύ 1,000,000,000,000,000,000, 25āϟāĻž characterāĨ¤ Kenji āύāĻŋāĻļā§āϚāĻŋāϤ, constraints āĻŽā§‡āύ⧇ āϚāϞāĻž āĻ…āĻ¨ā§āϝ āϕ⧋āύ⧋ input āĻāχ āϞāĻžāχāύ⧇āϰ āĻšā§‡āϝāĻŧ⧇āĻ“ āϞāĻŽā§āĻŦāĻž āϞāĻžāχāύ print āĻ•āϰ⧇āĨ¤

āĻ“ āĻ•āĻŋ āĻ āĻŋāĻ•? āϕ⧋āύ input āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž āϞāĻžāχāύ āĻĻ⧇āϝāĻŧ, āϏ⧇āϟāĻž āĻ•āϤ āϞāĻŽā§āĻŦāĻž, āφāϰ n = 20000 āĻšāϞ⧇ āĻāĻ•āϟāĻž test-āĻāϰ āĻĒ⧁āϰ⧋ output āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ āĻ•āϤ āĻŦāĻĄāĻŧ āĻšāϤ⧇ āĻĒāĻžāϰ⧇?

Constraints-āĻ āĻĻ⧇āĻ“āϝāĻŧāĻž āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ āϏāĻ‚āĻ–ā§āϝāĻžāϗ⧁āϞ⧋āϰ digit āĻ—ā§‹āύ⧋, āϤāĻžāϰāĻĒāϰ āĻ…āϤ digit-āĻāϰ āϏāĻ‚āĻ–ā§āϝāĻžāϝāĻŧ āĻ•āϝāĻŧāϟāĻž comma āĻŦāϏ⧇ āϏ⧇āϟāĻž āĻ—ā§‹āύ⧋āĨ¤

Problem 1: longest-wordāϏāĻšāϜFree

Zara āϜāĻžāύāϤ⧇ āϚāĻžāϝāĻŧ Bob-āĻāϰ āĻ˜ā§‹āϰāĻžāϰ note-āĻ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž word āϕ⧋āύāϟāĻž, āφāϰ āĻ“āϰ lengthāĨ¤ Word āĻŽāĻžāύ⧇ space āĻ›āĻžāĻĄāĻŧāĻž character-āĻāϰ āϝ⧇āϕ⧋āύ⧋ āϟāĻžāύāĻž āϏāĻžāϰāĻŋ, āϤāĻžāχ āϕ⧋āύ⧋ word-āĻāϰ āĻ—āĻžāϝāĻŧ⧇ āϞ⧇āϗ⧇ āĻĨāĻžāĻ•āĻž comma-āĻ“ āĻ“āϰ āĻ…āĻ‚āĻļāĨ¤

Input. Space āĻŦāĻž āύāϤ⧁āύ āϞāĻžāχāύ āĻĻāĻŋāϝāĻŧ⧇ āφāϞāĻžāĻĻāĻž word, input āĻļ⧇āώ āύāĻž āĻšāĻ“āϝāĻŧāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤāĨ¤ āĻļ⧁āϰ⧁āϤ⧇ āϕ⧋āύ⧋ count āύ⧇āχāĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇: āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž word, āĻāĻ•āϟāĻž space, āφāϰ āĻ“āϰ lengthāĨ¤ āϏāĻŽāĻžāύ āĻšāϞ⧇, āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻžāϗ⧁āϞ⧋āϰ āĻŽāĻ§ā§āϝ⧇ āĻĒā§āϰāĻĨāĻŽāϟāĻžāĨ¤

Constraints. 1 āĻĨ⧇āϕ⧇ 100000āϟāĻž word, āĻĒā§āϰāϤāĻŋāϟāĻžāϝāĻŧ 1 āĻĨ⧇āϕ⧇ 100āϟāĻž ASCII character; āĻĒ⧁āϰ⧋ input āĻŦāĻĄāĻŧāĻœā§‹āϰ 1000000 byteāĨ¤

Sample. Input Bob packs maps, snacks and a camera for the trip āĻĻāĻŋāϞ⧇ 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;
}
Run in Compiler

Hint 1

Sample-āĻ 6 character-āĻāϰ word āĻĻ⧁āχāϟāĻžāĨ¤ āύāϤ⧁āύ āĻāĻ•āϟāĻž word āϝāĻĻāĻŋ āĻāĻ–āύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻžāϟāĻžāϰ āĻ āĻŋāĻ• āϏāĻŽāĻžāύ āĻšāϝāĻŧ, āϤāĻžāĻšāϞ⧇ āϕ⧀ āĻšāĻ“āϝāĻŧāĻžāϰ āĻ•āĻĨāĻž?

Hint 2

āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž word-āϟāĻž āϰāĻžāĻ–ā§‹ āĻāĻ•āϟāĻž string-āĻ, āϝ⧇āϟāĻž āĻļ⧁āϰ⧁āϤ⧇ āĻĢāĻžāρāĻ•āĻžāĨ¤ āύāϤ⧁āύ word-āĻāϰ size āϏāĻ¤ā§āϝāĻŋāχ āĻŦāĻĄāĻŧ āĻšāϞ⧇ āϤāĻŦ⧇āχ āĻŦāĻĻāϞāĻžāĻ“āĨ¤ Loop-āĻāϰ āĻĒāϰ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž word, āĻāĻ•āϟāĻž space āφāϰ āĻ“āϰ size print āĻ•āϰ⧋āĨ¤

Solution

āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž word āĻļ⧁āϰ⧁ āĻšāϝāĻŧ āĻĢāĻžāρāĻ•āĻž āĻ…āĻŦāĻ¸ā§āĻĨāĻžāϝāĻŧ, size 0, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž word-āĻ āĻ…āĻ¨ā§āϤāϤ āĻāĻ•āϟāĻž character āĻĨāĻžāϕ⧇, āϤāĻžāχ āĻĒā§āϰāĻĨāĻŽ word āϏāĻŦāϏāĻŽāϝāĻŧ āĻ“āϰ āϜāĻžāϝāĻŧāĻ—āĻž āύ⧇āϝāĻŧāĨ¤ āĻĒāϰ⧇ āĻŦāĻĻāϞāĻžāϝāĻŧ āĻļ⧁āϧ⧁ āϏāĻ¤ā§āϝāĻŋāχ āϞāĻŽā§āĻŦāĻž āϕ⧋āύ⧋ word, āϤāĻžāχ āϏāĻŽāĻžāύ word-āϗ⧁āϞ⧋āϰ āĻŽāĻ§ā§āϝ⧇ āĻĒā§āϰāĻĨāĻŽāϟāĻžāχ āĻĨ⧇āϕ⧇ āϝāĻžāϝāĻŧāĨ¤ cin >> word space āφāϰ āύāϤ⧁āύ āϞāĻžāχāύ⧇āϰ āϝ⧇āϕ⧋āύ⧋ āĻŽāĻŋāĻļ⧇āϞ āĻĒāĻžāϰ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ Input ASCII, āϤāĻžāχ size() āĻŽāĻžāύ⧇āχ lengthāĨ¤

>= āĻĻāĻŋāϝāĻŧ⧇ āĻŦāĻĻāϞāĻžāϞ⧇ āϏāĻŽāĻžāύāĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻļ⧇āώāϟāĻž āĻĨāĻžāϕ⧇, āφāϰ sample-āĻ print āĻšāϝāĻŧ camera 6āĨ¤ Hidden test-āĻ āφāϛ⧇ āĻāĻ• character-āĻāϰ āĻāĻ•āϟāĻžāχ word, āφāϰ 100 character-āĻāϰ āĻāĻ•āϟāĻžāχ wordāĨ¤ āφāϰāĻ“ āφāϛ⧇ āĻ…āύ⧇āĻ• āϞāĻžāχāύ āϜ⧁āĻĄāĻŧ⧇ āϏāĻŽāĻžāύ āϞāĻŽā§āĻŦāĻž word, āύāϤ⧁āύ āϞāĻžāχāύ āĻ›āĻžāĻĄāĻŧāĻž āĻāĻ•āĻĻāĻŽ āĻļ⧇āώ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž word, āφāϰ āĻāĻ• character-āĻāϰ 100000āϟāĻž wordāĨ¤

Problem 2: email-domaināϏāĻšāϜFree

Alice-āĻāϰ club-āĻāϰ sign-up list-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻž address āĻĻ⧁āχ āĻ­āĻžāĻ— āĻ•āϰāĻž āĻĻāϰāĻ•āĻžāϰ: @-āĻāϰ āφāϗ⧇āϰ user name āφāϰ āĻĒāϰ⧇āϰ domaināĨ¤

Input. n, āϤāĻžāϰāĻĒāϰ n-āϟāĻž email address, āĻĒā§āϰāϤāĻŋ āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻžāĨ¤

Output. āĻĒā§āϰāϤāĻŋāϟāĻž address-āĻāϰ āϜāĻ¨ā§āϝ āĻāĻ• āϞāĻžāχāύ: @-āĻāϰ āφāϗ⧇āϰ āĻ…āĻ‚āĻļ, āĻāĻ•āϟāĻž space, āφāϰ āĻĒāϰ⧇āϰ āĻ…āĻ‚āĻļāĨ¤

Constraints. 1 <= n <= 20000; āĻĒā§āϰāϤāĻŋāϟāĻž address-āĻ āĻŦāĻĄāĻŧāĻœā§‹āϰ 100āϟāĻž ASCII character, āϕ⧋āύ⧋ space āύ⧇āχ, āĻ āĻŋāĻ• āĻāĻ•āϟāĻž @, āφāϰ āĻ“āϰ āĻĻ⧁āχ āĻĒāĻžāĻļ⧇ āĻ…āĻ¨ā§āϤāϤ āĻāĻ•āϟāĻž āĻ•āϰ⧇ characterāĨ¤

Sample. Input 3, maria@school.example, bob.rahman@mail.example.com āφāϰ z@x.io āĻĻāĻŋāϞ⧇ āϤāĻŋāύ āϞāĻžāχāύ⧇ maria school.example, bob.rahman mail.example.com āφāϰ z x.ioāĨ¤

#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;
}
Run in Compiler

Hint 1

z@x.io-āϤ⧇ @ āφāϛ⧇ index 1-āĻāĨ¤ āĻ“āϰ āφāϗ⧇ character āĻ•āϝāĻŧāϟāĻž?

Hint 2

@-āĻāϰ index āϖ⧁āρāĻœā§‡ āĻŦ⧇āϰ āĻ•āϰ⧋āĨ¤ User name āĻšāϞ⧋ 0 āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻšāĻ“āϝāĻŧāĻž āĻ āĻŋāĻ• āĻ…āϤāϗ⧁āϞ⧋ character-āĻāϰ substringāĨ¤ Domain āĻšāϞ⧋ @-āĻāϰ āĻāĻ• āϘāϰ āĻĒāϰ āĻĨ⧇āϕ⧇ āĻļ⧇āώ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ substringāĨ¤

Solution

find('@') āĻĻ⧇āϝāĻŧ @-āĻāϰ index, āφāϰ āĻ“āχ index-āχ āĻ“āϰ āφāϗ⧇āϰ character-āĻāϰ āϏāĻ‚āĻ–ā§āϝāĻžāĨ¤ pos 0 āĻĻāĻŋāϝāĻŧ⧇ substr(pos, len) āĻ āĻŋāĻ• āĻ“āϗ⧁āϞ⧋āχ āύ⧇āϝāĻŧ, āφāϰ @-āĻāϰ āĻāĻ• āϘāϰ āĻĒāϰ āĻĨ⧇āϕ⧇ substr(pos) āύ⧇āϝāĻŧ āĻŦāĻžāĻ•āĻŋāϟāĻžāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž address-āĻ āĻāĻ•āϟāĻž @ āφāϛ⧇, āϤāĻžāχ āĻāĻ–āĻžāύ⧇ string::npos āĻ•āĻ–āύ⧋ āĻĢ⧇āϰāϤ āφāϏ⧇ āύāĻžāĨ¤ āĻāχ āĻ•āĻĨāĻž āĻĻ⧇āĻ“āϝāĻŧāĻž āύāĻž āĻĨāĻžāĻ•āϞ⧇ āφāϗ⧇ āĻ“āϟāĻž check āĻ•āϰ⧋, āϝ⧇āĻŽāύ Example 2 āĻ•āϰ⧇āĨ¤

Domain āϝāĻĻāĻŋ @ āĻĨ⧇āϕ⧇āχ āĻļ⧁āϰ⧁ āĻ•āϰ⧋, print āĻšāϝāĻŧ maria @school.exampleāĨ¤ āĻāĻ•āϟāĻž character āĻ•āĻŽ āύāĻŋāϞ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž user name-āĻāϰ āĻļ⧇āώ āĻ…āĻ•ā§āώāϰ āĻ•āĻžāϟāĻž āĻĒāĻĄāĻŧ⧇āĨ¤ Hidden test @-āϕ⧇ āĻŦāϏāĻžāϝāĻŧ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āφāϰ āĻļ⧇āώ⧇āϰ āφāϗ⧇āϰ āϘāϰ⧇, āφāϰ +, _ āφāϰ ~-āĻāϰ āĻŽāϤ⧋ āϚāĻŋāĻšā§āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤ āĻāĻ•āϟāĻžāϝāĻŧ āφāϛ⧇ 100 character-āĻāϰ 10000āϟāĻž address, 1 MB-āĻāϰ āĻāĻ•āϟ⧁ āĻŦ⧇āĻļāĻŋāĨ¤

Problem 3: replace-wordāĻŽāĻžāĻāĻžāϰāĻŋPro

Amara-āϰ text editor-āĻ find-and-replace āϞāĻžāĻ—āĻŦ⧇āĨ¤ Text-āĻ from āϝāϤāĻŦāĻžāϰ āφāϛ⧇, āĻĒā§āϰāϤāĻŋāϟāĻžāϕ⧇ to āĻĻāĻŋāϝāĻŧ⧇ āĻŦāĻĻāϞāĻžāĻ“, āĻŦāĻžāρ āĻĨ⧇āϕ⧇ āĻĄāĻžāύ⧇ āĻĒāĻĄāĻŧāϤ⧇ āĻĒāĻĄāĻŧāϤ⧇, āφāϰ āĻ•āϝāĻŧāĻŦāĻžāϰ āĻŦāĻĻāϞāĻžāϞ⧇ āĻ—ā§‹āύ⧋āĨ¤ āĻāχāĻŽāĻžāĻ¤ā§āϰ āĻŦāϏāĻžāύ⧋ āϟ⧁āĻ•āϰ⧋āϰ āĻ­āĻŋāϤāϰ⧇ āĻ•āĻ–āύ⧋ āϖ⧁āρāϜāĻŦ⧇ āύāĻž, āφāϰ āĻĻ⧁āχāϟāĻž āĻŽāĻŋāϞ āĻāĻ•āϟāĻžāϰ āωāĻĒāϰ āφāϰ⧇āĻ•āϟāĻž āĻĒāĻĄāĻŧāϞ⧇ āĻŦāĻžāρāϝāĻŧ⧇āϰāϟāĻž āφāϗ⧇: aaa-āϤ⧇ aa āφāϰ b āĻĻāĻŋāϞ⧇ ba āφāϰ 1āĨ¤

Input. āϞāĻžāχāύ 1: text, āϝāĻžāϤ⧇ space āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āϞāĻžāχāύ 2: fromāĨ¤ āϞāĻžāχāύ 3: toāĨ¤

Output. āϞāĻžāχāύ 1-āĻ āύāϤ⧁āύ text, āφāϰ āϞāĻžāχāύ 2-āĻ āĻ•āϝāĻŧāĻŦāĻžāϰ āĻŦāĻĻāϞāĻžāύ⧋ āĻšāϞ⧋āĨ¤

Constraints. Text-āĻ 1 āĻĨ⧇āϕ⧇ 100000āϟāĻž ASCII character; from āφāϰ to-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻžāϝāĻŧ 1 āĻĨ⧇āϕ⧇ 10āϟāĻž character, āϕ⧋āύ⧋ space āύ⧇āχāĨ¤

Sample. Input I like cats. My cat likes catnip., cat āφāϰ dog āĻĻāĻŋāϞ⧇ āĻĻ⧁āχ āϞāĻžāχāύ⧇ I like dogs. My dog likes dognip. āφāϰ 3āĨ¤

#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;
}
Run in Compiler

Hint 1

banana-āϤ⧇ a āφāϰ aa āĻĻāĻŋāϝāĻŧ⧇ āĻ•āĻžāĻ—āĻœā§‡ āĻ•āϰ⧇ āĻĻ⧇āĻ–ā§‹āĨ¤ āĻāĻ•āĻŦāĻžāϰ āĻŦāĻĻāϞāĻžāύ⧋āϰ āĻĒāϰ⧇ āĻĒāϰ⧇āϰ āĻ–ā§‹āρāϜāĻž āϕ⧋āĻĨāĻž āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻšāĻ“āϝāĻŧāĻžāϰ āĻ•āĻĨāĻž?

Hint 2

āĻāĻ•āϟāĻž āύāϤ⧁āύ string āĻ—āĻĄāĻŧā§‹, āφāϰ āĻ–ā§‹āρāĻœā§‹ āĻļ⧁āϧ⧁ āφāϏāϞ text-āĻāĨ¤ āĻāĻ–āύāĻ•āĻžāϰ position āĻĨ⧇āϕ⧇ āĻĒāϰ⧇āϰ āĻŽāĻŋāϞāϟāĻž āĻ–ā§‹āρāĻœā§‹āĨ¤ āĻ“āϰ āφāϗ⧇āϰ text āφāϰ āύāϤ⧁āύ āϟ⧁āĻ•āϰ⧋āϟāĻž āϝ⧋āĻ— āĻ•āϰ⧋, āĻāĻ•āĻŦāĻžāϰ āĻ—ā§‹āύ⧋, āϤāĻžāϰāĻĒāϰ position-āϕ⧇ āĻĒ⧁āϰ⧋ āĻŽāĻŋāϞ⧇āϰ āĻĒāϰ⧇ āϏāϰāĻžāĻ“āĨ¤ āĻ–ā§‹āρāϜāĻžāϝāĻŧ āĻ•āĻŋāϛ⧁ āύāĻž āĻĒ⧇āϞ⧇ āĻŦāĻžāĻ•āĻŋāϟāĻž āϝ⧋āĻ— āĻ•āϰ⧋āĨ¤

Problem 4: thousands-separatorāĻŽāĻžāĻāĻžāϰāĻŋPro

David-āĻāϰ āĻšāĻŋāϏāĻžāĻŦ⧇āϰ āĻŽā§‹āϟāϗ⧁āϞ⧋ āĻĒāĻĄāĻŧāϤ⧇ āĻ•āĻˇā§āϟ āĻšāϝāĻŧāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž print āĻ•āϰ⧋ āĻĄāĻžāύ āĻĨ⧇āϕ⧇ āϗ⧁āύ⧇ āĻĒā§āϰāϤāĻŋ āϤāĻŋāύ digit-āĻ āĻāĻ•āϟāĻž comma āĻĻāĻŋāϝāĻŧ⧇āĨ¤ Minus āϚāĻŋāĻšā§āύ āĻĨāĻžāϕ⧇ āϏāĻžāĻŽāύ⧇āχ, āϝ⧇āĻŽāύ -1,000, āφāϰ 0 print āĻšāϝāĻŧ 0āĨ¤

Input. n, āϤāĻžāϰāĻĒāϰ n-āϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž, āĻĒā§āϰāϤāĻŋ āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻžāĨ¤

Output. āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āύāĻŋāĻœā§‡āϰ āϞāĻžāχāύ⧇, āĻ“āϰ comma-āϏāĻšāĨ¤

Constraints. 1 <= n <= 20000, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž -1018 āĻĨ⧇āϕ⧇ 1018-āĻāϰ āĻŽāĻ§ā§āϝ⧇āĨ¤

Sample. Input 5, 0, 999, 1000, -1234567 āφāϰ 1000000000000000000 āĻĻāĻŋāϞ⧇ āĻĒāĻžāρāϚ āϞāĻžāχāύ⧇ 0, 999, 1,000, -1,234,567 āφāϰ 1,000,000,000,000,000,000āĨ¤

#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;
}
Run in Compiler

Hint 1

-1234567-āĻāϰ āϜāĻ¨ā§āϝ to_string āϕ⧀ āĻĻ⧇āϝāĻŧ, āφāϰ āĻ“āϰ āĻĒā§āϰāĻĨāĻŽ character-āϟāĻž āĻ•āĻŋ āĻāĻ•āϟāĻž digit?

Hint 2

Minus āϚāĻŋāĻšā§āύāϟāĻž āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ āϰāĻžāĻ–ā§‹, āĻļ⧁āϧ⧁ digit-āϗ⧁āϞ⧋ āϰāĻžāĻ–ā§‹āĨ¤ āĻŦāĻžāρ āĻĨ⧇āϕ⧇ āĻ“āĻĻ⧇āϰ āωāĻĒāϰ āĻĻāĻŋāϝāĻŧ⧇ āĻšāĻžāρāĻŸā§‹āĨ¤ āĻĒā§āϰāĻĨāĻŽāϟāĻž āĻŦāĻžāĻĻ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž digit-āĻāϰ āφāϗ⧇ āĻāĻ•āϟāĻž comma āĻŦāϏāĻžāĻ“, āϝāĻĻāĻŋ āĻ“āχ digit āĻĨ⧇āϕ⧇ āĻļ⧇āώ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ digit-āĻāϰ āϏāĻ‚āĻ–ā§āϝāĻž 3-āĻāϰ āϗ⧁āĻŖāĻŋāϤāĻ• āĻšāϝāĻŧāĨ¤ āĻļ⧇āώ⧇ sign-āϟāĻž āφāĻŦāĻžāϰ āϏāĻžāĻŽāύ⧇ āĻŦāϏāĻžāĻ“āĨ¤

Problem 5: letter-frequencyāϏāĻšāϜFree

Maria āϜāĻžāύāϤ⧇ āϚāĻžāϝāĻŧ āĻāĻ•āϟāĻž text āϕ⧋āύ āϕ⧋āύ āĻ…āĻ•ā§āώāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤ a āĻĨ⧇āϕ⧇ z āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻ…āĻ•ā§āώāϰ āĻ—ā§‹āύ⧋, āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ āĻ“āϰ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰāϟāĻž āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ Digit, space āφāϰ āĻŦāĻŋāϰāĻžāĻŽāϚāĻŋāĻšā§āύ āĻ…āĻ•ā§āώāϰ āύāĻžāĨ¤

Input. āĻāĻ• āĻŦāĻž āĻāĻ•āĻžāϧāĻŋāĻ• āϞāĻžāχāύ⧇āϰ text, input āĻļ⧇āώ āύāĻž āĻšāĻ“āϝāĻŧāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤāĨ¤

Output. āϝ⧇ āĻ…āĻ•ā§āώāϰ āĻāϏ⧇āϛ⧇ āϤāĻžāϰ āĻĒā§āϰāϤāĻŋāϟāĻžāϰ āϜāĻ¨ā§āϝ āĻāĻ• āϞāĻžāχāύ, a āĻĨ⧇āϕ⧇ z āĻ•ā§āϰāĻŽā§‡: āĻ…āĻ•ā§āώāϰāϟāĻž, āĻāĻ•āϟāĻž space, āĻ“āϰ countāĨ¤ āϕ⧋āύ⧋ āĻ…āĻ•ā§āώāϰāχ āύāĻž āĻāϞ⧇ none āĻļāĻŦā§āĻĻāϟāĻžāĨ¤

Constraints. Text āĻŦāĻĄāĻŧāĻœā§‹āϰ 1000000 byte-āĻāϰ ASCIIāĨ¤

Sample. Input Hello, World! āφāϰ Zara 2026 āĻĻāĻŋāϞ⧇ āύāϝāĻŧāϟāĻž āϞāĻžāχāύ: a 2, d 1, e 1, h 1, l 3, o 2, r 2, w 1 āφāϰ 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;
}
Run in Compiler

Hint 1

'a' - 'a' āĻšāϞ⧋ 0, āφāϰ 'z' - 'a' āĻšāϞ⧋ 25āĨ¤ 'A' āφāϰ 'a'-āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻĻā§‚āϰāĻ¤ā§āĻŦ āĻ•āϤ?

Hint 2

āĻĒā§āϰāϤāĻŋāϟāĻž character-āĻāϰ āϜāĻ¨ā§āϝ, āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰāϕ⧇ āĻ“āϰ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰāϟāĻž āĻŦāĻžāύāĻžāĻ“, āϤāĻžāϰāĻĒāϰ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ āĻšāϞ⧇ āĻ“āϰ counter-āĻ 1 āϝ⧋āĻ— āĻ•āϰ⧋āĨ¤ āĻļ⧇āώ⧇ 26āϟāĻž counter-āĻāϰ āωāĻĒāϰ āĻĻāĻŋāϝāĻŧ⧇ āĻ•ā§āϰāĻŽāĻŽāϤ⧋ āĻšāĻžāρāĻŸā§‹, 0-āĻāϰ āĻŦ⧇āĻļāĻŋāϗ⧁āϞ⧋ print āĻ•āϰ⧋, āφāϰ āĻŽāύ⧇ āϰāĻžāĻ–ā§‹ āĻ•āĻŋāϛ⧁ print āĻšāϞ⧋ āĻ•āĻŋ āύāĻžāĨ¤

Solution

ASCII-āϤ⧇ 'A' āĻĨ⧇āϕ⧇ 'Z' āφāϰ 'a' āĻĨ⧇āϕ⧇ 'z' āĻĻ⧁āχāϟāĻžāχ āϟāĻžāύāĻž āϏāĻžāϰāĻŋ, 32 āϘāϰ āĻĻā§‚āϰ⧇āĨ¤ āϤāĻžāχ 'a' - 'A' āϝ⧋āĻ— āĻ•āϰāϞ⧇ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ āϛ⧋āϟ āĻšāϝāĻŧ, āφāϰ c - 'a' āĻšāϞ⧋ counter-āĻāϰ indexāĨ¤ Counter-āϗ⧁āϞ⧋āϰ āωāĻĒāϰ āĻĻāĻŋāϝāĻŧ⧇ 0 āĻĨ⧇āϕ⧇ 25 āĻšāĻžāρāϟāϞ⧇ a āĻĨ⧇āϕ⧇ z print āĻšāϝāĻŧ, āϕ⧋āύ⧋ sort āĻ›āĻžāĻĄāĻŧāĻžāχāĨ¤ āĻĒā§āϰāĻĨāĻŽ print-āĻ āĻāĻ•āϟāĻž flag āĻŦāϏāĻŋāϝāĻŧ⧇ āϰāĻžāĻ–āϞ⧇āχ none-āĻāϰ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤

char-āĻ cast āύāĻž āĻ•āϰ⧇ 'a' + k print āĻ•āϰāϞ⧇ āφāϏ⧇ 97, āĻ•āĻžāϰāĻŖ āϝ⧋āĻ—āĻĢāϞāϟāĻž āĻāĻ•āϟāĻž intāĨ¤ Range check āĻāĻ• āϘāϰ āϭ⧁āϞ āĻšāϞ⧇ āĻ—ā§‹āύāĻž āĻšāϝāĻŧ @, [, ` āĻŦāĻž {, āĻ…āĻ•ā§āώāϰāϗ⧁āϞ⧋āϰ āĻ āĻŋāĻ• āĻĒāĻžāĻļ⧇āϰ characterāĨ¤ Hidden test-āĻ āĻ āĻŋāĻ• āĻāϗ⧁āϞ⧋āχ āφāϛ⧇, āϏāĻžāĻĨ⧇ āϕ⧋āύ⧋ āĻ…āĻ•ā§āώāϰāχ āύāĻž āĻĨāĻžāĻ•āĻž text, āĻĢāĻžāρāĻ•āĻž āϞāĻžāχāύ, a-āĻāϰ 999000āϟāĻž copy, āφāϰ āύāϤ⧁āύ āϞāĻžāχāύ āĻ›āĻžāĻĄāĻŧāĻž āĻļ⧇āώ āϞāĻžāχāύāĨ¤

Problem 6: csv-best-studentāĻŽāĻžāĻāĻžāϰāĻŋPro

Kenji āĻ•ā§āϞāĻžāϏ⧇āϰ mark export āĻ•āϰ⧇āϛ⧇ name,mark1,mark2,mark3 āφāĻ•āĻžāϰ⧇āϰ CSV āϞāĻžāχāύ āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ āύāĻžāĻŽā§‡āϰ āĻ­āĻŋāϤāϰ⧇ āĻāĻ•āϟāĻž āĻ•āϰ⧇ space āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āϝāĻžāϰ āĻŽā§‹āϟ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ āϤāĻžāϰ āύāĻžāĻŽ, āφāϰ āĻŽā§‹āϟāϟāĻž print āĻ•āϰ⧋āĨ¤

Input. n, āϤāĻžāϰāĻĒāϰ n-āϟāĻž āϞāĻžāχāύ name,mark1,mark2,mark3āĨ¤

Output. āϞāĻžāχāύ 1-āĻ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ­āĻžāϞ⧋ āύāĻžāĻŽ, āφāϰ āϞāĻžāχāύ 2-āĻ āĻ“āϰ āĻŽā§‹āϟāĨ¤ āϏāĻŽāĻžāύ āĻšāϞ⧇, āĻ“āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻĒā§āϰāĻĨāĻŽāϜāύāĨ¤

Constraints. 1 <= n <= 20000āĨ¤ āύāĻžāĻŽā§‡ 1 āĻĨ⧇āϕ⧇ 40āϟāĻž character: āĻ…āĻ•ā§āώāϰ, āĻ­āĻŋāϤāϰ⧇ āĻāĻ•āϟāĻž āĻ•āϰ⧇ space, āϕ⧋āύ⧋ comma āύ⧇āχ, āφāϰ āĻĻ⧁āχ āĻŽāĻžāĻĨāĻžāϝāĻŧ āϕ⧋āύ⧋ space āύ⧇āχāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž mark 0 āĻĨ⧇āϕ⧇ 100āĨ¤

Sample. Input 4, Maria Rose,90,85,77, Bob,100,60,95, Zara Bell,88,95,72 āφāϰ Kenji,70,70,70 āĻĻāĻŋāϞ⧇ āĻĻ⧁āχ āϞāĻžāχāύ⧇ Bob āφāϰ 255āĨ¤

#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;
}
Run in Compiler

Hint 1

Maria Rose āύāĻžāĻŽā§‡ āĻāĻ•āϟāĻž space āφāϛ⧇āĨ¤ >> āĻ“āϟāĻž āĻĒāĻĄāĻŧāϤ⧇ āĻ—āĻŋāϝāĻŧ⧇ āϕ⧋āĻĨāĻžāϝāĻŧ āĻĨāĻžāĻŽāĻŦ⧇?

Hint 2

āϞāĻžāχāύāϟāĻž āĻāĻ•āϟāĻž istringstream-āĻ āĻĻāĻžāĻ“, āφāϰ āϤāĻŋāύ argument-āĻāϰ getline āĻĻāĻŋāϝāĻŧ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž comma āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒāĻĄāĻŧā§‹: āĻāĻ•āĻŦāĻžāϰ āύāĻžāĻŽā§‡āϰ āϜāĻ¨ā§āϝ, āϤāĻŋāύāĻŦāĻžāϰ mark-āĻāϰ āϜāĻ¨ā§āϝāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž mark-āϕ⧇ āϏāĻ‚āĻ–ā§āϝāĻž āĻŦāĻžāύāĻžāĻ“āĨ¤ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ āĻŽā§‹āϟ āφāϰ āĻ“āϰ āύāĻžāĻŽ āϰāĻžāĻ–ā§‹, āφāϰ āĻŦāĻĻāϞāĻžāĻ“ āĻļ⧁āϧ⧁ āĻŽā§‹āϟ āϏāĻ¤ā§āϝāĻŋāχ āĻŦāĻĄāĻŧ āĻšāϞ⧇āĨ¤

Problem 7: reverse-wordsāĻŽāĻžāĻāĻžāϰāĻŋPro

David-āĻāϰ chat app message āωāĻ˛ā§āĻŸā§‹ āĻ•āϰ⧇ āĻĒāĻžāĻ āĻžāϝāĻŧāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ⧇āϰ word-āϗ⧁āϞ⧋ āĻļ⧇āώāϟāĻž āĻĨ⧇āϕ⧇ āĻĒā§āϰāĻĨāĻŽāϟāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ print āĻ•āϰ⧋, āĻāĻ•āϟāĻž āĻ•āϰ⧇ space āĻĻāĻŋāϝāĻŧ⧇āĨ¤ āϞāĻžāχāύ⧇ word-āĻāϰ āĻŽāĻžāĻā§‡ āĻŦāĻžāĻĄāĻŧāϤāĻŋ space āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇, āφāϰ āĻļ⧁āϰ⧁āϤ⧇ āĻŦāĻž āĻļ⧇āώ⧇āĻ“ space āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

Input. n, āϤāĻžāϰāĻĒāϰ n-āϟāĻž āϞāĻžāχāύ, āĻĒā§āϰāϤāĻŋāϟāĻžāϝāĻŧ āĻ…āĻ•ā§āώāϰ āφāϰ digit-āĻāϰ 1 āĻĨ⧇āϕ⧇ 1000āϟāĻž word, āĻāĻ• āĻŦāĻž āĻāĻ•āĻžāϧāĻŋāĻ• space āĻĻāĻŋāϝāĻŧ⧇ āφāϞāĻžāĻĻāĻžāĨ¤

Output. āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ⧇āϰ word āωāĻ˛ā§āĻŸā§‹ āĻ•ā§āϰāĻŽā§‡, āĻāĻ•āϟāĻž āĻ•āϰ⧇ space āĻĻāĻŋāϝāĻŧ⧇ āφāϞāĻžāĻĻāĻžāĨ¤

Constraints. āĻĒ⧁āϰ⧋ input āĻŦāĻĄāĻŧāĻœā§‹āϰ 1000000 byteāĨ¤

Sample. Input 3, the quick brown fox, Zara tests edge cases āφāϰ hello āĻĻāĻŋāϞ⧇ āϤāĻŋāύ āϞāĻžāχāύ⧇ fox brown quick the, cases edge tests Zara āφāϰ helloāĨ¤

#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;
}
Run in Compiler

Hint 1

āĻĒāϰāĻĒāϰ āϤāĻŋāύāϟāĻž space, āĻŦāĻž input-āĻāϰ āĻļ⧁āϰ⧁āϤ⧇ space āĻĒ⧇āϞ⧇ >> āϕ⧀ āĻ•āϰ⧇?

Hint 2

āϞāĻžāχāύ⧇āϰ word-āϗ⧁āϞ⧋ āĻāĻ•āϟāĻž istringstream āĻĻāĻŋāϝāĻŧ⧇ āĻĒāĻĄāĻŧ⧇ āĻāĻ•āϟāĻž vector<string>-āĻ āϰāĻžāĻ–ā§‹āĨ¤ āϤāĻžāϰāĻĒāϰ vector-āϟāĻž āĻ“āϰ āĻļ⧇āώ index āĻĨ⧇āϕ⧇ 0 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ print āĻ•āϰ⧋, āĻĻ⧁āχāϟāĻž word-āĻāϰ āĻŽāĻžāĻā§‡ āĻāĻ•āϟāĻž space āĻĻāĻŋāϝāĻŧ⧇āĨ¤

Problem 8: palindrome-linesāĻŽāĻžāĻāĻžāϰāĻŋPro

Zara āĻāĻ•āϟāĻž āϞāĻžāχāύ⧇āϰ āĻļ⧁āϧ⧁ āĻ…āĻ•ā§āώāϰ āφāϰ digit āϰāĻžāϖ⧇, āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ•āϰ⧇, āϤāĻžāϰāĻĒāϰ āĻĻ⧇āϖ⧇ āϏ⧇āϟāĻž āĻĻ⧁āχ āĻĻāĻŋāĻ• āĻĨ⧇āϕ⧇ āĻāĻ•āχ āĻĒāĻĄāĻŧāĻžāϝāĻŧ āĻ•āĻŋ āύāĻžāĨ¤ āĻ•āĻŋāϛ⧁āχ āĻŦāĻžāĻ•āĻŋ āύāĻž āĻĨāĻžāĻ•āϞ⧇ āϏ⧇āϟāĻžāĻ“ palindromeāĨ¤

Input. n, āϤāĻžāϰāĻĒāϰ n-āϟāĻž āϞāĻžāχāύāĨ¤

Output. āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ⧇āϰ āϜāĻ¨ā§āϝ yes āĻŦāĻž noāĨ¤

Constraints. āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ⧇ 1 āĻĨ⧇āϕ⧇ 100000āϟāĻž printable ASCII character, āφāϰ āĻĒ⧁āϰ⧋ input āĻŦāĻĄāĻŧāĻœā§‹āϰ 1000000 byteāĨ¤

Sample. Input 5, A man, a plan, a canal: Panama, race a car, ?!, No 'x' in Nixon āφāϰ 12321 āĻĻāĻŋāϞ⧇ āĻĒāĻžāρāϚ āϞāĻžāχāύ⧇ yes, no, yes, yes āφāϰ yesāĨ¤

#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;
}
Run in Compiler

Hint 1

āĻļ⧁āϧ⧁ āĻ…āĻ•ā§āώāϰ āφāϰ digit āϰāĻžāĻ–āϞ⧇ ?!-āĻāϰ āϕ⧀ āĻŦāĻžāĻ•āĻŋ āĻĨāĻžāϕ⧇? āϏ⧇āϟāĻž āĻ•āĻŋ āĻĻ⧁āχ āĻĻāĻŋāĻ• āĻĨ⧇āϕ⧇ āĻāĻ•āχ āĻĒāĻĄāĻŧāĻžāϝāĻŧ?

Hint 2

āĻ…āĻ•ā§āώāϰ āφāϰ digit āĻĻāĻŋāϝāĻŧ⧇ āĻāĻ•āϟāĻž āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ string āĻŦāĻžāύāĻžāĻ“, āĻĒā§āϰāϤāĻŋāϟāĻž āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ•āϰ⧇āĨ¤ āϤāĻžāϰāĻĒāϰ āĻĻ⧁āχ āĻŽāĻžāĻĨāĻž āĻĨ⧇āϕ⧇ āĻĻ⧁āχāϟāĻž index āĻ­āĻŋāϤāϰ⧇āϰ āĻĻāĻŋāϕ⧇ āĻšāĻžāρāϟāĻžāĻ“, āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇ āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇, āϝāϤāĻ•ā§āώāĻŖ āύāĻž āĻ“āϰāĻž āĻŽā§āĻ–ā§‹āĻŽā§āĻ–āĻŋ āĻšāϝāĻŧāĨ¤

Problem 9: run-lengthāĻ•āĻ āĻŋāύPro

Kenji āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ⧇āϰ āĻāĻ•āϟāĻž string encode āĻ•āϰ⧇: āĻāĻ•āχ āĻ…āĻ•ā§āώāϰ⧇āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž āϟāĻžāύāĻž āĻĻāϞ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ āĻ“āχ āĻ…āĻ•ā§āώāϰ āφāϰ āϤāĻžāϰāĻĒāϰ āĻĻāϞ⧇āϰ lengthāĨ¤ āϤāĻžāχ aaabccdddd āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ a3b1c2d4āĨ¤

Input. āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ⧇āϰ āĻāĻ•āϟāĻž stringāĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ encode āĻ•āϰāĻž stringāĨ¤

Constraints. String-āĻ 1 āĻĨ⧇āϕ⧇ 500000āϟāĻž āĻ…āĻ•ā§āώāϰāĨ¤ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ test, length 1-āĻāϰ 500000āϟāĻž āĻĻāϞ, āωāĻ¤ā§āϤāϰ ans = ans + ... āĻĻāĻŋāϝāĻŧ⧇ āύāϤ⧁āύ āĻ•āϰ⧇ āĻ—āĻĄāĻŧāϞ⧇ āϏāĻŽāϝāĻŧ āĻĢ⧁āϰāĻŋāϝāĻŧ⧇ āĻĢ⧇āϞ⧇; āĻāϟāĻž GCC 12-āĻ āĻŽāĻžāĻĒāĻžāĨ¤

Sample. Input aaabccdddd āĻĻāĻŋāϞ⧇ 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;
}
Run in Compiler

Hint 1

āĻāĻ•āϟāĻž āĻĻāϞ āĻļ⧇āώ āĻšāϝāĻŧ āϕ⧋āĻĨāĻžāϝāĻŧ? āφāϰ 500000āϟāĻž āĻĻāϞ⧇āϰ āĻĒā§āϰāϤāĻŋāϟāĻžāϰ length 1 āĻšāϞ⧇ āωāĻ¤ā§āϤāϰ āĻ•āϤ āϞāĻŽā§āĻŦāĻž?

Hint 2

āĻāĻ•āϟāĻž āĻĻāϞ⧇āϰ āĻļ⧁āϰ⧁ āĻĨ⧇āϕ⧇ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āĻāĻ•āϟāĻž index āĻāĻ—āĻŋāϝāĻŧ⧇ āύāĻžāĻ“, āϝāϤāĻ•ā§āώāĻŖ āĻ…āĻ•ā§āώāϰ āĻāĻ•āχ āĻĨāĻžāϕ⧇āĨ¤ āĻ…āĻ•ā§āώāϰāϟāĻž āφāϰ āĻĻāϞ⧇āϰ length, text āĻšāĻŋāϏ⧇āĻŦ⧇, āωāĻ¤ā§āϤāϰ⧇āϰ āĻļ⧇āώ⧇ āϝ⧋āĻ— āĻ•āϰ⧋āĨ¤ āĻĻāϞ āϝ⧇āĻ–āĻžāύ⧇ āĻļ⧇āώ āĻšāϞ⧋ āϏ⧇āĻ–āĻžāύ⧇ āϞāĻžāĻĢ āĻĻāĻžāĻ“, āφāϰ āĻāĻ•āĻĻāĻŽ āĻļ⧇āώ⧇ āωāĻ¤ā§āϤāϰāϟāĻž āĻāĻ•āĻŦāĻžāϰ print āĻ•āϰ⧋āĨ¤

Problem 10: big-addāĻ•āĻ āĻŋāύPro

Amara-āϰ calculator-āϕ⧇ āĻāĻŽāύ āĻĻ⧁āχāϟāĻž non-negative āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž āϝ⧋āĻ— āĻ•āϰāϤ⧇ āĻšāĻŦ⧇, āϝ⧇āϗ⧁āϞ⧋ āĻāĻ•āϟāĻž long long-āĻāϰ āϜāĻ¨ā§āϝ āĻ…āύ⧇āĻ• āĻŦāĻĄāĻŧāĨ¤ āĻ“āϗ⧁āϞ⧋ string āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻĄāĻŧā§‹, āφāϰ āϝ⧋āĻ—āĻĢāϞ print āĻ•āϰ⧋āĨ¤

Input. āĻĻ⧁āχāϟāĻž āϞāĻžāχāύ, āĻĒā§āϰāϤāĻŋāϟāĻžāϝāĻŧ āĻāĻ•āϟāĻž non-negative āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻžāĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ āϝ⧋āĻ—āĻĢāϞāĨ¤

Constraints. āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻžāϝāĻŧ 1 āĻĨ⧇āϕ⧇ 100000āϟāĻž digit, āĻļ⧁āϰ⧁āϤ⧇ āϕ⧋āύ⧋ āĻļā§‚āĻ¨ā§āϝ āύ⧇āχ, āĻļ⧁āϧ⧁ 0 āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āĻ›āĻžāĻĄāĻŧāĻžāĨ¤

Sample. Input 958 āφāϰ 67 āĻĻāĻŋāϞ⧇ 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;
}
Run in Compiler

Hint 1

āĻ–āĻžāϤāĻžāϰ āύāĻŋāϝāĻŧāĻŽā§‡ āϝ⧋āĻ— āĻļ⧁āϰ⧁ āĻšāϝāĻŧ āϕ⧋āĻĨāĻž āĻĨ⧇āϕ⧇, āφāϰ āϕ⧋āύ⧋ āĻ•āϞāĻžāĻŽ 10-āĻ āĻĒ⧌āρāĻ›āĻžāϞ⧇ āϕ⧀ āĻšāϝāĻŧ? 999 āϝ⧋āĻ— 1 āĻ•āϰ⧇ āĻĻ⧇āĻ–ā§‹āĨ¤

Hint 2

āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻļ⧇āώ digit āĻĨ⧇āϕ⧇ āĻāĻ•āϟāĻž index āĻĒ⧇āĻ›āύ⧇āϰ āĻĻāĻŋāϕ⧇ āĻšāĻžāρāϟāĻžāĻ“āĨ¤ āĻāĻ•āϟāĻž āĻ•āϞāĻžāĻŽ āϝ⧋āĻ— āĻ•āϰ⧇ āĻĻ⧁āχāϟāĻž digit, āϕ⧋āύ⧋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ digit āĻĢ⧁āϰāĻžāϞ⧇ 0, āφāϰ āĻšāĻžāϤ⧇āϰ āϏāĻ‚āĻ–ā§āϝāĻžāĨ¤ āĻ“āϰ āĻļ⧇āώ digit-āϟāĻž āĻĢāϞāĻžāĻĢāϞ⧇ āϝ⧋āĻ— āĻ•āϰ⧋, āφāϰ āĻĻāĻļāϕ⧇āϰ āĻ…āĻ‚āĻļāϟāĻž āĻšāĻžāϤ⧇ āϰāĻžāĻ–ā§‹āĨ¤ āϕ⧋āύ⧋ digit āĻŦāĻž āĻšāĻžāϤ⧇ āĻ•āĻŋāϛ⧁ āĻŦāĻžāĻ•āĻŋ āĻĨāĻžāĻ•āĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϚāĻžāϞāĻžāĻ“, āϤāĻžāϰāĻĒāϰ āĻĢāϞāĻžāĻĢāϞāϟāĻž āĻāĻ•āĻŦāĻžāϰ āωāĻ˛ā§āĻŸā§‡ āĻĻāĻžāĻ“āĨ¤

āϏāϚāϰāĻžāϚāϰ āϝ⧇ āĻĒā§āϰāĻļā§āύāϗ⧁āϞ⧋ āφāϏ⧇

  • find āϕ⧇āύ -1 āύāĻž āĻĻāĻŋāϝāĻŧ⧇ string::npos āĻĻ⧇āϝāĻŧ?

    find āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ āĻāĻ•āϟāĻž size_t, āϝ⧇āϟāĻž negative āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤ āϤāĻžāχ library āĻĻ⧇āϝāĻŧ āĻāĻŽāύ āĻāĻ•āϟāĻž āĻŽāĻžāύ, āϝ⧇āĻ–āĻžāύ⧇ āϕ⧋āύ⧋ āφāϏāϞ index āĻĒ⧌āρāĻ›āĻžāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž, āĻŽāĻžāύ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ size_t, āφāϰ āĻ“āϰ āύāĻžāĻŽ āĻĻ⧇āϝāĻŧ string::nposāĨ¤ āĻ“āχ āύāĻžāĻŽā§‡āϰ āϏāĻžāĻĨ⧇ āϤ⧁āϞāύāĻž āĻ•āϰ⧋, āϤāĻžāĻšāϞ⧇ code āϏāĻŦ machine-āĻ āϚāϞāĻŦ⧇āĨ¤

  • Judge āϞāĻžāχāύ⧇āϰ āĻļ⧇āώ⧇āϰ space āϧāϰ⧇ āύāĻžāĨ¤ āϤāĻžāĻšāϞ⧇ āĻ•āĻŋ āĻĒā§āϰāϤāĻŋāϟāĻž word-āĻāϰ āĻĒāϰ⧇ āĻāĻ•āϟāĻž space āϰ⧇āϖ⧇ āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰāĻŋ?

    āϞāĻžāχāύ⧇āϰ āĻāĻ•āĻĻāĻŽ āĻļ⧇āώ⧇, āĻšā§āϝāĻžāρ, judge āĻ“āϟāĻž āϧāϰ⧇ āύāĻžāĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āϞāĻžāχāύ⧇āϰ āĻ­āĻŋāϤāϰ⧇ āĻĻ⧁āχāϟāĻž space, āĻŦāĻž āĻļ⧁āϰ⧁āϤ⧇ āĻāĻ•āϟāĻž, āĻŽāĻžāύ⧇ āφāϞāĻžāĻĻāĻž āĻāĻ•āϟāĻž āϞāĻžāχāύ, āφāϰ āωāĻ¤ā§āϤāϰ āϭ⧁āϞāĨ¤ āĻĻ⧁āχāϟāĻž word-āĻāϰ āĻŽāĻžāĻā§‡ āĻāĻ•āϟāĻž space, āĻĒā§āϰāĻĨāĻŽāϟāĻžāϰ āφāϗ⧇ āĻ•āĻ–āύ⧋ āύāĻž, āĻāχ āĻ…āĻ­ā§āϝāĻžāϏāϟāĻžāχ āϏāĻŦāϏāĻŽāϝāĻŧ āĻ āĻŋāĻ•āĨ¤

  • āĻĒā§āϰāϤāĻŋāϟāĻž input ASCII āϕ⧇āύ? āφāϏāϞ text-āĻ āϤ⧋ āĻŦāĻžāĻ‚āϞāĻž āĻĨāĻžāϕ⧇āĨ¤

    ASCII-āϤ⧇ āĻāĻ•āϟāĻž character āĻŽāĻžāύ⧇ āĻāĻ• byte, āϤāĻžāχ size(), s[i] āφāϰ tolower āϝāĻž āĻŽāύ⧇ āĻšāϝāĻŧ āĻ āĻŋāĻ• āϤāĻžāχ āĻ•āϰ⧇āĨ¤ UTF-8-āĻ āĻāĻ•āϟāĻž āĻŦāĻžāĻ‚āϞāĻž āĻ…āĻ•ā§āώāϰ 3 byte, āϤāĻžāχ āĻāĻ•āχ code byte āϗ⧁āύāϤ, lesson 01 āϝ⧇āĻŽāύ āĻĻ⧇āĻ–āĻŋāϝāĻŧ⧇āϛ⧇āĨ¤ āφāϏāϞ āĻ…āĻ•ā§āώāϰ āϗ⧁āύāϤ⧇ āĻāϰ āϜāĻ¨ā§āϝ āĻŦāĻžāύāĻžāύ⧋ library āϞāĻžāϗ⧇, āφāϰ āϏ⧇āϟāĻž āĻāχ set-āĻāϰ āĻŦāĻžāχāϰ⧇āĨ¤

  • ans = ans + piece āĻ•āĻŋ āϏāĻŦāϏāĻŽāϝāĻŧāχ āϭ⧁āϞ?

    āύāĻžāĨ¤ āĻ•āϝāĻŧ⧇āĻ•āϟāĻž āϟ⧁āĻ•āϰ⧋ āĻāĻ•āĻŦāĻžāϰ āĻœā§‹āĻĄāĻŧāĻž āĻĻ⧇āĻ“āϝāĻŧāĻž, āϝ⧇āĻŽāύ name = first + " " + last, āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ āφāϰ āϏāĻ¸ā§āϤāĻžāĨ¤ āĻ–āϰāϚ āφāϏ⧇ āϝāĻ–āύ āωāĻ¤ā§āϤāϰ loop-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āĻŦāĻžāĻĄāĻŧāϤ⧇ āĻĨāĻžāϕ⧇, āĻ•āĻžāϰāĻŖ āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ āĻ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻ—āĻĄāĻŧāĻž āϏāĻŦāĻ•āĻŋāϛ⧁ copy āĻšāϝāĻŧāĨ¤ Loop-āĻāϰ āĻ­āĻŋāϤāϰ⧇ += āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧋āĨ¤

āĻŽā§‚āϞ āĻ•āĻĨāĻž

  • Word āĻĒāĻĄāĻŧā§‹ cin >> āĻĻāĻŋāϝāĻŧ⧇ āφāϰ āϞāĻžāχāύ getline āĻĻāĻŋāϝāĻŧ⧇; cin >> n-āĻāϰ āĻĒāϰ⧇ āĻāĻ•āϟāĻž getline āĻ“āχ āϞāĻžāχāύāϟāĻž āĻļ⧇āώ āĻ•āϰ⧇āĨ¤
  • āĻāĻ–āĻžāύ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž input ASCII, āϤāĻžāχ size() character āĻ—ā§‹āύ⧇ āφāϰ s[i] āĻŽāĻžāύ⧇ āĻāĻ•āϟāĻž characterāĨ¤
  • find āĻĻ⧇āϝāĻŧ āĻāĻ•āϟāĻž index āĻŦāĻž string::npos; āĻ“āϟāĻž āĻāĻ•āϟāĻž size_t-āĻ āϰāĻžāĻ–ā§‹ āφāϰ string::npos-āĻāϰ āϏāĻžāĻĨ⧇ āĻŽā§‡āϞāĻžāĻ“āĨ¤
  • 1018 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻ‚āĻ–ā§āϝāĻž āĻāĻ•āϟāĻž long long-āĻ āϧāϰ⧇; āĻāϰ āĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻžāϗ⧁āϞ⧋ string āĻšāϝāĻŧ⧇āχ āĻĨāĻžāϕ⧇, āφāϰ āϝ⧋āĻ— āĻšāϝāĻŧ āĻāĻ• āĻ•āϞāĻžāĻŽ āĻ•āϰ⧇āĨ¤
  • āĻŦāĻžāĻĄāĻŧāϤ⧇ āĻĨāĻžāĻ•āĻž āωāĻ¤ā§āϤāϰ āĻ—āĻĄāĻŧā§‹ += āĻĻāĻŋāϝāĻŧ⧇: loop-āĻ ans = ans + piece āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ test-āĻ āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰāχ āĻāĻ• āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒ⧇āϰāĻŋāϝāĻŧ⧇ āϗ⧇āϛ⧇āĨ¤
  • āφāϰāĻ“ āĻ—āĻ­ā§€āϰ⧇ āϝ⧇āϤ⧇ āϚāĻžāχāϞ⧇: CP and Interview Pack, string-āĻāϰ pattern āφāϰ bug gallery (Pro)āĨ¤

āĻāϰāĻĒāϰ āφāϏāϛ⧇ cheat sheet, āĻāĻ• āĻĒāĻžāϤāĻžāϝāĻŧ āĻĒ⧁āϰ⧋ string, āϤāĻžāϰāĻĒāϰ module testāĨ¤

lesson ā§­ āĻļ⧇āώ

āϏāĻŦ problem accepted āĻšāϞ⧇āχ lesson āĻļ⧇āώāĨ¤

ā§Š āϟāĻž free problem-āĻāϰ āĻŽāĻ§ā§āϝ⧇ ā§Ļ āϟāĻž accepted

āĻĒāϰ⧇āϰāϟāĻž: Cheat sheet: āĻāĻ• āĻĒāĻžāϤāĻžāϝāĻŧ string

Problem: string | Learn C++ STL | Progsity