Skip to content

mahbuba01/Competitive-Programming-Tips

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

23 Commits
 
 
 
 

Repository files navigation

Competitive Programming (CP): Tips for Improvement in Bangla

āϏāĻŦāĻžāχāϕ⧇āχ āĻ•āĻŽā§āĻĒāĻŋāϟāĻŋāϟāĻŋāĻ­ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ā§Ÿā§‡ āĻĒā§āϰāĻŦāϞ⧇āĻŽ āĻĢ⧇āχāϏ āĻ•āϰāϤ⧇ āĻšā§Ÿ, āĻāĻŽāύ āϕ⧇āω āύ⧇āχ āϝ⧇ āĻāχ āĻĒā§āϰāĻŦāϞ⧇āĻŽāϟāĻž āĻĢ⧇āχāϏ āĻ•āϰ⧇ āύāĻžāĨ¤

  1. āĻāĻ•āϟāĻž āĻĒā§āϰāĻļā§āύ āϏāĻŦāĻžāϰ-āχ āĻĨāĻžāϕ⧇ āϝ⧇ āĻ•āĻŋāĻ­āĻžāĻŦ⧇ Cp āϤ⧇ āĻ­āĻžāϞ⧋ āĻ•āϰāĻŦā§‹ ? -> Practice! Practice! Practice! āĻ•āĻŽā§āĻĒāĻŋāϟāĻŋāϟāĻŋāĻ­ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ā§Ÿā§‡ āĻ­āĻžāϞ⧋ āĻ•āϰāĻžāϰ āϏāĻ°ā§āĻŦā§‹āĻ¤ā§āϤāĻŽ āωāĻĒāĻžāϝāĻŧ āύāĻŋāϝāĻŧāĻŽāĻŋāϤ āĻ…āύ⧁āĻļā§€āϞāύ āĻ•āϰāĻžāĨ¤ āĻĒā§āϰāϤāĻŋāĻĻāĻŋāύ āĻ…āĻ¨ā§āϤāϤ ⧍-ā§Š āϟāĻž āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻžāϰ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰāĻž āωāϚāĻŋāϤāĨ¤ Current Ratings āϝāĻĻāĻŋ "x" āĻšā§Ÿ, āϤāĻžāĻšāϞ⧇ {x+100 to x+300} Ratings āĻāϰ āĻĒā§āϰāĻŦāϞ⧇āĻŽāϗ⧁āϞ⧋ āϏāϞāĻ­ āĻ•āϰāĻž āωāϚāĻŋāϤāĨ¤ āϰ⧇āϗ⧁āϞāĻžāϰ āĻ•āύāĻŸā§‡āĻ¸ā§āϟ āϗ⧁āϞ⧋āϤ⧇ āĻ…āĻ‚āĻļ āĻ¨ā§‡ā§ŸāĻž āωāϚāĻŋāϤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āϝāĻĻāĻŋ āϰ⧇āϟāĻŋāĻ‚āϏ āĻŦāĻžāĻœā§‡ āφāϏ⧇ āĻ…āĻĨāĻŦāĻž āύ⧇āϗ⧇āϟāĻŋāĻ­ āĻšā§Ÿā§‡ āϝāĻžā§Ÿ āϤāĻžāĻšāϞ⧇āĻ“ Continue āĻ•āϰāϤ⧇ āĻšāĻŦ⧇ āĻāĻŦāĻ‚ āϝ⧇ āĻĒā§āϰāĻŦāϞ⧇āĻŽāϗ⧁āϞ⧋ āĻāĻ•āϟ⧁āϰ āϜāĻ¨ā§āϝ āϏāϞāĻ­ āĻšā§Ÿ āύāĻŋ, āϏ⧇āϗ⧁āϞ⧋ āφāĻŦāĻžāϰ⧋ Try āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤ āϏāϞāĻ­ āĻ•āϰāϤ⧇ āĻ—āĻŋāϝāĻŧ⧇ āϘāĻ¨ā§āϟāĻžāϰ āĻĒāϰ āϘāĻ¨ā§āϟāĻž āĻ…āĻĨāĻŦāĻž āĻĻāĻŋāύ⧇āϰ āĻĒāϰ āĻĻāĻŋāύ āφāϟāϕ⧇ āĻĨāĻžāĻ•āϞ⧇āĻ“ āĻšāϤāĻžāĻļ āĻšāĻ“āϝāĻŧāĻžāϰ āĻ•āĻŋāϛ⧁ āύ⧇āχ, āĻāϟāĻž āϏāĻŦāĻžāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇āχ āĻšā§ŸāĨ¤ (āφāĻŽāĻŋ āύāĻŋāĻœā§‡āĻ“ āĻāĻ•āĻŦāĻžāϰ āĻāĻ•āϟāĻž Hard Problem ā§§ āĻŽāĻžāϏ āϏāĻŽā§Ÿ āύāĻŋā§Ÿā§‡ āϏāϞāĻ­ āĻ•āϰ⧇āĻ›āĻŋāϞāĻžāĻŽ)

  2. āĻāĻŽāύ āĻ…āύ⧇āϕ⧇āχ āφāϛ⧇ āϝāĻžāϰāĻž āĻĒā§āϰāĻŦāϞ⧇āĻŽāϟāĻžāχ āĻŦ⧁āĻāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž, āĻāĻ–āύ āĻĒā§āϰāĻŦāϞ⧇āĻŽ āĻŦ⧁āĻāϤ⧇ āύāĻž āĻĒāĻžāϰāϞ⧇ āĻ•āĻŋ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇ ? -> āĻĒā§āϰāĻŦāϞ⧇āĻŽāϗ⧁āϞ⧋ āϝ⧇āĻšā§‡āϤ⧁ āχāĻ‚āϞāĻŋāĻļ⧇ āĻĨāĻžāϕ⧇ āϤāĻžāχ āύāĻž āĻŦ⧁āĻāϤ⧇ āĻĒāĻžāϰāĻžāϰ āĻāϟāĻžāĻ“ āĻāĻ•āϟāĻž āĻ•āĻžāϰāĻŖ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāϜāĻ¨ā§āϝ āĻĒā§āϰāĻĨāĻŽ āĻĒā§āϰāĻĨāĻŽ āĻĒā§āϰāϤāĻŋāĻĻāĻŋāύāχ āĻ•āĻŋāϛ⧁ āĻĒā§āϰāĻŦāϞ⧇āĻŽ āĻĒ⧜āĻžāϰ āĻ…āĻ­ā§āϝāĻžāϏ āĻ•āϰāϞ⧇ āĻŦ⧇āϟāĻžāϰāĨ¤ āĻĒ⧇āχāύ āϖ⧇āϞ⧇āĻ“ āĻāĻ•āϟ⧁ āϧ⧈āĻ°ā§āĻ¯ā§āϝ āύāĻŋā§Ÿā§‡ āĻāχ āĻ•āĻžāϜāϗ⧁āϞ⧋ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤

  3. āĻāĻŦāĻžāϰ āφāϰ āĻāĻ•āϟāĻŋ āĻĒā§āϰāĻļā§āύ āĻĒā§āϰāĻžā§Ÿ āĻ…āύ⧇āϕ⧇āϰāχ āĻĨāĻžāϕ⧇ āϝ⧇ āϕ⧋āύ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻ˛ā§āϝāĻžāĻ‚āĻ—ā§ā§Ÿā§‡āϜ āĻĻāĻŋā§Ÿā§‡ āĻ•āĻŽā§āĻĒāĻŋāϟāĻŋāϟāĻŋāĻ­ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻ•āϰāĻž āωāϚāĻŋāϤ ? -> āĻ…āĻŦāĻļā§āϝāχ C++ āĻ•āĻžāϰāĻŖ āĻāϟāĻž āĻ—āϤāĻŋ āĻāĻŦāĻ‚ āĻĻāĻ•ā§āώāϤāĻžāϰ āϜāĻ¨ā§āϝ āĻŦ⧇āĻ¸ā§āϟāĨ¤ āĻĒā§āϰāϤāĻŋāϝ⧋āĻ—āĻŋāϤāĻžāĻŽā§‚āϞāĻ• āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚āϝāĻŧ⧇ āϏāĻŽāϝāĻŧ āĻāĻŦāĻ‚ āĻŽā§‡āĻŽā§‹āϰāĻŋāϰ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž āĻ­ā§€āώāĻŖ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āϏ⧇āĻ–āĻžāύ⧇ C++ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻŦ⧁āĻĻā§āϧāĻŋāĻŽāĻžāύ⧇āϰ āĻ•āĻžāϜāĨ¤ āĻŦāĻŋāĻļ⧇āώāĻ•āϰ⧇ C++ āĻāϰ STL āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻžāϰāĻĻ⧇āϰ āĻĻā§āϰ⧁āϤ āĻāĻŦāĻ‚ āφāϰāĻ“ āĻĻāĻ•ā§āώāϤāĻžāϰ āϏāĻžāĻĨ⧇ āϕ⧋āĻĄ āϞāĻŋāĻ–āϤ⧇ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āĻ•āϰ⧇āĨ¤ āĻ…āύ⧇āϕ⧇āχ "Python" Prefer āĻ•āϰ⧇, āφāĻŽāĻŋ āύāĻŋāĻœā§‡āĻ“ āĻ•āϰāĻŋ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĒāĻžāχāĻĨāύ⧇āϰ āϧ⧀āϰāĻ—āϤāĻŋ āĻ…āύ⧇āĻ• āϏāĻŽā§Ÿāχ āĻ•āĻ¨ā§āĻŸā§‡āĻ¸ā§āĻŸā§‡āϰ āϜāĻ¨ā§āϝ āĻŦ⧇āĻļ āĻ…āϏ⧁āĻŦāĻŋāϧāĻžāϜāύāĻ• āĻšā§Ÿā§‡ āĻĻāĻžāρ⧜āĻžā§ŸāĨ¤

  4. āĻāĻŦāĻžāϰ āφāϏāĻŋ āϕ⧋āĻĨāĻžā§Ÿ Practice āĻ…āĻĨāĻŦāĻž Contest āĻ•āϰāĻŦā§‹ ? Beecrowd, HackerRank, Codeforces, Codechef, AtCoder, LeetCode: Beginner to Advance, āϕ⧇ āϕ⧋āύ Online Judge āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻĒā§āϰāĻŦāϞ⧇āĻŽ āϏāϞāĻ­ āĻāĻŦāĻ‚ Cp āĻ•āϰāĻŦ⧇āύ ? -> āĻŦāĻŋāĻ—āĻŋāύāĻžāϰ āϟ⧁ āĻāĻĄāĻ­āĻžāĻ¨ā§āϏāĻĄ, āϏāĻŋāϰāĻŋ⧟āĻžāϞāĻŋ āĻŦāϞāĻž āĻšāϞ⧋āσ

