Learn C Programming

lesson ā§§ / ā§­ ¡ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύ⧇āĻ“āϝāĻŧāĻž

Module ā§Ģ ¡ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύ⧇āĻ“āϝāĻŧāĻž

If, else if, else: āĻĒāĻĨ āĻŦ⧇āϛ⧇ āύ⧇āĻ“āϝāĻŧāĻž

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

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

  • if, if else āφāϰ else if ladder āϞāĻŋāĻ–āϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āĻĒā§āϰāϤāĻŋāϟāĻž body-āϰ āϚāĻžāϰāĻĒāĻžāĻļ⧇ brace āĻĻāĻŋāϝāĻŧ⧇āĨ¤
  • āĻāĻ•āϟāĻž ladder-āϕ⧇ trace table āĻĻāĻŋāϝāĻŧ⧇ āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāϰāĻŦ⧇: āϕ⧋āύ input āϕ⧋āύ āĻĒāĻĨ⧇ āϗ⧇āϞāĨ¤
  • āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ ladder-āĻāϰ āĻ•ā§āϰāĻŽ āϕ⧇āύ āωāĻ¤ā§āϤāϰ āĻŦāĻĻāϞ⧇ āĻĻ⧇āϝāĻŧ, āφāϰ condition-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āĻāĻ•āϟāĻž = āϕ⧇āύ bugāĨ¤

Module 4-āĻ Amara leap year-āĻāϰ āύāĻŋāϝāĻŧāĻŽāϟāĻž āĻāĻ• expression-āĻ āϞāĻŋāϖ⧇āĻ›āĻŋāϞ, āφāϰ āĻ“āϟāĻž 1 āĻŦāĻž 0 āĻ›āĻžāĻĒāϤāĨ¤ āĻ“āϰ calendar app āĻ•āĻŋāĻ¨ā§āϤ⧁ āϚāĻžāχāĻ›āĻŋāϞ āĻāĻ•āϟāĻž āĻŦāĻžāĻ•ā§āϝ: "2024 has 366 days"āĨ¤

Screen-āĻ āĻāĻ•āϟāĻž 1 āĻĻ⧇āĻ–āĻžāύ⧋ āφāϰ āĻāĻ•āϟāĻž āĻŦāĻžāĻ•ā§āϝ āĻŦāϞāĻž āĻāĻ• āϜāĻŋāύāĻŋāϏ āύāĻžāĨ¤ āĻĻ⧁āχāϟāĻž āĻŦāĻžāĻ•ā§āϝ⧇āϰ āĻāĻ•āϟāĻž āĻ›āĻžāĻĒāϤ⧇ āĻšāϞ⧇ program-āϕ⧇ āĻŦ⧇āϛ⧇ āύāĻŋāϤ⧇ āĻšāĻŦ⧇ āϕ⧋āύ āϞāĻžāχāύāϟāĻž āϚāϞāĻŦ⧇āĨ¤

āĻāĻ–āύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒā§āϰāϤāĻŋāϟāĻž program āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ āϚāĻžāϞāĻŋāϝāĻŧ⧇āϛ⧇, āωāĻĒāϰ āĻĨ⧇āϕ⧇ āύāĻŋāĻšā§‡, āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰāĨ¤ āφāϜ āϰāĻžāĻ¸ā§āϤāĻžāϟāĻž āĻĻ⧁āχ āĻ­āĻžāĻ— āĻšāĻšā§āϛ⧇āĨ¤

if: āϝ⧇ block āĻļ⧁āϧ⧁ āωāĻ¤ā§āϤāϰ āĻļā§‚āĻ¨ā§āϝ āύāĻž āĻšāϞ⧇ āϚāϞ⧇

if statement āĻāĻ•āϟāĻž āĻĒā§āϰāĻļā§āύ āĻ•āϰ⧇āĨ¤ āωāĻ¤ā§āϤāϰ āϏāĻ¤ā§āϝ āĻšāϞ⧇āχ āĻļ⧁āϧ⧁ āĻāĻ•āϟāĻž block āϚāĻžāϞāĻžāϝāĻŧāĨ¤ C-āϤ⧇ "āϏāĻ¤ā§āϝ" āĻŽāĻžāύ⧇ "āĻļā§‚āĻ¨ā§āϝ āύāĻž", Module 2-āĻāϰ āϏ⧇āχ āύāĻŋāϝāĻŧāĻŽāĨ¤

if statement

if (condition) {
    statements
}
  • if āĻšāϞ⧋ keyword, āφāϰ āĻāϰ āĻĒāϰ⧇ āϏāĻŦ āϏāĻŽāϝāĻŧ āĻŦāĻ¨ā§āϧāύ⧀ āφāϏ⧇āĨ¤
  • condition āϝ⧇āϕ⧋āύ⧋ expressionāĨ¤ āĻļā§‚āĻ¨ā§āϝ āĻŽāĻžāύ⧇ āĻŽāĻŋāĻĨā§āϝāĻž; āĻŦāĻžāĻ•āĻŋ āϏāĻŦ āĻŽāĻžāύ āϏāĻ¤ā§āϝāĨ¤
  • Brace-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āĻĨāĻžāϕ⧇ body: āϝ⧇ āϞāĻžāχāύāϗ⧁āϞ⧋ āĻļ⧁āϧ⧁ condition āϏāĻ¤ā§āϝ āĻšāϞ⧇ āϚāϞ⧇āĨ¤
  • āĻļ⧇āώ brace-āĻāϰ āĻĒāϰ⧇ program āύāĻŋāĻœā§‡āϰ āĻŽāϤ⧋ āĻāĻ—āĻŋāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āĻĒā§āϰāĻļā§āύ⧇āϰ āωāĻ¤ā§āϤāϰ āϝāĻž-āχ āĻšā§‹āĻ•āĨ¤
#include <stdio.h>

int main(void)
{
    int stock = 7;

    if (stock < 10) {
        printf("reorder\n");
    }
    printf("stock checked\n");
    return 0;
}
reorder
stock checked

7-āϕ⧇ 12 āĻ•āϰ⧇ āĻĻāĻžāĻ“, āϤāĻ–āύ āĻļ⧁āϧ⧁ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āϞāĻžāχāύāϟāĻž āĻ›āĻžāĻĒāĻŦ⧇āĨ¤ Brace-āĻāϰ āĻ­āĻŋāϤāϰ⧇āϰ printf āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧ⧇; āĻĒāϰ⧇āϰāϟāĻž āĻĒāĻĄāĻŧ⧇ āύāĻžāĨ¤

āĻŽāĻžāύ⧇ if program āĻĨāĻžāĻŽāĻžāϝāĻŧ āύāĻž, āϕ⧋āύ⧋ āĻŦ⧇āϰ⧋āύ⧋āϰ āϰāĻžāĻ¸ā§āϤāĻžāĻ“ āĻŦāĻžāϛ⧇ āύāĻžāĨ¤ āĻ“ āĻļ⧁āϧ⧁ āĻ āĻŋāĻ• āĻ•āϰ⧇ āĻāĻ•āϟāĻž block āϚāϞāĻŦ⧇ āĻ•āĻŋ āύāĻž, āϤāĻžāϰāĻĒāϰ program āϚāϞāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤

else: āĻĻ⧁āχāϟāĻž āĻĒāĻĨ⧇āϰ āĻ āĻŋāĻ• āĻāĻ•āϟāĻž

