Learn C Programming

lesson ā§§ / ⧝ ¡ Loop āφāϰ jump statement

Module ā§Ŧ ¡ Loop āφāϰ jump statement

While: āĻŦāĻžāϰāĻŦāĻžāϰ āĻ•āϰāĻžāϰ āϧāĻžāϰāĻŖāĻž

FreeāĻĒāĻĄāĻŧāĻž

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

  • āĻļ⧁āϰ⧁, condition āφāϰ step āĻĻāĻŋāϝāĻŧ⧇ āĻāĻ•āϟāĻž while loop āϞāĻŋāĻ–āϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ āϚāĻžāϞāĻžāύ⧋āϰ āφāϗ⧇ table āĻĻāĻŋāϝāĻŧ⧇ trace āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤
  • Sentinel āφāϏāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ, āĻŦāĻž input āĻļ⧇āώ āĻšāĻ“āϝāĻŧāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻ‚āĻ–ā§āϝāĻž āĻĒāĻĄāĻŧāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ while (scanf("%d", &x) == 1) āĻĻāĻŋāϝāĻŧ⧇āĨ¤
  • āĻāĻ•āϟāĻž āĻ…āĻ‚āĻļ āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧāϞ⧇ āϕ⧀ āĻšāϝāĻŧ āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ āĻĒā§āϰāĻĨāĻŽ āĻĒāĻĄāĻŧāĻž āĻŽāĻžāύ āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇ āĻāĻ–āύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏ⧇āϰāĻž āĻŽāĻžāύāϟāĻž āϧāϰ⧇ āϰāĻžāĻ–āϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤

Bob-āĻāϰ rocket game-āĻ āĻāĻ•āϟāĻž countdown āϞāĻžāĻ—āĻŦ⧇: 3, 2, 1, liftoffāĨ¤ āĻ“ āϚāĻžāϰāϟāĻž printf āϞāĻžāχāύ āϞ⧇āϖ⧇, āφāϰ āĻ•āĻžāϜ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤

āϤāĻžāϰāĻĒāϰ designer āĻŦāϞ⧇, countdown āĻļ⧁āϰ⧁ āĻšāĻŦ⧇ 100 āĻĨ⧇āϕ⧇āĨ¤ Bob 101āϟāĻž āϞāĻžāχāύ āϞāĻŋāĻ–āϤ⧇ āϚāĻžāϝāĻŧ āύāĻž, āφāϰ āϞ⧇āĻ–āĻž āωāϚāĻŋāϤāĻ“ āύāĻžāĨ¤ āĻāĻ•āϟāĻžāχ āĻ•āĻžāϜ, "āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āĻ›āĻžāĻĒā§‹, āϤāĻžāϰāĻĒāϰ āĻāĻ• āĻ•āĻŽāĻžāĻ“", āĻŦāĻžāϰāĻŦāĻžāϰ āϚāϞāϤ⧇ āĻšāĻŦ⧇āĨ¤

Loop āĻšāϞ⧋ code-āĻāϰ āĻāĻŽāύ āĻāĻ•āϟāĻž āĻ…āĻ‚āĻļ, āϝ⧇āϟāĻž āĻāĻ•āϟāĻž condition āϝāϤāĻ•ā§āώāĻŖ āĻ…āύ⧁āĻŽāϤāĻŋ āĻĻ⧇āϝāĻŧ āϤāϤāĻ•ā§āώāĻŖ āĻŦāĻžāϰāĻŦāĻžāϰ āϚāϞ⧇āĨ¤ Computer āĻāĻ•āχ āĻ•āĻžāϜ āĻŦāĻžāϰāĻŦāĻžāϰ āĻ•āϰāϤ⧇ āĻ•āĻ–āύ⧋ āĻŦāĻŋāϰāĻ•ā§āϤ āĻšāϝāĻŧ āύāĻž, āφāϰ āĻ“āϰ āĻ•āĻžāĻœā§‡ āϞāĻžāĻ—āĻžāϰ āφāϏāϞ āĻ•āĻžāϰāĻŖāχ āĻāϟāĻžāĨ¤

while: āĻāĻ•āχ block, āĻŦāĻžāϰāĻŦāĻžāϰ

while loop āĻāĻ•āϟāĻž condition āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰ⧇āĨ¤ āϏāĻ¤ā§āϝ āĻšāϞ⧇ block-āϟāĻž āĻāĻ•āĻŦāĻžāϰ āϚāĻžāϞāĻžāϝāĻŧ, āϤāĻžāϰāĻĒāϰ āĻĢāĻŋāϰ⧇ āĻ—āĻŋāϝāĻŧ⧇ āφāĻŦāĻžāϰ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰ⧇āĨ¤ āϝ⧇āĻŦāĻžāϰ āĻĒā§āϰāĻĨāĻŽ āĻŽāĻŋāĻĨā§āϝāĻž āĻĒāĻžāϝāĻŧ, āϏ⧇āĻŦāĻžāϰāχ āĻĨāĻžāĻŽā§‡āĨ¤

while loop

while (condition) {
    statements
}
  • while āĻšāϞ⧋ keyword, āφāϰ āĻāϰ āĻĒāϰ⧇ āϏāĻŦ āϏāĻŽāϝāĻŧ āĻŦāĻ¨ā§āϧāύ⧀ āφāϏ⧇āĨ¤
  • Block-āϟāĻž āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ āϚāĻžāϞāĻžāύ⧋āϰ āφāϗ⧇ condition āĻĒāϰ⧀āĻ•ā§āώāĻž āĻšāϝāĻŧāĨ¤ āĻļā§‚āĻ¨ā§āϝ āĻŽāĻžāύ⧇ āĻĨāĻžāĻŽā§‹; āĻŦāĻžāĻ•āĻŋ āϝ⧇āϕ⧋āύ⧋ āĻŽāĻžāύ āĻŽāĻžāύ⧇ āφāϰ⧇āĻ•āĻŦāĻžāϰ āϚāĻžāϞāĻžāĻ“āĨ¤
  • Brace-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āĻĨāĻžāϕ⧇ bodyāĨ¤ Body āĻāĻ•āĻŦāĻžāϰ āϚāϞāĻžāϕ⧇ āĻŦāϞ⧇ āĻāĻ•āϟāĻž pass (āϕ⧋āύ⧋ āϕ⧋āύ⧋ āĻŦāχ āĻŦāϞ⧇ iteration)āĨ¤
  • āĻĒāϰ⧀āĻ•ā§āώāĻž āĻŽāĻŋāĻĨā§āϝāĻž āĻšāϞ⧇ program āĻļ⧇āώ brace-āĻāϰ āĻĒāϰ āĻĨ⧇āϕ⧇ āϚāϞāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤
#include <stdio.h>

int main(void)
{
    int n = 3;

    while (n > 0) {
        printf("%d\n", n);
        n--;
    }
    printf("liftoff\n");
    return 0;
}
3
2
1
liftoff

3-āϕ⧇ 100 āĻ•āϰ⧇ āĻĻāĻžāĻ“, program āĻĒ⧁āϰ⧋ countdown āĻ›āĻžāĻĒāĻŦ⧇āĨ¤ āφāϰ āĻāĻ•āϟāĻž āϞāĻžāχāύāĻ“ āĻŦāĻĻāϞāĻžāϤ⧇ āĻšāϝāĻŧ āύāĻžāĨ¤

āϤāĻžāϰ āĻŽāĻžāύ⧇ while āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻž if, āϝ⧇āϟāĻž āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āĻĒāϰ⧇ āύāĻŋāĻœā§‡āϰ āĻĒāϰ⧀āĻ•ā§āώāĻžāϝāĻŧ āĻĢāĻŋāϰ⧇ āϝāĻžāϝāĻŧāĨ¤ āωāĻ¤ā§āϤāϰ "āύāĻž" āĻšāĻ“āϝāĻŧāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ body āϚāϞāϤ⧇āχ āĻĨāĻžāϕ⧇āĨ¤

āϚāĻžāϞāĻžāύ⧋āϰ āφāϗ⧇ table āĻĻāĻŋāϝāĻŧ⧇ loop trace āĻ•āϰ⧋

āĻāĻ•āχ āϞāĻžāχāύ āĻ…āύ⧇āĻ•āĻŦāĻžāϰ āϚāϞ⧇, āϤāĻžāχ loop āĻāĻ•āĻŦāĻžāϰ āĻšā§‹āĻ– āĻŦ⧁āϞāĻŋāϝāĻŧ⧇ āĻĒāĻĄāĻŧāĻž āĻ•āĻ āĻŋāύāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āϜāĻ¨ā§āϝ āĻāĻ• āϏāĻžāϰāĻŋ āϰ⧇āϖ⧇ āĻāĻ•āϟāĻž trace table āĻŦāĻžāύāĻžāĻ“ (Module 5): āĻĒāϰ⧀āĻ•ā§āώāĻžāϰ āϏāĻŽāϝāĻŧ variable-āϗ⧁āϞ⧋āϰ āĻŽāĻžāύ, āωāĻ¤ā§āϤāϰ, āφāϰ body āϕ⧀ āĻ•āϰāϞāĨ¤

