इस कोड स्पष्टीकरण को फिर से सुंदर बनाएं

17

परिचय

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

हालाँकि, जब आप इस स्पष्टीकरण को संपादित करना चाहते हैं क्योंकि आपने कुछ पागल गोल्फ बनाए हैं, तो आप अक्सर अपने स्पष्टीकरण को फिर से सुंदर बनाने के लिए समय व्यतीत करते हैं। चूंकि यह एक बहुत दोहराव वाला काम है, इसलिए आप इसके लिए एक कार्यक्रम लिखना चाहते हैं।

चुनौती

स्पष्टीकरण और एक विभाजक के साथ कोड की कई पंक्तियों को देखते हुए, स्पष्टीकरण के साथ अच्छी तरह से स्वरूपित कोड का उत्पादन करते हैं।

उदाहरण

इनपुट

shM-crz1dc4। "ANDBYOROF # z = इनपुट

     rz1 # इनपुट को अपरकेस में बदलें
    सीडी # रिक्त स्थान पर इनपुट विभाजित करें
         c4। "ANDBYOROF # पैक स्ट्रिंग से शब्दों की एक सूची बनाएं जिसे नजरअंदाज किया जाएगा
   - # उन शब्दों को फ़िल्टर करें
 hM # केवल सभी शब्दों का पहला अक्षर लें
s # उन्हें एक स्ट्रिंग में शामिल करें

उत्पादन

shM-crz1dc4। "ANDBYOROF # z = इनपुट

     rz1 # इनपुट को अपरकेस में बदलें
    सीडी # रिक्त स्थान पर इनपुट विभाजित करें
         c4। "ANDBYOROF # पैक स्ट्रिंग से शब्दों की एक सूची बनाएं जो कि होगी
                           # अवहेलना करना
   - # उन शब्दों को फ़िल्टर करें
 hM # केवल सभी शब्दों का पहला अक्षर लें
s # उन्हें एक स्ट्रिंग में शामिल करें

पहले वाले के लिए एक कुकी जो यह पता लगा सकती है कि यह कोड क्या करता है।

स्वरूपण एल्गोरिथ्म

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

टिप्पणियाँ

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

नियम

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

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