else āĻŽāĻŋāĻĨā§āϝāĻž āωāĻ¤ā§āϤāϰāϕ⧇ āύāĻŋāĻœā§‡āϰ āĻāĻ•āϟāĻž block āĻĻ⧇āϝāĻŧāĨ¤ āĻĻ⧁āχāϟāĻž block-āĻāϰ āĻ āĻŋāĻ• āĻāĻ•āϟāĻžāχ āϚāϞ⧇: āĻ•āĻ–āύ⧋ āĻĻ⧁āχāϟāĻžāχ āύāĻž, āĻ•āĻ–āύ⧋ āĻāĻ•āϟāĻžāĻ“-āύāĻž-āĻāĻŽāύāĻ“ āύāĻžāĨ¤

#include <stdio.h>

int main(void)
{
    int year = 2024;
    int leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;

    if (leap) {
        printf("%d has 366 days\n", year);
    } else {
        printf("%d has 365 days\n", year);
    }
    return 0;
}
2024 has 366 days

Expression-āϟāĻž Module 4-āĻāϰ Amara-āϰ āϞ⧇āĻ–āĻž, āĻāĻ•āϟ⧁āĻ“ āĻŦāĻĻāϞāĻžāϝāĻŧāύāĻŋāĨ¤ āύāϤ⧁āύ āĻļ⧁āϧ⧁ āĻāϟāĻž āϝ⧇ āĻ“āϰ 1 āĻŦāĻž 0 āĻāĻ–āύ āĻ āĻŋāĻ• āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧ āϕ⧋āύ printf āϚāϞāĻŦ⧇āĨ¤

āϤāĻžāϰ āĻŽāĻžāύ⧇ leap year-āĻāϰ āύāĻŋāϝāĻŧāĻŽ āĻāĻ•āϟ⧁āĻ“ āĻŦāĻĻāϞāĻžāϝāĻŧāύāĻŋāĨ¤ āĻ“āϟāĻž āĻ›āĻžāĻĒāĻžāϰ āĻŽāϤ⧋ āωāĻ¤ā§āϤāϰ āĻĨ⧇āϕ⧇ āĻ•āĻžāĻœā§‡ āϞāĻžāĻ—āĻžāύ⧋āϰ āĻŽāϤ⧋ āωāĻ¤ā§āϤāϰ āĻšāϝāĻŧ⧇ āϗ⧇āϛ⧇āĨ¤

else if ladder: āĻĒā§āϰāĻĨāĻŽ āϝ⧇ condition āϏāĻ¤ā§āϝ, āϏ⧇-āχ āĻœā§‡āϤ⧇

āĻŦāĻžāĻ¸ā§āϤāĻŦ⧇āϰ āĻŦ⧇āĻļāĻŋāϰ āĻ­āĻžāĻ— āĻĒā§āϰāĻļā§āύ⧇āϰ āωāĻ¤ā§āϤāϰ āĻĻ⧁āχāϟāĻžāϰ āĻŦ⧇āĻļāĻŋāĨ¤ C āĻ“āϗ⧁āϞ⧋āϕ⧇ else if āĻĻāĻŋāϝāĻŧ⧇ āĻļāĻŋāĻ•āϞ⧇āϰ āĻŽāϤ⧋ āĻœā§‹āĻĄāĻŧ⧇, āφāϰ āĻāχ āĻļāĻŋāĻ•āϞāϟāĻžāϕ⧇ āϏāĻžāϧāĻžāϰāĻŖāϤ ladder āĻŦāϞ⧇āĨ¤

else if ladder

if (condition_1) {
    runs when condition_1 is true
} else if (condition_2) {
    runs when condition_1 was false and condition_2 is true
} else {
    runs when every condition above was false
}
  • C āωāĻĒāϰ āĻĨ⧇āϕ⧇ condition-āϗ⧁āϞ⧋ āĻāĻ•āϟāĻž āĻāĻ•āϟāĻž āĻ•āϰ⧇ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰ⧇āĨ¤
  • āĻĒā§āϰāĻĨāĻŽ āϝ⧇āϟāĻž āϏāĻ¤ā§āϝ, āϏ⧇āϟāĻžāϰ block āϚāϞ⧇, āφāϰ āϤāĻžāϰ āύāĻŋāĻšā§‡āϰ āϏāĻŦ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧ⧇āĨ¤
  • āĻļ⧇āώ⧇āϰ else āύāĻž āĻĻāĻŋāϞ⧇āĻ“ āϚāϞ⧇āĨ¤ āύāĻž āĻĻāĻŋāϞ⧇, āϕ⧋āύ⧋āϟāĻžāϰ āϏāĻžāĻĨ⧇ āύāĻž āĻŽā§‡āϞāĻž āĻŽāĻžāύ⧇āϰ āϜāĻ¨ā§āϝ āĻ•āĻŋāϛ⧁āχ āϚāϞ⧇ āύāĻžāĨ¤
#include <stdio.h>

int main(void)
{
    int marks = 72;

    if (marks >= 80) {
        printf("distinction\n");
    } else if (marks >= 60) {
        printf("merit\n");
    } else if (marks >= 40) {
        printf("pass\n");
    } else {
        printf("fail\n");
    }
    return 0;
}
merit

Ladder āĻĒāĻĄāĻŧāĻžāϰ āĻšāĻžāϤāĻŋāϝāĻŧāĻžāϰ āĻšāϞ⧋ trace tableāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž input-āĻāϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻž āϏāĻžāϰāĻŋ, āφāϰ C āφāϏāϞ⧇ āϝ⧇ āĻĒāϰ⧀āĻ•ā§āώāĻžāϗ⧁āϞ⧋ āϚāĻžāϞāĻŋāϝāĻŧ⧇āϛ⧇ āϏ⧇āϗ⧁āϞ⧋āϰ āĻāĻ•āϟāĻž āĻ•āϞāĻžāĻŽāĨ¤

marksāϝ⧇ āĻĒāϰ⧀āĻ•ā§āώāĻžāϗ⧁āϞ⧋ āϚāϞāϞ, āĻ•ā§āϰāĻŽā§‡āϝ⧇ āĻĒāĻĨ⧇ āϗ⧇āϞ
95>= 80 āϏāĻ¤ā§āϝdistinction
72>= 80 āĻŽāĻŋāĻĨā§āϝāĻž, >= 60 āϏāĻ¤ā§āϝmerit
60>= 80 āĻŽāĻŋāĻĨā§āϝāĻž, >= 60 āϏāĻ¤ā§āϝmerit
45>= 80 āĻŽāĻŋāĻĨā§āϝāĻž, >= 60 āĻŽāĻŋāĻĨā§āϝāĻž, >= 40 āϏāĻ¤ā§āϝpass
12āϤāĻŋāύāϟāĻžāχ āĻŽāĻŋāĻĨā§āϝāĻžfail, āĻŽāĻžāύ⧇ else

72-āĻāϰ āϏāĻžāϰāĻŋāϰ āĻŽāĻžāĻā§‡āϰ āĻ•āϞāĻžāĻŽāϟāĻž āĻĒāĻĄāĻŧā§‹āĨ¤ >= 40 āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž āϚāϞ⧇āχāύāĻŋāĨ¤ āĻĒā§āϰāĻĨāĻŽ āϏāĻ¤ā§āϝ āωāĻ¤ā§āϤāϰ⧇āχ ladder āĻĨ⧇āĻŽā§‡ āϗ⧇āϛ⧇āĨ¤

