कंसोल में निर्माण कार्य। भाग 2 (अनुसूची)

शुरू कर दिया



पिछली बार मैं फ़ंक्शन मानों की तालिका बनाने पर बस गया था। समय निर्धारित करने के लिए आगे बढ़ने का समय आ गया है, जिसके लिए यह सब, वास्तव में, शुरू हुआ।

तो, मुख्य विचार इस प्रकार है। निर्देशांक अक्ष 90 डिग्री दक्षिणावर्त घुमाएँ। किसी भी शीट में प्रत्येक बिंदु के बारे में डेटा संग्रहीत किए बिना निर्माण को सरल बनाने के लिए यह आवश्यक है।

अगला, हम चार्ट के बेहतर पठनीयता के लिए खेल के समन्वय अक्ष को 82 वर्णों तक सीमित करते हैं। यह स्पष्ट है कि ऐसा करने में हम सटीकता खो देते हैं और अनुसूची अधिक योजनाबद्ध (बहुत तंग) होगी, विशेष रूप से "शांत" कार्यों के लिए, लेकिन फिर भी।

उसके बाद, हम खिलाड़ियों की धुरी के सापेक्ष एक्स अक्ष की स्थिति की गणना करते हैं, अर्थात्, हम इस बात की तलाश करते हैं कि हमारे पास किस स्थान पर बिंदु (x, 0) होगा। ठीक है, तो हम इस बिंदु पर फ़ंक्शन y1 के x-by-लाइन को असाइन करेंगे।

चलो चलते हैं

सबसे पहले, हमें निम्न सूत्र की आवश्यकता है:

$$

$$अनुपात = (अधिकतम (y1) - मिनट (y1)) / (80)$$

हम खुद को निर्धारित करने के लिए 80 पदों को सौंपेंगे, शेष दो स्थान पूरी तरह से सजावटी होंगे। इस सूत्र से हमें पता चलता है कि हमारे चार्ट में कौन सी श्रेणी किस मान से मेल खाती है। तब हम उस पर वर्तमान बिंदु को सही ढंग से चिह्नित कर सकते हैं।

मुख्य विचारों को रेखांकित किया गया है, इसलिए चलो कोड पर ही चलते हैं

dial_length = 12 label = "  y1 = x**3 - 2*x**2 + 4*x - 8" print("{1:>{0}}".format(len(label) + dial_length, label), '\n') print("{aux[1]:>{aux[0]}}\n {aux[2]:>{aux[0]}}>\n".format(aux = [dial_length + 82, 'y' , 82*'-'])); 

पहले भाग के लिए टिप्पणियों के लिए धन्यवाद सहित, मैंने प्रारूप जैसी चीज़ के बारे में सीखा। यह मेरे लिए एक तंबू के साथ मेरे नृत्य की तुलना में वास्तव में अधिक सुविधाजनक लग रहा था, इसलिए इंडेंट की गणना से कोड का एक बड़ा टुकड़ा कुछ पंक्तियों में बदल गया

 print("{1:>{0}}".format(len(label) + dial_length, label), '\n') 

इकाई प्रारूप फ़ंक्शन के तर्क के रूप में पारित तत्व की संख्या के लिए जिम्मेदार है, अर्थात, यह लेबल चर के लिए "लिंक" (शाब्दिक रूप से नहीं) है, जिसे हम वास्तव में स्क्रीन पर प्रदर्शित करते हैं। अंकन ठीक उसी तरह होता है जैसे कि चादरों में - खरोंच से।

वर्णों की एक जोड़ी :> का उपयोग दाईं ओर प्रदर्शित पाठ को संरेखित करने के लिए किया जाता है। ठीक है, {0} के बाद > वर्ण की आवश्यकता होती है ताकि आपके द्वारा आवश्यक पंक्ति पदों की संख्या निर्धारित की जा सके।

यही है, इस मामले में, हम लाइन लेबल लेन (लेबल) + डायल_लॉन्ग पोजीशन के लिए आरक्षित करते हैं, और लेबल स्वयं केवल लेन (लेबल) लेता है, और हम इन पदों के सेट के अंदर दाईं ओर पाठ संरेखित करते हैं।

 print("{1:>{0}}".format(len(label) + dial_length, label), '\n') print(dial_length*' ' + label, '\n') 

ये पंक्तियाँ समकक्ष हैं


हां, स्ट्रिंग्स के लिए, शायद दूसरे विकल्प का उपयोग करना आसान है, लेकिन सामान्य विकास के लिए पहले आवेदन करने से चोट नहीं पहुंचेगी)

 print("{aux[1]:>{aux[0]}}\n {aux[2]:>{aux[0]}}>\n".format(aux = [dial_length + 82, 'y' , 82*'-'])); 

यहां तक ​​कि r_value प्रकार (C ++ में) के सरणियों को प्रारूप में crammed किया जा सकता है, अर्थात, किसी तर्क को पास करते समय सीधे बनाया जाता है।