4.1. Beecrowd (Former name URI): āϝāĻžāϰāĻž āĻāϕ⧇āĻŦāĻžāϰ⧇āχ āĻĒā§āϰāĻŦāϞ⧇āĻŽ āϏāϞāĻ­āĻŋāĻ‚ āĻĒāĻžāϰ⧇āύ āύāĻž āĻ…āĻĨāĻŦāĻž āĻĒā§āϰāĻŦāϞ⧇āĻŽāϟāĻžāχ āĻŦ⧁āĻāϤ⧇ āĻĒāĻžāϰ⧇āύ āύāĻž, āĻĒā§āϰāĻŦāϞ⧇āĻŽ āĻŦ⧁āĻāϤ⧇ āĻĒ⧇āχāύ āϞāĻžāϗ⧇ āϤāĻžāĻšāϞ⧇ āϤāĻžāĻĻ⧇āϰ āϜāĻ¨ā§āϝ Beecrowd.

4.2. HackerRank: Practice āĻāϰ āϜāĻ¨ā§āϝ HackerRank āĻŦ⧇āĻ¸ā§āϟ āĻŦ⧇āĻ¸ā§āϟ āĻŦ⧇āĻ¸ā§āϟ! āϝāĻžāϰāĻž āĻŽā§‹āϟāĻžāĻŽā§āϟāĻŋ āĻāĻ•āϟ⧁ āĻ­āĻžāϞ⧋ āĻĒā§āϰāĻŦāϞ⧇āĻŽ āϏāϞāĻ­āĻŋāĻ‚ āĻĒāĻžāϰ⧇āύ āĻ…āĻĨāĻŦāĻž āĻĒā§āϰāĻŦāϞ⧇āĻŽ āĻŦ⧁āĻāϤ⧇ āĻ…āϏ⧁āĻŦāĻŋāϧāĻž āĻšā§Ÿ āύāĻž āϤāĻžāĻšāϞ⧇ āĻāϟāĻž āϤāĻžāĻĻ⧇āϰ āϜāĻ¨ā§āϝāĨ¤