else if ladder, āĻāĻ•āϟāĻž flowchart āĻšāĻŋāϏ⧇āĻŦ⧇ āĻšā§āϝāĻžāρ āĻšāϞ⧇ ladder āĻļ⧇āώ; āĻļ⧁āϧ⧁ āύāĻž āĻšāϞ⧇āχ āĻĒāϰ⧇āϰ āĻĒāϰ⧀āĻ•ā§āώāĻž marks >= 80 āĻšā§āϝāĻžāρ distinction āύāĻž marks >= 60 āĻšā§āϝāĻžāρ merit āύāĻž marks >= 40 āĻšā§āϝāĻžāρ pass āύāĻž else: fail 72 marks-āĻāϰ āĻĒāĻĨ: āĻĒā§āϰāĻĨāĻŽ āĻĒāϰ⧀āĻ•ā§āώāĻžāϝāĻŧ āύāĻž, āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧāϤ⧇ āĻšā§āϝāĻžāρ, āφāϰ āϤ⧃āϤ⧀āϝāĻŧāϟāĻž āϚāϞ⧇āχ āύāĻžāĨ¤

āĻāĻŦāĻžāϰ āĻ•ā§āϰāĻŽā§‡āϰ āύāĻŋāϝāĻŧāĻŽāĨ¤ Bob, āϝ⧇ āϏāĻŦ āϏāĻŽāϝāĻŧ āϤāĻžāĻĄāĻŧāĻžāĻšā§āĻĄāĻŧāĻž āĻ•āϰ⧇, āĻāĻ•āχ ladder āϞ⧇āϖ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϏāĻšāϜ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    int marks = 95;

    if (marks >= 40) {
        printf("pass\n");
    } else if (marks >= 60) {
        printf("merit\n");
    } else if (marks >= 80) {
        printf("distinction\n");
    } else {
        printf("fail\n");
    }
    return 0;
}
pass

95-āϕ⧇ āĻāϰ āĻ­āĻŋāϤāϰ āĻĻāĻŋāϝāĻŧ⧇ trace āĻ•āϰ⧋āĨ¤ āĻĒā§āϰāĻĨāĻŽ āĻĒāϰ⧀āĻ•ā§āώāĻž, >= 40, āϏāĻ¤ā§āϝ, āϤāĻžāχ ladder āĻ“āĻ–āĻžāύ⧇āχ āĻĨāĻžāĻŽā§‡āĨ¤ 62 āφāϰ 100-āĻāϰ āĻŦ⧇āϞāĻžāϤ⧇āĻ“ āĻāĻ•āχ āĻ•āĻĨāĻžāĨ¤

40 āĻĨ⧇āϕ⧇ āωāĻĒāϰ⧇āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āĻŽāĻžāĻ°ā§āĻ• āĻĒā§āϰāĻĨāĻŽ āĻĒāϰ⧀āĻ•ā§āώāĻžāϤ⧇āχ āĻĒāĻžāĻļ āĻ•āϰ⧇ āϝāĻžāϝāĻŧ, āϤāĻžāχ merit āφāϰ distinction-āĻāϰ block āĻ•āĻ–āύ⧋ āϚāϞāϤ⧇āχ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤ Compiler āĻ•āĻŋāϛ⧁āχ āĻŦāϞ⧇ āύāĻž; Bob āϕ⧀ āĻŦā§‹āĻāĻžāϤ⧇ āĻšā§‡āϝāĻŧ⧇āĻ›āĻŋāϞ, āϏ⧇āϟāĻž āĻ“āϰ āϜāĻžāύāĻžāϰ āωāĻĒāĻžāϝāĻŧ āύ⧇āχāĨ¤

āϤāĻžāχ āϝ⧇āϕ⧋āύ⧋ ladder-āĻāϰ āύāĻŋāϝāĻŧāĻŽāϟāĻž āĻāχāĨ¤ āĻāĻ•āϟāĻž condition-āĻāϰ āĻĒāϰāĻŋāϏāϰ āϝāĻĻāĻŋ āφāϰ⧇āĻ•āϟāĻžāϰ āĻĒāϰāĻŋāϏāϰāϕ⧇ āĻ­āĻŋāϤāϰ⧇ āϧāϰ⧇ āϰāĻžāϖ⧇, āϛ⧋āϟ āĻĒāϰāĻŋāϏāϰāϟāĻžāϕ⧇ āφāϗ⧇ āĻŦāϏāĻžāϤ⧇ āĻšāĻŦ⧇āĨ¤ āĻāĻ–āĻžāύ⧇ "80 āφāϰ āϤāĻžāϰ āĻŦ⧇āĻļāĻŋ" āφāϛ⧇ "40 āφāϰ āϤāĻžāϰ āĻŦ⧇āĻļāĻŋ"-āϰ āĻ­āĻŋāϤāϰ⧇, āϤāĻžāχ āĻ“āϟāĻž āωāĻĒāϰ⧇ āϝāĻžāϝāĻŧāĨ¤

āϝ⧇āϕ⧋āύ⧋ int-āχ condition, āφāϰ 0 āĻŽāĻžāύ⧇ āĻŽāĻŋāĻĨā§āϝāĻž

if-āĻāϰ āĻĒāϰ⧇āϰ āĻŦāĻ¨ā§āϧāύ⧀āϤ⧇ āϤ⧁āϞāύāĻž āĻĨāĻžāĻ•āϤ⧇āχ āĻšāĻŦ⧇, āĻāĻŽāύ āύāĻžāĨ¤ āϏāĻ‚āĻ–ā§āϝāĻž āĻšāϝāĻŧ āĻāĻŽāύ āϝ⧇āϕ⧋āύ⧋ expression āϚāϞ⧇, āφāϰ āĻļ⧁āϧ⧁ āĻļā§‚āĻ¨ā§āϝ āĻŽāĻžāύ⧇ āύāĻžāĨ¤

#include <stdio.h>

int main(void)
{
    int stock = 0;
    int n = -7;

    if (stock) {
        printf("in stock\n");
    } else {
        printf("sold out\n");
    }

    if (n % 2) {
        printf("%d is odd\n", n);
    }
    return 0;
}
sold out
-7 is odd

if (stock) āĻŽāĻžāύ⧇ āĻšā§āĻŦāĻšā§ if (stock != 0)āĨ¤ "āĻ•āĻŋāϛ⧁ āφāϛ⧇ āĻ•āĻŋ" āϧāϰāύ⧇āϰ āĻ—āĻŖāύāĻžāϰ āϜāĻ¨ā§āϝ āϛ⧋āϟ āϰ⧂āĻĒāϟāĻž āĻĒāĻĄāĻŧāϤ⧇ āĻ­āĻžāϞ⧋ āϞāĻžāϗ⧇āĨ¤

āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž āĻāĻ•āϟ⧁ āϏ⧂āĻ•ā§āĻˇā§āĻŽāĨ¤ -7 % 2 āĻšāϞ⧋ -1, Module 4-āĻāϰ sign-āĻāϰ āύāĻŋāϝāĻŧāĻŽ, āφāϰ -1 āĻļā§‚āĻ¨ā§āϝ āύāĻžāĨ¤ āϤāĻžāχ negative āĻŦāĻŋāĻœā§‹āĻĄāĻŧ āϏāĻ‚āĻ–ā§āϝāĻžāϤ⧇āĻ“ āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž āϏāĻ¤ā§āϝ, āϝ⧇āĻ–āĻžāύ⧇ n % 2 == 1 āĻšāϤ⧋ āĻŽāĻŋāĻĨā§āϝāĻžāĨ¤

