Learn C Programming

lesson ā§Š / ā§­ ¡ āĻ•āύāĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āϟ, qualifier, āχāύāĻĒ⧁āϟ āφāϰ āφāωāϟāĻĒ⧁āϟ

Module ā§Š ¡ āĻ•āύāĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āϟ, qualifier, āχāύāĻĒ⧁āϟ āφāϰ āφāωāϟāĻĒ⧁āϟ

Printf: format specifier, width āφāϰ precision

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

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

  • āϝ⧇āϕ⧋āύ⧋ format specifier-āϕ⧇ āϚāĻžāϰāϟāĻž āφāϞāĻžāĻĻāĻž āĻ…āĻ‚āĻļ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻĄāĻŧāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ āύāĻŋāĻœā§‡ āĻāĻ•āϟāĻž āϞāĻŋāĻ–āϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤
  • Width, minus flag āφāϰ zero flag āĻĻāĻŋāϝāĻŧ⧇ āĻāĻŽāύ table āĻ›āĻžāĻĒāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ āϝāĻžāϰ āĻ•āϞāĻžāĻŽāϗ⧁āϞ⧋ āĻŽāĻŋāϞ⧇ āĻĨāĻžāϕ⧇āĨ¤
  • printf āϝāĻž āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ āϏ⧇āϟāĻž āĻ•āĻžāĻœā§‡ āϞāĻžāĻ—āĻžāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ Playground-āĻ āϭ⧁āϞ specifier āϕ⧀ āĻ•āϰ⧇ āϏ⧇āϟāĻž āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤

Amara āĻāĻ•āϟāĻž contest-āϰ leaderboard āĻ›āĻžāĻĒāϛ⧇āĨ¤ āĻ“āϰ āύāĻžāĻŽāϗ⧁āϞ⧋ āύāĻžāύāĻž āĻĻ⧈āĻ°ā§āĻ˜ā§āϝ⧇āϰ, āϤāĻžāχ solved āĻ•āϞāĻžāĻŽāϟāĻž āĻĒā§āϰāϤāĻŋ āϏāĻžāϰāĻŋāϤ⧇ āĻ…āĻ¨ā§āϝ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻļ⧁āϰ⧁ āĻšāϝāĻŧāĨ¤ āĻĒ⧁āϰ⧋ āϜāĻŋāύāĻŋāϏāϟāĻž āĻĻ⧇āĻ–āϤ⧇ āĻ•āĻžāϟāĻžāϛ⧇āρāĻĄāĻŧāĻž āϚāĻŋāĻ āĻŋāϰ āĻŽāϤ⧋āĨ¤ āĻ“ āĻŦāĻŋāĻļ āĻŽāĻŋāύāĻŋāϟ āϧāϰ⧇ āĻšāĻžāϤ⧇ āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻž āĻŦāϏāĻžāĻšā§āϛ⧇āĨ¤

āϏāĻŽāĻžāϧāĻžāύāϟāĻž āϚāĻžāϰāϟāĻž āĻ…āĻ•ā§āώāϰāĨ¤ 1972 āϏāĻžāϞ āĻĨ⧇āϕ⧇ printf-āϰ āĻ­āĻŋāϤāϰ⧇ āϛ⧋āϟ āĻāĻ•āϟāĻž āϏāĻžāϜāĻžāύ⧋āϰ āĻ­āĻžāώāĻž āφāϛ⧇, āφāϰ āĻĒā§āϰāĻžāϝāĻŧ āĻ•āĻžāωāϕ⧇āχ āĻ“āϟāĻž āĻ āĻŋāĻ•āĻŽāϤ⧋ āĻļ⧇āĻ–āĻžāύ⧋ āĻšāϝāĻŧ āύāĻžāĨ¤ āĻāχ lesson āĻ“āϟāĻž āĻ āĻŋāĻ•āĻŽāϤ⧋ āĻļ⧇āĻ–āĻžāϝāĻŧāĨ¤

Format string āĻŽāĻžāύ⧇ āĻĢ⧁āĻŸā§‹ āĻ•āϰāĻž āĻ•āĻŋāϛ⧁ āϞ⧇āĻ–āĻž

printf-āϰ āĻĒā§āϰāĻĨāĻŽ argument āĻāĻ•āϟāĻž āĻ›āĻžāρāϚāĨ¤ āĻāϰ āϏāĻŦāĻ•āĻŋāϛ⧁āχ āϝ⧇āĻŽāύ āφāϛ⧇ āϤ⧇āĻŽāύāχ āĻ›āĻžāĻĒāĻž āĻšāϝāĻŧ, āϕ⧇āĻŦāϞ % āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧁āϰ⧁ āĻšāĻ“āϝāĻŧāĻž āĻ…āĻ‚āĻļāϟāĻž āĻ›āĻžāĻĄāĻŧāĻž, āϝ⧇āϟāĻž āĻāĻ•āϟāĻž conversion specification: āĻāĻ•āϟāĻž āĻĢ⧁āĻŸā§‹, āϏāĻžāĻĨ⧇ āϏ⧇āϟāĻž āĻ­āϰāĻžāϰ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāĨ¤

Format string-āϰ āĻĒāϰ⧇āϰ āĻŽāĻžāύāϗ⧁āϞ⧋ āĻĢ⧁āĻŸā§‹āϗ⧁āϞ⧋ āĻ•ā§āϰāĻŽ āϧāϰ⧇ āĻ­āϰ⧇āĨ¤ āϚāϞāĻžāϰ āϏāĻŽāϝāĻŧ āϕ⧋āύ⧋ āϝāĻžāϚāĻžāχ āĻšāϝāĻŧ āύāĻž, āφāϰ āĻāχ āĻāĻ•āϟāĻž āĻ•āĻĨāĻž āĻĨ⧇āϕ⧇āχ āĻāχ lesson-āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϭ⧁āϞ āφāϏ⧇āĨ¤

āĻāĻ•āϟāĻž specifier, āϚāĻžāϰāϟāĻž āϐāĻšā§āĻ›āĻŋāĻ• āĻ…āĻ‚āĻļ āφāϰ āĻāĻ•āϟāĻž āĻŦāĻžāĻ§ā§āϝāϤāĻžāĻŽā§‚āϞāĻ•

%[flags][width][.precision]conversion

flags        -  āϘāϰ⧇āϰ āĻ­āĻŋāϤāϰ⧇ āĻŦāĻžāρāϝāĻŧ⧇ āϏāĻžāϜāĻžāύ⧋
             0  āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻžāϰ āĻŦāĻĻāϞ⧇ āĻļā§‚āĻ¨ā§āϝ āĻĻāĻŋāϝāĻŧ⧇ āϘāϰ āĻ­āϰāĻž
             +  āϧāύāĻžāĻ¤ā§āĻŽāĻ• āĻšāϞ⧇āĻ“ āϏāĻŦāϏāĻŽāϝāĻŧ āϚāĻŋāĻšā§āύ āĻ›āĻžāĻĒāĻž
                āĻāĻ•āϟāĻž āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻž, āϝ⧋āĻ— āϚāĻŋāĻšā§āύ⧇āϰ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻĢāĻžāρāĻ•āĻž āĻ›āĻžāĻĒāĻž

width        āĻāĻ•āϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž: āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽ āĻ•āϤ āĻ…āĻ•ā§āώāϰ āϞāĻžāĻ—āĻŦ⧇

.precision   float-āϰ āϜāĻ¨ā§āϝ, āĻĻāĻļāĻŽāĻŋāϕ⧇āϰ āĻĒāϰ⧇ āĻ•āϝāĻŧ āĻ…āĻ™ā§āĻ•
             string-āϰ āϜāĻ¨ā§āϝ, āĻŦāĻĄāĻŧāĻœā§‹āϰ āĻ•āϝāĻŧ āĻ…āĻ•ā§āώāϰ āĻ›āĻžāĻĒāĻž āĻšāĻŦ⧇