PassāĻĒāϰ⧀āĻ•ā§āώāĻžāϰ āϏāĻŽāϝāĻŧ nn > 0Body āĻ›āĻžāĻĒ⧇n---āĻāϰ āĻĒāϰ⧇ n
13āϏāĻ¤ā§āϝ32
22āϏāĻ¤ā§āϝ21
31āϏāĻ¤ā§āϝ10
āύ⧇āχ, āĻļ⧁āϧ⧁ āĻĒāϰ⧀āĻ•ā§āώāĻž0āĻŽāĻŋāĻĨā§āϝāĻžāĻ•āĻŋāϛ⧁ āύāĻž; loop āĻļ⧇āώ0

āϏāĻžāϰāĻŋāϗ⧁āϞ⧋ āĻ—ā§‹āύ⧋āĨ¤ Body āϚāϞ⧇āϛ⧇ 3 āĻŦāĻžāϰ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻšāϝāĻŧ⧇āϛ⧇ 4 āĻŦāĻžāϰāĨ¤ āĻļ⧇āώ āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž, āϝ⧇āϟāĻž āĻŽāĻŋāĻĨā§āϝāĻž āĻŦāϞ⧇, āϏ⧇āϟāĻžāχ loop āĻļ⧇āώ āĻ•āϰ⧇āĨ¤

while loop, back edge-āϏāĻš āĻāĻ•āϟāĻž flowchart āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž pass āĻļ⧇āώ āĻšāϝāĻŧ āĻĒāϰ⧀āĻ•ā§āώāĻžāϝāĻŧ āĻĢāĻŋāϰ⧇ āϝāĻžāĻ“āϝāĻŧāĻž āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧁āϰ⧁: n = 3 āĻĒāϰ⧀āĻ•ā§āώāĻž: n > 0 āĻšā§āϝāĻžāρ body: n āĻ›āĻžāĻĒā§‹ step: n-- back edge āύāĻž liftoff āĻ›āĻžāĻĒā§‹ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āφāϗ⧇ āĻĒāϰ⧀āĻ•ā§āώāĻž āϚāϞ⧇āĨ¤ n = 3 āĻšāϞ⧇ body āϚāϞ⧇ 3 āĻŦāĻžāϰ, āĻĒāϰ⧀āĻ•ā§āώāĻž āĻšāϝāĻŧ 4 āĻŦāĻžāϰāĨ¤ āĻŦ⧇āϰ⧋āύ⧋āϰ āĻāĻ•āĻŽāĻžāĻ¤ā§āϰ āĻĒāĻĨ "āύāĻž"-āĻāϰ āϤ⧀āϰ, āϤāĻžāχ body-āϰ āĻ­āĻŋāϤāϰ⧇ āĻ•āĻŋāϛ⧁ āĻāĻ•āϟāĻžāϕ⧇ n-āϕ⧇ āĻ“āĻĻāĻŋāϕ⧇ āϠ⧇āϞāϤ⧇ āĻšāĻŦ⧇āĨ¤

āϰāĻ™āĻŋāύ āϤ⧀āϰāϟāĻž āĻšāϞ⧋ back edge: body-āϰ āĻļ⧇āώ āĻĨ⧇āϕ⧇ āĻĒāϰ⧀āĻ•ā§āώāĻžāϝāĻŧ āĻĢāĻŋāϰ⧇ āϝāĻžāĻ“āϝāĻŧāĻžāϰ āϞāĻžāĻĢāĨ¤ if-āĻāϰ āĻāĻŽāύ āĻ•āĻŋāϛ⧁ āύ⧇āχ, āφāϰ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āφāϰ loop-āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻĒ⧁āϰ⧋ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝāϟāĻž āĻāχ āϤ⧀āϰ⧇āχāĨ¤

āϤāĻžāχ loop āϚāĻžāϞāĻžāύ⧋āϰ āφāϗ⧇ āĻ•āĻžāĻ—āĻœā§‡ table-āϟāĻž āĻ­āϰ⧇ āĻĢ⧇āϞ⧋āĨ¤ āĻļ⧇āώ āϏāĻžāϰāĻŋāϟāĻž āϝāĻĻāĻŋ āĻ•āĻ–āύ⧋ āύāĻž āφāϏ⧇, loop-āĻ“ āĻ•āĻ–āύ⧋ āĻļ⧇āώ āĻšāĻŦ⧇ āύāĻžāĨ¤

āĻļ⧁āϰ⧁, condition āφāϰ step: āĻĒā§āϰāϤāĻŋāϟāĻž loop-āĻāϰ āϤāĻŋāύāϟāĻž āĻ…āĻ‚āĻļ

āϝ⧇ loop āĻļ⧇āώ āĻšāϝāĻŧ, āϤāĻžāϰ āϤāĻŋāύāϟāĻž āĻ…āĻ‚āĻļ āĻĨāĻžāϕ⧇āĨ¤ āĻļ⧁āϰ⧁ variable-āϕ⧇ āĻĒā§āϰāĻĨāĻŽ āĻŽāĻžāύ āĻĻ⧇āϝāĻŧāĨ¤ Condition āĻ āĻŋāĻ• āĻ•āϰ⧇ āφāϰ⧇āĻ•āϟāĻž pass āϚāϞāĻŦ⧇ āĻ•āĻŋ āύāĻžāĨ¤ Step variable-āϟāĻž āĻŦāĻĻāϞāĻžāϝāĻŧ, āϝāĻžāϤ⧇ condition āĻāĻ•āϏāĻŽāϝāĻŧ āĻŽāĻŋāĻĨā§āϝāĻž āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āĻ…āĻ‚āĻļCountdown-āĻāύāĻž āĻĨāĻžāĻ•āϞ⧇ āĻŦāĻž āϭ⧁āϞ āĻšāϞ⧇
āĻļ⧁āϰ⧁int n = 3;Loop āϭ⧁āϞ āϜāĻžāϝāĻŧāĻ—āĻž āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻšāϝāĻŧāĨ¤ n-āϕ⧇ 0 āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰāϞ⧇ body āĻāĻ•āĻŦāĻžāϰāĻ“ āϚāϞ⧇ āύāĻžāĨ¤
conditionn > 0āĻāϕ⧇āĻŦāĻžāϰ⧇ āĻŦāĻžāĻĻ āĻĻāĻŋāϞ⧇, while (), āĻ•āĻŋāϛ⧁āχ compile āĻšāϝāĻŧ āύāĻžāĨ¤ āϝ⧇ condition āĻ•āĻ–āύ⧋ āĻŽāĻŋāĻĨā§āϝāĻž āĻšāϝāĻŧ āύāĻž, āϏ⧇āϟāĻž āϚāĻŋāϰāĻ•āĻžāϞ āĻ˜ā§‹āϰ⧇āĨ¤
stepn--;n āĻĨ⧇āϕ⧇ āϝāĻžāϝāĻŧ 3, āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ āĻĒāϰ⧀āĻ•ā§āώāĻž āϏāĻ¤ā§āϝ, āφāϰ loop āĻ•āĻ–āύ⧋ āĻļ⧇āώ āĻšāϝāĻŧ āύāĻžāĨ¤

āĻĢāĻžāρāĻ•āĻž āĻŦāĻ¨ā§āϧāύ⧀ āĻĒā§āϰāϤāĻŋāϟāĻž command line-āĻ error, Playground-āϏāĻš: error: expected expression before ')' tokenāĨ¤

āĻļā§‚āĻ¨ā§āϝ pass-āĻāϰ āĻŦā§āϝāĻžāĻĒāĻžāϰāϟāĻž āϖ⧇āϝāĻŧāĻžāϞ āĻ•āϰ⧋āĨ¤ while āĻĒā§āϰāĻĨāĻŽ pass-āĻāϰ āφāϗ⧇āχ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰ⧇, āϤāĻžāχ āĻ“āϰ body āĻšāϝāĻŧāϤ⧋ āĻāĻ•āĻŦāĻžāϰāĻ“ āϚāϞāĻŦ⧇ āύāĻžāĨ¤ Lesson 3-āĻ āĻāĻŽāύ āĻāĻ•āϟāĻž loop āφāϏāϛ⧇, āϝ⧇āϟāĻž āĻ…āĻ¨ā§āϤāϤ āĻāĻ•āĻŦāĻžāϰ āϚāϞāĻŦ⧇āχāĨ¤

āϤāĻžāχ loop āωāĻ˛ā§āϟāĻžāĻĒāĻžāĻ˛ā§āϟāĻž āĻ•āϰāϞ⧇ āϤāĻŋāύāϟāĻž āĻ…āĻ‚āĻļ āĻ•ā§āϰāĻŽā§‡ āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–ā§‹āĨ¤ Condition āĻ•āĻŋ āĻ•āĻ–āύ⧋ āĻŽāĻŋāĻĨā§āϝāĻž āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āφāϰ step āĻ•āĻŋ āĻ“āĻĻāĻŋāϕ⧇āχ āĻāĻ—ā§‹āϝāĻŧ?