āϤāĻžāϰ āĻŽāĻžāύ⧇ condition āφāϞāĻžāĻĻāĻž āϕ⧋āύ⧋ āϜāĻžāϤ⧇āϰ āĻŽāĻžāύ āύāĻžāĨ¤ āĻ“āϟāĻž āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž, āφāϰ āĻļ⧁āϧ⧁ āĻļā§‚āĻ¨ā§āϝāχ āύāĻž āĻŦāϞ⧇āĨ¤

āĻāĻ•āϟāĻž āϏāĻŽāĻžāύ-āϚāĻŋāĻšā§āύ: āϝ⧇ bug compile āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ

= āĻāĻ•āϟāĻž āĻŽāĻžāύ āϰāĻžāϖ⧇āĨ¤ == āĻāĻ•āϟāĻž āĻĒā§āϰāĻļā§āύ āĻ•āϰ⧇āĨ¤ Condition-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āĻĒā§āϰāĻĨāĻŽāϟāĻž āĻĒā§āϰāĻžāϝāĻŧ āϏāĻŦ āϏāĻŽāϝāĻŧāχ āϟāĻžāχāĻĒ⧇āϰ āϭ⧁āϞāĨ¤

#include <stdio.h>

int main(void)
{
    int marks = 35;

    if (marks = 100) {
        printf("full marks\n");
    }
    printf("marks is now %d\n", marks);
    return 0;
}
full marks
marks is now 100

āĻāĻ•āϏāĻžāĻĨ⧇ āĻĻ⧁āχāϟāĻž āϜāĻŋāύāĻŋāϏ āϭ⧁āϞ āĻšāϞ⧋āĨ¤ Assignment-āĻāϰ āĻŽāĻžāύ 100, āϝ⧇āϟāĻž āĻļā§‚āĻ¨ā§āϝ āύāĻž, āϤāĻžāχ āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž āϏāĻŦ āϏāĻŽāϝāĻŧ āϏāĻ¤ā§āϝāĨ¤ āφāϰ āĻ›āĻžāĻ¤ā§āϰāϟāĻžāϰ āφāϏāϞ āĻŽāĻžāĻ°ā§āĻ•āϟāĻž āĻŽā§āϛ⧇ āϗ⧇āϛ⧇āĨ¤

Playground āĻāϟāĻž āϚ⧁āĻĒāϚāĻžāĻĒ compile āĻ•āϰ⧇, āĻ•āĻžāϰāĻŖ āĻ“āĻ–āĻžāύ⧇ -Wall āύ⧇āχāĨ¤ āύāĻŋāĻœā§‡āϰ āĻŽā§‡āĻļāĻŋāύ⧇ GCC 12-āĻāϰ gcc -Wall āĻŦāϞ⧇ warning: suggest parentheses around assignment used as truth value [-Wparentheses]āĨ¤

āϤāĻžāχ āϝ⧇ if āϤ⧋āĻŽāĻžāϰ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻĒā§āϰāϤāĻŋāϟāĻž input-āĻāχ āϏāĻ¤ā§āϝ, āĻ“āĻ–āĻžāύ⧇ āφāϗ⧇ āĻāĻ•āĻž āĻāĻ•āϟāĻž = āĻ–ā§‹āρāĻœā§‹āĨ¤

āĻĒā§āϰāϤāĻŋāϟāĻž body-āϤ⧇ brace, āφāϰ āϝ⧇ bug āϏāĻŦāĻžāχāϕ⧇ āĻ•āĻžāϰāĻŖāϟāĻž āĻļāĻŋāĻ–āĻŋāϝāĻŧ⧇āϛ⧇

Body āϝāĻĻāĻŋ āĻāĻ•āϟāĻžāχ statement āĻšāϝāĻŧ, C brace āĻ›āĻžāĻĄāĻŧāĻž if āϞāĻŋāĻ–āϤ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻāχ track āϏ⧇āχ āĻ›āĻžāĻĄāĻŧ āĻ•āĻ–āύ⧋ āύ⧇āϝāĻŧ āύāĻž, āφāϰ āĻ•āĻžāϰāĻŖāϟāĻž āĻāĻ–āĻžāύ⧇āĨ¤

2014-āϰ February-āϤ⧇ Apple iOS āφāϰ macOS-āĻāϰ TLS code-āĻāϰ āĻāĻ•āϟāĻž fix āĻ›āĻžāĻĄāĻŧ⧇, āϝ⧇āϟāĻžāϰ āύāĻžāĻŽ CVE-2014-1266āĨ¤ Server-āĻāϰ signature āϝāĻžāϚāĻžāχ āĻ•āϰāĻž āĻāĻ•āϟāĻž function-āĻ brace āĻ›āĻžāĻĄāĻŧāĻž āĻāĻ•āϟāĻž if-āĻāϰ āύāĻŋāĻšā§‡ āĻĒāϰāĻĒāϰ āĻĻ⧁āχāϟāĻž āĻšā§āĻŦāĻšā§ āĻāĻ• āϞāĻžāχāύ āĻ›āĻŋāϞ: goto fail;āĨ¤ āĻĒā§āϰāĻĨāĻŽ āϞāĻžāχāύāϟāĻžāχ āĻļ⧁āϧ⧁ if-āĻāϰāĨ¤ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧāϟāĻž āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ āϚāϞāϤ, āφāϏāϞ āϝāĻžāϚāĻžāχāϟāĻž āϟāĻĒāϕ⧇ āϝ⧇āϤ, āφāϰ āĻŦāϞāϤ āϏāĻŦ āĻ āĻŋāĻ• āφāϛ⧇āĨ¤ āϞ⧋āϕ⧇ āĻ“āϟāĻžāϕ⧇ āĻĄāĻžāϕ⧇ "goto fail"āĨ¤

āĻļ⧁āϧ⧁ printf āĻĻāĻŋāϝāĻŧ⧇āχ āĻāĻ•āχ āĻĢāĻžāρāĻĻ āĻŦāĻžāύāĻžāύ⧋ āϝāĻžāϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    int marks = 35;

    if (marks >= 40)
        printf("pass\n");
        printf("certificate printed\n");
    return 0;
}
certificate printed

Indentation āĻĻ⧇āϖ⧇ āĻŽāύ⧇ āĻšāϝāĻŧ āĻĻ⧁āχāϟāĻž āϞāĻžāχāύāχ if-āĻāϰāĨ¤ Compiler indentation-āϕ⧇ āĻĒāĻžāĻ¤ā§āϤāĻžāχ āĻĻ⧇āϝāĻŧ āύāĻž, āϤāĻžāχ āĻļ⧁āϧ⧁ āĻĒā§āϰāĻĨāĻŽāϟāĻžāχ āĻ“āϰāĨ¤

Playground āφāĻŦāĻžāϰāĻ“ āϚ⧁āĻĒāĨ¤ āύāĻŋāĻœā§‡āϰ āĻŽā§‡āĻļāĻŋāύ⧇āϰ gcc -Wall āĻŦāϞ⧇ warning: this 'if' clause does not guard... [-Wmisleading-indentation]āĨ¤ Brace āĻĨāĻžāĻ•āϞ⧇ āĻĒā§āϰāĻļā§āύāϟāĻžāχ āĻ“āϠ⧇ āύāĻžāĨ¤

āϤāĻžāχ brace āϏāĻžāϜāϏāĻœā§āϜāĻž āύāĻžāĨ¤ Body āϕ⧋āĻĨāĻžāϝāĻŧ āĻļ⧇āώ, C-āϕ⧇ āϏ⧇āϟāĻž āĻŦāϞāĻžāϰ āĻāĻ•āĻŽāĻžāĻ¤ā§āϰ āωāĻĒāĻžāϝāĻŧ āĻ“āϟāĻžāχāĨ¤

