शब्दों की सूची तैयार करें

Question

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

इनपुट

इनपुट शब्दों की एक अंतरिक्ष-पृथक सूची होगी और फिर एक संख्या जो कम से कम 4 होगी।

उत्पादन

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

परीक्षण के मामलों

Input:
foo bar baz qux 12

Output:
foo, bar,
baz, qux


Input:
foo bar baz qux 5

Output:
foo,
bar,
baz,
qux


Input:
strength dexterity constitution intelligence wisdom charisma 10

Output:
strength,
dexterity,
consti...,
intell...,
wisdom,
charisma


Input:
quas wex exort 4

Output:
...,
wex,
e...

Comments

शानदार आमंत्रण!

— घातक

संबंधित

— पीटर टेलर

Answer 1

अपठनीय , 2559 बाइट्स

यह चुनौती अपठनीय के लिए अनुकूल है।

इसका पहला संस्करण 3379 बाइट्स था, बस आपको यह अंदाजा देने के लिए कि मैंने इसे कितना गॉल्फ़ किया है।

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

' "" "" "" "" "" "" "" "" "'" " '" "'" " '" "'" " '" "'" "" ' "" "" "'" " '" "" "" "'" " '" ""' "" "" "" "" "" "" "" "" ' "" "" ""' "" "" "" "" ' "" "" " '" "" "" "" "" "" "" "" "" "'" "" "" "" "" "" "" "" " '""" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '" "'" "" "" "" "" """ "" " '" "" "" "'" "" "" "" "" "" ' "" "" "" "" "" "" "" "" "" "" "" " '" ""' "" "" "" "" "" "" "" "" "" "" " '" "" "" "" "" ""' "" ' "" " "" "" "" "" "" "" "" " '" "" "" "" "" "" "" "'" " '" ""' "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" """" ' ""' "" "" "" "" ' ""' "" " '" "" "" "" "" "" "" "" ""' "" ' "" "' "" "" "" ' ""' "" "" " '" "'" " '" "'" " '" "'" " '" "'" " '" "'" "" "" " " '" "'" "" ' "" "" "" ""' "" ' "" "'" "" "" ' "" "" ""' "" "" "" "" """ "" "" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""' " "" "" " '" "'" "" ' ""' "" "" "" "" " '" ""' "" "" " '" "" "" "'" " '" "" ' "" "" "" "" "" "" "" "'" " '" "" "" "" ""' "" "" "" ' "" "'" "" """ "" "" "" "" "" "" ' "" "" "" "" "'" " '" "'" " '" "'" "" ' ""' "" ' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" "" "" ' ""' "" ' ""' "" ' " " '" ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' ""' ""' "" ' ""' "" ' ""' "" ' ""' "" "" "" ' ""' "" ' "" "'" " '" "'" " '" " "" "" "" "" "" "" "" " '" "'" " '" "'" " '" "'" " '" "" "" "'" "" ' "" " ' "" "" "'" "" "" "" "" ' "" "" "" "" "" "" "" "" ""' "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "" "'" " '" "" "" ""' "" "" "" "" "" " '" "" "" "" ""' "" "" "" "" "" "" "" "" "" ' "" "" " "" "" "" "" "" ' ""' "" " '" "" "" "" ""' "" "" "" "" "" "" "" " '"" "" "" "" " '" ""' "" "" "" "" "" "" "" "" "" ' "" "" "" "" "" "" "" "" "" "" " '" "" "" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" " ' "" "" "" ' "" "" "" ""' "" ' ""' "" " '" "" "" "" ""' "" "" "" " '""" "" "" "" "" "" "" "" " '" "'" " '" ""' "" "" "" "" " '" "" "" "" "' "" "" "" "" "" ' "" "" "" "" ""' "" "" "" "" "" "" "" "" "" "" "" " " '" "'" " '" "'" "" ' "'" "" "" "" "" ' ""' "" ' ""' "" ' "" "'" "" '"" "" " '" "" "" "" "" "" ""' "" "" "" "" "" " '" "'" "" "" "" "" "" " "" "" "" ' "'" " '" "'" " '" "'" " '" "'" " '" "'" " '" "'" " '" "'" " '" " '" "'" " '" "'" " '" "'" " '" "'" " '" "'" " '" "'" " '" "'" " '" "'" " '"" ' ""' "" "" "" "" "" "" "" "" "" "" "" "" " '" "" "" "" ""' "" "" " "" ' ""' "" " '"' "" "" "" "" " '" "'" " '" "'" "" ' "" "" "" "" "" "' "" "" "" "" " '" "" "" "" ""' "" ' ""' "" " '" "" "" "" "" "" "" "" '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" "" ' ""' "" "" "" " '" ""' "" "" "" "" "" "" "" "" "" " '" "'" "" "" "" "" ' "" "'" " '" "" "" "" "" " '" "" "" "" "" "'" "" "" " '" ""' "" ' "" "" "" "'""" ' "'" " '" "'" " '" "'" " '" "'" " '" "'" " '" "'" " '" "'" " '" "'" " ' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' "" "" "" "" "" "" "'" "" "" "" "" "" ' ""' "" "" "" "" "" "" "" " '""" ' "'" ' "'" "" "" "" "" "" "" "" "" " '" "" "" "" "" ""' "" ' "" "" "" "" "" "" "" "" "" ' ""' "" ' "" "" "" "" "'" " '" "'" " '" ""' "" " "" "" "" "" "" "" "" " '" ""' " '" "" "" "" ""' "" ' ""' "" ' "" "'"" " '"' "" "" "" "" " '" "'" "" ' "" "" "" "" "" "" ""' "" " '" ""

