पाठ के एक ब्लॉक को पूरी तरह से औचित्यपूर्ण और सक्रिय करें


26
Given  a width  and  a block  of
text containing possible hyphen-
ation points,  format it  fully-
justified (in monospace).

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

सम्बंधित:

इनपुट

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

  • 5-100 (समावेशी) श्रेणी में एक लक्ष्य चौड़ाई (वर्णों में);
  • संभवतः हाइफ़न शब्दों वाले पाठ का एक ब्लॉक। यह एक अंतरिक्ष-पृथक स्ट्रिंग, शब्दों की एक सरणी, या शब्द टुकड़े के सरणियों का एक सरणी (या किसी अन्य डेटा प्रतिनिधित्व इच्छा) हो सकता है।

एक विशिष्ट इनपुट हो सकता है:

Width: 25
Text:  There's no bu-si-ne-ss lik-e s-h-o-w busine-ss, n-o bus-iness I know.

जहां हाइफ़न संभव हाइफ़नेशन बिंदुओं को दर्शाते हैं, और रिक्त स्थान शब्द सीमाओं को दर्शाते हैं। पाठ का एक संभावित वैकल्पिक प्रतिनिधित्व:

[["There's"], ["no"], ["bu", "si", "ne", "ss"], ["lik", "e"], (etc.)]

उत्पादन

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

उपरोक्त इनपुट के लिए एक संभावित आउटपुट हो सकता है:

There's no  business like
show  business,  no  bus-
iness I know.

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

नियम

  • प्रत्येक पंक्ति के भीतर, शब्दों के बीच रिक्त स्थान की संख्या 1 से अधिक नहीं हो सकती है, लेकिन जहां आप अतिरिक्त स्थान सम्मिलित करते हैं, अन्यथा आपके ऊपर है:

    hello hi foo     bar    <-- not permitted (1,1,5)
    hello  hi foo    bar    <-- not permitted (2,1,4)
    hello  hi  foo   bar    <-- OK (2,2,3)
    hello  hi   foo  bar    <-- OK (2,3,2)
    hello   hi  foo  bar    <-- OK (3,2,2)
    
  • कोई भी रेखा रिक्त स्थान के साथ शुरू या समाप्त नहीं हो सकती है (अंतिम पंक्ति को छोड़कर, जो रिक्त स्थान के साथ समाप्त हो सकती है)।

  • अंतिम पंक्ति को उचित छोड़ा जाना चाहिए, जिसमें प्रत्येक शब्द के बीच एकल रिक्त स्थान हो। यदि वांछित हो तो मनमाने ढंग से व्हाट्सएप / एक नई पंक्ति का पालन किया जा सकता है, लेकिन इसकी आवश्यकता नहीं है।

  • शब्दों में AZ, az, 0-9 और सरल विराम चिह्न शामिल होंगे ( .,'()&)

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

  • उदाहरण के लिए, आपको हाइफ़नेशन पॉइंट चुनना होगा जो कि पहले की लाइनों पर शब्द वर्णों की संख्या को अधिकतम करता है (यानी शब्दों का लालच से उपभोग किया जाना चाहिए):

    This is an input stri-ng with hyph-en-at-ion poi-nts.
    
    This     is     an     input    stri-      <-- not permitted
    ng with hyphenation points.
    
    This  is an  input string  with hyph-      <-- not permitted
    enation points.
    
    This is an input  string with hyphen-      <-- OK
    ation points.
    
  • बाइट्स में सबसे छोटा कोड जीतता है

उदाहरण

Width: 20
Text:  The q-uick brown fox ju-mp-s ove-r t-h-e lazy dog.

The quick  brown fox
jumps over the  lazy
dog.

Width: 32
Text: Given a width and a block of text cont-ain-ing pos-sible hyphen-ation points, for-mat it ful-ly-just-ified (in mono-space).

Given  a width  and  a block  of
text containing possible hyphen-
ation points,  format it  fully-
justified (in monospace).

Width: 80
Text:  Pro-gram-ming Puz-zles & Code Golf is a ques-tion and ans-wer site for pro-gram-ming puz-zle enth-usi-asts and code golf-ers. It's built and run by you as part of the St-ack Exch-ange net-work of Q&A sites. With your help, we're work-ing to-g-et-her to build a lib-rary of pro-gram-ming puz-zles and their sol-ut-ions.

Programming Puzzles &  Code Golf  is a question and answer  site for programming
puzzle enthusiasts  and code golfers.  It's built and run  by you as part of the
Stack Exchange network  of Q&A sites. With your help,  we're working together to
build a library of programming puzzles and their solutions.

Width: 20
Text:  Pro-gram-ming Puz-zles & Code Golf is a ques-tion and ans-wer site for pro-gram-ming puz-zle enth-usi-asts and code golf-ers. It's built and run by you as part of the St-ack Exch-ange net-work of Q&A sites. With your help, we're work-ing to-g-et-her to build a lib-rary of pro-gram-ming puz-zles and their sol-ut-ions.

Programming  Puzzles
&  Code  Golf  is  a
question and  answer
site for programming
puzzle   enthusiasts
and  code   golfers.
It's  built  and run
by  you  as  part of
the  Stack  Exchange
network    of    Q&A
sites.   With   your
help,  we're working
together to  build a
library of  program-
ming   puzzles   and
their solutions.

Width: 5
Text:  a b c d e f g h i j k l mm nn oo p-p qq rr ss t u vv ww x yy z

a b c
d e f
g h i
j k l
mm nn
oo pp
qq rr
ss  t
u  vv
ww  x
yy z

Width: 10
Text:  It's the bl-ack be-ast of Araghhhhh-hhh-h-hhh-h-h-h-hh!

It's   the
black  be-
ast     of
Araghhhhh-
hhhhhhhhh-
hhh!

अंत में, एक और (पाठ-आधारित) टाइपोग्राफी चुनौती :-)
ETHproductions