Example 1: input āĻĒāĻĄāĻŧāĻž āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ if

āĻāĻ•āϟāĻž condition, āĻāĻ•āϟāĻž body, āφāϰ āωāĻ¤ā§āϤāϰ āύāĻž āĻšāϞ⧇ āĻ•āĻŋāϛ⧁āχ āύāĻžāĨ¤

#include <stdio.h>

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

    if (celsius < 0) {
        printf("freezing\n");
    }
    return 0;
}
freezing

āĻ“āχ output-āϟāĻž -3 input-āĻāϰ āϜāĻ¨ā§āϝāĨ¤ 5 āĻĻāĻŋāϞ⧇ program āĻ•āĻŋāϛ⧁āχ āĻ›āĻžāĻĒ⧇ āύāĻž, āφāϰ āĻ“āϕ⧇ āĻ āĻŋāĻ• āϏ⧇āϟāĻžāχ āĻ•āϰāϤ⧇ āĻŦāϞāĻž āĻšāϝāĻŧ⧇āĻ›āĻŋāϞāĨ¤

Run in Compiler
Example 2: if else, āĻāĻ•āϟāĻž negative input āĻĻāĻŋāϝāĻŧ⧇

āĻĻ⧁āχāϟāĻž āĻĒāĻĨ, āφāϰ negative āϏāĻ‚āĻ–ā§āϝāĻž āϕ⧋āύ āĻĒāĻĨ⧇ āϝāĻžāĻŦ⧇ āϏ⧇āϟāĻž āĻ āĻŋāĻ• āĻ•āϰ⧇ Module 4-āĻāϰ āĻ­āĻžāĻ—āĻļ⧇āώ⧇āϰ āύāĻŋāϝāĻŧāĻŽāĨ¤

#include <stdio.h>

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

    if (n % 2 == 0) {
        printf("%d is even\n", n);
    } else {
        printf("%d is odd\n", n);
    }
    return 0;
}
-7 is odd

āĻ“āχ output-āϟāĻž -7 input-āĻāϰ āϜāĻ¨ā§āϝāĨ¤ 0-āϰ āϏāĻžāĻĨ⧇ āĻŽā§‡āϞāĻžāϞ⧇ āĻĻ⧁āχ sign-āĻāχ āĻ•āĻžāϜ āĻ•āϰ⧇, āĻ•āĻžāϰāĻŖ -1 āĻ­āĻžāĻ—āĻļ⧇āώāĻ“ āϤ⧋ 0 āύāĻžāĨ¤

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

āĻŦāϝāĻŧāϏ āĻĻ⧇āϖ⧇ āϏāĻŋāύ⧇āĻŽāĻžāϰ āϟāĻŋāĻ•āĻŋāϟāĨ¤ āĻāĻ•āϟāĻž āĻĒāĻžāĻšāĻžāϰāĻž āφāϗ⧇ āĻ…āϏāĻŽā§āĻ­āĻŦ input āĻŦāĻžāĻĻ āĻĻ⧇āϝāĻŧ, āϤāĻžāϰāĻĒāϰ band-āϗ⧁āϞ⧋ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ āĻŦāϝāĻŧāϏ āĻĨ⧇āϕ⧇ āωāĻĒāϰ⧇ āĻ“āϠ⧇āĨ¤

#include <stdio.h>

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

    if (age < 0) {
        printf("invalid age\n");
    } else if (age < 3) {
        printf("ticket 0\n");
    } else if (age < 12) {
        printf("ticket 150\n");
    } else if (age >= 60) {
        printf("ticket 200\n");
    } else {
        printf("ticket 300\n");
    }
    return 0;
}
ticket 200

āĻ“āχ output-āϟāĻž 65 input-āĻāϰ āϜāĻ¨ā§āϝāĨ¤ āĻāĻ–āĻžāύ⧇ āĻĒāϰ⧀āĻ•ā§āώāĻžāϗ⧁āϞ⧋āϝāĻŧ <, āϤāĻžāχ "3-āĻāϰ āĻ•āĻŽ" āφāϛ⧇ "12-āĻāϰ āĻ•āĻŽ"-āĻāϰ āĻ­āĻŋāϤāϰ⧇, āφāϰ āĻ“āϟāĻžāχ āφāϗ⧇ āφāϏ⧇āĨ¤ āύāĻŋāϝāĻŧāĻŽ āϏ⧇āχ āĻāĻ•āϟāĻžāχ, āĻļ⧁āϧ⧁ āωāĻ˛ā§āĻŸā§‹ āĻĻāĻŋāĻ• āĻĨ⧇āϕ⧇ āĻĒāĻĄāĻŧāĻžāĨ¤

Run in Compiler

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

  • āĻĒāϰ⧀āĻ•ā§āώāĻžāϰ āĻĢāϞāĨ¤ āĻŦāĻžāĻ‚āϞāĻžāĻĻ⧇āĻļ⧇āϰ āĻļāĻŋāĻ•ā§āώāĻž āĻŦā§‹āĻ°ā§āĻĄ āĻāĻ•āϟāĻž grade-āĻāϰ table āĻ›āĻžāĻĒ⧇: 80 āĻŦāĻž āϤāĻžāϰ āĻŦ⧇āĻļāĻŋ A+, āφāϰ 33-āĻāϰ āύāĻŋāĻšā§‡ FāĨ¤ āϝ⧇ program āĻ“āϟāĻž āĻ›āĻžāĻĒ⧇, āϏ⧇āϟāĻž āĻāĻ•āϟāĻž else if ladder, āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻĄāĻŧāĻž band āφāϗ⧇āĨ¤
  • ThermostatāĨ¤ Linux kernel-āĻāϰ step_wise thermal governor āϤāĻžāĻĒāĻŽāĻžāĻ¤ā§āϰāĻžāϕ⧇ āĻ•āϝāĻŧ⧇āĻ•āϟāĻž trip point-āĻāϰ āϏāĻžāĻĨ⧇ āĻŽā§‡āϞāĻžāϝāĻŧāĨ¤ āĻ•āϝāĻŧ⧇āĻ•āϟāĻž if āĻĒāϰāĻĒāϰ āĻ āĻŋāĻ• āĻ•āϰ⧇ āĻ āĻžāĻ¨ā§āĻĄāĻž āĻ•āϰāĻž āĻŦāĻžāĻĄāĻŧāĻŦ⧇, āĻ•āĻŽāĻŦ⧇, āύāĻž āĻāĻ•āχ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤
  • Input āϝāĻžāϚāĻžāχāĨ¤ nginx web server client_max_body_size-āĻāϰ āĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ request body-āϕ⧇ status 413 āĻĻāĻŋāϝāĻŧ⧇ āĻĢāĻŋāϰāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻāĻ•āϟāĻž āϤ⧁āϞāύāĻž, āĻāĻ•āϟāĻž branch, āφāϏāϞ āĻ•āĻžāϜ āĻļ⧁āϰ⧁āϰ āφāϗ⧇āχāĨ¤
  • Login āĻĒāϰ⧀āĻ•ā§āώāĻžāĨ¤ OpenSSH-āĻāϰ server āϭ⧁āϞ password-āĻāϰ āĻšā§‡āĻˇā§āϟāĻžāϗ⧁āϞ⧋ āĻ—ā§‹āύ⧇, āφāϰ MaxAuthTries-āϟāĻž āϭ⧁āϞ⧇āϰ āĻĒāϰ⧇ āϏāĻ‚āϝ⧋āĻ— āϕ⧇āĻŸā§‡ āĻĻ⧇āϝāĻŧāĨ¤ āĻ“āϟāĻž āĻāĻ•āϟāĻž counter-āĻāϰ āωāĻĒāϰ ifāĨ¤

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

