98:I[903690,["/chat-static/_next/static/immutable/chunks/3di3wd_v8ubwv.js","/chat-static/_next/static/immutable/chunks/1y2bsbsbyxhrd.js","/chat-static/_next/static/immutable/chunks/0s13a2j9-r_7z.js","/chat-static/_next/static/immutable/chunks/0lyxw0nk-7-p_.js","/chat-static/_next/static/immutable/chunks/2836u6jwf9bgv.js","/chat-static/_next/static/immutable/chunks/3ktygcwrvju41.js","/chat-static/_next/static/immutable/chunks/3npdfuq6kuky8.js","/chat-static/_next/static/immutable/chunks/3xgcz543a20n9.js","/chat-static/_next/static/immutable/chunks/2ks2dvr47nqsg.js","/chat-static/_next/static/immutable/chunks/0wp9iyt7gqj9c.js","/chat-static/_next/static/immutable/chunks/03w_e6mqufrhn.js","/chat-static/_next/static/immutable/chunks/3su8b9kn4mbaa.js","/chat-static/_next/static/immutable/chunks/2sp-yda0t06bm.js","/chat-static/_next/static/immutable/chunks/06-mpaxkl_qww.js","/chat-static/_next/static/immutable/chunks/2v1ytxhjawdqw.js","/chat-static/_next/static/immutable/chunks/3vhx3fg583u19.js","/chat-static/_next/static/immutable/chunks/3bon2sery8l35.js","/chat-static/_next/static/immutable/chunks/3jcppue8tkzp-.js","/chat-static/_next/static/immutable/chunks/0iy9i8p65rpg9.js","/chat-static/_next/static/immutable/chunks/2r3778mxx4zx3.js","/chat-static/_next/static/immutable/chunks/0sxli_t5tjx17.js","/chat-static/_next/static/immutable/chunks/00hu8fdgh1j4v.js","/chat-static/_next/static/immutable/chunks/0ggiln07qpg3x.js","/chat-static/_next/static/immutable/chunks/3fsx833y_862p.js","/chat-static/_next/static/immutable/chunks/362eoze68z3tj.js","/chat-static/_next/static/immutable/chunks/30xbirk075f9u.js","/chat-static/_next/static/immutable/chunks/2s3rmbgvk5alc.js","/chat-static/_next/static/immutable/chunks/022gnoebsh94r.js","/chat-static/_next/static/immutable/chunks/2pqzsqlo20uhj.js","/chat-static/_next/static/immutable/chunks/24oxen36r-7_-.js","/chat-static/_next/static/immutable/chunks/21nzp1fdul4xe.js","/chat-static/_next/static/immutable/chunks/3flb8mtnjv-7y.js","/chat-static/_next/static/immutable/chunks/0_0cjja_qg_5n.js","/chat-static/_next/static/immutable/chunks/27kqtemkm6wc0.js","/chat-static/_next/static/immutable/chunks/3_po9f1i65xl2.js","/chat-static/_next/static/immutable/chunks/286-_7hvrlp96.js","/chat-static/_next/static/immutable/chunks/296p94gz62u7b.js","/chat-static/_next/static/immutable/chunks/04a8jfjv6v0qb.js","/chat-static/_next/static/immutable/chunks/1etiboqt-76vo.js","/chat-static/_next/static/immutable/chunks/2n2cl3ur75prf.js","/chat-static/_next/static/immutable/chunks/1r05hdbmn7x54.js","/chat-static/_next/static/immutable/chunks/3onxldbrh6ob_.js","/chat-static/_next/static/immutable/chunks/0o-tvqrw-60f9.js","/chat-static/_next/static/immutable/chunks/3-364ma1v8dxe.js","/chat-static/_next/static/immutable/chunks/37c02pbgwkg5r.js","/chat-static/_next/static/immutable/chunks/1elbuzr4anjh-.js","/chat-static/_next/static/immutable/chunks/0mn-dmkxxrk86.js","/chat-static/_next/static/immutable/chunks/2rhujd4vukzvn.js","/chat-static/_next/static/immutable/chunks/3k-_ftam8_83e.js","/chat-static/_next/static/immutable/chunks/01enxheexz0xq.js","/chat-static/_next/static/immutable/chunks/3iwjjn69p6vc6.js","/chat-static/_next/static/immutable/chunks/1s22lwokbrj5q.js","/chat-static/_next/static/immutable/chunks/408m_6lxo2us-.js"],"ExplicitChatIdProvider"] 99:I[838238,["/chat-static/_next/static/immutable/chunks/3di3wd_v8ubwv.js","/chat-static/_next/static/immutable/chunks/1y2bsbsbyxhrd.js","/chat-static/_next/static/immutable/chunks/0s13a2j9-r_7z.js","/chat-static/_next/static/immutable/chunks/0lyxw0nk-7-p_.js","/chat-static/_next/static/immutable/chunks/2836u6jwf9bgv.js","/chat-static/_next/static/immutable/chunks/3ktygcwrvju41.js","/chat-static/_next/static/immutable/chunks/3npdfuq6kuky8.js","/chat-static/_next/static/immutable/chunks/3xgcz543a20n9.js","/chat-static/_next/static/immutable/chunks/2ks2dvr47nqsg.js","/chat-static/_next/static/immutable/chunks/0wp9iyt7gqj9c.js","/chat-static/_next/static/immutable/chunks/03w_e6mqufrhn.js","/chat-static/_next/static/immutable/chunks/3su8b9kn4mbaa.js","/chat-static/_next/static/immutable/chunks/2sp-yda0t06bm.js","/chat-static/_next/static/immutable/chunks/06-mpaxkl_qww.js","/chat-static/_next/static/immutable/chunks/2v1ytxhjawdqw.js","/chat-static/_next/static/immutable/chunks/3vhx3fg583u19.js","/chat-static/_next/static/immutable/chunks/3bon2sery8l35.js","/chat-static/_next/static/immutable/chunks/3jcppue8tkzp-.js","/chat-static/_next/static/immutable/chunks/0iy9i8p65rpg9.js","/chat-static/_next/static/immutable/chunks/2r3778mxx4zx3.js","/chat-static/_next/static/immutable/chunks/0sxli_t5tjx17.js","/chat-static/_next/static/immutable/chunks/00hu8fdgh1j4v.js","/chat-static/_next/static/immutable/chunks/0ggiln07qpg3x.js","/chat-static/_next/static/immutable/chunks/3fsx833y_862p.js","/chat-static/_next/static/immutable/chunks/362eoze68z3tj.js","/chat-static/_next/static/immutable/chunks/30xbirk075f9u.js","/chat-static/_next/static/immutable/chunks/2s3rmbgvk5alc.js","/chat-static/_next/static/immutable/chunks/022gnoebsh94r.js","/chat-static/_next/static/immutable/chunks/2pqzsqlo20uhj.js","/chat-static/_next/static/immutable/chunks/24oxen36r-7_-.js","/chat-static/_next/static/immutable/chunks/21nzp1fdul4xe.js","/chat-static/_next/static/immutable/chunks/3flb8mtnjv-7y.js","/chat-static/_next/static/immutable/chunks/0_0cjja_qg_5n.js","/chat-static/_next/static/immutable/chunks/27kqtemkm6wc0.js","/chat-static/_next/static/immutable/chunks/3_po9f1i65xl2.js","/chat-static/_next/static/immutable/chunks/286-_7hvrlp96.js","/chat-static/_next/static/immutable/chunks/296p94gz62u7b.js","/chat-static/_next/static/immutable/chunks/04a8jfjv6v0qb.js","/chat-static/_next/static/immutable/chunks/1etiboqt-76vo.js","/chat-static/_next/static/immutable/chunks/2n2cl3ur75prf.js","/chat-static/_next/static/immutable/chunks/1r05hdbmn7x54.js","/chat-static/_next/static/immutable/chunks/3onxldbrh6ob_.js","/chat-static/_next/static/immutable/chunks/0o-tvqrw-60f9.js","/chat-static/_next/static/immutable/chunks/3-364ma1v8dxe.js","/chat-static/_next/static/immutable/chunks/37c02pbgwkg5r.js","/chat-static/_next/static/immutable/chunks/1elbuzr4anjh-.js","/chat-static/_next/static/immutable/chunks/0mn-dmkxxrk86.js","/chat-static/_next/static/immutable/chunks/2rhujd4vukzvn.js","/chat-static/_next/static/immutable/chunks/3k-_ftam8_83e.js","/chat-static/_next/static/immutable/chunks/01enxheexz0xq.js","/chat-static/_next/static/immutable/chunks/3iwjjn69p6vc6.js","/chat-static/_next/static/immutable/chunks/1s22lwokbrj5q.js","/chat-static/_next/static/immutable/chunks/408m_6lxo2us-.js"],"SWRDataProvider"] 9b:[] 9c:[["b_SCP3oZo9Sy1",null],["b_eBRoAAxkBra",null],["b_DCfegdL6nDK",null]] 9d:[["b_SCP3oZo9Sy1",{"templateVersionId":null,"templateCanonId":null}],["b_eBRoAAxkBra",{"templateVersionId":null,"templateCanonId":null}],["b_DCfegdL6nDK",{"templateVersionId":null,"templateCanonId":null}]] 9e:[["S2YftG2hziu","$D2025-08-11T02:56:52.190Z"],["b_JsJhytJgwFI","$D2025-08-12T10:05:57.074Z"],["b_Ccpu61a1yzz","$D2025-08-12T10:10:37.747Z"],["b_eA2nXKrHb9l","$D2025-08-12T10:17:28.198Z"],["b_Cm2CWYT8xip","$D2025-08-12T10:34:28.540Z"],["b_pgMJ5pH0Px5","$D2025-08-12T10:48:52.375Z"],["b_4uRmpHgWXu8","$D2025-08-12T11:01:20.598Z"],["b_wu1hUCJ8qab","$D2025-08-12T11:07:08.285Z"],["b_tBpKr8U3nuI","$D2025-08-12T11:14:24.868Z"],["b_aIqtiGtRXMR","$D2025-08-12T11:18:06.887Z"],["b_ucbHfJ2kk0n","$D2025-08-12T11:24:34.970Z"],["b_WdQDgil72EQ","$D2025-08-12T14:08:36.082Z"],["b_kgi2aUjjiUs","$D2025-08-12T14:09:45.878Z"],["b_ou612N3YoXU","$D2025-08-12T14:15:05.210Z"],["b_np3Fljk9ZfD","$D2025-08-12T14:17:42.536Z"],["b_okOAFy7ENKE","$D2025-08-12T14:43:37.864Z"],["b_J1R3lquGJYK","$D2025-08-12T15:13:54.600Z"],["b_a5c9t0zAAim","$D2025-08-12T15:14:29.186Z"],["b_ymIbDp2Mr7q","$D2025-08-12T15:15:34.090Z"],["b_SuVQsx6nGvs","$D2025-08-12T15:16:13.082Z"],["b_P31MRkTO4Fd","$D2025-08-12T15:20:06.188Z"],["b_4T5XEsW7zW8","$D2025-08-13T05:09:05.622Z"],["b_U0CZt500q7q","$D2025-08-13T05:19:27.120Z"],["b_ORepVqMCmuO","$D2025-08-13T09:48:06.810Z"],["b_cfYecQgANqW","$D2025-08-13T10:08:23.007Z"],["b_Oah3L7GrCvC","$D2025-08-13T10:35:40.907Z"],["b_VRuBagCHeI1","$D2025-08-13T14:29:23.540Z"],["b_g8Vt6Ly7LZZ","$D2025-08-13T14:35:54.841Z"],["b_sBzdya4yXSL","$D2025-08-13T15:31:52.761Z"],["b_mY9oIdWwbYM","$D2025-08-13T17:28:12.352Z"],["b_xSgjDqKiCVc","$D2025-08-14T02:55:08.424Z"],["b_A5ZXmf21y8J","$D2025-08-14T02:57:20.518Z"],["b_XpoiMuG6JQs","$D2025-08-14T03:41:40.517Z"],["b_wD5GSf7zxDD","$D2025-08-14T04:35:41.587Z"],["b_ofXvFSqXpfb","$D2025-08-14T04:38:16.749Z"],["b_AmBl5kbdh9z","$D2025-08-14T04:41:47.213Z"],["b_XQ40t7kLpnO","$D2025-08-14T04:47:14.046Z"],["b_Jd20T7u2lSs","$D2025-08-14T04:53:00.549Z"],["b_mxLdYgFt9jq","$D2025-08-14T04:59:33.373Z"],["b_ufkhsWWsHZF","$D2025-08-14T05:14:52.094Z"],["b_5KYtWLjBT98","$D2025-08-14T05:16:59.120Z"],["b_BPoNIG1ka11","$D2025-08-14T05:28:42.677Z"],["b_FDoZFzda7p7","$D2025-08-14T05:33:51.613Z"],["b_2q2zvza7E8Z","$D2025-08-14T05:37:19.769Z"],["b_GfVu3kazk31","$D2025-08-14T05:38:57.486Z"],["b_iyqGgfYbkHW","$D2025-08-14T05:46:25.085Z"],["b_3SC1X24RWg2","$D2025-08-14T05:47:03.911Z"],["b_FyXUzUH9xgd","$D2025-08-14T05:54:16.459Z"],["b_Qb4ytCOrEf8","$D2025-08-14T05:56:34.256Z"],["b_rOi2v3r1yJv","$D2025-08-14T09:31:53.967Z"],["b_JG85oSC2PF8","$D2025-08-14T09:36:18.862Z"],["b_4ozbtezfh8s","$D2025-08-14T10:20:12.698Z"],["b_OwKyGi1wSa7","$D2025-08-18T03:17:38.510Z"],["b_KWBODwpTeYk","$D2025-08-18T07:36:13.957Z"],["b_LLMmdqB82UE","$D2025-08-18T14:42:11.681Z"],["b_le3N342EZQp","$D2025-08-18T14:46:50.233Z"],["b_kSthBql6vxy","$D2025-08-18T14:51:00.061Z"],["b_S6U5UgoPQ4l","$D2025-08-19T05:23:17.498Z"],["b_bDuFZZ3G2nE","$D2025-08-19T05:36:56.780Z"],["b_E1RQN6ZDJpL","$D2025-08-21T08:01:18.918Z"],["b_XcvHkme8XMW","$D2025-08-21T08:11:47.749Z"],["b_mNSCRXwLZNq","$D2025-08-21T08:47:47.085Z"],["b_9h3LxzFjYzb","$D2025-08-21T08:51:38.930Z"],["b_LSSp4dN2PYh","$D2025-08-21T09:07:35.266Z"],["b_6Z5kVqyxCD4","$D2025-08-21T09:12:15.598Z"],["b_Z0Kd5UnrdkH","$D2025-08-21T09:24:11.960Z"],["b_LSX8mcIaFu4","$D2025-08-21T09:39:44.897Z"],["b_pZdErNN3Tmk","$D2025-08-21T10:13:00.616Z"],["b_7q1YpJXbH85","$D2025-08-21T10:20:46.736Z"],["b_OrUZNBphkaa","$D2025-08-21T10:25:49.161Z"],["b_UXkm4Ep2QHE","$D2025-08-21T10:36:57.241Z"],["b_7uW0v8s7esl","$D2025-08-21T10:44:38.585Z"],["b_JehZHRBiN8P","$D2025-08-22T04:36:46.147Z"],["b_Lyn2XSE54Bb","$D2025-08-22T04:43:23.924Z"],["b_roCV0Pi2Ung","$D2025-08-22T05:32:00.994Z"],["b_aE1LzmroFko","$D2025-08-22T05:37:32.606Z"],["b_ZRFwTKkY3Uw","$D2025-08-22T05:48:30.805Z"],["b_CAHr0Z2BVry","$D2025-08-22T05:52:27.345Z"],["b_NiWK2Y3kIIn","$D2025-08-22T10:19:57.892Z"],["b_3Ewc496rKm6","$D2025-09-20T04:37:12.338Z"],["b_CTlfFqrVtMj","$D2025-09-20T07:57:56.958Z"],["b_bPntlESw2Ef","$D2025-09-20T08:01:09.063Z"],["b_VD4Y0mCdiSQ","$D2025-09-22T09:36:59.607Z"],["b_tIq634kKmIi","$D2025-09-22T09:42:29.671Z"],["b_WHtjmn9AWQS","$D2025-09-22T09:53:19.483Z"],["b_xjdpNkKDkUq","$D2025-09-27T06:10:48.279Z"],["b_wwYO6JlnetL","$D2025-09-27T06:40:16.080Z"],["b_YipYo1K6AFs","$D2025-09-27T06:45:17.688Z"],["b_URn0gLitM4D","$D2025-09-27T06:48:26.226Z"],["b_qGp0JRxhr0T","$D2025-09-27T07:42:52.158Z"],["b_ii95S1xv0ps","$D2025-09-27T07:49:04.993Z"],["b_rPMoV4lkWUD","$D2025-09-27T08:09:19.712Z"],["b_zQuxPTWbrV6","$D2025-10-31T02:56:08.090Z"],["b_Y58yc8kPiL8","$D2025-10-31T02:57:03.065Z"],["b_OdsgMFKjX2q","$D2025-10-31T02:57:50.522Z"],["b_XDZHlYgoG9P","$D2025-10-31T03:16:27.365Z"],["b_jiYWnHHFzuA","$D2025-10-31T03:17:40.159Z"],["b_K4vgYT2egHg","$D2025-10-31T03:18:26.524Z"],["b_sOjWRo80hEZ","$D2025-11-13T03:16:26.698Z"],["b_NCtznD4s7Dv","$D2025-11-13T03:17:26.629Z"],["b_UXMjZEH8cuZ","$D2025-11-13T03:18:14.152Z"],["b_BXzkHQ4AVVQ","$D2025-11-13T06:55:23.595Z"],["b_YYao2rqNScS","$D2025-11-13T06:56:43.691Z"],["b_hFisqUc8LUs","$D2025-11-13T07:03:19.921Z"],["b_9R7I4QV4sH2","$D2025-11-13T10:48:07.296Z"],["b_sul5Xn8muwa","$D2025-11-14T08:08:01.708Z"],["b_Y0Qj4AeUkgz","$D2025-11-14T08:15:33.721Z"],["b_ajRxPbIf8NL","$D2025-11-14T08:22:00.255Z"],["b_BRWAJjuWzK5","$D2025-11-14T08:23:22.078Z"],["b_ChpGRe5NKXs","$D2025-11-14T08:28:31.827Z"],["b_AvFFVF746lc","$D2025-11-14T08:29:29.191Z"],["b_bt9pGGMgmPI","$D2025-11-20T06:09:07.143Z"],["b_lWOChhSTLBT","$D2026-01-16T19:58:05.645Z"],["b_KOV8hFAIQSG","$D2026-01-16T20:02:55.730Z"],["b_qXHzM78ymJg","$D2026-02-02T14:04:21.857Z"],["b_7ZHGK40QWAp","$D2026-02-02T14:06:23.470Z"],["b_74k9pdzM5iL","$D2026-02-02T14:08:46.188Z"],["b_CrXh0uJKQtv","$D2026-02-02T14:09:32.017Z"],["b_7E7cnh1B3zP","$D2026-02-02T15:08:27.557Z"],["b_jQZb4XVgplw","$D2026-02-02T15:08:58.681Z"],["b_ylHVSW0zUSN","$D2026-02-02T15:10:14.509Z"],["b_IUSh7yODzXS","$D2026-02-02T15:11:50.123Z"],["b_66vECXm1CBi","$D2026-04-02T06:06:21.137Z"],["b_YGaPTgfMTMN","$D2026-04-02T06:06:43.219Z"],["b_qmJhlv3dSaD","$D2026-04-02T06:09:44.004Z"],["b_O2qUr88Zxjv","$D2026-04-02T06:11:45.210Z"],["b_jb0aVZvUKH3","$D2026-04-02T06:15:57.155Z"],["b_QEzcLgiizdx","$D2026-04-02T06:19:59.472Z"],["b_zzL0rmfI3Xx","$D2026-04-02T06:20:49.419Z"],["b_g7RBsTeKqmq","$D2026-04-02T06:23:31.862Z"],["b_bHvww105FtA","$D2026-06-06T10:51:49.239Z"],["b_YmpyF6jOwUL","$D2026-06-24T17:19:41.276Z"],["b_U9l6XxC0Zhc","$D2026-06-24T17:20:02.360Z"],["b_HcrUCCujVXR","$D2026-06-24T17:24:32.723Z"],["b_UdZMNuqddKW","$D2026-07-04T09:46:07.073Z"],["b_Q4NLGNuvU0l","$D2026-07-04T10:47:51.948Z"],["b_yMFrmZnTqZ8","$D2026-07-04T10:48:14.060Z"],["b_YJ7uHDNvo9R","$D2026-07-04T10:48:32.203Z"],["b_zt8vZOGA7tn","$D2026-07-04T10:48:54.687Z"],["b_epSQnF6DWnJ","$D2026-07-04T10:49:14.292Z"],["b_CWMhqC93eR9","$D2026-07-04T11:15:30.285Z"],["b_zX21aNij07c","$D2026-07-04T11:15:57.437Z"],["b_aFhLgV96hOP","$D2026-07-04T11:16:13.895Z"],["b_K9Af9NjX82Q","$D2026-07-04T11:16:40.255Z"],["b_ZltdmuLbLvV","$D2026-07-04T11:17:01.494Z"],["b_9DbZqJZmNQ2","$D2026-07-04T11:17:21.272Z"],["b_UEyg2Ge8vzy","$D2026-07-04T11:17:40.180Z"],["b_79luUOCrHjn","$D2026-07-04T11:18:05.841Z"],["b_CCWxxKzDo7K","$D2026-07-04T11:18:22.762Z"],["b_mTwCRZiETnZ","$D2026-07-04T11:18:48.923Z"],["b_ufiMkPh35dx","$D2026-07-04T11:19:26.792Z"],["b_mh5LL0fmyje","$D2026-07-04T11:20:07.956Z"],["b_IieoiDYJE9H","$D2026-07-04T11:21:01.326Z"],["b_3xWmoEfTNrn","$D2026-07-04T11:21:46.006Z"],["b_ETjBhK0Omvs","$D2026-07-04T11:22:38.894Z"],["b_PLKS5Hfsgi2","$D2026-07-04T17:53:00.363Z"],["b_kAcVkXN5PjF","$D2026-07-04T17:53:30.077Z"],["b_YF5wkdnRktX","$D2026-07-04T17:53:57.988Z"],["b_ce1Iy3Ycu5D","$D2026-07-04T17:54:37.661Z"],["b_o1bps8dyyjf","$D2026-07-04T17:55:17.800Z"],["b_crVp5seNY7B","$D2026-07-04T17:55:59.488Z"],["b_6khvabnopoH","$D2026-07-04T17:56:44.359Z"],["b_gsfhn1wQmsl","$D2026-07-04T17:57:29.070Z"],["b_XpCt0uiaMK4","$D2026-07-04T17:58:16.387Z"],["b_D9NxQTH7Kqk","$D2026-07-06T10:00:48.223Z"],["b_R6qTaB9hfLw","$D2026-07-06T10:01:13.046Z"],["b_bEmkF8LJiUa","$D2026-07-06T10:10:41.271Z"],["b_Fh7Yk9NLi6N","$D2026-07-06T10:12:48.823Z"],["b_6qAI5gUTP9h","$D2026-07-06T10:13:54.785Z"],["b_z13fSMww7Gi","$D2026-07-06T10:14:54.322Z"],["b_b2EDiml209B","$D2026-07-06T10:18:17.253Z"],["b_0dMsUSqgZ6Q","$D2026-07-06T10:18:49.046Z"],["b_mcYGDVVkgd8","$D2026-07-06T10:20:54.350Z"],["b_wxGyfVIleNc","$D2026-07-06T10:21:27.147Z"],["b_4fdvmnSGZxx","$D2026-07-06T10:26:43.594Z"],["b_TkjwAL3WTOh","$D2026-07-06T10:29:27.481Z"],["b_nnscVzzOrYb","$D2026-07-06T10:32:00.079Z"],["b_g6brQXTobvQ","$D2026-07-06T10:33:59.094Z"],["b_Mk7OVrvAjR4","$D2026-07-07T17:34:34.098Z"],["b_6Euzn1R88Mv","$D2026-07-07T17:35:15.157Z"],["b_3K7bERwBnvQ","$D2026-07-07T17:35:39.695Z"],["b_Hol0LFq4PaN","$D2026-07-07T17:36:04.244Z"],["b_GpRiiVXLo4D","$D2026-07-07T17:48:28.018Z"],["b_OrhgehiPSM1","$D2026-07-07T18:03:54.908Z"],["b_mnSpaCxQCho","$D2026-07-07T18:04:26.381Z"],["b_8XdyloyBfU7","$D2026-07-07T18:05:16.438Z"],["b_BgioFXESltK","$D2026-07-07T18:08:23.314Z"],["b_M6QmdNYFpeQ","$D2026-07-07T18:20:23.660Z"],["b_08u66KVnwqo","$D2026-07-07T18:20:54.780Z"],["b_aOnW7tquGS6","$D2026-07-07T18:27:35.092Z"],["b_daU0EpipOtW","$D2026-07-07T18:58:18.802Z"],["b_YcqbLjVCOwS","$D2026-07-07T18:58:46.077Z"],["b_GvaN6SQVhQl","$D2026-07-07T19:24:51.040Z"],["b_DkMhpHov00x","$D2026-07-07T19:35:26.276Z"],["b_ToE4OK4Yz0U","$D2026-07-07T19:36:52.622Z"],["b_uVHsVAppw5b","$D2026-07-07T19:47:05.965Z"],["b_m0k2ghEtu2Y","$D2026-07-07T19:58:27.747Z"],["b_6jD69GnsNol","$D2026-07-07T19:58:53.596Z"],["b_YCe7pItHHiV","$D2026-07-07T19:59:43.842Z"],["b_0zRDHw12S9g","$D2026-07-07T20:00:11.059Z"],["b_HLF2LIl3D6W","$D2026-07-07T20:01:25.984Z"],["b_jglIergaUvJ","$D2026-07-07T20:02:01.154Z"],["b_iGL5kupiJmb","$D2026-07-07T20:02:40.848Z"],["b_kCrzsyUIBvA","$D2026-07-07T20:03:21.792Z"],["b_Tuu1rqoi0X6","$D2026-07-07T20:06:43.117Z"],["b_AVBni2l8GuX","$D2026-07-07T20:07:07.905Z"],["b_7sNpaFJmp6Y","$D2026-07-07T20:18:22.200Z"],["b_sxJWR3JXW83","$D2026-07-08T17:20:55.398Z"],["b_2y3d9yOT8hh","$D2026-07-08T17:25:14.069Z"],["b_g9XaAxS6kHD","$D2026-07-08T17:29:44.570Z"],["b_NAsvjKiSzE2","$D2026-07-08T17:30:07.723Z"],["b_rq8P4tWjNv8","$D2026-07-08T17:38:14.622Z"],["b_9HLoM9IlYZv","$D2026-07-08T17:38:40.774Z"],["b_L4JMKRAmLei","$D2026-07-08T17:39:14.041Z"],["b_iOPUcoPPqOH","$D2026-07-08T17:39:40.881Z"],["b_FcbtCUdxsPC","$D2026-07-08T17:40:45.401Z"],["b_C7bGC2IPiUF","$D2026-07-08T17:43:00.661Z"],["b_CyQvioUggu4","$D2026-07-08T17:43:45.890Z"],["b_l3dd5QKQgpq","$D2026-07-08T17:44:19.710Z"],["b_cDcZQp8OvOo","$D2026-07-08T17:45:22.745Z"],["b_Z2HIxH3Rk5l","$D2026-07-08T17:45:45.139Z"],["b_iQixa4Uy4Pn","$D2026-07-08T17:47:26.700Z"],["b_a2NJ63Uyxzx","$D2026-07-08T17:47:49.834Z"],["b_PvL1MmD1Cfr","$D2026-07-08T17:50:15.622Z"],["b_JwFkm09GEqI","$D2026-07-08T17:51:53.675Z"],["b_mzQiqi0kteN","$D2026-07-08T17:53:02.272Z"],["b_XiF124aYtH7","$D2026-07-08T17:53:29.253Z"],["b_QwVxdjPJ6sj","$D2026-07-08T17:53:52.102Z"],["b_RhAQWgRazYy","$D2026-07-08T17:57:11.946Z"],["b_7uGQ3re9Ui7","$D2026-07-08T17:58:37.961Z"],["b_x4WP4onJmzV","$D2026-07-08T18:01:44.816Z"],["b_iXv8DOv0T8p","$D2026-07-08T18:02:10.236Z"],["b_dVEDXFyGVvm","$D2026-07-08T18:02:37.537Z"],["b_da3kGBCAPFs","$D2026-07-08T18:02:59.267Z"],["b_rjTznx654gt","$D2026-07-08T18:05:25.359Z"],["b_gUaWvD7V3Cv","$D2026-07-08T18:05:52.594Z"],["b_srnjp3ckH8I","$D2026-07-09T17:13:29.794Z"],["b_0aJoskkY00s","$D2026-07-09T17:16:12.673Z"],["b_BokXuB11aRO","$D2026-07-09T17:16:36.532Z"],["b_jXLTfchHMU6","$D2026-07-09T17:16:56.838Z"],["b_OPaOP6wRF0R","$D2026-07-09T17:17:21.066Z"],["b_VteUuiQX0Op","$D2026-07-09T17:20:24.578Z"],["b_1Dp0bUmeQDo","$D2026-07-09T17:20:45.596Z"],["b_LX7tmgfYHYm","$D2026-07-09T17:27:28.950Z"],["b_BZV6lvYVQnH","$D2026-07-09T17:27:58.428Z"],["b_5dfAwP7NXHE","$D2026-07-09T17:28:24.476Z"],["b_tCJtIMfTg1G","$D2026-07-09T17:40:41.518Z"],["b_5ingJN1sRdM","$D2026-07-09T17:40:43.986Z"],["b_zRQ7ddqxLAi","$D2026-07-09T17:41:06.834Z"],["b_2ghKGdiTf5y","$D2026-07-09T17:41:28.117Z"],["b_Bmdrz0XVmaF","$D2026-07-09T17:41:52.640Z"],["b_IcPG1wyjpKk","$D2026-07-09T17:42:11.245Z"],["b_WHJEXXWbw8n","$D2026-07-09T17:42:34.023Z"],["b_Yd3K61HjtoF","$D2026-07-09T17:42:53.128Z"],["b_k01CUYyXoPG","$D2026-07-09T18:06:39.695Z"],["b_x6iHCueAj4X","$D2026-07-09T18:07:16.106Z"],["b_0KGLAIXYjo2","$D2026-07-09T18:07:42.083Z"],["b_P4t20qg6YKR","$D2026-07-09T18:08:15.941Z"],["b_fCmUYHTDYGN","$D2026-07-09T18:19:02.266Z"],["b_PdmbPm6Oj2L","$D2026-07-09T18:31:08.462Z"],["b_6ZJav1EYPVZ","$D2026-07-09T18:31:35.362Z"],["b_PhEf38cAEsW","$D2026-07-09T18:32:00.336Z"],["b_0XHQ2Hctigq","$D2026-07-09T18:33:01.153Z"],["b_TtfBQbLd0S9","$D2026-07-09T18:34:01.070Z"],["b_6Cz8rWC6WdM","$D2026-07-09T18:34:50.338Z"],["b_Ik8vdCHq2Jb","$D2026-07-10T08:57:16.388Z"],["b_dhxSR1ylCdB","$D2026-07-10T08:57:46.795Z"],["b_I8WkHtiL74G","$D2026-07-10T08:59:38.740Z"],["b_q1QwCNIId08","$D2026-07-10T09:00:05.101Z"],["b_aZhIgl5MfaL","$D2026-07-10T09:00:29.495Z"],["b_0zcCwPg23bS","$D2026-07-10T09:03:41.175Z"],["b_AaPNpNKnvub","$D2026-07-10T13:38:48.102Z"],["b_qEmU0fXmWdg","$D2026-07-10T14:12:59.140Z"],["b_SE7FO6c2q9K","$D2026-07-10T14:14:53.868Z"],["b_dYht5c7yDFX","$D2026-07-10T16:54:56.004Z"],["b_erlW3H8CTJ1","$D2026-07-11T09:46:10.171Z"],["b_OWZg3hLJi6t","$D2026-07-11T09:46:44.364Z"],["b_PvPKjSFMTFA","$D2026-07-11T11:18:30.827Z"],["b_owqOZqeZIE8","$D2026-07-11T11:18:50.303Z"],["b_L7SNDN4q6Ql","$D2026-07-11T11:22:11.211Z"],["b_DgaEndOZAek","$D2026-07-11T11:23:29.167Z"],["b_tL53rMn7pX2","$D2026-07-11T11:23:52.492Z"],["b_s4BjTvPKl66","$D2026-07-11T11:24:23.925Z"],["b_wPE7d2bhi7T","$D2026-07-11T11:24:45.244Z"],["b_wJjXqRuQLx7","$D2026-07-11T11:25:13.555Z"],["b_VgOkn0izvwQ","$D2026-07-11T11:25:57.760Z"],["b_ClYi4Eq0UyM","$D2026-07-11T11:26:20.640Z"],["b_TL2Lcz2VgeP","$D2026-07-11T11:26:43.309Z"],["b_q1aGptw1pwO","$D2026-07-11T11:27:18.233Z"],["b_wP9uhxyIT1C","$D2026-07-11T11:27:53.018Z"],["b_ntxnC6JQ2rp","$D2026-07-11T12:19:24.834Z"],["b_GOVhLH1eGqz","$D2026-07-11T12:22:28.964Z"],["b_0l0gtitt6w7","$D2026-07-11T12:24:17.620Z"],["b_oJgjIrnnFFm","$D2026-07-11T12:24:44.582Z"],["b_Hc4K6g2PuLK","$D2026-07-11T12:25:32.961Z"],["b_8hqWOUlGj2l","$D2026-07-11T12:26:09.562Z"],["b_QBMk3gEplj3","$D2026-07-11T12:26:34.294Z"],["b_BqDW4Bo4m45","$D2026-07-11T12:27:13.051Z"],["b_bQ6nmXY2fMl","$D2026-07-11T12:27:40.292Z"],["b_lxu0DTySiLY","$D2026-07-11T12:28:22.246Z"],["b_LarwBFblWDl","$D2026-07-11T12:28:50.799Z"],["b_Mf632akmcVZ","$D2026-07-11T12:29:34.868Z"],["b_dMLRcruvOAq","$D2026-07-11T12:30:33.299Z"],["b_k38zjJ92NRW","$D2026-07-11T12:31:06.026Z"],["b_xT8yw7vO9Bo","$D2026-07-11T12:31:52.518Z"],["b_tqbICEtyhcA","$D2026-07-11T12:32:36.656Z"],["b_YLbg2MVj1PU","$D2026-07-11T13:28:24.419Z"],["b_aatgCKUsjKG","$D2026-07-14T06:27:12.383Z"],["b_cfzsJxMSoCu","$D2026-07-14T06:27:38.166Z"],["b_mr3IopiNFHT","$D2026-07-14T06:28:00.496Z"],["b_NAhqvFHRoDQ","$D2026-07-14T06:29:08.466Z"],["b_HCxWacvQKoO","$D2026-07-14T06:29:33.570Z"],["b_iWszxyZoZCp","$D2026-07-14T06:29:56.817Z"],["b_RH3iiTlHDh7","$D2026-07-14T06:30:23.416Z"],["b_VAJE8WJLmiu","$D2026-07-14T06:30:48.503Z"],["b_7OUkwQZL5sC","$D2026-07-14T06:31:13.905Z"],["b_5ASbSIJQ5tS","$D2026-07-14T06:31:40.398Z"],["b_EVWB5qullLr","$D2026-07-14T06:32:08.212Z"],["b_gXNUQs7RayL","$D2026-07-14T06:32:35.146Z"],["b_OxzOKemBrkc","$D2026-07-14T06:33:07.106Z"],["b_NhK0zBuJCNs","$D2026-07-14T06:38:41.431Z"],["b_E4Lf5SuSs1t","$D2026-07-14T06:44:51.166Z"],["b_cajqdLElVrz","$D2026-07-14T06:45:27.661Z"],["b_kC7llSxKkGv","$D2026-07-14T06:45:57.196Z"],["b_8FoaxpPmfCb","$D2026-07-14T06:46:22.545Z"],["b_TCn4saT4Wdd","$D2026-07-15T18:01:38.421Z"],["b_CofcfkESydE","$D2026-07-15T18:02:01.975Z"],["b_fChRrMBYl9i","$D2026-07-15T18:10:08.375Z"],["b_gXgzHvYMP8Y","$D2026-07-15T18:11:06.238Z"],["b_2Oz35h6uMQD","$D2026-07-15T18:13:46.248Z"],["b_1nn0qLLes1G","$D2026-07-15T18:17:14.476Z"],["b_uwH8kk7VhrT","$D2026-07-15T18:17:43.129Z"],["b_NOxwl9Ub4rD","$D2026-07-15T18:18:16.594Z"],["b_1mKb5BiZWdS","$D2026-07-15T18:27:10.753Z"],["b_kWwfPiAe7EE","$D2026-07-15T18:27:43.098Z"],["b_DiB3XLUTu4L","$D2026-07-15T18:28:08.575Z"],["b_YcKMXYSrJex","$D2026-07-15T18:28:34.125Z"],["b_1YRjQ7scK03","$D2026-07-15T18:29:03.579Z"],["b_tjw22xMsuFN","$D2026-07-15T18:29:27.256Z"],["b_Or58F0KDdA2","$D2026-07-15T18:29:52.105Z"],["b_TTt3BHkB3Yu","$D2026-07-16T08:33:29.627Z"],["b_qM5f3WOJPQJ","$D2026-07-16T08:33:53.645Z"],["b_ecvL1P16zw7","$D2026-07-16T08:34:16.011Z"],["b_b4lHZV7g2Vl","$D2026-07-16T08:34:40.271Z"],["b_KHu7Su3XAyu","$D2026-07-16T08:35:40.779Z"],["b_1n5I604BCfR","$D2026-07-16T08:36:07.444Z"],["b_144LJveKsq1","$D2026-07-16T08:36:42.724Z"],["b_9tx4XmjBl2J","$D2026-07-16T09:38:35.768Z"],["b_MdzJPsbqMAt","$D2026-07-16T09:38:58.993Z"],["b_xHYHuwk5yeY","$D2026-07-16T09:39:33.001Z"],["b_SCP3oZo9Sy1","$D2026-07-16T09:50:02.620Z"],["b_eBRoAAxkBra","$D2026-07-16T09:50:40.906Z"],["b_DCfegdL6nDK","$D2026-07-16T09:52:25.042Z"]] 9f:[["b_SCP3oZo9Sy1",false],["b_eBRoAAxkBra",false],["b_DCfegdL6nDK",false]] a0:[["b_SCP3oZo9Sy1","$undefined"],["b_eBRoAAxkBra","$undefined"],["b_DCfegdL6nDK",{"deploymentId":"dpl_9tuBzBoRSZNnAremEbbbaak7QztL","showV0Button":true}]] a1:[["b_SCP3oZo9Sy1",null],["b_eBRoAAxkBra",null],["b_DCfegdL6nDK",null]] a2:[["b_SCP3oZo9Sy1",true],["b_eBRoAAxkBra",true],["b_DCfegdL6nDK",true]] a3:[["b_SCP3oZo9Sy1",true],["b_eBRoAAxkBra",true],["b_DCfegdL6nDK",true]] a4:[] a5:T279cad,[V0_FILE]plaintext:file=".gitignore" isMerged="true" # See https://help.github.com/articles/ignoring-files/ for more about ignoring files. # dependencies /node_modules # next.js /.next/ /out/ # production /build # debug npm-debug.log* yarn-debug.log* yarn-error.log* .pnpm-debug.log* # env files .env* # vercel .vercel # typescript *.tsbuildinfo next-env.d.ts [V0_FILE]markdown:file="README.md" isMerged="true" # Blog *Automatically synced with your [v0.dev](https://v0.dev) deployments* [![Deployed on Vercel](https://img.shields.io/badge/Deployed%20on-Vercel-black?style=for-the-badge&logo=vercel)](https://vercel.com/pythontyro0341-gmailcoms-projects/v0-blog) [![Built with v0](https://img.shields.io/badge/Built%20with-v0.dev-black?style=for-the-badge)](https://v0.dev/chat/projects/HtqYF3f0Isx) ## Overview This repository will stay in sync with your deployed chats on [v0.dev](https://v0.dev). Any changes you make to your deployed app will be automatically pushed to this repository from [v0.dev](https://v0.dev). ## Deployment Your project is live at: **[https://vercel.com/pythontyro0341-gmailcoms-projects/v0-blog](https://vercel.com/pythontyro0341-gmailcoms-projects/v0-blog)** ## Build your app Continue building your app on: **[https://v0.dev/chat/projects/HtqYF3f0Isx](https://v0.dev/chat/projects/HtqYF3f0Isx)** ## How It Works 1. Create and modify your project using [v0.dev](https://v0.dev) 2. Deploy your chats from the v0 interface 3. Changes are automatically pushed to this repository 4. Vercel deploys the latest version from this repository [V0_FILE]typescriptreact:file="app/computer-science/class-11/computer-system-organization/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight } from "lucide-react" import TOC from "./toc" import Related from "./related" import PdfDownloadButton from "@/components/pdf-download-button" export default function ComputerSystemOrganizationPage() { return (

{/* Breadcrumb with PDF Button */}

Home Computer Science Class 11 Computer System Organization

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Chapter 1: Computer System Organization

{/* Introduction */}

Introduction

A computer is an electronic device that accepts a set of instructions in the form of a program, executes it and displays the output to the user.

{/* Basic Components */}

Basic Components of a Computer System

Input Unit
Central Processing Unit (CPU)
Memory Unit
Output Unit
Software Concepts

{/* Input Unit */}

Input Unit

An input unit fetches the input and converts it into binary form which is directly understood by the computer. The term Binary means two states ON/OFF, HIGH/LOW, 0/1.

{/* Keyboard */}

1. Keyboard

Definition: A keyboard is an input device used to enter data and instructions into a computer.

Layout: Most commonly used layout is the QWERTY layout (named after the first six letters on the top row).

Types of Keys:

Alphanumeric Keys – Letters (A-Z), numbers (0-9)
Function Keys – F1 to F12, perform special functions
Control Keys – Ctrl, Alt, Windows key, etc.
Navigation Keys – Arrow keys, Home, End, Page Up, Page Down
Numeric Keypad – Found on the right side, used for quick numeric entry
Special Keys – Enter, Spacebar, Backspace, Shift, Tab, Caps Lock, Esc

Functionality: When a key is pressed, it sends a digital signal to the computer which is then interpreted as input.

Connection Types:

Wired keyboards – Connect using USB or PS/2 port
Wireless keyboards – Use Bluetooth or RF (radio frequency) technology

{/* Mouse */}

2. Mouse

Definition: A mouse is a pointing input device used to interact with items on a computer screen.

Basic Functions:

Pointing – Move the cursor on the screen
Clicking – Select or open files and folders
Dragging – Move items by holding and moving the mouse
Scrolling – Move through long documents using the scroll wheel

Types of Mouse:

Mechanical Mouse – Uses a rubber ball for movement (old model)
Optical Mouse – Uses LED light to detect motion (modern)
Laser Mouse – More accurate, uses a laser for tracking
Wireless Mouse – Connects through Bluetooth or RF technology

Mouse Buttons:

Left Button – For selecting and clicking
Right Button – For opening context menus
Scroll Wheel – For scrolling and sometimes used as a third button

{/* Light Pen */}

3. Light Pen

Definition: A light pen is a pointing input device that allows the user to draw or select objects directly on the screen.

Working Principle: It detects light from the computer screen (usually a CRT screen). When the pen touches the screen, it identifies the exact location using the screen's brightness.

Main Functions:

Pointing – Select icons or menu items
Drawing – Used in CAD (Computer-Aided Design) and graphic design applications
Writing – Input handwriting directly on the screen

{/* OMR */}

4. Optical Mark Reader (OMR)

Definition: OMR is an input device used to read marks made on paper using a pencil or pen.

Where It Is Used:

Entrance exams like NEET, JEE, etc.
Surveys and polls
Attendance sheets

{/* Smart Card Reader */}

5. Smart Card Reader

Smart Card Reader is used to read data from a smart card. A smart card is like an ATM card with a chip inside. The chip stores important information like ID, bank, or health details.

Used in:

ATM machines
Office ID cards
Metro/train cards
Health and government cards

{/* Barcode Reader */}

6. Barcode Reader

A Barcode Reader is used to read barcodes printed on products. A barcode is a pattern of black and white lines that stores product information. The reader uses laser light to scan the barcode.

Used in:

Supermarkets
Libraries
Shopping malls
Inventory systems

{/* QR Code Reader */}

7. QR Code Reader

A QR Code Reader is used to scan QR codes. QR code means Quick Response code – it looks like a square box with black and white patterns. It stores more data than a barcode.

Used in:

Online payments (like Google Pay, PhonePe)
E-tickets and ID cards
Product info and advertisements

{/* Biometric Sensor */}

8. Biometric Sensor

A Biometric Sensor is used to identify a person using body features. It reads fingerprints, face, eye (iris), or voice.

Types:

Fingerprint scanner
Face recognition sensor
Iris scanner
Voice recognition

{/* Touch Sensor */}

9. Touch Sensor

A Touch Sensor detects when you touch a surface. It is used in touch screens – like in mobile phones, tablets, and ATMs.

{/* Microphone */}

10. Microphone

A microphone is an input device that captures sound (like your voice). It converts sound waves into electrical signals that the computer can understand.

{/* Webcam */}

11. Webcam

A webcam is a small camera used to capture live video and images. It sends the video data to the computer in real-time.

{/* MICR */}

12. Magnetic Ink Character Reader (MICR)

MICR is used to read special characters printed with magnetic ink on documents. Mainly used to read cheques in banks.

{/* OCR */}

13. Optical Character Reader (OCR)

OCR is used to read printed or typed text from paper documents. The OCR scans the document and converts the text into digital form.

{/* CPU */}

Central Processing Unit (CPU)

1. Arithmetic Logic Unit (ALU)

The Arithmetic Logic Unit (ALU) is a part of the CPU. It performs all arithmetic operations like addition, subtraction, multiplication, and division. It also performs logical operations like comparing numbers (greater than, less than, equal to).

2. Control Unit (CU)

The Control Unit (CU) is a part of the CPU. It directs and controls all the operations inside the computer. CU fetches instructions from memory and decodes them. Think of CU as the "manager" or "traffic controller" inside the CPU.

3. Registers

Registers are small, very fast storage locations inside the CPU. They temporarily hold data, instructions, or addresses during processing.

Different types of registers:

Program Counter (PC): holds address of next instruction
Instruction Register (IR): holds current instruction
Accumulator (ACC): holds intermediate arithmetic results

{/* Memory Unit */}

Memory Unit

The Memory Unit stores data and instructions needed by the CPU. It holds both program instructions and data temporarily or permanently.

Primary Memory (Main Memory)

RAM (Random Access Memory)

Temporary or volatile memory
Stores data and instructions while the computer is ON
Data is lost when power is turned off
Allows both read and write operations

Types of RAM:

Static RAM (SRAM)
- Stores data using flip-flops
- Faster and more expensive than DRAM
- Used in cache memory
Dynamic RAM (DRAM)
- Stores data using capacitors
- Needs to be refreshed to keep the data
- Slower and cheaper than SRAM
- Used as main memory (RAM) in computers

ROM (Read-Only Memory)

Permanent or non-volatile memory
Stores essential instructions needed to start the computer (like BIOS)
Data cannot be modified or deleted easily
Retains data even when power is off

Types of ROM:

PROM (Programmable ROM)
- Can be programmed only once after manufacturing
- Once written, data cannot be changed
EPROM (Erasable Programmable ROM)
- Data can be erased using UV light
- After erasing, it can be reprogrammed
EEPROM (Electrically Erasable Programmable ROM)
- Data can be erased and rewritten using electric signals
- Used in BIOS chips and smart cards

Units of Memory

Unit	Size (in bytes)
1 Byte (B)	8 bits
1 Kilobyte (KB)	1,024 Bytes
1 Megabyte (MB)	1,024 Kilobytes
1 Gigabyte (GB)	1,024 Megabytes
1 Terabyte (TB)	1,024 Gigabytes

Secondary Memory

Secondary Memory (also called external memory or non-volatile memory) is used to store data and programs permanently. It retains data even when the computer is turned off.

1. Hard Disk Drive (HDD)

Main secondary storage device in most computers. Consists of magnetic disks that rotate to read/write data.

Track: Circular paths on the surface of a disk platter
Sector: Each track is divided into small segments called sectors

2. Optical Storage Devices

Compact Disc (CD): Stores up to 700 MB of data
Digital Versatile Disc (DVD): Stores 4.7 GB to 17 GB
Blu-ray Disc (BD): Stores 25 GB to 128 GB

3. Flash Storage

USB Pen Drives: Portable flash memory devices
Memory Cards: Used in smartphones, cameras, tablets

4. Magnetic Tapes

Long strips of plastic film coated with magnetic material. Used for sequential data storage and backups.

{/* Output Unit */}

Output Unit

The Output Unit is responsible for presenting processed data (output) to the user. It converts digital data into human-readable form.

1. Visual Display Unit (VDU) / Monitor

LCD Screen: Uses liquid crystals and backlight
LED Screen: Uses LED backlighting, better efficiency
OLED Screen: Each pixel emits its own light, better contrast

2. Printers

Dot Matrix Printer: Impact printer, noisy but reliable
Inkjet Printer: Sprays ink droplets, good for color prints
Laser Printer: Uses laser technology, fast and high-quality

3. Speakers

Convert digital audio signals into sound.

4. Plotters

Specialized devices for printing vector graphics and engineering drawings.

{/* Software Concepts */}

Software Concepts

Software is a set of instructions or programs that tell the computer what to do.

Types of Software

System Software
Application Software
Utility Software
Programming Tools

System Software

Manages and controls hardware components and enables other software to run.

Operating System (Windows, Linux, macOS)
Device Drivers
Language Translators (Compilers, Interpreters)

Operating System

An Operating System (OS) manages computer hardware and software resources and provides services for programs.

Functions of Operating System:

Resource Management
Process Management
Memory Management
File Management
Device Management

OS User Interfaces:

Command Line Interface (CLI): Text-based commands
Graphical User Interface (GUI): Icons, windows, menus
Touch User Interface: Touch screen interaction
Voice Based Interface: Voice commands
Gesture Based Interface: Hand/body movements

Language Translators

Assembler: Translates assembly language to machine code
Compiler: Translates high-level language to machine code all at once
Interpreter: Translates and executes code line by line

Application Software

Designed to perform specific tasks for users.

General Purpose: MS Word, Excel, Web browsers
Specific Purpose/Customized: School Management System, Banking Software

Utility Software

Performs maintenance tasks to improve computer performance.

Antivirus Software
Disk Defragmentation
Backup Utility
Compression Utility
Disk Cleaner
Device Drivers

Programming Tools

Used by developers to write, test, and debug programs.

Compilers and Interpreters
Text Editors (Notepad++, VS Code)
Debuggers
IDEs (Eclipse, PyCharm)

Classification of Programming Languages

Low-Level Languages: Machine Language, Assembly Language
High-Level Languages: Python, C++, Java
Generations:
- 1st Gen: Machine Language
- 2nd Gen: Assembly Language
- 3rd Gen: High-Level Languages (C, Java)
- 4th Gen: Very high-level (SQL, MATLAB)
- 5th Gen: AI-focused (Prolog, LISP)

Next Chapter: Python Fundamentals

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/computer-system-organization/related.tsx" isMerged="true" import Link from "next/link" export default function ComputerSystemRelated() { const relatedResources = [ { id: 1, title: "Python Tokens", type: "video", url: "https://youtu.be/SaWUxEB7OMc" }, { id: 2, title: "Flow Of Execution", type: "video", url: "https://youtu.be/ix8aeEGsKZ0" }, { id: 3, title: "4 Mark Compusory Question", type: "pdf", url: "https://youtu.be/Cw536v0pTOg" }, { id: 4, title: "Practice MCQs", type: "link", url: "/mcqs/computer-science/class-11/computer-system" }, { id: 5, title: "CBSE Class 11 and Class 12(Tamil) Explanation", type: "video", url: "https://youtube.com/@pythontyro4579" }, ] return (

Related Resources

{resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/computer-system-organization/toc.tsx" isMerged="true" import Link from "next/link" export default function ComputerSystemTOC() { const chapters = [ { id: 1, title: "Computer System Organization", slug: "computer-system-organization" }, { id: 2, title: "Data Representation and Boolean Logic", slug: "data-representation-boolean-logic" }, { id: 3, title: "Getting Started With Python", slug: "getting-started-with-python" }, { id: 4, title: "Python Programming Fundamentals", slug: "python-programming-fundamentals" }, { id: 5, title: "Conditional And Looping Construct", slug: "conditional-looping-construct" }, { id: 6, title: "Strings Manipulation In Python", slug: "strings-python" }, { id: 7, title: "List Manipulation In Python", slug: "list-manipulation-python" }, { id: 8, title: "Tuples and Dictionary", slug: "tuples-dictionary" }, { id: 9, title: "Introduction to Python Modules", slug: "introduction-to-python-modules" }, { id: 10, title: "Society, Law and Ethics", slug: "society-law-ethics" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/flow-of-control/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight } from "lucide-react" import TOC from "./toc" import Related from "./related" import PdfDownloadButton from "@/components/pdf-download-button" export default function FlowOfControlPage() { return (

{/* Breadcrumb with PDF Button */}

Home Computer Science Class 11 Flow of Control

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Flow of Control

Flow of control refers to the order in which the statements in a program are executed. Python provides various control structures that allow you to control the flow of your program based on conditions and loops.

1. Conditional Statements

Conditional statements allow you to execute certain blocks of code based on whether a condition is true or false.

1.1 if Statement

The if statement is used to execute a block of code only if a specified condition is true.

                    # Simple if statement x = 10 if x {">"} 5: print("x is greater than 5")

1.2 if-else Statement

The if-else statement allows you to execute one block of code if the condition is true and another block if it is false.

                    
                      # if-else statement x = 3 if x {">"} 5: print("x is greater than 5") else: print("x is not greater
                      than 5")

1.3 if-elif-else Statement

The if-elif-else statement allows you to check multiple conditions and execute different blocks of code accordingly.

                    
                      # if-elif-else statement marks = 75 if marks {">"} 90: grade = "A" elif marks {">"} 80: grade =
                      "B" elif marks {">"} 70: grade = "C" elif marks {">"} 60: grade = "D" else: grade = "F"
                      print(f"Grade: {"{grade}"}")

1.4 Nested if Statements

You can also nest if statements inside other if statements to check for multiple conditions.

                    
                      # Nested if statement x = 10 y = 5 if x {">"} 5: print("x is greater than 5") if y {"<"} 10:
                      print("y is less than 10")

2. Looping Statements

Loops are used to execute a block of code repeatedly as long as a condition is true or for a specified number of times.

2.1 for Loop

The for loop is used to iterate over a sequence (like a list, tuple, string) or other iterable objects.

                    
                      # for loop with a list fruits = ["apple", "banana", "cherry"] for fruit in fruits: print(fruit) #
                      for loop with range for i in range(5): print(i) # Prints 0, 1, 2, 3, 4

2.2 while Loop

The while loop executes a block of code as long as a specified condition is true.

                    # while loop count = 0 while count {"<"} 5: print(count) count += 1 # Increment count

3. Loop Control Statements

Python provides statements to control the flow of loops.

3.1 break Statement

The break statement is used to exit a loop prematurely.

                    
                      # break statement for i in range(10): if i == 5: break # Exit the loop when i equals 5 print(i) #
                      Prints 0, 1, 2, 3, 4

3.2 continue Statement

The continue statement is used to skip the current iteration of a loop and continue with the next iteration.

                    
                      # continue statement for i in range(10): if i == 5: continue # Skip iteration when i equals 5
                      print(i) # Prints 0, 1, 2, 3, 4, 6, 7, 8, 9

3.3 pass Statement

The pass statement is a null operation; nothing happens when it executes. It is used as a placeholder.

                    
                      # pass statement for i in range(5): if i == 3: pass # Do nothing when i equals 3 print(i) # Prints
                      0, 1, 2, 3, 4

Practice Questions

Write a Python program to check if a number is positive, negative, or zero.
Write a Python program to find the largest among three numbers using nested if statements.
Write a Python program to print all even numbers between 1 and 20 using a for loop.
Write a Python program to calculate the factorial of a number using a while loop.
Write a Python program to print the Fibonacci sequence up to a given number using loops.

Next Chapter: Functions

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/flow-of-control/related.tsx" isMerged="true" import Link from "next/link" export default function FlowOfControlRelated() { const relatedResources = [ { id: 1, title: "Conditional Statements Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 2, title: "Loops in Python", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 3, title: "Flow Control Cheatsheet", type: "pdf", url: "/resources/flow-control-cheatsheet.pdf" }, { id: 4, title: "Practice MCQs", type: "link", url: "/mcqs/computer-science/class-11/flow-of-control" }, ] return (

Related Resources

{resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/flow-of-control/toc.tsx" isMerged="true" import Link from "next/link" export default function FlowOfControlTOC() { const chapters = [ { id: 1, title: "Computer System Organization", slug: "computer-system-organization" }, { id: 2, title: "Data Representation and Boolean Logic", slug: "data-representation-boolean-logic" }, { id: 3, title: "Getting Started With Python", slug: "getting-started-with-python" }, { id: 4, title: "Python Programming Fundamentals", slug: "python-programming-fundamentals" }, { id: 5, title: "Conditional And Looping Construct", slug: "conditional-looping-construct" }, { id: 6, title: "Strings Manipulation In Python", slug: "strings-python" }, { id: 7, title: "List Manipulation In Python", slug: "list-manipulation-python" }, { id: 8, title: "Tuples and Dictionary", slug: "tuples-dictionary" }, { id: 9, title: "Introduction to Python Modules", slug: "introduction-to-python-modules" }, { id: 10, title: "Society, Law and Ethics", slug: "society-law-ethics" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/list-manipulation-python/related.tsx" isMerged="true" import Link from "next/link" export default function ListsPythonRelated() { const relatedResources = [ { id: 1, title: "Python Lists Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579", }, { id: 2, title: "List Operations Practice", type: "practical", url: "/computer-science/practical/class-11/list-operations", }, { id: 3, title: "Lists Methods Cheatsheet", type: "pdf", url: "/resources/list-methods-cheatsheet.pdf", }, { id: 4, title: "Lists MCQs Practice", type: "link", url: "/mcqs/computer-science/class-11/lists", }, { id: 5, title: "Strings in Python", type: "theory", url: "/computer-science/class-11/strings-python", }, { id: 6, title: "Tuples and Dictionary", type: "theory", url: "/computer-science/class-11/tuples-dictionary", }, ] return (

Related Resources

{resource.type === "theory" && ( )} {resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.type === "practical" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance on Python data structures.

Practice More

Try list manipulation exercises to strengthen your Python skills.

View Practical Programs →

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/list-manipulation-python/toc.tsx" isMerged="true" import Link from "next/link" export default function ComputerSystemTOC() { const chapters = [ { id: 1, title: "Computer System Organization", slug: "computer-system-organization" }, { id: 2, title: "Data Representation and Boolean Logic", slug: "data-representation-boolean-logic" }, { id: 3, title: "Getting Started With Python", slug: "getting-started-with-python" }, { id: 4, title: "Python Programming Fundamentals", slug: "python-fundamentals" }, { id: 5, title: "Conditional And Looping Construct", slug: "conditional-looping-construct" }, { id: 6, title: "Strings Manipulation In Python", slug: "strings-python" }, { id: 7, title: "List Manipulation In Python", slug: "list-manipulation-python" }, { id: 8, title: "Tuples and Dictionary", slug: "tuples-dictionary" }, { id: 9, title: "Introduction to Python Modules", slug: "introduction-to-python-modules" }, { id: 10, title: "Society, Law and Ethics", slug: "society-law-ethics" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, FileText, Download, Youtube } from "lucide-react" export default function ComputerScienceClass11Page() { // Sample chapter data const chapters = [ { id: 1, title: "Computer System Organization", slug: "computer-system-organization" }, { id: 2, title: "Data Representation and Boolean Logic", slug: "data-representation-boolean-logic" }, { id: 3, title: "Getting Started With Python", slug: "getting-started-with-python" }, { id: 4, title: "Python Programming Fundamentals", slug: "python-fundamentals" }, { id: 5, title: "Conditional And Looping Construct", slug: "conditional-looping-construct" }, { id: 6, title: "Strings in Python", slug: "strings-python" }, { id: 7, title: "Lists in Python", slug: "list-manipulation-python" }, { id: 8, title: "Tuples and Dictionary", slug: "tuples-dictionary" }, { id: 9, title: "Introduction to Python Modules", slug: "introduction-to-python-modules" }, { id: 10, title: "Society, Law and Ethics", slug: "society-law-ethics" }, ] // Sample related resources const relatedResources = [ { id: 1, title: "Python Basics Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 2, title: "Python Cheatsheet", type: "pdf", url: "/resources/python-cheatsheet.pdf" }, { id: 3, title: "Lists and Tuples Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 4, title: "File Handling Examples", type: "pdf", url: "/resources/file-handling-examples.pdf" }, { id: 5, title: "Practice MCQs", type: "link", url: "/mcqs/computer-science/class-11" }, ] return (

{/* Breadcrumb */}

Home Computer Science Class 11

{/* Main Content */}

{/* Left Sidebar - TOC */}

Chapters

{chapter.id}. {chapter.title}

{/* Middle Content */}

Computer Science - Class 11

Welcome to the Computer Science (083) resources for CBSE Class 11. This section provides comprehensive study materials, notes, programs, and practice questions aligned with the latest CBSE curriculum.

Course Overview

The CBSE Class 11 Computer Science curriculum introduces students to the fundamental concepts of computer science and programming using Python. The course covers Python programming basics, data structures, file handling, and computer networks.

Key Topics

Introduction to Computer Systems and Computing
Python Programming Language Fundamentals
Flow of Control (Conditional and Iterative Statements)
Functions and Modules
Data Structures (Lists, Tuples, Dictionaries, Sets)
String Manipulation
File Handling in Python
Data Visualization using Python Libraries
Computer Networks and Internet

How to Use These Resources

Each chapter includes comprehensive notes, example programs, practice questions, and downloadable resources. Click on any chapter in the sidebar to access its content. You can also find related video tutorials and additional resources in the right sidebar.

Important Note

Make sure to practice all the example programs and complete the exercises to gain proficiency in Python programming. Regular practice is key to mastering programming concepts.

Sample Program

                    
                      # A simple Python program to demonstrate list operations {"\n"}numbers = [10, 20, 30, 40, 50] {"\n"}
                      #Accessing elements {"\n"}
                      print("First element:", numbers[0]){"\n"} 
                      print("Last element:", numbers[-1]) {"\n"}
                      #Slicing {"\n"}
                      print("First three elements:", numbers[:3]) {"\n"}
                      # Adding elements numbers.append(60){"\n"}
                      print("After append:", numbers){"\n"} 
                      # Inserting elements numbers.insert(2, 25){"\n"} 
                      print("After insert:",numbers) {"\n"} 
                      # Removing elements numbers.remove(25) {"\n"}
                      print("After remove:", numbers) {"\n"}
                      # Sorting numbers.sort(reverse=True) {"\n"}
                      print("After sorting in descending order:", numbers)

Practical Exam Preparation

The practical examination for Class 11 Computer Science tests your programming skills and understanding of Python concepts. We provide comprehensive practical exam preparation resources, including:

Sample practical questions with solutions
Step-by-step guides for common programming tasks
Tips for efficient coding and debugging
Mock practical exams to practice under timed conditions

Start Learning Python

{/* Right Sidebar - Related Resources */}

Related Resources

{resource.type === "video" && } {resource.type === "pdf" && } {resource.type === "link" && } {resource.title} {resource.type === "pdf" && }

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/python-fundamentals/related.tsx" isMerged="true" import Link from "next/link" export default function PythonFundamentalsRelated() { const relatedResources = [ { id: 1, title: "Python Basics Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 2, title: "Python Cheatsheet", type: "pdf", url: "/resources/python-cheatsheet.pdf" }, { id: 3, title: "Python Practice Questions", type: "pdf", url: "/resources/python-practice.pdf" }, { id: 4, title: "Python MCQs", type: "link", url: "/mcqs/computer-science/class-11/python" }, ] return (

Related Resources

{resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/python-fundamentals/toc.tsx" isMerged="true" import Link from "next/link" export default function PythonFundamentalsTOC() { const chapters = [ { id: 1, title: "Computer System Organization", slug: "computer-system-organization" }, { id: 2, title: "Data Representation and Boolean Logic", slug: "data-representation-boolean-logic" }, { id: 3, title: "Getting Started With Python", slug: "getting-started-with-python" }, { id: 4, title: "Python Programming Fundamentals", slug: "python-fundamentals" }, { id: 5, title: "Conditional And Looping Construct", slug: "conditional-looping-construct" }, { id: 6, title: "Strings in Python", slug: "strings-python" }, { id: 7, title: "Lists in Python", slug: "list-manipulation-python" }, { id: 8, title: "Tuples and Dictionary", slug: "tuples-dictionary" }, { id: 9, title: "Introduction to Python Modules", slug: "introduction-to-python-modules" }, { id: 10, title: "Society, Law and Ethics", slug: "society-law-ethics" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/strings-python/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight } from "lucide-react" import TOC from "./toc" import Related from "./related" import PdfDownloadButton from "@/components/pdf-download-button" export default function StringsPythonPage() { return (

{/* Breadcrumb with PDF Button */}

Home Computer Science Class 11 Strings in Python

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Chapter 6: Strings in Python

{/* Introduction */}

Introduction to Strings

Immutable

A string object always represents the same string. Once created, strings cannot be modified.

Strings are sequences of UNICODE characters that may include letters, numbers, special characters, white-space, or backslashes. Strings are enclosed with single quotes (' '), double quotes (" "), or triple quotes (''' ''').

"Hello Python"

'Hello Python'

''' Hi Hello Python1234'''

{/* Creating Strings */}

Creating Strings

Basic String Creation

                      {`A = "Good Morning"
X = "Write article on \\"AI\\" briefly"
print(X)  # Output: Write article on "AI" briefly`}

Empty String

                      {`str = ""
str = ' '
print(str)  # Output: ' '`}

Multiline String

                      {`A = ''' This is a 
Multiline String 
Example'''
print(A)  # Output: This is a Multiline String Example`}

{/* String Indexing */}

String Indexing and Traversing

Accessing all elements of a string one after another using subscript or index values.

Example: str = "HELLO PYTHON"

Positive Index (Forward)

H E L L O P Y T H O N

0 1 2 3 4 5 6 7 8 9 10 11

Negative Index (Backward)

H E L L O P Y T H O N

-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

                      {`str = "Hello Python"
print(str[4])   # Output: o
print(str[-1])  # Output: n`}

{/* String Operators */}

Special String Operators

String Operators

1. Slicing → String[range]
2. Concatenation → String1 + String2
3. Repetition → String1 * x
4. Membership → in, not in
5. Reverse → String[::-1]
6. Comparison → {"<"}, {">"}, {"<="}, {">="} {"=="}, !=

1. Slicing [start:stop:step]

Note: stop = stop - 1

                      {`s = "HELLO PYTHON"
print(s[1:5])    # Output: ELLO
print(s[0:8])    # Output: HELLO PY
print(s[1:9:-1]) # Output: (empty string)`}

2. Concatenation (+)

Joining two strings together.

                      {`str = "GOOD"
str1 = "Morning"
print(str + str1)           # Output: GOODMorning
print("Python" + "Program") # Output: PythonProgram
print("Python" + " " + "Program") # Output: Python Program
print("Python" + "10")      # Output: Python10

# Error example:
# print("Python" + 10)  # TypeError: can only concatenate str (not "int") to str`}

3. Repetition (*)

                      {`str = "Hi !!! "
print(str * 3)        # Output: Hi !!! Hi !!! Hi !!! 
print("Hello" * 2)    # Output: HelloHello
print(3 * "Hi")       # Output: HiHiHi
print(3 * 2 * "Hi")   # Output: HiHiHiHiHiHi
print('AI!' * 2 * 2)  # Output: AI!AI!AI!AI!

# Error example:
# print('Hi' * 'Hello')  # TypeError: can't multiply sequence by non-int`}

4. Membership (in, not in)

                      {`str = "HELLO PYTHON"
print('LLO' in str)      # Output: True
print('aa' in str)       # Output: False
print('zz' in str)       # Output: False
print('abc' not in str)  # Output: True
print('py' not in str)   # Output: True
print('Py' not in str)   # Output: True`}

5. Reverse

                      {`str = "HELLO PYTHON"
print(str[::-1])  # Output: NOHTYP OLLEH`}

6. Comparison

                      {`print('apple' > 'a')      # Output: True
print('apple' > 'A')      # Output: True
print('Apple' > 'a')      # Output: False
print('Apple' >= 'z')     # Output: False
print('Apple' == 'apple') # Output: False
print('apple' == 'apple') # Output: True
print('apple' != 'apple') # Output: False

a = 'python'
b = 'apple'
print(a > b)              # Output: True`}

{/* String Methods */}

String Methods and Built-in Functions

1. len() - Length of String

                      {`a = "PYTHON"
print(len(a))  # Output: 6`}

2. capitalize() - First Letter Uppercase

                      {`a = "python"
print(a.capitalize())  # Output: Python

a = "python programming language"
print(a.capitalize())  # Output: Python programming language`}

3. split() - Split String into List

Syntax: str.split([separator[, maxsplit]])

                      {`x = "Red$blue$green"
print(x.split("$"))  # Output: ['Red', 'blue', 'green']

g = "red:blue:orange:pink"
print(g.split(':', 2))  # Output: ['red', 'blue', 'orange:pink']
print(g.split(':', 1))  # Output: ['red', 'blue:orange:pink']
print(g.split(':', 0))  # Output: ['red:blue:orange:pink']`}

4. replace() - Replace Substring

                      {`x = "This is a String Example"
print(x.replace("is", "was"))  # Output: Thwas was a String Example`}

5. find() - Find Substring Index

Returns -1 if substring not found.

                      {`str = "Green Revolution"
print(str.find("green"))    # Output: -1
print(str.find("Green"))    # Output: 0
print(str.find("een"))      # Output: 2
print(str.find("n", 3, 20)) # Output: 4
print(str.find("n", 5, 20)) # Output: 15`}

6. index() - Find Index (Raises Exception)

Similar to find() but raises ValueError if substring not found.

                      {`str = "Hello ITS all about STRINGS!!!"
print(str.index('Hello'))  # Output: 0
print(str.index('ll'))     # Output: 2
print(str.index("all"))    # Output: 10

# Error example:
# print(str.index('abc'))  # ValueError: substring not found`}

7. isalpha() - Check for Alphabets Only

                      {`str = "Good"
print(str.isalpha())     # Output: True

str = "123good"
print(str.isalpha())     # Output: False`}

8. isalnum() - Check for Alphanumeric

                      {`str = "Good"
print(str.isalnum())        # Output: True

str = "123Good"
print(str.isalnum())        # Output: True

str = "Good Morning"
print(str.isalnum())        # Output: False (space is not alphanumeric)`}

9. isdigit() - Check for Digits Only

                      {`str = "12345"
print(str.isdigit())     # Output: True

str = "123Good"
print(str.isdigit())     # Output: False`}

10. title() - Title Case

                      {`str = "hello ITS all about STRINGS"
print(str.title())  # Output: Hello Its All About Strings`}

11. count() - Count Substring Occurrences

                      {`str = "Hello Hi Python Hello World Hi Welcome"
print(str.count("Hello", 12, 40))  # Output: 1
print(str.count("Hi", 2, 40))      # Output: 2`}

12. lower() - Convert to Lowercase

                      {`str = "Learning Python"
print(str.lower())  # Output: learning python

str = "PYthON"
print(str.lower())  # Output: python`}

13. islower() - Check if Lowercase

                      {`str = "Learning Python"
print(str.islower())  # Output: False

str = "python"
print(str.islower())  # Output: True`}

14. upper() - Convert to Uppercase

                      {`str = "Learning Python"
print(str.upper())  # Output: LEARNING PYTHON

str = "python"
print(str.upper())  # Output: PYTHON`}

15. isupper() - Check if Uppercase

                      {`str = "PYTHON"
print(str.isupper())  # Output: True

str = "PYTHOn"
print(str.isupper())  # Output: False`}

16. lstrip() - Remove Left Spaces

                      {`str = "    Green REvolution"
print(str.lstrip())  # Output: Green REvolution

str = "Green REvolution"
print(str.lstrip("Gr"))  # Output: een REvolution`}

17. rstrip() - Remove Right Spaces

                      {`str = "Green Revolution    "
print(str.rstrip())  # Output: Green Revolution

str = "Green Revolution"
print(str.rstrip("tion"))  # Output: Green Revolu`}

18. strip() - Remove Both Side Spaces

                      {`str = "   Hello ITS all about STRINGS     "
print(str.strip())  # Output: Hello ITS all about STRINGS`}

19. isspace() - Check for Whitespace Only

                      {`str = "   "
print(str.isspace())  # Output: True

str = "Hello ITS all about STRINGS"
print(str.isspace())  # Output: False`}

20. istitle() - Check if Title Case

                      {`str = "All Learn Python"
print(str.istitle())  # Output: True

str = "All Learn python"
print(str.istitle())  # Output: False`}

21. join() - Join Sequence with Separator

                      {`str = "12345"
s = '-'
print(s.join(str))  # Output: 1-2-3-4-5

s = '*'
print(s.join(str))  # Output: 1*2*3*4*5

s = '****'
print(s.join(str))  # Output: 1****2****3****4****5`}

22. swapcase() - Swap Case

                      {`str = "Welcome"
print(str.swapcase())  # Output: wELCOME

str = "PYTHon"
print(str.swapcase())  # Output: pythON

str = "PYTHON"
print(str.swapcase())  # Output: python`}

23. partition() - Split into 3 Parts

                      {`str = "xyz@gmail.com"
print(str.partition("@"))  # Output: ('xyz', '@', 'gmail.com')
print(str.partition("."))  # Output: ('xyz@gmail', '.', 'com')
print(str.partition("g"))  # Output: ('xyz@', 'g', 'mail.com')`}

{/* Other Functions */}

Other Important Functions

1. ord() - ASCII/Unicode Value

                      {`ch = 'A'
print(ord(ch))  # Output: 65

ch = 'a'
print(ord(ch))  # Output: 97`}

2. chr() - Character from ASCII/Unicode

                      {`print(chr(97))  # Output: a
print(chr(65))  # Output: A`}

{/* Jump Statements */}

Jump Statements

1. Break Statement

The break statement terminates the current loop. If break statement is inside a nested loop, break will terminate the innermost loop.

                      {`for val in "String":
    if val == 'i':
        break
    print(val)
print("end")

# Output:
# S
# t
# r
# end`}

2. Continue Statement

When a continue statement is encountered, the control jumps to the beginning of the loop for next iteration.

                      {`for val in "String":
    if val == 'i':
        continue
    print(val)
print("end")

# Output:
# S
# t
# r
# n
# g
# end`}

3. Pass Statement

It is used when a statement is required syntactically but you do not want any command or code to execute. The pass statement is a null operation; nothing happens when it executes.

                      {`S = ['p', 'y', 't', 'h', 'o', 'n']
for v in S:
    pass  # Nothing happens, just a placeholder

# Syntax: pass`}

{/* Local and Global Declaration */}

Local and Global Declaration

Note: This topic will be covered in detail in the Functions chapter. Local variables are accessible within the function where they are declared, while global variables can be accessed throughout the program.

{/* Mutable and Immutable */}

Mutable and Immutable Objects

Mutable

Objects CAN be changed after creation

• List
• Dictionary
• Set
• User defined classes

Immutable

Objects CAN'T be changed after creation

• Tuple
• String
• Numbers (int, float)
• Boolean

Important Note

Strings are immutable in Python. When you perform operations like concatenation or replacement, a new string object is created rather than modifying the existing one.

{/* Practice Examples */}

Practice Examples

Example 1: String Slicing

                        {`X = "AmaZing"
# Index:  0123456
# Index: -7-6-5-4-3-2-1

print(X[3:], "and", X[:2])      # Output: Zing and Am
print(X[-7:], "and", X[-4:-2])  # Output: AmaZing and Zi
print(X[2:7], "and", X[-4:-1])  # Output: aZing and Zin`}

Example 2: String Operations

                        {`x = "1bzz"
print(x[0:3] + 'c')  # Output: 1bzc

# Finding substring
text = "green vegetables"
print(text.find('g', 2))  # Output: 8 (finds 'g' starting from index 2)`}

Next Chapter: Lists in Python

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/strings-python/related.tsx" isMerged="true" import Link from "next/link" export default function StringsPythonRelated() { const relatedResources = [ { id: 1, title: "Python String Methods Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579", }, { id: 2, title: "String Manipulation Practice", type: "practical", url: "/computer-science/practical/class-11/string-operations", }, { id: 3, title: "String Methods Cheatsheet", type: "pdf", url: "/resources/string-methods-cheatsheet.pdf", }, { id: 4, title: "String MCQs Practice", type: "link", url: "/mcqs/computer-science/class-11/strings", }, { id: 5, title: "Python Fundamentals", type: "theory", url: "/computer-science/class-11/python-fundamentals", }, { id: 6, title: "Lists in Python", type: "theory", url: "/computer-science/class-11/lists-python", }, ] return (

Related Resources

{resource.type === "theory" && ( )} {resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.type === "practical" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance on Python programming.

Practice More

Try string manipulation exercises to strengthen your Python skills.

View Practical Programs →

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/strings-python/toc.tsx" isMerged="true" import Link from "next/link" export default function StringsPythonTOC() { const chapters = [ { id: 1, title: "Computer System Organization", slug: "computer-system-organization" }, { id: 2, title: "Data Representation and Boolean Logic", slug: "data-representation-boolean-logic" }, { id: 3, title: "Getting Started With Python", slug: "getting-started-with-python" }, { id: 4, title: "Python Programming Fundamentals", slug: "python-fundamentals" }, { id: 5, title: "Conditional And Looping Construct", slug: "conditional-looping-construct" }, { id: 6, title: "Strings in Python", slug: "strings-python" }, { id: 7, title: "Lists in Python", slug: "list-manipulation-python" }, { id: 8, title: "Tuples and Dictionary", slug: "tuples-dictionary" }, { id: 9, title: "Introduction to Python Modules", slug: "introduction-to-python-modules" }, { id: 10, title: "Society, Law and Ethics", slug: "society-law-ethics" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/tuples-dictionary/related.tsx" isMerged="true" import Link from "next/link" export default function TupleDictionaryRelated() { const relatedResources = [ { id: 1, title: "Python String Methods Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579", }, { id: 2, title: "String Manipulation Practice", type: "practical", url: "/computer-science/practical/class-11/string-operations", }, { id: 3, title: "String Methods Cheatsheet", type: "pdf", url: "/resources/string-methods-cheatsheet.pdf", }, { id: 4, title: "String MCQs Practice", type: "link", url: "/mcqs/computer-science/class-11/strings", }, { id: 5, title: "Python Fundamentals", type: "theory", url: "/computer-science/class-11/python-fundamentals", }, { id: 6, title: "Lists in Python", type: "theory", url: "/computer-science/class-11/lists-python", }, ] return (

Related Resources

{resource.type === "theory" && ( )} {resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.type === "practical" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance on Python programming.

Practice More

Try string manipulation exercises to strengthen your Python skills.

View Practical Programs →

) } [V0_FILE]typescriptreact:file="app/computer-science/class-11/tuples-dictionary/toc.tsx" isMerged="true" import Link from "next/link" export default function TuplesDictionaryTOC() { const chapters = [ { id: 1, title: "Computer System Organization", slug: "computer-system-organization" }, { id: 2, title: "Data Representation and Boolean Logic", slug: "data-representation-boolean-logic" }, { id: 3, title: "Getting Started With Python", slug: "getting-started-with-python" }, { id: 4, title: "Python Programming Fundamentals", slug: "python-fundamentals" }, { id: 5, title: "Conditional And Looping Construct", slug: "conditional-looping-construct" }, { id: 6, title: "Strings in Python", slug: "strings-python" }, { id: 7, title: "Lists in Python", slug: "list-manipulation-python" }, { id: 8, title: "Tuples and Dictionary", slug: "tuples-dictionary" }, { id: 9, title: "Introduction to Python Modules", slug: "introduction-to-python-module" }, { id: 10, title: "Society, Law and Ethics", slug: "society-law-ethics" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/computer-networks/related.tsx" isMerged="true" import Link from "next/link" import { FileText, Download, Video, BookOpen } from "lucide-react" export default function Related() { return (

{/* Related Topics */}

Study Resources

Practice MCQs

{/* Quick Links */}

Quick Access

Class 11 CS Class 12 IP

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/computer-networks/toc.tsx" isMerged="true" import Link from "next/link" export default function ComputerNetworkTOC() { const chapters = [ { id: 1, title: "Python Revision Tour 1", slug: "python-revision-tour-1" }, { id: 2, title: "Python Revision Tour 2", slug: "python-revision-tour-2" }, { id: 3, title: "Working With Functions", slug: "working-with-functions" }, { id: 4, title: "Data File Handling", slug: "data-file-handling" }, { id: 5, title: "Satck-Data Structure", slug: "stack-data-structure" }, { id: 6, title: "Relational Database and MySQL", slug: "relational-database-and-mysql" }, { id: 7, title: "Interface Python With MYSQL", slug: "interface-python-with-mysql" }, { id: 8, title: "Computer Networks", slug: "computer-networks" }, { id: 9, title: "Using Python Libraries", slug: "using-python-libraries" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/data-file-handling/related.tsx" isMerged="true" import Link from "next/link" export default function DataFileHandlingRelated() { const relatedResources = [ { id: 1, title: "Python Basics Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 2, title: "Python Cheatsheet", type: "pdf", url: "/resources/python-cheatsheet.pdf" }, { id: 3, title: "Python Practice Questions", type: "pdf", url: "/resources/python-practice.pdf" }, { id: 4, title: "Python MCQs", type: "link", url: "/mcqs/computer-science/class-11/python" }, ] return (

Related Resources

{resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/data-file-handling/toc.tsx" isMerged="true" import Link from "next/link" export default function DataFileHandlingTOC() { const chapters = [ { id: 1, title: "Python Revision Tour 1", slug: "python-revision-tour-1" }, { id: 2, title: "Python Revision Tour 2", slug: "python-revision-tour-2" }, { id: 3, title: "Working With Functions", slug: "working-with-functions" }, { id: 4, title: "Data File Handling", slug: "data-file-handling" }, { id: 5, title: "Satck-Data Structure", slug: "stack-data-structure" }, { id: 6, title: "Relational Database and MySQL", slug: "relational-database-and-mysql" }, { id: 7, title: "Interface Python With MYSQL", slug: "interface-python-with-mysql" }, { id: 8, title: "Computer Networks", slug: "computer-networks" }, { id: 9, title: "Using Python Libraries", slug: "using-python-libraries" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/interface-python-with-mysql/related.tsx" isMerged="true" import Link from "next/link" export default function DataFileHandlingRelated() { const relatedResources = [ { id: 1, title: "Python Basics Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 2, title: "Python Cheatsheet", type: "pdf", url: "/resources/python-cheatsheet.pdf" }, { id: 3, title: "Python Practice Questions", type: "pdf", url: "/resources/python-practice.pdf" }, { id: 4, title: "Python MCQs", type: "link", url: "/mcqs/computer-science/class-11/python" }, ] return (

Related Resources

{resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/interface-python-with-mysql/toc.tsx" isMerged="true" import Link from "next/link" export default function DataFileHandlingTOC() { const chapters = [ { id: 1, title: "Python Revision Tour 1", slug: "python-revision-tour-1" }, { id: 2, title: "Python Revision Tour 2", slug: "python-revision-tour-2" }, { id: 3, title: "Working With Functions", slug: "working-with-functions" }, { id: 4, title: "Data File Handling", slug: "data-file-handling" }, { id: 5, title: "Satck-Data Structure", slug: "stack-data-structure" }, { id: 6, title: "Relational Database and MySQL", slug: "relational-database-and-mysql" }, { id: 7, title: "Interface Python With MYSQL", slug: "interface-python-with-mysql" }, { id: 8, title: "Computer Networks", slug: "computer-networks" }, { id: 9, title: "Using Python Libraries", slug: "using-python-libraries" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/python-revision-tour-1/related.tsx" isMerged="true" import Link from "next/link" export default function PythonRevisionTour1Related() { const relatedResources = [ { id: 1, title: "Python Basics Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 2, title: "Python Cheatsheet", type: "pdf", url: "/resources/python-cheatsheet.pdf" }, { id: 3, title: "Python Practice Questions", type: "pdf", url: "/resources/python-practice.pdf" }, { id: 4, title: "Python MCQs", type: "link", url: "/mcqs/computer-science/class-11/python" }, ] return (

Related Resources

{resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/python-revision-tour-1/toc.tsx" isMerged="true" import Link from "next/link" export default function PythonRevisionTour1TOC() { const chapters = [ { id: 1, title: "Python Revision Tour 1", slug: "python-revision-tour-1" }, { id: 2, title: "Python Revision Tour 2", slug: "python-revision-tour-2" }, { id: 3, title: "Working With Functions", slug: "working-with-functions" }, { id: 4, title: "Data File Handling", slug: "data-file-handling" }, { id: 5, title: "Satck-Data Structure", slug: "stack-data-structure" }, { id: 6, title: "Relational Database and MySQL", slug: "relational-database-and-mysql" }, { id: 7, title: "Interface Python With MYSQL", slug: "interface-python-with-mysql" }, { id: 8, title: "Computer Networks", slug: "computer-networks" }, { id: 9, title: "Using Python Libraries", slug: "using-python-libraries" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/python-revision-tour-2/related.tsx" isMerged="true" import Link from "next/link" export default function PythonRevisionTour2Related() { const relatedResources = [ { id: 1, title: "Python Basics Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 2, title: "Python Cheatsheet", type: "pdf", url: "/resources/python-cheatsheet.pdf" }, { id: 3, title: "Python Practice Questions", type: "pdf", url: "/resources/python-practice.pdf" }, { id: 4, title: "Python MCQs", type: "link", url: "/mcqs/computer-science/class-11/python" }, ] return (

Related Resources

{resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/python-revision-tour-2/toc.tsx" isMerged="true" import Link from "next/link" export default function PythonRevisionTour2TOC() { const chapters = [ { id: 1, title: "Python Revision Tour 1", slug: "python-revision-tour-1" }, { id: 2, title: "Python Revision Tour 2", slug: "pythno-revision-tour-2" }, { id: 3, title: "Working With Functions", slug: "working-with-functions" }, { id: 4, title: "Data File Handling", slug: "data-file-handling" }, { id: 5, title: "Satck-Data Structure", slug: "stack-data-structure" }, { id: 6, title: "Relational Database and MySQL", slug: "relational-database-and-mysql" }, { id: 7, title: "Interface Python With MYSQL", slug: "interface-python-with-mysql" }, { id: 8, title: "Computer Networks", slug: "computer-networks" }, { id: 9, title: "Using Python Libraries", slug: "using-python-libraries" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/relational-database-and-mysql/toc.tsx" isMerged="true" import Link from "next/link" export default function RelationalDatabaseandMysqlTOC() { const chapters = [ { id: 1, title: "Python Revision Tour 1", slug: "python-revision-tour-1" }, { id: 2, title: "Python Revision Tour 2", slug: "python-revision-tour-2" }, { id: 3, title: "Working With Functions", slug: "working-with-functions" }, { id: 4, title: "Data File Handling", slug: "data-file-handling" }, { id: 5, title: "Satck-Data Structure", slug: "stack-data-structure" }, { id: 6, title: "Relational Database and MySQL", slug: "relational-database-and-mysql" }, { id: 7, title: "Interface Python With MYSQL", slug: "interface-python-with-mysql" }, { id: 8, title: "Computer Networks", slug: "computer-networks" }, { id: 9, title: "Using Python Libraries", slug: "using-python-libraries" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/stack-data-structure/related.tsx" isMerged="true" import Link from "next/link" export default function DataFileHandlingRelated() { const relatedResources = [ { id: 1, title: "Python Basics Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 2, title: "Python Cheatsheet", type: "pdf", url: "/resources/python-cheatsheet.pdf" }, { id: 3, title: "Python Practice Questions", type: "pdf", url: "/resources/python-practice.pdf" }, { id: 4, title: "Python MCQs", type: "link", url: "/mcqs/computer-science/class-11/python" }, ] return (

Related Resources

{resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/stack-data-structure/toc.tsx" isMerged="true" import Link from "next/link" export default function StackDataStructureTOC() { const chapters = [ { id: 1, title: "Python Revision Tour 1", slug: "python-revision-tour-1" }, { id: 2, title: "Python Revision Tour 2", slug: "python-revision-tour-2" }, { id: 3, title: "Working With Functions", slug: "working-with-functions" }, { id: 4, title: "Data File Handling", slug: "data-file-handling" }, { id: 5, title: "Satck-Data Structure", slug: "stack-data-structure" }, { id: 6, title: "Relational Database and MySQL", slug: "relational-database-and-mysql" }, { id: 7, title: "Interface Python With MYSQL", slug: "interface-python-with-mysql" }, { id: 8, title: "Computer Networks", slug: "computer-networks" }, { id: 9, title: "Using Python Libraries", slug: "using-python-libraries" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/working-with-functions/related.tsx" isMerged="true" import Link from "next/link" export default function WorkingWithFunctionsPage() { const relatedResources = [ { id: 1, title: "Python Basics Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 2, title: "Python Cheatsheet", type: "pdf", url: "/resources/python-cheatsheet.pdf" }, { id: 3, title: "Python Practice Questions", type: "pdf", url: "/resources/python-practice.pdf" }, { id: 4, title: "Python MCQs", type: "link", url: "/mcqs/computer-science/class-11/python" }, ] return (

Related Resources

{resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/class-12/working-with-functions/toc.tsx" isMerged="true" import Link from "next/link" export default function WorkingWithFunctionsTOC() { const chapters = [ { id: 1, title: "Python Revision Tour 1", slug: "python-revision-tour-1" }, { id: 2, title: "Python Revision Tour 2", slug: "python-revision-tour-2" }, { id: 3, title: "Working With Functions", slug: "working-with-functions" }, { id: 4, title: "Data File Handling", slug: "data-file-handling" }, { id: 5, title: "Satck-Data Structure", slug: "stack-data-structure" }, { id: 6, title: "DBMS-Mysql", slug: "dbms-mysql" }, { id: 7, title: "Interface Python With MYSQL", slug: "interface-python-with-mysql" }, { id: 8, title: "Computer Networks", slug: "computer-networks" }, { id: 9, title: "Using Python Libraries", slug: "using-python-libraries" }, ] return (

Chapters

{chapter.id}. {chapter.title}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/arithmetic-operations/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, Download } from "lucide-react" import TOC from "./toc" import Related from "./related" export default function ArithmeticOperationsPage() { return (

{/* Breadcrumb */}

Home Computer Science Practical Class 11 Arithmetic Operations

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Basic Arithmetic Operations Calculator

{/* AIM */}

AIM

To write a Python program that performs basic arithmetic operations (addition, subtraction, multiplication, division, and modulus) on two numbers entered by the user.

{/* ALGORITHM */}

ALGORITHM

Start
Take two numbers as input from the user
Perform addition and display the result
Perform subtraction and display the result
Perform multiplication and display the result
Perform division and display the result (check for division by zero)
Perform modulus operation and display the result
Perform floor division and display the result
Perform exponentiation and display the result
Stop

{/* PROGRAM */}

PROGRAM

                      
                        {`# Python program for basic arithmetic operations

print("Basic Arithmetic Operations Calculator")
print("=" * 45)

# Taking input from the user
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))

print("\\n" + "=" * 45)
print("ARITHMETIC OPERATIONS RESULTS")
print("=" * 45)

# Addition
addition = num1 + num2
print(f"Addition: {num1} + {num2} = {addition}")

# Subtraction
subtraction = num1 - num2
print(f"Subtraction: {num1} - {num2} = {subtraction}")

# Multiplication
multiplication = num1 * num2
print(f"Multiplication: {num1} × {num2} = {multiplication}")

# Division (with zero division check)
if num2 != 0:
    division = num1 / num2
    print(f"Division: {num1} ÷ {num2} = {division:.2f}")
else:
    print("Division: Cannot divide by zero!")

# Modulus (remainder)
if num2 != 0:
    modulus = num1 % num2
    print(f"Modulus: {num1} % {num2} = {modulus}")
else:
    print("Modulus: Cannot find remainder when dividing by zero!")

# Floor Division
if num2 != 0:
    floor_division = num1 // num2
    print(f"Floor Division: {num1} // {num2} = {floor_division}")
else:
    print("Floor Division: Cannot divide by zero!")

# Exponentiation
exponentiation = num1 ** num2
print(f"Exponentiation: {num1} ^ {num2} = {exponentiation}")

print("=" * 45)

# Additional calculations
print("\\nADDITIONAL INFORMATION:")
print("-" * 25)
print(f"Absolute difference: |{num1} - {num2}| = {abs(num1 - num2)}")
print(f"Average: ({num1} + {num2}) / 2 = {(num1 + num2) / 2}")
print(f"Maximum: max({num1}, {num2}) = {max(num1, num2)}")
print(f"Minimum: min({num1}, {num2}) = {min(num1, num2)}")`}

{/* OUTPUT */}

OUTPUT

Basic Arithmetic Operations Calculator

=============================================

Enter first number: 15

Enter second number: 4

=============================================

ARITHMETIC OPERATIONS RESULTS

=============================================

Addition: 15.0 + 4.0 = 19.0

Subtraction: 15.0 - 4.0 = 11.0

Multiplication: 15.0 × 4.0 = 60.0

Division: 15.0 ÷ 4.0 = 3.75

Modulus: 15.0 % 4.0 = 3.0

Floor Division: 15.0 // 4.0 = 3.0

Exponentiation: 15.0 ^ 4.0 = 50625.0

=============================================

ADDITIONAL INFORMATION:

-------------------------

Absolute difference: |15.0 - 4.0| = 11.0

Average: (15.0 + 4.0) / 2 = 9.5

Maximum: max(15.0, 4.0) = 15.0

Minimum: min(15.0, 4.0) = 4.0

{/* CONCLUSION */}

CONCLUSION

Thus, the given program was successfully executed and the output was verified as per the expected result.

{/* VIVA QUESTIONS */}

VIVA QUESTIONS

What are arithmetic operators in Python?

Arithmetic operators are symbols used to perform mathematical operations: +, -, *, /, %, //, and **.
What is the difference between / and // operators?

/ performs true division returning a float, while // performs floor division returning the quotient without the decimal part.
What does the modulus (%) operator do?

The modulus operator returns the remainder after division. For example, 15 % 4 = 3.
Why do we check for division by zero?

Division by zero is mathematically undefined and causes a ZeroDivisionError in Python, so we check to prevent program crashes.
What is the exponentiation operator?

The ** operator performs exponentiation, raising the first number to the power of the second number.
What is operator precedence?

Operator precedence determines the order of operations. In Python: ** > *, /, //, % > +, -. Parentheses have highest precedence.
What does the abs() function do?

The abs() function returns the absolute value of a number, which is always positive or zero.
How do you format floating-point numbers in output?

You can use f-strings with format specifiers like {`{value:.2f}`} to display 2 decimal places.

Next Program: Pattern Generation

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/arithmetic-operations/related.tsx" isMerged="true" import Link from "next/link" import { ExternalLink, FileText, BookOpen } from "lucide-react" export default function Related() { return (

{/* Related Programs */}

Related Programs

Number Comparison Series Sum GCD & LCM

{/* Study Resources */}

Study Resources

Python Fundamentals Flow of Control

{/* Quick Links */}

Quick Links

Class 11 MCQs Class 11 Theory

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/fibonacci-series/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, Download } from "lucide-react" import TOC from "./toc" import Related from "./related" export default function FibonacciSeriesPage() { return (

{/* Breadcrumb */}

Home Computer Science Practical Programs Class 11 Fibonacci Series

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Display Terms of Fibonacci Series

{/* AIM */}

AIM

To write a Python program that displays the terms of a Fibonacci series up to n terms as specified by the user.

Fibonacci Series:

A sequence where each number is the sum of the two preceding ones. The series starts with 0 and 1.
Example: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

{/* ALGORITHM */}

ALGORITHM

Start
Initialize first two terms: n1 = 0, n2 = 1
Input the number of terms from the user
Check if terms is less than or equal to 0 - display error message
If terms = 1, print only the first term (0)
If terms ≥ 2, print first two terms (0, 1)
Use a loop from 2 to terms:
- Calculate next_term = n1 + n2
- Print next_term
- Update n1 = n2 and n2 = next_term
Stop

{/* PROGRAM */}

PROGRAM

                      
                        {`# Display the terms of a Fibonacci series

n1 = 0
n2 = 1
terms = int(input("Enter the Terms of Fibonacci series you want to print: "))

if terms <= 0:
    print("Enter positive value of term.")
else:
    if terms == 1:
        print(n1, end=" ")
    else:
        print(n1, n2, end=" ")
        for i in range(2, terms):
            next_term = n1 + n2
            print(next_term, end=" ")
            n1 = n2
            n2 = next_term`}

{/* OUTPUT */}

OUTPUT

Test Case 1 (10 terms):

Enter the Terms of Fibonacci series you want to print: 10

0 1 1 2 3 5 8 13 21 34

Test Case 2 (5 terms):

Enter the Terms of Fibonacci series you want to print: 5

0 1 1 2 3

Test Case 3 (1 term):

Enter the Terms of Fibonacci series you want to print: 1

Test Case 4 (Invalid input):

Enter the Terms of Fibonacci series you want to print: -2

Enter positive value of term.

{/* CONCLUSION */}

CONCLUSION

Thus, the given program was successfully executed and the output was verified as per the expected result.

{/* VIVA QUESTIONS */}

VIVA QUESTIONS

What is the Fibonacci series and where is it found in nature?

The Fibonacci series is a sequence where each number is the sum of two preceding ones (0, 1, 1, 2, 3, 5, 8...). It appears in nature in flower petals, pinecones, shells, and spiral galaxies.
Why do we initialize n1=0 and n2=1?

These are the first two terms of the Fibonacci series by definition. The series starts with 0 and 1, and each subsequent term is calculated from these initial values.
What is the purpose of the end=" " parameter in print()?

The end=" " parameter prevents the print function from adding a newline character, allowing all numbers to be printed on the same line separated by spaces.
How does the variable swapping work in this program?

After calculating next_term, we update n1=n2 and n2=next_term. This shifts the values forward so the next iteration can calculate the subsequent term correctly.
Can you write a recursive version of this program?

Yes, using recursion: def fib(n): return n if n <= 1 else fib(n-1) + fib(n-2). However, the iterative approach is more efficient for large numbers.
What happens if the user enters 0 or negative number?

The program displays "Enter positive value of term." because the Fibonacci series requires at least one term to be meaningful.
What is the mathematical relationship in Fibonacci numbers?

Each term equals the sum of the two preceding terms: F(n) = F(n-1) + F(n-2), where F(0)=0 and F(1)=1.
How would you find the nth Fibonacci number without printing the series?

Use the same logic but don't print intermediate values. Keep updating n1 and n2 until you reach the nth position, then return n2.

Previous: Prime or Composite Next: GCD and LCM

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/fibonacci-series/related.tsx" isMerged="true" import Link from "next/link" import { BookOpen, FileText, Download, ExternalLink, Lightbulb, HelpCircle } from "lucide-react" export default function Related() { return (

{/* Related Programs */}

Related Programs

Series Sum

Mathematical series calculations

Prime Numbers

Number theory concepts

Pattern Generation

Loop-based patterns

GCD & LCM

Mathematical algorithms

{/* Theory Topics */}

Theory Topics

Flow of Control

Loops and iterations

Python Fundamentals

Basic programming concepts

{/* Study Resources */}

Study Resources

MCQs - Class 11

Practice questions

NCERT Solutions

Textbook answers

Sumita Arora Solutions

Reference book solutions

{/* Quick Tips */}

Quick Tips

Fibonacci Formula

F(n) = F(n-1) + F(n-2)

Variable Swapping

n1, n2 = n2, n1+n2 (Python way)

Golden Ratio

Fibonacci ratio approaches φ ≈ 1.618

{/* Help Section */}

Need Help?

Get personalized help

Online Tuition

1-on-1 programming help

{/* External Resources */}

External Resources

Fibonacci Numbers

Mathematical background

Python For Loops

Official documentation

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/gcd-lcm/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, Download } from "lucide-react" import TOC from "./toc" import Related from "./related" export default function GCDLCMPage() { return (

{/* Breadcrumb */}

Home Computer Science Practical Programs Class 11 GCD and LCM

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Compute GCD and LCM of Two Integers

{/* AIM */}

AIM

To write a Python program that computes the Greatest Common Divisor (GCD) and Least Common Multiple (LCM) of two integers.

Definitions:

GCD: The largest positive integer that divides both numbers without remainder
LCM: The smallest positive integer that is divisible by both numbers
Formula: LCM(a,b) = (a × b) / GCD(a,b)

{/* ALGORITHM */}

ALGORITHM

Start
Input two integers num1 and num2
Initialize gcd = 1
Check if num1 is divisible by num2
If yes, then gcd = num2
Otherwise, iterate from num2//2 down to 2
Find the largest number that divides both num1 and num2
Calculate LCM using formula: LCM = (num1 × num2) / GCD
Display the GCD and LCM
Stop

{/* PROGRAM */}

PROGRAM

                      
                        {`# Compute the greatest common divisor and least common multiple of two integers.

num1 = int(input("Enter First Number:"))
num2 = int(input("Enter Second Number:"))

gcd = 1

if num1 % num2 == 0:
    gcd = num2
else:
    for k in range(num2//2, 1, -1):
        if num1 % k == 0 and num2 % k == 0:
            gcd = k
            break

lcm = (num1 * num2) / gcd

print("GCD is:", gcd)
print("LCM is:", lcm)`}

{/* OUTPUT */}

OUTPUT

Test Case 1:

Enter First Number: 48

Enter Second Number: 18

GCD is: 6

LCM is: 144.0

Test Case 2:

Enter First Number: 15

Enter Second Number: 25

GCD is: 5

LCM is: 75.0

Test Case 3:

Enter First Number: 7

Enter Second Number: 13

GCD is: 1

LCM is: 91.0

{/* CONCLUSION */}

CONCLUSION

Thus, the given program was successfully executed and the output was verified as per the expected result.

{/* VIVA QUESTIONS */}

VIVA QUESTIONS

What is the difference between GCD and LCM?

GCD is the largest number that divides both numbers, while LCM is the smallest number that both numbers can divide. They are inversely related through the formula: GCD × LCM = num1 × num2.
Why do we start the loop from num2//2?

The largest possible common divisor (other than the number itself) cannot be greater than half of the smaller number. This optimization reduces the number of iterations.
What happens if we input two prime numbers?

If both numbers are prime and different, their GCD will be 1 (they are coprime) and their LCM will be their product.
Can you explain the Euclidean algorithm for GCD?

The Euclidean algorithm uses repeated division: GCD(a,b) = GCD(b, a%b) until the remainder becomes 0. It's more efficient than our current approach.
What is the time complexity of this algorithm?

The time complexity is O(min(num1, num2)) in the worst case, as we might iterate through half of the smaller number.
Why is LCM calculated as (num1 * num2) / gcd?

This formula comes from the mathematical relationship that for any two numbers, their product equals the product of their GCD and LCM.
What would happen if one of the inputs is 0?

If one number is 0, the GCD would be the other number (by convention), but LCM would be undefined or 0. The program should include input validation.
How can we modify this program to handle negative numbers?

We can use the absolute values of the inputs since GCD and LCM are typically defined for positive integers: abs(num1) and abs(num2).

Previous: Fibonacci Series Next: String Analysis

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/gcd-lcm/related.tsx" isMerged="true" import Link from "next/link" export default function Related() { const relatedResources = [ { id: 1, title: "Number Theory Basics", type: "theory", url: "/computer-science/class-11/python-fundamentals", }, { id: 2, title: "Mathematical Operations in Python", type: "video", url: "https://youtube.com/@pythontyro4579", }, { id: 3, title: "GCD LCM Algorithms PDF", type: "pdf", url: "/resources/gcd-lcm-algorithms.pdf", }, { id: 4, title: "Number Theory MCQs", type: "link", url: "/mcqs/computer-science/class-11/number-theory", }, { id: 5, title: "Prime Numbers Program", type: "practical", url: "/computer-science/practical/class-11/prime-composite", }, ] return (

Related Resources

{resource.type === "theory" && ( )} {resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.type === "practical" && ( )} {resource.title}

Mathematical Tips

• GCD × LCM = num1 × num2
• Use Euclidean algorithm for efficiency
• Handle edge cases (0, negative numbers)
• Understand prime factorization

Practice More

Try more mathematical programs to strengthen your problem-solving skills.

View All Programs →

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/largest-number/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, Download } from "lucide-react" import TOC from "./toc" import Related from "./related" export default function LargestNumberPage() { return (

{/* Breadcrumb */}

Home Computer Science Practical Programs Class 11 Largest Number

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Find the Largest Among Three Numbers

{/* AIM */}

AIM

To write a Python program that finds the largest among three numbers entered by the user.

{/* ALGORITHM */}

ALGORITHM

Start
Take three numbers as input from the user
Compare the first number with the second and third numbers
If the first number is greater than both the second and third numbers, it is the largest
Otherwise, compare the second number with the third number
If the second number is greater than the third number, it is the largest
Otherwise, the third number is the largest
Display the largest number
Stop

{/* PROGRAM */}

PROGRAM

                      
                        {`# Python program to find the largest among three numbers

#Write Any One Method
# Taking input from the user
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))
num3 = float(input("Enter third number: "))

# Method 1: Using if-elif-else statements
if num1 >= num2 and num1 >= num3:
    largest = num1
elif num2 >= num1 and num2 >= num3:
    largest = num2
else:
    largest = num3

print("The largest number is:", largest)

# Method 2: Using built-in max() function
# largest = max(num1, num2, num3)
# print("The largest number using max() function is:", largest)`}

{/* OUTPUT */}

OUTPUT

Enter first number: 25

Enter second number: 45

Enter third number: 15

The largest number is: 45.0

Enter first number: 89

Enter second number: 32

Enter third number: 67

The largest number is: 89.0

{/* CONCLUSION */}

CONCLUSION

Thus, the given program was successfully executed and the output was verified as per the expected result.

{/* VIVA QUESTIONS */}

VIVA QUESTIONS

What is the purpose of this program?

The purpose of this program is to find the largest among three numbers entered by the user.
What would happen if we input non-numeric values?

If non-numeric values are entered, the program will raise a ValueError because the float() function cannot convert strings like "abc" to floating-point numbers.
How can we modify this program to find the smallest number?

We can modify the program by changing the comparison operators from >= to <= or by using the min() function instead of max().
What is the advantage of using the max() function?

The max() function provides a more concise and readable solution. It can also handle more than three numbers easily.
How would you modify this program to find the largest among four numbers?

We would need to add another input for the fourth number and either extend the if-elif-else statements or simply add the fourth number to the max() function.

Next Program: Check if a number is prime

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/largest-number/related.tsx" isMerged="true" import Link from "next/link" export default function Related() { const relatedResources = [ { id: 1, title: "Python Conditional Statements", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 2, title: "Python Operators Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" }, { id: 3, title: "Python Input/Output", type: "pdf", url: "/resources/python-io.pdf" }, { id: 4, title: "Practice MCQs on Conditionals", type: "link", url: "/mcqs/computer-science/class-11/conditionals", }, ] return (

Related Resources

{resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing.

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/largest-number/toc.tsx" isMerged="true" import Link from "next/link" export default function TOC() { const programs = [ { id: 1, title: "Input a welcome message and display it", slug: "welcome-message" }, { id: 2, title: "Input two numbers and display the larger/smaller number", slug: "number-comparison" }, { id: 3, title: "Input three numbers and display the largest / smallest number", slug: "three-number-comparison" }, { id: 4, title: "Enter two integers and perform all arithmetic operations", slug: "arithmetic-operations" }, { id: 5, title: "Generate patterns using nested loop", slug: "pattern-generation" }, { id: 6, title: "Input x and n, print sum of series", slug: "series-sum" }, { id: 7, title: "Check perfect number, Armstrong number or palindrome", slug: "number-checks" }, { id: 8, title: "Check if number is prime or composite", slug: "prime-composite" }, { id: 9, title: "Display Fibonacci series terms", slug: "fibonacci-series" }, { id: 10, title: "Compute GCD and LCM of two integers", slug: "gcd-lcm" }, { id: 11, title: "Count vowels, consonants, uppercase, lowercase in string", slug: "string-analysis" }, { id: 12, title: "Check palindrome string and convert case", slug: "string-palindrome" }, { id: 13, title: "Find largest/smallest number in list/tuple", slug: "list-min-max" }, { id: 14, title: "Swap elements at even and odd locations", slug: "list-swap" }, { id: 15, title: "Search element in list/tuple", slug: "list-search" }, { id: 16, title: "Find smallest and largest number from list", slug: "list-extremes" }, { id: 17, title: "Dictionary with student marks above 75", slug: "student-marks" }, { id: 18, title: "Menu-driven student dictionary program", slug: "student-menu" }, { id: 19, title: "Choose 4 random lucky winners from 100 customers", slug: "lucky-winners" }, { id: 20, title: "String module operations menu", slug: "string-module" }, { id: 21, title: "Friends phone directory dictionary operations", slug: "phone-directory" }, ] return (

Class 11 Programs

{program.id}. {program.title}

Quick Tips

• Always test your programs with different inputs
• Use meaningful variable names
• Add comments to explain your code
• Practice regularly to improve coding skills

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/list-extremes/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, Download } from "lucide-react" import TOC from "./toc" import Related from "./related" export default function ListExtremesPage() { return (

{/* Breadcrumb */}

Home Computer Science Practical Programs Class 11 List Extremes

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Find Smallest and Largest Number from List

{/* AIM */}

AIM

To write a Python program that inputs a list of numbers and finds the smallest and largest number from the list using different methods.

Note: This program demonstrates multiple approaches: built-in functions (max/min) and sorting method for finding extremes in a list.

{/* ALGORITHM */}

ALGORITHM

Start
Initialize an empty list
Input the number of elements from user
Use a loop to input numbers and append them to the list
Method 1: Use built-in max() and min() functions
Method 2: Sort the list and access first and last elements
Display the maximum and minimum elements
Stop

{/* PROGRAM */}

PROGRAM

                      
                        {`# Input a list of numbers and find the smallest and largest number

# Method 1: Using built-in functions
lst = []
num = int(input("How many numbers: "))
for n in range(num):
    numbers = int(input("Enter Number: "))
    lst.append(numbers)

print("The entered list is:", lst)
print("Maximum element in the list is:", max(lst))
print("Minimum element in the list is:", min(lst))

# Method 2: Using sorting
print("\\nBy Method 2 (Sorting):")
lst.sort()
print("Maximum element in the list is:", lst[num - 1])
print("Minimum element in the list is:", lst[0])

print("\\n" + "=" * 50)
print("METHOD 3: Manual Search (Without Built-in Functions)")
print("=" * 50)

# Method 3: Manual search without built-in functions
lst3 = []
num3 = int(input("\\nHow many numbers: "))
for n in range(num3):
    numbers = int(input("Enter Number: "))
    lst3.append(numbers)

print("The entered list is:", lst3)

# Find maximum manually
maximum = lst3[0]
for i in range(1, len(lst3)):
    if lst3[i] > maximum:
        maximum = lst3[i]

# Find minimum manually
minimum = lst3[0]
for i in range(1, len(lst3)):
    if lst3[i] < minimum:
        minimum = lst3[i]

print("Maximum element (manual search):", maximum)
print("Minimum element (manual search):", minimum)

print("\\n" + "=" * 50)
print("METHOD 4: Using Tuple and Multiple Data Types")
print("=" * 50)

# Method 4: Working with mixed data (numbers only)
mixed_numbers = [45, 12, 78, 23, 67, 89, 34, 56]
print("Predefined list:", mixed_numbers)

# Find second largest and second smallest
sorted_list = sorted(mixed_numbers)
print("Sorted list:", sorted_list)
print("Largest:", sorted_list[-1])
print("Second largest:", sorted_list[-2])
print("Smallest:", sorted_list[0])
print("Second smallest:", sorted_list[1])

# Remove duplicates and find extremes
unique_numbers = list(set(mixed_numbers))
print("\\nUnique numbers:", unique_numbers)
print("Max from unique:", max(unique_numbers))
print("Min from unique:", min(unique_numbers))

print("\\n" + "=" * 50)
print("METHOD 5: Function-based Approach")
print("=" * 50)

def find_extremes(data_list):
    """Function to find min and max from a list"""
    if not data_list:
        return None, None
    
    minimum = maximum = data_list[0]
    
    for num in data_list[1:]:
        if num > maximum:
            maximum = num
        if num < minimum:
            minimum = num
    
    return minimum, maximum

def find_nth_largest(data_list, n):
    """Function to find nth largest element"""
    if len(data_list) < n:
        return None
    sorted_unique = sorted(set(data_list), reverse=True)
    return sorted_unique[n-1] if len(sorted_unique) >= n else None

# Demo with function
demo_list = [64, 25, 12, 22, 11, 90, 88, 76, 50, 42]
print(f"\\nDemo list: {demo_list}")

min_val, max_val = find_extremes(demo_list)
print(f"Minimum: {min_val}")
print(f"Maximum: {max_val}")

# Find nth largest
print(f"2nd largest: {find_nth_largest(demo_list, 2)}")
print(f"3rd largest: {find_nth_largest(demo_list, 3)}")

print("\\n" + "=" * 50)
print("PERFORMANCE COMPARISON")
print("=" * 50)

import time

# Large list for performance testing
large_list = list(range(10000, 0, -1))  # Descending order
print(f"\\nTesting with {len(large_list)} elements...")

# Time built-in functions
start_time = time.time()
max_builtin = max(large_list)
min_builtin = min(large_list)
builtin_time = time.time() - start_time

# Time manual search
start_time = time.time()
manual_min, manual_max = find_extremes(large_list)
manual_time = time.time() - start_time

# Time sorting method
start_time = time.time()
sorted_list = sorted(large_list)
sort_max = sorted_list[-1]
sort_min = sorted_list[0]
sort_time = time.time() - start_time

print(f"Built-in functions time: {builtin_time:.6f} seconds")
print(f"Manual search time: {manual_time:.6f} seconds")
print(f"Sorting method time: {sort_time:.6f} seconds")
print(f"\\nAll methods give same result: {max_builtin == manual_max == sort_max}")`}

{/* OUTPUT */}

OUTPUT

How many numbers: 5

Enter Number: 45

Enter Number: 12

Enter Number: 78

Enter Number: 23

Enter Number: 67

The entered list is: [45, 12, 78, 23, 67]

Maximum element in the list is: 78

Minimum element in the list is: 12

By Method 2 (Sorting):

Maximum element in the list is: 78

Minimum element in the list is: 12

==================================================

METHOD 4: Using Tuple and Multiple Data Types

==================================================

Predefined list: [45, 12, 78, 23, 67, 89, 34, 56]

Sorted list: [12, 23, 34, 45, 56, 67, 78, 89]

Largest: 89

Second largest: 78

Smallest: 12

Second smallest: 23

==================================================

METHOD 5: Function-based Approach

==================================================

Demo list: [64, 25, 12, 22, 11, 90, 88, 76, 50, 42]

Minimum: 11

Maximum: 90

2nd largest: 88

3rd largest: 76

{/* CONCLUSION */}

CONCLUSION

Thus, the given program was successfully executed and the output was verified as per the expected result.

{/* VIVA QUESTIONS */}

VIVA QUESTIONS

What is the time complexity of max() and min() functions?

Both max() and min() have O(n) time complexity as they need to examine each element once to find the extreme values.
Which method is most efficient for finding both max and min?

Using built-in max() and min() functions is most efficient. Manual search in single loop is also good. Sorting is least efficient with O(n log n) complexity.
What happens if the list is empty?

max() and min() functions raise ValueError on empty lists. Always check if list is empty before calling these functions.
How do you find the second largest element?

Sort the list and access second last element, or use set() to remove duplicates first, then sort and access appropriate index.
What is the difference between sort() and sorted()?

sort() modifies the original list in-place and returns None. sorted() returns a new sorted list without modifying the original.
How can you find extremes without using built-in functions?

Initialize max and min with first element, then iterate through remaining elements comparing and updating max/min values as needed.
Can these methods work with floating-point numbers?

Yes, all methods work with float numbers. Just change int(input()) to float(input()) for decimal number inputs.
How do you handle duplicate values when finding nth largest?

Use set() to remove duplicates first, then sort. This ensures you get truly distinct nth largest value, not just nth position in sorted list.

Next Program: Student Marks Dictionary

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/list-extremes/related.tsx" isMerged="true" import Link from "next/link" export default function Related() { const relatedResources = [ { id: 1, title: "List Manipulation Python", type: "theory", url: "/computer-science/class-11/list-manipulation-python", }, { id: 2, title: "Sorting Algorithms Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579", }, { id: 3, title: "Python Built-in Functions PDF", type: "pdf", url: "/resources/python-builtin-functions.pdf", }, { id: 4, title: "List Operations MCQs", type: "link", url: "/mcqs/computer-science/class-11/list-operations", }, { id: 5, title: "Previous Program: List Search", type: "practical", url: "/computer-science/practical/class-11/list-search", }, ] return (

Related Resources

{resource.type === "theory" && ( )} {resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.type === "practical" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Performance Tips

• Use max()/min() for single pass efficiency
• Avoid sorting for simple min/max finding
• Handle empty lists with proper checks
• Consider memory usage with large datasets

Practice More

Try more list manipulation and algorithm programs.

View All Programs →

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/list-min-max/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, Download } from "lucide-react" import TOC from "./toc" import Related from "./related" export default function ListMinMaxPage() { return (

{/* Breadcrumb */}

Home Computer Science Practical Programs Class 11 List Min-Max

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Find Largest/Smallest Number in List/Tuple

{/* AIM */}

AIM

To write a Python program that finds the largest and smallest numbers in a list/tuple, including second largest and second smallest elements.

Key Concepts:

• List Sorting: Using sort() method to arrange elements
• List Indexing: Accessing elements by position
• Built-in Functions: Using max() and min() functions

{/* ALGORITHM */}

ALGORITHM

Method 1 - Using Sorting:

Start
Initialize a list with numbers
Find the length of the list
Sort the list in ascending order using sort()
Access first element for smallest (index 0)
Access last element for largest (index length-1)
Access second element for second smallest (index 1)
Access second last element for second largest (index length-2)
Display all results
Stop

Method 2 - Using Built-in Functions:

Use max() function to find largest element
Use min() function to find smallest element
Remove max element and find max again for second largest
Remove min element and find min again for second smallest

{/* PROGRAM */}

PROGRAM

Method 1 - Using Sorting:

                      
                        {`# Find the largest/smallest number in a list/tuple
lst = [12, 34, 43, 67, 33, 3, 10]
length = len(lst)
lst.sort()

print("Largest element is:", lst[length-1])
print("Smallest element is:", lst[0])
print("Second Largest element is:", lst[length-2])
print("Second smallest element is:", lst[1])`}

Method 2 - Using Built-in Functions:

                      
                        {`# Alternative method using max() and min() functions
lst = [12, 34, 43, 67, 33, 3, 10]
print("Original List:", lst)

# Find largest and smallest
largest = max(lst)
smallest = min(lst)

print("Largest element is:", largest)
print("Smallest element is:", smallest)

# Find second largest and second smallest
lst_copy = lst.copy()
lst_copy.remove(largest)
second_largest = max(lst_copy)

lst_copy2 = lst.copy()
lst_copy2.remove(smallest)
second_smallest = min(lst_copy2)

print("Second Largest element is:", second_largest)
print("Second smallest element is:", second_smallest)`}

Method 3 - Working with Tuples:

                      
                        {`# Working with tuples
tup = (12, 34, 43, 67, 33, 3, 10)
print("Original Tuple:", tup)

# Convert tuple to list for sorting
lst = list(tup)
lst.sort()

print("Largest element is:", lst[-1])
print("Smallest element is:", lst[0])
print("Second Largest element is:", lst[-2])
print("Second smallest element is:", lst[1])`}

{/* OUTPUT */}

OUTPUT

Method 1 Output:

Largest element is: 67

Smallest element is: 3

Second Largest element is: 43

Second smallest element is: 10

Method 2 Output:

Original List: [12, 34, 43, 67, 33, 3, 10]

Largest element is: 67

Smallest element is: 3

Second Largest element is: 43

Second smallest element is: 10

Method 3 Output (Tuple):

Original Tuple: (12, 34, 43, 67, 33, 3, 10)

Largest element is: 67

Smallest element is: 3

Second Largest element is: 43

Second smallest element is: 10

{/* CONCLUSION */}

CONCLUSION

Thus, the given program was successfully executed and the output was verified as per the expected result.

{/* VIVA QUESTIONS */}

VIVA QUESTIONS

What is the difference between sort() and sorted() in Python?

sort() modifies the original list in-place and returns None, while sorted() returns a new sorted list without modifying the original.
How do negative indices work in Python lists?

Negative indices count from the end of the list. -1 refers to the last element, -2 to the second last, and so on.
What happens if the list has duplicate maximum values?

max() returns one instance of the maximum value. For second largest, you need to remove all instances of the maximum value.
Can you use these methods on tuples directly?

max() and min() work directly on tuples, but sort() doesn't. You need to convert tuple to list first for sorting.
What is the time complexity of the sorting approach?

The sorting approach has O(n log n) time complexity, while the max/min approach has O(n) time complexity.
How would you handle an empty list?

Check if the list is empty using len(lst) == 0 or if not lst before applying max/min functions to avoid ValueError.
What if the list has only one element?

For a single element list, largest and smallest are the same. Second largest and smallest would cause IndexError.
How can you find the third largest element?

After sorting, use lst[-3] for third largest, or remove the two largest elements and find max of remaining elements.

Previous: String Palindrome Next: List Swap

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/list-min-max/related.tsx" isMerged="true" import Link from "next/link" export default function Related() { const relatedResources = [ { id: 1, title: "List Manipulation in Python", type: "theory", url: "/computer-science/class-11/list-manipulation-python", }, { id: 2, title: "Tuples and Dictionary", type: "theory", url: "/computer-science/class-11/tuples-dictionary", }, { id: 3, title: "List Extremes Program", type: "practical", url: "/computer-science/practical/class-11/list-extremes", }, { id: 4, title: "List Search Program", type: "practical", url: "/computer-science/practical/class-11/list-search", }, { id: 5, title: "Python Lists MCQs", type: "link", url: "/mcqs/computer-science/class-11/lists", }, ] return (

Related Resources

{resource.type === "theory" && ( )} {resource.type === "practical" && ( )} {resource.type === "link" && ( )} {resource.title}

List Tips

• Use sort() for in-place sorting
• Negative indices count from end
• max()/min() work on any iterable
• Handle empty lists to avoid errors

Practice More

Try more list manipulation programs to master data structures.

View All Programs →

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/list-search/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, Download } from "lucide-react" import TOC from "./toc" import Related from "./related" export default function ListSearchPage() { return (

{/* Breadcrumb */}

Home Computer Science Practical Programs Class 11 List Search

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Search Element in List/Tuple

{/* AIM */}

AIM

To write a Python program that inputs a list/tuple of elements and searches for a given element, displaying its index and position if found.

Note: Index starts from 0, while position starts from 1. Index is used in programming, position is more user-friendly.

{/* ALGORITHM */}

ALGORITHM

Start
Initialize an empty list
Input the number of elements from user
Use a loop to input elements and append them to the list
Display the entered list
Input the element to be searched
Use a loop to iterate through the list
Compare each element with the search element
If found, display the index and position, then break
If loop completes without finding, display "not found" message
Stop

{/* PROGRAM */}

PROGRAM

                      
                        {`# Input a list/tuple of elements, search for a given element

# Method 1: Linear Search in List
lst = []
num = int(input("How many Numbers in the list: "))
for n in range(num):
    numbers = int(input("Enter Number: "))
    lst.append(numbers)

print("The Entered list is:", lst)
length = len(lst)
element = int(input("Enter the element to be searched for: "))

for i in range(0, length):
    if element == lst[i]:
        print(element, "found at index", i, "and position:", i + 1)
        break
else:
    print(element, "is not found!!!")

print("\\n" + "=" * 50)
print("METHOD 2: Using Built-in Methods")
print("=" * 50)

# Method 2: Using built-in methods
lst2 = []
num2 = int(input("\\nHow many Numbers in the list: "))
for n in range(num2):
    numbers = int(input("Enter Number: "))
    lst2.append(numbers)

print("The Entered list is:", lst2)
element2 = int(input("Enter the element to be searched for: "))

if element2 in lst2:
    index = lst2.index(element2)
    print(element2, "found at index", index, "and position:", index + 1)
    
    # Count occurrences
    count = lst2.count(element2)
    print(f"Element {element2} appears {count} time(s) in the list")
    
    # Find all occurrences
    all_indices = [i for i, x in enumerate(lst2) if x == element2]
    print(f"All indices where {element2} is found: {all_indices}")
else:
    print(element2, "is not found!!!")

print("\\n" + "=" * 50)
print("METHOD 3: Search in Tuple")
print("=" * 50)

# Method 3: Search in Tuple
tuple_elements = []
num3 = int(input("\\nHow many elements in tuple: "))
for n in range(num3):
    element_input = input("Enter element: ")
    # Try to convert to int, if fails keep as string
    try:
        element_input = int(element_input)
    except ValueError:
        pass
    tuple_elements.append(element_input)

my_tuple = tuple(tuple_elements)
print("The Entered tuple is:", my_tuple)

search_element = input("Enter the element to be searched for: ")
# Try to convert search element to int if possible
try:
    search_element = int(search_element)
except ValueError:
    pass

found = False
for i, item in enumerate(my_tuple):
    if item == search_element:
        print(f"{search_element} found at index {i} and position {i + 1}")
        found = True
        break

if not found:
    print(f"{search_element} is not found in the tuple!!!")

print("\\n" + "=" * 50)
print("METHOD 4: Function-based Search")
print("=" * 50)

def linear_search(data_list, target):
    """Function to perform linear search"""
    for i, item in enumerate(data_list):
        if item == target:
            return i
    return -1

def search_all_occurrences(data_list, target):
    """Function to find all occurrences of target"""
    indices = []
    for i, item in enumerate(data_list):
        if item == target:
            indices.append(i)
    return indices

# Demo with predefined data
demo_list = [10, 20, 30, 20, 40, 20, 50]
print(f"\\nDemo list: {demo_list}")
target = 20

result = linear_search(demo_list, target)
if result != -1:
    print(f"First occurrence of {target} found at index {result}")
else:
    print(f"{target} not found in the list")

all_occurrences = search_all_occurrences(demo_list, target)
if all_occurrences:
    print(f"All occurrences of {target} at indices: {all_occurrences}")
    print(f"Total occurrences: {len(all_occurrences}")
else:
    print(f"{target} not found in the list")`}

{/* OUTPUT */}

OUTPUT

How many Numbers in the list: 5

Enter Number: 10

Enter Number: 20

Enter Number: 30

Enter Number: 40

Enter Number: 50

The Entered list is: [10, 20, 30, 40, 50]

Enter the element to be searched for: 30

30 found at index 2 and position: 3

==================================================

METHOD 2: Using Built-in Methods

==================================================

How many Numbers in the list: 4

Enter Number: 5

Enter Number: 15

Enter Number: 25

Enter Number: 35

The Entered list is: [5, 15, 25, 35]

Enter the element to be searched for: 100

100 is not found!!!

==================================================

METHOD 4: Function-based Search

==================================================

Demo list: [10, 20, 30, 20, 40, 20, 50]

First occurrence of 20 found at index 1

All occurrences of 20 at indices: [1, 3, 5]

Total occurrences: 3

{/* CONCLUSION */}

CONCLUSION

Thus, the given program was successfully executed and the output was verified as per the expected result.

{/* VIVA QUESTIONS */}

VIVA QUESTIONS

What is the difference between index and position?

Index starts from 0 and is used in programming, while position starts from 1 and is more user-friendly. Position = Index + 1.
How does the for-else construct work in Python?

The else block executes only if the loop completes normally (without encountering a break). If break is executed, the else block is skipped.
What is the time complexity of linear search?

Linear search has O(n) time complexity in worst case, where n is the number of elements. Best case is O(1) when element is found at first position.
What happens if we use index() method on non-existent element?

The index() method raises a ValueError if the element is not found. That's why we use 'in' operator first to check existence.
How can you find all occurrences of an element?

Use list comprehension: [i for i, x in enumerate(lst) if x == target] or iterate through the list and collect all matching indices.
What is the difference between searching in list vs tuple?

The search algorithm is the same, but tuples are immutable. Lists can be modified during search, while tuples cannot. Both support indexing and iteration.
How would you implement binary search?

Binary search requires a sorted list and has O(log n) complexity. It repeatedly divides the search space in half by comparing with the middle element.
What is the advantage of using enumerate() function?

enumerate() returns both index and value in each iteration, making code cleaner than manually tracking index with range(len(list)).

Next Program: List Extremes

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/list-search/related.tsx" isMerged="true" import Link from "next/link" export default function Related() { const relatedResources = [ { id: 1, title: "List Manipulation Python", type: "theory", url: "/computer-science/class-11/list-manipulation-python", }, { id: 2, title: "Search Algorithms Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579", }, { id: 3, title: "Python Search Methods PDF", type: "pdf", url: "/resources/python-search.pdf", }, { id: 4, title: "Search Algorithm MCQs", type: "link", url: "/mcqs/computer-science/class-11/search-algorithms", }, { id: 5, title: "Previous Program: List Swap", type: "practical", url: "/computer-science/practical/class-11/list-swap", }, ] return (

Related Resources

{resource.type === "theory" && ( )} {resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.type === "practical" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Search Tips

• Use 'in' operator for simple existence checks
• Handle ValueError when using index() method
• Consider binary search for sorted data
• Use enumerate() for index-value pairs

Practice More

Try more search and list programs to improve your skills.

View All Programs →

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/list-swap/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, Download } from "lucide-react" import TOC from "./toc" import Related from "./related" export default function ListSwapPage() { return (

{/* Breadcrumb */}

Home Computer Science Practical Programs Class 11 List Element Swap

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Swap Elements at Even and Odd Locations

{/* AIM */}

AIM

To write a Python program that inputs a list of numbers and swaps elements at even locations with elements at odd locations.

Note: In this program, even and odd locations refer to indices. Index 0 (even) swaps with index 1 (odd), index 2 (even) swaps with index 3 (odd), and so on.

{/* ALGORITHM */}

ALGORITHM

Start
Initialize an empty list L
Input the size of the list from user
Use a loop to input elements and append them to the list
Display the original list
Use a loop with step 2 to iterate through even indices (0, 2, 4, ...)
For each even index i, swap L[i] with L[i+1] using temporary variables
Display the list after swapping
Stop

{/* PROGRAM */}

PROGRAM

                      
                        {`# Input a list of numbers and swap elements at even location with odd location

# Code to get list from user
L = []
N = int(input("Enter the size of the list: "))
print("Enter the elements one by one:")
for i in range(N):
    Element = int(input("-> "))
    L.append(Element)

print("The given List is:")
print(L)

# Swap the elements at even location with the elements at odd location
for i in range(0, N, 2):
    if i + 1 < N:  # Check if odd index exists
        temp1 = L[i]
        temp2 = L[i + 1]
        L[i] = temp2
        L[i + 1] = temp1

print("\\nThe List after swapping is:")
print(L)

# Alternative method using tuple unpacking
print("\\n" + "=" * 50)
print("ALTERNATIVE METHOD - Using Tuple Unpacking")
print("=" * 50)

# Reset the list for demonstration
L2 = []
N2 = int(input("\\nEnter the size of the list: "))
print("Enter the elements one by one:")
for i in range(N2):
    Element = int(input("-> "))
    L2.append(Element)

print("The given List is:")
print(L2)

# Swap using tuple unpacking (Pythonic way)
for i in range(0, N2, 2):
    if i + 1 < N2:
        L2[i], L2[i + 1] = L2[i + 1], L2[i]

print("\\nThe List after swapping is:")
print(L2)

# Method 3: Function-based approach
def swap_even_odd(lst):
    """Function to swap elements at even and odd positions"""
    n = len(lst)
    for i in range(0, n, 2):
        if i + 1 < n:
            lst[i], lst[i + 1] = lst[i + 1], lst[i]
    return lst

print("\\n" + "=" * 50)
print("FUNCTION-BASED APPROACH")
print("=" * 50)

# Demo with predefined list
demo_list = [10, 20, 30, 40, 50, 60, 70]
print(f"\\nOriginal list: {demo_list}")
swapped_list = swap_even_odd(demo_list.copy())
print(f"After swapping: {swapped_list}")

# Demo with odd number of elements
odd_list = [1, 2, 3, 4, 5]
print(f"\\nOriginal odd list: {odd_list}")
swapped_odd = swap_even_odd(odd_list.copy())
print(f"After swapping: {swapped_odd}")`}

{/* OUTPUT */}

OUTPUT

Enter the size of the list: 6

Enter the elements one by one:

{"-> 10"}

{"-> 20"}

{"-> 30"}

{"-> 40"}

{"-> 50"}

{"-> 60"}

The given List is:

[10, 20, 30, 40, 50, 60]

The List after swapping is:

[20, 10, 40, 30, 60, 50]

==================================================

FUNCTION-BASED APPROACH

==================================================

Original list: [10, 20, 30, 40, 50, 60, 70]

After swapping: [20, 10, 40, 30, 60, 50, 70]

Original odd list: [1, 2, 3, 4, 5]

After swapping: [2, 1, 4, 3, 5]

{/* CONCLUSION */}

CONCLUSION

Thus, the given program was successfully executed and the output was verified as per the expected result.

{/* VIVA QUESTIONS */}

VIVA QUESTIONS

What does range(0, N, 2) do in this program?

range(0, N, 2) generates a sequence starting from 0, up to N-1, with a step of 2. This gives us even indices: 0, 2, 4, 6, etc.
Why do we check if i+1 {"< N"} before swapping?

This prevents IndexError when the list has odd number of elements. The last element at even index would not have a corresponding odd index to swap with.
What happens if the list has only one element?

If the list has only one element, the loop range(0, 1, 2) will execute once with i=0, but the condition i+1 {"< N"} (0+1 {"< 1"}) will be false, so no swapping occurs.
What is the advantage of tuple unpacking over temporary variables?

Tuple unpacking (a, b = b, a) is more concise, readable, and Pythonic. It eliminates the need for temporary variables and reduces the chance of errors.
How would you modify this program to swap every 3rd element?

Change the range to range(0, N, 3) and swap L[i] with L[i+2], ensuring i+2 {"< N"} to avoid index errors.
What is the time complexity of this swapping algorithm?

The time complexity is O(n) where n is the number of elements, as we iterate through the list once with step 2, performing constant-time swap operations.
Can this program work with strings or other data types?

Yes, the swapping logic works with any data type. You would just need to modify the input section to accept strings or other types instead of integers.
How would you swap elements at specific user-defined positions?

Take two position inputs from user, validate they are within list bounds, then swap using L[pos1], L[pos2] = L[pos2], L[pos1].

Next Program: List Search

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/list-swap/related.tsx" isMerged="true" import Link from "next/link" export default function Related() { const relatedResources = [ { id: 1, title: "List Manipulation Python", type: "theory", url: "/computer-science/class-11/list-manipulation-python", }, { id: 2, title: "Python Lists Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579", }, { id: 3, title: "List Methods PDF", type: "pdf", url: "/resources/python-lists.pdf", }, { id: 4, title: "List Manipulation MCQs", type: "link", url: "/mcqs/computer-science/class-11/list-manipulation", }, { id: 5, title: "Next Program: List Search", type: "practical", url: "/computer-science/practical/class-11/list-search", }, ] return (

Related Resources

{resource.type === "theory" && ( )} {resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.type === "practical" && ( )} {resource.title} {resource.type === "pdf" && ( )}

List Tips

• Always check array bounds before accessing
• Use tuple unpacking for clean swaps
• Consider edge cases like empty or single-element lists
• Test with both even and odd length lists

Practice More

Try more list manipulation programs to strengthen your skills.

View All Programs →

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/lucky-winners/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, Download } from "lucide-react" import TOC from "./toc" import Related from "./related" export default function LuckyWinnersPage() { return (

{/* Breadcrumb */}

Home Computer Science Practical Programs Class 11 Lucky Winners

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Choose 4 Random Lucky Winners from 100 Customers

{/* AIM */}

AIM

To write a Python program that randomly selects 4 customers as lucky winners from a pool of 100 customers using the random module.

{/* ALGORITHM */}

ALGORITHM

Start
Import the random module
Generate first random number between 1 and 100 for customer 1
Generate second random number between 1 and 100 for customer 2
Generate third random number between 1 and 100 for customer 3
Generate fourth random number between 1 and 100 for customer 4
Display all four lucky winner customer numbers
Stop

{/* PROGRAM */}

PROGRAM

                      
                        {`# Method 1: Basic approach (may have duplicates)
import random

c1 = random.randint(1, 100)
c2 = random.randint(1, 100)
c3 = random.randint(1, 100)
c4 = random.randint(1, 100)

print("Lucky winners are:", c1, c2, c3, c4)

# Method 2: Using random.sample() to avoid duplicates
import random

customers = list(range(1, 101))  # Create list of customers 1-100
lucky_winners = random.sample(customers, 4)

print("Lucky winners are:", lucky_winners)

# Method 3: Using set to ensure unique winners
import random

winners = set()
while len(winners) < 4:
    winner = random.randint(1, 100)
    winners.add(winner)

print("Lucky winners are:", list(winners))`}

{/* OUTPUT */}

OUTPUT

Method 1 Output:

Lucky winners are: 23 67 45 89

Method 2 Output:

Lucky winners are: [12, 78, 34, 91]

Method 3 Output:

Lucky winners are: [56, 23, 87, 14]

{/* CONCLUSION */}

CONCLUSION

Thus, the given program was successfully executed and the output was verified as per the expected result.

{/* VIVA QUESTIONS */}

VIVA QUESTIONS

What is the purpose of the random module in Python?

The random module provides functions to generate random numbers, make random selections, and shuffle sequences. It's useful for simulations, games, testing, and statistical sampling.
What is the difference between random.randint() and random.sample()?

random.randint(a, b) generates a single random integer between a and b (inclusive), while random.sample(population, k) selects k unique elements from a population without replacement.
Why might the basic method produce duplicate winners?

Since each random.randint() call is independent, there's a possibility that the same number could be generated multiple times, resulting in duplicate customer numbers.
How does random.sample() ensure unique winners?

random.sample() uses sampling without replacement, meaning once a number is selected, it cannot be selected again in the same operation, guaranteeing unique results.
What would happen if we try to sample more elements than available?

If we try random.sample(range(1, 101), 150), Python would raise a ValueError because we cannot sample 150 unique elements from a population of only 100.
How can we make the random selection reproducible?

We can use random.seed() with a specific value before generating random numbers. This ensures the same sequence of random numbers is generated each time the program runs.
What is the advantage of using a set in Method 3?

Sets automatically handle duplicates - if the same number is generated twice, it's only stored once. The while loop continues until we have exactly 4 unique winners.
How would you modify this program to select winners from a list of customer names?

We could create a list of customer names and use random.sample(customer_names, 4) to directly select 4 random names from the list.

Next Program: String Module Operations

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/lucky-winners/related.tsx" isMerged="true" import Link from "next/link" export default function Related() { const relatedResources = [ { id: 1, title: "Python Fundamentals", type: "theory", url: "/computer-science/class-11/python-fundamentals", }, { id: 2, title: "Python Input/Output Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579", }, { id: 3, title: "Python Basics PDF", type: "pdf", url: "/resources/python-basics.pdf", }, { id: 4, title: "Python Fundamentals MCQs", type: "link", url: "/mcqs/computer-science/class-11/python-fundamentals", }, { id: 5, title: "Next Program: Number Comparison", type: "practical", url: "/computer-science/practical/class-11/number-comparison", }, ] return (

Related Resources

{resource.type === "theory" && ( )} {resource.type === "video" && ( )} {resource.type === "pdf" && ( )} {resource.type === "link" && ( )} {resource.type === "practical" && ( )} {resource.title} {resource.type === "pdf" && ( )}

Need Help?

Join our tuition classes for personalized guidance and doubt clearing sessions.

Practice More

Try more Python programs to strengthen your programming skills.

View All Programs →

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/number-checks/page.tsx" isMerged="true" import Link from "next/link" import { ChevronRight, Download } from "lucide-react" import TOC from "./toc" import Related from "./related" export default function NumberChecksPage() { return (

{/* Breadcrumb */}

Home Computer Science Practical Programs Class 11 Number Checks

{/* Main Content */}

{/* Left Sidebar - TOC */}

{/* Middle Content */}

Check Perfect Number, Armstrong Number or Palindrome

{/* AIM */}

AIM

To write Python programs that determine whether a number is a perfect number, an Armstrong number, or a palindrome.

Definitions:

Perfect Number: A positive integer equal to the sum of its proper divisors (excluding itself). Example: 6 = 1 + 2 + 3
Armstrong Number: A number equal to the sum of its digits raised to the power of number of digits. Example: 371 = 3³ + 7³ + 1³
Palindrome: A number that reads the same forwards and backwards. Example: 121, 1331

{/* ALGORITHM */}

ALGORITHM

Perfect Number Algorithm:

Start
Input a number n
Initialize sum = 0
For i from 1 to n-1:
If n % i == 0, then sum = sum + i
If sum == n, then it's a perfect number
Else, it's not a perfect number
Stop

Armstrong Number Algorithm:

Start
Input a number n
Count the number of digits
Initialize sum = 0
For each digit in the number:
Extract the digit and raise it to the power of number of digits
Add to sum
If sum equals original number, it's Armstrong
Stop

Palindrome Algorithm:

Start
Input a number n
Initialize reverse = 0
Store original number in temp
While n != 0:
Extract last digit
reverse = reverse * 10 + last_digit
n = n // 10
If temp == reverse, it's palindrome
Stop

{/* PROGRAM */}

PROGRAMS

Program 1: Perfect Number Check

                      
                        {`# Determine whether a number is a perfect number
n = int(input("Enter any number: "))
sum = 0
i = 1

for i in range(1, n):
    if(n % i == 0):
        sum = sum + i

if (n == sum):
    print("The number is a Perfect number!")
else:
    print("The number is not a Perfect number!")`}

Program 2: Armstrong Number Check

                      
                        {`# Finding Armstrong Number
n1 = int(input("Enter any number: "))
temp = num = n1
no_of_digits = 0

# Count number of digits
while(num != 0):
    no_of_digits += 1
    num = int(num / 10)

print("No of digits is:", no_of_digits)

# Sum of the digits power raise to no of digits
sum = 0
while(n1 != 0):
    last_digit = n1 % 10
    sum += (last_digit ** no_of_digits)
    n1 = int(n1 / 10)

# Checking Armstrong Number
if(sum == temp):
    print("Number is Armstrong number")
else:
    print("Number is Not Armstrong number")`}

Program 3: Palindrome Check

                      
                        {`# Finding Palindrome or Not
n = int(input("Enter the Number: "))
rev = 0
temp = n

while(n != 0):
    last_digit = n % 10
    rev = rev * 10 + last_digit
    n = n // 10

if(temp == rev):
    print("It is Palindrome Number")
else:
    print("It is not a Palindrome Number")`}

{/* OUTPUT */}

OUTPUT

Perfect Number Output:

Enter any number: 6

The number is a Perfect number!

Enter any number: 10

The number is not a Perfect number!

Armstrong Number Output:

Enter any number: 371

No of digits is: 3

Number is Armstrong number

Enter any number: 123

No of digits is: 3

Number is Not Armstrong number

Palindrome Output:

Enter the Number: 121

It is Palindrome Number

Enter the Number: 123

It is not a Palindrome Number

{/* CONCLUSION */}

CONCLUSION

Thus, the given program was successfully executed and the output was verified as per the expected result.

{/* VIVA QUESTIONS */}

VIVA QUESTIONS

What is a perfect number? Give examples.

A perfect number is a positive integer that is equal to the sum of its proper positive divisors (excluding itself). Examples: 6 (1+2+3=6), 28 (1+2+4+7+14=28), 496, 8128.
How do you calculate if 371 is an Armstrong number?

371 has 3 digits. Calculate: 3³ + 7³ + 1³ = 27 + 343 + 1 = 371. Since the sum equals the original number, 371 is an Armstrong number.
What is the difference between // and / operators in Python?

// is floor division (returns integer quotient), while / is true division (returns float). For digit extraction, we use // to get integer results.
Why do we use modulo operator (%) in these programs?

The modulo operator is used to: find divisors (n%i==0), extract last digit (n%10), and check divisibility conditions.
How would you modify the palindrome program to work with strings?

For strings, we can use string slicing: if string == string[::-1] or compare characters from both ends using loops.
What happens if we input 0 or negative numbers?

Perfect numbers are defined for positive integers only. For 0 or negative numbers, we should add input validation to handle these cases appropriately.
Can a single-digit number be an Armstrong number?

Yes, all single-digit numbers (1-9) are Armstrong numbers because each digit raised to the power 1 equals itself.
How can we optimize the perfect number checking algorithm?

We can optimize by checking divisors only up to √n, and for each divisor i found, also add n/i to the sum (if i ≠ n/i and n/i ≠ n).

Previous: Series Sum Next: Prime/Composite Check

{/* Right Sidebar - Related Resources */}

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/number-checks/related.tsx" isMerged="true" import Link from "next/link" export default function Related() { const relatedResources = [ { id: 1, title: "Prime/Composite Numbers", type: "practical", url: "/computer-science/practical/class-11/prime-composite", }, { id: 2, title: "Fibonacci Series Program", type: "practical", url: "/computer-science/practical/class-11/fibonacci-series", }, { id: 3, title: "GCD and LCM Program", type: "practical", url: "/computer-science/practical/class-11/gcd-lcm", }, { id: 4, title: "String Palindrome Check", type: "practical", url: "/computer-science/practical/class-11/string-palindrome", }, { id: 5, title: "Flow of Control Theory", type: "theory", url: "/computer-science/class-11/flow-of-control", }, { id: 6, title: "Python Fundamentals", type: "theory", url: "/computer-science/class-11/python-fundamentals", }, { id: 7, title: "Number Theory MCQs", type: "link", url: "/mcqs/computer-science/class-11/number-theory", }, { id: 8, title: "Mathematical Functions in Python", type: "video", url: "https://youtube.com/@pythontyro4579", }, ] return (

Related Resources

{resource.type === "theory" && ( )} {resource.type === "video" && ( )} {resource.type === "link" && ( )} {resource.type === "practical" && ( )} {resource.title}

Mathematical Concepts

• Perfect numbers: 6, 28, 496, 8128
• Armstrong: 153, 371, 407, 1634
• Palindromes: 121, 1331, 12321
• Digit manipulation techniques

Programming Tips

• Use // for integer division
• Modulo (%) for digit extraction
• Store original value before loops
• Validate input for edge cases

Need Help?

Join our tuition classes for detailed explanations of number theory and mathematical programming.

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/number-comparison/related.tsx" isMerged="true" import Link from "next/link" import { ExternalLink, FileText, BookOpen } from "lucide-react" export default function Related() { return (

{/* Related Programs */}

Related Programs

Welcome Message Arithmetic Operations Number Checks

{/* Study Resources */}

Study Resources

Flow of Control Python Fundamentals

{/* Quick Links */}

Quick Links

Class 11 MCQs Class 11 Theory

) } [V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/pattern-generation/page.tsx" isMerged="true" import type { Metadata } from "next" import Link from "next/link" import { ChevronRight, Home, FileText, Code, Play, CheckCircle, HelpCircle } from "lucide-react" import TOC from "./toc" import Related from "./related" export const metadata: Metadata = { title: "Generate Patterns Using Nested Loop - Class 11 Computer Science Practical", description: "Learn to create star patterns, reverse number patterns, and alphabet patterns using nested loops in Python. Complete practical program with code, output, and VIVA questions.", } export default function PatternGenerationPage() { return (

{/* Breadcrumb */}

Computer Science Practical Class 11 Pattern Generation

{/* TOC Sidebar */}

{/* Main Content */}


                
                  Generate Patterns Using Nested Loop



              {/* AIM */}
              
                
                  
                  AIM
                
                
                  
                    To write Python programs to generate different patterns using nested loops including:
                  
                  
                    • Star Pattern (1 to 5 stars)
                    • Reverse Number Pattern (12345 to 1)
                    • Alphabet Pattern (A to ABCDE)
                  
                
              

              {/* ALGORITHM */}
              
                
                  
                  ALGORITHM
                

                                  
                  
                    
                      1: Start
                    
                    
                      2: Accept user choice
                    
                    
                      3: Based on choice, execute respective pattern logic:
                    
                    
                      For Star Pattern:
                      
                        - Use outer loop from 1 to 5
                        - Use inner loop from 1 to current row number
                        - Print star followed by space
                      
                    
                    
                      For Reverse Number Pattern:
                      
                        - Use outer loop from 5 to 1 (decreasing)
                        - Use inner loop from 1 to current row number
                        - Print numbers without space
                      
                    
                    
                      For Alphabet Pattern:
                      
                        - Use outer loop from 1 to 5
                        - Use inner loop from 1 to current row number
                        - Convert numbers to alphabets using chr(64+j)
                      
                    
                    
                      4: Print newline after each row
                    
                    
                      5: Stop
                    
                  
                
              


              {/* PROGRAM */}
              
                
                  
                  PROGRAM
                

                
                                      {`# Pattern Generation Program using Nested Loops
    print("\\nStar Pattern:")   
    for i in range(1, 6):
        for j in range(1, i + 1):
            print("*", end=" ")
        print()  # New line after each row

    print("\\nReverse Number Pattern:")   
    for i in range(5, 0, -1):
        for j in range(1, i + 1):
            print(j, end="")
        print()  # New line after each row

    print("\\nAlphabet Pattern:")   
    for i in range(1, 6):
        for j in range(1, i + 1):
            print(chr(64 + j), end="")
        print()  # New line after each row

`}
                  
                
              


              {/* OUTPUT */}
              
                
                  
                  OUTPUT
                

                
                  
                    Pattern 1: Star Pattern
                                          {`Star Pattern:
---------------
* 
* * 
* * * 
* * * * 
* * * * *`}
                    
                  

                  
                    Pattern 2: Reverse Number Pattern
                                          {`Reverse Number Pattern:
-------------------------
12345
1234
123
12
1`}
                    
                  

                  
                    Pattern 3: Alphabet Pattern
                                          {`Alphabet Pattern:
------------------
A
AB
ABC
ABCD
ABCDE`}
                    
                  
                
              

              {/* CONCLUSION */}
              
                
                  
                  CONCLUSION
                
                
                  
                     Thus, the given program was successfully executed and the output was verified as per the expected result.
                  
                
              

              {/* VIVA QUESTIONS */}
              
                
                  
                  VIVA QUESTIONS
                
                
                  {[
                    {
                      q: "What is a nested loop and why is it used in pattern generation?",
                      a: "A nested loop is a loop inside another loop. It's used in pattern generation because we need to control both rows (outer loop) and columns (inner loop) to create 2D patterns.",
                    },
                    {
                      q: "How does the chr() function work in alphabet pattern generation?",
                      a: "chr() function converts ASCII values to characters. chr(65) gives 'A', chr(66) gives 'B', etc. We use chr(64 + j) where j starts from 1 to get alphabets A, B, C...",
                    },
                    {
                      q: "What is the difference between print() and print(end='') in pattern programs?",
                      a: "print() adds a newline character after printing, while print(end='') doesn't add newline. We use end='' to print elements in the same line and print() to move to next line.",
                    },
                    {
                      q: "How do you create a reverse number pattern like 12345, 1234, 123?",
                      a: "Use outer loop with range(5, 0, -1) to go from 5 to 1, and inner loop with range(1, i+1) where i is the current outer loop value.",
                    },
                    {
                      q: "What is the ASCII value of 'A' and how is it used in alphabet patterns?",
                      a: "ASCII value of 'A' is 65. We use chr(64 + j) or chr(65 + j - 1) to convert numbers to alphabets starting from A.",
                    },
                    {
                      q: "How can you modify the star pattern to create a right-aligned triangle?",
                      a: "Add spaces before stars using another inner loop: for k in range(5-i): print(' ', end='') before printing stars.",
                    },
                    {
                      q: "What happens if you use range(1, 6) vs range(5, 0, -1) in outer loop?",
                      a: "range(1, 6) creates increasing pattern (1,2,3,4,5 rows), while range(5, 0, -1) creates decreasing pattern (5,4,3,2,1 rows).",
                    },
                    {
                      q: "How do you create a pattern with both numbers and alphabets in the same row?",
                      a: "Use two inner loops or combine both in one loop: print(j, chr(64+j), end=' ') to print both number and corresponding alphabet.",
                    },
                  ].map((item, index) => (
                    
                      
                        Q{index + 1}. {item.q}
                      
                      {item.a}
                    
                  ))}
                
              

              {/* Navigation */}
              
                
                  
                  Previous: Arithmetic Operations
                
                
                  Next: Series Sum



          {/* Related Sidebar */}


  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/pattern-generation/related.tsx" isMerged="true"
import Link from "next/link"
import { BookOpen, Code, FileText, Download, ExternalLink, Lightbulb, Users, HelpCircle, Youtube } from "lucide-react"

export default function Related() {
  return (
    
      {/* Related Programs */}
      
        
          
          Related Programs
        

        
          
            
              
              Series Sum Calculation
            
          
          
            
              
              Fibonacci Series
            
          
          
            
              
              Prime Number Check
            
          
          
            
              
              Number Properties
            
          
        
      


      {/* Theory Topics */}
      
        
          
          Theory Topics
        
        
          
            
              
              Flow of Control
            
          
          
            
              
              Python Fundamentals
            
          
          
            
              
              Strings in Python
            
          
        
      

      {/* MCQs Section */}
      
        
          
          MCQs & Practice
        
        
          
            
              
              Class 11 CS MCQs
            
          
          
            
              
              Loops MCQs
            
          
          
            
              
              Pattern MCQs
            
          
        
      

      {/* YouTube Video */}
      
        
          
          Video Tutorial
        
        
          
          Pattern Generation in Python - Complete Tutorial
        
        Learn nested loops and pattern creation
      

      {/* Quick Tips */}
      
        
          
          Quick Tips
        
        
          
            
            Use nested loops: outer for rows, inner for columns
          
          
            
            chr(65) = 'A', chr(66) = 'B' for alphabet patterns
          
          
            
            Use end='' to print in same line, print() for new line
          
          
            
            range(5,0,-1) creates decreasing sequence
          
        
      

      {/* Help Section */}
      
        
          
          Need Help?
        
        
          
            
              
              Get Online Tuition
            
          
          
            
              
              Ask Questions
            
          
        
      

      {/* Download Section */}
      
        
          
          Downloads
        
        
          
            
          
          
            
          

        

      


      {/* External Resources */}
      
        
          
          External Resources
        
        
          
            
              
              Python Control Flow
            
          
          
            
              
              Python chr() Function
            
          
        
      
    

  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/phone-directory/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from 'lucide-react'
import TOC from "./toc"
import Related from "./related"

export default function PhoneDirectoryPage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 11
            
            
            Friends Phone Directory
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                Friends Phone Directory Dictionary Operations
                
              

              
                {/* AIM */}
                
                  AIM
                  To write a program to input friends' names and their phone numbers, store them in a dictionary as key-value pairs, and perform various operations like display, add, delete, modify, search, and sort.
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Start
                    Input the number of friends and create an empty dictionary
                    For each friend, input name and phone number and store in dictionary
                    Display the initial dictionary
                    Start a menu-driven loop with 7 options
                    Based on user choice, perform the following operations:
                      
                        Display all friends and their phone numbers
                        Add a new friend to the dictionary
                        Delete a friend using pop() method
                        Modify phone number of an existing friend
                        Search for a friend in the dictionary
                        Display dictionary in sorted order of names
                        Exit the program
                      
                    
                    Repeat until user chooses to exit
                    Stop
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`# Friends Phone Directory Dictionary Operations

n = int(input("How many friends?"))
fd = {}

for i in range(n):
    print("Enter details of Friend:", (i+1))
    name = input("Name:")
    ph = int(input("Phone:"))
    fd[name] = ph

print("Friends dictionary is", fd)

ch = 0
while ch != 7:
    print("\\t MENU")
    print("1. Display all Friends")
    print("2. Add a new Friend")
    print("3. Delete a Friend")
    print("4. Modify a Phone Number")
    print("5. Search for a Friend")
    print("6. Sort the Names")
    print("7. Exit")
    
    ch = int(input("Enter your choice(1 to 7):"))
    
    if ch == 1:
        print(fd)
    elif ch == 2:
        print("Enter Details of New Friend:")
        name = input("Name")
        ph = int(input("Phone:"))
        fd[name] = ph
    elif ch == 3:
        nm = input("Friend Name to be deleted:")
        res = fd.pop(nm, -1)
        if res != -1:
            print(res, "Deleted")
        else:
            print("No Such friend")
    elif ch == 4:
        name = input("Friend Name:")
        ph = int(input("Changed Phone:"))
        fd[name] = ph
    elif ch == 5:
        name = input("Friend Name:")
        if name in fd:
            print(name, "Exists in the dictionary.")
        else:
            print(name, "does not exist in the dictionary..")
    elif ch == 6:
        lst = sorted(fd)
        print("{", end='')
        for a in lst:
            print(a, ":", fd[a], end='')
        print("}")
    elif ch == 7:
        print("Exited successfully..")
        break
    else:
        print("Valid choices are 1 to 7")`}
                      
                    
                  
                

                {/* OUTPUT */}
                
                  OUTPUT
                  
                    How many friends?3
                    Enter details of Friend: 1
                    Name:Alice
                    Phone:9876543210
                    Enter details of Friend: 2
                    Name:Bob
                    Phone:8765432109
                    Enter details of Friend: 3
                    Name:Charlie
                    Phone:7654321098
                    {'Friends dictionary is {"Alice": 9876543210, "Bob": 8765432109, "Charlie": 7654321098}'}
                    

                    	 MENU
                    1. Display all Friends
                    2. Add a new Friend
                    3. Delete a Friend
                    4. Modify a Phone Number
                    5. Search for a Friend
                    6. Sort the Names
                    7. Exit
                    Enter your choice(1 to 7):1
                    {'{"Alice": 9876543210, "Bob": 8765432109, "Charlie": 7654321098}'}
                  
                  
                    Enter your choice(1 to 7):2
                    Enter Details of New Friend:
                    NameDiana
                    Phone:6543210987
                    

                    Enter your choice(1 to 7):6
                    {'{"Alice": 9876543210 "Bob": 8765432109 "Charlie": 7654321098 "Diana": 6543210987}'}
                  
                

                {/* ALTERNATIVE METHODS */}
                
                  ALTERNATIVE METHODS
                  
                  Method 2: Using Functions
                  
                                          
                        {`def display_friends(directory):
    if directory:
        print("\\nFriends Directory:")
        for name, phone in directory.items():
            print(f"{name}: {phone}")
    else:
        print("No friends in directory!")

def add_friend(directory):
    name = input("Enter friend's name: ")
    phone = input("Enter phone number: ")
    directory[name] = phone
    print(f"{name} added successfully!")

def delete_friend(directory):
    name = input("Enter friend's name to delete: ")
    if name in directory:
        del directory[name]
        print(f"{name} deleted successfully!")
    else:
        print(f"{name} not found in directory!")

def modify_phone(directory):
    name = input("Enter friend's name: ")
    if name in directory:
        new_phone = input("Enter new phone number: ")
        directory[name] = new_phone
        print(f"{name}'s phone number updated!")
    else:
        print(f"{name} not found in directory!")

def search_friend(directory):
    name = input("Enter friend's name to search: ")
    if name in directory:
        print(f"{name}: {directory[name]}")
    else:
        print(f"{name} not found in directory!")

def sort_friends(directory):
    if directory:
        sorted_names = sorted(directory.keys())
        print("\\nSorted Directory:")
        for name in sorted_names:
            print(f"{name}: {directory[name]}")
    else:
        print("No friends to sort!")

def main():
    friends = {}
    
    # Initial input
    n = int(input("How many friends? "))
    for i in range(n):
        name = input(f"Enter name of friend {i+1}: ")
        phone = input(f"Enter phone number: ")
        friends[name] = phone
    
    while True:
        print("\\n" + "="*30)
        print("FRIENDS DIRECTORY MENU")
        print("="*30)
        print("1. Display all friends")
        print("2. Add new friend")
        print("3. Delete friend")
        print("4. Modify phone number")
        print("5. Search friend")
        print("6. Sort friends")
        print("7. Exit")
        
        choice = input("Enter your choice (1-7): ")
        
        if choice == '1':
            display_friends(friends)
        elif choice == '2':
            add_friend(friends)
        elif choice == '3':
            delete_friend(friends)
        elif choice == '4':
            modify_phone(friends)
        elif choice == '5':
            search_friend(friends)
        elif choice == '6':
            sort_friends(friends)
        elif choice == '7':
            print("Thank you for using Friends Directory!")
            break
        else:
            print("Invalid choice! Please try again.")

if __name__ == "__main__":
    main()`}
                      
                    
                  

                  Method 3: Using Dictionary Methods
                  
                                          
                        {`# Enhanced version using dictionary methods

def create_directory():
    friends = {}
    n = int(input("How many friends? "))
    
    for i in range(n):
        print(f"\\nEnter details for friend {i+1}:")
        name = input("Name: ").strip().title()
        
        while True:
            try:
                phone = input("Phone: ").strip()
                # Basic phone validation
                if len(phone) >= 10 and phone.isdigit():
                    friends[name] = phone
                    break
                else:
                    print("Please enter a valid 10-digit phone number!")
            except ValueError:
                print("Invalid input! Please try again.")
    
    return friends

def display_all(friends):
    if not friends:
        print("\\nNo friends in directory!")
        return
    
    print("\\n" + "="*40)
    print("FRIENDS DIRECTORY")
    print("="*40)
    for name, phone in friends.items():
        print(f"{name:<20} : {phone}")
    print("="*40)

def add_new_friend(friends):
    name = input("\\nEnter friend's name: ").strip().title()
    
    if name in friends:
        print(f"{name} already exists! Use modify option to change phone number.")
        return
    
    phone = input("Enter phone number: ").strip()
    friends[name] = phone
    print(f"\\n{name} added successfully!")

def remove_friend(friends):
    if not friends:
        print("\\nNo friends to delete!")
        return
    
    name = input("\\nEnter friend's name to delete: ").strip().title()
    removed_phone = friends.pop(name, None)
    
    if removed_phone:
        print(f"\\n{name} (Phone: {removed_phone}) deleted successfully!")
    else:
        print(f"\\n{name} not found in directory!")

def update_phone(friends):
    if not friends:
        print("\\nNo friends to modify!")
        return
    
    name = input("\\nEnter friend's name: ").strip().title()
    
    if name in friends:
        old_phone = friends[name]
        new_phone = input(f"Current phone: {old_phone}\\nEnter new phone: ").strip()
        friends[name] = new_phone
        print(f"\\n{name}'s phone updated from {old_phone} to {new_phone}")
    else:
        print(f"\\n{name} not found in directory!")

def find_friend(friends):
    if not friends:
        print("\\nNo friends to search!")
        return
    
    name = input("\\nEnter friend's name to search: ").strip().title()
    phone = friends.get(name)
    
    if phone:
        print(f"\\nFound: {name} - {phone}")
    else:
        print(f"\\n{name} not found in directory!")

def show_sorted(friends):
    if not friends:
        print("\\nNo friends to sort!")
        return
    
    print("\\n" + "="*40)
    print("SORTED FRIENDS DIRECTORY")
    print("="*40)
    
    for name in sorted(friends.keys()):
        print(f"{name:<20} : {friends[name]}")
    print("="*40)

def main():
    print("FRIENDS PHONE DIRECTORY")
    print("="*30)
    
    friends = create_directory()
    
    menu_options = {
        '1': ("Display all friends", display_all),
        '2': ("Add new friend", add_new_friend),
        '3': ("Delete friend", remove_friend),
        '4': ("Modify phone number", update_phone),
        '5': ("Search friend", find_friend),
        '6': ("Show sorted directory", show_sorted),
        '7': ("Exit", None)
    }
    
    while True:
        print("\\n" + "="*30)
        print("MENU OPTIONS")
        print("="*30)
        for key, (description, _) in menu_options.items():
            print(f"{key}. {description}")
        print("="*30)
        
        choice = input("Enter your choice (1-7): ").strip()
        
        if choice == '7':
            print("\\nThank you for using Friends Directory!")
            print("Goodbye!")
            break
        elif choice in menu_options:
            _, function = menu_options[choice]
            if function:
                function(friends)
        else:
            print("\\nInvalid choice! Please enter a number between 1-7.")

if __name__ == "__main__":
    main()`}
                      
                    
                  
                

                {/* CONCLUSION */}
                
                  CONCLUSION
                  
                     Thus, the given program was successfully executed and the output was verified as per the expected result.
                  
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is the advantage of using a dictionary over a list for storing phone directory data?
                      
                        Dictionaries provide O(1) average time complexity for search, insert, and delete operations using keys, while lists require O(n) time for searching. Dictionaries also provide meaningful key-value associations.
                      
                    
                    
                      What does the pop() method return when the key is not found?
                      
                        The pop() method returns the default value (second argument) if the key is not found. In our program, pop(nm, -1) returns -1 when the friend's name is not found, allowing us to handle the error gracefully.
                      
                    
                    
                      How does the sorted() function work with dictionaries?
                      
                        sorted(fd) returns a sorted list of dictionary keys. To access the corresponding values, we iterate through the sorted keys and use them to retrieve values from the original dictionary.
                      
                    
                    
                      What happens if we try to modify a phone number for a non-existent friend?
                      
                        The program will create a new key-value pair in the dictionary. To prevent this, we should check if the key exists using 'if name in fd:' before modification.
                      
                    
                    
                      How can we handle duplicate phone numbers in this program?
                      
                        We can check if the phone number already exists by iterating through dictionary values or maintaining a reverse dictionary. We could also use validation to prevent duplicate entries.
                      
                    
                    
                      What are the limitations of storing phone numbers as integers?
                      
                        Storing as integers removes leading zeros, doesn't support international formats with '+' or '-', and may cause overflow for very large numbers. Strings are better for phone number storage.
                      
                    
                    
                      How would you implement case-insensitive name searching?
                      
                        Convert both the search key and dictionary keys to lowercase using .lower() method, or store all names in a consistent case (title case) when adding them to the dictionary.
                      
                    
                    
                      How can this program be extended to store additional information about friends?
                      
                        Instead of storing phone numbers as values, we can store dictionaries or lists containing multiple pieces of information like email, address, birthday, etc. For example: {'friends[name] = {"phone": ph, "email": email}'}.
                      
                    
                  
                

                
                  
                    Next Program: List Element Swapping
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/phone-directory/related.tsx" isMerged="true"
import Link from "next/link"

export default function Related() {
  const relatedResources = [
    {
      id: 1,
      title: "Python Fundamentals",
      type: "theory",
      url: "/computer-science/class-11/python-fundamentals",
    },
    {
      id: 2,
      title: "Python Input/Output Tutorial",
      type: "video",
      url: "https://youtube.com/@pythontyro4579",
    },
    {
      id: 3,
      title: "Python Basics PDF",
      type: "pdf",
      url: "/resources/python-basics.pdf",
    },
    {
      id: 4,
      title: "Python Fundamentals MCQs",
      type: "link",
      url: "/mcqs/computer-science/class-11/python-fundamentals",
    },
    {
      id: 5,
      title: "Next Program: Number Comparison",
      type: "practical",
      url: "/computer-science/practical/class-11/number-comparison",
    },
  ]

  return (
    
      Related Resources
      
        {relatedResources.map((resource) => (
          
            
              {resource.type === "theory" && (
                
              )}
              {resource.type === "video" && (
                
              )}
              {resource.type === "pdf" && (
                
              )}
              {resource.type === "link" && (
                
              )}
              {resource.type === "practical" && (
                
              )}
              {resource.title}
              {resource.type === "pdf" && (
                
              )}
            
          
        ))}
      

      
        Need Help?
        
          Join our tuition classes for personalized guidance and doubt clearing sessions.
        
        
          Register for Classes →
        
      

      
        Practice More
        Try more Python programs to strengthen your programming skills.
        
          View All Programs →
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/prime-composite/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function PrimeCompositePage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 11
            
            
            Prime or Composite Number
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                Check if Number is Prime or Composite
                
              

              
                {/* AIM */}
                
                  AIM
                  
                    To write a Python program that checks whether a given number is a prime number or a composite
                    number.
                  

                  
                    Definitions:
                    
                      
                        Prime Number: A natural number greater than 1 that has no positive divisors
                        other than 1 and itself.
                      
                      
                        Composite Number: A positive integer that has at least one positive divisor
                        other than 1 and itself.
                      
                      
                        Special Cases: 0 and 1 are neither prime nor composite numbers.
                      
                    
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Start
                    Input a number from the user
                    Check if the number is 0 or 1 - if yes, print "neither prime nor composite"
                    If the number is greater than 1:
                    
                      
                        Use a loop from 2 to n-1
                        Check if the number is divisible by any number in this range
                        If divisible, it's composite; otherwise, it's prime
                      
                    
                    If the number is negative, ask for a positive integer
                    Display the result
                    Stop
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`# Python program to check if a number is prime or composite

n = int(input("Enter any number: "))

if (n == 0 or n == 1):
    print("Number is neither Prime nor Composite")
elif (n > 1):
    for i in range(2, n):
        if (n % i == 0):
            print("Number is not Prime but Composite")
            break
    else:
        print("Number is Prime number but not Composite")
else:
    print("Please enter positive integer number")`}
                      
                    
                  
                

                {/* OUTPUT */}
                
                  OUTPUT

                  
                    
                      Test Case 1 (Prime Number):
                    
                    Enter any number: 7
                    Number is Prime number but not Composite
                  

                  
                    
                      Test Case 2 (Composite Number):
                    
                    Enter any number: 12
                    Number is not Prime but Composite
                  

                  
                    
                      Test Case 3 (Special Case):
                    
                    Enter any number: 1
                    Number is neither Prime nor Composite
                  

                  
                    
                      Test Case 4 (Negative Number):
                    
                    Enter any number: -5
                    Please enter positive integer number
                  
                

                {/* CONCLUSION */}
                
                  CONCLUSION
                   Thus, the given program was successfully executed and the output was verified as per the expected result.
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is the difference between prime and composite numbers?
                      
                        Prime numbers have exactly two factors (1 and itself), while composite numbers have more than
                        two factors. For example, 7 is prime (factors: 1, 7) and 12 is composite (factors: 1, 2, 3, 4,
                        6, 12).
                      
                    
                    
                      Why are 0 and 1 neither prime nor composite?
                      
                        By definition, prime numbers must be greater than 1 and have exactly two distinct factors. 0 has
                        infinite factors, and 1 has only one factor (itself), so neither fits the definition.
                      
                    
                    
                      What is the purpose of the break statement in this program?
                      
                        The break statement exits the loop immediately when a divisor is found, making the program more
                        efficient by avoiding unnecessary iterations.
                      
                    
                    
                      How does the for-else construct work in Python?
                      
                        The else block executes only if the for loop completes normally (without encountering a break).
                        If break is executed, the else block is skipped.
                      
                    
                    
                      Can you optimize this algorithm for better performance?
                      
                        Yes, we can check divisors only up to √n instead of n-1, and check for even numbers separately
                        to reduce iterations by half.
                      
                    
                    
                      What happens if we input a very large prime number?
                      
                        The program will take longer to execute as it checks all numbers from 2 to n-1. For large
                        numbers, more efficient algorithms like Miller-Rabin test are preferred.
                      
                    
                    
                      Is 2 a prime number? Why is it special?
                      
                        Yes, 2 is prime and it's the only even prime number. All other even numbers are divisible by 2,
                        making them composite.
                      
                    
                    
                      
                        How would you modify this program to find all prime numbers up to n?
                      
                      
                        We would use nested loops or implement the Sieve of Eratosthenes algorithm to efficiently find
                        all primes up to a given number.
                      
                    
                  
                

                
                  
                    
                    Previous: Number Checks
                  
                  
                    Next: Fibonacci Series
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/prime-composite/related.tsx" isMerged="true"
import Link from "next/link"
import { BookOpen, FileText, Download, ExternalLink, Lightbulb, HelpCircle } from "lucide-react"

export default function Related() {
  return (
    
      {/* Related Programs */}
      
        
          
          Related Programs
        
        
          
            Number Properties
            Perfect, Armstrong, Palindrome
          
          
            Fibonacci Series
            Number sequence generation
          
          
            GCD & LCM
            Mathematical operations
          
          
            Series Sum
            Mathematical series
          
        
      

      {/* Theory Topics */}
      
        
          
          Theory Topics
        
        
          
            Flow of Control
            Loops and conditions
          
          
            Python Fundamentals
            Basic programming concepts
          
        
      

      {/* Study Resources */}
      
        
          
          Study Resources
        
        
          
            MCQs - Class 11
            Practice questions
          
          
            NCERT Solutions
            Textbook answers
          
          
            Sumita Arora Solutions
            Reference book solutions
          
        
      

      {/* Quick Tips */}
      
        
          
          Quick Tips
        
        
          
            Prime Numbers
            Only divisible by 1 and itself
          
          
            Optimization
            Check divisors up to √n only
          
          
            For-Else
            Else runs if no break occurs
          
        
      

      {/* Help Section */}
      
        
          
          Need Help?
        
        
          
            Contact Us
            Get personalized help
          
          
            Online Tuition
            1-on-1 programming help
          
        
      

      {/* External Resources */}
      
        
          
          External Resources
        
        
          
            Python Control Flow
            Official documentation
          
          
            Prime Numbers
            Mathematical background
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/prime-composite/toc.tsx" isMerged="true"
import Link from "next/link"
import { FileText, Code, BookOpen } from "lucide-react"

const class11Programs = [
 { id: 1, title: "Input a welcome message and display it", slug: "welcome-message" },
    { id: 2, title: "Input two numbers and display the larger/smaller number", slug: "number-comparison" },
    { id: 3, title: "Input three numbers and display the largest / smallest number", slug: "three-number-comparison" },    
    { id: 4, title: "Enter two integers and perform all arithmetic operations", slug: "arithmetic-operations" },
    { id: 5, title: "Generate patterns using nested loop", slug: "pattern-generation" },
    { id: 6, title: "Input x and n, print sum of series", slug: "series-sum" },
    { id: 7, title: "Check perfect number, Armstrong number or palindrome", slug: "number-checks" },
    { id: 8, title: "Check if number is prime or composite", slug: "prime-composite" },
    { id: 9, title: "Display Fibonacci series terms", slug: "fibonacci-series" },
    { id: 10, title: "Compute GCD and LCM of two integers", slug: "gcd-lcm" },
    { id: 11, title: "Count vowels, consonants, uppercase, lowercase in string", slug: "string-analysis" },
    { id: 12, title: "Check palindrome string and convert case", slug: "string-palindrome" },
    { id: 13, title: "Find largest/smallest number in list/tuple", slug: "list-min-max" },
    { id: 14, title: "Swap elements at even and odd locations", slug: "list-swap" },
    { id: 15, title: "Search element in list/tuple", slug: "list-search" },
    { id: 16, title: "Find smallest and largest number from list", slug: "list-extremes" },
    { id: 17, title: "Dictionary with student marks above 75", slug: "student-marks" },
    { id: 18, title: "Menu-driven student dictionary program", slug: "student-menu" },
    { id: 19, title: "Choose 4 random lucky winners from 100 customers", slug: "lucky-winners" },
    { id: 20, title: "String module operations menu", slug: "string-module" },
    { id: 21, title: "Friends phone directory dictionary operations", slug: "phone-directory" },
]

export default function TOC() {
  return (
    
      
        
        Class 11 Practical Programs
      

      
        {class11Programs.map((program) => (
          
            {program.id}. {program.title}
          
        ))}
      

      
     
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/series-sum/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function SeriesSumPage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 11
            
            
            Series Sum
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                Input x and n, Print Sum of Series
                
              

              
                {/* AIM */}
                
                  AIM
                  
                    To write Python programs to input the value of x and n and print the sum of different mathematical
                    series.
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Start
                    Input the value of x (base) and n (number of terms)
                    Initialize sum variable according to the series type
                    Use a loop to calculate each term of the series
                    Add or subtract terms based on the series pattern
                    Display the final sum
                    Stop
                  
                

                {/* PROGRAM */}
                
                  PROGRAM

                  {/* Series 1 */}
                  1. Series: 1 + x + x² + x³ + ... + xⁿ
                  
                                          
                        {`# Series 1: 1 + x + x^2 + x^3 + ... + x^n
x = float(input('Enter value of x: '))
n = int(input('Enter value of n: '))
s = 0
for i in range(n + 1):
    s += x**i
print('Sum of the series:', s)`}
                      
                    
                  

                  {/* Series 2 */}
                  2. Series: 1 - x + x² - x³ + ... ± xⁿ
                  
                                          
                        {`# Series 2: 1 - x + x^2 - x^3 + ... +/- x^n
x = float(input('Enter value of x: '))
n = int(input('Enter value of n: '))
s = 1
for i in range(1, n+1):
    if i%2 == 0:
        s = s + x**i
    else:
        s = s - x**i
print('Sum of the series:', s)`}
                      
                    
                  

                  {/* Series 3 */}
                  
                    3. Series: x - x²/2 + x³/3 - x⁴/4 + ...
                  
                  
                                          
                        {`# Series 3: x - x^2/2 + x^3/3 - x^4/4 + ...
x = float(input('Enter value of x: '))
n = int(input('Enter value of n: '))
sum = x
for i in range(2, n+1):
    if (i%2 == 0):
        sum -= (x**i)/i
    else:
        sum += (x**i)/i
print('Sum is:', sum)`}
                      
                    
                  

                  {/* Series 4 */}
                  
                    4. Series: x - x²/2! + x³/3! - x⁴/4! + ...
                  
                  
                                          
                        {`# Series 4: x - x^2/2! + x^3/3! - x^4/4! + ...
import math
x = float(input('Enter value of x: '))
n = int(input('Enter value of n: '))
sum = x
for i in range(2, n+1):
    if (i%2 == 0):
        sum = sum + ((x**i)/math.factorial(i))
    else:
        sum = sum - ((x**i)/math.factorial(i))
print('Sum is:', sum)`}
                      
                    
                  
                

                {/* OUTPUT */}
                
                  OUTPUT

                  Series 1 Output:
                  
                    Enter value of x: 2
                    Enter value of n: 4
                    Sum of the series: 31.0
                  

                  Series 2 Output:
                  
                    Enter value of x: 2
                    Enter value of n: 4
                    Sum of the series: 11.0
                  

                  Series 3 Output:
                  
                    Enter value of x: 2
                    Enter value of n: 4
                    Sum is: 0.6666666666666667
                  

                  Series 4 Output:
                  
                    Enter value of x: 2
                    Enter value of n: 4
                    Sum is: 1.4666666666666666
                  
                

                {/* CONCLUSION */}
                
                  CONCLUSION
                  
                    Thus, the given program was successfully executed and the output was verified as per the expected result.
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is the purpose of these series programs?
                      
                        These programs calculate the sum of different mathematical series like geometric series,
                        alternating series, and factorial-based series which are commonly used in mathematics and
                        engineering.
                      
                    
                    
                      What is the difference between Series 1 and Series 2?
                      
                        Series 1 is a simple geometric series where all terms are positive. Series 2 is an alternating
                        series where terms alternate between positive and negative based on whether the power is even or
                        odd.
                      
                    
                    
                      Why do we use math.factorial() in Series 4?
                      
                        Series 4 involves factorial terms in the denominator (2!, 3!, 4!, etc.). The math.factorial()
                        function calculates the factorial of a number efficiently.
                      
                    
                    
                      What happens if we input negative values for x?
                      
                        Negative values for x are valid and will produce different results. For alternating series,
                        negative x values can affect the sign pattern of the terms.
                      
                    
                    
                      How does the modulo operator (%) work in these programs?
                      
                        The modulo operator (%) returns the remainder after division. We use i%2 to check if a number is
                        even (remainder 0) or odd (remainder 1) to determine the sign of terms in alternating series.
                      
                    
                    
                      What is the mathematical significance of Series 4?
                      
                        Series 4 represents the Taylor series expansion of sin(x) or cos(x) functions, which are
                        fundamental in calculus and used to approximate trigonometric functions.
                      
                    
                    
                      Why do we initialize 'sum' differently in different series?
                      
                        The initialization depends on the first term of each series. Series 1 and 2 start with 1, while
                        Series 3 and 4 start with x, so we initialize accordingly.
                      
                    
                    
                      What would happen if we input a very large value for n?
                      
                        For large n values, the computation time increases, and for Series 4, factorial values become
                        very large, which might cause overflow errors or precision issues in floating-point
                        calculations.
                      
                    
                  
                

                
                  
                    
                    Previous: Pattern Generation
                  
                  
                    Next: Number Checks
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/series-sum/related.tsx" isMerged="true"
import Link from "next/link"

export default function Related() {
  const relatedResources = [
    {
      id: 1,
      title: "Pattern Generation Program",
      type: "practical",
      url: "/computer-science/practical/class-11/pattern-generation",
    },
    {
      id: 2,
      title: "Fibonacci Series Program",
      type: "practical",
      url: "/computer-science/practical/class-11/fibonacci-series",
    },
    {
      id: 3,
      title: "Number Checks Program",
      type: "practical",
      url: "/computer-science/practical/class-11/number-checks",
    },
    {
      id: 4,
      title: "Flow of Control Theory",
      type: "theory",
      url: "/computer-science/class-11/flow-of-control",
    },
    {
      id: 5,
      title: "Python Fundamentals",
      type: "theory",
      url: "/computer-science/class-11/python-fundamentals",
    },
    {
      id: 6,
      title: "Mathematical Series Tutorial",
      type: "video",
      url: "https://youtube.com/@pythontyro4579",
    },
    {
      id: 7,
      title: "Python Math Module Documentation",
      type: "link",
      url: "https://docs.python.org/3/library/math.html",
    },
    {
      id: 8,
      title: "Series and Sequences MCQs",
      type: "link",
      url: "/mcqs/computer-science/class-11/series-sequences",
    },
  ]

  return (
    
      Related Resources
      
        {relatedResources.map((resource) => (
          
            
              {resource.type === "theory" && (
                
              )}
              {resource.type === "video" && (
                
              )}
              {resource.type === "practical" && (
                
              )}
              {resource.type === "link" && (
                
              )}
              {resource.title}
            
          
        ))}
      

      
        Mathematical Concepts
        
          • Geometric progression and series
          • Alternating series convergence
          • Taylor series expansions
          • Factorial calculations
          • Power functions and exponents
        
      

      
        Programming Tips
        
          • Use appropriate data types (float/int)
          • Handle large factorial values carefully
          • Test with different x and n values
          • Understand alternating sign patterns
          • Import math module for factorial
        
      

      
        Need Help?
        
          Join our tuition classes for detailed explanation of mathematical series and programming concepts.
        
        
          Register for Classes →
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/series-sum/toc.tsx" isMerged="true"
import Link from "next/link"

export default function TOC() {
  const class11Programs = [
    { id: 1, title: "Input a welcome message and display it", slug: "welcome-message" },
    { id: 2, title: "Input two numbers and display the larger/smaller number", slug: "number-comparison" },
    { id: 3, title: "Input three numbers and display the largest / smallest number", slug: "three-number-comparison" },    
    { id: 4, title: "Enter two integers and perform all arithmetic operations", slug: "arithmetic-operations" },
    { id: 5, title: "Generate patterns using nested loop", slug: "pattern-generation" },
    { id: 6, title: "Input x and n, print sum of series", slug: "series-sum" },
    { id: 7, title: "Check perfect number, Armstrong number or palindrome", slug: "number-checks" },
    { id: 8, title: "Check if number is prime or composite", slug: "prime-composite" },
    { id: 9, title: "Display Fibonacci series terms", slug: "fibonacci-series" },
    { id: 10, title: "Compute GCD and LCM of two integers", slug: "gcd-lcm" },
    { id: 11, title: "Count vowels, consonants, uppercase, lowercase in string", slug: "string-analysis" },
    { id: 12, title: "Check palindrome string and convert case", slug: "string-palindrome" },
    { id: 13, title: "Find largest/smallest number in list/tuple", slug: "list-min-max" },
    { id: 14, title: "Swap elements at even and odd locations", slug: "list-swap" },
    { id: 15, title: "Search element in list/tuple", slug: "list-search" },
    { id: 16, title: "Find smallest and largest number from list", slug: "list-extremes" },
    { id: 17, title: "Dictionary with student marks above 75", slug: "student-marks" },
    { id: 18, title: "Menu-driven student dictionary program", slug: "student-menu" },
    { id: 19, title: "Choose 4 random lucky winners from 100 customers", slug: "lucky-winners" },
    { id: 20, title: "String module operations menu", slug: "string-module" },
    { id: 21, title: "Friends phone directory dictionary operations", slug: "phone-directory" },
  ]

  return (
    
      Class 11 Programs
      
        {class11Programs.map((program) => (
          
            
              {program.id}.
              {program.title}
            
          
        ))}
      

      
        Series Types
        
          • Geometric Series (1 + x + x² + ...)
          • Alternating Series (1 - x + x² - ...)
          • Rational Series (x - x²/2 + x³/3 - ...)
          • Factorial Series (x - x²/2! + x³/3! - ...)
        
      

      
        Key Concepts
        
          • Loop structures and iterations
          • Mathematical operations (**)
          • Conditional statements (if-else)
          • Modulo operator for alternating signs
          • Math module and factorial function
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/string-analysis/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function StringAnalysisPage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 11
            
            
            String Analysis
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                
                  Count Vowels, Consonants, Uppercase, Lowercase Characters
                
                
              

              
                {/* AIM */}
                
                  AIM
                  
                    To write a Python program that counts and displays the number of vowels, consonants, uppercase, and
                    lowercase characters in a given string.
                  

                  
                    Character Classifications:
                    
                      
                        Vowels: a, e, i, o, u (both uppercase and lowercase)
                      
                      
                        Consonants: All alphabetic characters except vowels
                      
                      
                        Uppercase: Characters from A to Z
                      
                      
                        Lowercase: Characters from a to z
                      
                    
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Start
                    Input a string from the user
                    Initialize counters for vowels, consonants, uppercase, and lowercase to 0
                    For each character in the string:
                    Check if it's a vowel (a, e, i, o, u) - increment vowel counter
                    Otherwise, if it's alphabetic - increment consonant counter
                    For case counting, iterate through string again:
                    Check if character is between 'a' and 'z' - increment lowercase counter
                    Check if character is between 'A' and 'Z' - increment uppercase counter
                    Display all counters
                    Stop
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`# Count and display the number of vowels, consonants, uppercase, lowercase characters in string.

str = input("Enter the String::\\n")

vowels = 0
consonants = 0

for i in str:
    if (i=='a' or i=='e' or i=='i' or i=='o' or i=='u' or 
        i=='A' or i=='E' or i=='I' or i=='O' or i=='U'):
        vowels = vowels + 1
    else:
        consonants = consonants + 1

print("The number of vowels:", vowels)
print("The number of Consonants:", consonants)

# UPPERCASE and LOWERCASE LOGIC
str1 = input("Enter the String::\\n")

upper = 0
lower = 0

for i in range(len(str1)):
    if(str1[i] >= 'a' and str1[i] <= 'z'):
        lower += 1
    elif(str1[i] >= 'A' and str1[i] <= 'Z'):
        upper += 1

print('Lower case letters =', lower)
print('Upper case letters =', upper)`}
                      
                    
                  
                

                {/* OUTPUT */}
                
                  OUTPUT

                  
                    
                      Test Case 1:
                    
                    Enter the String::
                    Hello World
                    The number of vowels: 3
                    The number of Consonants: 8
                    Enter the String::
                    Hello World
                    Lower case letters = 8
                    Upper case letters = 2
                  

                  
                    
                      Test Case 2:
                    
                    Enter the String::
                    Programming123
                    The number of vowels: 3
                    The number of Consonants: 11
                    Enter the String::
                    Programming123
                    Lower case letters = 10
                    Upper case letters = 1
                  

                  
                    
                      Test Case 3:
                    
                    Enter the String::
                    PYTHON programming
                    The number of vowels: 4
                    The number of Consonants: 13
                    Enter the String::
                    PYTHON programming
                    Lower case letters = 11
                    Upper case letters = 6
                  
                

                {/* CONCLUSION */}
                
                  CONCLUSION
                   Thus, the given program was successfully executed and the output was verified as per the expected result.
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      Why do we count consonants as total characters minus vowels?
                      
                        In this program, consonants include all non-vowel characters including spaces, digits, and
                        special characters. A better approach would be to check if the character is alphabetic first.
                      
                    
                    
                      
                        What is the difference between {"str[i]"} and iterating directly over characters?
                      
                      
                        Direct iteration (for i in str) gives you the character directly, while index-based iteration
                        (for i in range(len(str))) gives you the index, requiring str[i] to access the character.
                      
                    
                    
                      How can we improve the vowel checking logic?
                      
                        We can use: if i.lower() in 'aeiou' which is more concise and handles both cases automatically.
                      
                    
                    
                      What happens if the string contains numbers or special characters?
                      
                        Numbers and special characters are counted as consonants in the current logic. We should add a
                        check using isalpha() method to count only alphabetic characters.
                      
                    
                    
                      Can we use built-in string methods for this task?
                      
                        Yes, we can use methods like isupper(), islower(), isalpha() to make the code more readable and
                        efficient.
                      
                    
                    
                      Why do we ask for input twice in this program?
                      
                        The program has two separate sections - one for vowel/consonant counting and another for case
                        counting. This could be optimized to use a single input and single loop.
                      
                    
                    
                      How would you modify this to handle Unicode characters?
                      
                        For Unicode support, we should use methods like isupper(), islower() instead of ASCII range
                        comparisons, as they work with international characters.
                      
                    
                    
                      What is the time complexity of this algorithm?
                      
                        The time complexity is O(n) where n is the length of the string, as we iterate through the
                        string twice (once for vowels/consonants, once for case counting).
                      
                    
                  
                

                
                  
                    
                    Previous: GCD and LCM
                  
                  
                    Next: String Palindrome
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/string-analysis/related.tsx" isMerged="true"
import Link from "next/link"

export default function Related() {
  const relatedResources = [
    {
      id: 1,
      title: "Strings in Python",
      type: "theory",
      url: "/computer-science/class-11/strings-python",
    },
    {
      id: 2,
      title: "String Methods Tutorial",
      type: "video",
      url: "https://youtube.com/@pythontyro4579",
    },
    {
      id: 3,
      title: "String Operations PDF",
      type: "pdf",
      url: "/resources/string-operations.pdf",
    },
    {
      id: 4,
      title: "String Manipulation MCQs",
      type: "link",
      url: "/mcqs/computer-science/class-11/strings",
    },
    {
      id: 5,
      title: "String Palindrome Program",
      type: "practical",
      url: "/computer-science/practical/class-11/string-palindrome",
    },
  ]

  return (
    
      Related Resources
      
        {relatedResources.map((resource) => (
          
            
              {resource.type === "theory" && (
                
              )}
              {resource.type === "video" && (
                
              )}
              {resource.type === "pdf" && (
                
              )}
              {resource.type === "link" && (
                
              )}
              {resource.type === "practical" && (
                
              )}
              {resource.title}
            
          
        ))}
      

      
        String Tips
        
          • Use built-in methods like isupper(), islower()
          • Consider Unicode characters for international text
          • Optimize with single loop for multiple counts
          • Handle special characters appropriately
        
      

      
        Practice More
        Try more string manipulation programs to master text processing.
        
          View All Programs →
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/string-module/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"
import Image from "next/image"

export default function StringModulePage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 11
            
            
            String Module Operations
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                String Module Operations Menu
                
              

              
                {/* AIM */}
                
                  AIM
                  
                    To write a menu-driven program to perform various operations using the string module in Python,
                    including displaying ASCII letters, digits, hexadecimal digits, octal digits, punctuation, and
                    converting strings to title case.
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Start
                    Import the string module
                    Initialize choice variable to 0
                    Start a while loop that continues until choice is 7
                    Display the menu with 7 options
                    Take user's choice as input
                    
                      Use if-elif-else statements to handle each choice:
                      
                        Choice 1: Display ASCII letters using string.ascii_letters
                        Choice 2: Display digits using string.digits
                        Choice 3: Display hexadecimal digits using string.hexdigits
                        Choice 4: Display octal digits using string.octdigits
                        Choice 5: Display punctuation using string.punctuation
                        Choice 6: Take string input and display in title case using string.capwords()
                        Choice 7: Break the loop to exit
                      
                    
                    Repeat until user chooses to exit
                    Stop
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`# Menu-driven program to perform string module operations

import string

ch = 0
while ch != 7:
    print('''
            1. Display the ascii letters
            2. Display the digits
            3. Display Hexadedigits
            4. Display Octaldigits
            5. Display Punctuation
            6. Display string in title case
            7. Exit
            ''')
    
    ch = int(input("Enter your choice:"))
    
    if ch == 1:
        print(string.ascii_letters)
    elif ch == 2:
        print(string.digits)
    elif ch == 3:
        print(string.hexdigits)
    elif ch == 4:
        print(string.octdigits)
    elif ch == 5:
        print(string.punctuation)
    elif ch == 6:
        s = input("Enter sentence:")
        print(string.capwords(s))
    elif ch == 7:
        break
    else:
        print("Invalid Choice")`}
                      
                    
                  
                

                {/* OUTPUT */}
                
                  OUTPUT
                  
                    
                  
                  
                    The above image shows the complete execution of the program with different menu choices
                    demonstrating all string module operations.
                  
                

                {/* STRING MODULE CONSTANTS */}
                
                  STRING MODULE CONSTANTS
                  
                    
                      
                        
                          Constant
                          Description
                          Value
                        
                      
                      
                        
                          string.ascii_letters
                          
                            All ASCII letters (lowercase + uppercase)
                          
                          
                            abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
                          
                        
                        
                          string.digits
                          All decimal digits
                          0123456789
                        
                        
                          string.hexdigits
                          All hexadecimal digits
                          0123456789abcdefABCDEF
                        
                        
                          string.octdigits
                          All octal digits
                          01234567
                        
                        
                          string.punctuation
                          All punctuation characters
                          
                            {"!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"}
                          
                        
                      
                    
                  
                

                {/* ALTERNATIVE METHODS */}
                
                  ALTERNATIVE METHODS

                  Method 2: Using Functions
                  
                                          
                        {`import string

def display_ascii_letters():
    print("ASCII Letters:", string.ascii_letters)

def display_digits():
    print("Digits:", string.digits)

def display_hexdigits():
    print("Hexadecimal Digits:", string.hexdigits)

def display_octdigits():
    print("Octal Digits:", string.octdigits)

def display_punctuation():
    print("Punctuation:", string.punctuation)

def display_title_case():
    s = input("Enter sentence: ")
    print("Title Case:", string.capwords(s))

def main():
    functions = {
        1: display_ascii_letters,
        2: display_digits,
        3: display_hexdigits,
        4: display_octdigits,
        5: display_punctuation,
        6: display_title_case
    }
    
    while True:
        print('''
        1. Display ASCII letters
        2. Display digits
        3. Display Hexadecimal digits
        4. Display Octal digits
        5. Display Punctuation
        6. Display string in title case
        7. Exit
        ''')
        
        choice = int(input("Enter your choice: "))
        
        if choice == 7:
            break
        elif choice in functions:
            functions[choice]()
        else:
            print("Invalid choice!")

if __name__ == "__main__":
    main()`}
                      
                    
                  

                  
                    Method 3: Using Class-Based Approach
                  
                  
                                          
                        {`import string

class StringOperations:
    def __init__(self):
        self.menu_options = {
            1: ("Display ASCII letters", self.show_ascii_letters),
            2: ("Display digits", self.show_digits),
            3: ("Display Hexadecimal digits", self.show_hexdigits),
            4: ("Display Octal digits", self.show_octdigits),
            5: ("Display Punctuation", self.show_punctuation),
            6: ("Display string in title case", self.show_title_case),
            7: ("Exit", None)
        }
    
    def show_menu(self):
        print("\\n" + "="*40)
        print("STRING MODULE OPERATIONS MENU")
        print("="*40)
        for key, (description, _) in self.menu_options.items():
            print(f"{key}. {description}")
        print("="*40)
    
    def show_ascii_letters(self):
        print(f"ASCII Letters: {string.ascii_letters}")
    
    def show_digits(self):
        print(f"Digits: {string.digits}")
    
    def show_hexdigits(self):
        print(f"Hexadecimal Digits: {string.hexdigits}")
    
    def show_octdigits(self):
        print(f"Octal Digits: {string.octdigits}")
    
    def show_punctuation(self):
        print(f"Punctuation: {string.punctuation}")
    
    def show_title_case(self):
        sentence = input("Enter sentence: ")
        print(f"Title Case: {string.capwords(sentence)}")
    
    def run(self):
        while True:
            self.show_menu()
            try:
                choice = int(input("Enter your choice: "))
                if choice == 7:
                    print("Thank you for using String Operations!")
                    break
                elif choice in self.menu_options:
                    _, function = self.menu_options[choice]
                    if function:
                        function()
                else:
                    print("Invalid choice! Please try again.")
            except ValueError:
                print("Please enter a valid number!")

# Usage
if __name__ == "__main__":
    app = StringOperations()
    app.run()`}
                      
                    
                  
                

                {/* CONCLUSION */}
                
                  CONCLUSION
                  
                     Thus, the given program was successfully executed and the output was verified as per the expected result.
                                    
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is the purpose of the string module in Python?
                      
                        The string module provides various constants and functions for string operations. It contains
                        predefined constants like ascii_letters, digits, punctuation, etc., and functions like
                        capwords() for text manipulation.
                      
                    
                    
                      
                        What is the difference between string.ascii_letters and string.ascii_lowercase?
                      
                      
                        string.ascii_letters contains both lowercase and uppercase letters (a-z and A-Z), while
                        string.ascii_lowercase contains only lowercase letters (a-z).
                      
                    
                    
                      How does string.capwords() differ from the title() method?
                      
                        string.capwords() capitalizes the first letter of each word and removes extra whitespace, while
                        title() capitalizes the first letter after any whitespace or punctuation but preserves the
                        original spacing.
                      
                    
                    
                      What characters are included in string.punctuation?
                      
                        string.punctuation includes all ASCII punctuation characters:{" "}
                        {"!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"}
                      
                    
                    
                      
                        How would you modify this program to handle invalid menu choices more gracefully?
                      
                      
                        Add try-except blocks to handle ValueError for non-integer inputs, provide clear error messages,
                        and use input validation to ensure choices are within the valid range (1-7).
                      
                    
                    
                      
                        What is the advantage of using hexadecimal and octal digit constants?
                      
                      
                        These constants are useful for validating input in different number systems, converting between
                        bases, and working with low-level programming where different number representations are common.
                      
                    
                    
                      
                        How can you extend this program to include custom string operations?
                      
                      
                        Add new menu options with corresponding elif conditions, create functions for complex operations
                        like palindrome checking, string reversal, or character frequency counting.
                      
                    
                    
                      
                        What are the limitations of using a simple while loop for menu-driven programs?
                      
                      
                        Simple while loops don't handle exceptions well, can become complex with many options, and don't
                        provide easy extensibility. Using functions or classes provides better organization and error
                        handling.
                      
                    
                  
                

                
                  
                    Next Program: Phone Directory Operations
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/string-module/related.tsx" isMerged="true"
import Link from "next/link"

export default function Related() {
  const relatedResources = [
    {
      id: 1,
      title: "Python Fundamentals",
      type: "theory",
      url: "/computer-science/class-11/python-fundamentals",
    },
    {
      id: 2,
      title: "Python Input/Output Tutorial",
      type: "video",
      url: "https://youtube.com/@pythontyro4579",
    },
    {
      id: 3,
      title: "Python Basics PDF",
      type: "pdf",
      url: "/resources/python-basics.pdf",
    },
    {
      id: 4,
      title: "Python Fundamentals MCQs",
      type: "link",
      url: "/mcqs/computer-science/class-11/python-fundamentals",
    },
    {
      id: 5,
      title: "Next Program: Number Comparison",
      type: "practical",
      url: "/computer-science/practical/class-11/number-comparison",
    },
  ]

  return (
    
      Related Resources
      
        {relatedResources.map((resource) => (
          
            
              {resource.type === "theory" && (
                
              )}
              {resource.type === "video" && (
                
              )}
              {resource.type === "pdf" && (
                
              )}
              {resource.type === "link" && (
                
              )}
              {resource.type === "practical" && (
                
              )}
              {resource.title}
              {resource.type === "pdf" && (
                
              )}
            
          
        ))}
      

      
        Need Help?
        
          Join our tuition classes for personalized guidance and doubt clearing sessions.
        
        
          Register for Classes →
        
      

      
        Practice More
        Try more Python programs to strengthen your programming skills.
        
          View All Programs →
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/string-palindrome/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function StringPalindromePage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 11
            
            
            String Palindrome
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                Check Palindrome String and Convert Case
                
              

              
                {/* AIM */}
                
                  AIM
                  
                    To write a Python program that determines whether a string is a palindrome or not and demonstrates
                    case conversion of characters in a string.
                  

                  
                    Key Concepts:
                    
                      
                        • Palindrome: A string that reads the same forwards and backwards
                      
                      
                        • String Slicing: Using [::-1] to reverse a string
                      
                      
                        • Case Conversion: Converting between uppercase and lowercase
                      
                    
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  For Palindrome Check:
                  
                    Start
                    Input a string from the user
                    Create a reversed version of the string using slicing [::-1]
                    Compare the original string with the reversed string
                    If they are equal, the string is a palindrome
                    Otherwise, it is not a palindrome
                    Display the result
                    Stop
                  

                  For Case Conversion:
                  
                    Input a string from the user
                    Use built-in string methods for case conversion
                    Display original, uppercase, lowercase, and title case versions
                  
                

                {/* PROGRAM */}
                
                  PROGRAM

                  Palindrome Check Program:
                  
                                          
                        {`# Input a string and determine whether it is a palindrome or not
original = input("Enter a string:")
reverse = original[::-1]  # [::-1] will reverse the string
# print("Reverse String=", reverse)

if original == reverse:
    print("String is Palindrome:")
else:
    print("String is not Palindrome:")`}
                      
                    
                  

                  Case Conversion Program:
                  
                                          
                        {`# Convert the case of characters in a string
text = input("Enter a string: ")

print("Original String:", text)
print("Uppercase:", text.upper())
print("Lowercase:", text.lower())
print("Title Case:", text.title())
print("Capitalize:", text.capitalize())
print("Swapcase:", text.swapcase())`}
                      
                    
                  
                

                {/* OUTPUT */}
                
                  OUTPUT

                  Test Case 1 - Palindrome String:
                  
                    Enter a string: madam
                    String is Palindrome:
                  

                  Test Case 2 - Non-Palindrome String:
                  
                    Enter a string: hello
                    String is not Palindrome:
                  

                  Test Case 3 - Case Conversion:
                  
                    Enter a string: Hello World
                    Original String: Hello World
                    Uppercase: HELLO WORLD
                    Lowercase: hello world
                    Title Case: Hello World
                    Capitalize: Hello world
                    Swapcase: hELLO wORLD
                  
                

                {/* CONCLUSION */}
                
                  CONCLUSION
                  
                    In this program, we learned how to check if a string is a palindrome using string slicing and how to
                    perform various case conversions. Key learning outcomes include:
                  
                  
                    Understanding string slicing with [::-1] for reversing strings
                    String comparison for palindrome detection
                    Using built-in string methods for case conversion
                    Difference between capitalize(), title(), and other case methods
                  
                  
                    This program demonstrates fundamental string manipulation techniques that are essential for text
                    processing applications.
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is a palindrome string?
                      
                        A palindrome string is a string that reads the same forwards and backwards. Examples include
                        "madam", "racecar", "level", etc.
                      
                    
                    
                      How does [::-1] work in Python?
                      
                        [::-1] is string slicing syntax where the third parameter -1 indicates step size of -1, which
                        reverses the string by reading it backwards.
                      
                    
                    
                      What is the difference between upper() and capitalize()?
                      
                        upper() converts all characters to uppercase, while capitalize() only converts the first
                        character to uppercase and rest to lowercase.
                      
                    
                    
                      How would you check palindrome ignoring case sensitivity?
                      
                        Convert both original and reversed strings to the same case using lower() or upper() before
                        comparison: original.lower() == reverse.lower()
                      
                    
                    
                      What does swapcase() method do?
                      
                        swapcase() converts uppercase characters to lowercase and lowercase characters to uppercase in
                        the string.
                      
                    
                    
                      How can you check palindrome without using slicing?
                      
                        Use a loop to compare characters from start and end positions moving towards center, or use
                        reversed() function.
                      
                    
                    
                      What is the difference between title() and capitalize()?
                      
                        title() capitalizes the first letter of each word, while capitalize() only capitalizes the first
                        letter of the entire string.
                      
                    
                    
                      How would you handle spaces and punctuation in palindrome checking?
                      
                        Remove spaces and punctuation using replace() or regular expressions, then check palindrome on
                        the cleaned string.
                      
                    
                  
                

                
                  
                    
                    Previous: String Analysis
                  
                  
                    Next: List Min-Max
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/string-palindrome/related.tsx" isMerged="true"
import Link from "next/link"

export default function Related() {
  const relatedResources = [
    {
      id: 1,
      title: "Strings in Python",
      type: "theory",
      url: "/computer-science/class-11/strings-python",
    },
    {
      id: 2,
      title: "String Methods Tutorial",
      type: "video",
      url: "https://youtube.com/@pythontyro4579",
    },
    {
      id: 3,
      title: "String Analysis Program",
      type: "practical",
      url: "/computer-science/practical/class-11/string-analysis",
    },
    {
      id: 4,
      title: "String Module Operations",
      type: "practical",
      url: "/computer-science/practical/class-11/string-module",
    },
    {
      id: 5,
      title: "Python Strings MCQs",
      type: "link",
      url: "/mcqs/computer-science/class-11/strings",
    },
  ]

  return (
    
      Related Resources
      
        {relatedResources.map((resource) => (
          
            
              {resource.type === "theory" && (
                
              )}
              {resource.type === "video" && (
                
              )}
              {resource.type === "practical" && (
                
              )}
              {resource.type === "link" && (
                
              )}
              {resource.title}
            
          
        ))}
      

      
        String Tips
        
          • Use [::-1] for quick string reversal
          • String methods don't modify original string
          • Consider case sensitivity in comparisons
          • Handle spaces and punctuation carefully
        
      

      
        Practice More
        Try more string manipulation programs to master text processing.
        
          View All Programs →
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/student-menu/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function StudentMenuPage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 11
            
            
            Student Menu System
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                Menu-Driven Student Record Management System
                
              

              
                {/* AIM */}
                
                  AIM
                  
                    To create a dictionary named student and write a menu-driven program to perform various operations:
                    Show record, Add new student, Delete a student, Search record, Update record, Sort record, and Exit.
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Start
                    Input number of students and create initial dictionary
                    Initialize choice variable c = 0
                    While c ≠ 7, repeat the following:
                    a. Display menu options (1-7)
                    b. Input user choice
                    c. Execute corresponding operation:
                    • Choice 1: Display all records
                    • Choice 2: Add new student
                    • Choice 3: Delete student by name
                    • Choice 4: Search for student
                    • Choice 5: Update student record
                    • Choice 6: Sort and display records
                    • Choice 7: Exit program
                    Stop
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`# Menu-driven Student Record Management System
n = int(input("How many students:"))
std = {}

# Initial data entry
for i in range(n):
    print("Enter details of student:", i+1)
    name = input("Enter name of student:")
    pn = int(input("Enter Percentage:"))
    std[name] = pn

c = 0
while c != 7:
    print('''
            1. Show record
            2. Add new student
            3. Delete a student
            4. Search record
            5. Update record
            6. Sort record
            7. Exit
            ''')
    
    c = int(input("Enter your choice:"))
    
    if c == 1:
        for i in std:
            print(i, ":", std[i])
    
    elif c == 2:
        print("Enter details of new student:")
        name = input("Enter name:")
        pn = int(input("Enter Percentage:"))
        std[name] = pn
    
    elif c == 3:
        nm = input("Enter name to be deleted:")
        f = std.pop(nm, -1)
        if f != -1:
            print(f, " is deleted successfully.")
        else:
            print(nm, " not found.")
    
    elif c == 4:
        name = input("Enter Customer Name:")
        if name in std:
            print(name, " found in the record.")
        else:
            print(name, " not found in the record.")
    
    elif c == 5:
        name = input("Enter Customer Name:")
        pn = int(input("Enter percentage to modify:"))
        std[name] = pn
    
    elif c == 6:
        l = sorted(std)
        for i in l:
            print(i, ":", std[i])
    
    elif c == 7:
        break
    
    else:
        print("Invalid Choice")`}
                      
                    
                  
                

                {/* OUTPUT */}
                
                  OUTPUT
                  
                    How many students: 2
                    Enter details of student: 1
                    Enter name of student: Alice
                    Enter Percentage: 85
                    Enter details of student: 2
                    Enter name of student: Bob
                    Enter Percentage: 78
                    

                     1. Show record
                     2. Add new student
                     3. Delete a student
                     4. Search record
                     5. Update record
                     6. Sort record
                     7. Exit
                    

                    Enter your choice: 1
                    Alice : 85
                    Bob : 78
                  
                  
                    Enter your choice: 2
                    Enter details of new student:
                    Enter name: Charlie
                    Enter Percentage: 92
                    

                    Enter your choice: 6
                    Alice : 85
                    Bob : 78
                    Charlie : 92
                  
                

                {/* CONCLUSION */}
                
                  CONCLUSION
                  
                    Thus, the given program was successfully executed and the output was verified as per the expected result.
                  
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      
                        Why do we use a while loop instead of a for loop for the menu system?
                      
                      
                        A while loop allows the program to continue running until the user chooses to exit (option 7). A
                        for loop would require knowing the exact number of iterations in advance, which is not suitable
                        for menu-driven programs.
                      
                    
                    
                      
                        What is the purpose of using std.pop(nm, -1) in the delete operation?
                      
                      
                        The pop() method with a default value (-1) safely removes and returns the value if the key
                        exists, or returns the default value if the key doesn't exist, preventing KeyError exceptions.
                      
                    
                    
                      How does the sort operation work in this program?
                      
                        The sorted(std) function returns a sorted list of dictionary keys (student names) in
                        alphabetical order. We then iterate through this sorted list to display records in alphabetical
                        order.
                      
                    
                    
                      What happens if we try to update a student who doesn't exist?
                      
                        The program will create a new entry with that name and percentage, as dictionary assignment
                        (std[name] = pn) creates a new key-value pair if the key doesn't exist.
                      
                    
                    
                      How can we improve the search functionality?
                      
                        We could implement case-insensitive search using name.lower(), partial name matching, or search
                        by percentage ranges. We could also display the student's percentage when found.
                      
                    
                    
                      What are the limitations of this current implementation?
                      
                        Limitations include: no data persistence after program ends, no input validation for percentages
                        (0-100 range), no handling of duplicate names, and no option to sort by percentage.
                      
                    
                    
                      How would you add input validation for percentage values?
                      
                        We could add a while loop to check if 0 ≤ percentage ≤ 100, and use try-except blocks to handle
                        non-numeric input, prompting the user to re-enter valid values.
                      
                    
                    
                      How can we modify the program to save data to a file?
                      
                        We could use the json module to save the dictionary to a JSON file when exiting and load it when
                        starting the program, providing data persistence across program runs.
                      
                    
                  
                

                
                  
                    Next Program: Lucky Winners Selection
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/student-menu/related.tsx" isMerged="true"
import Link from "next/link"

export default function Related() {
  const relatedResources = [
    {
      id: 1,
      title: "Python Fundamentals",
      type: "theory",
      url: "/computer-science/class-11/python-fundamentals",
    },
    {
      id: 2,
      title: "Python Input/Output Tutorial",
      type: "video",
      url: "https://youtube.com/@pythontyro4579",
    },
    {
      id: 3,
      title: "Python Basics PDF",
      type: "pdf",
      url: "/resources/python-basics.pdf",
    },
    {
      id: 4,
      title: "Python Fundamentals MCQs",
      type: "link",
      url: "/mcqs/computer-science/class-11/python-fundamentals",
    },
    {
      id: 5,
      title: "Next Program: Number Comparison",
      type: "practical",
      url: "/computer-science/practical/class-11/number-comparison",
    },
  ]

  return (
    
      Related Resources
      
        {relatedResources.map((resource) => (
          
            
              {resource.type === "theory" && (
                
              )}
              {resource.type === "video" && (
                
              )}
              {resource.type === "pdf" && (
                
              )}
              {resource.type === "link" && (
                
              )}
              {resource.type === "practical" && (
                
              )}
              {resource.title}
              {resource.type === "pdf" && (
                
              )}
            
          
        ))}
      

      
        Need Help?
        
          Join our tuition classes for personalized guidance and doubt clearing sessions.
        
        
          Register for Classes →
        
      

      
        Practice More
        Try more Python programs to strengthen your programming skills.
        
          View All Programs →
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/three-number-comparison/related.tsx" isMerged="true"
import Link from "next/link"
import { ExternalLink, FileText, BookOpen } from "lucide-react"

export default function Related() {
  return (
    
      {/* Related Programs */}
      
        Related Programs
        
          
            
            Welcome Message
          
          
            
            Arithmetic Operations
          
          
            
            Number Checks
          
        
      

      {/* Study Resources */}
      
        Study Resources
        
          
            
            Flow of Control
          
          
            
            Python Fundamentals
          
        
      

      {/* Quick Links */}
      
        Quick Links
        
          
            
            Class 11 MCQs
          
          
            
            Class 11 Theory
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/welcome-message/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function WelcomeMessagePage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 11
            
            
            Welcome Message
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                Display Welcome Message
                
              

              
                {/* AIM */}
                
                  AIM
                  
                    To write a Python program that displays a welcome message to the user with proper formatting and decorative elements.
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Start
                    Take the user's name as input
                    Display a decorative border using asterisks
                    Display the welcome message with the user's name
                    Add additional formatting for better presentation
                    Stop
                  
                

                {/* PROGRAM */}
                
  PROGRAM
  
          
        {`# Python program to display welcome message
print("Welcome to Python Programming!")`}
      
    
  



                {/* OUTPUT */}
                
                  OUTPUT
                  
                    Welcome to Python Programming!
                  
                

                {/* CONCLUSION */}
                
                  CONCLUSION
                    
                    Thus, the given program was successfully executed and the output was verified as per the expected result.
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is the purpose of the print() function in Python?
                      
                        The print() function is used to display output on the screen. It can print strings, numbers,
                        variables, and expressions.
                      
                    
                    
                      How do you take input from the user in Python?
                      
                        We use the input() function to take input from the user. It always returns a string, so we need
                        to convert it to other data types if required.
                      
                    
                    
                      What is string formatting and why is it useful?
                      
                        String formatting allows us to insert variables into strings. F-strings (f"text {"{name}"}")
                        provide a clean and readable way to format strings.
                      
                    
                    
                      What does the * operator do with strings?
                      
                        The * operator with strings performs string multiplication, repeating the string a specified
                        number of times. For example, "*" * 5 produces "*****".
                      
                    
                    
                      What is the purpose of escape sequences like \\n?
                      
                        Escape sequences represent special characters. \\n represents a newline character, \\t
                        represents a tab, and \\\\ represents a backslash.
                      
                    
                    
                      How does the center() method work?
                      
                        The center() method centers a string within a specified width by adding spaces on both sides.
                        For example, "Hello".center(10) produces " Hello ".
                      
                    
                    
                      What is the difference between single and double quotes in Python?
                      
                        Both single ('') and double ("") quotes can be used to create strings in Python. They are
                        functionally equivalent, but you can use one inside the other.
                      
                    
                    
                      How can you calculate the length of a string?
                      
                        You can use the len() function to calculate the length of a string. For example, len("Hello")
                        returns 5.
                      
                    
                  
                

                
                  
                    Next Program: Number Comparison
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-11/welcome-message/related.tsx" isMerged="true"
import Link from "next/link"
import { ExternalLink, FileText, BookOpen } from "lucide-react"

export default function Related() {
  return (
    
      {/* Related Programs */}
      
        Related Programs
        
          
            
            Number Comparison
          
          
            
            Arithmetic Operations
          
          
            
            String Analysis
          
        
      

      {/* Study Resources */}
      
        Study Resources
        
          
            
            Python Fundamentals
          
          
            
            Strings in Python
          
        
      

      {/* Quick Links */}
      
        Quick Links
        
          
            
            Class 11 MCQs
          
          
            
            Class 11 Theory
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/dice-simulator/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function DiceSimulatorPage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 12
            
            
            Dice Simulator
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                
                  Write a random number generator that generates random numbers between 1 and 6 (simulates a dice)
                
                
              

              
                {/* AIM */}
                
                  AIM
                  
                    To write a Python program that generates random numbers between 1 and 6 to simulate a dice roll.
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Import the random module.
                    Create a function to simulate dice roll using random.randint(1, 6).
                    Display the menu options to the user.
                    Get user choice for single roll, multiple rolls, or exit.
                    For single roll, generate and display one random number.
                    For multiple rolls, ask for number of rolls and generate that many numbers.
                    Display the results with appropriate formatting.
                    Continue until user chooses to exit.
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`import random

def roll_dice():
    """Function to simulate a single dice roll"""
    return random.randint(1, 6)

def display_dice(number):
    """Function to display dice in a visual format"""
    dice_faces = {
        1: ["┌─────────┐",
            "│         │",
            "│    ●    │",
            "│         │",
            "└─────────┘"],
        2: ["��─────────┐",
            "│  ●      │",
            "│         │",
            "│      ●  │",
            "└─────────┘"],
        3: ["┌─────────┐",
            "│  ●      │",
            "│    ●    │",
            "│      ●  │",
            "└─────────┘"],
        4: ["┌─────────┐",
            "│  ●   ●  │",
            "│         │",
            "│  ●   ●  │",
            "└─────────┘"],
        5: ["┌─────────┐",
            "│  ●   ●  │",
            "│    ●    │",
            "│  ●   ●  │",
            "└─────────┘"],
        6: ["┌─────────┐",
            "│  ●   ●  │",
            "│  ●   ●  │",
            "│  ●   ●  │",
            "└─────────┘"]
    }
    
    for line in dice_faces[number]:
        print(line)

# Main program
print("🎲 DICE SIMULATOR 🎲")
print("=" * 30)

while True:
    print("\\n1. Roll dice once")
    print("2. Roll dice multiple times")
    print("3. Roll two dice")
    print("4. Exit")
    
    choice = input("\\nEnter your choice (1-4): ")
    
    if choice == '1':
        result = roll_dice()
        print(f"\\n🎲 You rolled: {result}")
        display_dice(result)
        
    elif choice == '2':
        try:
            num_rolls = int(input("How many times do you want to roll the dice? "))
            if num_rolls <= 0:
                print("Please enter a positive number!")
                continue
                
            print(f"\\n🎲 Rolling dice {num_rolls} times:")
            results = []
            for i in range(num_rolls):
                roll = roll_dice()
                results.append(roll)
                print(f"Roll {i+1}: {roll}")
            
            print(f"\\nSummary:")
            print(f"Total rolls: {len(results)}")
            print(f"Results: {results}")
            print(f"Sum: {sum(results)}")
            print(f"Average: {sum(results)/len(results):.2f}")
            
        except ValueError:
            print("Please enter a valid number!")
            
    elif choice == '3':
        dice1 = roll_dice()
        dice2 = roll_dice()
        total = dice1 + dice2
        
        print(f"\\n🎲 First dice: {dice1}")
        display_dice(dice1)
        print(f"\\n🎲 Second dice: {dice2}")
        display_dice(dice2)
        print(f"\\n🎯 Total: {total}")
        
    elif choice == '4':
        print("\\n👋 Thanks for playing! Goodbye!")
        break
        
    else:
        print("❌ Invalid choice! Please enter 1, 2, 3, or 4.")

print("\\nProgram ended.")`}
                      
                    
                  
                

                {/* OUTPUT */}
                
                  OUTPUT
                  
                    🎲 DICE SIMULATOR 🎲
                    ==============================
                    
                    1. Roll dice once
                    2. Roll dice multiple times
                    3. Roll two dice
                    4. Exit
                    
                    Enter your choice (1-4): 1
                    
                    🎲 You rolled: 4
                    ┌─────────┐
                    │ ● ● │
                    │ │
                    │ ● ● │
                    └─────────┘
                    
                    Enter your choice (1-4): 2
                    How many times do you want to roll the dice? 5
                    
                    🎲 Rolling dice 5 times:
                    Roll 1: 3
                    Roll 2: 6
                    Roll 3: 1
                    Roll 4: 5
                    Roll 5: 2
                    
                    Summary:
                    Total rolls: 5
                    Results: [3, 6, 1, 5, 2]
                    Sum: 17
                    Average: 3.40
                  
                

                {/* RESULT */}
                
                  RESULT
                  
                    
                      Thus, the given program was successfully executed and the output was verified as per the expected
                      result.
                    
                  
                

                {/* KEY POINTS */}
                
                  KEY POINTS
                  
                    
                      random.randint(1, 6): Generates random integers between 1 and 6 (inclusive)
                    
                    
                      Visual Representation: ASCII art used to display dice faces
                    
                    
                      Menu-driven: User can choose different rolling options
                    
                    
                      Statistics: Program calculates sum and average for multiple rolls
                    
                    
                      Error Handling: Validates user input for number of rolls
                    
                  
                

                {/* PROGRAM VARIATIONS */}
                
                  PROGRAM VARIATIONS

                  Method 1: Simple Dice Simulator
                  
                                          
                        {`import random

# Simple dice simulator
def simple_dice():
    return random.randint(1, 6)

# Roll dice 10 times
print("Rolling dice 10 times:")
for i in range(10):
    result = simple_dice()
    print(f"Roll {i+1}: {result}")

# Single roll
print(f"\\nSingle roll: {simple_dice()}")`}
                      
                    
                  

                  Method 2: Using random.choice()
                  
                                          
                        {`import random

# Using random.choice with list of dice values
dice_values = [1, 2, 3, 4, 5, 6]

def roll_with_choice():
    return random.choice(dice_values)

# Roll dice
for i in range(5):
    print(f"Roll {i+1}: {roll_with_choice()}")`}
                      
                    
                  

                  
                    Method 3: Class-based Dice Simulator
                  
                  
                                          
                        {`import random

class Dice:
    def __init__(self):
        self.history = []
    
    def roll(self):
        result = random.randint(1, 6)
        self.history.append(result)
        return result
    
    def get_statistics(self):
        if not self.history:
            return "No rolls yet!"
        
        return {
            'total_rolls': len(self.history),
            'sum': sum(self.history),
            'average': sum(self.history) / len(self.history),
            'max': max(self.history),
            'min': min(self.history)
        }

# Usage
my_dice = Dice()
for i in range(10):
    result = my_dice.roll()
    print(f"Roll {i+1}: {result}")

print("\\nStatistics:", my_dice.get_statistics())`}
                      
                    
                  
                

                {/* COMMON ERRORS */}
                
                  COMMON ERRORS & SOLUTIONS
                  
                    
                      ModuleNotFoundError
                      
                        Make sure to import the random module at the beginning of your program.
                      
                    
                    
                      ValueError in input
                      
                        Use try-except blocks to handle invalid input when asking for number of rolls.
                      
                    
                    
                      Wrong range in randint()
                      
                        Remember that randint(1, 6) includes both 1 and 6 in the possible results.
                      
                    
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is the difference between randint() and choice()?
                      
                        randint(a, b) generates random integers between a and b (inclusive), while choice(seq) selects a
                        random element from a sequence.
                      
                    
                    
                      How do you ensure truly random results?
                      
                        Python's random module uses a pseudorandom number generator. For cryptographic purposes, use the
                        secrets module instead.
                      
                    
                    
                      What does random.seed() do?
                      
                        random.seed() initializes the random number generator with a specific value, making the sequence
                        reproducible.
                      
                    
                    
                      How would you simulate rolling two dice simultaneously?
                      
                        Call randint(1, 6) twice and store the results in separate variables, then add them for the
                        total.
                      
                    
                    
                      What is the probability of getting each number on a fair dice?
                      
                        Each number (1-6) has an equal probability of 1/6 or approximately 16.67% on a fair six-sided
                        dice.
                      
                    
                    
                      How can you test if the dice simulator is fair?
                      
                        Roll the dice many times (e.g., 10000) and check if each number appears approximately 1/6 of the
                        time.
                      
                    
                    
                      What other random functions are available in Python?
                      
                        random.uniform(), random.random(), random.shuffle(), random.sample(), etc. for different random
                        operations.
                      
                    
                    
                      How would you modify this for a 20-sided dice?
                      
                        Change randint(1, 6) to randint(1, 20) and update the display function accordingly.
                      
                    
                  
                

                
                  
                    Back to Class 12 Programs
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/dice-simulator/related.tsx" isMerged="true"
import Link from "next/link"

export default function Related() {
  const relatedResources = [
    {
      id: 1,
      title: "Python Random Module",
      type: "theory",
      url: "/computer-science/class-12/python-revision-tour-1",
    },
    {
      id: 2,
      title: "Random Number Generation Tutorial",
      type: "video",
      url: "https://youtube.com/@pythontyro4579",
    },
    {
      id: 3,
      title: "Functions in Python",
      type: "theory",
      url: "/computer-science/class-12/working-with-functions",
    },
    {
      id: 4,
      title: "Python Programming MCQs",
      type: "link",
      url: "/mcqs/computer-science/class-12/python-programming",
    },
    {
      id: 5,
      title: "More Random Programs",
      type: "practical",
      url: "/computer-science/practical/class-11/lucky-winners",
    },
  ]

  return (
    
      Related Resources
      
        {relatedResources.map((resource) => (
          
            
              {resource.type === "theory" && (
                
              )}
              {resource.type === "video" && (
                
              )}
              {resource.type === "pdf" && (
                
              )}
              {resource.type === "link" && (
                
              )}
              {resource.type === "practical" && (
                
              )}
              {resource.title}
              {resource.type === "pdf" && (
                
              )}
            
          
        ))}
      

      
        Need Help?
        
          Join our tuition classes for personalized guidance and doubt clearing sessions.
        
        
          Register for Classes →
        
      

      
        Practice More
        Try similar random number programs to strengthen your concepts.
        
          View All Programs →
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/dice-simulator/toc.tsx" isMerged="true"
import Link from "next/link"

export default function TOC() {
  const programs = [
    { id: 1, title: "Read text file line by line with # separator", slug: "text-file-line-by-line" },
    {id: 2,title: "Count vowels, consonants, uppercase, lowercase in file",slug: "vowels-consonants-uppercase-lowercase"},
    { id: 3, title: "Remove lines containing character 'a'", slug: "remove-lines-with-character" },
    { id: 4, title: "Binary file with name and roll number search", slug: "binary-file-search" },
    { id: 5, title: "Binary file update marks by roll number", slug: "binary-file-update" },
    { id: 6, title: "Random number generator (Dice Simulator)", slug: "dice-simulator" },
    { id: 7, title: "Stack implementation using list", slug: "stack-implementation" },
    { id: 8, title: "CSV file with user-id and password", slug: "csv-user-password" },
    { id: 9, title: "User Defined Functions to manipulate List Store Indices of Non Zero elements &Double the Odd values", slug: "non-zero-double-odd-values" },
    { id: 10, title: "WORKING WITH BINARY FILE IN PYTHON Create a binary file, Search and display the records from the binary file", slug:"Binary-file-search-display-records" },
    { id: 11, title: "TEXT FILES IN PYTHON Remove duplicate lines from the file & Display unique words present in the file", slug: "text-file-remove-duplicate" },
    { id: 12, title: "TEXT FILES IN PYTHON Copying lines to a new file & Replacing the '-' sign with a blankspace", slug: "copying-line-new-file" },
    { id: 13, title: "TEXT FILES IN PYTHON Count the lines starts with I/T & Display the lines with exactly 6 words", slug:"text-file-exactly" },
    { id: 14, title: "TEXT FILES IN PYTHON Count the occurrences of word & Count number of vowels and consonants", slug: "count-occurrences" },
    { id: 15, title: "User Defined Functions to Manipulate List Find the Longest Word and Shifting the elements to left", slug: "longest-word-shifting-left" },
    { id: 16, title: "IMPLEMENTATION OF STACK USING LIST IN PYTHON", slug: "stack-list" },
    { id: 17, title: "ALTER table to add new attributes / modify data type / drop attribute", slug: "alter-table" },
    { id: 18, title: "UPDATE table to modify data", slug: "update-table" },
    { id: 19, title: "ORDER By to display data in ascending / descending order", slug: "order-by" },
    { id: 20, title: "DELETE to remove tuple(s)", slug: "delete-tuple" },
    { id: 21, title: "GROUP BY and find the min, max, sum, count and average", slug: "group-by" },
    { id: 22, title: "INTERFACING PYTHON WITH MYSQL DATABASE CONNECTIVITY APPLICATION PROGRAM - DELETE RECORDS", slug: "delete-records" },
    { id: 23, title: "INTERFACING PYTHON WITH MYSQL DATABASE CONNECTIVITY APPLICATION PROGRAM - UPDATE RECORDS ", slug: "update-records" },
    { id: 24, title: "INTERFACING PYTHON WITH MYSQL DATABASE CONNECTIVITY APPLICATION PROGRAM - INSERT RECORDS", slug: "insert-records" },
  ]

  return (
    
      Class 12 Programs
      
        {programs.map((program) => (
          
            
              {program.id}.
              {program.title}
            
          
        ))}
      

      
        Quick Tips
        
          • Import random module for number generation
          • Use randint(1, 6) for dice simulation
          • Handle user input validation properly
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/remove-lines-with-character/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function RemoveLinesWithCharacterPage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 12
            
            
            Remove Lines With Character
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                
                  Remove all the lines that contain the character 'a' in a file and write it to another file
                
                
              

              
                {/* AIM */}
                
                  AIM
                  
                    To remove all the lines that contain the character 'a' (both uppercase and lowercase) from a text
                    file and write the remaining lines to another file.
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Open the source file in read mode.
                    Open the destination file in write mode.
                    Read the source file line by line.
                    For each line, check if it contains the character 'a' or 'A'.
                    If the line does not contain 'a' or 'A', write it to the destination file.
                    If the line contains 'a' or 'A', skip it (do not write to destination).
                    Close both files.
                    Display appropriate messages about the operation.
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`# Open source file in read mode and destination file in write mode
source_file = open("source.txt", "r")
destination_file = open("destination.txt", "w")

lines_removed = 0
lines_kept = 0

# Read the source file line by line
for line in source_file:
    # Check if line contains 'a' or 'A'
    if 'a' in line or 'A' in line:
        lines_removed += 1
        print(f"Removed line: {line.strip()}")
    else:
        # Write line to destination file if it doesn't contain 'a' or 'A'
        destination_file.write(line)
        lines_kept += 1

# Close both files
source_file.close()
destination_file.close()

print(f"\\nOperation completed successfully!")
print(f"Lines kept: {lines_kept}")
print(f"Lines removed: {lines_removed}")
print("Check 'destination.txt' for the filtered content.")`}
                      
                    
                  
                

                {/* SAMPLE FILES */}
                
                  Content of source.txt file:
                  
                    Python is a programming language
                    It is easy to learn
                    Python supports multiple paradigms
                    Object-oriented programming
                    Functional programming
                    It has extensive libraries
                  

                  
                    Content of destination.txt file (after execution):
                  
                  
                    It is easy to learn
                    Object-oriented programming
                    Functional programming
                  
                

                {/* OUTPUT */}
                
                  OUTPUT
                  
                    Removed line: Python is a programming language
                    Removed line: Python supports multiple paradigms
                    Removed line: It has extensive libraries
                    
                    Operation completed successfully!
                    Lines kept: 3
                    Lines removed: 3
                    Check 'destination.txt' for the filtered content.
                  
                

                {/* RESULT */}
                
                  RESULT
                  
                    
                      Thus, the given program was successfully executed and the output was verified as per the expected
                      result.
                    
                  
                

                {/* KEY POINTS */}
                
                  KEY POINTS
                  
                    
                      Case Sensitivity: The program checks for both 'a' and 'A' to handle
                      case-insensitive matching
                    
                    
                      File Modes: Source file opened in 'r' mode, destination file in 'w' mode
                    
                    
                      Line Processing: Each line is processed individually using a for loop
                    
                    
                      Conditional Writing: Lines are written to destination only if they don't contain
                      the target character
                    
                    
                      Statistics: Program keeps track of lines kept and removed for user feedback
                    
                  
                

                {/* PROGRAM VARIATIONS */}
                
                  PROGRAM VARIATIONS

                  
                    Method 1: Using 'with' statement (Recommended)
                  
                  
                                          
                        {`# Using 'with' statement for better file handling
with open("source.txt", "r") as source, open("destination.txt", "w") as dest:
    lines_removed = 0
    lines_kept = 0
    
    for line in source:
        if 'a' not in line.lower():  # Case-insensitive check
            dest.write(line)
            lines_kept += 1
        else:
            lines_removed += 1
    
    print(f"Lines kept: {lines_kept}, Lines removed: {lines_removed}")
# Files are automatically closed`}
                      
                    
                  

                  Method 2: Using list comprehension
                  
                                          
                        {`# Reading all lines and filtering using list comprehension
with open("source.txt", "r") as source:
    lines = source.readlines()

# Filter lines that don't contain 'a' or 'A'
filtered_lines = [line for line in lines if 'a' not in line.lower()]

# Write filtered lines to destination
with open("destination.txt", "w") as dest:
    dest.writelines(filtered_lines)

print(f"Original lines: {len(lines)}")
print(f"Filtered lines: {len(filtered_lines)}")
print(f"Lines removed: {len(lines) - len(filtered_lines)}")`}
                      
                    
                  

                  Method 3: Function-based approach
                  
                                          
                        {`def remove_lines_with_character(source_file, dest_file, char):
    """Remove lines containing specified character from source to dest file"""
    try:
        with open(source_file, "r") as src, open(dest_file, "w") as dst:
            lines_kept = 0
            lines_removed = 0
            
            for line in src:
                if char.lower() not in line.lower():
                    dst.write(line)
                    lines_kept += 1
                else:
                    lines_removed += 1
            
            return lines_kept, lines_removed
    
    except FileNotFoundError:
        print(f"Error: {source_file} not found!")
        return 0, 0

# Call the function
kept, removed = remove_lines_with_character("source.txt", "destination.txt", "a")
print(f"Lines kept: {kept}, Lines removed: {removed}")`}
                      
                    
                  
                

                {/* COMMON ERRORS */}
                
                  COMMON ERRORS & SOLUTIONS
                  
                    
                      FileNotFoundError
                      
                        Make sure the source file exists in the same directory as your Python script.
                      
                    
                    
                      Permission Error
                      
                        Ensure you have write permissions for the destination file location.
                      
                    
                    
                      Case Sensitivity Issues
                      
                        Use .lower() method to make the search case-insensitive if needed.
                      
                    
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is the difference between 'r' and 'w' file modes?
                      
                        'r' mode opens file for reading only, while 'w' mode opens file for writing (creates new file or
                        overwrites existing).
                      
                    
                    
                      How do you make the character search case-insensitive?
                      
                        Use the .lower() method: if 'a' not in line.lower() to convert the line to lowercase before
                        checking.
                      
                    
                    
                      What happens if the source file doesn't exist?
                      
                        Python raises a FileNotFoundError. This should be handled using try-except blocks.
                      
                    
                    
                      Why is it important to close files?
                      
                        Closing files frees up system resources and ensures all data is properly written to the file.
                      
                    
                    
                      What is the advantage of using 'with' statement?
                      
                        The 'with' statement automatically closes files even if an error occurs, making it safer for
                        file operations.
                      
                    
                    
                      How can you modify this program to remove multiple characters?
                      
                        Use a list of characters and check if any character from the list is present in the line using
                        any() function.
                      
                    
                    
                      What does strip() method do in file processing?
                      
                        strip() removes leading and trailing whitespaces including newline characters from a string.
                      
                    
                    
                      How would you count the total number of characters removed?
                      
                        Keep a counter for characters and increment it by len(line) for each line that contains the
                        target character.
                      
                    
                  
                

                
                  
                    Back to Class 12 Programs
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/remove-lines-with-character/related.tsx" isMerged="true"
import Link from "next/link"
import { ExternalLink, FileText, BookOpen } from "lucide-react"

export default function Related() {
  return (
    
      {/* Related Programs */}
      
        Related Programs
        
          
            
            Number Comparison
          
          
            
            Series Sum
          
          
            
            GCD & LCM
          
        
      

      {/* Study Resources */}
      
        Study Resources
        
          
            
            Python Fundamentals
          
          
            
            Flow of Control
          
        
      

      {/* Quick Links */}
      
        Quick Links
        
          
            
            Class 11 MCQs
          
          
            
            Class 11 Theory
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/remove-lines-with-character/toc.tsx" isMerged="true"
import Link from "next/link"

export default function TOC() {
  const programs = [
    { id: 1, title: "Read text file line by line with # separator", slug: "text-file-line-by-line" },
    {id: 2,title: "Count vowels, consonants, uppercase, lowercase in file",slug: "vowels-consonants-uppercase-lowercase"},
    { id: 3, title: "Remove lines containing character 'a'", slug: "remove-lines-with-character" },
    { id: 4, title: "Binary file with name and roll number search", slug: "binary-file-search" },
    { id: 5, title: "Binary file update marks by roll number", slug: "binary-file-update" },
    { id: 6, title: "Random number generator (Dice Simulator)", slug: "dice-simulator" },
    { id: 7, title: "Stack implementation using list", slug: "stack-implementation" },
    { id: 8, title: "CSV file with user-id and password", slug: "csv-user-password" },
    { id: 9, title: "User Defined Functions to manipulate List Store Indices of Non Zero elements &Double the Odd values", slug: "non-zero-double-odd-values" },
    { id: 10, title: "WORKING WITH BINARY FILE IN PYTHON Create a binary file, Search and display the records from the binary file", slug:"Binary-file-search-display-records" },
    { id: 11, title: "TEXT FILES IN PYTHON Remove duplicate lines from the file & Display unique words present in the file", slug: "text-file-remove-duplicate" },
    { id: 12, title: "TEXT FILES IN PYTHON Copying lines to a new file & Replacing the '-' sign with a blankspace", slug: "copying-line-new-file" },
    { id: 13, title: "TEXT FILES IN PYTHON Count the lines starts with I/T & Display the lines with exactly 6 words", slug:"text-file-exactly" },
    { id: 14, title: "TEXT FILES IN PYTHON Count the occurrences of word & Count number of vowels and consonants", slug: "count-occurrences" },
    { id: 15, title: "User Defined Functions to Manipulate List Find the Longest Word and Shifting the elements to left", slug: "longest-word-shifting-left" },
    { id: 16, title: "IMPLEMENTATION OF STACK USING LIST IN PYTHON", slug: "stack-list" },
    { id: 17, title: "ALTER table to add new attributes / modify data type / drop attribute", slug: "alter-table" },
    { id: 18, title: "UPDATE table to modify data", slug: "update-table" },
    { id: 19, title: "ORDER By to display data in ascending / descending order", slug: "order-by" },
    { id: 20, title: "DELETE to remove tuple(s)", slug: "delete-tuple" },
    { id: 21, title: "GROUP BY and find the min, max, sum, count and average", slug: "group-by" },
    { id: 22, title: "INTERFACING PYTHON WITH MYSQL DATABASE CONNECTIVITY APPLICATION PROGRAM - DELETE RECORDS", slug: "delete-records" },
    { id: 23, title: "INTERFACING PYTHON WITH MYSQL DATABASE CONNECTIVITY APPLICATION PROGRAM - UPDATE RECORDS ", slug: "update-records" },
    { id: 24, title: "INTERFACING PYTHON WITH MYSQL DATABASE CONNECTIVITY APPLICATION PROGRAM - INSERT RECORDS", slug: "insert-records" },
  ]

  return (
    
      Class 12 Programs
      
        {programs.map((program) => (
          
            
              {program.id}.
              {program.title}
            
          
        ))}
      

      
        Quick Tips
        
          • Always use 'with' statement for file handling
          • Handle file exceptions properly
          • Consider case sensitivity in string operations
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/text-file-line-by-line/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function TextFileLineByLinePage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 12
            
            
            Text File Line By Line
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                
                  Read a text file line by line and display each word separated by a #
                
                
              

              
                {/* AIM */}
                
                  AIM
                  To read a text file line by line and display each word separated by a # symbol.
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Open the text file in read mode.
                    Read the file line by line using a loop.
                    For each line, remove leading/trailing whitespaces using strip().
                    Split the line into words using split().
                    Join the words using # as the separator using join().
                    Print the joined words.
                    Close the file.
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`# Open the file in read mode
file = open("sample.txt", "r")

# Read the file line by line
for line in file:
    line = line.strip()  # Remove leading/trailing whitespace or newline
    words = line.split()  # Split line into words
    output = '#'.join(words)  # Join words using #
    print(output)  # Display the formatted line

# Close the file
file.close()`}
                      
                    
                  
                

                {/* SAMPLE FILE CONTENT */}
                
                  Content of sample.txt file:
                  
                    CBSE Computer Science Class 12
                    File handling is an important topic
                    Python makes file processing easy
                  
                

                {/* OUTPUT */}
                
                  OUTPUT
                  
                    CBSE#Computer#Science#Class#12
                    File#handling#is#an#important#topic
                    Python#makes#file#processing#easy
                  
                

                {/* RESULT */}
                
                  RESULT
                  
                    The program executed successfully and displayed each word from the text file separated by a #
                    symbol, as required.
                  
                

                {/* KEY POINTS */}
                
                  KEY POINTS
                  
                    
                      strip(): Removes leading and trailing whitespaces including newline characters
                    
                    
                      split(): Splits a string into a list of words based on whitespace
                    
                    
                      join(): Joins elements of a list into a string using a specified separator
                    
                    
                      File handling: Always close the file after reading to free up system resources
                    
                  
                

                {/* PROGRAM VARIATIONS */}
                
                  PROGRAM VARIATIONS

                  
                    Method 1: Using 'with' statement (Recommended)
                  
                  
                                          
                        {`# Using 'with' statement for better file handling
with open("sample.txt", "r") as file:
    for line in file:
        line = line.strip()
        words = line.split()
        output = '#'.join(words)
        print(output)
# File is automatically closed`}
                      
                    
                  

                  
                    Method 2: Reading all lines at once
                  
                  
                                          
                        {`# Reading all lines at once
with open("sample.txt", "r") as file:
    lines = file.readlines()
    for line in lines:
        line = line.strip()
        words = line.split()
        output = '#'.join(words)
        print(output)`}
                      
                    
                  
                

                {/* COMMON ERRORS */}
                
                  COMMON ERRORS & SOLUTIONS
                  
                    
                      FileNotFoundError
                      
                        Make sure the file "sample.txt" exists in the same directory as your Python script.
                      
                    
                    
                      Not closing the file
                      
                        Always close the file using file.close() or use 'with' statement for automatic closure.
                      
                    
                    
                      Empty lines in output
                      
                        Use strip() to remove whitespaces and check if line is not empty before processing.
                      
                    
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is the purpose of strip() function?
                      
                        The strip() function removes leading and trailing whitespaces, including newline characters from
                        a string.
                      
                    
                    
                      What does split() function do?
                      
                        The split() function splits a string into a list of words based on whitespace characters
                        (spaces, tabs, newlines).
                      
                    
                    
                      How does join() function work?
                      
                        The join() function joins elements of a list into a single string using a specified separator.
                        Here, '#'.join(words) joins words with # symbol.
                      
                    
                    
                      Why should we close the file?
                      
                        Closing the file frees up system resources and ensures that all data is properly written to the
                        file.
                      
                    
                    
                      What is the advantage of using 'with' statement?
                      
                        The 'with' statement automatically closes the file even if an error occurs, making it a safer
                        way to handle files.
                      
                    
                  
                

                
                  
                    Back to Class 12 Programs
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/text-file-line-by-line/related.tsx" isMerged="true"
import Link from "next/link"
import { ExternalLink, FileText, BookOpen } from "lucide-react"

export default function Related() {
  return (
    
      {/* Related Programs */}
      
        Related Programs
        
          
            
            Number Comparison
          
          
            
            Series Sum
          
          
            
            GCD & LCM
          
        
      

      {/* Study Resources */}
      
        Study Resources
        
          
            
            Python Fundamentals
          
          
            
            Flow of Control
          
        
      

      {/* Quick Links */}
      
        Quick Links
        
          
            
            Class 11 MCQs
          
          
            
            Class 11 Theory
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/text-file-line-by-line/toc.tsx" isMerged="true"
import Link from "next/link"

export default function TOC() {
  const programs = [
    { id: 1, title: "Read text file line by line with # separator", slug: "text-file-line-by-line" },
    { id: 2, title: "File handling - Read and Write", slug: "file-read-write" },
    { id: 3, title: "Count words in a file", slug: "count-words-file" },
    { id: 4, title: "Search text in a file", slug: "search-text-file" },
    { id: 5, title: "Copy content from one file to another", slug: "copy-file-content" },
    { id: 6, title: "CSV file operations", slug: "csv-operations" },
    { id: 7, title: "Binary file handling", slug: "binary-file-handling" },
    { id: 8, title: "Stack implementation", slug: "stack-implementation" },
    { id: 9, title: "Queue implementation", slug: "queue-implementation" },
    { id: 10, title: "Database connectivity with MySQL", slug: "mysql-connectivity" },
  ]

  return (
    
      Class 12 Programs
      
        {programs.map((program) => (
          
            
              {program.id}.
              {program.title}
            
          
        ))}
      

      
        Quick Tips
        
          • Always use 'with' statement for file handling
          • Remember to handle file exceptions
          • Use appropriate file modes (r, w, a)
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/vowels-consonants-uppercase-lowercase /page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function vowelsconsonantsuppercaselowercasePage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 12
            
            
            Vowels Consonant Uppercase Lowercase
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                
                  Read a text file and display the number of vowels/consonants/uppercase/lowercase characters in the file
                
                
              

              
                {/* AIM */}
                
                  AIM
                  To read a text file line by line and display each word separated by a # symbol.
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Open the text file in read mode.
                    Read the file line by line using a loop.
                    For each line, remove leading/trailing whitespaces using strip().
                    Split the line into words using split().
                    Join the words using # as the separator using join().
                    Print the joined words.
                    Close the file.
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`# Open the file in read mode
file = open("sample.txt", "r")

# Read the file line by line
for line in file:
    line = line.strip()  # Remove leading/trailing whitespace or newline
    words = line.split()  # Split line into words
    output = '#'.join(words)  # Join words using #
    print(output)  # Display the formatted line

# Close the file
file.close()`}
                      
                    
                  
                

                {/* SAMPLE FILE CONTENT */}
                
                  Content of sample.txt file:
                  
                    CBSE Computer Science Class 12
                    File handling is an important topic
                    Python makes file processing easy
                  
                

                {/* OUTPUT */}
                
                  OUTPUT
                  
                    CBSE#Computer#Science#Class#12
                    File#handling#is#an#important#topic
                    Python#makes#file#processing#easy
                  
                

                {/* RESULT */}
                
                  RESULT
                  
                    The program executed successfully and displayed each word from the text file separated by a #
                    symbol, as required.
                  
                

                {/* KEY POINTS */}
                
                  KEY POINTS
                  
                    
                      strip(): Removes leading and trailing whitespaces including newline characters
                    
                    
                      split(): Splits a string into a list of words based on whitespace
                    
                    
                      join(): Joins elements of a list into a string using a specified separator
                    
                    
                      File handling: Always close the file after reading to free up system resources
                    
                  
                

                {/* PROGRAM VARIATIONS */}
                
                  PROGRAM VARIATIONS

                  
                    Method 1: Using 'with' statement (Recommended)
                  
                  
                                          
                        {`# Using 'with' statement for better file handling
with open("sample.txt", "r") as file:
    for line in file:
        line = line.strip()
        words = line.split()
        output = '#'.join(words)
        print(output)
# File is automatically closed`}
                      
                    
                  

                  
                    Method 2: Reading all lines at once
                  
                  
                                          
                        {`# Reading all lines at once
with open("sample.txt", "r") as file:
    lines = file.readlines()
    for line in lines:
        line = line.strip()
        words = line.split()
        output = '#'.join(words)
        print(output)`}
                      
                    
                  
                

                {/* COMMON ERRORS */}
                
                  COMMON ERRORS & SOLUTIONS
                  
                    
                      FileNotFoundError
                      
                        Make sure the file "sample.txt" exists in the same directory as your Python script.
                      
                    
                    
                      Not closing the file
                      
                        Always close the file using file.close() or use 'with' statement for automatic closure.
                      
                    
                    
                      Empty lines in output
                      
                        Use strip() to remove whitespaces and check if line is not empty before processing.
                      
                    
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is the purpose of strip() function?
                      
                        The strip() function removes leading and trailing whitespaces, including newline characters from
                        a string.
                      
                    
                    
                      What does split() function do?
                      
                        The split() function splits a string into a list of words based on whitespace characters
                        (spaces, tabs, newlines).
                      
                    
                    
                      How does join() function work?
                      
                        The join() function joins elements of a list into a single string using a specified separator.
                        Here, '#'.join(words) joins words with # symbol.
                      
                    
                    
                      Why should we close the file?
                      
                        Closing the file frees up system resources and ensures that all data is properly written to the
                        file.
                      
                    
                    
                      What is the advantage of using 'with' statement?
                      
                        The 'with' statement automatically closes the file even if an error occurs, making it a safer
                        way to handle files.
                      
                    
                  
                

                
                  
                    Back to Class 12 Programs
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/vowels-consonants-uppercase-lowercase /related.tsx" isMerged="true"
import Link from "next/link"
import { ExternalLink, FileText, BookOpen } from "lucide-react"

export default function Related() {
  return (
    
      {/* Related Programs */}
      
        Related Programs
        
          
            
            Number Comparison
          
          
            
            Series Sum
          
          
            
            GCD & LCM
          
        
      

      {/* Study Resources */}
      
        Study Resources
        
          
            
            Python Fundamentals
          
          
            
            Flow of Control
          
        
      

      {/* Quick Links */}
      
        Quick Links
        
          
            
            Class 11 MCQs
          
          
            
            Class 11 Theory
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/vowels-consonants-uppercase-lowercase /toc.tsx" isMerged="true"
import Link from "next/link"

export default function TOC() {
  const programs = [
   { id: 1, title: "Input a welcome message and display it", slug: "welcome-message" },
    { id: 2, title: "Input two numbers and display the larger/smaller number", slug: "number-comparison" },
    { id: 3, title: "Enter two integers and perform all arithmetic operations", slug: "arithmetic-operations" },
    { id: 4, title: "Generate patterns using nested loop", slug: "pattern-generation" },
    { id: 5, title: "Input x and n, print sum of series", slug: "series-sum" },
    { id: 6, title: "Check perfect number, Armstrong number or palindrome", slug: "number-checks" },
    { id: 7, title: "Check if number is prime or composite", slug: "prime-composite" },
    { id: 8, title: "Display Fibonacci series terms", slug: "fibonacci-series" },
    { id: 9, title: "Compute GCD and LCM of two integers", slug: "gcd-lcm" },
    { id: 10, title: "Count vowels, consonants, uppercase, lowercase in string", slug: "string-analysis" },
    { id: 11, title: "Check palindrome string and convert case", slug: "string-palindrome" },
    { id: 12, title: "Find largest/smallest number in list/tuple", slug: "list-min-max" },
    { id: 13, title: "Swap elements at even and odd locations", slug: "list-swap" },
    { id: 14, title: "Search element in list/tuple", slug: "list-search" },
    { id: 15, title: "Find smallest and largest number from list", slug: "list-extremes" },
    { id: 16, title: "Dictionary with student marks above 75", slug: "student-marks" },
    { id: 17, title: "Menu-driven student dictionary program", slug: "student-menu" },
    { id: 18, title: "Choose 4 random lucky winners from 100 customers", slug: "lucky-winners" },
    { id: 19, title: "String module operations menu", slug: "string-module" },
    { id: 20, title: "Friends phone directory dictionary operations", slug: "phone-directory" },
  ]

  return (
    
      Class 12 Programs
      
        {programs.map((program) => (
          
            
              {program.id}.
              {program.title}
            
          
        ))}
      

      
        Quick Tips
        
          • Always use 'with' statement for file handling
          • Remember to handle file exceptions
          • Use appropriate file modes (r, w, a)
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/vowels-consonants-uppercase-lowercase/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight, Download } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function VowelsConsonantsUppercaseLowercasePage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            
              Practical Programs
            
            
            
              Class 12
            
            
            Vowels Consonants Uppercase Lowercase
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              
                
                  Read a text file and display the number of vowels/consonants/uppercase/lowercase characters
                
                
              

              
                {/* AIM */}
                
                  AIM
                  
                    To read a text file and display the number of vowels, consonants, uppercase characters, and
                    lowercase characters in the file.
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Open the text file in read mode.
                    Initialize counters for vowels, consonants, uppercase, and lowercase characters to 0.
                    Read the entire content of the file.
                    Iterate through each character in the file content.
                    
                      For each character:
                      
                        Check if it's an alphabetic character
                        If uppercase, increment uppercase counter
                        If lowercase, increment lowercase counter
                        If vowel (a, e, i, o, u), increment vowel counter
                        If consonant (alphabetic but not vowel), increment consonant counter
                      
                    
                    Display the counts of vowels, consonants, uppercase, and lowercase characters.
                    Close the file.
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`# Open the file in read mode
file = open("sample.txt", "r")

# Initialize counters
vowels = 0
consonants = 0
uppercase = 0
lowercase = 0

# Read the entire content of the file
content = file.read()

# Define vowels
vowel_list = "aeiouAEIOU"

# Iterate through each character
for char in content:
    if char.isalpha():  # Check if character is alphabetic
        if char.isupper():
            uppercase += 1
        if char.islower():
            lowercase += 1
        
        if char in vowel_list:
            vowels += 1
        else:
            consonants += 1

# Display the results
print("Character Analysis of the file:")
print(f"Number of vowels: {vowels}")
print(f"Number of consonants: {consonants}")
print(f"Number of uppercase characters: {uppercase}")
print(f"Number of lowercase characters: {lowercase}")

# Close the file
file.close()`}
                      
                    
                  
                

                {/* SAMPLE FILE CONTENT */}
                
                  Content of sample.txt file:
                  
                    Hello World!
                    This is a SAMPLE file for Testing.
                    Python Programming is FUN.
                  
                

                {/* OUTPUT */}
                
                  OUTPUT
                  
                    Character Analysis of the file:
                    Number of vowels: 15
                    Number of consonants: 25
                    Number of uppercase characters: 12
                    Number of lowercase characters: 28
                  
                

                {/* RESULT */}
                
                  RESULT
                  
                    The program executed successfully and displayed the count of vowels, consonants, uppercase
                    characters, and lowercase characters from the text file.
                  
                

                {/* KEY POINTS */}
                
                  KEY POINTS
                  
                    
                      isalpha(): Checks if a character is alphabetic (a-z, A-Z)
                    
                    
                      isupper(): Checks if a character is uppercase
                    
                    
                      islower(): Checks if a character is lowercase
                    
                    
                      Vowels: a, e, i, o, u (both uppercase and lowercase)
                    
                    
                      Consonants: All alphabetic characters except vowels
                    
                  
                

                {/* PROGRAM VARIATIONS */}
                
                  PROGRAM VARIATIONS

                  
                    Method 1: Using 'with' statement (Recommended)
                  
                  
                                          
                        {`# Using 'with' statement for better file handling
with open("sample.txt", "r") as file:
    content = file.read()
    
    vowels = consonants = uppercase = lowercase = 0
    vowel_list = "aeiouAEIOU"
    
    for char in content:
        if char.isalpha():
            if char.isupper():
                uppercase += 1
            if char.islower():
                lowercase += 1
            
            if char in vowel_list:
                vowels += 1
            else:
                consonants += 1
    
    print(f"Vowels: {vowels}")
    print(f"Consonants: {consonants}")
    print(f"Uppercase: {uppercase}")
    print(f"Lowercase: {lowercase}")
# File is automatically closed`}
                      
                    
                  

                  
                    Method 2: Using functions for better organization
                  
                  
                                          
                        {`def analyze_file(filename):
    vowels = consonants = uppercase = lowercase = 0
    vowel_list = "aeiouAEIOU"
    
    try:
        with open(filename, "r") as file:
            content = file.read()
            
            for char in content:
                if char.isalpha():
                    if char.isupper():
                        uppercase += 1
                    if char.islower():
                        lowercase += 1
                    
                    if char in vowel_list:
                        vowels += 1
                    else:
                        consonants += 1
        
        return vowels, consonants, uppercase, lowercase
    
    except FileNotFoundError:
        print("File not found!")
        return 0, 0, 0, 0

# Call the function
v, c, u, l = analyze_file("sample.txt")
print(f"Vowels: {v}, Consonants: {c}")
print(f"Uppercase: {u}, Lowercase: {l}")`}
                      
                    
                  
                

                {/* COMMON ERRORS */}
                
                  COMMON ERRORS & SOLUTIONS
                  
                    
                      FileNotFoundError
                      
                        Make sure the file "sample.txt" exists in the same directory as your Python script.
                      
                    
                    
                      Incorrect vowel counting
                      
                        Remember to include both uppercase and lowercase vowels in your vowel list.
                      
                    
                    
                      Counting non-alphabetic characters
                      
                        Always check if a character is alphabetic using isalpha() before counting.
                      
                    
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What does isalpha() function do?
                      
                        The isalpha() function returns True if all characters in the string are alphabetic (a-z, A-Z)
                        and there is at least one character.
                      
                    
                    
                      How do you check if a character is a vowel?
                      
                        You can check if a character is in the vowel list "aeiouAEIOU" using the 'in' operator.
                      
                    
                    
                      What's the difference between isupper() and islower()?
                      
                        isupper() returns True if the character is uppercase, while islower() returns True if the
                        character is lowercase.
                      
                    
                    
                      Why do we use read() method?
                      
                        The read() method reads the entire content of the file as a single string, making it easy to
                        iterate through each character.
                      
                    
                    
                      How can you handle file not found error?
                      
                        You can use try-except block to catch FileNotFoundError and handle it gracefully.
                      
                    
                  
                

                
                  
                    Back to Class 12 Programs
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/vowels-consonants-uppercase-lowercase/related.tsx" isMerged="true"
import Link from "next/link"
import { ExternalLink, FileText, BookOpen } from "lucide-react"

export default function Related() {
  return (
    
      {/* Related Programs */}
      
        Related Programs
        
          
            
            Number Comparison
          
          
            
            Series Sum
          
          
            
            GCD & LCM
          
        
      

      {/* Study Resources */}
      
        Study Resources
        
          
            
            Python Fundamentals
          
          
            
            Flow of Control
          
        
      

      {/* Quick Links */}
      
        Quick Links
        
          
            
            Class 11 MCQs
          
          
            
            Class 11 Theory
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/class-12/vowels-consonants-uppercase-lowercase/toc.tsx" isMerged="true"
import Link from "next/link"

export default function TOC() {
  const programs = [
    { id: 1, title: "Input a welcome message and display it", slug: "welcome-message" },
    { id: 2, title: "Input two numbers and display the larger/smaller number", slug: "number-comparison" },
    { id: 3, title: "Enter two integers and perform all arithmetic operations", slug: "arithmetic-operations" },
    { id: 4, title: "Generate patterns using nested loop", slug: "pattern-generation" },
    { id: 5, title: "Input x and n, print sum of series", slug: "series-sum" },
    { id: 6, title: "Check perfect number, Armstrong number or palindrome", slug: "number-checks" },
    { id: 7, title: "Check if number is prime or composite", slug: "prime-composite" },
    { id: 8, title: "Display Fibonacci series terms", slug: "fibonacci-series" },
    { id: 9, title: "Compute GCD and LCM of two integers", slug: "gcd-lcm" },
    { id: 10, title: "Count vowels, consonants, uppercase, lowercase in string", slug: "string-analysis" },
    { id: 11, title: "Check palindrome string and convert case", slug: "string-palindrome" },
    { id: 12, title: "Find largest/smallest number in list/tuple", slug: "list-min-max" },
    { id: 13, title: "Swap elements at even and odd locations", slug: "list-swap" },
    { id: 14, title: "Search element in list/tuple", slug: "list-search" },
    { id: 15, title: "Find smallest and largest number from list", slug: "list-extremes" },
    { id: 16, title: "Dictionary with student marks above 75", slug: "student-marks" },
    { id: 17, title: "Menu-driven student dictionary program", slug: "student-menu" },
    { id: 18, title: "Choose 4 random lucky winners from 100 customers", slug: "lucky-winners" },
    { id: 19, title: "String module operations menu", slug: "string-module" },
    { id: 20, title: "Friends phone directory dictionary operations", slug: "phone-directory" },
  ]

  return (
    
      Class 12 Programs
      
        {programs.map((program) => (
          
            
              {program.id}.
              {program.title}
            
          
        ))}
      

      
        Quick Tips
        
          • Use isalpha() to check alphabetic characters
          • Remember both upper and lower case vowels
          • Handle file exceptions properly
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/computer-science/practical/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight } from "lucide-react"

export default function ComputerSciencePracticalPage() {
  // Sample practical programs for Class 11
  const class11Programs = [
    { id: 1, title: "Input a welcome message and display it", slug: "welcome-message" },
    { id: 2, title: "Input two numbers and display the larger/smaller number", slug: "number-comparison" },
    { id: 3, title: "Input three numbers and display the largest / smallest number", slug: "three-number-comparison" },    
    { id: 4, title: "Enter two integers and perform all arithmetic operations", slug: "arithmetic-operations" },
    { id: 5, title: "Generate patterns using nested loop", slug: "pattern-generation" },
    { id: 6, title: "Input x and n, print sum of series", slug: "series-sum" },
    { id: 7, title: "Check perfect number, Armstrong number or palindrome", slug: "number-checks" },
    { id: 8, title: "Check if number is prime or composite", slug: "prime-composite" },
    { id: 9, title: "Display Fibonacci series terms", slug: "fibonacci-series" },
    { id: 10, title: "Compute GCD and LCM of two integers", slug: "gcd-lcm" },
    { id: 11, title: "Count vowels, consonants, uppercase, lowercase in string", slug: "string-analysis" },
    { id: 12, title: "Check palindrome string and convert case", slug: "string-palindrome" },
    { id: 13, title: "Find largest/smallest number in list/tuple", slug: "list-min-max" },
    { id: 14, title: "Swap elements at even and odd locations", slug: "list-swap" },
    { id: 15, title: "Search element in list/tuple", slug: "list-search" },
    { id: 16, title: "Find smallest and largest number from list", slug: "list-extremes" },
    { id: 17, title: "Dictionary with student marks above 75", slug: "student-marks" },
    { id: 18, title: "Menu-driven student dictionary program", slug: "student-menu" },
    { id: 19, title: "Choose 4 random lucky winners from 100 customers", slug: "lucky-winners" },
    { id: 20, title: "String module operations menu", slug: "string-module" },
    { id: 21, title: "Friends phone directory dictionary operations", slug: "phone-directory" },
  
  ]

  // Sample practical programs for Class 12
  const class12Programs = [
    { id: 1, title: "Read text file line by line with # separator", slug: "text-file-line-by-line" },
    {id: 2,title: "Count vowels, consonants, uppercase, lowercase in file",slug: "vowels-consonants-uppercase-lowercase"},
    { id: 3, title: "Remove lines containing character 'a'", slug: "remove-lines-with-character" },
    { id: 4, title: "Binary file with name and roll number search", slug: "binary-file-search" },
    { id: 5, title: "Binary file update marks by roll number", slug: "binary-file-update" },
    { id: 6, title: "Random number generator (Dice Simulator)", slug: "dice-simulator" },
    { id: 7, title: "Stack implementation using list", slug: "stack-implementation" },
    { id: 8, title: "CSV file with user-id and password", slug: "csv-user-password" },
    { id: 9, title: "User Defined Functions to manipulate List Store Indices of Non Zero elements &Double the Odd values", slug: "non-zero-double-odd-values" },
    { id: 10, title: "WORKING WITH BINARY FILE IN PYTHON Create a binary file, Search and display the records from the binary file", slug:"Binary-file-search-display-records" },
    { id: 11, title: "TEXT FILES IN PYTHON Remove duplicate lines from the file & Display unique words present in the file", slug: "text-file-remove-duplicate" },
    { id: 12, title: "TEXT FILES IN PYTHON Copying lines to a new file & Replacing the '-' sign with a blankspace", slug: "copying-line-new-file" },
    { id: 13, title: "TEXT FILES IN PYTHON Count the lines starts with I/T & Display the lines with exactly 6 words", slug:"text-file-exactly" },
    { id: 14, title: "TEXT FILES IN PYTHON Count the occurrences of word & Count number of vowels and consonants", slug: "count-occurrences" },
    { id: 15, title: "User Defined Functions to Manipulate List Find the Longest Word and Shifting the elements to left", slug: "longest-word-shifting-left" },
    { id: 16, title: "IMPLEMENTATION OF STACK USING LIST IN PYTHON", slug: "stack-list" },
    { id: 17, title: "ALTER table to add new attributes / modify data type / drop attribute", slug: "alter-table" },
    { id: 18, title: "UPDATE table to modify data", slug: "update-table" },
    { id: 19, title: "ORDER By to display data in ascending / descending order", slug: "order-by" },
    { id: 20, title: "DELETE to remove tuple(s)", slug: "delete-tuple" },
    { id: 21, title: "GROUP BY and find the min, max, sum, count and average", slug: "group-by" },
    { id: 22, title: "INTERFACING PYTHON WITH MYSQL DATABASE CONNECTIVITY APPLICATION PROGRAM - DELETE RECORDS", slug: "delete-records" },
    { id: 23, title: "INTERFACING PYTHON WITH MYSQL DATABASE CONNECTIVITY APPLICATION PROGRAM - UPDATE RECORDS ", slug: "update-records" },
    { id: 24, title: "INTERFACING PYTHON WITH MYSQL DATABASE CONNECTIVITY APPLICATION PROGRAM - INSERT RECORDS", slug: "insert-records" },
  ]

  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Computer Science
            
            
            Practical Programs
          
        
      

      {/* Main Content */}
      
        Computer Science (083) Practical Programs

        
          This section contains practical programs for CBSE Computer Science (083) curriculum for Class 11 and Class 12.
          Each program includes the aim, algorithm, source code, conclusion, and output. These programs will help you
          prepare for your practical examinations.
        

        
          {/* Class 11 Programs */}
          
            
              Class 11 Practical Programs
            
            
              
                {class11Programs.map((program) => (
                  
                    
                      {program.title}
                      
                    
                  
                ))}
              
            
          

          {/* Class 12 Programs */}
          
            
              Class 12 Practical Programs
            
            
              
                {class12Programs.map((program) => (
                  
                    
                      {program.title}
                      
                    
                  
                ))}
              
            
          
        

        
          Important Note for Practical Examination
          
            Make sure to understand the logic behind each program
            Practice writing the programs from scratch without referring to notes
            Pay attention to proper indentation and code formatting
            Include appropriate comments to explain your code
            Test your programs with different inputs to ensure they work correctly
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/example-with-helper.tsx" isMerged="true"
"use client"

import { usePdfDownloadButton } from "@/lib/add-pdf-to-pages"

export default function ExamplePage() {
  // This will automatically add a PDF download button next to the first h1 element
  usePdfDownloadButton("Example Page Title", 39)

  return (
    
      
        Example Page Title

        
          This is an example page that demonstrates how to use the PDF download helper function.
          The helper function automatically adds a PDF download button next to the page title.
        
      
    
  )
}
[V0_FILE]css:file="app/globals.css" isMerged="true"
@tailwind base;
@tailwind components;
@tailwind utilities;

:root {
  --primary-color: #1f888f;
  --secondary-color: #b80877;
}

html {
  scroll-behavior: smooth;
}

body {
  min-height: 100vh;
}

/* Mobile menu styles */
@media (max-width: 768px) {
  .group:hover .group-hover\:block {
    display: none;
  }

  .group.active .group-hover\:block {
    display: block;
  }
}

/* Custom scrollbar */
::-webkit-scrollbar {
  width: 8px;
}

::-webkit-scrollbar-track {
  background: #f1f1f1;
}

::-webkit-scrollbar-thumb {
  background: var(--primary-color);
  border-radius: 4px;
}

::-webkit-scrollbar-thumb:hover {
  background: var(--secondary-color);
}

/* Gradient header */
.bg-gradient-header {
  background: linear-gradient(90deg, #1f888f 0%, #8a3a8a 50%, #b80877 100%);
}

@keyframes progress {
  0% {
    width: 0%;
  }
  100% {
    width: 100%;
  }
}

.animate-progress {
  animation: progress 2s ease-in-out;
}

/* Code block styling for better visibility */
pre {
  background-color: #1e1e1e !important;
  color: #e8e8e8 !important;
  padding: 16px !important;
  border-radius: 8px !important;
  overflow-x: auto !important;
  font-size: 13px !important;
  line-height: 1.5 !important;
  border: 1px solid #333 !important;
}

pre code {
  background-color: transparent !important;
  color: #e8e8e8 !important;
  font-family: 'Courier New', monospace !important;
}

/* Syntax highlighting for code elements */
code {
  background-color: #f5f5f5;
  color: #d63384;
  padding: 2px 6px;
  border-radius: 3px;
  font-family: 'Courier New', monospace;
}
[V0_FILE]typescriptreact:file="app/informatics-practices/class-11/computer-system/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function ComputerSystemPage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Informatics Practices
            
            
            
              Class 11
            
            
             Informatics Practices
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
               Informatics Practices

              
                
                  Flow of control refers to the order in which the statements in a program are executed. Python provides
                  various control structures that allow you to control the flow of your program based on conditions and
                  loops.
                

                1. Conditional Statements
                
                  Conditional statements allow you to execute certain blocks of code based on whether a condition is
                  true or false.
                

                1.1 if Statement
                
                  The if statement is used to execute a block of code only if a specified condition is true.
                
                
                                      # Simple if statement x = 10 if x {">"} 5: print("x is greater than 5")
                  
                

                1.2 if-else Statement
                
                  The if-else statement allows you to execute one block of code if the condition is true and another
                  block if it is false.
                
                
                                      
                      # if-else statement x = 3 if x {">"} 5: print("x is greater than 5") else: print("x is not greater
                      than 5")
                    
                  
                

                1.3 if-elif-else Statement
                
                  The if-elif-else statement allows you to check multiple conditions and execute different blocks of
                  code accordingly.
                
                
                                      
                      # if-elif-else statement marks = 75 if marks {">"} 90: grade = "A" elif marks {">"} 80: grade =
                      "B" elif marks {">"} 70: grade = "C" elif marks {">"} 60: grade = "D" else: grade = "F"
                      print(f"Grade: {"{grade}"}")
                    
                  
                

                1.4 Nested if Statements
                
                  You can also nest if statements inside other if statements to check for multiple conditions.
                
                
                                      
                      # Nested if statement x = 10 y = 5 if x {">"} 5: print("x is greater than 5") if y {"<"} 10:
                      print("y is less than 10")
                    
                  
                

                2. Looping Statements
                
                  Loops are used to execute a block of code repeatedly as long as a condition is true or for a specified
                  number of times.
                

                2.1 for Loop
                
                  The for loop is used to iterate over a sequence (like a list, tuple, string) or other iterable
                  objects.
                
                
                                      
                      # for loop with a list fruits = ["apple", "banana", "cherry"] for fruit in fruits: print(fruit) #
                      for loop with range for i in range(5): print(i) # Prints 0, 1, 2, 3, 4
                    
                  
                

                2.2 while Loop
                
                  The while loop executes a block of code as long as a specified condition is true.
                
                
                                      # while loop count = 0 while count {"<"} 5: print(count) count += 1 # Increment count
                  
                

                3. Loop Control Statements
                Python provides statements to control the flow of loops.

                3.1 break Statement
                The break statement is used to exit a loop prematurely.
                
                                      
                      # break statement for i in range(10): if i == 5: break # Exit the loop when i equals 5 print(i) #
                      Prints 0, 1, 2, 3, 4
                    
                  
                

                3.2 continue Statement
                
                  The continue statement is used to skip the current iteration of a loop and continue with the next
                  iteration.
                
                
                                      
                      # continue statement for i in range(10): if i == 5: continue # Skip iteration when i equals 5
                      print(i) # Prints 0, 1, 2, 3, 4, 6, 7, 8, 9
                    
                  
                

                3.3 pass Statement
                
                  The pass statement is a null operation; nothing happens when it executes. It is used as a placeholder.
                
                
                                      
                      # pass statement for i in range(5): if i == 3: pass # Do nothing when i equals 3 print(i) # Prints
                      0, 1, 2, 3, 4
                    
                  
                

                Practice Questions
                
                  Write a Python program to check if a number is positive, negative, or zero.
                  Write a Python program to find the largest among three numbers using nested if statements.
                  Write a Python program to print all even numbers between 1 and 20 using a for loop.
                  Write a Python program to calculate the factorial of a number using a while loop.
                  Write a Python program to print the Fibonacci sequence up to a given number using loops.
                

                
                  
                    Next Chapter: Functions
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/informatics-practices/class-11/computer-system/related.tsx" isMerged="true"
import Link from "next/link"

export default function ComputerSystemRelated() {
  const relatedResources = [
    { id: 1, title: "Conditional Statements Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" },
    { id: 2, title: "Loops in Python", type: "video", url: "https://youtube.com/@pythontyro4579" },
    { id: 3, title: "Flow Control Cheatsheet", type: "pdf", url: "/resources/flow-control-cheatsheet.pdf" },
    { id: 4, title: "Practice MCQs", type: "link", url: "/mcqs/computer-science/class-11/flow-of-control" },
  ]

  return (
    
      Related Resources
      
        {relatedResources.map((resource) => (
          
            
              {resource.type === "video" && (
                
              )}
              {resource.type === "pdf" && (
                
              )}
              {resource.type === "link" && (
                
              )}
              {resource.title}
              {resource.type === "pdf" && (
                
              )}
            
          
        ))}
      

      
        Need Help?
        
          Join our tuition classes for personalized guidance and doubt clearing.
        
        
          Register for Classes →
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/informatics-practices/class-11/computer-system/toc.tsx" isMerged="true"
import Link from "next/link"

export default function ComputerSystemTOC() {
  const chapters = [
    { id: 1, title: "Computer System", slug: "computer-system" },
    { id: 2, title: "Python Fundamentals", slug: "python-fundamentals" },
    { id: 3, title: "Flow of Control", slug: "flow-of-control" },
    { id: 4, title: "Functions", slug: "functions" },
    { id: 5, title: "Lists and Tuples", slug: "lists-and-tuples" },
    { id: 6, title: "Dictionaries and Sets", slug: "dictionaries-and-sets" },
    { id: 7, title: "String Manipulation", slug: "string-manipulation" },
    { id: 8, title: "File Handling", slug: "file-handling" },
    { id: 9, title: "Data Visualization", slug: "data-visualization" },
    { id: 10, title: "Computer Networks", slug: "computer-networks" },
  ]

  return (
    
      Chapters
      
        {chapters.map((chapter) => (
          
            
              {chapter.id}.
              {chapter.title}
            
          
        ))}
      
    
  )
}
[V0_FILE]typescriptreact:file="app/informatics-practices/practical/class-11/csv-import/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight } from "lucide-react"
import TOC from "./toc"
import Related from "./related"

export default function CSVImportPage() {
  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Informatics Practices
            
            
            
              Practical Programs
            
            
            
              Class 11
            
            
            CSV Import
          
        
      

      {/* Main Content */}
      
        
          {/* Left Sidebar - TOC */}
          
            
          

          {/* Middle Content */}
          
            
              Data Import from CSV Files

              
                {/* AIM */}
                
                  AIM
                  
                    To write a Python program that imports data from a CSV file using Pandas and performs basic
                    analysis.
                  
                

                {/* ALGORITHM */}
                
                  ALGORITHM
                  
                    Start
                    Import the necessary libraries (pandas)
                    Read the CSV file using pandas.read_csv() function
                    Display the first few rows of the DataFrame using head() method
                    Display information about the DataFrame using info() method
                    Display statistical summary of the DataFrame using describe() method
                    Perform basic data analysis on the DataFrame
                    Stop
                  
                

                {/* PROGRAM */}
                
                  PROGRAM
                  
                                          
                        {`# Python program to import data from a CSV file using Pandas

# Import the necessary libraries
import pandas as pd

# Read the CSV file
# Assuming we have a file named 'student_data.csv' with student information
df = pd.read_csv('student_data.csv')

# Display the first 5 rows of the DataFrame
print("First 5 rows of the DataFrame:")
print(df.head())

# Display information about the DataFrame
print("\nDataFrame Information:")
print(df.info())

# Display statistical summary of the DataFrame
print("\nStatistical Summary:")
print(df.describe())

# Basic data analysis
print("\nNumber of students:", len(df))

# Calculate the average marks
if 'Marks' in df.columns:
    print("Average Marks:", df['Marks'].mean())
    print("Highest Marks:", df['Marks'].max())
    print("Lowest Marks:", df['Marks'].min())

# Count the number of students by gender
if 'Gender' in df.columns:
    print("\nNumber of students by gender:")
    print(df['Gender'].value_counts())

# Group students by class and calculate average marks
if 'Class' in df.columns and 'Marks' in df.columns:
    print("\nAverage marks by class:")
    print(df.groupby('Class')['Marks'].mean())`}
                      
                    
                  
                

                {/* OUTPUT */}
                
                  OUTPUT
                  
                    First 5 rows of the DataFrame:
                                          {`   ID       Name  Age Gender  Class  Marks
0   1      Rahul   16      M     11     85
1   2      Priya   15      F     10     92
2   3      Amit    16      M     11     78
3   4      Neha    15      F     10     88
4   5  Rajesh K    17      M     12     95`}
                    
                     
                    DataFrame Information:
                                          {`
RangeIndex: 10 entries, 0 to 9
Data columns (total 6 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   ID      10 non-null     int64 
 1   Name    10 non-null     object
 2   Age     10 non-null     int64 
 3   Gender  10 non-null     object
 4   Class   10 non-null     int64 
 5   Marks   10 non-null     int64 
dtypes: int64(4), object(2)
memory usage: 608.0+ bytes
None`}
                    
                     
                    Statistical Summary:
                                          {`              ID        Age      Class      Marks
count  10.000000  10.000000  10.000000  10.000000
mean    5.500000  15.800000  11.000000  86.500000
std     3.027650   0.788811   0.816497   6.687823
min     1.000000  15.000000  10.000000  75.000000
25%     3.250000  15.000000  10.250000  82.250000
50%     5.500000  16.000000  11.000000  86.500000
75%     7.750000  16.000000  11.750000  91.500000
max    10.000000  17.000000  12.000000  95.000000`}
                    
                     
                    Number of students: 10
                    Average Marks: 86.5
                    Highest Marks: 95
                    Lowest Marks: 75
                     
                    Number of students by gender:
                                          {`M    6
F    4
Name: Gender, dtype: int64`}
                    
                     
                    Average marks by class:
                                          {`Class
10    87.75
11    82.33
12    93.00
Name: Marks, dtype: float64`}
                    
                  
                

                {/* CONCLUSION */}
                
                  CONCLUSION
                  
                    In this program, we learned how to import data from a CSV file using the Pandas library and perform
                    basic data analysis:
                  
                  
                    We used the pandas.read_csv() function to read data from a CSV file into a DataFrame
                    We displayed the first few rows of the DataFrame using the head() method
                    We obtained information about the DataFrame using the info() method
                    We generated a statistical summary of the numerical columns using the describe() method
                    We performed basic data analysis, including calculating averages and grouping data
                  
                  
                    This program demonstrates the power of Pandas for data manipulation and analysis. Pandas provides a
                    wide range of functions and methods to work with structured data, making it an essential tool for
                    data analysis in Python.
                  
                

                {/* VIVA QUESTIONS */}
                
                  VIVA QUESTIONS
                  
                    
                      What is Pandas and why is it used?
                      
                        Pandas is a Python library used for data manipulation and analysis. It provides data structures
                        like DataFrame and Series that make it easy to work with structured data.
                      
                    
                    
                      What is a DataFrame in Pandas?
                      
                        A DataFrame is a two-dimensional, size-mutable, and potentially heterogeneous tabular data
                        structure with labeled axes (rows and columns). It's similar to a spreadsheet or SQL table.
                      
                    
                    
                      How can you handle missing values in a DataFrame?
                      
                        Missing values can be handled using methods like dropna() to remove rows or columns with missing
                        values, or fillna() to fill missing values with a specific value or method (like mean, median,
                        etc.).
                      
                    
                    
                      What is the difference between loc and iloc in Pandas?
                      
                        loc is label-based indexing, which means you use the actual row and column labels to select
                        data. iloc is integer-based indexing, where you use integer positions to select data.
                      
                    
                    
                      How would you filter rows in a DataFrame based on a condition?
                      
                        You can filter rows using boolean indexing. For example, df[df['Marks'] > 80] would return
                        all rows where the 'Marks' column has values greater than 80.
                      
                    
                  
                

                
                  
                    Next Program: Data Filtering and Selection
                    
                  
                
              
            
          

          {/* Right Sidebar - Related Resources */}
          
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/informatics-practices/practical/class-11/csv-import/related.tsx" isMerged="true"
import Link from "next/link"

export default function Related() {
  const relatedResources = [
    { id: 1, title: "Pandas CSV Import Tutorial", type: "video", url: "https://youtube.com/@pythontyro4579" },
    { id: 2, title: "Working with DataFrames", type: "video", url: "https://youtube.com/@pythontyro4579" },
    { id: 3, title: "Pandas Cheatsheet", type: "pdf", url: "/resources/pandas-cheatsheet.pdf" },
    { id: 4, title: "Practice MCQs on Pandas", type: "link", url: "/mcqs/informatics-practices/class-11/pandas" },
  ]

  return (
    
      Related Resources
      
        {relatedResources.map((resource) => (
          
            
              {resource.type === "video" && (
                
              )}
              {resource.type === "pdf" && (
                
              )}
              {resource.type === "link" && (
                
              )}
              {resource.title}
              {resource.type === "pdf" && (
                
              )}
            
          
        ))}
      

      
        Need Help?
        
          Join our tuition classes for personalized guidance and doubt clearing.
        
        
          Register for Classes →
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/informatics-practices/practical/class-11/csv-import/toc.tsx" isMerged="true"
import Link from "next/link"

export default function TOC() {
  const programs = [
    { id: 1, title: "Series generation using Pandas", slug: "series-generation" },
    { id: 2, title: "DataFrame creation and operations", slug: "dataframe-operations" },
    { id: 3, title: "Data import from CSV files", slug: "csv-import" },
    { id: 4, title: "Data filtering and selection", slug: "data-filtering" },
    { id: 5, title: "Data aggregation with groupby", slug: "data-aggregation" },
    { id: 6, title: "Data visualization with Pandas", slug: "data-visualization" },
    { id: 7, title: "String operations in Pandas", slug: "string-operations" },
    { id: 8, title: "Date and time operations", slug: "datetime-operations" },
    { id: 9, title: "Data export to CSV and Excel", slug: "data-export" },
    { id: 10, title: "Basic statistical analysis", slug: "statistical-analysis" },
  ]

  return (
    
      Class 11 Programs
      
        {programs.map((program) => (
          
            
              {program.id}.
              {program.title}
            
          
        ))}
      
    
  )
}
[V0_FILE]typescriptreact:file="app/informatics-practices/practical/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight } from "lucide-react"

export default function InformaticsPracticesPracticalPage() {
  // Sample practical programs for Class 11
  const class11Programs = [
    { id: 1, title: "Series generation using Pandas", slug: "series-generation" },
    { id: 2, title: "DataFrame creation and operations", slug: "dataframe-operations" },
    { id: 3, title: "Data import from CSV files", slug: "csv-import" },
    { id: 4, title: "Data filtering and selection", slug: "data-filtering" },
    { id: 5, title: "Data aggregation with groupby", slug: "data-aggregation" },
    { id: 6, title: "Data visualization with Pandas", slug: "data-visualization" },
    { id: 7, title: "String operations in Pandas", slug: "string-operations" },
    { id: 8, title: "Date and time operations", slug: "datetime-operations" },
    { id: 9, title: "Data export to CSV and Excel", slug: "data-export" },
    { id: 10, title: "Basic statistical analysis", slug: "statistical-analysis" },
  ]

  // Sample practical programs for Class 12
  const class12Programs = [
    { id: 1, title: "MySQL database connection", slug: "mysql-connection" },
    { id: 2, title: "MySQL table creation and data insertion", slug: "mysql-create-insert" },
    { id: 3, title: "MySQL data retrieval and filtering", slug: "mysql-retrieval" },
    { id: 4, title: "MySQL data update and deletion", slug: "mysql-update-delete" },
    { id: 5, title: "MySQL joins and relationships", slug: "mysql-joins" },
    { id: 6, title: "MySQL integration with Pandas", slug: "mysql-pandas" },
    { id: 7, title: "Data visualization with Matplotlib", slug: "matplotlib-visualization" },
    { id: 8, title: "Data visualization with Seaborn", slug: "seaborn-visualization" },
    { id: 9, title: "Interactive dashboards with Plotly", slug: "plotly-dashboards" },
    { id: 10, title: "Data analysis project", slug: "data-analysis-project" },
  ]

  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              Informatics Practices
            
            
            Practical Programs
          
        
      

      {/* Main Content */}
      
        Informatics Practices (065) Practical Programs

        
          This section contains practical programs for CBSE Informatics Practices (065) curriculum for Class 11 and
          Class 12. Each program includes the aim, algorithm, source code, conclusion, and output. These programs will
          help you prepare for your practical examinations.
        

        
          {/* Class 11 Programs */}
          
            
              Class 11 Practical Programs
            
            
              
                {class11Programs.map((program) => (
                  
                    
                      {program.title}
                      
                    
                  
                ))}
              
            
          

          {/* Class 12 Programs */}
          
            
              Class 12 Practical Programs
            
            
              
                {class12Programs.map((program) => (
                  
                    
                      {program.title}
                      
                    
                  
                ))}
              
            
          
        

        
          Important Note for Practical Examination
          
            Make sure to understand the concepts of Pandas and data manipulation
            Practice working with real datasets to gain hands-on experience
            Learn to interpret the results of your data analysis
            Include appropriate comments to explain your code
            Test your programs with different datasets to ensure they work correctly
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/mcqs/computer-science/class-11/page.tsx" isMerged="true"
"use client"

import { useState, useEffect } from "react"
import Link from "next/link"
import { ChevronRight, CheckCircle, XCircle } from "lucide-react"

export default function ComputerScienceClass11MCQsPage() {
  // Sample chapters for TOC
  const chapters = [
    { id: 1, title: "Computer Overview", slug: "computer-overview" },
    { id: 2, title: "Python Fundamentals", slug: "python-fundamentals" },
    { id: 3, title: "Flow of Control", slug: "flow-of-control" },
    { id: 4, title: "Functions", slug: "functions" },
    { id: 5, title: "Lists and Tuples", slug: "lists-and-tuples" },
    { id: 6, title: "Dictionaries and Sets", slug: "dictionaries-and-sets" },
    { id: 7, title: "String Manipulation", slug: "string-manipulation" },
    { id: 8, title: "File Handling", slug: "file-handling" },
    { id: 9, title: "Data Visualization", slug: "data-visualization" },
    { id: 10, title: "Computer Networks", slug: "computer-networks" },
  ]

  // Sample MCQs for Python Fundamentals
  const pythonMcqs = [
    {
      id: 1,
      question: "Which of the following is not a valid data type in Python?",
      options: ["int", "float", "char", "bool"],
      correctAnswer: 2, // Index of the correct answer (0-based)
      explanation:
        "Python does not have a 'char' data type. Characters in Python are represented as strings of length 1.",
    },
    {
      id: 2,
      question: "What will be the output of the following code?\n\nx = 5\ny = 2\nprint(x // y)",
      options: ["2", "2.5", "2.0", "Error"],
      correctAnswer: 0,
      explanation:
        "The // operator performs floor division, which returns the largest integer less than or equal to the result of the division. 5 // 2 = 2.",
    },
    {
      id: 3,
      question: "Which of the following is used to take user input in Python?",
      options: ["get()", "input()", "scanf()", "read()"],
      correctAnswer: 1,
      explanation:
        "The input() function is used to take user input in Python. It reads a line from the input and returns it as a string.",
    },
    {
      id: 4,
      question: "What is the correct way to create a list in Python?",
      options: ["list = (1, 2, 3)", "list = [1, 2, 3]", "list = {1, 2, 3}", "list = <1, 2, 3>"],
      correctAnswer: 1,
      explanation:
        "In Python, lists are created using square brackets []. Parentheses () are used for tuples, and curly braces {} are used for dictionaries and sets.",
    },
    {
      id: 5,
      question: "Which of the following is the correct way to comment multiple lines in Python?",
      options: ["// This is a comment", "/* This is a comment */", "''' This is a comment '''", "# This is a comment"],
      correctAnswer: 2,
      explanation:
        "In Python, multi-line comments can be written using triple quotes (''' or \"\"\"). Single-line comments use the # symbol.",
    },
  ]

  // Sample MCQs for Computer Overview
  const computerOverviewMcqs = [
    {
      id: 1,
      question: "Which of the following is not a type of computer?",
      options: ["Mainframe", "Supercomputer", "Minicomputer", "Megacomputer"],
      correctAnswer: 3,
      explanation:
        "Megacomputer is not a standard type of computer. The main types are Supercomputers, Mainframes, Minicomputers, and Microcomputers.",
    },
    {
      id: 2,
      question: "What does CPU stand for?",
      options: [
        "Central Processing Unit",
        "Computer Processing Unit",
        "Central Program Unit",
        "Control Processing Unit",
      ],
      correctAnswer: 0,
      explanation:
        "CPU stands for Central Processing Unit. It is the primary component of a computer that performs most of the processing.",
    },
    {
      id: 3,
      question: "Which of the following is an input device?",
      options: ["Printer", "Monitor", "Speaker", "Scanner"],
      correctAnswer: 3,
      explanation:
        "A scanner is an input device that captures images from physical items and converts them into digital format.",
    },
  ]

  // State variables
  const [currentChapter, setCurrentChapter] = useState("python-fundamentals")
  const [mcqs, setMcqs] = useState(pythonMcqs)
  const [currentQuestion, setCurrentQuestion] = useState(0)
  const [selectedOption, setSelectedOption] = useState(null)
  const [showResult, setShowResult] = useState(false)
  const [score, setScore] = useState(0)
  const [answeredQuestions, setAnsweredQuestions] = useState([])

  // Change MCQs when chapter changes
  useEffect(() => {
    if (currentChapter === "python-fundamentals") {
      setMcqs(pythonMcqs)
    } else if (currentChapter === "computer-overview") {
      setMcqs(computerOverviewMcqs)
    } else {
      // Default to Python MCQs for other chapters
      setMcqs(pythonMcqs)
    }

    // Reset states when changing chapters
    setCurrentQuestion(0)
    setSelectedOption(null)
    setShowResult(false)
    setScore(0)
    setAnsweredQuestions([])
  }, [currentChapter])

  const handleChapterChange = (slug: string) => {
    setCurrentChapter(slug)
  }

  const handleOptionSelect = (optionIndex: number) => {
    if (answeredQuestions.includes(currentQuestion)) return
    setSelectedOption(optionIndex)
  }

  const handleCheckAnswer = () => {
    if (selectedOption === null) return

    if (!answeredQuestions.includes(currentQuestion)) {
      setAnsweredQuestions([...answeredQuestions, currentQuestion])

      if (selectedOption === mcqs[currentQuestion].correctAnswer) {
        setScore(score + 1)
      }
    }

    setShowResult(true)
  }

  const handleNextQuestion = () => {
    if (currentQuestion < mcqs.length - 1) {
      setCurrentQuestion(currentQuestion + 1)
      setSelectedOption(null)
      setShowResult(false)
    }
  }

  const handlePrevQuestion = () => {
    if (currentQuestion > 0) {
      setCurrentQuestion(currentQuestion - 1)
      setSelectedOption(null)
      setShowResult(false)
    }
  }

  const resetQuiz = () => {
    setCurrentQuestion(0)
    setSelectedOption(null)
    setShowResult(false)
    setScore(0)
    setAnsweredQuestions([])
  }

  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              MCQs
            
            
            
              Computer Science
            
            
            Class 11
          
        
      

      {/* Main Content */}
      
        Computer Science Class 11 MCQs

        
          {/* Left Sidebar - TOC (20%) */}
          
            
              Chapters
              
                {chapters.map((chapter) => (
                  
                    
                  
                ))}
              
            
          

          {/* Middle Content - MCQs (60%) */}
          
            {/* Score Display */}
            
              
                Score: 
                {score}
                 / {mcqs.length}
              
              
                Question: 
                {currentQuestion + 1}
                 / {mcqs.length}
              
              
            

            {/* Question Card */}
            
              
                {currentQuestion + 1}. {mcqs[currentQuestion].question}
              

              
                {mcqs[currentQuestion].options.map((option, index) => (
                   handleOptionSelect(index)}
                    className={`p-3 border rounded-md cursor-pointer transition-colors ${
                      selectedOption === index
                        ? "border-[#1f888f] bg-[#1f888f]/5"
                        : "border-gray-200 hover:border-gray-300"
                    } ${
                      showResult && index === mcqs[currentQuestion].correctAnswer ? "border-green-500 bg-green-50" : ""
                    } ${
                      showResult && selectedOption === index && index !== mcqs[currentQuestion].correctAnswer
                        ? "border-red-500 bg-red-50"
                        : ""
                    }`}
                  >
                    
                      
                        {selectedOption === index && }
                      
                      
                        {option}
                      
                      {showResult && index === mcqs[currentQuestion].correctAnswer && (
                        
                      )}
                      {showResult && selectedOption === index && index !== mcqs[currentQuestion].correctAnswer && (
                        
                      )}
                    
                  
                ))}
              

              {/* Explanation */}
              {showResult && (
                
                  Explanation:
                  {mcqs[currentQuestion].explanation}
                
              )}

              
                

                {!showResult ? (
                  
                ) : (
                  
                )}
              
            
          

          {/* Right Sidebar - Related Resources (20%) */}
          
            
              Related Resources
              
                
                  
                    
                    Python Notes
                  
                
                
                  
                    
                    Video Tutorials
                  
                
                
                  
                    
                    Python Cheatsheet
                    
                  
                
                
                  
                    
                    Practical Programs
                  
                
              

              
                Need Help?
                
                  Join our tuition classes for personalized guidance and doubt clearing.
                
                
                  Register for Classes →
                
              
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/mcqs/computer-science/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight } from "lucide-react"

export default function ComputerScienceMCQsPage() {
  const classes = [
    {
      id: 1,
      title: "Class 11",
      slug: "class-11",
      topics: [
        { id: 1, title: "Computer Overview", slug: "computer-overview" },
        { id: 2, title: "Python Fundamentals", slug: "python-fundamentals" },
        { id: 3, title: "Flow of Control", slug: "flow-of-control" },
        { id: 4, title: "Functions", slug: "functions" },
        { id: 5, title: "Lists and Tuples", slug: "lists-and-tuples" },
      ],
    },
    {
      id: 2,
      title: "Class 12",
      slug: "class-12",
      topics: [
        { id: 1, title: "Python Revision", slug: "python-revision" },
        { id: 2, title: "Functions", slug: "functions" },
        { id: 3, title: "File Handling", slug: "file-handling" },
        { id: 4, title: "SQL", slug: "sql" },
        { id: 5, title: "Database Connectivity", slug: "database-connectivity" },
      ],
    },
  ]

  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              MCQs
            
            
            Computer Science
          
        
      

      {/* Main Content */}
      
        
          Computer Science MCQs

          
            Practice with our comprehensive collection of Computer Science MCQs for CBSE Class 11 and Class 12. These
            questions are designed to help you prepare for exams and test your understanding of key programming
            concepts.
          

          
            {classes.map((cls) => (
              
                
                  {cls.title}
                
                
                  
                    {cls.topics.map((topic) => (
                      
                        
                          {topic.title} MCQs
                          
                        
                      
                    ))}
                  
                  
                    
                      View All {cls.title} MCQs
                      
                    
                  
                
              
            ))}
          

          
            MCQ Practice Tips

            
              
                
                  1
                
                
                  Regular Practice
                  
                    Set aside dedicated time each day to practice MCQs. Consistent practice helps reinforce concepts and
                    improves retention.
                  
                
              

              
                
                  2
                
                
                  Understand the Explanation
                  
                    Don't just memorize answers. Take time to understand the explanation for each question, especially
                    for the ones you got wrong.
                  
                
              

              
                
                  3
                
                
                  Track Your Progress
                  
                    Keep track of your scores and identify areas where you need improvement. Focus more on those topics.
                  
                
              
            

            
              
                Start Practicing
                
              
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/mcqs/informatics-practices/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight } from "lucide-react"

export default function InformaticsPracticesMCQsPage() {
  const classes = [
    {
      id: 1,
      title: "Class 11",
      slug: "class-11",
      topics: [
        { id: 1, title: "Computer System", slug: "computer-system" },
        { id: 2, title: "Python Fundamentals", slug: "python-fundamentals" },
        { id: 3, title: "Flow of Control", slug: "flow-of-control" },
        { id: 4, title: "Functions", slug: "functions" },
        { id: 5, title: "Lists and Tuples", slug: "lists-and-tuples" },
      ],
    },
    {
      id: 2,
      title: "Class 12",
      slug: "class-12",
      topics: [
        { id: 1, title: "Python Pandas", slug: "python-pandas" },
        { id: 2, title: "Functions", slug: "functions" },
        { id: 3, title: "File Handling", slug: "file-handling" },
        { id: 4, title: "SQL", slug: "sql" },
        { id: 5, title: "Database Connectivity", slug: "database-connectivity" },
      ],
    },
  ]

  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            
              MCQs
            
            
            Computer Science
          
        
      

      {/* Main Content */}
      
        
          Computer Science MCQs

          
            Practice with our comprehensive collection of Computer Science MCQs for CBSE Class 11 and Class 12. These
            questions are designed to help you prepare for exams and test your understanding of key programming
            concepts.
          

          
            {classes.map((cls) => (
              
                
                  {cls.title}
                
                
                  
                    {cls.topics.map((topic) => (
                      
                        
                          {topic.title} MCQs
                          
                        
                      
                    ))}
                  
                  
                    
                      View All {cls.title} MCQs
                      
                    
                  
                
              
            ))}
          

          
            MCQ Practice Tips

            
              
                
                  1
                
                
                  Regular Practice
                  
                    Set aside dedicated time each day to practice MCQs. Consistent practice helps reinforce concepts and
                    improves retention.
                  
                
              

              
                
                  2
                
                
                  Understand the Explanation
                  
                    Don't just memorize answers. Take time to understand the explanation for each question, especially
                    for the ones you got wrong.
                  
                
              

              
                
                  3
                
                
                  Track Your Progress
                  
                    Keep track of your scores and identify areas where you need improvement. Focus more on those topics.
                  
                
              
            

            
              
                Start Practicing
                
              
            
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/mcqs/page.tsx" isMerged="true"
import Link from "next/link"
import { ChevronRight } from "lucide-react"

export default function MCQsPage() {
  const subjects = [
    {
      id: 1,
      title: "Computer Science (083)",
      slug: "computer-science",
      classes: [
        { id: 1, title: "Class 11", slug: "class-11" },
        { id: 2, title: "Class 12", slug: "class-12" },
      ],
    },
    {
      id: 2,
      title: "Informatics Practices (065)",
      slug: "informatics-practices",
      classes: [
        { id: 1, title: "Class 11", slug: "class-11" },
        { id: 2, title: "Class 12", slug: "class-12" },
      ],
    },
    {
      id: 3,
      title: "Information Technology (402)",
      slug: "it",
      classes: [
        { id: 1, title: "Class 9", slug: "class-9" },
        { id: 2, title: "Class 10", slug: "class-10" },
      ],
    },
    {
      id: 4,
      title: "Artificial Intelligence (417)",
      slug: "ai",
      classes: [
        { id: 1, title: "Class 9", slug: "class-9" },
        { id: 2, title: "Class 10", slug: "class-10" },
      ],
    },
  ]

  return (
    
      {/* Breadcrumb */}
      
        
          
            
              Home
            
            
            MCQs
          
        
      

      {/* Main Content */}
      
        
          Multiple Choice Questions

          
            Practice with our comprehensive collection of Multiple Choice Questions (MCQs) for all CBSE computer
            subjects. These questions are designed to help you prepare for exams and test your understanding of key
            concepts.
          

          
            {subjects.map((subject) => (
              
                
                  {subject.title}
                
                
                  
                    {subject.classes.map((cls) => (
                      
                        
                          {cls.title} MCQs
                          
                        
                      
                    ))}
                  
                
              
            ))}
          

          
            How to Use MCQs Effectively
            
              Attempt all questions without looking at the answers first
              Review your answers and understand why certain options are correct or incorrect
              Revisit questions you answered incorrectly after studying the related concepts
              Use the MCQs as a diagnostic tool to identify areas that need more focus
            
          

          
            Sample MCQ

            
              Which of the following is not a valid data type in Python?
              
                
                  
                  int
                
                
                  
                  float
                
                
                  
                  char
                
                
                  
                  bool
                
                
              
            

            
              
                Start Practicing
                
              
            
          
        
      
    
  )
}
[V0_FILE]json:file="components.json" isMerged="true"
{
  "$schema": "https://ui.shadcn.com/schema.json",
  "style": "default",
  "rsc": true,
  "tsx": true,
  "tailwind": {
    "config": "tailwind.config.ts",
    "css": "app/globals.css",
    "baseColor": "neutral",
    "cssVariables": true,
    "prefix": ""
  },
  "aliases": {
    "components": "@/components",
    "utils": "@/lib/utils",
    "ui": "@/components/ui",
    "lib": "@/lib",
    "hooks": "@/hooks"
  },
  "iconLibrary": "lucide"
}
[V0_FILE]typescriptreact:file="components/theme-provider.tsx" isMerged="true"
'use client'

import * as React from 'react'
import {
  ThemeProvider as NextThemesProvider,
  type ThemeProviderProps,
} from 'next-themes'

export function ThemeProvider({ children, ...props }: ThemeProviderProps) {
  return {children}
}
[V0_FILE]typescriptreact:file="components/ui/accordion.tsx" isMerged="true"
"use client"

import * as React from "react"
import * as AccordionPrimitive from "@radix-ui/react-accordion"
import { ChevronDown } from "lucide-react"

import { cn } from "@/lib/utils"

const Accordion = AccordionPrimitive.Root

const AccordionItem = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, ...props }, ref) => (
  
))
AccordionItem.displayName = "AccordionItem"

const AccordionTrigger = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, children, ...props }, ref) => (
  
    svg]:rotate-180",
        className
      )}
      {...props}
    >
      {children}
      
    
  
))
AccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName

const AccordionContent = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, children, ...props }, ref) => (
  
    {children}
  
))

AccordionContent.displayName = AccordionPrimitive.Content.displayName

export { Accordion, AccordionItem, AccordionTrigger, AccordionContent }
[V0_FILE]typescriptreact:file="components/ui/alert-dialog.tsx" isMerged="true"
"use client"

import * as React from "react"
import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog"

import { cn } from "@/lib/utils"
import { buttonVariants } from "@/components/ui/button"

const AlertDialog = AlertDialogPrimitive.Root

const AlertDialogTrigger = AlertDialogPrimitive.Trigger

const AlertDialogPortal = AlertDialogPrimitive.Portal

const AlertDialogOverlay = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, ...props }, ref) => (
  
))
AlertDialogOverlay.displayName = AlertDialogPrimitive.Overlay.displayName

const AlertDialogContent = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, ...props }, ref) => (
  
    
    
  
))
AlertDialogContent.displayName = AlertDialogPrimitive.Content.displayName

const AlertDialogHeader = ({
  className,
  ...props
}: React.HTMLAttributes) => (
  
)
AlertDialogHeader.displayName = "AlertDialogHeader"

const AlertDialogFooter = ({
  className,
  ...props
}: React.HTMLAttributes) => (
  
)
AlertDialogFooter.displayName = "AlertDialogFooter"

const AlertDialogTitle = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, ...props }, ref) => (
  
))
AlertDialogTitle.displayName = AlertDialogPrimitive.Title.displayName

const AlertDialogDescription = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, ...props }, ref) => (
  
))
AlertDialogDescription.displayName =
  AlertDialogPrimitive.Description.displayName

const AlertDialogAction = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, ...props }, ref) => (
  
))
AlertDialogAction.displayName = AlertDialogPrimitive.Action.displayName

const AlertDialogCancel = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, ...props }, ref) => (
  
))
AlertDialogCancel.displayName = AlertDialogPrimitive.Cancel.displayName

export {
  AlertDialog,
  AlertDialogPortal,
  AlertDialogOverlay,
  AlertDialogTrigger,
  AlertDialogContent,
  AlertDialogHeader,
  AlertDialogFooter,
  AlertDialogTitle,
  AlertDialogDescription,
  AlertDialogAction,
  AlertDialogCancel,
}
[V0_FILE]typescriptreact:file="components/ui/alert.tsx" isMerged="true"
import * as React from "react"
import { cva, type VariantProps } from "class-variance-authority"

import { cn } from "@/lib/utils"

const alertVariants = cva(
  "relative w-full rounded-lg border p-4 [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground",
  {
    variants: {
      variant: {
        default: "bg-background text-foreground",
        destructive:
          "border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive",
      },
    },
    defaultVariants: {
      variant: "default",
    },
  }
)

const Alert = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes & VariantProps
>(({ className, variant, ...props }, ref) => (
  
))
Alert.displayName = "Alert"

const AlertTitle = React.forwardRef<
  HTMLParagraphElement,
  React.HTMLAttributes
>(({ className, ...props }, ref) => (
  
))
AlertTitle.displayName = "AlertTitle"

const AlertDescription = React.forwardRef<
  HTMLParagraphElement,
  React.HTMLAttributes
>(({ className, ...props }, ref) => (
  
))
AlertDescription.displayName = "AlertDescription"

export { Alert, AlertTitle, AlertDescription }
[V0_FILE]typescriptreact:file="components/ui/aspect-ratio.tsx" isMerged="true"
"use client"

import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio"

const AspectRatio = AspectRatioPrimitive.Root

export { AspectRatio }
[V0_FILE]typescriptreact:file="components/ui/avatar.tsx" isMerged="true"
"use client"

import * as React from "react"
import * as AvatarPrimitive from "@radix-ui/react-avatar"

import { cn } from "@/lib/utils"

const Avatar = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, ...props }, ref) => (
  
))
Avatar.displayName = AvatarPrimitive.Root.displayName

const AvatarImage = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, ...props }, ref) => (
  
))
AvatarImage.displayName = AvatarPrimitive.Image.displayName

const AvatarFallback = React.forwardRef<
  React.ElementRef,
  React.ComponentPropsWithoutRef
>(({ className, ...props }, ref) => (
  
))
AvatarFallback.displayName = AvatarPrimitive.Fallback.displayName

export { Avatar, AvatarImage, AvatarFallback }
[V0_FILE]typescriptreact:file="components/ui/badge.tsx" isMerged="true"
import * as React from "react"
import { cva, type VariantProps } from "class-variance-authority"

import { cn } from "@/lib/utils"

const badgeVariants = cva(
  "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
  {
    variants: {
      variant: {
        default:
          "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
        secondary:
          "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
        destructive:
          "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
        outline: "text-foreground",
      },
    },
    defaultVariants: {
      variant: "default",
    },
  }
)

export interface BadgeProps
  extends React.HTMLAttributes,
    VariantProps {}

function Badge({ className, variant, ...props }: BadgeProps) {
  return (
    
  )
}

export { Badge, badgeVariants }
[V0_FILE]typescriptreact:file="components/ui/breadcrumb.tsx" isMerged="true"
import * as React from "react"
import { Slot } from "@radix-ui/react-slot"
import { ChevronRight, MoreHorizontal } from "lucide-react"

import { cn } from "@/lib/utils"

const Breadcrumb = React.forwardRef<
  HTMLElement,
  React.ComponentPropsWithoutRef<"nav"> & {
    separator?: React.ReactNode
  }
>(({ ...props }, ref) => )
Breadcrumb.displayName = "Breadcrumb"

const BreadcrumbList = React.forwardRef<
  HTMLOListElement,
  React.ComponentPropsWithoutRef<"ol">
>(({ className, ...props }, ref) => (
  
))
BreadcrumbList.displayName = "BreadcrumbList"

const BreadcrumbItem = React.forwardRef<
  HTMLLIElement,
  React.ComponentPropsWithoutRef<"li">
>(({ className, ...props }, ref) => (
  
))
BreadcrumbItem.displayName = "BreadcrumbItem"

const BreadcrumbLink = React.forwardRef<
  HTMLAnchorElement,
  React.ComponentPropsWithoutRef<"a"> & {
    asChild?: boolean
  }
>(({ asChild, className, ...props }, ref) => {
  const Comp = asChild ? Slot : "a"

  return (
    
  )
})
BreadcrumbLink.displayName = "BreadcrumbLink"

const BreadcrumbPage = React.forwardRef<
  HTMLSpanElement,
  React.ComponentPropsWithoutRef<"span">
>(({ className, ...props }, ref) => (
  
))
BreadcrumbPage.displayName = "BreadcrumbPage"

const BreadcrumbSeparator = ({
  children,
  className,
  ...props
}: React.ComponentProps<"li">) => (
  
svg]:w-3.5 [&>svg]:h-3.5", className)}
    {...props}
  >
    {children ?? }
  
)
BreadcrumbSeparator.displayName = "BreadcrumbSeparator"

const BreadcrumbEllipsis = ({
  className,
  ...props
}: React.ComponentProps<"span">) => (
  
    
    More
  
)
BreadcrumbEllipsis.displayName = "BreadcrumbElipssis"

export {
  Breadcrumb,
  BreadcrumbList,
  BreadcrumbItem,
  BreadcrumbLink,
  BreadcrumbPage,
  BreadcrumbSeparator,
  BreadcrumbEllipsis,
}
[V0_FILE]typescriptreact:file="components/ui/button.tsx" isMerged="true"
import * as React from "react"
import { Slot } from "@radix-ui/react-slot"
import { cva, type VariantProps } from "class-variance-authority"

import { cn } from "@/lib/utils"

const buttonVariants = cva(
  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
  {
    variants: {
      variant: {
        default: "bg-primary text-primary-foreground hover:bg-primary/90",
        destructive:
          "bg-destructive text-destructive-foreground hover:bg-destructive/90",
        outline:
          "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
        secondary:
          "bg-secondary text-secondary-foreground hover:bg-secondary/80",
        ghost: "hover:bg-accent hover:text-accent-foreground",
        link: "text-primary underline-offset-4 hover:underline",
      },
      size: {
        default: "h-10 px-4 py-2",
        sm: "h-9 rounded-md px-3",
        lg: "h-11 rounded-md px-8",
        icon: "h-10 w-10",
      },
    },
    defaultVariants: {
      variant: "default",
      size: "default",
    },
  }
)

export interface ButtonProps
  extends React.ButtonHTMLAttributes,
    VariantProps {
  asChild?: boolean
}

const Button = React.forwardRef(
  ({ className, variant, size, asChild = false, ...props }, ref) => {
    const Comp = asChild ? Slot : "button"
    return (
      
    )
  }
)
Button.displayName = "Button"

export { Button, buttonVariants }
[V0_FILE]typescriptreact:file="components/ui/calendar.tsx" isMerged="true"
'use client'

import * as React from 'react'
import {
  ChevronDownIcon,
  ChevronLeftIcon,
  ChevronRightIcon,
} from 'lucide-react'
import { DayButton, DayPicker, getDefaultClassNames } from 'react-day-picker'

import { cn } from '@/lib/utils'
import { Button, buttonVariants } from '@/components/ui/button'

function Calendar({
  className,
  classNames,
  showOutsideDays = true,
  captionLayout = 'label',
  buttonVariant = 'ghost',
  formatters,
  components,
  ...props
}: React.ComponentProps & {
  buttonVariant?: React.ComponentProps['variant']
}) {
  const defaultClassNames = getDefaultClassNames()

  return (
    svg]:rotate-180`,
        String.raw`rtl:**:[.rdp-button\_previous>svg]:rotate-180`,
        className
      )}
      captionLayout={captionLayout}
      formatters={{
        formatMonthDropdown: date =>
          date.toLocaleString('default', { month: 'short' }),
        ...formatters,
      }}
      classNames={{
        root: cn('w-fit', defaultClassNames.root),
        months: cn(
          'flex gap-4 flex-col md:flex-row relative',
          defaultClassNames.months
        ),
        month: cn('flex flex-col w-full gap-4', defaultClassNames.month),
        nav: cn(
          'flex items-center gap-1 w-full absolute top-0 inset-x-0 justify-between',
          defaultClassNames.nav
        ),
        button_previous: cn(
          buttonVariants({ variant: buttonVariant }),
          'size-[--cell-size] aria-disabled:opacity-50 p-0 select-none',
          defaultClassNames.button_previous
        ),
        button_next: cn(
          buttonVariants({ variant: buttonVariant }),
          'size-[--cell-size] aria-disabled:opacity-50 p-0 select-none',
          defaultClassNames.button_next
        ),
        month_caption: cn(
          'flex items-center justify-center h-[--cell-size] w-full px-[--cell-size]',
          defaultClassNames.month_caption
        ),
        dropdowns: cn(
          'w-full flex items-center text-sm font-medium justify-center h-[--cell-size] gap-1.5',
          defaultClassNames.dropdowns
        ),
        dropdown_root: cn(
          'relative has-focus:border-ring border border-input shadow-xs has-focus:ring-ring/50 has-focus:ring-[3px] rounded-md',
          defaultClassNames.dropdown_root
        ),
        dropdown: cn(
          'absolute bg-popover inset-0 opacity-0',
          defaultClassNames.dropdown
        ),
        caption_label: cn(
          'select-none font-medium',
          captionLayout === 'label'
            ? 'text-sm'
            : 'rounded-md pl-2 pr-1 flex items-center gap-1 text-sm h-8 [&>svg]:text-muted-foreground [&>svg]:size-3.5',
          defaultClassNames.caption_label
        ),
        table: 'w-full border-collapse',
        weekdays: cn('flex', defaultClassNames.weekdays),
        weekday: cn(
          'text-muted-foreground rounded-md flex-1 font-normal text-[0.8rem] select-none',
          defaultClassNames.weekday
        ),
        week: cn('flex w-full mt-2', defaultClassNames.week),
        week_number_header: cn(
          'select-none w-[--cell-size]',
          defaultClassNames.week_number_header
        ),
        week_number: cn(
          'text-[0.8rem] select-none text-muted-foreground',
          defaultClassNames.week_number
        ),
        day: cn(
          'relative w-full h-full p-0 text-center [&:first-child[data-selected=true]_button]:rounded-l-md [&:last-child[data-selected=true]_button]:rounded-r-md group/day aspect-square select-none',
          defaultClassNames.day
        ),
        range_start: cn(
          'rounded-l-md bg-accent',
          defaultClassNames.range_start
        ),
        range_middle: cn('rounded-none', defaultClassNames.range_middle),
        range_end: cn('rounded-r-md bg-accent', defaultClassNames.range_end),
        today: cn(
          'bg-accent text-accent-foreground rounded-md data-[selected=true]:rounded-none',
          defaultClassNames.today
        ),
        outside: cn(
          'text-muted-foreground aria-selected:text-muted-foreground',
          defaultClassNames.outside
        ),
        disabled: cn(
          'text-muted-foreground opacity-50',
          defaultClassNames.disabled
        ),
        hidden: cn('invisible', defaultClassNames.hidden),
        ...classNames,
      }}
      components={{
        Root: ({ className, rootRef, ...props }) => {
          return (
            
          )
        },
        Chevron: ({ className, orientation, ...props }) => {
          if (orientation === 'left') {
            return (
              
            )
          }

          if (orientation === 'right') {
            return (
              
            )
          }

          return (
            
          )
        },
        DayButton: CalendarDayButton,
        WeekNumber: ({ children, ...props }) => {
          return (
            
              
                {children}
              
            
          )
        },
        ...components,
      }}
      {...props}
    />
  )
}

function CalendarDayButton({
  className,
  day,
  modifiers,
  ...props
}: React.ComponentProps) {
  const defaultClassNames = getDefaultClassNames()

  const ref = React.useRef(null)
  React.useEffect(() => {
    if (modifiers.focused) ref.current?.focus()
  }, [modifiers.focused])

  return (
    
  )
})
CarouselPrevious.displayName = "CarouselPrevious"

const CarouselNext = React.forwardRef<
  HTMLButtonElement,
  React.ComponentProps
>(({ className, variant = "outline", size = "icon", ...props }, ref) => {
  const { orientation, scrollNext, canScrollNext } = useCarousel()

  return (
    
  )
})
CarouselNext.displayName = "CarouselNext"

export {
  type CarouselApi,
  Carousel,
  CarouselContent,
  CarouselItem,
  CarouselPrevious,
  CarouselNext,
}
[V0_FILE]typescriptreact:file="components/ui/chart.tsx" isMerged="true"
"use client"

import * as React from "react"
import * as RechartsPrimitive from "recharts"

import { cn } from "@/lib/utils"

// Format: { THEME_NAME: CSS_SELECTOR }
const THEMES = { light: "", dark: ".dark" } as const

export type ChartConfig = {
  [k in string]: {
    label?: React.ReactNode
    icon?: React.ComponentType
  } & (
    | { color?: string; theme?: never }
    | { color?: never; theme: Record }
  )
}

type ChartContextProps = {
  config: ChartConfig
}

const ChartContext = React.createContext(null)

function useChart() {
  const context = React.useContext(ChartContext)

  if (!context) {
    throw new Error("useChart must be used within a ")
  }

  return context
}

const ChartContainer = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div"> & {
    config: ChartConfig
    children: React.ComponentProps<
      typeof RechartsPrimitive.ResponsiveContainer
    >["children"]
  }
>(({ id, className, children, config, ...props }, ref) => {
  const uniqueId = React.useId()
  const chartId = `chart-${id || uniqueId.replace(/:/g, "")}`

  return (
    
      
        
        
          {children}
        
      
    
  )
})
ChartContainer.displayName = "Chart"

const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
  const colorConfig = Object.entries(config).filter(
    ([_, config]) => config.theme || config.color
  )

  if (!colorConfig.length) {
    return null
  }

  return (

Constant	Description	Value
string.ascii_letters	All ASCII letters (lowercase + uppercase)	abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
string.digits	All decimal digits	0123456789
string.hexdigits	All hexadecimal digits	0123456789abcdefABCDEF
string.octdigits	All octal digits	01234567
string.punctuation	All punctuation characters	{"!\"#$%&'()*+,-./:;<=>?@[\\]^_`{\|}~"}