1
@ बिल्डरों के लिए हाँ: कोई कोड प्रतिबंध नहीं है, और सबसे कम कोड जीतता है। हालांकि, यह एक उबाऊ जवाब के लिए कर सकता है! पुस्तकालयों के लिए, आप तब तक हो सकते हैं जब तक पुस्तकालय स्वतंत्र रूप से उपलब्ध है और आप अपने उत्तर को "भाषा + पुस्तकालय" के रूप में चिह्नित करते हैं। इसके अलावा लाइब्रेरी संस्करण को इस चुनौती को पूर्व-तिथि करना होगा।
डेव

1
इस घटना में कि एक लाइन या तो एक हाइफ़न या एकल वर्ण के साथ समाप्त anybod-yहो सकती है , जैसे कि चौड़ाई 7 के साथ, क्या हम anybodyया तो आउटपुट चुन सकते हैं या anybod-\ny?
darrylyeo

1
@JonathanAllan हाँ; क्षमा करें, मैं इसे ठीक करूँगा
डेव

3
@darrylyeo नहीं, आपको उस मामले में पूर्ण शब्द का उत्पादन करना होगा, क्योंकि यह प्रत्येक पंक्ति में यथासंभव लाल वर्ण के रूप में होना चाहिए।
दवे

जवाबों:


7

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

w=>s=>s.map((c,i)=>c.map((p,j)=>(k+p)[l="length"]-w-(b=!i|j>0)+(j<c[l]-1)<0?k+=b?p:" "+p:(Array(w-k[l]-b).fill(h=k.split` `).map((_,i)=>h[i%(h[l]-1)]+=" "),o.push(h.join` `+(b?"-":"")),k=p)),o=[],k="")&&o.join`
`+`
`+k