ā§§. Condition-āĻ āĻāĻ•āϟāĻž āϏāĻŽāĻžāύ-āϚāĻŋāĻšā§āύāĨ¤

if (marks = 100) {
    printf("full marks\n");
}

Playground-āĻ āύ⧀āϰāĻŦāĨ¤ āύāĻŋāĻœā§‡āϰ āĻŽā§‡āĻļāĻŋāύ⧇āϰ gcc -Wall āĻŦāϞ⧇ warning: suggest parentheses around assignment used as truth value [-Wparentheses]āĨ¤ āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž āϏāĻŦ āϏāĻŽāϝāĻŧ āϏāĻ¤ā§āϝ, āφāϰ marks-āĻāϰ āĻŽāĻžāύ āĻŽā§āϛ⧇ āϝāĻžāϝāĻŧāĨ¤ == āϞ⧇āĻ–ā§‹āĨ¤ āĻœā§‹āϰ⧇ āϟāĻžāχāĻĒ āĻ•āϰāϞ⧇āχ āĻāϟāĻž āĻšāĻŦ⧇, āĻ•āĻžāϰāĻŖ āĻĻ⧁āχāϟāĻž āĻāĻ•āχ āϚāĻžāĻŦāĻŋāĨ¤

⧍. Condition-āĻāϰ āĻ āĻŋāĻ• āĻĒāϰ⧇āχ āĻāĻ•āϟāĻž semicolonāĨ¤

if (marks >= 40);
{
    printf("pass\n");
}

Playground-āĻ āύ⧀āϰāĻŦāĨ¤ āύāĻŋāĻœā§‡āϰ āĻŽā§‡āĻļāĻŋāύ⧇āϰ gcc -Wall āϜāĻžāύāĻžāϝāĻŧ this 'if' clause does not guard... [-Wmisleading-indentation], āφāϰ -Wextra āϝ⧋āĻ— āĻ•āϰ⧇ suggest braces around empty body in an 'if' statement [-Wempty-body]āĨ¤ Semicolon-āϟāĻžāχ āĻāĻ•āϟāĻž āĻĢāĻžāρāĻ•āĻž body, āϤāĻžāχ āĻĒā§āϰāϤāĻŋāϟāĻž āĻŽāĻžāĻ°ā§āϕ⧇āχ "pass" āĻ›āĻžāĻĒ⧇āĨ¤ āĻ“āϟāĻž āĻŽā§āϛ⧇ āĻĻāĻžāĻ“; if-āĻāϰ āϞāĻžāχāύ āĻ•āĻ–āύ⧋ semicolon āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧇āώ āĻšāϝāĻŧ āύāĻžāĨ¤

ā§Š. āĻŽā§āϖ⧇ āϝ⧇ āĻ•ā§āϰāĻŽā§‡ āĻŦāϞ⧋, āϏ⧇āχ āĻ•ā§āϰāĻŽā§‡ āϚāĻŋāĻšā§āύ āϞ⧇āĻ–āĻžāĨ¤

if (marks =< 40) {
    printf("fail\n");
}

āĻĒā§āϰāϤāĻŋāϟāĻž command line-āĻ error, Playground-āϏāĻš: error: expected expression before '<' tokenāĨ¤ Operator-āϟāĻž <=, āϕ⧋āĻŖāϟāĻž āφāϗ⧇āĨ¤ āĻŽā§āϖ⧇ āϤ⧋ āĻŦāϞ⧋ "less than or equal", āϚāĻŋāĻšā§āύāĻ“ āχāĻ‚āϰ⧇āϜāĻŋ āĻ•āĻĨāĻžāϟāĻžāϰ āĻ•ā§āϰāĻŽā§‡āχ āĻŦāϏ⧇āĨ¤

ā§Ē. āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϚāĻ“āĻĄāĻŧāĻž āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž āϏāĻŦāĻžāϰ āωāĻĒāϰ⧇āĨ¤

if (marks >= 40) {
    printf("pass\n");
} else if (marks >= 80) {
    printf("distinction\n");
}

āϕ⧋āύ⧋ command line-āĻāχ āĻŦāĻžāĻ°ā§āϤāĻž āύ⧇āχāĨ¤ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ block āĻ•āĻ–āύ⧋ āϚāϞāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž, āĻ•āĻžāϰāĻŖ 80 āϛ⧋āρāϝāĻŧāĻž āĻĒā§āϰāϤāĻŋāϟāĻž āĻŽāĻžāĻ°ā§āĻ• āφāϗ⧇āχ āĻĒā§āϰāĻĨāĻŽ āĻĒāϰ⧀āĻ•ā§āώāĻžāϝāĻŧ āĻĒāĻžāĻļ āĻ•āϰ⧇ āϗ⧇āϛ⧇āĨ¤ āϛ⧋āϟ āĻĒāϰāĻŋāϏāϰ āφāϗ⧇ āĻŦāϏāĻžāĻ“, āφāϰ āĻŦāĻŋāĻļā§āĻŦāĻžāϏ āĻ•āϰāĻžāϰ āφāϗ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž band āĻĨ⧇āϕ⧇ āĻāĻ•āϟāĻž āĻ•āϰ⧇ input trace āĻ•āϰ⧋āĨ¤

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

x positive āύāĻž āĻšāϞ⧇ Bob "b" āϚāĻžāϝāĻŧāĨ¤ āĻŽāĻžāĻĨāĻžāϝāĻŧ āϝ⧇āĻ­āĻžāĻŦ⧇ āĻŦāĻžāĻ•ā§āϝāϟāĻž āφāϏ⧇, āĻ“ āϏ⧇āĻ­āĻžāĻŦ⧇āχ āϞāĻžāχāύāϟāĻž āϞ⧇āϖ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    int x = -1;
    int y = 5;

    if (x > 0)
        if (y > 0)
            printf("a\n");
    else
        printf("b\n");

    printf("done\n");
    return 0;
}

āĻāϟāĻž āĻļ⧁āϧ⧁ done āĻ›āĻžāĻĒ⧇āĨ¤ āĻŦāϞ⧋ āϤ⧋, x -1 āĻšāϞ⧇ "b" āϕ⧇āύ āφāϏ⧇ āύāĻžāĨ¤ āϤāĻžāϰāĻĒāϰ āĻ•āĻ āĻŋāύ āĻ…āĻ°ā§āϧ⧇āĻ•āϟāĻž: x āφāϰ y-āĻāϰ āϕ⧋āύ āĻŽāĻžāύ⧇ "b" āĻ›āĻžāĻĒ⧇?

āĻāĻ•āϟāĻž else-āϕ⧇ āĻ āĻŋāĻ• āĻāĻ•āϟāĻž if-āĻāϰ āĻšāϤ⧇ āĻšāϝāĻŧāĨ¤ Indentation āĻšāϞ⧋ Bob-āĻāϰ āĻŽāϤāĻžāĻŽāϤ; compiler-āĻāϰ āύāĻŋāĻœā§‡āϰ āĻāĻ•āϟāĻž āύāĻŋāϝāĻŧāĻŽ āφāϛ⧇āĨ¤

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

