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

Hoàn toàn hợp lý có nghĩa là nó được căn chỉnh ở bên trái và bên phải, và đạt được bằng cách tăng khoảng cách giữa các từ cho đến khi mỗi dòng phù hợp.

Liên quan:

• Xác minh một văn bản bằng cách thêm khoảng trắng
• Căn chỉnh văn bản thành một khối
• Và theo một cách nào đó, đây có thể được coi là bước tiếp theo trong Xử lý văn bản # 1: Dấu gạch nối (dường như chưa bao giờ được đăng).

Đầu vào

Bạn có thể lấy đầu vào ở bất kỳ định dạng nào bạn thích. Bạn sẽ được:

• Độ rộng mục tiêu (tính bằng ký tự), trong phạm vi 5-100 (đã bao gồm);
• Một khối văn bản chứa các từ có thể gạch nối. Đây có thể là một chuỗi được phân tách bằng dấu cách, một mảng các từ hoặc một mảng các mảng của các đoạn từ (hoặc bất kỳ biểu diễn dữ liệu nào khác mà bạn mong muốn).

Một đầu vào điển hình có thể là:

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

Trường hợp dấu gạch nối biểu thị các điểm gạch nối có thể và khoảng trắng biểu thị ranh giới từ. Một đại diện thay thế có thể của văn bản:

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

Đầu ra

Văn bản đầu vào với khoảng trắng được thêm vào giữa các từ, dòng mới ở độ rộng cột và các điểm gạch nối được chọn để chứng minh đầy đủ cho chiều rộng cột. Đối với các hàm, một chuỗi các chuỗi (một cho mỗi dòng) có thể được trả về thay vì sử dụng phân tách dòng mới.

Một đầu ra có thể cho đầu vào trên có thể là:

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

Lưu ý rằng tất cả các dấu gạch nối đã bị xóa ngoại trừ dấu gạch ngang trong "bus-iness" cuối cùng, được giữ để hiển thị rằng từ đó kết thúc với dòng tiếp theo và được chọn để đảm bảo dòng thứ hai chứa càng nhiều văn bản càng tốt.

Quy tắc

• Trong mỗi dòng, số lượng khoảng trắng giữa các từ không thể thay đổi nhiều hơn 1, nhưng nếu bạn chèn thêm khoảng trắng thì tùy thuộc vào bạn:

  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)
  

• Không có dòng nào có thể bắt đầu hoặc kết thúc bằng dấu cách (ngoại trừ dòng cuối cùng, có thể kết thúc bằng dấu cách).

• Dòng cuối cùng phải được để lại hợp lý, chứa khoảng trắng đơn giữa mỗi từ. Nó có thể được theo sau bởi khoảng trắng tùy ý / một dòng mới nếu muốn, nhưng điều này là không bắt buộc.

• Các từ sẽ bao gồm AZ, az, 0-9 và dấu câu đơn giản ( .,'()&)

• Bạn có thể giả định rằng không có đoạn từ nào dài hơn chiều rộng mục tiêu và sẽ luôn có thể điền các dòng theo quy tắc (nghĩa là sẽ có ít nhất 2 đoạn từ trên mỗi dòng hoặc 1 đoạn từ sẽ điền vào dòng hoàn hảo)

• Bạn phải chọn các điểm gạch nối để tối đa hóa số lượng ký tự từ trên các dòng trước đó (nghĩa là các từ phải được tiêu thụ một cách tham lam bởi các dòng), ví dụ:

  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.
  

• Mã ngắn nhất tính bằng byte

Ví dụ

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!

JavaScript (ES6), 218 byte

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

Đưa ra các đối số theo cú pháp currying ( f(width)(text)) và kiểu nhập văn bản ở định dạng mảng kép được mô tả trong thử thách. Chuỗi được chuyển đổi sang định dạng đó thông qua .split` `.map(a=>a.split`-`)). Ngoài ra, các dòng mới là dòng mới theo nghĩa đen bên trong chuỗi mẫu.

Không chơi gôn và sắp xếp lại

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
}

Ý tưởng ở đây là từng bước qua từng phần của toàn bộ chuỗi và xây dựng từng dòng một phần. Khi một dòng hoàn thành, nó sẽ tăng khoảng cách từ từ trái sang phải cho đến khi tất cả các khoảng trắng thừa được đặt.

Kiểm tra đoạn trích

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>

GNU sed -r, 621 byte

Lấy đầu vào là hai dòng: Chiều rộng dưới dạng số đơn đầu tiên và chuỗi thứ hai.

Tôi chắc chắn rằng điều này có thể được chơi golf nhiều hơn nữa nhưng tôi đã bỏ quá nhiều thời gian vào nó.

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/

Hãy thử trực tuyến!

Giải trình

Chương trình hoạt động theo hai giai đoạn: 1. Chia nhỏ và 2. Biện minh. Đối với bên dưới, giả sử đầu vào của chúng tôi là:

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

Thiết lập

Đầu tiên chúng ta đọc đầu vào, di chuyển dòng đầu tiên (chiều rộng dưới dạng số đơn) sang không gian giữ ( x), sau đó nối thêm dòng tiếp theo ( N) và sau đó sao chép chiều rộng từ không gian giữ ( G) vào không gian mẫu. Kể từ khi Nđể lại cho chúng tôi một người dẫn đầu, \nchúng tôi thay thế nó !@, chúng tôi sẽ sử dụng làm con trỏ trong Giai đoạn 1.

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