f(width)(text)चुनौती में वर्णित दोहरे सरणी प्रारूप में पाठ वाक्यविन्यास ( ) और पाठ इनपुट में तर्क देता है । स्ट्रिंग्स को उस प्रारूप में बदल दिया जाता है.split` `.map(a=>a.split`-`)) । इसके अलावा, newlines टेम्पलेट स्ट्रिंग्स के अंदर शाब्दिक newlines हैं।

गैर-गोल्फ और पुनर्व्यवस्थित

width=>string=> {
    out=[];
    line="";
    string.map((word,i)=> {
        word.map((part,j)=> {

            noSpaceBefore = i==0 || j>0;
            if ((line+part).length - width - noSpaceBefore + (j<word.length-1) < 0) {
                line += noSpaceBefore ? part : " "+part;
            }
            else {
                words=line.split` `;
                Array(width - line.length - noSpaceBefore).fill()
                    .map((_,i) => words[i % (words.length-1)] += " ");
                out.push(words.join(" ") + (noSpaceBefore? "-" : ""));
                line=part;
            }
        });
    });
    return out.join("\n") + "\n"+line
}

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

टेस्ट स्निपेट

f=
w=>s=>s.map((c,i)=>c.map((p,j)=>(k+p)[l="length"]-w-(b=!i|j>0)+(j<c[l]-1)<0?k+=b?p:" "+p:(Array(w-k[l]-b).fill(h=k.split` `).map((_,i)=>h[i%(h[l]-1)]+=" "),o.push(h.join` `+(b?"-":"")),k=p)),o=[],k="")&&o.join`
`+`
`+k
<style>*{font-family:Consolas,monospace;}</style>
<div oninput="O.innerHTML=f(+W.value)(S.value.split` `.map(a=>a.split`-`))">
Width: <input type="number" size="3" min="5" max="100" id="W">
Tests: <select id="T" style="width:20em" oninput="let x=T.value.indexOf(','),s=T.value;W.value=s.slice(0,x);S.value=s.slice(x+2)"><option></option><option>20, The q-uick brown fox ju-mp-s ove-r t-h-e lazy dog.</option><option>32, Given a width and a block of text cont-ain-ing pos-sible hyphen-ation points, for-mat it ful-ly-just-ified (in mono-space).</option><option>80, Pro-gram-ming Puz-zles & Code Golf is a ques-tion and ans-wer site for pro-gram-ming puz-zle enth-usi-asts and code golf-ers. It's built and run by you as part of the St-ack Exch-ange net-work of Q&A sites. With your help, we're work-ing to-g-et-her to build a lib-rary of pro-gram-ming puz-zles and their sol-ut-ions.</option><option>20, Pro-gram-ming Puz-zles & Code Golf is a ques-tion and ans-wer site for pro-gram-ming puz-zle enth-usi-asts and code golf-ers. It's built and run by you as part of the St-ack Exch-ange net-work of Q&A sites. With your help, we're work-ing to-g-et-her to build a lib-rary of pro-gram-ming puz-zles and their sol-ut-ions.</option><option>5, a b c d e f g h i j k l mm nn oo p-p qq rr ss t u vv ww x yy z</option><option>10, It's the bl-ack be-ast of Araghhhhh-hhh-h-hhh-h-h-h-hh</option></select><br>
Text: &nbsp;<textarea id="S" cols="55" rows="4"></textarea>
</div>
<pre id="O" style="border: 1px solid black;display:inline-block;"></pre>


8

GNU sed -r , 621 बाइट्स

इनपुट को दो लाइनों के रूप में लेता है: एक यूनेरी नंबर के रूप में चौड़ाई और दूसरी स्ट्रिंग।

मुझे यकीन है कि यह बहुत अधिक गोल्फ हो सकता है, लेकिन मैं पहले से ही इसमें बहुत अधिक समय डंप कर चुका हूं।

