नमस्ते!
इस "लेख", या निबंध में, मैं लेटेक्स और अजगर की मूल बातें जानने का एक बहुत ही सरल तरीका दिखाऊंगा।

क्यों?
ठीक है, आप बच्चों को गिनने के लिए सरल भाव उत्पन्न कर सकते हैं। या ऐसे ही। हां, कम से कम वॉलपेपर पर रखो, अगर तुम उतने ही कट्टर हो, जितना मैं हूं।
यह कैसे काम करने वाला है?
विचार वास्तव में बहुत सरल है, बिल्कुल कोई भी ऐसा कार्यक्रम लिख सकता है। हम कुछ संख्या n (जो उपयोगकर्ता प्रवेश करता है) के बराबर एक अभिव्यक्ति उत्पन्न करना चाहते हैं। किसी भी संख्या को अंकगणितीय अभिव्यक्ति के साथ प्रतिस्थापित किया जा सकता है, उदाहरण के लिए, 3 = 1 + 2. और 2 4/2 है। इसी तरह हमने 3 = 1 + 4/2 उत्पन्न किया है। इसी तरह, हम कई अलग-अलग ऑपरेशन पेश करते हैं और इसे सूत्र भाषा में लाटेक्स में लपेटते हैं।
आप की आवश्यकता होगी ...अजगर और matplotlib में एक सप्ताह का अनुभव। मैं गंभीर हूं।
मुख्य तंत्र
हमें अभिव्यक्ति को पार्स करने की जरूरत है ताकि संख्या वहां से निकल सके। चलो हमारी कक्षा को समस्याओं का एक जनरेटर कहते हैं (हम सभी इसे बहुत याद करते हैं!)
import random from math import log import math import sys sys.setrecursionlimit(1000)
Extract_nums फ़ंक्शन का अर्थ संख्याओं (ए, बी) के एन जोड़े प्राप्त करना है, जहां ए पहले चरित्र की स्थिति है, बी अंतिम + 1 की स्थिति है।
उदाहरण के लिए, यदि हम निम्नलिखित कोड चलाते हैं:
gen = ProblemGenerator() print(gen.extract_nums("13+256/355+25"))
हम देखेंगे:
[(0, 2), (3, 6), (7, 10), (11, 13)]
यानी यह एक तुगलकी सरणी है। (0, 2) का अर्थ है कि 0 (सम्मिलित) और 2 (सम्मिलित नहीं) के बीच एक संख्या है।
अब हम अलग-अलग ऑपरेटर बनाना चाहते हैं, चलो गुणा और योग से शुरू करते हैं। तीन कार्यों की घोषणा करें
def unmin(*args, acc=2): r = [] for arg in args: f = round(arg, acc) if f > 0: f = str(f) else: f = "(" + str(f) + ")" r.append(f) return r def __c_sum(num): a = round(random.random() * 100, 3) b = num - a a, b = unmin(a, b) return a + " + " + b def __c_mul(num): a = num / (random.random() * 100 + 10) if a == 0.0: b = random.random() else: b = num / a a, b = unmin(a, b) return a + " * " + b
अनमिन फ़ंक्शन का सार केवल सभी तर्कों को स्ट्रिंग्स में बदलना नहीं है, बल्कि कुछ ऑपरेंड को ब्रैकेट करना भी है यदि यह शून्य से कम है। उदाहरण के लिए, हमें संख्या a = 3, b = -4 मिली। अगर हम लिखते हैं
a = 3 b = -4 a, b = unmin(a, b)
फिर एक = "3", बी = "(- 4)"
ठीक है, बाकी कार्य स्पष्ट हैं: __c_sum "13 + 4" फॉर्म का एक स्ट्रिंग लौटाता है, और __c_mul "13 * 4"।
यह इन दो टुकड़ों को जोड़ती है और प्रत्येक संख्या को अभिव्यक्ति के साथ अभिव्यक्ति में बदल देती है।
ProblemGenerator में निम्न कोड जोड़ें:
class ProblemGenerator: ... def __init__(self): self.funcs = [] def add_expander(self, func): self.funcs.append(func) def complexify(self, num): return random.choice(self.funcs)(num) def __rxp__(self, exp): x, y = random.choice(self.extract_nums(exp)) exp = exp[:x] + "(" + self.complexify(float(exp[x:y])) + ")" + exp[y:] return exp def randexpr(self, ans, steps): e = str(ans) for i in range(steps): e = self.__rxp__(e) return e
complexify कुछ संख्या लेता है, और एक स्ट्रिंग देता है - एक जटिल अभिव्यक्ति। उदाहरण के लिए, यदि हम लिखते हैं:
gen = ProblemGenerator() gen.add_expander(__c_sum) print(gen.complexify(13))
हमें मिलता है:
31.2 + (-18.2)
__Rxp__ कैसे काम करता है? हम किसी संख्या की स्थिति को एक अभिव्यक्ति से चुनते हैं (उदाहरण के लिए, यदि कोई अभिव्यक्ति "13 + 35/45" है, तो मान लें कि हमने चयन किया है (3, 5)) और इस संख्या को उस संख्या के बराबर अभिव्यक्ति के साथ बदलें। यही है, मैं यह करना चाहूंगा:
"13 + 35/45" - एक यादृच्छिक संख्या (3, 5)
"13+" + "(12 + 23)" + "/ 45"
"13+ (12 + 23) / 45"
इस तरह __rxp__ काम करता है
खैर, रैंडेक्सप्रिंट काफी सरलता से काम करता है। उदाहरण के लिए, यदि हमारे पास चार चरण हैं, तो अभिव्यक्ति इस तरह खुलेगी:
13 (5.62 + 7.38) ((20.63 + (-15.01)) + 7.38) ((20.63 + (-(67.5 + (-52.49)))) + 7.38) ((20.63 + (-((15.16 + 52.34) + (-52.49)))) + 7.38)
आइए चलाने की कोशिश करें:
gen = ProblemGenerator() gen.add_expander(__c_sum) gen.add_expander(__c_mul) exp = gen.randexpr(1, 5) print(exp)
परिणाम:
((6.63 + (56.62 + 16.8)) + (-((60.53 + 3.61) + 14.91)))
LaTeX
विचित्र रूप से पर्याप्त, सबसे सरल रहता है। हम कई अलग-अलग LaTeX ऑपरेटरों की घोषणा करेंगे:
def __l_sum(num): a = 100 ** (random.random() * 2) b = num - a a, b = unmin(a, b) return a + " + " + b def __l_div(num): a = num * (random.random() * 100 + 10) if a == 0.0: b = random.random() else: b = a / num a, b = unmin(a, b) return "\\frac{" + a + "}{" + b + "}" def __l_pow(num): if num == 0: return str(random.randint(2, 7)) + "^{-\\infty}" a = random.randint(0, 10) + 3 b = math.log(abs(num), a) a, b = unmin(a, b) return ("-" if num < 0 else "") + a + "^{" + b + "}" def __l_sqrt(num): a = num ** 0.5 a = unmin(a)[0] return "\\sqrt{" + a + "}" def __l_int(num): patterns = [ ("x^{2}", (3 * num) ** (1/3), "dx"), ("y^{3}", (4 * num) ** (1/4), "dy"), ("\sqrt{t}", (1.5 * num) ** (2/3), "dt") ] p, b, f = random.choice(patterns) b = str(round(b, 3)) return "\\int_{0}^{" + b + "} " + p + " " + f def __l_sig(num): a = random.randint(1, 10) b = random.randint(1, 10) + a s = sum([i for i in range(a, b + 1)]) c = num / s a, b, c = unmin(a, b, c) return "\\sum_{i=" + a + "}^{" + b + "} i*" + c
सभी कार्यों को जीन में जोड़ें:
gen = ProblemGenerator() gen.add_expander(__l_sum)
अंत में, परिणाम का आउटपुट जोड़ें:
import matplotlib.pyplot as plt plt.axis("off") latex_expression = gen.randexpr(1, 30)
वह सब है।
पूरा कोड import random from math import log import math import sys sys.setrecursionlimit(1000) class ProblemGenerator: def extract_nums(self, exp): symbols = list(exp) NUM = "1234567890." for i in range(len(symbols)): symbols[i] = "N" if symbols[i] in NUM else "T" begins = [] ends = [] for i in range(len(symbols) - 1): fn = symbols[i] + symbols[i + 1] if fn == "TN": begins.append(i) elif fn == "NT": ends.append(i) if exp[-1] in NUM: ends.append(len(exp) - 1) if exp[0] in NUM: begins = [-1] + begins return [(x + 1, y + 1) for x, y in zip(begins, ends)] def __init__(self): self.funcs = [] def add_expander(self, func): self.funcs.append(func) def complexify(self, num): return random.choice(self.funcs)(num) def __rxp__(self, exp): x, y = random.choice(self.extract_nums(exp)) exp = exp[:x] + "(" + self.complexify(float(exp[x:y])) + ")" + exp[y:] return exp def randexpr(self, ans, steps): e = str(ans) for i in range(steps): e = self.__rxp__(e) return e def unmin(*args, acc=2): r = [] for arg in args: f = round(arg, acc) if f > 0: f = str(f) else: f = "(" + str(f) + ")" r.append(f) return r def __c_sum(num): a = round(random.random() * 100, 3) b = num - a a, b = unmin(a, b) return a + " + " + b def __c_mul(num): a = num / (random.random() * 100 + 10) if a == 0.0: b = random.random() else: b = num / a a, b = unmin(a, b, acc=5) return a + " * " + b def __c_sub(num): a = num + 100 ** (random.random() * 2) b = (a - num) a, b = unmin(a, b) return a + " - " + b def __c_log(num): fr = random.randint(300, 500) a = math.e ** (num / fr) a, fr = unmin(a, fr, acc=5) return "log(" + a + ") * " + fr def __l_sum(num): a = 100 ** (random.random() * 2) b = num - a a, b = unmin(a, b) return a + " + " + b def __l_div(num): a = num * (random.random() * 100 + 10) if a == 0.0: b = random.random() else: b = a / num a, b = unmin(a, b) return "\\frac{" + a + "}{" + b + "}" def __l_pow(num): if num == 0: return str(random.randint(2, 7)) + "^{-\\infty}" a = random.randint(0, 10) + 3 b = math.log(abs(num), a) a, b = unmin(a, b) return ("-" if num < 0 else "") + a + "^{" + b + "}" def __l_sqrt(num): a = num ** 0.5 a = unmin(a)[0] return "\\sqrt{" + a + "}" def __l_int(num): patterns = [ ("x^{2}", (3 * num) ** (1/3), "dx"), ("y^{3}", (4 * num) ** (1/4), "dy"), ("\sqrt{t}", (1.5 * num) ** (2/3), "dt") ] p, b, f = random.choice(patterns) b = str(round(b, 3)) return "\\int_{0}^{" + b + "} " + p + " " + f def __l_sig(num): a = random.randint(1, 10) b = random.randint(1, 10) + a s = sum([i for i in range(a, b + 1)]) c = num / s a, b, c = unmin(a, b, c) return "\\sum_{i=" + a + "}^{" + b + "} i*" + c gen = ProblemGenerator() gen.add_expander(__l_sum) gen.add_expander(__l_div) gen.add_expander(__l_pow) gen.add_expander(__l_sqrt) gen.add_expander(__l_int) gen.add_expander(__l_sig) import matplotlib.pyplot as plt plt.axis("off") latex_expression = gen.randexpr(1, 30)