conversion   d  i  āĻāĻ•āϟāĻž signed int            u  āĻāĻ•āϟāĻž unsigned int
             ld    āĻāĻ•āϟāĻž long                  lld   āĻāĻ•āϟāĻž long long
             f     double, āĻ¸ā§āĻĨāĻŋāϰ āĻĻāĻļāĻŽāĻŋāĻ•          e  double, āĻŦ⧈āĻœā§āĻžāĻžāύāĻŋāĻ•
             g     double, āϝ⧇āϟāĻž āϛ⧋āϟ āĻšāϝāĻŧ
             c     āĻāĻ•āϟāĻž āĻ…āĻ•ā§āώāϰ                  s   āĻāĻ•āϟāĻž string
             x  X  hexadecimal, āϛ⧋āϟ āĻŦāĻž āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ
             o     octal                      p   āĻāĻ•āϟāĻž pointer
             zu    āĻāĻ•āϟāĻž size_t                %%  āĻāĻ•āϟāĻž āĻļāϤāĻžāĻ‚āĻļ āϚāĻŋāĻšā§āύ
  • āϕ⧇āĻŦāϞ % āφāϰ conversion āĻŦāĻžāĻ§ā§āϝāϤāĻžāĻŽā§‚āϞāĻ•āĨ¤ %d āĻāĻ•āϟāĻž āĻĒā§‚āĻ°ā§āĻŖ specifierāĨ¤
  • Width āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽ āĻ•āϤāϟ⧁āϕ⧁, āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ āĻ•āϤāϟ⧁āϕ⧁ āύāĻžāĨ¤ āϘāϰ⧇āϰ āĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ āĻŽāĻžāύ āĻŦāĻžāχāϰ⧇ āĻŦ⧇āϰāĻŋāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤
  • Conversion-āϰ āφāϗ⧇āϰ āĻ…āĻ•ā§āώāϰāϟāĻž āĻāĻ•āϟāĻž length modifier, āφāϰ āĻ“āϟāĻž type-āϰ āϏāĻžāĻĨ⧇ āύāĻž āĻŽāĻŋāϞāϞ⧇ āĻĒāĻĄāĻŧāĻžāϟāĻžāχ āϭ⧁āϞ āĻšāϝāĻŧāĨ¤
%-8.2f specifier-āϰ āĻĒāĻžāρāϚāϟāĻž āĻ…āĻ‚āĻļ āĻāĻ•āϟāĻž specifier, āĻŦāĻžāρ āĻĨ⧇āϕ⧇ āĻĄāĻžāύ⧇ āĻĒāĻĄāĻŧāĻž % - 8 .2 f āĻļ⧁āϰ⧁ flag width precision conversion āϏāĻŦāϏāĻŽāϝāĻŧ āĻŦāĻžāρāϝāĻŧ⧇ āϏāĻžāϜāĻžāύ⧋ āĻ…āĻ¨ā§āϤāϤ 8 2 āĻĻāĻļāĻŽāĻŋāĻ• āϘāϰ āĻāĻ•āϟāĻž double āϕ⧇āĻŦāϞ āĻĒā§āϰāĻĨāĻŽ āφāϰ āĻļ⧇āώ āϘāϰāϟāĻž āĻŦāĻžāĻ§ā§āϝāϤāĻžāĻŽā§‚āϞāĻ•āĨ¤ āĻŽāĻžāĻā§‡āϰ āϤāĻŋāύāϟāĻž āϏāĻžāϜāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻžāχ āĻŦāĻžāĻĻ āĻĻ⧇āĻ“āϝāĻŧāĻž āϝāĻžāϝāĻŧāĨ¤ printf("[%-8.2f]", 3.14159) āĻ›āĻžāĻĒ⧇ [3.14 ], āĻ•āĻžāϰāĻŖ āĻŽāĻžāύāϟāĻž āφāϗ⧇ āĻĻ⧁āχ āĻĻāĻļāĻŽāĻŋāĻ• āϘāϰ⧇ āĻ—ā§‹āϞ āĻšāϝāĻŧ, āϤāĻžāϰāĻĒāϰ āĻĄāĻžāύ āĻĻāĻŋāϕ⧇ āĻ­āϰāĻžāϟ āĻšāϝāĻŧ āϝāϤāĻ•ā§āώāĻŖ āύāĻž āϘāϰāϟāĻž āφāϟ āĻ…āĻ•ā§āώāϰ āϚāĻ“āĻĄāĻŧāĻž āĻšāϝāĻŧāĨ¤ āĻāχ āĻ•ā§āϰāĻŽā§‡ āĻ…āĻ‚āĻļāϗ⧁āϞ⧋ āĻĒāĻĄāĻŧā§‹, āϤāĻžāĻšāϞ⧇ āϕ⧋āύ⧋ specifier āφāϰ āϚāĻŽāĻ• āĻĻ⧇āĻŦ⧇ āύāĻžāĨ¤
Figure 1. āĻāĻ•āϟāĻž specifier-āϰ āĻ—āĻĄāĻŧāύāĨ¤ āĻ…āĻ‚āĻļāϗ⧁āϞ⧋āϰ āĻ•ā§āϰāĻŽ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āφāϰ āĻŽāĻžāĻā§‡āϰ āϤāĻŋāύāϟāĻž āϐāĻšā§āĻ›āĻŋāĻ•āĨ¤

Width āĻŽāĻžāύ⧇ āĻāĻ•āϟāĻž āĻŽāĻžāύ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽ āϝāϤ āϘāϰ āύ⧇āĻŦ⧇

Width āĻŽāĻžāύāϟāĻžāϕ⧇ āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻž āĻĻāĻŋāϝāĻŧ⧇ āĻ­āϰāĻžāϟ āĻ•āϰ⧇, āϝāϤāĻ•ā§āώāĻŖ āύāĻž āϘāϰāϟāĻž āĻ“āχ āϚāĻ“āĻĄāĻŧāĻž āĻšāϝāĻŧāĨ¤ Default-āĻ āĻ­āϰāĻžāϟāϟāĻž āĻŦāĻžāρ āĻĻāĻŋāϕ⧇ āĻŦāϏ⧇, āϤāĻžāχ āĻŽāĻžāύāϟāĻž āϘāϰ⧇āϰ āĻĄāĻžāύ āĻĻāĻŋāϕ⧇ āĻ—āĻŋāϝāĻŧ⧇ āĻĻāĻžāρāĻĄāĻŧāĻžāϝāĻŧāĨ¤

āĻĻ⧁āχāϟāĻž flag āĻāϟāĻž āĻŦāĻĻāϞāĻžāϝāĻŧāĨ¤ Minus āϚāĻŋāĻšā§āύ āĻ­āϰāĻžāϟāϟāĻž āĻĄāĻžāύ āĻĻāĻŋāϕ⧇ āϏāϰāĻžāϝāĻŧ, āϤāĻžāχ āĻŽāĻžāύāϟāĻž āĻŦāĻžāρāϝāĻŧ⧇ āĻŦāϏ⧇āĨ¤ Zero āĻĢāĻžāρāĻ•āĻžāϰ āĻŦāĻĻāϞ⧇ āĻļā§‚āĻ¨ā§āϝ āĻĻāĻŋāϝāĻŧ⧇ āĻ­āϰ⧇, āϝ⧇āϟāĻž āϕ⧇āĻŦāϞ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϜāĻ¨ā§āϝāχ āĻ…āĻ°ā§āĻĨāĻŦāĻšāĨ¤

#include <stdio.h>

int main(void)
{
    printf("[%d]\n", 42);
    printf("[%8d]\n", 42);
    printf("[%-8d]\n", 42);
    printf("[%08d]\n", 42);
    printf("[%+d]\n", 42);
    printf("[% d]\n", 42);
    printf("[%8.3f]\n", 3.14159);
    printf("[%-8.3f]\n", 3.14159);
    printf("[%.3s]\n", "Progsity");
    printf("[%%]\n");
    return 0;
}
[42]
[      42]
[42      ]
[00000042]
[+42]
[ 42]
[   3.142]
[3.142   ]
[Pro]
[%]

āĻ“āχ output-āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϤ⧃āϤ⧀āϝāĻŧ āĻŦāĻ¨ā§āϧāύ⧀ āĻ āĻŋāĻ• āϏ⧇āĻ–āĻžāύ⧇āχ, āϝ⧇āĻ–āĻžāύ⧇ āϘāϰāϟāĻž āĻļ⧁āϰ⧁ āφāϰ āĻļ⧇āώ āĻšāϝāĻŧāĨ¤ āĻŽāĻžāĻā§‡āϰ āĻ…āĻ•ā§āώāϰ āϗ⧁āύ⧇ āĻĻ⧇āĻ–ā§‹, āĻĒā§āϰāϤāĻŋāϟāĻž āύāĻŋāϝāĻŧāĻŽ āύāĻŋāĻœā§‡āχ āĻŦ⧁āĻāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤

āύāĻŦāĻŽ āϞāĻžāχāύāϟāĻžāχ āϚāĻŽāĻ•āĨ¤ String-āϰ āĻŦ⧇āϞāĻžāϝāĻŧ precision āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽ āύāĻž, āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ āĻ•āϤ, āϤāĻžāχ %.3s āφāϟāϟāĻžāϰ āĻŽāĻ§ā§āϝ⧇ āϤāĻŋāύāϟāĻž āĻ…āĻ•ā§āώāϰ āϛ⧇āĻĒ⧇āϛ⧇āĨ¤

āĻļ⧇āώ āϞāĻžāχāύāϟāĻž āĻšāϞ⧋ āĻļāϤāĻžāĻ‚āĻļ āϚāĻŋāĻšā§āύ āĻ›āĻžāĻĒāĻžāϰ āωāĻĒāĻžāϝāĻŧāĨ¤ āĻāĻ•āĻž āĻāĻ•āϟāĻž % specifier āĻļ⧁āϰ⧁ āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧ, āϤāĻžāχ āϤ⧁āĻŽāĻŋ āĻĻ⧁āχāϟāĻž āϞ⧇āĻ–ā§‹āĨ¤

Precision āĻĻ⧁āχ āϰāĻ•āĻŽ āϜāĻŋāύāĻŋāϏ āĻŦā§‹āĻāĻžāϝāĻŧ

Float-āĻ precision āĻŽāĻžāύ⧇ āĻĻāĻļāĻŽāĻŋāϕ⧇āϰ āĻĒāϰ⧇ āĻ•āϝāĻŧ āĻ…āĻ™ā§āĻ•, āφāϰ āĻŽāĻžāύāϟāĻž āϤāĻžāϤ⧇ āφāρāϟāĻžāϰ āϜāĻ¨ā§āϝ āĻ—ā§‹āϞ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āϟāĻžāĻ•āĻž āφāϰ āĻŽāĻžāĻĒāĻœā§‹āϕ⧇āϰ āĻĒā§āϰāĻžāϝāĻŧ āĻĒā§āϰāϤāĻŋāϟāĻž problem %.2f āĻ—āĻĄāĻŧāύāϟāĻžāχ āϚāĻžāϝāĻŧāĨ¤

String-āĻ precision āĻŽāĻžāύ⧇ āĻŦāĻĄāĻŧāĻœā§‹āϰ āĻ•āϝāĻŧāϟāĻž āĻ…āĻ•ā§āώāϰ āĻ›āĻžāĻĒāĻž āĻšāĻŦ⧇, āφāϰ āĻŦāĻžāĻ•āĻŋāϟāĻž āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧ⧇āĨ¤

Integer-āĻ precision āĻŽāĻžāύ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽ āĻ•āϝāĻŧ āĻ…āĻ™ā§āĻ•, āĻļā§‚āĻ¨ā§āϝ āĻĻāĻŋāϝāĻŧ⧇ āĻ­āϰāĻžāϟ āĻ•āϰ⧇, āϝ⧇āϟāĻž āϕ⧇āω āĻ•āĻŽāχ āϚāĻžāϝāĻŧ āφāϰ āϚāĻŋāύ⧇ āϰāĻžāĻ–āĻž āĻ­āĻžāϞ⧋āĨ¤

āϤāĻžāχ āĻāĻ•āχ āĻĻ⧁āχāϟāĻž āĻ…āĻ•ā§āώāϰ⧇āϰ āĻŽāĻžāύ⧇ āĻ—ā§‹āϞ āĻ•āϰāĻž, āϕ⧇āĻŸā§‡ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻŦāĻž āĻ­āϰāĻžāϟ āĻ•āϰāĻž, āφāϰ āϏ⧇āϟāĻž āĻ āĻŋāĻ• āĻ•āϰ⧇ āϤāĻŋāύ āϘāϰ āĻĄāĻžāύ⧇āϰ āĻāĻ•āϟāĻž āĻ…āĻ•ā§āώāϰāĨ¤

āĻŽāĻŋāϞ⧇ āĻĨāĻžāĻ•āĻž table āĻŽāĻžāύ⧇ āϕ⧇āĻŦāϞ width, āφāϰ āĻ•āĻŋāϛ⧁ āύāĻž

Amara-āϰ leaderboard-āĻ āĻĒā§āϰāϤāĻŋāϟāĻž āĻ•āϞāĻžāĻŽā§‡āϰ āĻāĻ•āϟāĻž āĻ•āϰ⧇ width āϞāĻžāĻ—āĻŦ⧇, āφāϰ āϞ⧇āĻ–āĻžāϰ āĻ•āϞāĻžāĻŽāϟāĻžāϝāĻŧ minus flag āϞāĻžāĻ—āĻŦ⧇ āϝāĻžāϤ⧇ āύāĻžāĻŽāϗ⧁āϞ⧋ āĻāĻ•āχ āϜāĻžāϝāĻŧāĻ—āĻž āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻšāϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    printf("%-14s%8s%10s\n", "PLAYER", "SOLVED", "PENALTY");
    printf("%-14s%8d%10d\n", "Amara", 9, 412);
    printf("%-14s%8d%10d\n", "Kenji", 9, 1207);
    printf("%-14s%8d%10d\n", "Zara", 7, 388);
    printf("%-14s%8d%10d\n", "Bob", 2, 44);
    return 0;
}
PLAYER          SOLVED   PENALTY
Amara                9       412
Kenji                9      1207
Zara                 7       388
Bob                  2        44

āĻāĻ•āϟāĻžāχ format string, āĻĒāĻžāρāϚāĻŦāĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻžāĨ¤ Header āϏāĻžāϰāĻŋāϤ⧇ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ•āϞāĻžāĻŽā§‡āϰ āĻļāĻŋāϰ⧋āύāĻžāĻŽā§‡āϰ āϜāĻ¨ā§āϝ %s āĻĻ⧇āĻ“āϝāĻŧāĻž, āφāϰ āĻāχ āĻ•āĻžāϰāϪ⧇āχ āĻĒāĻžāρāϚ āϞāĻžāχāύ⧇āχ width āĻŽāĻŋāϞ⧇ āϝāĻžāϝāĻŧāĨ¤

āϖ⧇āϝāĻŧāĻžāϞ āĻ•āϰ⧋, specifier-āϗ⧁āϞ⧋āϰ āĻŽāĻžāĻā§‡ āϕ⧋āύ⧋ āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻž āύ⧇āχāĨ¤ Width āφāϗ⧇āχ āĻĢāĻžāρāĻ•āϟ⧁āϕ⧁ āĻĻāĻŋāĻšā§āϛ⧇, āφāϰ āϤāĻžāϰ āϏāĻžāĻĨ⧇ āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻž āϝ⧋āĻ— āĻ•āϰāϞ⧇āχ table āĻāĻ• āĻ…āĻ•ā§āώāϰ āϏāϰ⧇ āϝāĻžāϝāĻŧāĨ¤

Printf āϤ⧋āĻŽāĻžāϕ⧇ āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ

āĻāϟāĻž āĻĒā§āϰāĻžāϝāĻŧ āϕ⧇āω āϜāĻžāύ⧇ āύāĻžāĨ¤ printf āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ āĻ“ āĻ•āϝāĻŧāϟāĻž āĻ…āĻ•ā§āώāϰ āϞāĻŋāĻ–āϞ, āφāϰ āϞ⧇āĻ–āĻž āĻŦā§āϝāĻ°ā§āĻĨ āĻšāϞ⧇ āĻāĻ•āϟāĻž āĻ‹āĻŖāĻžāĻ¤ā§āĻŽāĻ• āϏāĻ‚āĻ–ā§āϝāĻžāĨ¤