x;N
G
s/\n/!@/
:
/@\n/bZ
s/-!(.*)@ /\1 !@/
s/!(.*[- ])(@.*1)$/\1!\2/
s/@(.)(.*)1$/\1@\2/
s/-!(.*-)(@.*)\n$/\1!\2\n1/
s/(\n!@) /\1/
s/-!(.* )(@.*)\n$/\1!\2\n1/
s/-!(.*-)(@.*1)$/\1!\21/
s/!(.*)-@([^ ]) /\1\2!@ /
t
s/ !@(.*)\n$/\n!@\1#/
s/!(.*-)@(.*)\n$/\1\n!@\2#/
s/!(.*)(@ | @)(.*)\n$/\1\n!@\3#/
s/-!(.*[^-])@([^ ]) (.*)\n$/\1\2\n!@\3#/
s/!(.+)@([^ ].*)\n$/\n!@\1\2#/
/#|!@.*\n$/{s/#|\n$//;G;b}
:Z
s/-?!|@.*//g
s/ \n/\n/g
s/^/%/
:B
G
/%.*\n.+\n/!bQ
:C
s/%([^\n])(.*)1$/\1%\2/
tC
s/([^\n]+)%\n/%\1\n/
:D
s/%([^ \n]* )(.*)1$/\1 %\2/
tD
s/(^|\n)([^\n]+)%(.*1)$/\1%\2\3/
tD
s/%([^\n]*)\n(.*)\n$/\1\n%\2/
tB
:Q
s/%(.*)\n1*$/\1/

इसे ऑनलाइन आज़माएं!

व्याख्या

कार्यक्रम दो चरणों में काम करता है: 1. विभाजन, और 2. औचित्य। नीचे के लिए, मान लें कि हमारा इनपुट है:

111111111111
I re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.

सेट अप

पहले हम इनपुट को पढ़ते हैं, पहली पंक्ति (एक यूनिरी नंबर के रूप में चौड़ाई) को होल्ड स्पेस ( x) में ले जाते हैं, फिर अगली पंक्ति ( N) और फिर होल्ड स्पेस ( G) से पैटर्न स्पेस में चौड़ाई की एक प्रति जोड़ते हैं। चूँकि Nहमें एक अग्रणी के साथ छोड़ दिया , जिसे हम \nइसके साथ प्रतिस्थापित करते हैं !@, जिसे हम चरण 1 में कर्सर के रूप में उपयोग करेंगे।

x;N
G
s/\n/!@/

अब होल्ड स्पेस की सामग्री है 1111111111111(और उसके बाद नहीं बदलेगी) और पैटर्न स्पेस है (sed के "प्रिंट अनंबिगली" lकमांड के प्रारूप में ):

!@I re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n111111111111$

चरण 1

चरण 1 में, मुख्य @कर्सर एक समय में एक चरित्र को आगे बढ़ाता है, और प्रत्येक वर्ण 1के लिए पैटर्न स्पेस के अंत में "काउंटर" से हटा दिया जाता है। दूसरे शब्दों @foo\n111$में f@oo\n11$,fo@o\n1$ , आदि

यदि !कर्सर @लाइन के मध्य में 0 तक पहुँच जाता है, तो कर्सर पीछे के निशान को हटा देता है। कुछ राउंड इस तरह दिखेंगे:

!@I re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n111111111111$
!I@ re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n11111111111$
!I @re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n1111111111$

यहां एक पैटर्न है जिसे हम पहचानते हैं: @कर्सर द्वारा तुरंत एक स्थान । चूंकि काउंटर 0 से अधिक है, हम ब्रेक मार्कर को आगे बढ़ाते हैं, फिर मुख्य कर्सर को आगे बढ़ाते रहें:

I !@re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n1111111111$
I !r@e-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n111111111$
I !re@-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n11111111$
I !re-@mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n1111111$

यहां एक और पैटर्न दिया गया है: -@और हमारे पास अभी भी काउंटर में 7 हैं, इसलिए हम ब्रेक कर्सर को फिर से आगे बढ़ाते हैं और आगे बढ़ते रहते हैं:

I re-!mem-@ber a time of cha-os, ru-ined dreams, this was-ted land.\n111$