['shM-crz1dc4। "ANDBYOROF # z = इनपुट', '', 'rz1 # इनपुट को अपरकेस में बदलें', 'cd # स्प्लिट इनपुट ऑन स्पेस', 'c4।" और NYOROF # पैक से शब्दों की एक सूची बनाएं। स्ट्रिंग जिसे अनदेखा किया जाएगा ',' - # उन शब्दों को फ़िल्टर करें ',' hM # केवल सभी शब्दों का पहला अक्षर लें ',' s # उन्हें एक स्ट्रिंग में शामिल करें '], "#" -> [' shM-crz1dr4 । "ANDBYOROF # z = input ',' ',' rz1 # इनपुट को अपरकेस में बदलें ',' cd # स्प्लिट इनपुट ऑन स्पेस ',' c4।" ANDBYOROF # पैक स्ट्रिंग से शब्दों की एक सूची बनाएं जो कि होगी '। , ' # अवहेलना करना', '- # उन शब्दों को फ़िल्टर करें ',' hM # केवल सभी शब्दों का पहला अक्षर लें ',' s # उन्हें एक स्ट्रिंग में शामिल करें]]
['कोडेकोडबॉस ई # स्पष्टीकरण', 'sdf dsf sdf e # ए वेरी वेरी वेरी वेरी वेरी वेरी वेरी इन लॉन्ग लॉन्ग लॉन्ग लॉन्ग एक्सप्लेनेशन एंड लॉन्ग लॉन्ग लॉन्ग एक्सप्लेन।' ',' ' अधिक कोडे # और कुछ और स्पष्टीकरण '], "ई #" -> [' कोडकोडोडबेक ई # स्पष्टीकरण ',' sdf dsf sdf e # ए वेरी वेरी वेरी वेरी वेरी वेरी वेरी वेरी लॉन्ग लॉन्ग लॉन्ग ',' ई # लॉन्ग लंबी लंबी लंबी लंबी लंबी व्याख्या और यह लंबे समय तक ',' ई # और लंबे समय तक ',' ',' कुछ और कोड ई # और कुछ और स्पष्टीकरण 'पर बनी रहती है।

हैप्पी कोडिंग!

code-golf  string 
— Denker
स्रोत
1
@ मैट सभी सेपरेटर हमेशा कॉलम में होते हैं length of the longest code-line + 5। यह उन लाइनों पर भी लागू होता है जिनमें केवल एक स्पष्टीकरण होता है, क्योंकि वे लिपटे हुए थे।
— डेनकर
हे भगवान मैं पिछले 3 घंटे से यह गलत कर रहा हूं। मैं लंबे कोड को लपेटने की कोशिश कर रहा था और स्पष्टीकरण को लंबा छोड़ रहा था। कम से कम अब यह आसान है। धन्यवाद। आपने इसे ठीक कहा .... मैं सिर्फ मूर्ख हूं।
— मैट
उन सभी पंक्तियों को लपेटें जो 93 वर्णों से अधिक लंबी हैं, क्या इसका मतलब है कि कोड, जिसमें प्रमुख स्थान भी शामिल हैं, कभी भी 87 वर्णों से अधिक नहीं होंगे?
— मैट
@ मैट कोड और सेपरेटर एक साथ 87 वर्णों से अधिक लंबे नहीं होंगे क्योंकि हमें कोड और सेपरेटर और स्पष्टीकरण के लिए एक वर्ण के बीच 5 रिक्त स्थान की आवश्यकता होती है।
— डेनकर
1
Pyth कोड किसी भी दिए गए स्ट्रिंग का संक्षिप्त नाम पाता है। मुझे पता होगा क्योंकि यह मेरे सवाल का जवाब था।
— अप्प्लत १२

जवाबों:

3

रूबी, 245 237 220 216 212 209 205 बाइट्स

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

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

->x,d{l,S=0," "
s=->n{m,q=n.size,94-l-d.size
m>q ?(i=n.rindex(S,q)
n[0,i]+"
"+S*l+d+s[n[i+1,m]]):n}
x.map{|n|c,t=n.split d
c=(c||S).rstrip
l=[l,5+c.size].max
[c,t]}.map{|c,t|c+S*(l-c.size)+d+s[t]if t}*"
"}

बदलाव का:

  • इनपुट में कुछ वादों का लाभ उठाकर कुछ बाइट्स को बचाया, विशेष रूप से यह वादा किया कि सभी गैर-खाली लाइनों में विभाजक चरित्र और एक स्पष्टीकरण है।
  • पहली mapकॉल से स्प्लिट स्ट्रिंग्स को बचाने और stripवादे के आधार पर कुछ अनावश्यक कार्यों को करने से थोड़ा अधिक गोल्फ के लिए प्रबंधित किया गया कि स्पष्टीकरण में शब्दों के बीच हमेशा एक ही स्थान होता है। इसके अलावा, " "एक निरंतर को सौंपा गया है क्योंकि मैं इसे बहुत उपयोग करता हूं।
  • mapउच्च-क्रम वाले कार्यों की शक्ति का लाभ उठाकर दोनों कॉलों को एक साथ जोड़ा, जिसका अर्थ है कि पहला मैप कॉल लंबाई चर को lसही ढंग से सेट करेगा भले ही इसे हेल्पर फ़ंक्शन की घोषणा के बाद कहा जाए s। -4 निवाले।
  • दुर्व्यवहार वाली बहुस्तरीय स्ट्रिंग्स को \nवास्तविक न्यूलाइन्स के साथ बदलने के लिए , साथ ifही टर्नरी ऑपरेटरों पर एक छोटी सी चाल का उपयोग करके (जब मूल्यों के joinसाथ एक सरणी पर कहा जाता है nil, तो वे खाली स्ट्रिंग्स बन जाते हैं)
  • .joinजाहिर है एक के साथ बदला जा सकता है *।
— मान स्याही
स्रोत
मुझे लगता है कि इसे अब तय किया जाना चाहिए?
— वैल्यू इंक
94 पर कैसे लपेटता है?
— वेन
सब ठीक है, अब जब मेरे पास कोड पर काम करने के लिए अधिक समय था, तो यह ठीक से लपेटता है।
— वैल्यू इंक
"हालांकि स्पष्टीकरण में असीमित लंबाई हो सकती है, विभाजक और कोड में केवल अधिकतम अधिकतम 93 - 5 = 87चार वर्ण हो सकते हैं। 5 वर्ण कोड और विभाजक के बीच रिक्त स्थान हैं। कोड और विभाजक हमेशा कम से कम एक वर्ण लंबा होगा।" आपका कोड अनुभाग 97 वर्णों के साथ सीमा के पार है, इसलिए कार्यक्रम में अपरिभाषित व्यवहार है।
— मूल्य इंक
आह, अच्छी तरह से देखा, समझ में आता है!
— वेन
9

लाइवस्क्रिप्ट, 243 236 233 228 219 225 बाइट्स

f = (x,k,m+5)->l=(.length);x.=map(->it/"#k"=>..0-=/ +$/;m>?=5+l ..0);i=0;[..0&&..0+' '*(m- l ..0)+k+..1 for x]=>while i<(l ..),++i=>j=(s=..[i])lastIndexOf ' ' 93;(..splice i+1 0 ' '*m+k+s[j to]*'';s.=substr 0 j) if 94<l s;..[i]=s

यह कैसे काम करता है: ज्यादातर जावा कोड की तरह। अलियासिंग लंबाई से शुरू करें (LiveScript कोष्ठकों का उपयोग करके ऑपरेटरों से एक फ़ंक्शन बनाने की अनुमति देता है)। .=वह है a = a.b- जिसका उपयोग हम यहां मानचित्र बनाने के लिए करते हैं।

=> blabla ..स्मॉलटॉक-ईश कैस्केड का निर्माण होता है: बाईं ओर का =>हिस्सा ..ब्लॉक के बाकी हिस्सों के लिए सुलभ है ; और वापस कर दिया जाएगा। यहाँ, यह k पर विभाजित तत्व है। नोट: मैं स्ट्रिंग इंटरपोलेशन का उपयोग कर रहा हूं, क्योंकि /केवल शाब्दिक स्ट्रिंग के साथ "विभाजन" का मतलब है।

रास हमें a-=/regexp/इस लैम्ब्डा में भी उपयोग करने की अनुमति देता है (स्ट्रिंग शाब्दिक के साथ भी काम करता है): यह केवल एक .replaceकॉल के लिए चीनी है ।

अंत में, >?=कॉम्बिनेटर- >?हत्यारा ऑपरेटर है, जो दो ऑपरेंड से अधिक रिटर्न देता है।

एलएस में व्यापकता के लिए पायथन / हास्केल-शैली है, जिसमें कुछ भी फैंसी नहीं है, अंतरिक्ष को लंबे समय तक दोहराने के लिए "स्ट्रिंग * बार" को छोड़कर।

यह समझ के लिए विषय के रूप में कार्य करता है (कैस्केड एओव के बारे में ब्लॉक देखें)।

फिर हम एरे के प्रत्येक तत्व में लूप करते हैं (एक जिसे हमने सिर्फ समझ के साथ बनाया है), और यदि कोई रेखा 93chars से बड़ी है, तो हम इस के अंतिम इंडेक्स को पाते हैं, वहां विभाजित करते हैं, और इस वर्तमान पुनरावृत्ति के बाद अलग लाइन को धकेलते हैं ... ताकि अगली पुनरावृत्ति फिर से विभाजित हो जाए यदि रेखा बहुत बड़ी है)।

केवल आखिरी बात कल्पना a[j to](जे से समाप्त करने के लिए) एक सीमा है, लेकिन क्योंकि यह सरणी तरीकों का उपयोग करता है कि हम इसे वापस एक स्ट्रिंग को शामिल होने के लिए है, जो हम अतिभारित का उपयोग करते हैं *: *''।

उदाहरण

s = """this is kod # Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
d # y

efgh # z"""

f = (x,k,m=5)->l=(.length);x.=map(->it/"#k"=>..0-=/ +$/;m>?=5+l ..0);i=0;[..0&&..0+' '*(m- l ..0)+k+..1 for x]=>while i<(l ..),++i=>j=(s=..[i])lastIndexOf ' ' 93;(..splice i+1 0 ' '*m+k+s[j to]*'';s.=substr 0 j) if 94<l s;..[i]=s

console.log (f s / '\n', '#') * \\n

उत्पादन:

this is kod     # Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod
                # tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
                # veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
                # commodo consequat. Duis aute irure dolor in reprehenderit in voluptate
                # velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
                # cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id
                # est laborum.
d               # y

efgh            # z
— Ven
स्रोत
1
जिसने भी अपदस्थ किया है: उत्तर निश्चित है।
— वेन
2
जब कोई स्पष्टीकरण ओवरफ्लो हो जाता है, तो आपको अपने विभाजक पात्रों को शेष, IIRC के साथ संरेखित करने के लिए नई लाइन की आवश्यकता होती है।
— वैल्यू इंक
@KevinLau अच्छी तरह से देखा, तय!
— वेन
क्या आप अपना उदाहरण आउटपुट भी अपडेट कर सकते हैं?
— वैल्यू इंक
@ केविनलाऊ किया।
— वेन
6

जावा, 347 + 19 = 366 बाइट्स

आवश्यक है

import java.util.*;

इस प्रकार +19 बाइट्स।

(c,s)->{int p=0,i=0,t;String l;for(;i<c.size();i++){l=c.get(i);l=l.replaceAll(" *"+s,s);p=Math.max(l.indexOf(s),p);c.set(i,l);}p+=5;for(i=0;i<c.size();i++){l=c.get(i);t=l.indexOf(s);while(t>-1&t<p)l=l.substring(0,t)+" "+l.substring(t++);t=93;if(l.length()>t){while(l.charAt(t)!=' ')t--;c.add(i+1,s+l.substring(t));l=l.substring(0,t);}c.set(i,l);}}

प्रारूप में ले जाता है f.accept(List<String> code, String seperator)। प्रारूप में जगह एक संस्करण जो एक नया बनाता है और रिटर्न करता List<String>है, उसे लागू करने के लिए तुच्छ होगा, लेकिन कुछ बाइट्स खर्च होंगे।

इंडेंटेड + उदाहरण उपयोग:

static BiConsumer<List<String>, String> prettify = (code, seperator) -> {
    int space = 0, i=0, t;
    String line;
    for (; i<code.size(); i++) { // for each line
        line = code.get(i); // get line
        line = line.replaceAll(" *" + seperator, seperator); // strip space before seperator
        space = Math.max(line.indexOf(seperator), space); // save biggest space until seperator
        code.set(i, line); // save line
    }
    space += 5;
    for (i=0; i<code.size(); i++) { // for each line
        line = code.get(i); // get line
        t = line.indexOf(seperator); // get index of seperator
        while (t>-1&t<space) // while the seperator exists and is further left than desired
            line = line.substring(0,t) + " " + line.substring(t++); // move it right by adding a space before it
        t = 93; // get desired line length
        if (line.length()>t) { // if the line is longer than that
            while (line.charAt(t)!=' ') t--; // scan backwards for a space
            code.add(i+1, seperator + line.substring(t)); // add a line after this one with seperator and the rest of the line
                                                          // the next pass will space it correctly
            line = line.substring(0,t); // cut off this line at that point
        }
        code.set(i, line); // save edited line back to List
    }
};

public static void main(String[] args) {
    List<String> code = new ArrayList<>();
    code.add("shM-crz1dc4.\"ANDBYOROF  # z = input");
    code.add("");
    code.add("     rz1      # convert input to uppercase");
    code.add("    c   d        # split input on spaces");
    code.add("         c4.\"ANDBYOROF        # create a list of the words from a packed string which shall be ignored");
    code.add("   -          # filter those words out");
    code.add(" hM                # only take the first letter of all words");
    code.add("s                   # join them into one string");
    prettify.accept(code, "#");
    code.stream().forEach(System.out::println);
}

... मुझे शायद इसे खुद के माध्यम से चलाना चाहिए: पी

— CAD97
स्रोत
अगर कोई यह पता लगा सकता replace(" *"+s)है कि काम क्यों नहीं कर रहा है, लेकिन replaceAll(" *"+s)क्या मैं इसे सुनना पसंद करूंगा - मैं इसका पता नहीं लगा सकता।
— सीएडी 97
<badguess> replaceस्ट्रिंग्स replaceAllका उपयोग करता है लेकिन रेगेक्स का उपयोग करता है। </ badguess>
— कैलकुलेटरफ़्लीन
@CatsAreFluffy अच्छी तरह से, आप सही हैं ! पता नहीं कैसे मुझे एहसास नहीं था कि: P
— CAD97
क्या आप नईलाइन नहीं निकाल सकते?
— कैलक्यूलेटरफैनलिन
अच्छी तरह से आवश्यक अर्ध की वजह से नई लाइन को हटाया जा सकता है: एस (जो होना चाहिए। लेकिन जो भी हो)
— कैल्क्युलेटरलाइन
2

पॉवरशेल, 224 217 235 बाइट्स

param($d,$s)$d=$d-split"`r`n";$p="\s+\$([char[]]$s-join"\")\s";$m=($d|%{($_-split$p)[0].Length}|sort)[-1];$d|%{$l,$c=$_-split$p;$c=if($c){"$s "+(("$c "-split"(.{1,$(87-$m)})\s"|?{$_})-join"`n$(" "*($m+5))$s ")}$l.PadRight($m+5," ")+$c}

अधिकतम कोड स्ट्रिंग लंबाई निर्धारित करने के लिए तर्क अद्यतित करें। कई विभाजकों को अनुमति देने के लिए अद्यतन किया गया है जिसमें रेगेक्स मेटा वर्ण शामिल हैं।

थोड़ा स्पष्टीकरण

यह इनपुट के लिए एक पूरी नईलाइन सीमांकित स्ट्रिंग में लेता है।

param($d,$s)
# $d is a newline delimited string. $s is the separator.
# Take the string and turn it into a string array. Stored as $d
$d=$d-split"`r`n"
# Save a regex pattern as it is used more than once
$p="\s+\$([char[]]$s-join"\")\s"
# Get the longest string of code's length
$m=($d|%{($_-split$p)[0].Length}|sort)[-1]
# Split each line again into code and comment. Write out each line with formatted explanations based on separator column position $m
$d|%{
# Split the line
$l,$c=$_-split$p
# Build the comment string assuming there is one.
$c=if($c){"$s "+(("$c "-split"(.{1,$(87-$m)})\s"|?{$_})-join"`n$(" "*($m+5))$s ")}
# Pad the right amount of space on the code and add the comment string.
$l.PadRight($m+5," ")+$c
}

कुछ लोरम इप्सम के साथ नमूना आउटपुट

shM-crz1dc4."ANDBYOROF     # z = input

     rz1                   # convert input to uppercase
    c   d                  # split input on spaces
         c4."ANDBYOROF     # But I must explain to you how all this mistaken idea of
                           # denouncing pleasure and praising pain was born and I will give
                           # you a complete account of the system, and expound the actual
                           # teachings of the great explorer
   -                       # filter those words out
 hM                        # only take the first letter of all words
s                          # join them into one string
— मैट
स्रोत
@nimi उम्मीद है कि अपडेट अब बेहतर समाधान के लिए करेंगे।
— मैट
@nimi कुछ और आप गलत नोटिस? मैं स्पष्ट रूप से पिछले कुछ दिनों के मुद्दों को पढ़ रहा हूं।
— मैट
नहीं। अब एक +1 है।
— निकमी
1

MATLAB, 270 265 262 बाइट्स

function d=f(I,s);S=@sprintf;R=@regexprep;m=regexp(I,['\s*\',s]);L=max([m{:}])+4;a=@(x)S('%-*s%s',L,x,s);b=@(x)R(R(x,S('(.{1,%d}(\\s+|$))',93-L),S('$1\n%*s ',L+1,s)),['\n\s*\',s,' $'],'');c=R(I,['(.*?)\s*\',s,'\s*(.*$)'],'${a($1)} ${b($2)}');d=S('%s\n',c{:});end

प्रोग्राम इनपुट Iको स्ट्रिंग के सेल एरे के रूप में स्वीकार करता है जहां सेल एरे के प्रत्येक तत्व इनपुट की एक अलग लाइन होती है। यह एक दूसरे इनपुट को भी स्वीकार करता है जो बताता है कि टिप्पणी चरित्र (यानी #) क्या है। फ़ंक्शन एक बहु-पंक्ति स्ट्रिंग देता है जो ठीक से स्वरूपित होता है।

संक्षिप्त विवरण

function d = f(I,s)
    %// Setup some shortcuts for commonly-used functions
    S = @sprintf;
    R = @regexprep;

    %// Find the location of the space AFTER each code block but before a comment
    m = regexp(I, ['\s*\',s]);

    %// Compute the maximum column location of the code and add 4 (5 - 1)
    L = max([m{:}]) + 4;

    %// This is a callback for when we detect code
    %// It left justifies and pads the string to L width
    a = @(x)S('%-*s%s', L, x, s);

    %// This is a callback for when we detect a comment.
    b = @(x)R(...
            R(x, ...
                S('(.{1,%d}(\\s|$))', 93 - L), ... Regex for wrapping text to desired width
                S('$1\n%*s ', L+1, s)), ... Append a newline and padding for next line 
            ['\n\s*\',s,' $'], ''); ... Remove the trailing newline (to be improved)

    %// Perform replacement of everything.
    c = R(I, ...
            ['(.*?)\s*\',s,'\s*(.*$)'], ... Match "code comment_char comment"
            '${a($1)} ${b($2)}');   ... Replace using the output of the callbacks

    %// Concatenate all of the strings together with a newline in between
    d=S('%s\n',c{:});
end

उदाहरण इनपुट

I = {
    'shM-crz1dc4."ANDBYOROF  # z = input'
    ''
    '     rz1      # convert input to uppercase'
    '    c   d        # split input on spaces'
    '         c4."ANDBYOROF        # create a list of the words from a packed string which shall be ignored'
    '   -          # filter those words out'
    ' hM                # only take the first letter of all words'
    's                   # join them into one string'
};

disp(f(I,'#'));

उदाहरण आउटपुट

shM-crz1dc4."ANDBYOROF     # z = input

     rz1                   # convert input to uppercase
    c   d                  # split input on spaces
         c4."ANDBYOROF     # create a list of the words from a packed string which shall be
                           # ignored
   -                       # filter those words out
 hM                        # only take the first letter of all words
s                          # join them into one string
— Suever
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.