āĻŦ⧇āĻļāĻŋāϰ āĻ­āĻžāĻ— program āĻ“āϟāĻž āĻ—ā§āϰāĻžāĻšā§āϝ āĻ•āϰ⧇ āύāĻž, āφāϰ āϏ⧇āϟāĻž āĻ āĻŋāĻ• āφāϛ⧇āĨ¤ "āĻ“āχ āϞāĻžāχāύāϟāĻž āĻ•āϤ āϚāĻ“āĻĄāĻŧāĻž āĻ›āĻŋāϞ" āĻĒā§āϰāĻļā§āύ⧇āϰ āĻāϟāĻžāχ āĻ¸ā§Ž āωāĻ¤ā§āϤāϰāĨ¤ āφāϰ āĻāϟāĻž āĻāϜāĻ¨ā§āϝāĻ“ āϜāϰ⧁āϰāĻŋ āϝ⧇ āĻĒāϰ⧇āϰ lesson-āĻ scanf-āϕ⧇ āĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻžāχ āĻšāϝāĻŧ āĻĢ⧇āϰāϤ āĻĒāĻžāĻ“āϝāĻŧāĻž āĻŽāĻžāύ āĻĻāĻŋāϝāĻŧ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    int written = printf("Amara scored %d\n", 97);

    printf("that line was %d characters long\n", written);
    printf("a %%d holds %d, a %%x holds %x, a %%o holds %o\n", 255, 255, 255);
    printf("a size_t needs %%zu: %zu\n", sizeof(int));
    return 0;
}
Amara scored 97
that line was 16 characters long
a %d holds 255, a %x holds ff, a %o holds 377
a size_t needs %zu: 4

āώ⧋āϞ⧋āϟāĻž āĻ…āĻ•ā§āώāϰ: āĻšā§‹āĻĻā§āĻĻāϟāĻž āĻĻ⧇āĻ–āĻž āϝāĻžāϝāĻŧ, āϏāĻžāĻĨ⧇ newline, āϏāĻžāĻĨ⧇ 97-āϰ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āĻ…āĻ™ā§āĻ•āϟāĻžāĨ¤ āύāĻŋāĻœā§‡ āϗ⧁āύ⧇ āĻĻ⧇āĻ–ā§‹, āĻ•āĻžāϰāĻŖ āĻ“āχ āϞāĻžāχāύāϟāĻžāϰ āĻŽāĻžāύ⧇āχ āĻāϟāĻžāĨ¤

āϤ⧃āϤ⧀āϝāĻŧ āϞāĻžāχāύāϟāĻž āĻāĻ•āϟāĻž āĻŽāĻžāύ āϤāĻŋāύāϟāĻž base-āĻ āϤāĻŋāύāĻŦāĻžāϰ āĻ›āĻžāĻĒ⧇āĨ¤ Module 3-āϰ lesson 1 āĻ“āχ base-āϗ⧁āϞ⧋ literal āĻšāĻŋāϏ⧇āĻŦ⧇ āϞāĻŋāϖ⧇āĻ›āĻŋāϞ; āĻāĻ–āĻžāύ⧇ āϏ⧇āϗ⧁āϞ⧋ āφāĻŦāĻžāϰ āĻĒāĻĄāĻŧāĻž āĻšāĻšā§āϛ⧇āĨ¤

āϚāϤ⧁āĻ°ā§āĻĨāϟāĻž %zu āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āϝ⧇āϟāĻž sizeof-āϰ āĻĻ⧇āĻ“āϝāĻŧāĻž type-āϰ specifierāĨ¤ Module 2-āϰ lesson 5 āĻ“āϟāĻž āϚāĻŋāύāĻŋāϝāĻŧ⧇āĻ›āĻŋāϞ, āφāϰ āĻāϟāĻž āĻāχ āϤāĻžāϞāĻŋāĻ•āĻžāϝāĻŧ āφāϛ⧇ āĻ•āĻžāϰāĻŖ āϏ⧇āĻ–āĻžāύ⧇ %d āĻāĻŽāύ āĻāĻ•āϟāĻž āϭ⧁āϞ āϝ⧇āϟāĻž āϕ⧇āω āϧāϰāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻŦ⧇ āύāĻžāĨ¤

Specifier āφāϰ āĻŽāĻžāύ āϝāĻ–āύ āĻŽā§‡āϞ⧇ āύāĻž

Specifier printf-āϕ⧇ āĻŦāϞ⧇ āĻ•āϝāĻŧ byte āύāĻŋāϤ⧇ āĻšāĻŦ⧇ āφāϰ āϏ⧇āϗ⧁āϞ⧋ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻĒāĻĄāĻŧāϤ⧇ āĻšāĻŦ⧇āĨ¤ āĻ“āϟāĻž āϭ⧁āϞ āĻšāϞ⧇āĻ“ printf āĻ“āχ byte-āϗ⧁āϞ⧋āχ āύ⧇āϝāĻŧ āφāϰ āĻ“āĻ­āĻžāĻŦ⧇āχ āĻĒāĻĄāĻŧ⧇āĨ¤

āϝ⧇ format āϝāĻžāϚāĻžāχ āĻāϟāĻž āϧāϰ⧇ āϏ⧇āϟāĻž āĻĨāĻžāϕ⧇ -Wall-āϰ āĻĒāĻŋāĻ›āύ⧇, āφāϰ Playground compile āĻ•āϰ⧇ gcc -O2 -std=c17 -lm āĻĻāĻŋāϝāĻŧ⧇, āϕ⧋āύ⧋ -Wall āĻ›āĻžāĻĄāĻŧāĻžāĨ¤ āϤāĻžāχ Playground-āĻ āĻāχ āϧāϰāύ⧇āϰ āϭ⧁āϞ āĻāĻ•āĻĻāĻŽ āύ⧀āϰāĻŦ, compile-āϰ āϏāĻŽāϝāĻŧ⧇āĻ“ āφāϰ āϚāϞāĻžāϰ āϏāĻŽāϝāĻŧ⧇āĻ“āĨ¤

āĻāϟāĻž Playground āĻāĻĄāĻŧāĻŋāϝāĻŧ⧇ āϚāϞāĻžāϰ āĻ•āĻžāϰāĻŖ āύāĻžāĨ¤ āĻāϟāĻž āύāĻŋāĻšā§‡āϰ āϚāĻžāϰāϟāĻž āĻ…āĻŽāĻŋāϞ āĻšā§‹āϖ⧇ āϚāĻŋāύ⧇ āϰāĻžāĻ–āĻžāϰ āĻ•āĻžāϰāĻŖ, āĻ•āĻžāϰāĻŖ āĻ“āϗ⧁āϞ⧋ āϖ⧁āρāϜāϤ⧇ āϤ⧁āĻŽāĻŋ āϕ⧋āύ⧋ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻĒāĻžāĻŦ⧇ āύāĻžāĨ¤

Example 1: āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ āϏāĻžāϜāĻžāύ⧋ āϞāĻžāχāύ

āĻāĻ•āϟāĻž āĻŽāĻžāύ, āϤāĻŋāύāϟāĻž width, āϝāĻžāϤ⧇ āϘāϰ āϜāĻŋāύāĻŋāϏāϟāĻž āφāϏāϞ⧇ āϕ⧀ āϏ⧇āϟāĻž āϤ⧁āĻŽāĻŋ āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāĻ“āĨ¤

#include <stdio.h>

int main(void)
{
    int marks = 7;

    printf("|%d|\n", marks);
    printf("|%4d|\n", marks);
    printf("|%-4d|\n", marks);
    return 0;
}
|7|
|   7|
|7   |

āϤāĻŋāύ āϞāĻžāχāύ, āĻāĻ•āϟāĻž āĻŽāĻžāύāĨ¤ āĻĻāĻžāĻ—āϗ⧁āϞ⧋ āϕ⧇āĻŦāϞ āĻāϜāĻ¨ā§āϝ, āϝāĻžāϤ⧇ āϤ⧁āĻŽāĻŋ āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻž āϗ⧁āύāϤ⧇ āĻĒāĻžāϰ⧋āĨ¤

Run in Compiler
Example 2: āĻāĻ•āϟāĻž receipt, āϝ⧇āĻ–āĻžāύ⧇ precision-āχ āĻĒ⧁āϰ⧋ āĻ•āĻžāϜ

āϟāĻžāĻ•āĻž āĻĻ⧁āχ āĻĻāĻļāĻŽāĻŋāĻ• āϘāϰ⧇, āĻĒāϰāĻŋāĻŽāĻžāĻŖ āĻĄāĻžāύ⧇ āϏāĻžāϜāĻžāύ⧋, āφāϰ āύāĻžāĻŽ āĻŦāĻžāρāϝāĻŧ⧇āĨ¤ āϤ⧁āĻŽāĻŋ āϝāϤ problem āĻĒāĻžāĻŦ⧇ āϤāĻžāϰ āĻ…āĻ°ā§āϧ⧇āϕ⧇āϰ āĻ—āĻĄāĻŧāύāχ āĻāϟāĻžāĨ¤

#include <stdio.h>

