स्वचालित कॉलम चौड़ाई गणना

कार्य

कार्य सरल लगता है - एक तालिका प्रिंट करें। प्रिंट करें ताकि यह सुंदर दिखे और, यदि संभव हो, तो क्रॉल न करें।

कुछ विचार-विमर्श के बाद, पीडीएफ उत्पन्न करने के लिए FOP का उपयोग करने का निर्णय लिया गया। पकड़ यह है कि अपाचे एफओपी table-layout:auto समर्थन नहीं करता है table-layout:auto , अर्थात, जब एक टेबल का निर्माण होता है, तो आपको कॉलम की चौड़ाई मैन्युअल रूप से निर्धारित करनी चाहिए (यह अच्छा है कि आप सापेक्ष चौड़ाई प्रतिशत में सेट कर सकते हैं)। यदि आप एक ही चौड़ाई के सभी कॉलम बनाते हैं, तो तालिका कुछ हद तक असंगत दिखाई देगी। यह पता चला है कि आपको मैन्युअल रूप से चौड़ाई की गणना करनी होगी।

मुख्य विचार यह है कि स्तंभों की चौड़ाई को इस तरह से चुना जाना चाहिए कि तालिका कोशिकाओं के अंदर लाइन ब्रेक की संख्या को कम करने के लिए जितना संभव हो सके।

निर्णय

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

डेटा की तैयारी

सबसे पहले, तय करें कि डेटा की आवश्यकता क्या है। हम तालिका के प्रत्येक कक्ष में पाठ को शब्दों में विभाजित करते हैं, प्रत्येक शब्द के लिए हम गणना करते हैं कि यह कागज पर कितना स्थान लेता है। इस प्रकार, प्रत्येक सेल के लिए हम इसके टेक्स्ट की शब्द लंबाई की एक सरणी संग्रहीत करेंगे।

इसके अलावा, आपको कागज की चौड़ाई पता होनी चाहिए, और शब्द की लंबाई के समान इकाइयों में व्यक्त किया जाना चाहिए।

मैंने शब्दों की लंबाई निर्धारित करने के लिए QFontMetrics :: चौड़ाई का उपयोग किया। इस प्रकार, शब्दों की लंबाई पिक्सल में प्राप्त की गई थी। फिर, पिक्सेल में कागज की चौड़ाई निर्धारित करने के लिए, स्क्रीन की डीपीआई द्वारा इंच में इसकी चौड़ाई को गुणा करने के लिए पर्याप्त है, जिसे QPaintDevice :: तार्किकDpiX फ़ंक्शन का उपयोग करके प्राप्त किया जा सकता है ।


यह पता चल सकता है कि तालिका को फिट करने के लिए कागज की चौड़ाई पर्याप्त नहीं है, भले ही आप कॉलम को इतना निचोड़ लें कि प्रत्येक पंक्ति में केवल एक शब्द फिट हो।

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

कम से कम चौड़ाई टेबल

द्वारा निर्धारित किया गया योग लंबाई सबसे ज्यादा लंबे समय तक शब्द कॉलम में

यदि तालिका फिट नहीं होती है, तो आपको लंबे शब्दों को ट्रिम करना होगा। चूंकि, जब से हमने शब्द को ट्रिम करने का फैसला किया है, हम इसे कहीं भी ट्रिम कर सकते हैं, हम ऐसे क्रॉप्ड शब्दों की प्रभावी लंबाई को शून्य मानेंगे।

इसलिए, हम तालिका में सबसे लंबे शब्द को तब तक ट्रिम करेंगे जब तक कि टेबल कागज पर फिट होना शुरू न हो जाए।

इस पर, डेटा तैयारी को पूर्ण माना जा सकता है, और हम कॉलम की चौड़ाई की गणना के लिए एल्गोरिथ्म पर आगे बढ़ सकते हैं।

गणना

लेख की शुरुआत में, मैंने समाधान का मुख्य विचार निर्धारित किया। अब इसे और अधिक औपचारिक रूप से व्यक्त करने का समय आ गया है। वास्तव में, टेबल पर कागज को इस तरह से प्रदर्शित करना आवश्यक है ताकि टेबल क्षेत्र को जितना संभव हो उतना कम किया जा सके।
तालिका के कब्जे वाले क्षेत्र को इसके स्तंभों के क्षेत्रों के योग के रूप में परिभाषित किया जा सकता है:

यहां और - क्रमशः कॉलम की ऊंचाई और चौड़ाई।

बेशक, यह पूरी तरह से सच नहीं है, लेकिन व्यवहार में ऐसा मॉडल पूरी तरह से संतोषजनक परिणाम देता है।

हम लिखेंगे कि कॉलम की ऊंचाई क्या है:

जहाँ m तालिका की पंक्तियों की संख्या है, lh पाठ की रेखा की ऊंचाई है, p एक गुणांक है जो इंडेंटेशन की ऊंचाई का वर्णन करता है, wc लाइन ब्रेक की संख्या है।

चूंकि लाइनों की संख्या, लाइन की ऊंचाई और इंडेंटेशन को प्रभावित करना असंभव है, उन्हें एक अलग गुणांक ए में निकाला जा सकता है ।

लेकिन पंक्ति विराम की संख्या कॉलम की चौड़ाई पर निर्भर करती है। इस प्रकार, स्तंभ की ऊंचाई को फिर से लिखा जा सकता है:


और कार्य फ़ंक्शन को छोटा करना है


हां, हां, मुझसे गलती नहीं हुई थी, ए और बी कश्मीर पर निर्भर नहीं करेगा, क्योंकि बी को लाइन की ऊंचाई से निर्धारित किया जाता है, और ए , इसके अलावा, इंडेंटेशन के आकार और लाइनों की संख्या से।

एस के रूप में फिर से लिखा जा सकता है:


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


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

क्या आपने व्युत्पन्न कहा?

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

इस तरह के फ़ंक्शन में डेरिवेटिव के साथ स्पष्ट समस्याएं हैं, लेकिन हम इसे सरल रूप से करेंगे: हम फ़ंक्शन को स्वयं नहीं मानेंगे, लेकिन कुछ नीरस रूप से कम होने वाले फ़ंक्शन, जो स्थानान्तरण की संख्या में परिवर्तन के मूल फ़ंक्शन की सही सीमा के साथ मेल खाते हैं।

शुरुआती बिंदु के रूप में, हम सबसे छोटे संभव स्तंभ चौड़ाई के साथ बिंदु लेते हैं।

एल्गोरिथ्म

प्रत्येक स्तंभ के लिए:

• हम उन बिंदुओं के सरणियों का निर्माण करते हैं जिन पर इस कॉलम में परिवर्तन की संख्या - एम _के ।
• इन बिंदुओं पर स्थानान्तरण की संख्या के सुचारू कार्य के मानों की सारणी (मैंने पिछले खंड में सुचारू कार्य को परिभाषित किया है) - cc _k ।

इन सरणियों को बनाने के लिए, हम तालिका के प्रत्येक कक्ष में पहले चरण में तैयार शब्द लंबाई पर डेटा का उपयोग करते हैं।

हम शुरुआती बिंदुओं के साथ सरणियों को पूरक करते हैं (वे कॉलम के रूप में कई थे)।

परिणामस्वरूप, कॉलम के लिए

कम से कम चौड़ाई टेबल

हमें निम्न डेटा संरचना मिलती है:

म ०	wc 0
11	2
13 ("चौड़ाई" और "टेबल" - एक लाइन पर)	1
24	0

हम शेष स्तंभों के लिए समान संरचना प्राप्त करते हैं।

अब पुनरावृति प्रक्रिया शुरू करें:
अब तक, कॉलम की चौड़ाई का योग पृष्ठ की चौड़ाई से कम है:

• हम सूत्र का उपयोग करके प्रत्येक समन्वय के साथ चलते समय क्षेत्र फ़ंक्शन ( यू ) में परिवर्तन की गणना करते हैं
  
  (यह एक उत्पाद के अंतर को लेने के लिए एक प्रसिद्ध सूत्र है: d (AB) = B d A + A d B)
• यदि एक सरणी में केवल एक तत्व बचा है, तो इस कॉलम में पहले से कोई लाइन नहीं है ( wc _k [0] == 0 )। हम इस तरह के कॉलम को ध्यान में नहीं रखते हैं।
• यदि एक भी सरणी पर विचार नहीं किया गया है, तो सभी स्तंभों में पंक्ति विराम पहले से ही गायब है, हम गणना समाप्त करते हैं।
• K- th कॉलम की चौड़ाई बढ़ाएँ, जिसमें d _k सबसे बड़ा है। हम इस कॉलम के लिए w _{k k} और m _k सरणियों के पहले तत्वों को हटाते हैं।

अंत में, हम प्राप्त कॉलम चौड़ाई को निरपेक्ष इकाइयों से प्रतिशत तक पुनर्गणना करते हैं। इस प्रकार, आइए उपयोग किए गए फ़ॉन्ट मीट्रिक से छुटकारा पाएं।

परिणाम

नतीजतन, तालिका बिल्कुल वही है जो मैं मैन्युअल स्वरूपण के साथ करूंगा।

पुनश्च
लेख गणितीय रूप से कठोर होने का दावा नहीं करता है, लेकिन यह आपको दिखाता है कि लागू प्रोग्रामिंग में थोड़ा गणित उपयोगी हो सकता है।