Bây giờ nội dung của không gian giữ là 1111111111111(và sẽ không thay đổi từ đó) và không gian mẫu là (theo định dạng của lệnh "in rõ ràng" của sed l):

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

Giai đoạn 1

Trong Giai đoạn 1, @con trỏ chính tiến lên một ký tự tại một thời điểm và đối với mỗi ký tự, a 1được xóa khỏi "bộ đếm" ở cuối không gian mẫu. Nói cách khác, @foo\n111$, f@oo\n11$, fo@o\n1$vv

Con !trỏ theo sau @con trỏ, đánh dấu những nơi chúng ta có thể phá vỡ nếu bộ đếm đạt 0 ở giữa dòng. Một vài vòng sẽ như thế này:

!@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$

Ở đây có một mẫu chúng ta nhận ra: một khoảng trắng ngay sau @con trỏ. Vì bộ đếm lớn hơn 0, chúng tôi tiến lên đánh dấu ngắt, sau đó tiếp tục tiến lên con trỏ chính:

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$

Đây là một mẫu khác: -@và chúng tôi vẫn có 7 trong bộ đếm, vì vậy chúng tôi lại tiến con trỏ phá vỡ và tiếp tục tiến lên:

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

Đây là một mẫu khác: Một dấu gạch nối ngay trước con trỏ ngắt và một dấu khác trước con trỏ chính. Chúng tôi xóa dấu gạch nối đầu tiên, tiến con trỏ ngắt và vì chúng tôi đã xóa một ký tự, thêm 1 vào bộ đếm.

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

Chúng tôi tiếp tục tiến lên con trỏ chính:

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

Tương tự như trước, nhưng lần này con trỏ chính đi trước một khoảng trắng thay vì theo dấu gạch nối. Chúng tôi loại bỏ dấu gạch nối, nhưng vì chúng tôi cũng đang tiến lên con trỏ chính, chúng tôi không tăng không giảm bộ đếm.

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$

Cuối cùng, quầy của chúng tôi đã đạt đến không. Vì ký tự sau con trỏ chính là khoảng trắng, chúng tôi chèn một dòng mới và đặt cả hai con trỏ ngay sau nó. Sau đó, chúng tôi bổ sung bộ đếm ( G) và bắt đầu lại.

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

Giai đoạn 1 tiếp tục, tiến tới các con trỏ và khớp các mẫu khác nhau, cho đến khi @con trỏ đến cuối chuỗi.

# 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

Vào cuối Giai đoạn 1, không gian mẫu của chúng ta trông như thế này:

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

Hoặc là:

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

Giai đoạn 2

Trong Giai đoạn 2, chúng tôi sử dụng %như một con trỏ và sử dụng bộ đếm theo cách tương tự, bắt đầu như thế này:

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

Đầu tiên, chúng tôi đếm các ký tự trên dòng đầu tiên bằng cách tiến con trỏ và xóa 1s khỏi bộ đếm, sau đó chúng tôi có;

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

Vì bộ đếm là 0, chúng tôi không làm gì khác trên dòng này. Dòng thứ hai cũng có cùng số lượng ký tự với bộ đếm, vì vậy hãy bỏ qua dòng thứ ba:

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

Bộ đếm lớn hơn 0, vì vậy chúng tôi di chuyển con trỏ trở lại đầu dòng. Sau đó, chúng tôi tìm thấy lần chạy đầu tiên của không gian và thêm một khoảng trắng, giảm dần bộ đếm.

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

Bộ đếm lớn hơn 0; vì con trỏ đã ở trong khoảng trống (chỉ) cuối cùng trên dòng, chúng tôi di chuyển nó trở lại đầu dòng và thực hiện lại:

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

Bây giờ bộ đếm là 0, vì vậy chúng tôi di chuyển con trỏ đến đầu dòng tiếp theo. Chúng tôi lặp lại điều này cho mỗi dòng ngoại trừ cuối cùng. Đó là kết thúc giai đoạn 2 và kết thúc chương trình! Kết quả cuối cùng là:

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/

JavaScript (ES6), 147 byte

Đưa đầu vào là (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)

Hãy thử trực tuyến!

Đã bình luận

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

APL (Dyalog Unicode) , 129 123 121 118 111 109 107 104 100 95 byte ^SBCS

{⊃⌽m←⍺≥-⌿c⍪+\⊢⌿c←' -'∘.≠⍵:⊂⍵/⍨⊢⌿c⋄(⊂∊l⊣l[(⍺-≢l)⍴⍸' '=l],←⊃0⍴l←⍵/⍨n×⊣⌿c⊖⍨1⌽n),⍺∇⍵/⍨~n←⌽∨\⌽m>×⌿c}

Hãy thử trực tuyến!

Stax , 51 50 byte

éS┴k╖♀╡¶┐'▼jÆD╨◙♠ß╒└╧rî{♀EÜ╢a┌ùLiƒ7ÉøΩS╜╪åⁿM◙┴,○9H

Chạy và gỡ lỗi nó

Python 2 , 343 byte

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())

Hãy thử trực tuyến!

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.