int main(void)
{
    printf("%-10s%5s%10s\n", "ITEM", "QTY", "TAKA");
    printf("%-10s%5d%10.2f\n", "rice", 12, 45.00);
    printf("%-10s%5d%10.2f\n", "oil", 3, 120.50);
    printf("%-10s%5d%10.2f\n", "salt", 7, 2.50);
    printf("%-10s%5d%10.2f\n", "TOTAL", 22, 1083.50);
    return 0;
}
ITEM        QTY      TAKA
rice         12     45.00
oil           3    120.50
salt          7      2.50
TOTAL        22   1083.50

āĻĻāĻļāĻŽāĻŋāĻ• āĻŦāĻŋāĻ¨ā§āĻĻ⧁āϗ⧁āϞ⧋ āĻŽāĻŋāϞ⧇ āĻĨāĻžāϕ⧇ āĻ•āĻžāϰāĻŖ āĻ“āχ āĻ•āϞāĻžāĻŽā§‡āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻžāϰ width āφāϰ precision āĻāĻ•āĨ¤ .2 āϏāϰāĻŋāϝāĻŧ⧇ āĻĻāĻžāĻ“, āĻ•āϞāĻžāĻŽāϟāĻž āϭ⧇āϙ⧇ āĻĒāĻĄāĻŧāĻŦ⧇āĨ¤

āϏāĻ¤ā§āϝāĻŋāĻ•āĻžāϰ⧇āϰ āϟāĻžāĻ•āĻž āĻ—ā§‹āύāĻž āĻšāϝāĻŧ āĻĒā§‚āĻ°ā§āĻŖ āĻĒāϝāĻŧāϏāĻžāϝāĻŧ, Module 2-āϰ lesson 3-āϰ āύāĻŋāϝāĻŧāĻŽāĨ¤ āĻāϟāĻž āϏāĻžāϜāĻžāύ⧋āϰ āωāĻĻāĻžāĻšāϰāĻŖ, āφāϰ āĻāχ module-āϰ graded problem-āϗ⧁āϞ⧋ āϏāĻŦāχ āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤

Run in Compiler
Example 3: āĻāĻ•āχ āϏāĻ‚āĻ–ā§āϝāĻž āϚāĻžāϰ base-āĻ, āϝ⧇āϟāĻž āϤ⧁āĻŽāĻŋ āϏāĻ¤ā§āϝāĻŋāχ āϞāĻŋāĻ–āϤ⧇

āĻāĻ•āϟāĻž device āĻĨ⧇āϕ⧇ āĻĒāĻĄāĻŧāĻž āĻŽāĻžāύ, āϚāĻžāϰ āĻ­āĻžāĻŦ⧇ āĻ›āĻžāĻĒāĻž, āĻ•āĻžāϰāĻŖ āύāĻžāύāĻž āϞ⧋āĻ• āύāĻžāύāĻž āĻ­āĻžāĻŦ⧇ āϚāĻžāχāĻŦ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    unsigned int reg = 48879;

    printf("dec:%10u\n", reg);
    printf("hex:%10x\n", reg);
    printf("HEX:%10X\n", reg);
    printf("oct:%10o\n", reg);
    printf("padded hex: 0x%08X\n", reg);
    return 0;
}
dec:     48879
hex:      beef
HEX:      BEEF
oct:    137357
padded hex: 0x0000BEEF

āĻļ⧇āώ āϞāĻžāχāύāϟāĻžāχ āϏāĻŦ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ hex dump āϞ⧇āĻ–āĻžāϰ āύāĻŋāϝāĻŧāĻŽāĨ¤ 0x āϤ⧋āĻŽāĻžāϰ āϟāĻžāχāĻĒ āĻ•āϰāĻž āϞ⧇āĻ–āĻž, āφāϰ 08 āĻŽāĻžāύ āϛ⧋āϟ āĻšāϞ⧇āĻ“ āφāϟ āĻ…āĻ™ā§āĻ• āϧāϰ⧇ āϰāĻžāϖ⧇āĨ¤

Run in Compiler

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

  • āĻāχ platform-āϰ āĻĒā§āϰāϤāĻŋāϟāĻž judgeāĨ¤ Progsity-āϰ judge āϤ⧋āĻŽāĻžāϰ output āφāϰ āĻĒā§āϰāĻ¤ā§āϝāĻžāĻļāĻŋāϤ file āĻ…āĻ•ā§āώāϰ⧇ āĻ…āĻ•ā§āώāϰ⧇ āĻŽā§‡āϞāĻžāϝāĻŧāĨ¤ āĻĒāϝāĻŧāϏāĻžāϰ āĻ•āϞāĻžāĻŽā§‡ āĻāĻ•āϟāĻž āĻļā§‚āĻ¨ā§āϝ āύāĻž āĻĨāĻžāĻ•āϞ⧇āχ wrong answer, āφāϰ āϤ⧋āĻŽāĻžāϰ āφāϰ āĻ“āϟāĻžāϰ āĻŽāĻžāĻāĻ–āĻžāύ⧇ āϕ⧇āĻŦāϞ specifier-āϟāĻžāχ āĻĻāĻžāρāĻĄāĻŧāĻžāύ⧋āĨ¤
  • āϝ⧇āϕ⧋āύ⧋ Linux āĻŽā§‡āĻļāĻŋāύ⧇āϰ ls -l āϤāĻžāϞāĻŋāĻ•āĻžāĨ¤ āĻŽāĻžāĻĒ, āϤāĻžāϰāĻŋāĻ– āφāϰ āύāĻžāĻŽā§‡āϰ āĻ•āϞāĻžāĻŽāϗ⧁āϞ⧋ āĻ āĻŋāĻ• āĻāχ width āĻĻāĻŋāϝāĻŧ⧇āχ āĻ›āĻžāĻĒāĻž āĻšāϝāĻŧ, C code āĻĻāĻŋāϝāĻŧ⧇, 1971-āĻ āϞ⧇āĻ–āĻž āφāϰ āĻāĻ–āύ⧋ āϚāϞāĻž āĻāĻ•āϟāĻž program-āĻāĨ¤
  • āφāϰāĻ“ āĻĒāĻžāρāϚāϟāĻž āĻ­āĻžāώāĻžāĨ¤ Python, Java, Go, Rust āφāϰ PHP āϏāĻŦāĻžāχ āĻāχ format āĻ­āĻžāώāĻžāϰ āϏāϰāĻžāϏāϰāĻŋ āωāĻ¤ā§āϤāϰāϏ⧂āϰāĻŋ āĻŦāϝāĻŧ⧇ āĻŦ⧇āĻĄāĻŧāĻžāϝāĻŧāĨ¤ C-āϰ āϰ⧂āĻĒāϟāĻž āĻļāĻŋāĻ–āϞ⧇ āĻ“āĻĻ⧇āϰāϗ⧁āϞ⧋āĻ“ āĻāĻŽāύāĻŋāϤ⧇āχ āĻļ⧇āĻ–āĻž āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤
  • āϕ⧋āύ⧋ āĻŦā§āϝāĻžāĻ‚āϕ⧇āϰ export job-āϰ CSV writerāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϘāϰ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ precision-āĻ āĻ›āĻžāĻĒāĻž āĻšāϝāĻŧ, āϝāĻžāϤ⧇ file āĻĒāĻĄāĻŧāĻž āĻĻ⧁āχāϟāĻž system āĻļ⧇āώ āĻĒāϝāĻŧāϏāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻāĻ•āχ āϏāĻ‚āĻ–ā§āϝāĻžāϝāĻŧ āĻāĻ•āĻŽāϤ āĻĨāĻžāϕ⧇āĨ¤

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

ā§§. Specifier āϝ⧇ āĻŽāĻžāύ⧇āϰ āϏāĻžāĻĨ⧇ āĻŽā§‡āϞ⧇ āύāĻžāĨ¤

double price = 12.5;
printf("%d\n", price);

Playground-āĻ āύ⧀āϰāĻŦ, āĻ•āĻžāϰāĻŖ format āϝāĻžāϚāĻžāχ āĻĨāĻžāϕ⧇ -Wall-āϰ āĻĒāĻŋāĻ›āύ⧇ āφāϰ Playground āĻ“āϟāĻž āĻĻ⧇āϝāĻŧ āύāĻžāĨ¤ Local gcc -Wall āĻŦāϞ⧇ warning: format '%d' expects argument of type 'int', but argument 2 has type 'double' āφāϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇ %f āĻĒāϰāĻžāĻŽāĻ°ā§āĻļ āĻĻāĻŋāϝāĻŧ⧇āĨ¤ āϝ⧇ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āĻ›āĻžāĻĒāĻž āĻšāϝāĻŧ āϤāĻžāϰ āϕ⧋āύ⧋ āĻŽāĻžāύ⧇ āύ⧇āχāĨ¤