Bob-āĻāϰ āϝ⧇ timer āĻ•āĻ–āύ⧋ āĻĨāĻžāĻŽā§‡ āύāĻž

Bob āϰāĻžāĻ¨ā§āύāĻžāϘāϰ⧇āϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻž timer āϞ⧇āϖ⧇āĨ¤ 5 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĨ⧇āϕ⧇ āωāĻ˛ā§āĻŸā§‹ āĻĻāĻŋāϕ⧇ āϗ⧁āύāĻŦ⧇, āϤāĻžāϰāĻĒāϰ beep āĻĻ⧇āĻŦ⧇āĨ¤ āϤāĻžāĻĄāĻŧāĻžāĻšā§āĻĄāĻŧāĻžāϝāĻŧ step-āϟāĻž āĻ“ āϭ⧁āϞ āϞ⧇āϖ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    int seconds = 5;

    while (seconds > 0) {
        seconds - 1;
    }
    printf("beep\n");
    return 0;
}

seconds - 1; āϞāĻžāχāύāϟāĻž 4 āĻšāĻŋāϏāĻžāĻŦ āĻ•āϰ⧇, āϤāĻžāϰāĻĒāϰ āĻĢ⧇āϞ⧇ āĻĻ⧇āϝāĻŧ, āϤāĻžāχ seconds āĻĨ⧇āϕ⧇ āϝāĻžāϝāĻŧ 5āĨ¤ Loop-āϟāĻžāϰ āφāϏāϞ⧇ āϕ⧋āύ⧋ step āύ⧇āχāĨ¤

Playground-āĻ āĻ•āĻŋāϛ⧁āχ āφāϏ⧇ āύāĻžāĨ¤ 10 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĒāϰ⧇ (free āĻŦāĻž sign in āύāĻž āĻ•āϰāĻž learner-āĻāϰ limit) Playground program-āϟāĻž āĻĨāĻžāĻŽāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤ Status badge-āĻ āϞ⧇āĻ–āĻž āĻ“āϠ⧇ āϟāĻžāχāĻŽ āϞāĻŋāĻŽāĻŋāϟ āĻĒāĻžāϰ āĻšāϝāĻŧ⧇āϛ⧇, āφāϰ āϕ⧋āύ⧋ output āύ⧇āχ, beep-āĻ“ āύāĻžāĨ¤

Judge, āĻŽāĻžāύ⧇ āϝ⧇ program hidden test āĻĻāĻŋāϝāĻŧ⧇ problem āĻ—ā§āϰ⧇āĻĄ āĻ•āϰ⧇, āϏ⧇-āĻ“ āĻāĻ•āχ āύāĻžāĻŽ āĻĻ⧇āϝāĻŧāĨ¤ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻĒā§āϰāϤāĻŋāϟāĻž test-āĻ 1 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āϏāĻŽāϝāĻŧ āĻĻ⧇āϝāĻŧāĨ¤ Judge āϝāĻ–āύ āĻŦāϞ⧇ Time limit exceeded, āϤāĻ–āύ āφāϗ⧇ āϏāĻ¨ā§āĻĻ⧇āĻš āĻ•āϰ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻž step-āϕ⧇, āϝ⧇āϟāĻž āĻŽāĻŋāĻĨā§āϝāĻžāϰ āĻĻāĻŋāϕ⧇ āĻ•āĻ–āύ⧋ āĻāĻ—ā§‹āϝāĻŧ āύāĻžāĨ¤

Playground Bob-āĻāϰ timer āϚ⧁āĻĒāϚāĻžāĻĒ compile āĻ•āϰ⧇āĨ¤ āύāĻŋāĻœā§‡āϰ āĻŽā§‡āĻļāĻŋāύ⧇ GCC 12-āĻāϰ gcc -Wall āĻŦāϞ⧇ warning: statement with no effect [-Wunused-value]āĨ¤ āĻ āĻŋāĻ• āĻ•āϰāϤ⧇ āϞ⧇āĻ–ā§‹ seconds--;āĨ¤

āϤāĻžāϰ āĻŽāĻžāύ⧇ step-āϕ⧇ āύāĻŋāĻœā§‡āϰ āĻĢāϞ āϜāĻŽāĻž āϰāĻžāĻ–āϤ⧇āχ āĻšāĻŦ⧇āĨ¤ āϝ⧇ āĻšāĻŋāϏāĻžāĻŦ āϕ⧋āĻĨāĻžāĻ“ āϝāĻžāϝāĻŧ āύāĻž, āϏ⧇āϟāĻž step āύāĻžāĨ¤

Sentinel-āĻ āĻĨāĻžāĻŽā§‹: 0 āφāϏāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒāĻĄāĻŧāϤ⧇ āĻĨāĻžāϕ⧋

Maria-āϰ till āĻĻāĻžāĻŽ āĻĒāĻĄāĻŧāϤ⧇ āĻĨāĻžāϕ⧇, āφāϰ āĻā§āĻĄāĻŧāĻŋ āĻ–āĻžāϞāĻŋ āĻšāϞ⧇ cashier 0 āϟāĻžāχāĻĒ āĻ•āϰ⧇āĨ¤ āĻ“āχ 0-āĻāϰ āĻŽāϤ⧋ āĻŽāĻžāύ, āϝ⧇āϟāĻž "data" āύāĻž āĻŦ⧁āĻāĻŋāϝāĻŧ⧇ "āĻĨāĻžāĻŽā§‹" āĻŦā§‹āĻāĻžāϝāĻŧ, āϤāĻžāϕ⧇ āĻŦāϞ⧇ sentinelāĨ¤

#include <stdio.h>

int main(void)
{
    int price = 0;
    int item = 0;

    while (scanf("%d", &price) == 1 && price != 0) {
        item++;
        printf("item %d: %d\n", item, price);
    }
    printf("%d items\n", item);
    return 0;
}
item 1: 120
item 2: 45
item 3: 300
3 items

āĻ“āχ output-āϟāĻž 120 45 300 0 99 input-āĻāϰ āϜāĻ¨ā§āϝāĨ¤ 0-āϟāĻž sentinel, āφāϰ āϤāĻžāϰ āĻĒāϰ⧇āϰ 99 āĻ•āĻ–āύ⧋ āĻĒāĻĄāĻŧāĻžāχ āĻšāϝāĻŧ āύāĻžāĨ¤

Condition-āϟāĻž āĻ•ā§āϰāĻŽā§‡ āĻĻ⧁āχāϟāĻž āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āφāϗ⧇ scanf āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āĻĒāĻĄāĻŧ⧇, āφāϰ 1 āĻĢ⧇āϰāϤ āĻĻāĻŋāϤ⧇ āĻšāϝāĻŧāĨ¤ āϤāĻžāϰāĻĒāϰāχ āĻļ⧁āϧ⧁ price != 0 āϚāϞ⧇, āĻ•āĻžāϰāĻŖ āĻŦāĻžāρ āĻĻāĻŋāĻ• āĻŽāĻŋāĻĨā§āϝāĻž āĻšāϞ⧇ && āĻĄāĻžāύ āĻĻāĻŋāĻ•āϟāĻž āĻŦāĻžāĻĻ āĻĻ⧇āϝāĻŧ (Module 4)āĨ¤

Sentinel-āϟāĻž āĻĒāĻĄāĻŧāĻž āĻšāϝāĻŧ, āĻĒāϰ⧀āĻ•ā§āώāĻžāϝāĻŧ āφāϟāϕ⧇ āϝāĻžāϝāĻŧ, āφāϰ body āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒ⧌āρāĻ›āĻžāϝāĻŧāχ āύāĻžāĨ¤ āĻāϜāĻ¨ā§āϝāχ "3 items" 0-āϟāĻžāϕ⧇ āĻ—ā§‹āύ⧇ āύāĻžāĨ¤

āϤāĻžāχ sentinel loop āĻĨāĻžāĻŽāĻžāϝāĻŧ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻ•āĻ–āύ⧋ data āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāĻœā§‡ āϞāĻžāϗ⧇ āύāĻžāĨ¤ āĻĒāĻĄāĻŧāĻžāϟāĻž āφāϰ sentinel-āĻāϰ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻāĻ•āχ condition-āĻ āϰāĻžāĻ–ā§‹āĨ¤

Input āĻļ⧇āώ āĻšāĻ“āϝāĻŧāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒāĻĄāĻŧā§‹