हम उन चर को ठीक करते हैं जो हमारे साथ स्थिर हैं, अर्थात, वे फ़ंक्शन के वर्तमान मूल्य पर निर्भर नहीं करते हैं।

अजगर में स्थिरांक को डिजाइन करने के लिए कोई शर्त नहीं है, इसलिए यह ऐसे अक्षरों को पूंजी अक्षरों में कॉल करने के लिए प्रथागत है और बस उन्हें नहीं बदलते हैं।

 MAX_Y1_VALUE_DIFFERENCE = (max_y1_value - min_y1_value) + \ (max_y1_value == min_y1_value) RATIO = MAX_Y1_VALUE_DIFFERENCE / 80 AXIS_X_POS = abs(int((- min_y1_value) / RATIO)) if (AXIS_X_POS > 80): AXIS_X_POS = 81 

चूंकि स्पष्ट कारणों के लिए RATIO 0 के बराबर नहीं हो सकता है, MAX_Y1_VALUE_DIFFERENCE एक सकारात्मक संख्या होनी चाहिए। यही कारण है कि दूसरा कार्यकाल असाइनमेंट के दाईं ओर है।

एक्स-अक्ष की स्थिति हम सूत्र द्वारा गणना करते हैं

$$

$$80 * (y1 (x) - मिनट (y1)) / (अधिकतम (y1) - मिनट (y1))$$

यह सूत्र कहाँ से आता है? हम केवल फ़ंक्शन (y1 (x)) के वर्तमान मूल्य और धुरी की शुरुआत से इसके अंत (अधिकतम (y1)) तक धुरी (मिनट (y1)) की शुरुआत से खंडों (खेल के अक्ष पर) के अनुपात की गणना करते हैं। खैर, हम अक्षों की शुरुआत से लेकर अंतरिक्ष में वर्तमान मूल्य (इसलिए, आप केवल पूर्णांकों का उपयोग कर सकते हैं) की दूरी को खोजने के लिए इस अनुपात को 80 से गुणा करते हैं, जो ग्राफ पर अनुपात-सूत्र को प्रतिबिंबित करेगा।

चूँकि हम y1 (x) = 0 पर स्थिति में रुचि रखते हैं, इसलिए हम आवश्यक मान और ध्वनि को सूत्र में प्रतिस्थापित करते हैं।

अब आप मुद्रण मूल्यों पर सीधे जा सकते हैं

 while (is_sequence_decreasing and from_x >= to_x) or \ (not is_sequence_decreasing and from_x <= to_x): y1_cur_value = y1(from_x) cur_y1_value_and_min_difference = (y1_cur_value - min_y1_value) + \ (y1_cur_value == min_y1_value) * \ ((max_y1_value == min_y1_value)) pos_of_y = int(cur_y1_value_and_min_difference * 80 / \ MAX_Y1_VALUE_DIFFERENCE) 

चक्र हमारे लिए पहले से ही परिचित है। हमें फ़ंक्शन के प्रत्येक मूल्य को दूसरी बार गिनना होगा, ताकि उन्हें एक शीट या किसी अन्य चीज़ में संग्रहीत न किया जाए।

खेल की स्थिति की गणना उपरोक्त सूत्र द्वारा की जाती है।

हमें सूत्र से ऊपरी अंतर को ठीक करना होगा, मामले के लिए प्रदान करना जब सूत्र में हमें शून्य द्वारा फार्म की अनिश्चितता मिलती है। यदि ऐसी अनिश्चितता उत्पन्न होती है, तो इसका मतलब होगा कि वर्तमान मूल्य y1 (x) = अधिकतम (y1) है, जिसका अर्थ है कि खेल का वर्तमान मूल्य y अक्ष के अंत के साथ मेल खाएगा।

  print("{1:^{0}.6g}".format(dial_length, from_x), end='') if (negative_value_exists): if y1_cur_value <= 0 - RATIO / 2: req_aux = AXIS_X_POS - pos_of_y if (req_aux != 0): print(pos_of_y * ' ' + '*' + (req_aux - 1) * ' ' + '|') else: print((AXIS_X_POS - 1) * ' ' + '*' + '|') elif y1_cur_value >= 0 + RATIO / 2: req_aux = pos_of_y - AXIS_X_POS if (req_aux != 0): print(AXIS_X_POS * ' ' + '|' + (req_aux - 1) * ' ' + '*') else: print((AXIS_X_POS) * ' ' + '|*') else: print(AXIS_X_POS * ' ' + '*') else: print('|' + pos_of_y* ' ' + '*') AXIS_X_POS = 0 from_x += pace_x print((dial_length + AXIS_X_POS) * ' ' + '|\n', (dial_length + AXIS_X_POS - 3) * ' ' + 'x V') 

कोड का यह हिस्सा सीधे ग्राफ को प्रिंट करने के लिए जिम्मेदार है।

 print("{1:^{0}.6g}".format(dial_length, from_x), end='') 

