🉑 🔳 🌠 फ्रेशर्स के लिए असतत गणित: शिक्षक अनुभव 👩🏽‍🎤 🗂️ 👩🏻‍💼

आज मेरे पास एक असामान्य पाठ है जो मशीन लर्निंग के लिए पूरी तरह से असंबंधित है (नए पाठकों के लिए: यह पाठ सर्फिंगबर्ड कंपनी ब्लॉग का हिस्सा है , जिसमें पिछले एक साल में मैंने परिशिष्ट में विभिन्न मशीन सीखने के उपकरणों के बारे में सिफारिश प्रणालियों पर बात की थी)। इस पोस्ट में, व्यावहारिक रूप से कोई गणितीय भाग नहीं होगा, लेकिन एक बहुत ही सरल कार्यक्रम का वर्णन होगा जो मैंने अपने छात्रों के लिए लिखा था। यह संभावना नहीं है कि कोई व्यक्ति इस पोस्ट से बहुत कुछ नया सीखेगा, लेकिन यह मुझे लगता है कि यह विचार स्वयं कुछ मूल्य का है - बहुत से लोग इस तथ्य के बारे में नहीं सोचते हैं कि "यह संभव है"। इसलिए ...

समस्या का बयान

इस सेमेस्टर, मैंने कुछ हद तक असामान्य गतिविधि शुरू की: मैं हायर स्कूल ऑफ इकोनॉमिक्स के सेंट पीटर्सबर्ग शाखा में नए लोगों को असतत गणित सिखाता हूं; मैं लंबे समय से पढ़ा रहा हूं, लेकिन ऐसा लगता है कि मेरे पास चौथे-पांचवें वर्ष से पहले कभी भी छात्र नहीं थे। यहां आप पाठ्यक्रम का सारांश पा सकते हैं, और यहां तक कि अधूरा (पाठ्यक्रम अभी भी प्रगति पर है), लेकिन यह पूरी तरह से इसके बारे में नहीं है।

मुझे लगता है कि हैबर के अधिकांश निवासियों को कम से कम याद है कि "नए लोगों के लिए असतत गणित" क्या है: प्रपोजल लॉजिक, कंजंक्टिव और डिसिजिव सामान्य रूप, बूलियन फ़ंक्शंस के आधार, द्विआधारी संबंध, आंशिक आदेश ... सामान्य तौर पर, कुछ भी वैचारिक रूप से जटिल नहीं है, लेकिन यह सब चीजें हैं, लेकिन जिसे बहुत दृढ़ता से महारत हासिल होनी चाहिए, कोई भी गणितीय शिक्षा उन पर होती है, और उनके बारे में सचेत रूप से सोचने की आवश्यकता जल्दी से एक दुर्गम विलासिता बन जाएगी। इसलिए, आपको "इसमें अपना हाथ लाने के लिए व्यावहारिक उदाहरणों और कार्यों की बहुत आवश्यकता है।"

रिपोर्टिंग के रूपों में से एक के रूप में, मैंने "बड़ा होमवर्क" चुना: इनमें से कुछ व्यावहारिक उदाहरण जिन्हें संबोधित करने की आवश्यकता है। इस फॉर्म के कई फायदे हैं: छात्र अपनी गति से काम करते हैं, मैं यह भी जांच सकता हूं कि कितनी जरूरत है, सब कुछ लिखित रूप में होता है, जो हमेशा सुविधाजनक होता है। लेकिन इसके नुकसान भी हैं; मुख्य माइनस सरल है - पचास छात्रों के लिए पचास विकल्प बनाना और जांचना मुश्किल है (धारा पर उनमें से लगभग एक ही संख्या है)। और यदि आप एक बड़े समूह को एक विकल्प देते हैं, तो यह स्पष्ट है कि आउटपुट पर आपको सुंदर रूप से सही उत्तर मिलेंगे, विशेष रूप से यह देखते हुए कि ऐसे बुनियादी असतत गणित में अक्सर कोई "समाधान" नहीं होता है (एसडीएनएफ का निर्माण कैसे करें - अच्छी तरह से, सत्य तालिका देखें और लिखें ...)।