Alice āĻŦāĻžāĻ‚āϞāĻžāĻĻ⧇āĻļ⧇āϰ āĻļāĻŋāĻ•ā§āώāĻž āĻŦā§‹āĻ°ā§āĻĄā§‡āϰ table āĻĻāĻŋāϝāĻŧ⧇ report card āĻ›āĻžāĻĒ⧇āĨ¤ 80 āĻĨ⧇āϕ⧇ 100 āĻšāϞ⧋ A+, 70 āĻĨ⧇āϕ⧇ 79 A, 60 āĻĨ⧇āϕ⧇ 69 A-, āφāϰ 50 āĻĨ⧇āϕ⧇ 59 BāĨ¤ āϤāĻžāϰāĻĒāϰ 40 āĻĨ⧇āϕ⧇ 49 C, 33 āĻĨ⧇āϕ⧇ 39 D, āφāϰ 0 āĻĨ⧇āϕ⧇ 32 FāĨ¤

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

Output. āĻāĻ• āϞāĻžāχāύ⧇ grade-āϟāĻž, āφāϰ marks āϝāĻĻāĻŋ 0-āϰ āύāĻŋāĻšā§‡ āĻŦāĻž 100-āϰ āωāĻĒāϰ⧇ āĻšāϝāĻŧ āϤāĻžāĻšāϞ⧇ invalidāĨ¤

Constraints. -1000 <= marks <= 1000āĨ¤

Sample. Input 79 āĻĻāĻŋāϞ⧇ AāĨ¤ Input 101 āĻĻāĻŋāϞ⧇ invalidāĨ¤

#include <stdio.h>

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

    /* One guard for the impossible marks, then one rung per band. */

    return 0;
}

grade-bands āύāĻžāĻŽā§‡ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧāĨ¤ Table-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϏ⧀āĻŽāĻžāχ hidden test, āĻĻ⧁āχ āĻĒāĻžāĻļ āĻĨ⧇āϕ⧇āχāĨ¤

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

Kenji āϤāĻŋāύāϟāĻž āĻ˛ā§āϝāĻžāĻĒ āĻĻ⧌āĻĄāĻŧ⧇āϛ⧇, āφāϰ leaderboard āĻļ⧁āϧ⧁ āĻ“āϰ āϏ⧇āϰāĻž score āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤ āĻĻ⧁āχāϟāĻž āĻ˛ā§āϝāĻžāĻĒ⧇āϰ score āϏāĻŽāĻžāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

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

Output. āĻāĻ• āϞāĻžāχāύ⧇ āϤāĻŋāύāϟāĻžāϰ āĻŽāĻ§ā§āϝ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧāϟāĻžāĨ¤

Constraints. āĻĒā§āϰāϤāĻŋāϟāĻž āĻŽāĻžāύ -1000000000 āĻĨ⧇āϕ⧇ 1000000000-āĻāϰ āĻŽāĻ§ā§āϝ⧇āĨ¤

Sample. Input 3 9 5 āĻĻāĻŋāϞ⧇ 9āĨ¤ Input 7 2 7 āĻĻāĻŋāϞ⧇ 7āĨ¤

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    scanf("%d %d %d", &a, &b, &c);

    /* Two separate ifs are enough. Equal values must not break it. */

    return 0;
}

largest-of-three āύāĻžāĻŽā§‡ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧāĨ¤ Hidden test-āϗ⧁āϞ⧋āϝāĻŧ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ āĻŽāĻžāύāϟāĻž āϤāĻŋāύāϟāĻž āϜāĻžāϝāĻŧāĻ—āĻžāϤ⧇āχ āϘ⧁āϰ⧇ āφāϏ⧇āĨ¤

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

Amara-āϰ calendar-āĻāϰ āϝ⧇āϕ⧋āύ⧋ āĻŦāĻ›āϰ⧇āϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻž āϏ⧋āϜāĻž āωāĻ¤ā§āϤāϰ āĻĻāϰāĻ•āĻžāϰ: leap year, āύāĻž āύāĻž?

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

Output. āĻāĻ• āϞāĻžāχāύ⧇: y leap year āĻšāϞ⧇ yes, āύāϝāĻŧāϤ⧋ noāĨ¤

Constraints. 1 <= y <= 9999āĨ¤

Sample. Input 1900 āĻĻāĻŋāϞ⧇ noāĨ¤ Input 2000 āĻĻāĻŋāϞ⧇ yesāĨ¤

#include <stdio.h>

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

    /* The Module 4 expression decides; an if else prints the word. */

    return 0;
}

āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧ āύāĻžāĨ¤ Problem lesson-āĻāϰ date-check āĻāχ āύāĻŋāϝāĻŧāĻŽāϟāĻžāχ āĻāĻ•āϟāĻž āĻŦāĻĄāĻŧ āĻĒā§āϰāĻļā§āύ⧇āϰ āĻ­āĻŋāϤāϰ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤

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

Zara āϤāĻŋāύāϟāĻž āĻĻ⧈āĻ°ā§āĻ˜ā§āϝ āĻĻāĻŋāϝāĻŧ⧇ āĻāĻ•āϟāĻž geometry app test āĻ•āϰ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āĻĻ⧈āĻ°ā§āĻ˜ā§āϝ āĻŦāĻžāĻ•āĻŋ āĻĻ⧁āχāϟāĻžāϰ āϝ⧋āĻ—āĻĢāϞ⧇āϰ āĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ āĻšāϤ⧇ āĻšāĻŦ⧇, āύāχāϞ⧇ triangle āύ⧇āχāĨ¤ āϝ⧋āĻ—āĻĢāϞ⧇āϰ āϏāĻŽāĻžāύ āĻšāϞ⧇ āφāĻ•āĻžāϰāϟāĻž āĻšā§āϝāĻžāĻĒā§āϟāĻž, āĻ“āϟāĻž āĻ—ā§‹āύāĻž āĻšāϝāĻŧ āύāĻžāĨ¤

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

Output. āĻāĻ• āϞāĻžāχāύ⧇: not a triangle, āύāχāϞ⧇ equilateral, isosceles āĻŦāĻž scaleneāĨ¤

Constraints. 1 <= a, b, c <= 1000000000āĨ¤

Sample. Input 2 2 3 āĻĻāĻŋāϞ⧇ isoscelesāĨ¤ Input 1 2 3 āĻĻāĻŋāϞ⧇ not a triangleāĨ¤

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    scanf("%d %d %d", &a, &b, &c);

    /* Is it a triangle at all? Then the narrowest kind first. */

    return 0;
}

triangle-kind āύāĻžāĻŽā§‡ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧāĨ¤ āϧāĻžāĻĒāϗ⧁āϞ⧋āϰ āĻ•ā§āϰāĻŽāϟāĻžāχ āĻĒ⧁āϰ⧋ āĻ•āĻ āĻŋāύ āĻ…āĻ‚āĻļāĨ¤