4.3. Codeforces, Codechef, AtCoder: āĻ•āύāĻŸā§‡āĻ¸ā§āϟ āĻāϰ āϜāĻ¨ā§āϝ āĻāχ āϤāĻŋāύāϟāĻŋ āĻ“ā§Ÿā§‡āĻŦāϏāĻžāχāϟ āĻŦ⧇āĻ¸ā§āϟāĨ¤ āĻĒā§āϰāĻŦāϞ⧇āĻŽ āϏāϞāĻ­āĻŋāĻ‚ Practice āĻ•āϰ⧇ āϤāĻžāϰāĻĒāϰ Cp āĻļ⧁āϰ⧁ āĻ•āϰ⧇ āĻĻā§‡ā§ŸāĻž āωāϚāĻŋāϤ āĻāĻŦāĻ‚ āĻ•āύāĻŸā§‡āĻ¸ā§āĻŸā§‡ āϰ⧇āϟāĻŋāĻ‚āϏ āϝāϤ⧋āχ āĻŦāĻžāĻœā§‡ āφāϏ⧁āĻ•, āϤāĻŦ⧁āĻ“ āĻ•āύāĻŸā§‡āĻ¸ā§āϟāϗ⧁āϞ⧋ Continue āĻ•āϰāĻž āωāϚāĻŋāϤāĨ¤

4.4. LeetCode: Practice, Contest, Interview Prep -> āϏāĻŦ āĻāĻ•āϏāĻžāĻĨ⧇ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āύ, All in One.

  1. āĻ•āĻŽā§āĻĒāĻŋāϟāĻŋāϟāĻŋāĻ­ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āϕ⧇āύ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ ? -> āĻāϟāĻž āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āĻĻāĻ•ā§āώāϤāĻž, āϝ⧌āĻ•ā§āϤāĻŋāĻ• āϝ⧁āĻ•ā§āϤāĻŋ āĻāĻŦāĻ‚ āĻŦāĻžāĻ•ā§āϏ⧇āϰ āĻŦāĻžāχāϰ⧇ āϚāĻŋāĻ¨ā§āϤāĻžāĻ­āĻžāĻŦāύāĻž āĻŦ⧃āĻĻā§āϧāĻŋ āĻ•āϰāϤ⧇ āϏāĻšāĻžāϝāĻŧāϤāĻž āĻ•āϰ⧇āĨ¤ āϜāĻŦ⧇āϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇āĻ“ āϕ⧋āĻĄāĻŋāĻ‚ āχāĻ¨ā§āϟāĻžāϰāĻ­āĻŋāĻ‰ā§Ÿā§‡āϰ āϜāĻ¨ā§āϝ āĻŦ⧇āĻļ āĻŦ⧜ āĻāĻ•āϟāĻž āĻ…āĻŦāĻĻāĻžāύ āϰāĻžāϖ⧇āĨ¤ āϏāĻžāĻĨ⧇ āφāĻ¤ā§āĻŽāĻŦāĻŋāĻļā§āĻŦāĻžāϏ āĻŦāĻžāĻĄāĻŧāĻžāϝāĻŧ āĻ•āĻžāϰāĻŖ āĻšā§āϝāĻžāϞ⧇āĻžā§āϜāĻŋāĻ‚ āϏāĻŽāĻ¸ā§āϝāĻžāϗ⧁āϞ⧋ āϏāĻĢāϞāĻ­āĻžāĻŦ⧇ āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āφāĻ¤ā§āĻŽāĻŦāĻŋāĻļā§āĻŦāĻžāϏ āĻ…āύ⧇āĻ•āϟāĻžāχ āĻ—ā§āϰ⧋ āĻ•āϰ⧇āĨ¤

  2. āϝāĻžāϰāĻž Debugging āĻ•āϰāϤ⧇āĻ“ āĻšāĻŋāĻŽāĻļāĻŋāĻŽ āĻ–āĻžā§Ÿ, āϤāĻžāĻĻ⧇āϰ āĻ•āĻŋ āĻ•āϰāĻž āωāϚāĻŋāϤ ? -> Practice! Practice! Practice! āĻŦ⧇āĻļāĻŋ āĻĒā§āĻ°ā§āϝāĻžāĻ•āϟāĻŋāϏ āύāĻž āĻ•āϰāĻžāϰ āĻĢāϞ⧇ āĻ…āύ⧇āĻ• āĻ…āĻ­āĻŋāĻœā§āĻž āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻžāϰāϰāĻž āĻ“ āĻĄāĻŋāĻŦāĻžāĻ—āĻŋāĻ‚ā§Ÿā§‡ āĻĻ⧁āĻ°ā§āĻŦāϞ āĻĨāĻžāϕ⧇, That's why Practice More!

Simple Tips: āφāĻŽāĻŋ āϕ⧋āĻĄā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āϭ⧁āϞ āϏāĻŋāϞ⧇āĻ•ā§āϟ āĻ•āϰāĻžāϰ āϏāĻŽā§Ÿ āϕ⧋āĻĄ āωāĻĒāϰ āĻĨ⧇āϕ⧇ āύāĻŋāĻšā§‡, āĻāĻ­āĻžāĻŦ⧇ āύāĻž āĻĒā§œā§‡ āωāĻ˛ā§āĻŸā§‹āĻ­āĻžāĻŦ⧇ āĻĒā§œā§‡ Debugging āĻ•āϰāĻŋāĨ¤ (āϏāĻŦāĻžāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āĻĒā§āϰāϝ⧋āĻœā§āϝ āύāĻžāĻ“ āĻšāϤ⧇ āĻĒāĻžāϰ⧇)

DSA for Competitive Programming (CP):

  1. DSA Foundations: Time & Space Complexity Analysis, Recursion, Divide & Conquer. (Essential for understanding the efficiency & structure of algorithms)

  2. Basic DSA: Arrays, Stack, Queue, Binary Search, Sorting, Hashing, Two pointers, Backtracking.

  3. Intermediate DSA: String Manipulation, Bit Manipulation, Greedy, Set, Map (Hash Map, Tree Map), Heap (Priority Queue), Graph (DFS, BFS, Shortest Paths), Disjoint Set (Union-Find). (Crucial for solving more complex problems & optimizing solutions)

  4. Advanced DSA: DP, Game Theory, Tries, Segment Trees, Fenwick Trees (Binary Indexed Trees), Suffix Tree, Suffix Array, Heavy-Light Decomposition, Graph Coloring, Network Flow (Max Flow/Min Cut), Sqrt Decomposition.