यहां एक अलग पैटर्न है: एक हाइफ़न तुरंत ब्रेक कर्सर से पहले और दूसरा मुख्य कर्सर से पहले। हम पहले हाइफ़न को हटाते हैं, ब्रेक कर्सर को आगे बढ़ाते हैं, और, चूंकि हमने एक वर्ण हटा दिया है, काउंटर पर 1 जोड़ें।

I remem-!@ber a time of cha-os, ru-ined dreams, this was-ted land.\n1111$

हम मुख्य कर्सर को आगे बढ़ाते रहते हैं:

I remem-!ber@ a time of cha-os, ru-ined dreams, this was-ted land.\n1$

पहले जैसा ही है, लेकिन इस बार मुख्य कर्सर एक हाइफ़न का अनुसरण करने के बजाय एक स्थान से पहले है। हम हाइफ़न को हटा देते हैं, लेकिन जब से हम मुख्य कर्सर को आगे बढ़ा रहे हैं, हम न तो वेतन वृद्धि को बढ़ाते हैं और न ही काउंटर को बढ़ाते हैं।

I remember !@a time of cha-os, ru-ined dreams, this was-ted land.\n1$
I remember !a@ time of cha-os, ru-ined dreams, this was-ted land.\n$

अंत में, हमारा काउंटर शून्य तक पहुँच गया है। चूंकि मुख्य कर्सर के बाद का चरित्र एक स्थान है, हम एक नई पंक्ति सम्मिलित करते हैं और इसके तुरंत बाद दोनों कर्सर डालते हैं। फिर हम काउंटर ( G) को फिर से शुरू करते हैं और फिर से शुरू करते हैं।

I remember a\n!@ time of cha-os, ru-ined dreams, this was-ted land.\n111111111111$

चरण 1 जारी है, कर्सर को आगे बढ़ाने और विभिन्न पैटर्न से मेल खाते हुए, जब तक कि @कर्सर स्ट्रिंग के अंत तक नहीं पहुंचता।

# Phase 1
:
  # End of string; branch to :Z (end of phase 1)
  /@\n/bZ

  # Match -!.*@_
  s/-!(.*)@ /\1 !@/

  # Match [-_]@ and >0
  s/!(.*[- ])(@.*1)$/\1!\2/

  # Advance cursor
  s/@(.)(.*)1$/\1@\2/

  # Match -!.*-@ and 0; add 1
  s/-!(.*-)(@.*)\n$/\1!\2\n1/

  # Match \n!@_
  s/(\n!@) /\1/

  # Match -!.*_@ and 0; add 1
  s/-!(.* )(@.*)\n$/\1!\2\n1/

  # Match -!.*-@ and >0; add 1
  s/-!(.*-)(@.*1)$/\1!\21/

  # Match -@[^_]_
  s/!(.*)-@([^ ]) /\1\2!@ /

  # If there were any matches, branch to `:`
  t

  # Match _!@ and 0
  s/ !@(.*)\n$/\n!@\1#/

  # Match -@ and 0
  s/!(.*-)@(.*)\n$/\1\n!@\2#/

  # Match @_|_@ and 0
  s/!(.*)(@ | @)(.*)\n$/\1\n!@\3#/

  # Match -!.*[^-]@[^_]_ and 0
  s/-!(.*[^-])@([^ ]) (.*)\n$/\1\2\n!@\3#/

  # Match !.+@[^_] and 0
  s/!(.+)@([^ ].*)\n$/\n!@\1\2#/

  # Match marked line (#) or !@ and 0
  /#|!@.*\n$/{
    # Remove mark; append width and branch to `:`
    s/#|\n$//
    G
    b
  }

:Z

# Cleanup
s/-?!|@.*//g
s/ \n/\n/g

चरण 1 के अंत में, हमारा पैटर्न स्थान इस तरह दिखता है:

I remember a\ntime of cha-\nos, ruined\ndreams, this\nwasted land.

या:

I remember a
time of cha-
os, ruined
dreams, this
wasted land.

2 चरण

चरण 2 में हम %एक कर्सर के रूप में उपयोग करते हैं और इस तरह से शुरुआत करते हुए काउंटर का उपयोग करते हैं:

%I remember a\ntime of cha-\nos, ruined\ndreams, this\nwasted land.\n111111111111$

सबसे पहले, हम कर्सर को आगे बढ़ाते हुए और काउंटर से 1s को हटाकर पहली पंक्ति में वर्णों की गणना करते हैं, जिसके बाद हमारे पास है;

I remember a%\ntime of cha-\nos, ruined\ndreams, this\nwasted land.\n$

चूंकि काउंटर 0 है, हम इस लाइन पर और कुछ नहीं करते हैं। दूसरी पंक्ति में भी काउंटर के समान वर्ण हैं, इसलिए तीसरी पंक्ति पर जाएं:

I remember a\ntime of cha-\nos, ruined%\ndreams, this\nwasted land.\n11$

काउंटर 0 से अधिक है, इसलिए हम कर्सर को लाइन की शुरुआत में वापस ले जाते हैं। तब हम रिक्त स्थान का पहला रन पाते हैं और काउंटर को घटाते हुए एक स्थान जोड़ते हैं।

I remember a\ntime of cha-\nos, % ruined\ndreams, this\nwasted land.\n1$

काउंटर 0 से अधिक है; चूँकि लाइन पर कर्सर पहले से ही (केवल) रिक्त स्थान पर चलता है, हम इसे लाइन की शुरुआत में वापस ले जाते हैं और इसे करते हैं:

I remember a\ntime of cha-\nos,  % ruined\ndreams, this\nwasted land.\n$

अब काउंटर 0 है, इसलिए हम कर्सर को अगली पंक्ति की शुरुआत में ले जाते हैं। हम अंतिम को छोड़कर हर पंक्ति के लिए इसे दोहराते हैं। यह चरण 2 का अंत और कार्यक्रम का अंत है! अंतिम परिणाम है:

I remember a
time of cha-
os,   ruined
dreams, this
wasted land.
# Phase 2
# Insert cursor
s/^/%/
:B
  # Append counter from hold space
  G
  # This is the last line; branch to :Q (end of phase 1)
  /%.*\n.+\n/!bQ

  :C
    # Count characters
    s/%([^\n])(.*)1$/\1%\2/
    tC

  # Move cursor to beginning of line
  s/([^\n]+)%\n/%\1\n/

  :D
    # Add one to each space on the line as long as counter is >0
    s/%([^ \n]* )(.*)1$/\1 %\2/
    tD

    # Counter is still >0; go back to beginning of line
    s/(^|\n)([^\n]+)%(.*1)$/\1%\2\3/
    tD

    # Counter is 0; move cursor to next line and branch to :B
    s/%([^\n]*)\n(.*)\n$/\1\n%\2/
    tB

:Q

# Remove cursor, any remaining 1s
s/%(.*)\n1*$/\1/

यह अविश्वसनीय है, लेकिन जब मैं इसका उपयोग करता gsed (GNU sed) 4.4हूं तो मुझे मिलता है gsed: -e expression #1, char 16: ":" lacks a label। क्या आप वास्तव में यह नोट कर सकते हैं कि आप इसे कैसे लागू कर रहे हैं? (मैं उपयोग कर रहा हूँ printf "%s\n%s" "$1" "$2" | gsed -r '<code here>';)
डेव

@Dave जो मेरे लिए GNU sed 4.2 में काम करता है। यहाँ एक जिस्ट है : gist.github.com/jrunning/91a7584d95fe10ef6b036d1c82bd385c ध्यान दें कि TiO का सेड पेज -rझंडे का सम्मान नहीं करता है , यही कारण है कि ऊपर TiO लिंक बैश पेज पर जाता है।
जॉर्डन