āĻ…āύ⧇āĻ• judge problem-āĻ āϕ⧋āύ⧋ sentinel āĻĨāĻžāϕ⧇ āύāĻžāĨ¤ āĻ“āϰāĻž āĻŦāϞ⧇ "āϏāĻ‚āĻ–ā§āϝāĻžāϗ⧁āϞ⧋ āφāϏāĻŦ⧇, input-āĻāϰ āĻļ⧇āώ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ", āĻ•āϝāĻŧāϟāĻž āφāϏāĻŦ⧇ āϏ⧇āϟāĻž āĻ•āĻ–āύ⧋ āĻŦāϞ⧇ āύāĻžāĨ¤ āĻāϰ āϜāĻ¨ā§āϝ āϞāĻžāϗ⧇ āϏ⧇āχ pattern, āϝ⧇āϟāĻžāϰ āĻ•āĻĨāĻž Module 3 āĻĻāĻŋāϝāĻŧ⧇ āϰ⧇āϖ⧇āĻ›āĻŋāϞāĨ¤

#include <stdio.h>

int main(void)
{
    int mark = 0;
    int passed = 0;

    while (scanf("%d", &mark) == 1) {
        if (mark >= 40) {
            passed++;
        }
    }
    printf("%d passed\n", passed);
    return 0;
}
3 passed

āĻ“āχ output-āϟāĻž āĻāĻŽāύ input-āĻāϰ āϜāĻ¨ā§āϝ: āĻāĻ• āϞāĻžāχāύ⧇ 72 35 90, āĻĒāϰ⧇āϰ āϞāĻžāχāύ⧇ 40 12āĨ¤ scanf space āφāϰ āύāϤ⧁āύ āϞāĻžāχāύ āĻĻ⧁āχāϟāĻžāχ āĻāĻ•āχāĻ­āĻžāĻŦ⧇ āϟāĻĒāϕ⧇ āϝāĻžāϝāĻŧ, āϤāĻžāχ input āϕ⧀āĻ­āĻžāĻŦ⧇ āϏāĻžāϜāĻžāύ⧋ āϏ⧇āϟāĻž āϕ⧋āύ⧋ āĻŦā§āϝāĻžāĻĒāĻžāϰ āύāĻžāĨ¤

āĻ•āϝāĻŧāϟāĻž āĻŽāĻžāĻ°ā§āĻ• āφāϏāϛ⧇, Alice-āĻāϰ program āϜāĻžāύ⧇ āύāĻžāĨ¤ āĻĒāĻĄāĻŧāĻž āϝāϤāĻ•ā§āώāĻŖ āĻ•āĻžāϜ āĻ•āϰ⧇, āĻ“ āĻĒāĻĄāĻŧāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤ 12-āĻāϰ āĻĒāϰ⧇ scanf āφāϰ āĻ•āĻŋāϛ⧁ āĻĒāĻžāϝāĻŧ āύāĻž, āφāϰ āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ EOF, āĻŽāĻžāύ⧇ -1 (Module 3, lesson 5)āĨ¤ -1 āϤ⧋ 1 āύāĻž, āϤāĻžāχ loop āĻļ⧇āώāĨ¤

Playground-āĻ input-āĻāϰ āĻļ⧇āώ āĻŽāĻžāύ⧇ āϏ⧋āϜāĻž input box-āĻ āϤ⧁āĻŽāĻŋ āϝāĻž āϞāĻŋāϖ⧇āĻ› āϤāĻžāϰ āĻļ⧇āώāĨ¤ Judge-āĻāϰ test file-āĻ“ āĻāĻ•āχāĻ­āĻžāĻŦ⧇ āĻļ⧇āώ āĻšāϝāĻŧāĨ¤ āύāĻŋāĻœā§‡āϰ computer-āĻāϰ terminal-āĻ Linux āφāϰ macOS-āĻ āϚāĻžāĻĒā§‹ Ctrl+D, Windows-āĻ Ctrl+Z āϤāĻžāϰāĻĒāϰ EnterāĨ¤

Input box āĻĢāĻžāρāĻ•āĻž āĻĨāĻžāĻ•āϞ⧇ body āĻāĻ•āĻŦāĻžāϰāĻ“ āϚāϞ⧇ āύāĻž, āφāϰ program āĻ›āĻžāĻĒ⧇ 0 passedāĨ¤ āϕ⧋āύ⧋ āĻŽāĻžāĻ°ā§āĻ• āύāĻž āĻĨāĻžāĻ•āϞ⧇ āĻ āĻŋāĻ• āωāĻ¤ā§āϤāϰ āĻāϟāĻžāχāĨ¤

āϤāĻžāχ while (scanf("%d", &x) == 1) āĻŽāĻžāύ⧇ "āϝāϤāϗ⧁āϞ⧋ āϏāĻ‚āĻ–ā§āϝāĻž āφāϛ⧇, āĻĒā§āϰāϤāĻŋāϟāĻžāϰ āϜāĻ¨ā§āϝ"āĨ¤ āϏāĻ‚āĻ–ā§āϝāĻž āύāĻž āĻāĻŽāύ āĻĒā§āϰāĻĨāĻŽ āϜāĻŋāύāĻŋāϏāϟāĻž āĻĒ⧇āϞ⧇āĻ“ āĻāϟāĻž āĻĨāĻžāĻŽā§‡āĨ¤

āĻāĻ–āύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏ⧇āϰāĻžāϟāĻž āϰāĻžāĻ–ā§‹, āĻļ⧁āϰ⧁ āĻĒā§āϰāĻĨāĻŽ āĻŽāĻžāύ āĻĨ⧇āϕ⧇

Zara āĻĒā§āϰāϤāĻŋāĻĻāĻŋāύ āϏāĻ•āĻžāϞ⧇ āϤāĻžāĻĒāĻŽāĻžāĻ¤ā§āϰāĻž āϞāĻŋāϖ⧇ āϰāĻžāϖ⧇, āφāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ āĻžāĻ¨ā§āĻĄāĻžāϟāĻž āϜāĻžāύāϤ⧇ āϚāĻžāϝāĻŧāĨ¤ āĻāĻ•āϟāĻž loop āĻāĻ–āύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏ⧇āϰāĻž āωāĻ¤ā§āϤāϰāϟāĻž āĻāĻ•āϟāĻž variable-āĻ āϰāĻžāĻ–āϤ⧇ āĻĒāĻžāϰ⧇, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻ āĻĻāϰāĻ•āĻžāϰ āĻšāϞ⧇ āϏ⧇āϟāĻž āĻŦāĻĻāϞāĻžāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āĻ“āϰ input āĻļ⧁āϰ⧁ āĻšāϝāĻŧ āĻĻāĻŋāύ⧇āϰ āϏāĻ‚āĻ–ā§āϝāĻž āĻĻāĻŋāϝāĻŧ⧇āĨ¤ āĻĒā§āϰāĻĨāĻŽ āĻŽāĻžāĻĒāϟāĻžāχ āĻšāϝāĻŧ āĻāĻ–āύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ āĻžāĻ¨ā§āĻĄāĻž, āĻ•āĻžāϰāĻŖ āĻ“āχ āĻŽā§āĻšā§‚āĻ°ā§āϤ⧇ āĻ“āϟāĻžāχ āĻāĻ•āĻŽāĻžāĻ¤ā§āϰ āĻŽāĻžāĻĒāĨ¤

#include <stdio.h>

int main(void)
{
    int days = 0;
    int t = 0;
    int coldest = 0;
    int day = 1;

    scanf("%d", &days);
    scanf("%d", &t);
    coldest = t;
    while (day < days) {
        scanf("%d", &t);
        if (t < coldest) {
            coldest = t;
        }
        day++;
    }
    printf("coldest: %d\n", coldest);
    return 0;
}
coldest: 12

āĻ“āχ output-āϟāĻž āĻāĻŽāύ input-āĻāϰ āϜāĻ¨ā§āϝ: 4, āϤāĻžāϰāĻĒāϰ 18 12 25 14āĨ¤ āĻāĻ–āĻžāύ⧇ day āĻ—ā§‹āύ⧇ āĻ•āϝāĻŧāϟāĻž āĻŽāĻžāĻĒ āύ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧ⧇ āϗ⧇āϛ⧇, āφāϰ āĻ…āĻ¨ā§āϤāϤ āĻāĻ•āϟāĻž āĻĻāĻŋāύ āϏāĻŦ āϏāĻŽāϝāĻŧ āĻĨāĻžāϕ⧇āĨ¤

PassāĻĒāϰ⧀āĻ•ā§āώāĻžāϰ āϏāĻŽāϝāĻŧ dayday < daysāĻĒāĻĄāĻŧāĻž tpass-āĻāϰ āĻĒāϰ⧇ coldest
loop-āĻāϰ āφāϗ⧇1āĻāĻ–āύ⧋ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻšāϝāĻŧāύāĻŋ1818
11āϏāĻ¤ā§āϝ1212
22āϏāĻ¤ā§āϝ2512
33āϏāĻ¤ā§āϝ1412
āύ⧇āχ, āĻļ⧁āϧ⧁ āĻĒāϰ⧀āĻ•ā§āώāĻž4āĻŽāĻŋāĻĨā§āϝāĻžāĻ•āĻŋāϛ⧁ āύāĻž12