Become good at solving math problems in CP (Math for CP)

  1. Fundamentals:

    • Binary Exponentiation
    • Euclidean Algorithm (GCD, LCM)
  2. Prime Numbers:

    • Sieve of Eratosthenes
    • Prime Factorization
    • Miller-Rabin Primality Test
  3. Number Theory:

    • Euler's Totient Function
    • Fermat's Little Theorem
    • Wilson's Theorem
    • Modular Inverse (using Fermat’s Little Theorem & Extended Euclidean Algorithm)
    • Number of Divisors / Sum of Divisors
    • Mobius Function
  4. Modular Arithmetic:

    • Chinese Remainder Theorem
    • Exponentiation by Squaring
  5. Linear Algebra:

    • Matrix Multiplication and Inversion
    • Vectors, Eigenvalues, and Eigenvectors
  6. Geometry:

    • Basics: Points, Lines, Circles, Distance, Angles
    • Computational Geometry: Convex Hull, Line Intersection
    • Coordinate Geometry: Point-Line Relationship, Polygon Area, Point in Polygon
    • Misc. Geometry: Orientation, Circle Intersection
  7. Combinatorics:

    • Permutations, Combinations
    • Binomial Theorem & Coefficients
    • Pigeonhole Principle (used in distribution and arrangement problems)
    • Stars & Bars
    • Inclusion-Exclusion Principle
    • Lucas' Theorem (rare but useful)
  8. Probability:

    • Basics
    • Expected Values (1D & 2D)
  9. Misc/Miscellaneous:

    • Fast Fourier Transform (FFT)
    • Polynomial Multiplication
    • Random Number Generation
    • Line Sweep

Understanding the error codes:

  1. Compilation Error (CE): Your program didn't get compiled successfully. Common reasons like Syntax Error, Missing Imports, Using restricted functionalities.

  2. Wrong Answer (WA): Your program ran successfully but returned a different output. Common reasons like Incorrect interpretation of problem, Incorrect solution, Bug in the code, Edge cases(multiple test cases).

  3. Time Limit Exceeded (TLE): Your program didn't complete execution in the alloted time. Your program gets a predefined time limit for every test case. Common reasons like Solution isn't optimal, Infinite Loop.

  4. Memory Limit Exceeded (MLE): Your program tried to allocate more memory. Common reasons like Declaring large arrays/lists, Adding a lot of data, Stack Overflow Error.

5.1. Runtime Error (SIGSEGV/Segmentation Fault): Your program tried to access or write to a memory that, it can't access or is invalid. Common reasons like Accessing array/string index outside its range, Using too much memory in some languages, Uninitialized/Incorrectly initialized pointers.

5.2. Runtime Error (SIGFPE): Your program encountered a floating-point error. Generally caused if you do an invalid math operation. Common reasons like Division by zero, Square Root/Log of negative numbers.

5.3. Runtime Error (SIGABRT): Your program aborted the program due to fatal error. Common reason like Using assert/abort in the code.

5.4. Runtime Error (NZEC/Non-Zero Error Code): Your program didn't return a zero-error code from the main method & didn't fall into any of the above buckets. Common reasons like Not returning 0 from main method, Not catching exceptions.

  1. Presentation Error (PE): Your program ran successfully & and the output's correct but the output format's incorrect. Normally due to "a missing space, newline, an extra space or newline."

Time Complexity:

In problem-solving, TLE (Time Limit Exceeded) means the program took too long to run within the allotted time. To understand when and where to use different types of algorithms, you need to understand the algorithm's time complexity. Time complexity is primarily about calculating how much time an algorithm takes to run, which helps compare multiple solutions to a problem.

Here are some common Time Complexities:

  1. O(1): Constant Time Complexity

The algorithm's runtime doesn't depend on the input size n, it always performs a constant number of operations.

  1. O(log n): Logarithmic Time Complexity

The runtime grows logarithmically relative to the input size n, typical of algorithms that divide the problem size in half at each step. (like Binary Search)

  1. O(n): Linear Time Complexity

The runtime increases linearly with the input size n, this's common in algorithms that iterate through each element of an array or list.

  1. O(n log n): Linearithmic Time Complexity

The runtime grows in proportion to n multiplied by the logarithm of n, this's often seen in efficient sorting algorithms. (like Merge & Quick Sort)

  1. O(n^2): Quadratic Time Complexity

The runtime is proportional to the square of the input size n, typical of algorithms with nested iterations over the input. (like Bubble, Selection & Insertion Sort)

  1. O(n^3): Cubic Time Complexity

The runtime grows with the cube of the input size n, occurring when there're three nested loops iterating over the input.

  1. O(2^n): Exponential Time Complexity

The runtime grows exponentially with the input size n, this's common in algorithms that solve problems by exploring all subsets or combinations. (like Brute-force)

  1. O(n!): Factorial Time Complexity

The runtime grows factorial with the input size n, typically seen in algorithms that generate permutations or combinations of a set.

  1. O(sqrt(n)): Square Root Time Complexity

This complexity occurs in algorithms where operations are performed up to the square root of the input size n, it's less common but can appear in certain mathematical algorithms or optimizations.

How to calculate algorithms time complexity:

  1. Identify the basic operations performed by the algorithm.

  2. Count the number of times each operation is executed in terms of the input size n.

  3. Express this count as a mathematical function of n.

  4. Simplify the function to focus on the term with the largest growth rate.

  5. Use "Big O Notation" to describe the asymptotic upper bound of the algorithm's time complexity.

Newbie to Candidate Master (CM): Ratings [0-1900]

Topics:

  1. Brute Force, Searching.
  2. Sorting (Language Library Function)
  3. Strings
  4. Number Theory like Floor, Ceil, Modulo, Divisors, Factorization.
  5. Time Complexity
  6. STL (Language Library)
  7. Binary Search
  8. Two Pointers
  9. Binary + Bitwise Stuff
  10. DP
  11. Combinatorics
  12. Prefix Sums (Basic Range Queries)
  13. Modular Arithmetic, GCD/LCM, Prime Factor Rep.
  14. Recursion
  15. Graphs, Trees
  16. DSU/UFDS
  17. Segment Trees
  18. String Algorithms (Hashing)
  19. Proofs
  20. Constructive Algorithms
  21. Combinatorial Techniques, Probability, Expected Value.
  22. Game Theory
  23. Advanced Graph Techniques like Shortest paths, MST.

āĻĄāĻžāϝāĻŧāύāĻžāĻŽāĻŋāĻ• āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚: Bitmask DP