इस समस्या को हल करने के लिए, मैंने एक सरल प्रोग्राम लिखने का फैसला किया, जो प्रत्येक छात्र के लिए यादृच्छिक रूप से एक व्यक्तिगत होमवर्क उत्पन्न करेगा। यह विचार बेहद सरल है, लेकिन किसी कारण से मैं इसे कभी नहीं मिला जब मैं एक छात्र था या बाद के शिक्षण अनुभव में - यही कारण है कि मैं यह पोस्ट लिख रहा हूं। मैं एक न्यूनतम काम करने का उदाहरण दूंगा, और फिर दिखाऊंगा कि मुझे क्या मिला।

इनको .tex और बढ़ावा :: प्रारूप में टेम्पलेट्स

बुनियादी तकनीक स्पष्ट है - आपको एक लाटेकस-रिक्त बनाने की आवश्यकता है जिसमें प्रत्येक छात्र के लिए विशिष्ट कार्य सम्मिलित हों। इससे कोई फर्क नहीं पड़ता कि इसे किस भाषा में करना है, यह मेरे लिए छोटे सी ++ प्रोग्राम लिखने के लिए ऐतिहासिक रूप से अधिक परिचित है, इसलिए मैं इसका उपयोग यहां करूंगा। C ++ में ऐसा करने का सबसे आसान तरीका जो मुझे पता है कि बढ़ावा है :: प्रारूप : बस प्लेसहोल्डर्स के साथ रिक्त स्थान बनाएं जैसे% 1%,% 2%, और फिर आप वहां कुछ भी सम्मिलित कर सकते हैं (बढ़ावा :: प्रारूप में अन्य विकल्प हैं लेकिन हमें अब उनकी आवश्यकता नहीं है)।

तो, हम टेम्पलेट बनाते हैं। सबसे पहले, "अमूर्त LaTeX दस्तावेज़" के लिए सामान्य टेम्पलेट:

थोड़ा सा टेक्स

\documentclass[a4paper]{article} \usepackage[utf8]{inputenc} \usepackage{amsthm,amsmath,amsfonts, amssymb} \usepackage[english,russian]{babel} \usepackage{concrete} \usepackage{enumerate} \usepackage{euler} \usepackage{fullpage} \pagestyle{empty} \selectlanguage{russian} \begin{document} \selectlanguage{russian} %1% \end{document}

फिर कार्य का एक विशिष्ट टेम्पलेट - हम इसे% 1% के लिए स्थानापन्न करेंगे। यहां, जैसा कि वादा किया गया था, मैं एक न्यूनतम उदाहरण देता हूं। हम केवल एक समस्या उत्पन्न करेंगे: दिए गए बूलियन सूत्र के अनुसार, इसे कई अन्य रूपों में अनुवादित करें।

थोड़ा सा टेक्स

   \hfill %1%  $2013$ \hfill  %2% \section*{ } \begin{enumerate} \item     $$ \varphi = %3%: $$ \begin{enumerate}[(i)] \item   ; \item  $\varphi$        ; \item  $\varphi$    ; \item $[\ast]$  $\varphi$     $x\mid y = \lnot(x\land y)$. \end{enumerate} \pagebreak

और अब हमें केवल% 3% (% 1% और% 2% के बजाय, छात्र का नाम और समूह संख्या प्रतिस्थापित किया जाएगा) भरने के लिए कुछ उत्पन्न करने की आवश्यकता है। ऐसा करने के लिए, आपको फॉर्मूले बनाने के तरीके सीखने की ज़रूरत है। मैं तुरंत चेतावनी देता हूं कि मैं एक बुरा प्रोग्रामर हूं, और नीचे दिए गए कोड शायद स्पेगेटी से मिलते जुलते हैं - सिद्धांत रूप में, यह काम करता है, अगर कोई व्यक्ति सुंदर रीफैक्टरिंग की सलाह देता है, तो मैं आपको धन्यवाद कहूंगा।