coldest-āϕ⧇ 0 āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰāϞ⧇ āϕ⧀ āĻšāϤ⧋? āĻļā§‚āĻ¨ā§āϝ⧇āϰ āωāĻĒāϰ⧇āϰ āϕ⧋āύ⧋ āϏāĻ•āĻžāϞ āĻ“āϕ⧇ āĻšāĻžāϰāĻžāϤ⧇ āĻĒāĻžāϰāϤ āύāĻž, āφāϰ āĻāχ input-āĻ āĻ›āĻžāĻĒāĻž āĻšāϤ⧋ 0, āϝ⧇ āϤāĻžāĻĒāĻŽāĻžāĻ¤ā§āϰāĻž āϕ⧇āω āĻŽāĻžāĻĒ⧇āχāύāĻŋāĨ¤

āϤāĻžāχ āĻāĻ–āύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏ⧇āϰāĻž āϰāĻžāĻ–āĻžāϰ variable āĻļ⧁āϰ⧁ āĻšāϝāĻŧ āĻāĻ•āϟāĻž āφāϏāϞ āĻŽāĻžāύ āĻĨ⧇āϕ⧇, āĻĒā§āϰāĻĨāĻŽ āĻĒāĻĄāĻŧāĻž āĻŽāĻžāύāϟāĻž āĻĨ⧇āϕ⧇āĨ¤ āϤāĻžāĻšāϞ⧇ āωāĻ¤ā§āϤāϰ āϏāĻŦ āϏāĻŽāϝāĻŧ input-āϗ⧁āϞ⧋āϰāχ āĻāĻ•āϟāĻžāĨ¤

āĻĒā§āϰāϤāĻŋāϟāĻž loop body-āϤ⧇ brace

Module 5 āĻĒā§āϰāϤāĻŋāϟāĻž if body-āϤ⧇ brace āĻĻāĻŋāϝāĻŧ⧇āĻ›āĻŋāϞ, loop-āĻ“ āĻāĻ•āχ āύāĻŋāϝāĻŧāĻŽ āĻŽāĻžāύ⧇āĨ¤ Brace āĻ›āĻžāĻĄāĻŧāĻž āĻāĻ•āϟāĻž while-āĻāϰ āĻ­āĻžāϗ⧇ āĻĒāĻĄāĻŧ⧇ āĻ āĻŋāĻ• āĻāĻ•āϟāĻž statementāĨ¤

#include <stdio.h>

int main(void)
{
    int n = 3;

    while (n > 0)
        printf("%d\n", n);
        n--;
    return 0;
}

Compiler loop-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āĻāĻ•āϟāĻžāχ āϞāĻžāχāύ āĻĻ⧇āϖ⧇, printf, āϤāĻžāχ program āĻŦāĻžāϰāĻŦāĻžāϰ 3 āĻ›āĻžāĻĒāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤ Playground āϚ⧁āĻĒāĨ¤ āύāĻŋāĻœā§‡āϰ āĻŽā§‡āĻļāĻŋāύ⧇āϰ gcc -Wall āĻŦāϞ⧇ warning: this 'while' clause does not guard... [-Wmisleading-indentation]āĨ¤

āϤāĻžāχ āĻāχ track-āĻ āĻĒā§āϰāϤāĻŋāϟāĻž loop body-āϤ⧇ brace āĻĨāĻžāϕ⧇, āĻāĻ• āϞāĻžāχāύ⧇āϰ body-āϤ⧇āĻ“āĨ¤ Body āϕ⧋āĻĨāĻžāϝāĻŧ āĻļ⧇āώ, C-āϕ⧇ āϏ⧇āϟāĻž āĻŦāϞ⧇ brace, space āύāĻžāĨ¤

Example 1: āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ loop, āϝāĻžāϰ step 1 āύāĻž

āĻŽāĻŋāĻĨā§āϝāĻžāϰ āĻĻāĻŋāϕ⧇ āĻāĻ—ā§‹āϝāĻŧ āĻāĻŽāύ āϝ⧇āϕ⧋āύ⧋ āĻŦāĻĻāϞāχ step āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāĻ–āĻžāύ⧇ āĻ“āϟāĻž āĻĻā§āĻŦāĻŋāϗ⧁āĻŖ āĻ•āϰ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    int p = 1;

    while (p < 100) {
        printf("%d\n", p);
        p = p * 2;
    }
    return 0;
}
1
2
4
8
16
32
64

64-āĻāϰ āĻĒāϰ⧇ step p-āϕ⧇ 128 āĻŦāĻžāύāĻžāϝāĻŧ, āφāϰ 128 < 100 āĻŽāĻŋāĻĨā§āϝāĻžāĨ¤ Loop āϚāϞāϞ 7āϟāĻž pass, āĻ…āĻĨāϚ āĻāχ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž program-āĻ āϕ⧇āω āϞ⧇āϖ⧇āύāĻŋāĨ¤

Run in Compiler
Example 2: āϞāĻ•ā§āĻˇā§āϝ⧇ āĻĒ⧌āρāĻ›āĻžāϤ⧇ āĻ•āϤ āϏāĻĒā§āϤāĻžāĻš

Kenji āĻĒā§āϰāϤāĻŋ āϏāĻĒā§āϤāĻžāĻšā§‡ āĻāĻ•āχ āĻĒāϰāĻŋāĻŽāĻžāĻŖ āϟāĻžāĻ•āĻž āϜāĻŽāĻžāϝāĻŧāĨ¤ āĻ•āϤ āϏāĻĒā§āϤāĻžāĻš āϞāĻžāĻ—āĻŦ⧇, āφāϗ⧇ āĻĨ⧇āϕ⧇ āϕ⧇āω āϜāĻžāύ⧇ āύāĻž, āφāϰ while āĻ āĻŋāĻ• āĻāĻŽāύ āϜāĻžāϝāĻŧāĻ—āĻžāϤ⧇āχ āĻŽāĻžāύāĻžāϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    int goal = 0;
    int weekly = 0;
    int saved = 0;
    int weeks = 0;

    scanf("%d %d", &goal, &weekly);
    while (saved < goal) {
        saved = saved + weekly;
        weeks++;
    }
    printf("%d weeks, %d saved\n", weeks, saved);
    return 0;
}
7 weeks, 1050 saved

āĻ“āχ output-āϟāĻž 1000 150 input-āĻāϰ āϜāĻ¨ā§āϝāĨ¤ āĻ›āϝāĻŧ āϏāĻĒā§āϤāĻžāĻšā§‡ āĻšāϝāĻŧ 900, āϏ⧇āϟāĻž āĻ•āĻŽ, āϤāĻžāχ āϏāĻĒā§āϤāĻŽ pass āϚāϞ⧇āĨ¤ āϞāĻ•ā§āĻˇā§āϝ 0 āĻšāϞ⧇ āφāϏ⧇ 0 weeks, 0 saved: āĻāĻ•āϟāĻžāĻ“ pass āύāĻžāĨ¤

Step-āϟāĻžāĻ“ āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–ā§‹: āϏāĻžāĻĒā§āϤāĻžāĻšāĻŋāĻ• āϜāĻŽāĻž 0 āĻšāϞ⧇ āĻ•āĻŋāϛ⧁āχ āϝ⧋āĻ— āĻšāϝāĻŧ āύāĻž, āφāϰ loop āĻ•āĻ–āύ⧋ āĻļ⧇āώ āĻšāϝāĻŧ āύāĻžāĨ¤

Run in Compiler
Example 3: āύāϤ⧁āύ āĻļāĻŋāĻ–āϛ⧇ āĻāĻŽāύ āϕ⧇āω āφāϏāϞ⧇ āϝ⧇ loop āϞ⧇āϖ⧇

āϝāϤāϗ⧁āϞ⧋ āϏāĻ‚āĻ–ā§āϝāĻž āφāϛ⧇ āϏāĻŦ āĻĒāĻĄāĻŧā§‹, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻžāϕ⧇ āĻāĻ•āϟāĻž āĻ—āĻŖāύāĻžāϝāĻŧ āĻĢ⧇āϞ⧋āĨ¤ āĻĒā§āϰāĻĨāĻŽ āĻĻāĻŋāϕ⧇āϰ āĻ…āύ⧇āĻ• judge problem āĻĻ⧇āĻ–āϤ⧇ āĻ āĻŋāĻ• āĻāϰāĻ•āĻŽāĨ¤

#include <stdio.h>

int main(void)
{
    int x = 0;
    int even = 0;
    int odd = 0;

    while (scanf("%d", &x) == 1) {
        if (x % 2 == 0) {
            even++;
        } else {
            odd++;
        }
    }
    printf("even %d\n", even);
    printf("odd %d\n", odd);
    return 0;
}
even 3
odd 2

āĻ“āχ output-āϟāĻž 4 -7 10 3 0 input-āĻāϰ āϜāĻ¨ā§āϝāĨ¤ -7 āĻŦāĻŋāĻœā§‹āĻĄāĻŧ, āĻ•āĻžāϰāĻŖ āĻ“āϰ āĻ­āĻžāĻ—āĻļ⧇āώ -1, āφāϰ āϏ⧇āϟāĻž 0 āύāĻž (Module 4)āĨ¤ āĻāĻ–āĻžāύ⧇ 0 āϏāĻžāϧāĻžāϰāĻŖ data, sentinel āύāĻžāĨ¤