Suppose āĻāĻ•āϟāĻž āĻĒā§āϰāĻŦāϞ⧇āĻŽā§‡ ā§ĢāϟāĻž āφāχāĻŸā§‡āĻŽ āĻĻ⧇āϝāĻŧāĻž āφāϛ⧇, āĻĒā§āϰāĻ¤ā§āϝ⧇āĻ•āϟāĻžāϰ āĻāĻ•āϟāĻž Weight & Value āφāϛ⧇āĨ¤ āĻ•āĻŋāϛ⧁ āφāχāĻŸā§‡āĻŽ āύ⧇āϝāĻŧāĻž āϝāĻžāϝāĻŧ āφāĻŦāĻžāϰ āĻ•āĻŋāϛ⧁ āĻŦāĻžāĻĻ āĻĻ⧇āϝāĻŧāĻž āϝāĻžāϝāĻŧāĨ¤ āϟāĻžāĻ°ā§āϗ⧇āϟ Total Weight ā§§ā§Ļ āĻāϰ āύāĻŋāĻšā§‡ āϰ⧇āϖ⧇ Max Value āĻŦ⧇āϰ āĻ•āϰāĻžāĨ¤ āĻāϟāĻž āĻ…āύ⧇āĻ•āϟāĻž āĻ•ā§āϞāĻžāϏāĻŋāĻ• Knapsack āĻāϰ āĻŽāϤ⧋ āĻļā§‹āύāĻžāϞ⧇āĻ“, āĻāĻ–āĻžāύ⧇ Twist āĻšāĻšā§āϛ⧇: āϕ⧋āύ āϕ⧋āύ āφāχāĻŸā§‡āĻŽ āĻ…āϞāϰ⧇āĻĄāĻŋ āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧ⧇āϛ⧇ āϏ⧇āϟāĻž Track āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤ āĻ•ā§āϞāĻžāϏāĻŋāĻ• Knapsack āĻāϰ O(N × W) āĻāϰ āϤ⧁āϞāύāĻžāϝāĻŧ āĻāϟāĻž āĻŦ⧇āĻļāĻŋ Complex āĻ•āĻŋāĻ¨ā§āϤ⧁ Bitmask DP āϛ⧋āϟ N āĻāϰ āϜāĻ¨ā§āϝ āĻŦ⧇āĻļāĻŋ Flexible.

āĻāĻ–āύ āĻāϟāĻž āϏāϞāĻ­ āĻ•āϰāϤ⧇ āĻ—āĻŋāϝāĻŧ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž āφāχāĻŸā§‡āĻŽā§‡āϰ āϜāĻ¨ā§āϝ āϞ⧁āĻĒ āϚāĻžāϞāĻŋāϝāĻŧ⧇ āĻāĻ•āϟāĻž āĻ…ā§āϝāĻžāϰ⧇ āĻĻāĻŋāϝāĻŧ⧇ Track āĻ•āϰāĻž āĻšāϞ⧇ āϕ⧋āĻĄā§‡āϰ āϟāĻžāχāĻŽ āĻ•āĻŽāĻĒā§āϞ⧇āĻ•ā§āϏāĻŋāϟāĻŋ āĻŦ⧇āĻĄāĻŧ⧇ āϝāĻžāĻŦ⧇ āĻāĻŦāĻ‚ Complex āĻšāϝāĻŧ⧇ āϝāĻžāĻŦ⧇āĨ¤ āφāϰ āϝāĻĻāĻŋ āφāχāĻŸā§‡āĻŽā§‡āϰ āϏāĻ‚āĻ–ā§āϝāĻž ⧍ā§Ļ āĻāϰ āĻŦ⧇āĻļāĻŋ āĻšāϝāĻŧ āϤāĻžāĻšāϞ⧇ TLE āĻ–āĻžāĻ“āϝāĻŧāĻžāϰ āϚāĻžāĻ¨ā§āϏ āφāϛ⧇, āφāϰ āĻāĻ–āĻžāύ⧇āχ Bitmask DP comes to the rescue!

★ Bitmask DP āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇?

āĻāĻ•āϟāĻž Integer āĻāϰ āĻŦāĻŋāϟ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻĒ⧁āϰ⧋ āĻ¸ā§āĻŸā§‡āϟ āϰāĻŋāĻĒā§āϰ⧇āĻœā§‡āĻ¨ā§āϟ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤ Suppose ā§ĢāϟāĻž āφāχāĻŸā§‡āĻŽ āφāϛ⧇, āϤāĻžāĻšāϞ⧇ āĻāĻ•āϟāĻž ā§Ģ āĻŦāĻŋāĻŸā§‡āϰ āϏāĻ‚āĻ–ā§āϝāĻž āĻĻāĻŋāϝāĻŧ⧇ āĻŸā§āĻ°ā§āϝāĻžāĻ• āĻ•āϰāĻž āϝāĻžāĻŦ⧇ āϝ⧇ āϕ⧋āύāϟāĻž āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧ⧇āϛ⧇ āφāϰ āϕ⧋āύāϟāĻž āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧāύāĻŋāĨ¤ Example:

  1. 00000 āĻŽāĻžāύ⧇ āĻ•āĻŋāϛ⧁āχ āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧāύāĻŋāĨ¤
  2. 10100 āĻŽāĻžāύ⧇ ⧍ āύāĻ‚ & ā§Ē āύāĻ‚ āφāχāĻŸā§‡āĻŽ āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧ⧇āϛ⧇āĨ¤
  3. 11111 āĻŽāĻžāύ⧇ āϏāĻŦāϗ⧁āϞ⧋ āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧ⧇āϛ⧇āĨ¤

āĻāĻ–āύ DP āĻ¸ā§āĻŸā§‡āϟ āĻšāĻŦ⧇: dp[mask][weight] (2D āĻ…ā§āϝāĻžāϰ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϞ⧇), āϝ⧇āĻ–āĻžāύ⧇ mask āĻšāĻšā§āϛ⧇ āĻŦāĻ°ā§āϤāĻŽāĻžāύ⧇ āϕ⧋āύ āφāχāĻŸā§‡āĻŽāϗ⧁āϞ⧋ āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧ⧇āϛ⧇āĨ¤ Recursion āĻĻāĻŋāϝāĻŧ⧇ āĻāϟāĻž āϏāϞāĻ­ āĻ•āϰāĻž āϝāĻžāĻŦ⧇āĨ¤

Suppose āφāχāĻŸā§‡āĻŽāϗ⧁āϞ⧋:

  1. Item 0: Weight 2, Value 3
  2. Item 1: Weight 3, Value 4
  3. Item 2: Weight 4, Value 5
  4. Item 3: Weight 1, Value 2
  5. Item 4: Weight 5, Value 6

Here, Total Weight āϞāĻŋāĻŽāĻŋāϟ ā§§ā§Ļ.

āĻāĻ–āĻžāύ⧇ dp[mask] āĻĻāĻŋāϝāĻŧ⧇ Max Value āĻ¸ā§āĻŸā§‹āϰ āĻ•āϰāĻž āĻšāĻŦ⧇āĨ¤ Bitmask DP āϤ⧇ āϏāĻžāϧāĻžāϰāĻŖāϤ dp[mask] (1D āĻ…ā§āϝāĻžāϰ⧇) āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ, āϝāĻĻāĻŋ weight āĻŸā§āĻ°ā§āϝāĻžāĻ• āĻ•āϰāϤ⧇ āĻšāϝāĻŧ āϤāĻžāĻšāϞ⧇ dp[mask][weight] āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤

  1. mask = 00001 (Item 0): Weight 2, Value 3
  2. mask = 00010 (Item 1): Weight 3, Value 4
  3. mask = 00100 (Item 2): Weight 4, Value 5
  4. mask = 01000 (Item 3): Weight 1, Value 2
  5. mask = 10000 (Item 4): Weight 5, Value 6
  6. mask = 00011 (Item 0 + Item 1): Weight (2+3)=5, Value (3+4)=7
  7. mask = 00101 (Item 0 + Item 2): Weight (2+4)=6, Value (3+5)=8
  8. mask = 01001 (Item 0 + Item 3): Weight (2+1)=3, Value (3+2)=5
  9. mask = 11001 (Item 0 + Item 1 + Item 4): Weight (2+3+5)=10, Value (3+4+6)=13
  10. mask = 01100 (Item 2 + Item 3): Weight (4+1)=5, Value (5+2)=7