Run in Compiler

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

  • Body āĻāĻ• āϞāĻžāχāύ⧇āϰ āĻšāϞ⧇āĻ“ āĻ•āĻŋ āϏāĻ¤ā§āϝāĻŋāχ brace āϞāĻžāĻ—āĻŦ⧇?

    C āĻŦāĻžāĻ§ā§āϝ āĻ•āϰ⧇ āύāĻžāĨ¤ āĻāχ track āĻ•āϰ⧇, āĻ•āĻžāϰāĻŖ āĻĒāϰ⧇ āϕ⧇āω āϝ⧇ āϞāĻžāχāύāϟāĻž āϝ⧋āĻ— āĻ•āϰāĻŦ⧇, āϏ⧇āϟāĻž āĻĻ⧇āϖ⧇ āĻŽāύ⧇ āĻšāĻŦ⧇ āĻĒāĻžāĻšāĻžāϰāĻžāϰ āĻ­āĻŋāϤāϰ⧇, āĻ…āĻĨāϚ āĻĨāĻžāĻ•āĻŦ⧇ āύāĻžāĨ¤ āĻĻ⧁āχāϟāĻž āĻ…āĻ•ā§āώāϰ āϤāĻžāϰ āϤ⧁āϞāύāĻžāϝāĻŧ āϖ⧁āĻŦ āϏāĻ¸ā§āϤāĻž āĻĻāĻžāĻŽāĨ¤

  • else if āĻ•āĻŋ āφāϞāĻžāĻĻāĻž āĻāĻ•āϟāĻž keyword?

    āύāĻžāĨ¤ āĻ“āϟāĻž āĻāĻ•āϟāĻž else, āϝāĻžāϰ body āϘāϟāύāĻžāϚāĻ•ā§āϰ⧇ āφāϰ⧇āĻ•āϟāĻž ifāĨ¤ āĻĻ⧁āχāϟāĻž āĻļāĻŦā§āĻĻ āĻāĻ• āϞāĻžāχāύ⧇ āϞ⧇āĻ–āĻž āϏāĻžāϜāĻžāύ⧋āϰ āĻ…āĻ­ā§āϝāĻžāϏ āĻŽāĻžāĻ¤ā§āϰ, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž C programmer ladder-āϟāĻž āĻ“āĻ­āĻžāĻŦ⧇āχ āĻĒāĻĄāĻŧ⧇āĨ¤

  • āφāϞāĻžāĻĻāĻž āφāϞāĻžāĻĻāĻž āĻ•āϝāĻŧ⧇āĻ•āϟāĻž if āύāĻž āϞāĻŋāϖ⧇ ladder āϕ⧇āύ?

    āφāϞāĻžāĻĻāĻž statement-āϗ⧁āϞ⧋ āϏāĻŦāϗ⧁āϞ⧋āχ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻšāϝāĻŧ, āϤāĻžāχ āĻāĻ•āĻžāϧāĻŋāĻ• block āϚāϞāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ 95 āĻŽāĻžāĻ°ā§āϕ⧇āϰ āϜāĻ¨ā§āϝ āϤāĻŋāύāϟāĻž āφāϞāĻžāĻĻāĻž āĻĒāϰ⧀āĻ•ā§āώāĻž distinction, merit āφāϰ pass āϤāĻŋāύāϟāĻžāχ āĻ›āĻžāĻĒāϤāĨ¤ Ladder āĻĒā§āϰāĻĨāĻŽ āϏāĻ¤ā§āϝ āĻĒāϰ⧀āĻ•ā§āώāĻžāϤ⧇āχ āĻĨāĻžāĻŽā§‡, āϤāĻžāχ āĻ āĻŋāĻ• āĻāĻ•āϟāĻž block āϚāϞ⧇āĨ¤

  • if (x) āĻ•āĻŋ āĻšā§āĻŦāĻšā§ if (x != 0)-āĻāϰ āĻŽāϤ⧋?

    āĻšā§āϝāĻžāρ, compiler-āĻāϰ āĻ•āĻžāϛ⧇āĨ¤ "āĻ•āĻŋāϛ⧁ āφāϛ⧇ āĻ•āĻŋ" āϧāϰāύ⧇āϰ flag āĻŦāĻž āĻ—āĻŖāύāĻžāϰ āϜāĻ¨ā§āϝ āϛ⧋āϟ āϰ⧂āĻĒāϟāĻž āύāĻžāĻ“āĨ¤ āĻļā§‚āĻ¨ā§āϝāϟāĻž āϝāĻ–āύ āφāϏāϞ āĻāĻ•āϟāĻž āĻŽāĻžāύ āϝāĻžāϰ āϏāĻžāĻĨ⧇ āϤ⧁āϞāύāĻž āĻ•āϰāĻ›, āϤāĻ–āύ āϞāĻŽā§āĻŦāĻž āϰ⧂āĻĒāϟāĻž āύāĻžāĻ“āĨ¤

  • āϞāĻŽā§āĻŦāĻž ladder āĻ•āĻŋ program āϧ⧀āϰ āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧ?

    āĻāĻ–āύ āĻŽāĻžāĻĒāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āύāĻžāĨ¤ Lesson 5 āĻĻ⧇āĻ–āĻžāĻŦ⧇ GCC āĻāĻ•āϟāĻž condition āĻĨ⧇āϕ⧇ āφāϏāϞ⧇ āϕ⧀ āĻŦāĻžāύāĻžāϝāĻŧ, āφāϰ āϏ⧇āϟāĻž āĻĒā§āϰāĻžāϝāĻŧāχ source āĻĻ⧇āϖ⧇ āϝāĻž āĻŽāύ⧇ āĻšāϝāĻŧ āϤāĻžāϰ āĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽāĨ¤

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

  • if āύāĻŋāĻœā§‡āϰ body āϚāĻžāϞāĻžāϝāĻŧ āĻļ⧁āϧ⧁ condition āĻļā§‚āĻ¨ā§āϝ āύāĻž āĻšāϞ⧇āĨ¤
  • else āĻŽāĻŋāĻĨā§āϝāĻž āωāĻ¤ā§āϤāϰāϕ⧇ āύāĻŋāĻœā§‡āϰ body āĻĻ⧇āϝāĻŧ, āφāϰ āĻĻ⧁āχāϟāĻžāϰ āĻ āĻŋāĻ• āĻāĻ•āϟāĻžāχ āϚāϞ⧇āĨ¤
  • Ladder āωāĻĒāϰ āĻĨ⧇āϕ⧇ āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰ⧇, āφāϰ āĻĒā§āϰāĻĨāĻŽ āϏāĻ¤ā§āϝ condition-āĻāχ āĻĨāĻžāĻŽā§‡āĨ¤
  • Trace table āĻĻ⧇āĻ–āĻžāϝāĻŧ āϕ⧋āύ āĻĒāϰ⧀āĻ•ā§āώāĻžāϗ⧁āϞ⧋ āϚāϞāϞ; āĻāĻ• āĻĒāϰāĻŋāϏāϰ āφāϰ⧇āĻ•āϟāĻžāϕ⧇ āϧāϰ⧇ āϰāĻžāĻ–āϞ⧇ āϛ⧋āϟāϟāĻž āφāϗ⧇āĨ¤
  • Condition-āĻāϰ āĻ­āĻŋāϤāϰ⧇ āĻāĻ•āĻž = āĻŽāĻžāύ āĻŦāϏāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧ, āφāϰ Playground āĻ“āϟāĻž āύāĻŋāϝāĻŧ⧇ āϚ⧁āĻĒ āĻĨāĻžāϕ⧇āĨ¤
  • āĻĒā§āϰāϤāĻŋāϟāĻž body-āϤ⧇ brace, āĻāĻ• āϞāĻžāχāύ⧇āϰ body-āϤ⧇āĻ“āĨ¤

āĻāϰāĻĒāϰ āĻāĻ•āϟāĻž if āĻĸ⧁āĻ•āĻŦ⧇ āφāϰ⧇āĻ•āϟāĻž if-āĻāϰ āĻ­āĻŋāϤāϰ⧇, āφāϰ āĻāĻ•āϟāĻž else āϭ⧁āϞ⧇ āϝāĻžāĻŦ⧇ āĻ“ āφāϏāϞ⧇ āĻ•āĻžāϰāĨ¤

lesson ā§§ āĻļ⧇āώ

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

āĻĒāϰ⧇āϰāϟāĻž: Nested condition āφāϰ āĻā§āϞ⧇ āĻĨāĻžāĻ•āĻž else