Run in Compiler

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

  • File āĻ—ā§‹āύāĻžāĨ¤ GNU coreutils-āĻāϰ wc āĻāĻ•āϟāĻž loop-āĻ input āĻāĻ•āĻŦāĻžāϰ⧇ āĻāĻ• āϟ⧁āĻ•āϰāĻž āĻ•āϰ⧇ āĻĒāĻĄāĻŧ⧇, āϝāϤāĻ•ā§āώāĻŖ āύāĻž āĻāĻ•āϟāĻž āĻĒāĻĄāĻŧāĻž āĻ•āĻŋāϛ⧁āχ āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ: āĻ“āϟāĻžāχ file-āĻāϰ āĻļ⧇āώāĨ¤
  • Online judgeāĨ¤ UVa-āϰ problem 100, "The 3n + 1 problem", file-āĻāϰ āĻļ⧇āώ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻœā§‹āĻĄāĻŧāĻž āĻĻ⧇āϝāĻŧāĨ¤ āϏāĻžāϧāĻžāϰāĻŖ C āϏāĻŽāĻžāϧāĻžāύ āĻ“āϗ⧁āϞ⧋ āĻĒāĻĄāĻŧ⧇ while (scanf(...) == 2) āĻĻāĻŋāϝāĻŧ⧇āĨ¤
  • Game loopāĨ¤ id Software 1997-āĻ Doom-āĻāϰ source code āĻĒā§āϰāĻ•āĻžāĻļ āĻ•āϰ⧇āĨ¤ Game-āϟāĻž āϚāϞ⧇ D_DoomLoop-āĻāϰ āĻ­āĻŋāϤāϰ⧇āĨ¤ āĻ“āχ while (1) loop āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻ input āĻĒāĻĄāĻŧ⧇ āφāϰ āĻāĻ•āϟāĻž frame āφāρāϕ⧇āĨ¤
  • ServerāĨ¤ Redis āĻ“āϰ event loop āϚāĻžāϞāĻžāϝāĻŧ aeMain-āĻ, while (!eventLoop->stop) āĻšāĻŋāϏ⧇āĻŦ⧇, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻ āϤ⧈āϰāĻŋ āĻšāϝāĻŧ⧇ āĻĨāĻžāĻ•āĻž connection-āϗ⧁āϞ⧋ āϏāĻžāĻŽāϞāĻžāϝāĻŧāĨ¤

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

ā§§. == 1 āĻ›āĻžāĻĄāĻŧāĻž scanf āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰāĻžāĨ¤

while (scanf("%d", &x)) {
    printf("%d\n", x);
}

āϕ⧋āύ⧋ command line-āĻāχ āĻŦāĻžāĻ°ā§āϤāĻž āύ⧇āχāĨ¤ Input āĻļ⧇āώ āĻšāϞ⧇ scanf āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ -1, āϝ⧇āϟāĻž āĻļā§‚āĻ¨ā§āϝ āύāĻž, āϤāĻžāχ āĻĒāϰ⧀āĻ•ā§āώāĻž āϏāĻ¤ā§āϝāĨ¤ 7 9 āĻĻāĻŋāϞ⧇ āĻāϟāĻž 7 āĻ›āĻžāĻĒ⧇, āϤāĻžāϰāĻĒāϰ āϚāĻŋāϰāĻ•āĻžāϞ 9āĨ¤ 1-āĻāϰ āϏāĻžāĻĨ⧇ āĻŽā§‡āϞāĻžāĻ“āĨ¤ āĻāϟāĻž āϤ⧁āĻŽāĻŋ āϞāĻŋāĻ–āĻŦ⧇, āĻ•āĻžāϰāĻŖ while (scanf(...)) āĻĒāĻĄāĻŧāϤ⧇ āχāĻ‚āϰ⧇āϜāĻŋ āĻŦāĻžāĻ•ā§āϝ⧇āϰ āĻŽāϤ⧋ āϞāĻžāϗ⧇āĨ¤

⧍. āϝ⧇ sentinel loop scanf-āĻāϰ āĻĢ⧇āϰāϤ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻŽāĻžāύ āĻĻ⧇āϖ⧇ āύāĻžāĨ¤

scanf("%d", &price);
while (price != 0) {
    printf("item: %d\n", price);
    scanf("%d", &price);
}

āϕ⧋āύ⧋ command line-āĻāχ āĻŦāĻžāĻ°ā§āϤāĻž āύ⧇āχāĨ¤ 0 āφāϏāĻžāϰ āφāϗ⧇āχ input āĻļ⧇āώ āĻšāϞ⧇ āĻŦā§āϝāĻ°ā§āĻĨ āĻĒāĻĄāĻŧāĻžāϟāĻž price-āϕ⧇ āϝ⧇āĻŽāύ āĻ›āĻŋāϞ āϤ⧇āĻŽāύāχ āϰ⧇āϖ⧇ āĻĻ⧇āϝāĻŧ (Module 3)āĨ¤ 120 45 āĻĻāĻŋāϞ⧇ āĻāϟāĻž āϚāĻŋāϰāĻ•āĻžāϞ item: 45 āĻ›āĻžāĻĒ⧇āĨ¤ āĻĒāĻĄāĻŧāĻžāϟāĻž condition-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āύāĻžāĻ“āĨ¤ āĻĒā§āϰāĻĨāĻŽā§‡ āĻāϟāĻžāχ āϞāĻŋāĻ–āĻŦ⧇, āĻ•āĻžāϰāĻŖ āĻ•āĻžāϜāϟāĻž āĻŽā§āϖ⧇ āĻŦāϞāϞ⧇ āĻāĻŽāύāχ āĻļā§‹āύāĻžāϝāĻŧāĨ¤

ā§Š. while-āĻāϰ āĻĒāϰ⧇ āĻāĻ•āϟāĻž semicolonāĨ¤

while (n > 0);
{
    printf("%d\n", n);
    n--;
}

Playground-āĻ āύ⧀āϰāĻŦāĨ¤ āύāĻŋāĻœā§‡āϰ āĻŽā§‡āĻļāĻŋāύ⧇āϰ gcc -Wall āωāĻĒāϰ⧇āϰ āϏ⧇āχ -Wmisleading-indentation warning-āϟāĻžāχ āĻĻ⧇āϝāĻŧāĨ¤ Semicolon-āϟāĻžāχ āĻāĻ•āϟāĻž āĻĢāĻžāρāĻ•āĻž body, āϤāĻžāχ āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž āϚāĻŋāϰāĻ•āĻžāϞ āϚāϞāϤ⧇ āĻĨāĻžāϕ⧇, āφāϰ brace āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻ•āĻ–āύ⧋ āĻĒ⧌āρāĻ›āĻžāϝāĻŧ āύāĻžāĨ¤ āĻ“āϟāĻž āĻŽā§āϛ⧇ āĻĻāĻžāĻ“āĨ¤

ā§Ē. āĻāĻ–āύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏ⧇āϰāĻžāϟāĻž āĻļ⧁āϰ⧁ āĻšāϝāĻŧ 0 āĻĨ⧇āϕ⧇āĨ¤

int coldest = 0;
while (day < days) {
    scanf("%d", &t);
    if (t < coldest) {
        coldest = t;
    }
    day++;
}

āϕ⧋āύ⧋ command line-āĻāχ āĻŦāĻžāĻ°ā§āϤāĻž āύ⧇āχāĨ¤ 18 12 25 14 āĻĻāĻŋāϞ⧇ āĻāϟāĻž āĻ›āĻžāĻĒ⧇ coldest: 0āĨ¤ āĻĒā§āϰāĻĨāĻŽ āĻĒāĻĄāĻŧāĻž āĻŽāĻžāύ āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧋āĨ¤ 0 āϞāĻŋāĻ–āĻŦ⧇, āĻ•āĻžāϰāĻŖ counter āϤ⧋ 0 āĻĨ⧇āϕ⧇āχ āĻļ⧁āϰ⧁ āĻšāϝāĻŧ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϏ⧇āϰāĻž āĻŽāĻžāύ āϧāϰ⧇ āϰāĻžāĻ–āĻž variable counter āύāĻžāĨ¤

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

Bob āĻāϟāĻž āĻāĻ•āϟāĻž forum-āĻ āĻĒ⧇āϝāĻŧ⧇āϛ⧇, āϝ⧇āĻ–āĻžāύ⧇ āϕ⧇āω -->-āϕ⧇ āĻŦāϞ⧇āϛ⧇ "goes to" operatorāĨ¤

#include <stdio.h>

int main(void)
{
    int n = 3;

    while (n --> 0) {
        printf("%d\n", n);
    }
    printf("after the loop, n is %d\n", n);
    return 0;
}