Here, Max Value 13 (āϝāĻ–āύ Item 0, 1 & 4 āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧ)

āϕ⧋āĻĄā§‡ āĻāϟāĻž āϰāĻŋāĻ•āĻžāĻ°ā§āϏāĻŋāĻ­āϞāĻŋ āĻšā§‡āĻ• āĻ•āϰāϤ⧇ āĻšāĻŦ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž āĻŦāĻŋāĻŸā§‡āϰ āϜāĻ¨ā§āϝ - āϕ⧋āύāϟāĻž āύ⧇āϝāĻŧāĻž āĻšāĻŦ⧇ & āϕ⧋āύāϟāĻž āύ⧇āϝāĻŧāĻž āĻšāĻŦ⧇ āύāĻžāĨ¤ āĻāϟāĻž āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Bitwise Operation āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāϝāĻŧāĨ¤ āϝ⧇āĻŽāύ: āϕ⧋āύ⧋ āφāχāĻŸā§‡āĻŽ i āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧ⧇āϛ⧇ āĻ•āĻŋāύāĻž āĻšā§‡āĻ• āĻ•āϰāϤ⧇ "mask & (1 << i)", āϝāĻĻāĻŋ ā§Ļ āĻšāϝāĻŧ āϤāĻžāĻšāϞ⧇ āϐ āφāχāĻŸā§‡āĻŽ āĻāĻ–āύ⧋ āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧāύāĻŋāĨ¤ āύāϤ⧁āύ āφāχāĻŸā§‡āĻŽ i āϝ⧋āĻ— āĻ•āϰāϤ⧇ "mask | (1 << i)", āĻāϟāĻž mask āĻ i āϤāĻŽ āĻŦāĻŋāϟāϕ⧇ ā§§ āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧāĨ¤

★ Complexity Analysis

Bitmask DP āϤ⧇ N āϟāĻŋ āφāχāĻŸā§‡āĻŽ āĻĨāĻžāĻ•āϞ⧇ 2^N āϏāĻ‚āĻ–ā§āϝāĻ• subset (mask) āϏāĻŽā§āĻ­āĻŦāĨ¤

Total States: 2^N Each State Process Time: O(N) Total Complexity: O(N × 2^N)

āϝ⧇āĻšā§‡āϤ⧁, 2^20 approx 10^6 āϤāĻžāχ N = 20 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻāϟāĻž Efficiently āϚāϞāĻŦ⧇ āĻ•āĻŋāĻ¨ā§āϤ⧁ N > 25 āĻšāϞ⧇ TLE āĻ–āĻžāĻ“ā§ŸāĻžāϰ āϏāĻŽā§āĻ­āĻžāĻŦāύāĻž āĻŦ⧇āĻļāĻŋ!

Programming Contests:

NHSPC, BdOI, IOI, APIO, IUPC, NCPC, ACM ICPC, Meta Hacker Cup, ACM ICFP, NGPC.

  1. NHSPC: For high school and college students, Polytechnic first & second year.
  2. BdOI, APIO, IOI: For school and college students. Language (IOI)-> â€ĸ For the past sessions (till 2015): C, C++, Pascal. â€ĸ But (Since 2017): C++, Java, Pascal.
  3. NCPC, IUPC, ICPC Dhaka Regional > ICPC Asia West > ICPC World Final - You can't participate in the same year: in more than 2 teams and "at more than 2 regionals.(for Asia)"
  4. Meta Hacker Cup: Open to everyone, consists of three rounds: Qualification, Elimination, and Final.
  5. ACM ICFP: Virtual coding contest, any programming language can be used.
  6. NGPC: For female students in high school, college, and university. Rules similar to ICPC.

Note: Google Code Jam, Hash Code, Kick Start, and TCO (Topcoder Open) contests are no longer held.

