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

Entièrement justifié signifie qu'il est aligné à gauche et à droite, et est obtenu en augmentant l'espacement entre les mots jusqu'à ce que chaque ligne s'adapte.

En relation:

• Justifier un texte en ajoutant des espaces
• Aligner le texte sur un bloc
• Et d'une certaine manière, cela peut être considéré comme la prochaine étape du traitement de texte n ° 1: la césure (qui semble n'avoir jamais été publiée).

Contribution

Vous pouvez saisir des informations dans le format de votre choix. Vous recevrez:

• Une largeur cible (en caractères), comprise entre 5 et 100 (inclus);
• Un bloc de texte contenant éventuellement des mots coupés. Cela peut être une chaîne séparée par des espaces, un tableau de mots ou un tableau de tableaux de fragments de mots (ou toute autre représentation de données que vous désirez).

Une entrée typique peut être:

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

Où les tirets indiquent les points de césure possibles et les espaces les limites des mots. Une représentation alternative possible du texte:

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

Sortie

Le texte d'entrée avec des espaces ajoutés entre les mots, les sauts de ligne à la largeur de la colonne et les points de césure choisis pour le justifier pleinement à la largeur de la colonne. Pour les fonctions, un tableau de chaînes (une pour chaque ligne) peut être renvoyé au lieu d'utiliser la séparation de nouvelle ligne.

Une sortie possible pour l'entrée ci-dessus peut être:

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

Notez que tous les tirets ont été supprimés à l'exception de celui dans le dernier "bus-iness", qui est conservé pour montrer que le mot passe à la ligne suivante, et a été choisi pour s'assurer que la deuxième ligne contient autant de texte que possible.

Règles

• À l'intérieur de chaque ligne, le nombre d'espaces entre les mots ne peut pas varier de plus de 1, mais l'endroit où vous insérez les espaces supplémentaires dépend de vous:

  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)
  

• Aucune ligne ne peut commencer ou se terminer par des espaces (sauf la dernière ligne, qui peut se terminer par des espaces).

• La dernière ligne doit être justifiée à gauche, contenant des espaces simples entre chaque mot. Il peut être suivi d'espaces arbitraires / d'une nouvelle ligne si vous le souhaitez, mais ce n'est pas obligatoire.

• Les mots seront constitués de AZ, az, 0-9 et d'une simple ponctuation ( .,'()&)

• Vous pouvez supposer qu'aucun fragment de mot ne sera plus long que la largeur cible, et il sera toujours possible de remplir les lignes selon les règles (c'est-à-dire qu'il y aura au moins 2 fragments de mot sur chaque ligne, ou 1 fragment de mot qui remplit la ligne à la perfection)

• Vous devez choisir des points de césure qui maximisent le nombre de caractères des mots sur les lignes précédentes (c'est-à-dire que les mots doivent être consommés avec gourmandise par les lignes), par exemple:

  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.
  

• Le code le plus court en octets gagne

Exemples

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 octets

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

Prend des arguments dans currying syntax ( f(width)(text)) et l'entrée de texte est au format double tableau décrit dans le défi. Les chaînes sont converties dans ce format via .split` `.map(a=>a.split`-`)). De plus, les sauts de ligne sont des sauts de ligne littéraux dans les chaînes de modèle.

Non golfé et réorganisé

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
}

L'idée ici était de parcourir chaque partie de la chaîne entière et de construire chaque ligne une partie à la fois. Une fois la ligne terminée, elle augmente l'espacement des mots de gauche à droite jusqu'à ce que tous les espaces supplémentaires soient placés.

Extrait de test

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 octets

Prend la saisie sur deux lignes: la largeur sous forme de nombre unaire en premier et la chaîne en second.

Je suis certain que cela pourrait être joué beaucoup plus, mais j'ai déjà jeté trop de temps dessus.

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/

Essayez-le en ligne!

Explication

Le programme fonctionne en deux phases: 1. Diviser et 2. Justifier. Pour ce qui suit, supposons que notre entrée soit:

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