āϕ⧋āύ⧋ āĻŦāĻžāĻ°ā§āϤāĻž āĻ›āĻžāĻĄāĻŧāĻžāχ āĻāϟāĻž compile āĻšāϝāĻŧāĨ¤ āĻāϟāĻž āϕ⧀ āĻ›āĻžāĻĒ⧇, āφāϰ --> āφāϏāϞ⧇ āϕ⧀? āĻ•āĻ āĻŋāύ āĻ…āĻ°ā§āϧ⧇āĻ•āϟāĻž: loop-āĻāϰ āĻĒāϰ⧇ n āϕ⧇āύ 0 āύāĻž?

Space-āϟāĻž āĻ…āĻ¨ā§āϝ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻŦāϏāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–ā§‹āĨ¤ āϤāĻžāϰāĻĒāϰ table āĻĻāĻŋāϝāĻŧ⧇ trace āĻ•āϰ⧋, āφāϰ āĻŽāύ⧇ āĻ•āϰ⧋ n-- āĻ•āĻ–āύ āύāĻŋāĻœā§‡āϰ āĻŽāĻžāύ āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ (Module 4)āĨ¤

āĻ…āύ⧁āĻļā§€āϞāύ ā§§āϏāĻšāϜ

Bob-āĻāϰ rocket game-āĻ player āϝ⧇ āϏāĻ‚āĻ–ā§āϝāĻž āĻŦāĻžāϛ⧇, āϏ⧇āĻ–āĻžāύ āĻĨ⧇āϕ⧇ countdown āĻšāϝāĻŧāĨ¤ āĻāĻŦāĻžāϰ āĻ“āϰ countdown āϏāĻ¤ā§āϝāĻŋ āϏāĻ¤ā§āϝāĻŋ āĻ āĻŋāĻ• āĻ•āϰ⧇ āĻĻāĻžāĻ“āĨ¤

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

Output. n āĻĨ⧇āϕ⧇ 1 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻ‚āĻ–ā§āϝāĻžāϗ⧁āϞ⧋, āĻĒā§āϰāϤāĻŋ āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻžāĨ¤

Constraints. 1 <= n <= 1000āĨ¤

Sample. Input 3 āĻĻāĻŋāϞ⧇ āϤāĻŋāύ āϞāĻžāχāύ⧇ 3, 2 āφāϰ 1āĨ¤

#include <stdio.h>

int main(void)
{
    int n = 0;
    scanf("%d", &n);

    /* Start, condition, step: one loop, one number per line. */

    return 0;
}

āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧ āύāĻžāĨ¤ Problem lesson-āĻāϰ largest-input āĻāĻ•āϟāĻž while loop āĻ—ā§āϰ⧇āĻĄ āĻ•āϰ⧇, āϝ⧇āĻ–āĻžāύ⧇ āĻ•āĻ āĻŋāύ edge case āφāϛ⧇āĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ⧍āϏāĻšāϜ

Maria-āϰ till-āĻāϰ āĻāĻŦāĻžāϰ āĻŦāĻŋāϞ āϞāĻžāĻ—āĻŦ⧇āĨ¤ Cashier āĻĻāĻžāĻŽāϗ⧁āϞ⧋ āϟāĻžāχāĻĒ āĻ•āϰ⧇, āφāϰ āĻā§āĻĄāĻŧāĻŋ āĻ–āĻžāϞāĻŋ āĻšāϞ⧇ 0āĨ¤

Input. Space āĻŦāĻž āύāϤ⧁āύ āϞāĻžāχāύ āĻĻāĻŋāϝāĻŧ⧇ āφāϞāĻžāĻĻāĻž āĻ•āϰāĻž positive āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž, āϤāĻžāϰāĻĒāϰ āĻāĻ•āϟāĻž 0āĨ¤ 0-āĻāϰ āĻĒāϰ⧇ āϝāĻž āĻĨāĻžāϕ⧇, āϏ⧇āϟāĻž āĻŦāĻžāĻĻāĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ 0-āĻāϰ āφāϗ⧇āϰ āĻĻāĻžāĻŽāϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞāĨ¤

Constraints. āϏāĻ°ā§āĻŦā§‹āĻšā§āϚ 1000āϟāĻž āĻĻāĻžāĻŽ, āĻĒā§āϰāϤāĻŋāϟāĻž 1 āĻĨ⧇āϕ⧇ 1000000, āϤāĻžāχ āϝ⧋āĻ—āĻĢāϞ āĻāĻ•āϟāĻž int-āĻ āĻāρāĻŸā§‡ āϝāĻžāϝāĻŧāĨ¤

Sample. Input 120 45 300 0 āĻĻāĻŋāϞ⧇ 465āĨ¤ Input 0 āĻĻāĻŋāϞ⧇ 0āĨ¤

#include <stdio.h>

int main(void)
{
    int price = 0;
    int total = 0;

    while (scanf("%d", &price) == 1 && price != 0) {
        /* Add this price to the total. */
    }

    /* Print the total. */

    return 0;
}

āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧ āύāĻžāĨ¤ āĻāϰ āĻāĻ•āĻŽāĻžāĻ¤ā§āϰ āĻĢāĻžāρāĻĻ, 0-āϟāĻž āϝ⧋āĻ—āĻĢāϞ⧇ āĻĸ⧁āϕ⧇ āĻĒāĻĄāĻŧāĻž, sample āϚāĻžāϞāĻžāϞ⧇āχ āϧāϰāĻž āĻĒāĻĄāĻŧ⧇āĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ā§ŠāĻŽāĻžāĻāĻžāϰāĻŋ

David-āĻāϰ āφāĻŦāĻšāĻžāĻ“āϝāĻŧāĻžāϰ sensor āĻāĻ•āϟāĻž log-āĻ āĻŽāĻžāĻĒ āϞāĻŋāϖ⧇ āϰāĻžāϖ⧇āĨ¤ Log-āĻ āĻ•āϝāĻŧāϟāĻž āĻŽāĻžāĻĒ āφāϛ⧇, āĻ“ āϜāĻžāύāϤ⧇ āϚāĻžāϝāĻŧāĨ¤

Input. Space āĻŦāĻž āύāϤ⧁āύ āϞāĻžāχāύ āĻĻāĻŋāϝāĻŧ⧇ āφāϞāĻžāĻĻāĻž āĻ•āϰāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž, input-āĻāϰ āĻļ⧇āώ āĻĒāĻ°ā§āϝāĻ¨ā§āϤāĨ¤ āĻāĻ•āϟāĻžāĻ“ āύāĻž āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ āĻ•āϝāĻŧāϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž āĻĒāĻĄāĻŧāĻž āĻšāϞ⧋āĨ¤

Constraints. āϏāĻ°ā§āĻŦā§‹āĻšā§āϚ 100000āϟāĻž āĻŽāĻžāύ, āĻĒā§āϰāϤāĻŋāϟāĻž -1000000000 āĻĨ⧇āϕ⧇ 1000000000āĨ¤

Sample. āĻāĻ• āϞāĻžāχāύ⧇ 5 -2 7 āφāϰ āĻĒāϰ⧇āϰ āϞāĻžāχāύ⧇ 0 3 āĻĻāĻŋāϞ⧇ 5āĨ¤ āĻĢāĻžāρāĻ•āĻž input āĻĻāĻŋāϞ⧇ 0āĨ¤

#include <stdio.h>

int main(void)
{
    int x = 0;
    int count = 0;

    while (scanf("%d", &x) == 1) {
        /* One more reading. */
    }

    /* Print the count. An empty log must still print a number. */

    return 0;
}

āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧ āύāĻžāĨ¤ āĻ—ā§āϰ⧇āĻĄ āĻšāĻ“āϝāĻŧāĻž largest-input-āϕ⧇āĻ“ āĻāĻ•āχāĻ­āĻžāĻŦ⧇ āĻĢāĻžāρāĻ•āĻž input āϚāĻŋāύāϤ⧇ āĻšāϝāĻŧ, āφāϰ āϏ⧇āĻ–āĻžāύ⧇ āĻ›āĻžāĻĒāĻžāϰ āωāĻ¤ā§āϤāϰāϟāĻž āφāϰāĻ“ āĻ•āĻ āĻŋāύāĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ā§ĒāĻ•āĻ āĻŋāύ

Zara scoreboard-āĻ score-āĻāϰ āĻāĻ•āϟāĻž āϤāĻžāϞāĻŋāĻ•āĻž āĻĻ⧇āϝāĻŧ, āφāϰ āϏ⧇āϰāĻžāϟāĻž āϜāĻžāύāϤ⧇ āϚāĻžāϝāĻŧāĨ¤ Score negative āĻšāϤ⧇ āĻĒāĻžāϰ⧇, āφāϰ āϕ⧋āύ⧋ āϕ⧋āύ⧋ āϖ⧇āϞāĻžāϝāĻŧ āĻāĻ•āϟāĻžāĻ“ score āĻĨāĻžāϕ⧇ āύāĻžāĨ¤