⧍. āĻĢ⧁āĻŸā§‹āϰ āĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽ āĻŽāĻžāύ āĻĻ⧇āĻ“āϝāĻŧāĻžāĨ¤

printf("marks %d and %d\n", 90);

Playground-āĻ āύ⧀āϰāĻŦāĨ¤ āĻĒā§āϰāĻĨāĻŽ āĻĢ⧁āĻŸā§‹āϟāĻž 90 āĻĒāĻžāϝāĻŧāĨ¤ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧāϟāĻž āĻĒāĻĄāĻŧ⧇ āϝāĻž āĻ•āĻŋāϛ⧁ argument-āϰ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻĒāĻĄāĻŧ⧇ āĻ›āĻŋāϞ, āϤāĻžāχ āϏ⧇āĻ–āĻžāύ⧇ āĻ…āĻ°ā§āĻĨāĻšā§€āύ āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āϭ⧇āϏ⧇ āĻ“āϠ⧇āĨ¤ -Wall āĻĻāĻŋāϞ⧇ āĻ•āĻĨāĻžāϟāĻž āĻšāϝāĻŧ warning: format '%d' expects a matching 'int' argumentāĨ¤

ā§Š. āϞ⧇āĻ–āĻžāϰ āĻŽāĻ§ā§āϝ⧇ āĻāĻ•āĻž āĻāĻ•āϟāĻž āĻļāϤāĻžāĻ‚āĻļ āϚāĻŋāĻšā§āύāĨ¤

printf("VAT is 15% of the bill\n");

Playground-āĻ āύ⧀āϰāĻŦ, āφāϰ output āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āĻ—ā§‹āϞāĻŽāĻžāϞ āĻšāϝāĻŧ āϝ⧇āϟāĻž āĻĻ⧇āϖ⧇ āĻ•āĻžāϰāĻŖāϟāĻž āφāĻ¨ā§āĻĻāĻžāϜāχ āĻ•āϰāĻž āϝāĻžāϝāĻŧ āύāĻžāĨ¤ %, āϤāĻžāϰ āĻĒāϰ⧇āϰ āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻž āφāϰ of-āϰ o, āϤāĻŋāύāϟāĻž āĻŽāĻŋāϞ⧇ āĻāĻ•āϟāĻž specifier āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻĄāĻŧāĻž āĻšāϝāĻŧ, āϤāĻžāχ āĻ“āχ āĻ…āĻ•ā§āώāϰāϗ⧁āϞ⧋ āĻšāĻžāĻ“āϝāĻŧāĻž āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ āφāϰ āϏ⧇āĻ–āĻžāύ⧇ āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āĻāϏ⧇ āĻŦāϏ⧇āĨ¤ āĻļāϤāĻžāĻ‚āĻļ āϚāĻŋāĻšā§āύ⧇āϰ āϜāĻ¨ā§āϝ %% āϞ⧇āĻ–ā§‹āĨ¤

ā§Ē. sizeof āĻŦāĻž long long-āϰ āϜāĻ¨ā§āϝ %dāĨ¤

long long total = 5000000000;
printf("%d\n", total);
printf("%d\n", sizeof(int));

Playground-āĻ āĻĻ⧁āχ āϞāĻžāχāύ⧇āχ āύ⧀āϰāĻŦāĨ¤ %d āϚāĻžāϰ byte āύ⧇āϝāĻŧ āφāϰ āĻ“āχ āĻĻ⧁āχāϟāĻž āĻŽāĻžāύāχ āφāϟ byte, āϤāĻžāχ āϝ⧇ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āĻ›āĻžāĻĒāĻž āĻšāϝāĻŧ āϏ⧇āϟāĻž āĻ“āĻĻ⧇āϰ āϭ⧁āϞ āĻ…āĻ°ā§āϧ⧇āĻ• āĻĨ⧇āϕ⧇ āĻŦāĻžāύāĻžāύ⧋āĨ¤ long long-āϰ āϜāĻ¨ā§āϝ %lld āφāϰ sizeof-āϰ āϜāĻ¨ā§āϝ %zu, āφāϰ Module 2-āϰ lesson 5 āĻĨ⧇āϕ⧇āχ āĻ“āϗ⧁āϞ⧋ āĻāϏ⧇āϛ⧇āĨ¤

āĻŽāĻžāĻĨāĻžāϰ āĻ–ā§‹āϰāĻžāĻ•

Zara āĻāĻ•āϟāĻž āĻŽāĻžāĻĒ āĻ›āĻžāĻĒāϛ⧇ āφāϰ āĻĒāĻžāρāϚ āĻ…āĻ•ā§āώāϰ⧇āϰ output āφāĻļāĻž āĻ•āϰāϛ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    printf("[%5.2f]\n", 3.14159);
    printf("[%5.2f]\n", 1234.5678);
    printf("[%.2f]\n", 3.14159);
    return 0;
}

āĻĒā§āϰāĻĨāĻŽ āϞāĻžāχāύāϟāĻž āĻ›āĻžāĻĒ⧇ [ 3.14], āϝ⧇āϟāĻž āĻĒāĻžāρāϚ āĻ…āĻ•ā§āώāϰ āϚāĻ“āĻĄāĻŧāĻž āφāϰ āϏāĻžāĻŽāύ⧇ āĻāĻ•āϟāĻž āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻžāĨ¤ āĻŽāĻžāύāϟāĻžāϝāĻŧ āϤ⧋ āĻ…āĻ™ā§āĻ• āφāϰ āĻŦāĻŋāĻ¨ā§āĻĻ⧁ āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇ āϚāĻžāϰāϟāĻžāχ āĻ…āĻ•ā§āώāϰ, āϤāĻžāĻšāϞ⧇ 5 āϕ⧀ āϗ⧁āύāϛ⧇ āϏ⧇āϟāĻž āĻŦāϞ⧋āĨ¤

āϤāĻžāϰāĻĒāϰ āĻ•āĻ āĻŋāύ āĻ…āĻ°ā§āϧ⧇āĻ•āϟāĻžāĨ¤ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āϞāĻžāχāύāϟāĻž āĻšā§āĻŦāĻšā§ āϕ⧀ āĻšāĻŦ⧇ āĻŦāϞ⧋, āφāϰ āĻŽāĻžāύ āϘāϰ⧇āϰ āĻ­āĻŋāϤāϰ⧇ āύāĻž āφāρāϟāϞ⧇ width āφāϏāϞ⧇ āϕ⧀ āĻ•āĻĨāĻž āĻĻ⧇āϝāĻŧ āϏ⧇āϟāĻž āĻŦāϞ⧋āĨ¤

3.14-āϰ āϚāĻžāϰāϟāĻž āĻ…āĻ•ā§āώāϰ āϞāĻŋāϖ⧇ āĻĢ⧇āϞ⧋ āφāϰ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧋ āĻĒāĻžāρāĻšā§‡ āĻĒ⧌āρāĻ›āĻžāϤ⧇ āφāϰ āĻ•āϝāĻŧāϟāĻž āϞāĻžāϗ⧇āĨ¤ āϤāĻžāϰāĻĒāϰ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧋, āĻāĻ•āϟāĻž āϘāϰ āĻ•āĻŋ āĻ•āĻ–āύ⧋ āϤāĻžāϰ āĻ­āĻŋāϤāϰ⧇āϰ āϜāĻŋāύāĻŋāϏ⧇āϰ āĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āĻ…āύ⧁āĻļā§€āϞāύ ā§§: hex-octal-dumpMedium

Kenji āĻāĻ•āϟāĻž device register āĻĒāĻĄāĻŧāϛ⧇ āφāϰ āĻ“āϟāĻž āϤāĻŋāύāϟāĻž base-āĻ āϚāĻžāϝāĻŧ, āĻĒā§āϰāϤāĻŋāϟāĻž āĻāĻ•āχ āĻĻāĻļ āϚāĻ“āĻĄāĻŧāĻž āϘāϰ⧇ āĻŦāϏāĻžāύ⧋āĨ¤

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

Output. āϚāĻžāϰ āϞāĻžāχāύ: dec:, hex:, HEX: āφāϰ oct:, āĻĒā§āϰāϤāĻŋāϟāĻžāϰ āĻĒāϰ⧇ n āĻāĻ•āϟāĻž 10 āϚāĻ“āĻĄāĻŧāĻž āϘāϰ⧇āĨ¤