पहले आपको एक संरचना बनाने की ज़रूरत है जो सूत्र में विभिन्न बंडलों और प्रकार के नोड्स को संग्रहीत करेगी; हमारे न्यूनतम उदाहरण के लिए, यह बहुत ही कम है, लेकिन मुझे सेट बीजगणित (यूनियनों, चौराहों और सममित अंतर) के सूत्रों के बारे में एक और काम करना था, और मैं सूत्र पेड़ों के बारे में कोड का पुन: उपयोग करना चाहता था। इसलिए, यहां एक वैश्विक वस्तु है जो बुनियादी जानकारी संग्रहीत करती है:

C ++ कोड

 class Globals { public: size_t TypesNo; size_t VarType; vector<string> TypesLatex; vector<size_t> TypesArity; boost::random::uniform_int_distribution<> RandomNodeType; boost::random::uniform_int_distribution<> RandomNodeNoVar; boost::random::uniform_int_distribution<> RandomNodeBinary; size_t VarsNo; vector<string> VarNames; boost::random::uniform_int_distribution<> RandomVarType; size_t current_varnum; Globals(size_t types_num, vector<string> types_latex, vector<size_t> types_arity, size_t var_num, vector<string> var_names) : TypesNo(types_num), VarType(types_num - 1), TypesLatex(types_latex), TypesArity(types_arity), RandomNodeType(0, types_num - 1), RandomNodeNoVar(0, types_num - 2), RandomNodeBinary(0, types_num - 3), VarsNo(var_num), VarNames(var_names), RandomVarType(0, var_num - 1), current_varnum(var_num - 1) {} size_t get_next_var() { current_varnum++; if (current_varnum == VarsNo) current_varnum = 0; return current_varnum; } }; Globals GBoolean(7, { "\\land", "\\lor", "\\rightarrow", "\\oplus", "\\equiv", "\\lnot", "\\var" }, { 2, 2, 2, 2, 2, 1, 0 }, 4, { "x", "y", "z", "t" });

यहाँ हमने "बूलियन फ़ार्मुलों की भाषा" बनाई, जिसमें पाँच बाइनरी संयोजक (संयोजन, अव्यवस्था, निहितार्थ, XOR और समतुल्यता) और एक एकात्मक (नकार) है। सातवाँ नोड प्रकार एक चर है, इसमें ० है। ० मेरे होमवर्क में, मैंने अपने आप को चार चर के सूत्रों तक सीमित किया: कम पर्याप्त नहीं है, लेकिन अधिक बोझिल होता जा रहा है। यह एक यादृच्छिक नोड प्रकार के जनरेटर, एक यादृच्छिक चर, एक यादृच्छिक बाइनरी लिंक लिखने के लिए भी सुविधाजनक है (मैंने वितरण से बटनों का उपयोग किया :: यादृच्छिक - फिर से, यह बहुत सुविधाजनक है; हालांकि वहाँ बहुत सारी चीजें लागू नहीं हुई हैं, हमें अब इसकी आवश्यकता नहीं है)।

सेट बीजगणित के सूत्रों के लिए इस तरह की संरचना का पुन: उपयोग करना आसान होगा (यह सिर्फ तुलना के लिए है, जीएसटी का उपयोग आगे नहीं किया जाएगा):

C ++ कोड

 Globals GSet(5, { "\\cap", "\\cup", "\\triangle", "\\overline", "\\var" }, { 2, 2, 2, 1, 0 }, 3, { "A", "B", "C" });