Installer

Nous lisons d'abord l'entrée, en déplaçant la première ligne (la largeur sous la forme d'un nombre unaire) vers l'espace d'attente ( x), puis en ajoutant la ligne suivante ( N), puis une copie de la largeur de l'espace d'attente ( G) à l'espace de motif. Depuis que Nnous avons laissé un leader, \nnous le remplaçons par !@, que nous utiliserons comme curseurs dans la phase 1.

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

Maintenant, le contenu de l'espace d'attente est 1111111111111(et ne changera plus désormais) et l'espace du motif est (au format de la commande "imprimer sans ambiguïté" de sed l):

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

La phase 1

Dans la phase 1, le @curseur principal avance d'un caractère à la fois et pour chaque caractère, a 1est supprimé du "compteur" à la fin de l'espace de motif. En d' autres termes, @foo\n111$, f@oo\n11$, fo@o\n1$, etc.

Le !curseur suit derrière le @curseur, marquant les endroits que nous pourrions casser si le compteur atteint 0 au milieu de la ligne. Quelques tours ressembleraient à ceci:

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

Ici, il y a un motif que nous reconnaissons: un espace immédiatement suivi par le @curseur. Puisque le compteur est supérieur à 0, nous avançons le marqueur de rupture, puis continuons à avancer le curseur principal:

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$

Voici un autre schéma:, -@et nous avons encore 7 dans le compteur, nous avançons à nouveau le curseur de pause et continuons d'avancer:

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

Voici un modèle différent: un trait d'union précédant immédiatement le curseur de rupture et un autre précédant le curseur principal. Nous supprimons le premier tiret, avançons le curseur de rupture et, puisque nous avons supprimé un caractère, ajoutons 1 au compteur.

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

Nous continuons à avancer le curseur principal:

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

Similaire à avant, mais cette fois le curseur principal précède un espace plutôt que de suivre un trait d'union. Nous supprimons le trait d'union, mais comme nous avançons également le curseur principal, nous n'augmentons ni ne décrémentons le compteur.

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$

Enfin, notre compteur a atteint zéro. Puisque le caractère après le curseur principal est un espace, nous insérons une nouvelle ligne et mettons les deux curseurs immédiatement après. Ensuite, nous réapprovisionnons le compteur ( G) et recommençons.

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

La phase 1 continue, faisant avancer les curseurs et faisant correspondre différents motifs, jusqu'à ce que le @curseur atteigne la fin de la chaîne.

# 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

À la fin de la phase 1, notre espace de modèle ressemble à ceci:

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

Ou:

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

Phase 2

Dans la phase 2, nous utilisons %comme curseur et utilisons le compteur de la même manière, en commençant comme ceci:

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

Tout d'abord, nous comptons les caractères sur la première ligne en avançant le curseur et en supprimant 1s du compteur, après quoi nous avons;

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

Puisque le compteur est 0, nous ne faisons rien d'autre sur cette ligne. La deuxième ligne a également le même nombre de caractères que le compteur, alors passons à la troisième ligne:

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

Le compteur est supérieur à 0, nous replaçons donc le curseur au début de la ligne. Ensuite, nous trouvons la première série d'espaces et ajoutons un espace, décrémentant le compteur.

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

Le compteur est supérieur à 0; puisque le curseur est déjà dans la dernière (seule) série d'espaces sur la ligne, nous le replaçons au début de la ligne et le faisons à nouveau:

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

Maintenant, le compteur est 0, nous déplaçons donc le curseur au début de la ligne suivante. Nous répétons cela pour chaque ligne sauf la dernière. C'est la fin de la phase 2 et la fin du programme! Le résultat final est:

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 octets

Prend l'entrée comme (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)

Essayez-le en ligne!

Commenté

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 octets ^SBCS

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

Essayez-le en ligne!

Stax , 51 50 octets

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

Exécuter et déboguer

Python 2 , 343 octets

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

Essayez-le en ligne!

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.