Constraints. 0 <= n <= 4294967295, āϤāĻžāχ āĻŽāĻžāύāϟāĻžāϰ āϜāĻ¨ā§āϝ unsigned int āϞāĻžāĻ—āĻŦ⧇āĨ¤

Sample. Input 255 āĻĻāĻŋāϞ⧇ dec: 255 āφāϰ āφāϰāĻ“ āϤāĻŋāύ āϞāĻžāχāύāĨ¤

#include <stdio.h>

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

    /* Four lines, four bases, one width. */

    return 0;
}

hex-octal-dump āύāĻžāĻŽā§‡ gradedāĨ¤ Range-āϰ āĻāĻ•āĻĻāĻŽ āωāĻĒāϰ⧇ āϚāĻžāϰ āϞāĻžāχāύ⧇āϰ āĻāĻ•āϟāĻž āĻāĻ—āĻžāϰ⧋ āĻ…āĻ•ā§āώāϰ āϚāĻ“āĻĄāĻŧāĻž āĻšāϝāĻŧ, āφāϰ āϏ⧇āϟāĻžāχ āĻ āĻŋāĻ•āĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ⧍: leaderboardEasy

āωāĻĒāϰ⧇āϰ example-āϰ Amara-āϰ table āφāĻŦāĻžāϰ āĻŦāĻžāύāĻžāĻ“, āĻĒā§āϰāϤāĻŋāϟāĻž āĻ•āϞāĻžāĻŽ āϤāĻŋāύ āĻ…āĻ•ā§āώāϰ āĻ•āϰ⧇ āϚāĻ“āĻĄāĻŧāĻž āĻ•āϰ⧇āĨ¤ āĻļ⧇āώ⧇ Maria-āϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻž āϏāĻžāϰāĻŋ āϝ⧋āĻ— āĻ•āϰ⧋, 5 solved āφāϰ 91 penalty āĻĻāĻŋāϝāĻŧ⧇āĨ¤

Output. āĻ›āϝāĻŧ āϞāĻžāχāύ, header āφāϰ āĻĒāĻžāρāϚāϜāύ āϖ⧇āϞ⧋āϝāĻŧāĻžāĻĄāĻŧ, āĻĒā§āϰāϤāĻŋāϟāĻž āĻ•āϞāĻžāĻŽ āĻŽāĻŋāϞ⧇ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤

āϕ⧋āύ⧋ input āύ⧇āχāĨ¤ Copy āύāĻž āĻ•āϰ⧇ āĻĒ⧁āϰ⧋āϟāĻž āϟāĻžāχāĻĒ āĻ•āϰ⧋, āφāϰ āĻāĻ•āϟāĻž width āĻŦāĻĻāϞ⧇ āĻĻ⧇āĻ–ā§‹ table āϕ⧀āĻ­āĻžāĻŦ⧇ āϏāϰ⧇ āϝāĻžāϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    /* One format string, used six times. Start from the example above. */

    return 0;
}

āĻāχ module-āĻ graded āύāĻž: input āĻ›āĻžāĻĄāĻŧāĻž program-āϰ āĻāĻ•āϟāĻžāχ āϏāĻŽā§āĻ­āĻžāĻŦā§āϝ output, āφāϰ āĻāĻ•āϟāĻž test āϕ⧋āύ⧋ judge āύāĻžāĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ā§Š: āĻĻāĻžāĻŽā§‡āϰ āϤāĻžāϞāĻŋāĻ•āĻžMedium

āϤāĻŋāύāϟāĻž āĻĻāĻžāĻŽ āĻĻāĻļāĻŽāĻŋāĻ• āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻĄāĻŧā§‹ āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž āĻ āĻŋāĻ• āĻĻ⧁āχ āĻĻāĻļāĻŽāĻŋāĻ• āϘāϰ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻ›āĻžāĻĒā§‹, āĻĻāĻļ āϚāĻ“āĻĄāĻŧāĻž āĻāĻ•āϟāĻž āϘāϰ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻžāϰ āĻĒāϰ⧇ taka āĻļāĻŦā§āĻĻāϟāĻž āĻŦāϏāĻžāĻ“āĨ¤

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

Output. āϤāĻŋāύ āϞāĻžāχāύ, āĻĒā§āϰāϤāĻŋāϟāĻžāϝāĻŧ āĻāĻ•āϟāĻž āĻĻāĻžāĻŽ āϤāĻžāϰāĻĒāϰ āĻāĻ•āϟāĻž āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻž āϤāĻžāϰāĻĒāϰ takaāĨ¤

Sample. Input 45 120.5 2.5 āĻĻāĻŋāϞ⧇ 45.00 taka āφāϰ āφāϰāĻ“ āĻĻ⧁āχ āϞāĻžāχāύāĨ¤

#include <stdio.h>

int main(void)
{
    double a = 0.0;
    double b = 0.0;
    double c = 0.0;
    scanf("%lf %lf %lf", &a, &b, &c);

    /* Three printf calls, one width and one precision each. */

    return 0;
}

āĻāχ module-āĻ graded āύāĻžāĨ¤ āĻāχ āĻ­āĻžāĻŦāύāĻžāϰ graded āϰ⧂āĻĒāϟāĻž problem lesson-āϰ invoice-exact, āϝ⧇āϟāĻž āĻŦāĻĻāϞ⧇ āĻĒā§‚āĻ°ā§āĻŖ āĻĒāϝāĻŧāϏāĻžāϝāĻŧ āĻ—ā§‹āύ⧇āĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ā§Ē: āĻ…āĻ•ā§āώāϰ āĻ—ā§‹āύāĻžāϰ āϝāĻ¨ā§āĻ¤ā§āϰHard

āύāĻŋāĻœā§‡āϰ āĻāĻ•āϟāĻž āϞāĻžāχāύ āĻ›āĻžāĻĒā§‹, āϤāĻžāϰāĻĒāϰ āĻ›āĻžāĻĒā§‹ āĻ“āχ āϞāĻžāχāύāϟāĻž āĻ•āϝāĻŧ āĻ…āĻ•ā§āώāϰ⧇āϰ āĻ›āĻŋāϞ, printf-āϰ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻŽāĻžāύ āĻĻāĻŋāϝāĻŧ⧇, āύāĻŋāĻœā§‡ āĻ—ā§‹āύāĻž āϕ⧋āύ⧋ āϏāĻ‚āĻ–ā§āϝāĻž āĻĻāĻŋāϝāĻŧ⧇ āύāĻžāĨ¤

Output. āĻĻ⧁āχ āϞāĻžāχāύāĨ¤ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧāϟāĻž āĻŦāϞ⧇ āĻĒā§āϰāĻĨāĻŽāϟāĻž āĻ•āϤ āϞāĻŽā§āĻŦāĻž āĻ›āĻŋāϞāĨ¤

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

#include <stdio.h>

int main(void)
{
    int written = printf("Progsity Learn, C track\n");

    /* One more printf, using written. */

    return 0;
}

āĻāχ module-āĻ graded āύāĻžāĨ¤ āϤāĻžāϰāĻĒāϰ āĻ•āĻžāĻ—āĻœā§‡ āĻāϟāĻžāϰ āωāĻ¤ā§āϤāϰ āĻĻāĻžāĻ“: āĻ—ā§‹āύāĻžāϟāĻžāϝāĻŧ newline āϧāϰāĻž āφāϛ⧇ āĻ•āĻŋ āύāĻž, āφāϰ āĻ¸ā§āĻŽā§ƒāϤāĻŋāϰ āωāĻĒāϰ āĻ­āϰāϏāĻž āύāĻž āĻ•āϰ⧇ āϏ⧇āϟāĻž āϕ⧀āĻ­āĻžāĻŦ⧇ āĻĒā§āϰāĻŽāĻžāĻŖ āĻ•āϰāĻŦ⧇āĨ¤