अब एक फॉर्मूला क्लास बनाएं। बुलियन फार्मूला एक पेड़ है जिसकी पत्तियां चर होती हैं, और तार्किक नोड आंतरिक कोने होते हैं। हम किसी दी गई गहराई के सूत्र उत्पन्न करने में सक्षम होना चाहते हैं, इसलिए हम कंस्ट्रक्टर को पास करेंगे कि क्या यह नोड को शीट बनाने का समय है या, इसके विपरीत, एक बाइनरी लिंक आवश्यक है। यदि आपको एक यादृच्छिक नोड बनाने की आवश्यकता है, तो हम टाइप करेंगे g-> TypesNo। यदि नोड एक पत्ती के रूप में निकला, तो इसे एक चर उत्पन्न करना होगा (ताकि उच्च संभावना के साथ सभी चर गिर जाएं, हम उन्हें केवल एक सर्कल में लेते हैं - सूत्र, बिल्कुल, पूरी तरह से यादृच्छिक नहीं हैं, लेकिन यह डरावना नहीं है)।

C ++ कोड

 class BNode { public: Globals *glob; size_t type; size_t varnum; BNode * left; BNode * right; BNode(Globals *g, size_t t, bool must_be_leaf = false, bool must_not_be_leaf = false, bool must_be_binary = false) : glob(g), type(t), left(NULL), right(NULL) { if (t == g->TypesNo) { // this means we want a random node type = must_be_leaf ? g->VarType : (must_be_binary ? g->RandomNodeBinary(gen) : (must_not_be_leaf ? g->RandomNodeNoVar(gen) : g->RandomNodeType(gen) )); } varnum = (type == g->VarType) ? g->get_next_var() : 0; } ~BNode() { if (left != NULL) delete left; if (right != NULL) delete right; } };

अब हम BNode वर्ग में भरना शुरू करते हैं। हमारे लिए मुख्य बात यह है कि सूत्र सफलतापूर्वक लाटेक्स में छपा है:

C ++ कोड

  string TypeString() const { if (type == glob->VarType) return glob->VarNames[varnum]; return glob->TypesLatex[type]; } string ToString() const { if (glob->TypesArity[type] == 0) return TypeString(); if (glob->TypesArity[type] == 1) return TypeString() + "{" + left->ToString() + "}"; return "(" + left->ToString() + " " + TypeString() + " " + right->ToString() + ")"; }

इसके अलावा, आपको चर के दिए गए सेट पर सूत्र के मूल्य की गणना करने में सक्षम होना चाहिए:

C ++ कोड

  bool get_truth_value(const vector<bool> & vals) { switch(type) { case 0: return left->get_truth_value(vals) && right->get_truth_value(vals); break; case 1: return left->get_truth_value(vals) || right->get_truth_value(vals); break; case 2: return (!left->get_truth_value(vals)) || right->get_truth_value(vals); break; case 3: return left->get_truth_value(vals) != right->get_truth_value(vals); break; case 4: return left->get_truth_value(vals) == right->get_truth_value(vals); break; case 5: return !left->get_truth_value(vals); break; case 6: return vals[varnum]; break; default: return false; break; } }

अब के लिए हम बोडोड क्लास छोड़ते हैं (हम इसे वापस कर देंगे); अब हम एक यादृच्छिक सूत्र जनरेटर लिख सकते हैं। हम किसी दिए गए न्यूनतम और अधिकतम गहराई के साथ एक सूत्र उत्पन्न करेंगे (न्यूनतम गहराई का समर्थन करने के लिए, हमने पहले कंस्ट्रक्टर को must_not_be_leaf फ़ील्ड जोड़ा):

C ++ कोड

 BNode *generate_tree(Globals & g, size_t min_depth, size_t max_depth, bool must_be_binary = false) { if (max_depth == 0) return NULL; BNode *node = new BNode(&g, g.TypesNo, max_depth == 1, min_depth > 0, must_be_binary); if (g.TypesArity[node->type] == 1) { node->left = generate_tree(g, min_depth, max_depth, true); } if (g.TypesArity[node->type] == 2) { node->left = generate_tree(g, min_depth - 1, max_depth - 1); node->right = generate_tree(g, min_depth - 1, max_depth - 1); } return node; }

यहां सब कुछ स्वयं स्पष्ट है; एकमात्र निर्णय जो मैंने यहाँ किया था, वह था एकरी फ़ंक्शंस (यानी नेगेटिव्स) "फ्री", गहराई के लिए नहीं, अन्यथा सूत्र बहुत सरल होंगे। इसके अलावा, बूलियन सूत्र में, एक पंक्ति में दो निगेटिव डालने पर रोक लगाना तर्कसंगत है, यह व्यर्थ है; ऐसा करने के लिए, हमें कंस्ट्रक्टर में must_be_binary ध्वज की आवश्यकता होगी।

और आप छात्रों की सूची के साथ एक फ़ाइल हैंडलर लिख सकते हैं:

C ++ कोड

 void process_one_student_file_boolean(string dir, string fname, boost::format & general_tmpl, boost::format & problem_tmpl, boost::format & solution_tmpl) { BNode *node_bool; ostringstream s; vector<string> students = readAllLinesFromFile(dir + "/" + fname + ".txt"); cout << "\t " << fname << endl; for (size_t i=0; i<students.size(); ++i) { if (students[i].size() == 0) continue; // empty line cout << "\t\t[ " << students[i] << " ]" << endl; node_bool = generate_tree(GBoolean, 2, 4); string group_string = "$" + fname + "$"; s << problem_tmpl % students[i] % group_string % node_bool->ToString(); delete node_bool; } ofstream ofs(dir + "/" + fname + ".tex"); ofs << general_tmpl % s.str() << endl; ofs.close(); }

और फिर मुख्य, जो फ़ाइलों को पढ़ता है और छात्र सूचियों के साथ फाइलों को प्रोसेस करता है:

C ++ कोड

 string students_dir = "2013"; vector<string> students_files = { "BoTR" }; int main(int argc, char *argv[]) { boost::format boolean_tpml( read_file_as_string("boolean_problem_minimal.tex") ); boost::format general_tmpl( read_file_as_string("general_template.tex") ); for (size_t i = 0; i < students_files.size(); ++i) { process_one_student_file_boolean(students_dir, students_files[i], general_tmpl, boolean_tpml); } return 0; }

लेकिन रुकिए, मुझे एक चौकस पाठक की आवाज सुनाई दे रही है। यह बकवास निकलेगा - मुझे लगता है, इतने सारे उत्पन्न यादृच्छिक सूत्रों का एक अच्छा आधा तुच्छ होगा! क्या सच है - मैं आधे के बारे में नहीं जानता, लेकिन यहां तक कि फ़ॉर्म \ varphi = x का एक भी यादृच्छिक रूप से उत्पन्न सूत्र हमारी पद्धति की प्रतिष्ठा को धूमिल कर देगा। आइए हम इसकी जाँच करना सीखते हैं। ऐसा करने के लिए, हम केवल यह गणना करते हैं कि सूत्र में कितने बंडल और विभिन्न चर पाए जाते हैं, और हमें आवश्यकता है कि सभी चर होते हैं, और बंडल कम से कम दो भिन्न होते हैं। बीएनओडी में एक सूत्र बायपास जोड़ें:

C ++ कोड

  void depth_first(function<void (const BNode * n)> do_with_node) { do_with_node(this); if (left != NULL) left->depth_first(do_with_node); if (right != NULL) right->depth_first(do_with_node); }

और तर्क के लिए सूत्र का सत्यापन दर्ज करें:

C ++ कोड

 bool sanity_check(BNode * node) { vector<bool> vars_present(node->glob->VarsNo, false); vector<bool> connectors_present(node->glob->TypesNo, false); node->depth_first([&] (const BNode * n) { if (n->type == n->glob->VarType) { vars_present[ n->varnum ] = true; } else { connectors_present[ n->type ] = true; } }); return all_of( vars_present.begin(), vars_present.end(), [](bool b) {return b;} ) && (accumulate(connectors_present.begin(), connectors_present.end(), 0) > 2); }

आप यह भी जांचना चाहते हैं कि क्या सूत्र है, कहते हैं, हमेशा सच होता है, लेकिन मैंने जानबूझकर ऐसा नहीं करने का फैसला किया है - अगर एक जटिल दिखने वाला सूत्र अचानक पहचान के लिए सच हो जाता है, तो यह कार्य छात्र के लिए जितना दिलचस्प होगा। और हमारे जनरेटर में "एक्स या नॉट एक्स" जैसे स्पष्ट उप-प्रकार काम नहीं करेंगे, क्योंकि चर बदले में हल होते हैं, और संयोग से नहीं।

छात्रों की एक सूची के साथ एक फ़ाइल पर परिणामी कार्यक्रम को लॉन्च करने से, हमें एक पर्याप्त रूप से स्वरूपित कार्यों के साथ एक .tex फ़ाइल मिलती है (यहां ऐसी फ़ाइल से संकलित एक पीडीएफ का एक उदाहरण है)।

समाधान

इस बिंदु पर एक संशयवादी पाठक यथोचित रूप से आपत्ति करेगा: ठीक है, बेशक, आप 9000 से अधिक विभिन्न कार्यों को उत्पन्न कर सकते हैं, लेकिन आपको बाद में जांचने के लिए यातना दी जाएगी! वास्तव में, प्रत्येक छात्र की सत्य तालिका की जांच करना बहुत मजबूत दिमाग वाले लोगों के लिए एक व्यवसाय है, जिनसे मैं संबंधित नहीं हूं। इसलिए, हमारे कार्यक्रम को संशोधित करने की आवश्यकता होगी ताकि यह सत्यापन प्रक्रिया को सुविधाजनक बना सके। इसे पूरी तरह से स्वचालित करना संभव नहीं होगा (छात्र अभी भी हाथों से नि: शुल्क प्रारूप में लिखे गए कार्यों में हाथ डालेंगे), इसलिए यह इस काम का सबसे बुरा हिस्सा अग्रिम रूप से करने के लिए पर्याप्त होगा।

हमें उत्तर के साथ दस्तावेज़ के लिए एक और LaTeX टेम्पलेट मिलता है:

LaTeX उत्तरदायी दस्तावेज़ टेम्पलेट

 {\footnotesize \subsection*{%1%,  %2%}     $%3%$: $$ %4% $$ } \pagebreak

मैं, फिर से, अपने आप को एक न्यूनतम उदाहरण तक सीमित करता हूं - चलो बस एक सत्य तालिका प्रदर्शित करते हैं। ऐसा करने के लिए, चर के सभी संभावित मूल्यों के माध्यम से जाएं, सूत्र के सत्य मूल्य की गणना करें और TeX में परिणाम को खूबसूरती से प्रारूपित करें। BNode वर्ग में दो विधियाँ जोड़ें:

C ++ कोड

  bool increment_counter(vector<bool> & v) { for (int i=v.size()-1; i>=0; --i) { if (!v[i]) { v[i] = true; for (size_t j=i+1; j<v.size(); ++j) v[j] = false; return true; } } return false; } string latex_truthtable() { ostringstream os; vector<bool> counter(glob->VarsNo, false); os << "\\begin{array}{"; for(size_t i=0; i<counter.size(); ++i) os << 'c'; os << "|c}\n"; for(size_t i=0; i<counter.size(); ++i) os << glob->VarNames[i] << " & "; os << " \\\\\\hline\n"; do { for(size_t i=0; i<counter.size(); ++i) os << counter[i] << " & "; os << get_truth_value(counter) << "\\\\\n"; } while (increment_counter(counter)); os << "\\end{array}\n"; return os.str(); }

और फिर इसे process_one_student_file_boolean में जोड़ें:

C ++ कोड

 void process_one_student_file_boolean(string dir, string fname, boost::format & general_tmpl, boost::format & problem_tmpl, boost::format & solution_tmpl) { BNode *node_bool; ostringstream s, ssolution; vector<string> students = readAllLinesFromFile(dir + "/" + fname + ".txt"); cout << "\t " << fname << endl; for (size_t i=0; i<students.size(); ++i) { if (students[i].size() == 0) continue; // empty line cout << "\t\t[ " << students[i] << " ]" << endl; do { node_bool = generate_tree(GBoolean, 2, 4); } while (!sanity_check(node_bool)); string group_string = "$" + fname + "$"; s << problem_tmpl % students[i] % group_string % node_bool->ToString(); ssolution << solution_tmpl % students[i] % group_string % node_bool->ToString() % node_bool->latex_truthtable(); delete node_bool; } ofstream ofs; open_for_writing(dir + "/" + fname + ".tex", ofs); ofs << general_tmpl % s.str() << endl; ofs.close(); open_for_writing(dir + "/" + fname + ".sol.tex", ofs); ofs << general_tmpl % ssolution.str() << endl; ofs.close(); } string students_dir = "2013"; vector<string> students_files = { "BoTR" }; int main(int argc, char *argv[]) { boost::format boolean_tpml( read_file_as_string("boolean_problem_minimal.tex") ); boost::format solution_tpml( read_file_as_string("boolean_solution_minimal.tex") ); boost::format general_tmpl( read_file_as_string("general_template.tex") ); for (size_t i = 0; i < students_files.size(); ++i) { process_one_student_file_boolean(students_dir, students_files[i], general_tmpl, boolean_tpml, solution_tpml); } return 0; }

परिणामस्वरूप, कार्य फ़ाइल ( उदाहरण ) के साथ जोड़ा जाता है, संबंधित निर्णय फ़ाइल प्राप्त की जाती है ( उसी उदाहरण, समाधान ), जिससे यह सत्यापित करना बहुत आसान हो जाता है।

निष्कर्ष

और यहां परिणाम है - काम का आधा दिन, और तैयार उत्तरों के साथ किसी भी संख्या में कार्यों के आउटपुट पर, सब कुछ खूबसूरती से डिज़ाइन किया गया है और छात्रों को वितरण के लिए तैयार है। यदि आप आश्चर्य करते हैं कि वास्तविक कार्य कैसे निकला, तो यहां अंतिम परिणाम का एक उदाहरण है । मैं उत्तर के साथ फाइल अपलोड नहीं करूंगा, ताकि छात्रों को एक बार फिर से संकेत न दें - वे अभी इस होमवर्क को हल कर रहे हैं। मुझे लगता है कि अगर एचएसई में मेरा शिक्षण जारी रहेगा, तो यह कार्यक्रम मुझे एक से अधिक बार सेवा प्रदान करेगा; इसे लागू करने का निकटतम मौका उसी समूहों में लिखित परीक्षा के लिए टिकट है।

PS जब मैं हेबर पर एक लेख तैयार कर रहा था, तो मुझे अपने सूत्र जनरेटर में एक छोटा बग मिला; लेकिन इसे ठीक नहीं किया। चौकस पाठक के लिए व्यायाम: क्या सूत्र, जिसमें सिद्धांत में कुछ भी बुरा नहीं है, क्या मेरा जनरेटर कभी भी उत्पन्न हो सकता है? (क्रम में वैरिएबल पर टिप्पणी के अलावा, जो मैंने पहले ही ऊपर किया था)

फ्रेशर्स के लिए असतत गणित: शिक्षक अनुभव

समस्या का बयान

इनको .tex और बढ़ावा :: प्रारूप में टेम्पलेट्स

समाधान

निष्कर्ष

More articles: