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

Sepenuhnya dibenarkan berarti selaras di sebelah kiri dan kanan, dan dicapai dengan meningkatkan jarak antara kata-kata sampai setiap baris cocok.

Terkait:

• Ratakan teks dengan menambahkan spasi
• Sejajarkan teks dengan blok
• Dan dengan cara ini dapat dianggap sebagai langkah selanjutnya dalam Pemrosesan Teks # 1: Tanda hubung (yang tampaknya belum pernah diposting).

Memasukkan

Anda dapat mengambil input dalam format apa pun yang Anda suka. Anda akan diberikan:

• Lebar target (dalam karakter), dalam kisaran 5-100 (inklusif);
• Blok teks yang berisi kata-kata yang mungkin ditulis dalam tanda penghubung. Ini bisa berupa string yang dipisahkan spasi, array kata, atau array array fragmen kata (atau representasi data lain yang Anda inginkan).

Input tipikal mungkin:

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

Di mana tanda hubung menunjukkan poin hyphenation yang mungkin, dan spasi menunjukkan batas kata. Kemungkinan representasi alternatif dari teks:

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

Keluaran

Teks input dengan spasi ditambahkan di antara kata-kata, baris baru pada lebar kolom, dan titik tanda hubung dipilih untuk sepenuhnya membenarkannya dengan lebar kolom. Untuk fungsi, array string (satu untuk setiap baris) dapat dikembalikan alih-alih menggunakan pemisahan baris baru.

Output yang mungkin untuk input di atas mungkin:

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

Perhatikan bahwa semua tanda hubung telah dihapus kecuali yang ada di "bus-iness" terakhir, yang disimpan untuk menunjukkan bahwa kata tersebut membungkus ke baris berikutnya, dan dipilih untuk memastikan baris kedua berisi teks sebanyak mungkin.

Aturan

• Dalam setiap baris, jumlah spasi di antara kata-kata tidak dapat berbeda lebih dari 1, tetapi di mana Anda memasukkan spasi tambahan terserah Anda:

  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)
  

• Tidak ada garis yang dapat dimulai atau diakhiri dengan spasi (kecuali baris terakhir, yang dapat diakhiri dengan spasi).

• Baris terakhir harus dibenarkan, berisi spasi tunggal antara setiap kata. Ini dapat diikuti oleh spasi putih / baris baru yang sewenang-wenang jika diinginkan, tetapi ini tidak diperlukan.

• Kata-kata akan terdiri dari AZ, az, 0-9 dan tanda baca sederhana ( .,'()&)

• Anda dapat mengasumsikan bahwa tidak ada fragmen kata yang akan lebih panjang dari lebar target, dan akan selalu memungkinkan untuk mengisi baris sesuai dengan aturan (yaitu akan ada setidaknya 2 fragmen kata pada setiap baris, atau 1 fragmen kata yang mengisi baris sempurna)

• Anda harus memilih titik tanda hubung yang memaksimalkan jumlah karakter kata pada baris sebelumnya (yaitu kata-kata harus dikonsumsi dengan rakus oleh baris), misalnya:

  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.
  

• Kode terpendek dalam byte menang

Contohnya

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

Membawa argumen dalam sintaks currying ( f(width)(text)) dan input teks dalam format array ganda yang dijelaskan dalam tantangan. String dikonversi ke format itu via .split` `.map(a=>a.split`-`)). Juga, baris baru adalah baris baru literal di dalam string template.

Tidak bermain golf dan mengatur ulang

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
}

Idenya di sini adalah untuk melangkah melalui setiap bagian dari seluruh string dan membangun setiap baris satu bagian pada satu waktu. Setelah satu baris selesai, itu menambah jarak kata dari kiri ke kanan sampai semua spasi tambahan ditempatkan.

Cuplikan Tes

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 bytes

Mengambil input sebagai dua baris: Lebar sebagai angka unary pertama dan string kedua.

Saya yakin ini bisa bermain golf lebih banyak tetapi saya sudah membuang terlalu banyak waktu ke dalamnya.

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/

Cobalah online!

Penjelasan

Program ini bekerja dalam dua fase: 1. Membagi, dan 2. Membenarkan. Untuk di bawah ini, anggaplah input kami adalah:

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

Mendirikan

Pertama kita membaca input, memindahkan baris pertama (lebar sebagai angka unary) ke ruang penahanan ( x), kemudian menambahkan baris berikutnya ( N) dan kemudian salinan lebar dari ruang penahanan ( G) ke ruang pola. Sejak Nmeninggalkan kita dengan yang \nkita ganti !@, yang akan kita gunakan sebagai kursor di Tahap 1.

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

Sekarang isi ruang pegang adalah 1111111111111(dan tidak akan berubah untuk selanjutnya) dan ruang pola adalah (dalam format lperintah "cetak jelas" ):

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

Fase 1

Dalam Fase 1, @kursor utama memajukan satu karakter pada satu waktu, dan untuk setiap karakter a 1dihapus dari "penghitung" di akhir ruang pola. Dengan kata lain, @foo\n111$, f@oo\n11$, fo@o\n1$, dll

The !trails kursor di belakang @kursor, menandai tempat kita bisa pecah jika counter mencapai 0 di tengah-tengah baris. Beberapa putaran akan terlihat seperti ini:

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

Di sini ada pola yang kami kenali: spasi segera diikuti oleh @kursor. Karena penghitung lebih besar dari 0, kami memajukan penanda istirahat, lalu terus memajukan kursor utama:

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$

Berikut pola lain:, -@dan kami masih memiliki 7 di penghitung, jadi kami memajukan kursor break lagi dan terus maju:

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

Berikut pola yang berbeda: Tanda hubung segera sebelum kursor istirahat dan lainnya sebelum kursor utama. Kami menghapus tanda hubung pertama, memajukan kursor istirahat, dan, karena kami menghapus karakter, tambahkan 1 ke penghitung.

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

Kami terus memajukan kursor utama:

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

Mirip dengan sebelumnya, tapi kali ini kursor utama mendahului spasi daripada mengikuti tanda hubung. Kami menghapus tanda hubung, tetapi karena kami juga memajukan kursor utama kami tidak menambah tidak ada penurunan penghitung.

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$

Akhirnya, penghitung kami telah mencapai nol. Karena karakter setelah kursor utama adalah spasi, kami menyisipkan baris baru dan meletakkan kedua kursor segera setelahnya. Lalu kami mengisi penghitung ( G) dan mulai lagi.

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

Fase 1 berlanjut, memajukan kursor dan mencocokkan berbagai pola, hingga @kursor mencapai akhir string.

# 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

Pada akhir Fase 1, ruang pola kami terlihat seperti ini:

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

Atau:

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

Fase 2

Dalam Fase 2 kita menggunakan %sebagai kursor dan menggunakan penghitung dengan cara yang sama, dimulai seperti ini:

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

Pertama, kita menghitung karakter pada baris pertama dengan memajukan kursor dan menghapus 1s dari penghitung, setelah itu kita miliki;

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

Karena penghitung adalah 0, kami tidak melakukan hal lain pada baris ini. Baris kedua juga memiliki jumlah karakter yang sama dengan penghitung, jadi mari kita lewati ke baris ketiga:

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

Penghitung lebih besar dari 0, jadi kami memindahkan kursor kembali ke awal baris. Kemudian kita menemukan run spasi pertama dan menambahkan spasi, mengurangi counter.

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

Penghitung lebih besar dari 0; karena kursor sudah berada dalam menjalankan spasi terakhir (satu-satunya) pada baris, kami memindahkannya kembali ke awal baris dan melakukannya lagi:

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

Sekarang penghitungnya adalah 0, jadi kami memindahkan kursor ke awal baris berikutnya. Kami mengulangi ini untuk setiap baris kecuali yang terakhir. Itulah akhir dari fase 2 dan akhir dari program! Hasil akhirnya adalah:

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

Mengambil input sebagai (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)

Cobalah online!

Berkomentar

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}

Cobalah online!

Stax , 51 50 byte

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

Jalankan dan debug itu

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

Cobalah online!

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.