यहाँ, प्रारूप बहुत उपयोगी था और कोड को सरल बनाया। ^ हमें चयनित क्षेत्र के केंद्र में संख्या को संरेखित करने की अनुमति देता है (इस मामले में, 12 स्थिति)। जी संख्याओं के लिए ज़िम्मेदार है - यदि उनके पास एक भिन्नात्मक भाग नहीं है, तो इसे मुद्रित नहीं किया जाएगा (संख्या int के रूप में), अन्यथा - 6% स्थान

चूँकि हमारा ग्राफ y अक्ष के साथ 80 वर्णों के स्थान तक सीमित है, इसलिए हमारे ग्राफ पर बिंदु पर फ़ंक्शन का मान x अक्ष के साथ न केवल y1 (x) = 0 में, बल्कि पड़ोस में भी होगा [0] RATIO / 2, 0 + RATIO / २]।

कुल में, हमारे पास तारांकन के स्थान (यानी, बिंदु) और ऊर्ध्वाधर छड़ी (यानी, एक्स अक्ष) के तीन मामले हैं: '* | (y1 (x) <= 0 - RATIO / 2), '*' (0 - RATIO / 2 <y1 (x) <0 + RATIO / 2), '| *' (y1 (x)> = + RATIO | / 2), हम इन तीन मामलों पर विचार करेंगे।

1. y1 (x) <= 0 - RATIO / 2
   इस स्थिति में, बिंदु x अक्ष पर स्थित है, इसलिए हम रिक्त स्थान में अक्ष से दूरी की तलाश कर रहे हैं। संख्याओं के गोल होने के कारण, ऐसा हो सकता है कि चर AXIS_X_POS और pos_of_y के मान मेल खा सकते हैं। लेकिन यह नहीं हो सकता है, क्योंकि इस मामले में हम तीसरे मामले में होंगे। हमारे मामले में, बिंदु एक्स अक्ष के साथ मेल नहीं खाता है, इसलिए एक अतिरिक्त स्थिति आवश्यक है, जो समानता के मामले में 1 से कम हो जाएगी।
2. y (x)> = 0 + RATIO / 2
   मामला पहले मामले के समान है, केवल बिंदु एक्स अक्ष के दूसरी तरफ स्थित होगा और इसके लिए उपरोक्त सभी क्रियाएं समायोजित की जाती हैं।
3. बाकी
   सबसे सरल मामला - बस अक्ष के स्थान पर एक तारांकन चिह्न प्रिंट करें

यदि हम नकारात्मक मान रखते हैं (y1 (x) <0)। यदि नहीं, तो बस टाइप करें '|' और बिंदु की स्थिति निर्धारित करते हैं।

खैर, हम एक अतिरिक्त एक्स-एक्सिस के साथ कार्यक्रम को समाप्त करते हैं।

तो, जो कोड समाप्त हुआ:

 dial_length = 12 label = "  y1 = x**3 - 2*x**2 + 4*x - 8" print("{1:^{0}.6f}".format(dial_length, x_copy)) print("{1:>{0}}".format(len(label) + dial_length, label), '\n') print("{aux[1]:>{aux[0]}}\n {aux[2]:>{aux[0]}}>\n".format(aux = [dial_length + 81, 'y' , 82*'-']), end=''); MAX_Y1_VALUE_DIFFERENCE = (max_y1_value - min_y1_value) + \ (max_y1_value == min_y1_value) RATIO = MAX_Y1_VALUE_DIFFERENCE / 80 AXIS_X_POS = abs(int((- min_y1_value) / RATIO)) if (AXIS_X_POS > 80): AXIS_X_POS = 81 while (is_sequence_decreasing and from_x >= to_x) or \ (not is_sequence_decreasing and from_x <= to_x): y1_cur_value = y1(from_x) cur_y1_value_and_min_difference = (y1_cur_value - min_y1_value) + \ (y1_cur_value == min_y1_value) * \ ((max_y1_value == min_y1_value)) pos_of_y = int(cur_y1_value_and_min_difference * 80 / \ MAX_Y1_VALUE_DIFFERENCE) print("{1:^{0}.6g}".format(dial_length, from_x), end='') if (negative_value_exists): if y1_cur_value <= 0 - RATIO / 2: req_aux = AXIS_X_POS - pos_of_y if (req_aux != 0): print(pos_of_y * ' ' + '*' + (req_aux - 1) * ' ' + '|') else: print((AXIS_X_POS - 1) * ' ' + '*' + '|') elif y1_cur_value >= 0 + RATIO / 2: req_aux = pos_of_y - AXIS_X_POS if (req_aux != 0): print(AXIS_X_POS * ' ' + '|' + (req_aux - 1) * ' ' + '*') else: print((AXIS_X_POS) * ' ' + '|*') else: print(AXIS_X_POS * ' ' + '*') else: print('|' + pos_of_y* ' ' + '*') AXIS_X_POS = 0 from_x += pace_x print((dial_length + AXIS_X_POS) * ' ' + '|\n', (dial_length + AXIS_X_POS - 3) * ' ' + 'x V') 

कई परीक्षणों पर कार्यक्रम चलाएं






यह काम करता है)