Input. Input-āĻāϰ āĻļ⧇āώ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž, āĻšāϝāĻŧāϤ⧋ āĻāĻ•āϟāĻžāĻ“ āύāĻžāĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧāϟāĻž, āφāϰ āϕ⧋āύ⧋ āϏāĻ‚āĻ–ā§āϝāĻž āύāĻž āĻĨāĻžāĻ•āϞ⧇ emptyāĨ¤

Constraints. āϏāĻ°ā§āĻŦā§‹āĻšā§āϚ 100000āϟāĻž āĻŽāĻžāύ, āĻĒā§āϰāϤāĻŋāϟāĻž -1000000000 āĻĨ⧇āϕ⧇ 1000000000āĨ¤

Sample. Input 3 -8 12 12 5 āĻĻāĻŋāϞ⧇ 12āĨ¤

#include <stdio.h>

int main(void)
{
    int x = 0;

    while (scanf("%d", &x) == 1) {
        /* Keep the best score so far. What is it before any score arrives? */
    }

    /* Print the best score, or empty if nothing was read. */

    return 0;
}

largest-input āύāĻžāĻŽā§‡ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧāĨ¤ Hidden test-āĻ āφāϛ⧇ āĻļ⧁āϧ⧁ negative score-āĻāϰ āĻāĻ•āϟāĻž āϤāĻžāϞāĻŋāĻ•āĻž, āφāϰ āĻāĻ•āĻĻāĻŽ āĻĢāĻžāρāĻ•āĻž āĻāĻ•āϟāĻž inputāĨ¤

Run in Compiler

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

  • āĻ•āĻ–āύ while āύ⧇āĻŦ, āφāϰ āĻ•āĻ–āύ for?

    āĻ•āϝāĻŧāϟāĻž pass āϞāĻžāĻ—āĻŦ⧇ āφāϗ⧇ āĻĨ⧇āϕ⧇ āϜāĻžāύāĻž āύāĻž āϗ⧇āϞ⧇ while āύāĻžāĻ“, āϝ⧇āĻŽāύ input āĻĒāĻĄāĻŧāĻž āĻŦāĻž āϟāĻžāĻ•āĻž āϜāĻŽāĻžāύ⧋āϰ āϞāĻ•ā§āĻˇā§āϝāĨ¤ āĻ—ā§‹āύāĻžāϰ āĻ•āĻžāĻœā§‡ āĻĒāϰ⧇āϰ lesson-āĻāϰ for āĻŽāĻžāύāĻžāϝāĻŧ āĻŦ⧇āĻļāĻŋāĨ¤ āĻāĻ•āϟāĻž āĻĻāĻŋāϝāĻŧ⧇ āφāϰ⧇āĻ•āϟāĻžāϰ āĻ•āĻžāϜ āĻ•āϰāĻžāχ āϝāĻžāϝāĻŧ; āϝ⧇āϟāĻž āĻĒāĻĄāĻŧāϤ⧇ āĻŦ⧇āĻļāĻŋ āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ, āϏ⧇āϟāĻž āύāĻžāĻ“āĨ¤

  • while (1) āĻ•āĻŋ āϏāĻŦ āϏāĻŽāϝāĻŧāχ bug?

    āύāĻžāĨ¤ Doom-āĻāϰ game loop āχāĻšā§āĻ›āĻž āĻ•āϰ⧇āχ āĻāĻ­āĻžāĻŦ⧇ āϞ⧇āĻ–āĻžāĨ¤ āĻāĻŽāύ loop āĻ­āĻŋāϤāϰ āĻĨ⧇āϕ⧇ āĻŦ⧇āϰ āĻšāϝāĻŧ break āĻĻāĻŋāϝāĻŧ⧇, āϝ⧇āϟāĻž lesson 4-āĻ āφāϛ⧇āĨ¤ āϤāĻŦ⧇ āφāϜ āϤ⧋āĻŽāĻžāϰ program-āĻ āĻāϟāĻž āĻĒā§āϰāĻžāϝāĻŧ āϏāĻŦ āϏāĻŽāϝāĻŧāχ bugāĨ¤

  • Program āĻĨāĻžāĻŽāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϞ⧋, āφāϰ loop-āĻāϰ āφāϗ⧇ āϝ⧇ āϞāĻžāχāύāϟāĻž āϛ⧇āĻĒ⧇āĻ›āĻŋāϞ āϏ⧇āϟāĻžāĻ“ āύ⧇āχāĨ¤ āϕ⧇āύ?

    printf output āĻāĻ•āϟāĻž buffer-āĻ āϜāĻŽāĻžāϝāĻŧ, āϤāĻžāϰāĻĒāϰ āϟ⧁āĻ•āϰāĻž āϟ⧁āĻ•āϰāĻž āĻ•āϰ⧇ āĻĒāĻžāĻ āĻžāϝāĻŧāĨ¤ Playground āĻŦāĻž judge-āĻ output āϝāĻžāϝāĻŧ āĻāĻ•āϟāĻž file-āĻāĨ¤ āĻ“āĻ–āĻžāύ⧇ program āĻĨāĻžāĻŽāĻŋāϝāĻŧ⧇ āĻĻāĻŋāϞ⧇ buffer-āĻ āϝāĻž āĻ…āĻĒ⧇āĻ•ā§āώāĻžāϝāĻŧ āĻ›āĻŋāϞ, āϏ⧇āϟāĻž āφāϰ āĻ•āĻ–āύ⧋ āϝāĻžāϝāĻŧ āύāĻžāĨ¤

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

  • while āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āφāϗ⧇ condition āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰ⧇, āφāϰ āĻĒā§āϰāĻĨāĻŽ āĻĒāϰ⧀āĻ•ā§āώāĻžāχ āĻŽāĻŋāĻĨā§āϝāĻž āĻšāϞ⧇ āĻāĻ•āϟāĻžāĻ“ pass āϚāϞ⧇ āύāĻžāĨ¤
  • Trace table-āĻ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āϜāĻ¨ā§āϝ āĻāĻ• āϏāĻžāϰāĻŋ, āφāϰ āĻļ⧇āώ⧇ āĻāĻ•āϟāĻž āϏāĻžāϰāĻŋ āϝ⧇āĻ–āĻžāύ⧇ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻŽāĻŋāĻĨā§āϝāĻž āĻšāϝāĻŧāĨ¤
  • āĻĒā§āϰāϤāĻŋāϟāĻž loop-āĻāϰ āϞāĻžāϗ⧇ āĻļ⧁āϰ⧁, condition āφāϰ step; āφāϏāϞ step āύāĻž āĻĨāĻžāĻ•āϞ⧇ loop āĻ•āĻ–āύ⧋ āĻļ⧇āώ āĻšāϝāĻŧ āύāĻžāĨ¤
  • āϚ⧁āĻĒāϚāĻžāĻĒ āϘ⧁āϰāϤ⧇ āĻĨāĻžāĻ•āĻž loop āϚāϞāϤ⧇āχ āĻĨāĻžāϕ⧇, āϝāϤāĻ•ā§āώāĻŖ āύāĻž time limit āĻ“āϕ⧇ āĻĨāĻžāĻŽāĻžāϝāĻŧ; badge-āĻ āϞ⧇āĻ–āĻž āĻ“āϠ⧇ āϟāĻžāχāĻŽ āϞāĻŋāĻŽāĻŋāϟ āĻĒāĻžāϰ āĻšāϝāĻŧ⧇āϛ⧇āĨ¤
  • while (scanf("%d", &x) == 1) āϝāϤāϗ⧁āϞ⧋ āϏāĻ‚āĻ–ā§āϝāĻž āφāϛ⧇ āϏāĻŦ āĻĒāĻĄāĻŧ⧇; sentinel-āĻāϰ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻĨāĻžāϕ⧇ āĻāĻ•āχ condition-āĻāĨ¤
  • āĻāĻ–āύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏ⧇āϰāĻž āĻŽāĻžāύ āĻļ⧁āϰ⧁ āĻšāϝāĻŧ āĻĒā§āϰāĻĨāĻŽ āĻĒāĻĄāĻŧāĻž āĻŽāĻžāύ āĻĨ⧇āϕ⧇, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž loop body-āϤ⧇ brace āĻĨāĻžāϕ⧇āĨ¤

āĻāϰāĻĒāϰ for āĻļ⧁āϰ⧁, condition āφāϰ step āϤāĻŋāύāϟāĻžāϕ⧇āχ āĻāĻ• āϞāĻžāχāύ⧇ āĻŦāϏāĻžāϝāĻŧ, āφāϰ Bob āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰ⧇ 1 āĻĨ⧇āϕ⧇ 10 āĻ›āĻžāĻĒāϤ⧇āĨ¤

lesson ā§§ āĻļ⧇āώ

āĻļ⧇āώ āĻšāϞ⧇ āϚāĻŋāĻšā§āύ āĻĻāĻŋāύ, āĻ…āĻ—ā§āϰāĻ—āϤāĻŋ āφāĻĒāύāĻžāϰ āϏāĻžāĻĨ⧇ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤

āĻĒāϰ⧇āϰāϟāĻž: For: init, condition, update, āϧāĻžāĻĒ⧇ āϧāĻžāĻĒ⧇