Run in Compiler

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

  • āĻŽāĻžāύ āĻŦāĻĄāĻŧ āĻšāϞ⧇ āĻ•āĻŋ width āĻ“āϟāĻžāϕ⧇ āϕ⧇āĻŸā§‡ āĻĻ⧇āϝāĻŧ?

    āύāĻžāĨ¤ Width āϕ⧇āĻŦāϞ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽ āĻ•āϤāϟ⧁āϕ⧁āĨ¤ āϘāϰāϟāĻž āĻŽāĻžāύ⧇āϰ āĻŽāĻžāĻĒ⧇ āĻŦāĻĄāĻŧ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ āφāϰ āĻĒāϰ⧇āϰ āĻ•āϞāĻžāĻŽāϗ⧁āϞ⧋ āϏāϰ⧇ āϝāĻžāϝāĻŧāĨ¤ āĻāχ āĻ•āĻžāϰāϪ⧇āχ āĻāĻ•āϟāĻž āϞāĻŽā§āĻŦāĻž āϏāĻžāϰāĻŋāϤ⧇ table āĻ­āĻžāϙ⧇, āϏāĻŦ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āύāĻžāĨ¤

  • printf-āĻ float āφāϰ double āĻĻ⧁āχāϟāĻžāϰ āϜāĻ¨ā§āϝāχ %f āϕ⧇āύ?

    āĻ•āĻžāϰāĻŖ call-āĻ āĻĸā§‹āĻ•āĻžāϰ āĻĒāĻĨ⧇ float argument-āϟāĻž double āĻšāϝāĻŧ⧇ āϚāĻ“āĻĄāĻŧāĻž āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ scanf-āĻ āĻ•āĻŋāϛ⧁āχ āϚāĻ“āĻĄāĻŧāĻž āĻšāϝāĻŧ āύāĻž, āφāϰ āϏ⧇āϜāĻ¨ā§āϝāχ āϏ⧇āĻ–āĻžāύ⧇ āϏāĻ¤ā§āϝāĻŋāχ %lf āϞāĻžāϗ⧇āĨ¤ āϏ⧇āϟāĻžāχ āĻĒāϰ⧇āϰ lessonāĨ¤

  • %.2f āĻ•āĻŋ āĻ—ā§‹āϞ āĻ•āϰ⧇ āύāĻž āϕ⧇āĻŸā§‡ āĻĻ⧇āϝāĻŧ?

    āĻ—ā§‹āϞ āĻ•āϰ⧇āĨ¤ āĻ“ āϝ⧇āϟāĻžāϕ⧇ āĻ—ā§‹āϞ āĻ•āϰ⧇ āϏ⧇āϟāĻž double-āĻ āϜāĻŽāĻž āĻŽāĻžāύ, āφāϰ Module 2-āϰ lesson 3 āĻĻ⧇āĻ–āĻŋāϝāĻŧ⧇āĻ›āĻŋāϞ āĻ“āϟāĻž āϏāĻŦāϏāĻŽāϝāĻŧ āϤ⧋āĻŽāĻžāϰ āϟāĻžāχāĻĒ āĻ•āϰāĻž āĻŽāĻžāύ āύāĻžāĨ¤

  • Width āĻ•āĻŋ variable-āĻ āϰāĻžāĻ–āĻž āϝāĻžāϝāĻŧ?

    āϝāĻžāϝāĻŧ, āĻāĻ•āϟāĻž āϤāĻžāϰāĻž āĻĻāĻŋāϝāĻŧ⧇: printf("%*d", 8, marks) āĻĒā§āϰāĻĨāĻŽ argument āĻĨ⧇āϕ⧇ width āύ⧇āϝāĻŧāĨ¤ āĻāϟāĻž āĻ•āĻŽāχ āϞāĻžāϗ⧇, āφāϰ āĻšāĻžāϤ⧇ āϤ⧋āϞāĻžāϰ āĻšā§‡āϝāĻŧ⧇ āϚāĻŋāύ⧇ āϰāĻžāĻ–āĻžāχ āĻ•āĻžāĻœā§‡āϰāĨ¤

  • āφāĻŽāĻžāϰ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āĻ…āĻĻā§āϭ⧁āϤ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻāϏ⧇ āĻŦāϏāϛ⧇ āϕ⧇āύ?

    āĻĒā§āϰāĻžāϝāĻŧ āϏāĻŦāϏāĻŽāϝāĻŧāχ āĻ“āχ āĻāĻ•āχ string-āĻ āφāϗ⧇ āϕ⧋āĻĨāĻžāĻ“ āĻāĻ•āĻž āĻāĻ•āϟāĻž % āφāϛ⧇āĨ¤ āĻ–āĻžāϰāĻžāĻĒ specifier-āϰ āĻĒāϰ⧇āϰ āϏāĻŦāĻ•āĻŋāϛ⧁āχ āϏāϰ⧇ āϝāĻžāϝāĻŧ, āϤāĻžāχ āĻ•ā§āώāϤāĻŋāϰ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āύāĻž āϤāĻžāĻ•āĻŋāϝāĻŧ⧇ āϤāĻžāϰ āĻŦāĻžāρ āĻĻāĻŋāϕ⧇ āϤāĻžāĻ•āĻžāĻ“āĨ¤

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

  • Specifier āĻŽāĻžāύ⧇ āĻāĻ•āϟāĻž āĻļāϤāĻžāĻ‚āĻļ āϚāĻŋāĻšā§āύ, āϤāĻžāϰāĻĒāϰ flag, width āφāϰ precision, āϤāĻžāϰāĻĒāϰ āĻāĻ•āϟāĻž conversion āĻ…āĻ•ā§āώāϰāĨ¤
  • Width āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽ āĻ•āϤāϟ⧁āϕ⧁: āĻŦāĻĄāĻŧ āĻŽāĻžāύ⧇āϰ āϜāĻ¨ā§āϝ āϘāϰ āĻŦāĻžāĻĄāĻŧ⧇, āφāϰ āϕ⧋āύ⧋ āĻŽāĻžāύ āĻ•āĻ–āύ⧋ āĻ•āĻžāϟāĻž āϝāĻžāϝāĻŧ āύāĻžāĨ¤
  • Precision float āĻ—ā§‹āϞ āĻ•āϰ⧇, string āϕ⧇āĻŸā§‡ āĻĻ⧇āϝāĻŧ, āφāϰ integer-āϕ⧇ āĻļā§‚āĻ¨ā§āϝ āĻĻāĻŋāϝāĻŧ⧇ āĻ­āϰāĻžāϟ āĻ•āϰ⧇āĨ¤
  • Minus flag āĻŦāĻžāρāϝāĻŧ⧇ āϏāĻžāϜāĻžāϝāĻŧ āφāϰ zero flag āĻļā§‚āĻ¨ā§āϝ āĻĻāĻŋāϝāĻŧ⧇ āĻ­āϰ⧇; āĻĻ⧁āχāϟāĻžāχ width-āϰ āφāϗ⧇ āĻŦāϏ⧇āĨ¤
  • printf āĻ•āϝāĻŧ āĻ…āĻ•ā§āώāϰ āϞāĻŋāĻ–āϞ āϏ⧇āϟāĻž āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ, āφāϰ %% āĻāĻ•āϟāĻž āĻļāϤāĻžāĻ‚āĻļ āϚāĻŋāĻšā§āύ āĻ›āĻžāĻĒ⧇āĨ¤
  • āϭ⧁āϞ specifier Playground-āĻ āύ⧀āϰāĻŦ, āĻ•āĻžāϰāĻŖ format āϝāĻžāϚāĻžāχāϝāĻŧ⧇āϰ āϜāĻ¨ā§āϝ -Wall āϞāĻžāϗ⧇āĨ¤

āĻāϰāĻĒāϰ āϤ⧁āĻŽāĻŋ āĻĒ⧁āϰ⧋ āϜāĻŋāύāĻŋāϏāϟāĻž āωāĻ˛ā§āĻŸā§‡ āĻĻāĻŋāϝāĻŧ⧇ āĻŽāĻžāύ āĻĒāĻĄāĻŧāĻŦ⧇, āϝ⧇āĻ–āĻžāύ⧇ āĻāĻ•āχ format āĻ­āĻžāώāĻžāϰ āĻāĻ•āϟāĻž āĻŦāĻžāĻĄāĻŧāϤāĻŋ āύāĻŋāϝāĻŧāĻŽ āφāϰ āĻāĻ•āϟāĻž āĻŦāĻŋāĻ–ā§āϝāĻžāϤ āĻĢāĻžāρāĻĻ āφāϛ⧇āĨ¤

lesson ā§Š āĻļ⧇āώ

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

āĻĒāϰ⧇āϰāϟāĻž: Scanf: āĻŽāĻžāĻĨāĻž āύāĻž āĻ–āĻžāϰāĻžāĻĒ āĻ•āϰ⧇ āχāύāĻĒ⧁āϟ āύ⧇āĻ“āϝāĻŧāĻž