Extra: āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻāϰ āĻ•āĻŋāϛ⧁ Interesting āϜāĻŋāύāĻŋāϏ

  1. Turing Completeness: āϝ⧇āĻ–āĻžāύ⧇ āĻāĻ•āϟāĻŋ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻ˛ā§āϝāĻžāĻ‚āϗ⧁āϝāĻŧ⧇āϜ āĻĻāĻŋā§Ÿā§‡ āϏāĻŦ āĻ•āĻŋāϛ⧁ Automate āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤ āĻŽāĻžāύ⧇ āĻāĻ•āϟāĻŋ āĻ˛ā§āϝāĻžāĻ‚āϗ⧁āϝāĻŧ⧇āϜ āĻĻāĻŋā§Ÿā§‡ āϏāĻŦ āϧāϰāύ⧇āϰ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻž āϝāĻžāϝāĻŧ (solve any complex computation problem if provided with enough memory & time)

  2. Quine: Quine āύāĻŋāĻœā§‡āϰ āϕ⧋āĻĄāϕ⧇ āφāωāϟāĻĒ⧁āϟ āĻšāĻŋāϏ⧇āĻŦ⧇ Print āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻāχ āϧāϰāύ⧇āϰ āϕ⧋āĻĄ āϞ⧇āĻ–āĻž Challenging (takes no input & produces a copy of its own source code as its only output)

  3. Algo-Trading: āĻ¸ā§āϟāĻ• āĻŽāĻžāĻ°ā§āϕ⧇āĻŸā§‡āϰ āϜāĻ¨ā§āϝ āĻ…ā§āϝāĻžāϞāĻ—āϰāĻŋāĻĻāĻŽ āϞāĻŋāϖ⧇ āĻ…āĻŸā§‹āĻŽā§‡āĻŸā§‡āĻĄ Trade āĻ•āϰāĻž āĻšā§ŸāĨ¤ āĻāĻ–āĻžāύ⧇ āϕ⧋āĻĄ Real-Time Data āύāĻŋā§Ÿā§‡ āϜāϟāĻŋāϞ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύāĻŋāϤ⧇ āĻĒāĻžāϰ⧇, āϝāĻž āĻŽāĻžāύ⧁āώ⧇āϰ āĻšā§‡ā§Ÿā§‡ āĻ…āύ⧇āĻ• Fast. (possible to make money with algo-trading)

  4. Sorting Algorithms Art: āĻ•āĻŋāϛ⧁ Sorting āĻ…ā§āϝāĻžāϞāĻ—āϰāĻŋāĻĻāĻŽ Like QuickSort, MergeSort āϕ⧇ āĻāĻ•āϟāĻŋ āφāĻ°ā§āϟāĻ“ā§ŸāĻžāĻ°ā§āĻ• āĻšāĻŋāϏ⧇āĻŦ⧇ Visualize āĻ•āϰāĻž āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻ­āĻŋāĻœā§āϝ⧁⧟āĻžāϞāĻžāχāĻœā§‡āĻļāύ⧇ āĻ…ā§āϝāĻžāϞāĻ—āϰāĻŋāĻĻāĻŽā§‡āϰ āφāϚāϰāĻŖ āĻ•āĻŋāĻ­āĻžāĻŦ⧇ Data Sort āĻ•āϰ⧇ āϏ⧇āϟāĻž āĻĻ⧇āĻ–āĻž āϝāĻžāĻŦ⧇, Interesting āύāĻž āĻŦā§āϝāĻžāĻĒāĻžāϰāϟāĻž ??

  5. Recursive Art: āϰāĻŋāĻ•āĻžāĻ°ā§āϏāĻŋāĻ­ āĻĢāĻžāĻ‚āĻļāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĻ“ Visual Art āϤ⧈āϰāĻŋ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤ Notable Example: Fractal Geometry(āĻĢā§āĻ°ā§āϝāĻžāĻ•ā§āϟāĻžāϞ āĻœā§āϝāĻžāĻŽāĻŋāϤāĻŋ); āϝ⧇āĻ–āĻžāύ⧇ āϞ⧁āĻĒ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻāĻ•āϟāĻŋ āĻĒā§āϝāĻžāϟāĻžāĻ°ā§āύ āĻŦāĻžā§œāĻžāϤ⧇ āĻŦāĻžā§œāĻžāϤ⧇ āϜāϟāĻŋāϞ āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤ ○ Base case: Simplest form of the problem that has a direct answer. ○ Recursive case: The step where you break the problem into a smaller, self-similar task.

  6. Polyglot Programming: āϝ⧇āĻ–āĻžāύ⧇ āĻāĻ•āϟāĻŋ āϕ⧋āĻĄ āĻāĻ•āĻžāϧāĻŋāĻ• āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻ˛ā§āϝāĻžāĻ‚āϗ⧁āϝāĻŧ⧇āĻœā§‡ Run āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ (the same code can work properly in different languages)

Example: āĻāĻ•āϟāĻŋ āϕ⧋āĻĄ āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āϞ⧇āĻ–āĻž āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āϝāĻž Python, JS, Ruby āĻŦāĻž āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āĻ­āĻžāώāĻžāϝāĻŧ āĻāĻ•āχāĻ­āĻžāĻŦ⧇ Run āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ Interesting āύāĻž āĻŦā§āϝāĻžāĻĒāĻžāϰāϟāĻž?? ★ But: Polyglot āϕ⧋āĻĄ create āĻ•āϰāĻž āϖ⧁āĻŦ āĻ•āĻ āĻŋāύ āĻ•āĻžāϰāĻŖ āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻ­āĻžāώāĻžāϰ Syntax & Structure Maintain āĻ•āϰāϤ⧇ āĻšā§Ÿ; āϝāĻž āϏāĻŦ āĻ­āĻžāώāĻžā§Ÿ āĻāĻ•āχāĻ­āĻžāĻŦ⧇ Match āĻšāϝāĻŧ āύāĻžāĨ¤ āϤāĻžāχ āĻāĻ•āĻžāϧāĻŋāĻ• āĻ­āĻžāώāĻžā§Ÿ āϕ⧋āĻĄāϟāĻŋ Run āĻ•āϰāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ Carefully āϕ⧋āĻĄ āϞāĻŋāĻ–āϤ⧇ āĻšā§ŸāĨ¤

  1. Easter Eggs in Code: āĻ…āύ⧇āĻ• āϏāĻĢāϟāĻ“āϝāĻŧā§āϝāĻžāϰ āĻŦāĻž āϕ⧋āĻĄā§‡ āĻĄā§‡āϭ⧇āϞāĻĒāĻžāϰāϰāĻž āχāĻšā§āĻ›āĻž āĻ•āϰ⧇ āĻ•āĻŋāϛ⧁ Secret/Funny āĻĢāĻŋāϚāĻžāϰ, āĻŽā§‡āϏ⧇āϜ āϰ⧇āϖ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻāϗ⧁āϞ⧋ āφāϏāϞ⧇ Surprise Plan!!

Examples:

7.1. Google āĻāϰ "Do a Barrel Roll": āϗ⧁āĻ—āϞ⧇ āĻāϟāĻž āϞāĻŋāϖ⧇ āϏāĻžāĻ°ā§āϚ āĻĻāĻŋāϞ⧇, āϏāĻžāĻ°ā§āϚ āĻĒ⧇āϜāϟāĻŋ 360 āĻĄāĻŋāĻ—ā§āϰāĻŋ āϘ⧁āϰ⧇ āϝāĻžāϝāĻŧāĨ¤

7.2. Chrome Dino Game: āχāĻ¨ā§āϟāĻžāϰāύ⧇āϟ āĻ•āĻžāύ⧇āĻ•āĻļāύ āύāĻž āĻĨāĻžāĻ•āϞ⧇ āĻāĻ•āϟāĻŋ āĻĄāĻžāχāύ⧋āϏāϰ Game āĻĻ⧇āĻ–āĻž āϝāĻžāϝāĻŧ āϝāĻž Key Press āĻ•āϰāϞ⧇ āĻļ⧁āϰ⧁ āĻšāϝāĻŧāĨ¤

7.3. Excel 95 āĻāϰ "Flight Simulator": āĻāĻ•ā§āϏ⧇āϞ⧇āϰ Old āĻ­āĻžāĻ°ā§āϏāύ⧇ Hidden Flight Simulator āĻ›āĻŋāϞāĨ¤