आह, मैं तिवारी लिंक पर ध्यान नहीं दिया था। वह मेरे लिए करेंगे; एक +1 है! अंतिम उदाहरण पर 2 छोटी गलतियाँ हैं ("ब्लैक बीस्ट" एक): यह दूसरी से आखिरी पंक्ति के एक वर्ण को छोटा करता है, और अंतिम को याद करता है !(हालांकि जब से मैं !संभावित विशेष पात्रों की सूची से चूक गया, मैं कि इसके खिलाफ नहीं होगा)।
दवे

5

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

के रूप में इनपुट लेता है (width)(text)

w=>F=(s,p=S=' ')=>(g=([c,...b],o='',h=c=='-')=>c?o[w-1]?c==S&&o+`
`+F(b):o[w+~h]?o+c+`
`+F(b):c>S?g(b,h?o:o+c):g(b,o+p)||g(b,o+p+c):o)(s)||F(s,p+S)

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

w =>                              // w = requested width
  F = (                           // F is a recursive function taking:
    s,                            //   s = either the input string (first iteration) or an
                                  //       array of remaining characters (next iterations)
    p =                           //   p = current space padding
    S = ' '                       //   S = space character
  ) => (                          //
    g = (                         // g is a recursive function taking:
      [c,                         //   c   = next character
          ...b],                  //   b[] = array of remaining characters
      o = '',                     //   o   = output for the current line
      h = c == '-'                //   h   = flag set if c is a hyphen
    ) =>                          //
      c ?                         // if c is defined:
        o[w - 1] ?                //   if the line is full:
          c == S &&               //     fail if c is not a space
          o + `\n` + F(b)         //     otherwise, append o + a linefeed and process the
                                  //     next line
        :                         //   else:
          o[w + ~h] ?             //     if this is the last character and c is a hyphen:
            o + c + `\n` + F(b)   //       append o + c + a linefeed and process the next
                                  //       line
          :                       //     else, we process the next character:
            c > S ?               //       if c is not a space:
              g(b, h ? o : o + c) //         append c if it's not a hyphen
            :                     //       else:
              g(b, o + p) ||      //         append either the current space padding
              g(b, o + p + c)     //         or the current padding and one extra space
      :                           // else:
        o                         //   success: return o
  )(s)                            // initial call to g() with s
  || F(s, p + S)                  // in case of failure, try again with a larger padding



1

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

W,T=input()
T+=' '
L,l=[],len
while T:
 p,r=0,''
 for i in range(l(T)):
  s=T[:i].replace('-','')
  if'-'==T[i]:s+='-'
  if T[i]in' -'and W-l(s)>=0:p,r=i,s
 R=r.split()
 if R:
  d,k=W-l(''.join(R)),0
  for j in range(d):
   R[k]+=' '
   k+=1
   if k==l(R)-1:k=0
  L+=[''.join(R)]
  T=T[p+1:]
print'\n'.join(L[:-1])
print' '.join(L[-1].split())

इसे ऑनलाइन आज़माएं!

The  input  is a block of text
containing possibly hyphenated
words.  For  each space/hyphen
position  p  the code computes
l(p)  the  length  of the line
induced  by  slipping the text
to this space/hyphen. Then the
code choses the position p for
which  the  length l(p) is the
closest  to  the given width W
(and  l(p)<=W).  If l(p)<W the
code  adds spaces  fairly  in-
between  the  words to achieve
the length W.

हालांकि इनपुट आपको किसी भी प्रारूप में पसंद हो सकता है, यह अभी भी एसटीडीआईएन या मापदंडों से आना चाहिए। I / O के लिए डिफ़ॉल्ट देखें । हम आम तौर पर "इनपुट" को पूर्व नियत चर से नहीं होने देते हैं।
mbomb007

आप print'\n'.join(L[:-1])for e in L[:-1]:print e
mbomb007

@ mbomb007 ठीक है हाँ मैं I / O का सम्मान करने के लिए आवश्यक बदलाव करूँगा
mdahmoune
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.