व्याख्या

मैं आपको इस बारे में बताने जा रहा हूं कि प्रोग्राम कैसे इनपुट को प्रोसेस करता है thyme horseradish peppermint 10। अपेक्षित आउटपुट हैthyme,\nhorser...,\npeppermint ।

पहले हम सेल # 7 से शुरू करते हैं और पूरे इनपुट को पढ़ते हैं, लेकिन हर वर्ण से 32 घटाते हैं ताकि रिक्त स्थान शून्य हो जाएं।

स्पष्ट कारणों के लिए, यह रनिंग पॉइंटर को छोड़ देता है (नामित पी यहां, सेल # 0 में संग्रहीत है)। हम अंतिम अंतराल को खोजने के लिए लूप का उपयोग करते हैं, जो कि आउटपुट की चौड़ाई को परिभाषित करने वाली संख्या की शुरुआत है (इस उदाहरण में सेल # 36)।

अब हम संख्या को डिकोड करना चाहते हैं (यानी दशमलव से रूपांतरित करें)। अंतिम परिणाम टी और आर दोनों कोशिकाओं में होगा । हम इस तथ्य पर भरोसा करते हैं कि वे शून्य पर शुरू होते हैं।

संख्या में प्रत्येक अंक के लिए, निम्नलिखित करें:

• टी Set15 पर सेट करें ।
• थोड़ी देर के लूप में, decrement r (जिसमें अब तक का परिणाम होता है) से dec1 (क्योंकि हमें बिल्कुल r पुनरावृत्तियों की आवश्यकता है , लेकिन चूँकि यह लूप की स्थिति के रूप में जाँचने से पहले घटता है, 0 तक घटने से एक कम पुनरावृत्ति होगी) और प्रत्येक पुनरावृत्ति के लिए, 10 से t जोड़ें । अब t में पिछले परिणाम का 15 गुना शून्य से 10 गुना है।
• थोड़ी देर के लूप में फिर से, घटाव * p से 0 और प्रत्येक पुनरावृत्ति के लिए, 1 से t जोड़ें । इसके बाद टी सही मध्यवर्ती परिणाम अब तक शामिल हैं: पात्रों '0'को '9'48-57 ASCII कोड है, तो 32 के पहले के घटाव वे 16-25 के बाद, हम वास्तव में करने के लिए 15-24 जोड़ें ताकि टी , जो -15 के साथ रद्द हम इसे पहले सेट करते हैं। यह भी महत्वपूर्ण है कि यह उन कोशिकाओं को शून्य करता है जिनमें अंक वर्ण होते थे ताकि बाद का कोड शब्दों की सूची के अंत को पहचान सके।
• R को नए मध्यवर्ती परिणाम पर सेट करें ताकि अगला पुनरावृत्ति इसे r में खोजे । (ध्यान दें कि हमें टी से दोबारा पढ़ने की आवश्यकता नहीं है , हम लूप से पिछले मान का उपयोग कर सकते हैं क्योंकि हम जानते हैं कि * p शून्य नहीं हो सकता है, इसलिए यह कम से कम एक बार चला है।)

अंत में, हम लूप में एक और सरल का उपयोग करते हैं ( काउंटर के रूप में टी को घटाते हुए ) जिस संख्या को हमने सिर्फ एकात्मक में गणना की है। हम सेल # 0 से बाईं ओर जा रहे 1 के तार को स्टोर करते हैं। यह इस तथ्य पर निर्भर करता है कि सेल # 1, इस ( q ) के लिए हमारा रनिंग पॉइंटर , 0. पर शुरू होता है। हमें एक कम 1 एस मिलता है क्योंकि अनरीडेबल में लूप इस तरह हैं:

इसके बाद, हमें अब r में मान की आवश्यकता नहीं है , इसलिए हम उस सेल का उपयोग किसी और चीज़ के लिए करते हैं। हम पॉइंटर्स पी और क्यू को रीसेट करते हैं और कुछ कोशिकाओं को एएससीआईआई कोड के साथ आरंभ करते हैं जिन्हें हमें बाद में चाहिए। मैं भी लेबल किया था ग और रों जो हम बाद में उपयोग करेगा, और हम तथ्य यह है कि पर निर्भर करेंगे एस शून्य पर बाहर शुरू होता है:

अरे, एक मिनट रुकिए। सेल # 0 रंगीन लाल क्यों है? ... खैर, यह एक डरपोक चाल को उजागर करना है। याद रखें हम एक 1 बहुत कम आउटपुट करते हैं? चाल यह है कि हम सेल # 0 का उपयोग एक "एक्सटेंशन" के रूप में करते हैं ताकि उसके लिए सही हो सके। यह काम करता है क्योंकि हम जानते हैं कि पी कभी भी 0. नहीं होगा। इस तरह, लाल ब्लॉक अब 10 सेल चौड़ा है, ठीक उसी तरह जिस पर हम चाहते हैं। यह 9 वर्णों को भी बचाता है जो 0 के बजाय q 1 को प्रारंभ करने में सक्षम होता है ।

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

चरण 1: पता करें कि अगला शब्द वर्तमान लाइन में फिट होगा या नहीं। हम तो बस ले जाकर ऐसा कर पी सही और करने के लिए क्यू थोड़ी देर के पाश जब तक साथ छोड़ दिया पी अगले अंतराल हिट:

अब वह p शब्द के दाईं ओर है, हम जाँच कर सकते हैं कि क्या यह सूची का अंतिम शब्द है कि जाँच करके यदि * (p + 1) शून्य है। हम उस मूल्य को भी संग्रहीत करते हैं (जो कि हमारे उदाहरण में 72 है क्योंकि यह ग में "horseradish" माइनस 32 से "h" है) क्योंकि हमें बाद में फिर से इसकी आवश्यकता होगी। इस स्थिति में, यह शून्य नहीं है, इसलिए हमें शब्द के साथ अल्पविराम का उत्पादन करना होगा, इसलिए यह शब्द एक वर्ण लंबा है। Decrementing द्वारा इस के कारण लो क्ष एक बार और। अंत में, एक और पाश स्थानांतरित करने के लिए है, जबकि का उपयोग पी शब्द के प्रारंभ करने के लिए वापस।

अब हम जानते हैं कि शब्द वर्तमान रेखा में फिट होगा क्योंकि q गैर-शून्य मान पर इंगित कर रहा है, इसलिए हमें केवल यह करना है:

• ले जाएँ पी आगे शब्द के माध्यम से फिर से, हर किरदार के मुद्रण (प्लस 32, क्योंकि सभी ASCII कोड 32 से बंद होती हैं)।
• यदि सी गैर-शून्य है, तो अल्पविराम (सेल # 5 में मान का उपयोग करके) प्रिंट करें।
• सेट रों एक गैर शून्य मान के लिए अगले चरण है कि हम एक पंक्ति के आरंभ में नहीं रह रहे हैं और इसलिए उत्पादन के लिए अगले शब्द से पहले एक स्थान चरित्र की जरूरत को इंगित करने के लिए। (हम इसके लिए उपरोक्त प्रिंट स्टेटमेंट के रिटर्न मूल्य का उपयोग करते हैं, जो अल्पविराम के लिए 44 है।)

अब तक का आउटपुट: thyme,

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

अब q एक शून्य सेल पर इंगित करता है, जिसका अर्थ है कि "हॉर्सरैडिश" वर्तमान लाइन में फिट नहीं होगा। क्या अब हम करते हैं इस पर निर्भर करता रों गैर-शून्य है। हमारे मामले में यह है, जिसका अर्थ है कि हमें अगली पंक्ति में लपेटने की आवश्यकता है। इसके लिए हमें बस इतना करना है:

• एक नई रेखा प्रिंट करें (सेल # 3 का उपयोग करके)
• वापस q 1 पर सेट करें
• सेट रों 0

अब तक का आउटपुट: thyme,\n

अगले पुनरावृत्ति के लिए, पी पहले की तरह ही है, इसलिए हम फिर से उसी शब्द को देखेंगे। पहले के रूप में, हम "सहिजन", सेट में पात्रों गिनती ग फिर जब हम वहाँ इस एक के बाद एक और शब्द, घटती है नोटिस 80 q अल्पविराम के लिए, और रिवाइंड पी शब्द के प्रारंभ करने के लिए वापस:

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

• 1s के लाल ब्लॉक की शुरुआत का पता लगाएं। हम सही जा कर ऐसा कर सकते हैं क्योंकि हम जानते हैं कि q इसे छोड़ना चाहिए।
• वृद्धि क्यू एक बार फिर अगर हमें एक कॉमा ( सी । 0) आउटपुट करने की आवश्यकता है ।

टेप अब इस तरह दिखता है:

मैंने यहां 6 सेल की अवधि चिन्हित की है। जैसा कि आप देख सकते हैं, हमें q = we1 तक वर्णों को आउटपुट करने की आवश्यकता है । यह (मूल रूप से while ((++q)+1) { ... }) जाँच करने के लिए बहुत ही कोड-कुशल है । इसलिए:

• उन वर्णों को प्रिंट करें (प्लस 32, क्योंकि सभी ASCII कोड 32 से बंद हैं) जब तक q .1 तक नहीं पहुंच जाता। p तब "हॉर्सरैडिश" शब्द के मध्य में सेल 19 पर होगा।
• तीन डॉट्स प्रिंट करें। चूंकि प्रिंट कमांड अपना तर्क देता है, इसलिए हम इसे (मूलत:, कुशलता से) कोड कर सकते हैं print(print(print('.')))। हम सेल से एएससीआईआई मान # 5 लेते हैं और डॉट के एएससीआईआई कोड प्राप्त करने के लिए इसमें 2 जोड़ते हैं।
• पी को शब्द के अंत में ले जाएं । चूँकि हम जानते हैं कि हम पहले ही शब्द के अंत तक नहीं पहुँच सकते हैं (क्योंकि यह शब्द बहुत लंबा था, और हमें डॉट्स को फिट करने के लिए इसमें से कम से कम 3 वर्णों को हटाना पड़ा था), इस लूप में निश्चित रूप से कम से कम एक चलना है, इसलिए यह कोड में छोटा है जबकि लूप का शरीर डॉट के लिए ASCII मान की गणना करता है और फिर प्रिंट कार्य के लिए लूप के रिटर्न मान को पास करता है।
• एक अल्पविराम प्रिंट अगर सी गैर-शून्य है।

इस सब के बाद, हम भी एक नई पंक्ति और सेट (सेल # 3 का प्रयोग करके) प्रिंट क्ष 1. वापस करने के लिए हम भी सेट कर सकते हैं रों 0 को भले ही यह पहले से ही है 0 है, जो इस एक ही बनाता है जब हम करने के लिए लिपटे है कि हम पहले किया था अगली पंक्ति (जब एस गैर-शून्य था), इसलिए कोड को दोहराने से बचने के लिए, हम इसे सशर्त के बाद करते हैं जो एस की जांच करता है ।

अब तक का आउटपुट: thyme,\nhorser...,\n

केवल एक पुनरावृत्ति शेष है। इस बार, शब्द के अक्षरों को गिनने के बाद, हमें यह मिलता है:

इस बार, वहाँ के बाद कुछ भी नहीं है पी , तो हम सेट ग "कोई अल्पविराम" इंगित करने के लिए 0 करने के लिए, और उसके अनुसार हम घटती नहीं है क्ष एक और समय। चूंकि q अब एक गैर-शून्य सेल पर इंगित करता है, हम जानते हैं कि शब्द फिट होगा, इसलिए समान कोड को पहले पुनरावृत्ति में निष्पादित किया जाता है, सिवाय इसके कि इस समय सी शून्य है, इसलिए यह बस कॉमा को प्रिंट नहीं करेगा।

आउटपुट: thyme,\nhorser...,\npeppermint

इस वॉकथ्रू में मैंने एक ऐसे मामले को शामिल नहीं किया जहां कोड वास्तव में एक स्थान प्रिंट करेगा, लेकिन मुझे लगता है कि यह अब बिल्कुल स्पष्ट होना चाहिए। यदि कोड को पता चलता है कि शब्द फिट बैठता है ( * q ) 0) और s गैर-शून्य है, तो यह शब्द से पहले एक स्थान का उत्पादन करेगा।

Answer 2

जावास्क्रिप्ट (ईएस 6), 171

एक अनाम फ़ंक्शन के रूप में एक सरणी के रूप में आउटपुट लौटाता है

(जैसा कि आम तौर पर अनुमति दी जाती है जब तक कि स्पष्ट रूप से मना नहीं किया जाता है: मेटा मेटा )

s=>(s=s.split` `,n=s.pop()-1,t='',o=[],s.map((w,i)=>(w=w[n+=!s[i+1]]?w.slice(0,n-3)+'...':w,(t+w)[n-2]&&(t&&o.push(t.slice(1)),t=''),t+=` ${w},`)),o.push(t.slice(1,-1)),o)

f=s=>(s=s.split` `,n=s.pop()-1,t='',o=[],s.map((w,i)=>(w=w[n+=!s[i+1]]?w.slice(0,n-3)+'...':w,(t+w)[n-2]&&(t&&o.push(t.slice(1)),t=''),t+=` ${w},`)),o.push(t.slice(1,-1)),o)

// Less golfed
U=s=>(
  s=s.split` `,
  n=s.pop()-1,
  t='', // current line
  o=[], // output
  s.map( (w,i)=>(
    w=w[
      n+=!s[i+1] // space for 1 more char on the last line
    ]?w.slice(0,n-3)+'...':w, // change w if it is too long
    (t+w)[n-2]&& ( // if current line + w is too long, ouput t and reset current line
      t&&o.push(t.slice(1)),t=''
    ),
    t+=` ${w},`
  )),
  o.push(t.slice(1,-1)), // remove tailing comma on last line
  o
)

console.log=x=>O.textContent+=x+'\n\n';
  
console.log(f("foo bar baz qux 12").join`\n`)
console.log(f("foo bar baz qux 5").join`\n`)
console.log(f("strength dexterity constitution intelligence wisdom charisma 10").join`\n`)
console.log(f("quas wex exort 4").join`\n`)

<pre id=O></pre>

Answer 3

पायथन 2, 206 बाइट्स

i=input().split()
l=int(i.pop())
i=[[w[:l-4]+'...',w][len(w)<l]+','for w in i][:-1]+[[w,w[:l-3]+'...'][len(w)>l]]
r=[i.pop(0)]
for w in i:
 if len(r[-1])+len(w)<l:r[-1]+=' '+w
 else:r+=[w]
print'\n'.join(r)