(these're mainly added as fun elements to entertain users, spark curiosity & encourage them to explore the software further)

  1. Genetic Algorithms: āĻāχ āĻ…ā§āϝāĻžāϞāĻ—āϰāĻŋāĻĻāĻŽ "Evolution(āĻĒā§āϰāĻ•ā§ƒāϤāĻŋāϰ āĻŦāĻŋāĻŦāĻ°ā§āϤāύ)" āϧāĻžāϰāĻŖāĻž āĻĨ⧇āϕ⧇ āĻ…āύ⧁āĻĒā§āϰāĻžāĻŖāĻŋāϤ, āϝāĻž "Survival of the Fittest" āϧāĻžāϰāĻŖāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤ āϝ⧇āĻ–āĻžāύ⧇ āϏāĻŽāĻ¸ā§āϝāĻž āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āϜāĻ¨ā§āϝ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϏāĻŽā§āĻ­āĻžāĻŦā§āϝ-āϏāĻŽāĻžāϧāĻžāύ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ āĻŦ⧇āĻ¸ā§āϟ āϟāĻž āϏāĻŋāϞ⧇āĻ•ā§āϟ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āφāϰ āĻāĻ­āĻžāĻŦ⧇āχ āĻāχ āĻ…ā§āϝāĻžāϞāĻ—āϰāĻŋāĻĻāĻŽ āĻĒāĻ°ā§āϝāĻžāϝāĻŧāĻ•ā§āϰāĻŽā§‡ Better Solution āϖ⧁āρāĻœā§‡ āĻŦ⧇āϰ āĻ•āϰāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤

  2. Code Golf: āϕ⧋āĻĄāĻŋāĻ‚ āĻĻāĻ•ā§āώāϤāĻž āĻāĻŦāĻ‚ āϏ⧃āϜāύāĻļā§€āϞāϤāĻžāϰ āĻĒāϰ⧀āĻ•ā§āώāĻž (āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻšā§āϝāĻžāϞ⧇āĻžā§āϜ); āϝ⧇āĻ–āĻžāύ⧇ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāϜ āĻ•āϰāϤ⧇, āϏāĻŦāĻšā§‡ā§Ÿā§‡ āĻ•āĻŽ āϕ⧋āĻĄ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻ•āĻžāϜāϟāĻŋ āĻ•āϰāĻžāϰ āĻ•ā§ŒāĻļāϞ āϖ⧁āρāĻœā§‡ āĻŦ⧇āϰ āĻ•āϰāϤ⧇ āĻšā§ŸāĨ¤ ★ āϕ⧋āĻĄā§‡āϰ āĻĻ⧈āĻ°ā§āĻ˜ā§āϝ āϝāϤ āĻ•āĻŽ āĻšāĻŦ⧇, āϤāϤ āĻŦ⧇āĻļāĻŋ āĻ¸ā§āϕ⧋āϰ āĻĒāĻžāĻ“ā§ŸāĻž āϝāĻžā§ŸāĨ¤

  3. Esoteric Programming Languages: āϝāĻž āĻŽāϜāĻžāϰ āωāĻĻā§āĻĻ⧇āĻļā§āϝ⧇ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧ, āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ āύāϝāĻŧāĨ¤ āĻāϏāĻŦ āĻ­āĻžāώāĻžāϰ āϕ⧋āĻĄ āϏāĻžāϧāĻžāϰāĻŖāϤ āϜāϟāĻŋāϞ, āĻ…āĻ¸ā§āĻŦāĻžāĻ­āĻžāĻŦāĻŋāĻ• āĻāĻŦāĻ‚ āĻ…āĻĻā§āϭ⧁āϤāĻ­āĻžāĻŦ⧇ āĻĄāĻŋāϜāĻžāχāύ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻāϗ⧁āϞ⧋ āĻšā§āϝāĻžāϞ⧇āĻžā§āϜ āĻ—ā§āϰāĻšāĻŖāĻ•āĻžāϰ⧀ āĻŦā§āϝāĻ•ā§āϤāĻŋāĻĻ⧇āϰ āϜāĻ¨ā§āϝ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšā§ŸāĨ¤

Examples:

10.1. LOLCODE: āϕ⧋āĻĄ āϞ⧇āĻ–āĻžāϰ āĻ¸ā§āϟāĻžāχāϞ "meme" āĻāϰ āĻŽāϤ⧋; āϝ⧇āĻ–āĻžāύ⧇ āϕ⧋āĻĄ āĻšāĻžāĻ¸ā§āϝāĻ•āϰāĻ­āĻžāĻŦ⧇ āϞ⧇āĻ–āĻž āĻšā§ŸāĨ¤

10.2. Shakespeare: āĻāχ āĻ­āĻžāώāĻžāϝāĻŧ āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āϕ⧋āĻĄ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ; āϝ⧇āĻ–āĻžāύ⧇ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāϟāĻŋ āĻāĻ•āϟāĻŋ āύāĻžāϟāϕ⧇āϰ āĻ¸ā§āĻ•ā§āϰāĻŋāĻĒā§āĻŸā§‡āϰ āĻŽāϤ⧋ āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤ āϕ⧋āĻĄā§‡āϰ āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏ āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āĻĄāĻŋāϜāĻžāχāύ āĻ•āϰāĻž āĻšāϝāĻŧ āϝ⧇ āϤāĻž āĻĻ⧇āĻ–āϤ⧇ āĻ…āύ⧇āĻ•āϟāĻž āĻļ⧇āĻ•ā§āϏāĻĒāĻŋāϝāĻŧāĻžāϰ⧇āϰ āύāĻžāϟāϕ⧇āϰ āĻŽāϤ⧋ āĻŽāύ⧇ āĻšāϝāĻŧāĨ¤

10.3. Piet: āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻ­āĻžāώāĻž; āϝāĻž āĻ›āĻŦāĻŋāϰ āĻŽāϤ⧋ āϕ⧋āĻĄ āϞ⧇āϖ⧇, āϝ⧇āĻ–āĻžāύ⧇ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāϟāĻŋ āĻĻ⧃āĻļā§āϝāĻŽāĻžāύāĻ­āĻžāĻŦ⧇ āĻāĻ•āϧāϰāύ⧇āϰ āĻ›āĻŦāĻŋāϰ āφāĻ•āĻžāϰ⧇ āĻĨāĻžāϕ⧇āĨ¤

  1. Concurrency & Parallelism: āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚āϝāĻŧ⧇ āĻ•āύāĻ•āĻžāϰ⧇āĻ¨ā§āϏāĻŋ āĻāĻŦāĻ‚ āĻĒā§āϝāĻžāϰāĻžāϞ⧇āϞāĻŋāϜāĻŽ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϞ⧇ āĻāĻ•āϏāĻžāĻĨ⧇ āĻ…āύ⧇āĻ• āĻ•āĻžāϜ āĻ•āϰāĻž āϝāĻžāϝāĻŧ, āϝāĻž āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡āϰ āĻ•āĻžāĻ°ā§āϝāĻ•ā§āώāĻŽāϤāĻž āĻ…āύ⧇āĻ• āĻŦāĻžā§œāĻŋā§Ÿā§‡ āĻĻā§‡ā§ŸāĨ¤ ★ Concurrency's about "dealing with" lots of things at once. Parallelism's about "doing" lots of things at once.

About

Tips for improvement, resources, DSA, math, verdicts, time complexity, ratings, contest, interesting things

Topics

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published