Begründen und trennen Sie einen Textblock vollständig

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

Vollständig ausgerichtet bedeutet, dass es links und rechts ausgerichtet ist und durch Vergrößern des Abstands zwischen Wörtern erreicht wird, bis jede Zeile passt.

Verbunden:

Eingang

Sie können Eingaben in jedem beliebigen Format vornehmen. Sie erhalten:

  • Eine Zielbreite (in Zeichen) im Bereich von 5 bis einschließlich 100;
  • Ein Textblock, der möglicherweise getrennte Wörter enthält. Dies kann eine durch Leerzeichen getrennte Zeichenfolge, ein Array von Wörtern oder ein Array von Arrays von Wortfragmenten (oder jede andere von Ihnen gewünschte Datendarstellung) sein.

Eine typische Eingabe könnte sein:

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

Wo die Bindestriche mögliche Trennungspunkte und die Leerzeichen Wortgrenzen bezeichnen. Eine mögliche alternative Darstellung des Textes:

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

Ausgabe

Der Eingabetext mit Leerzeichen zwischen Wörtern, Zeilenumbrüchen an der Spaltenbreite und Trennungspunkten, die ausgewählt wurden, um ihn vollständig an der Spaltenbreite auszurichten. Für Funktionen kann ein Array von Zeichenfolgen (eine für jede Zeile) zurückgegeben werden, anstatt die Zeilenumbruchtrennung zu verwenden.

Eine mögliche Ausgabe für die obige Eingabe könnte sein:

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

Beachten Sie, dass alle Bindestriche entfernt wurden, mit Ausnahme der in der letzten "Bus-Iness", die beibehalten wird, um anzuzeigen, dass das Wort in die nächste Zeile umgebrochen wird, und ausgewählt wurde, um sicherzustellen, dass die zweite Zeile so viel Text wie möglich enthält.

Regeln

  • Innerhalb jeder Zeile darf die Anzahl der Leerzeichen zwischen Wörtern nicht mehr als 1 betragen. Ansonsten liegt es an Ihnen, wo Sie die zusätzlichen Leerzeichen einfügen:

    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)
    
  • Keine Zeile darf mit Leerzeichen beginnen oder enden (mit Ausnahme der letzten Zeile, die mit Leerzeichen enden darf).

  • Die letzte Zeile sollte mit einem Leerzeichen zwischen den einzelnen Wörtern ausgerichtet bleiben. Auf Wunsch kann ein beliebiges Leerzeichen / eine neue Zeile folgen, dies ist jedoch nicht erforderlich.

  • Wörter bestehen aus AZ, az, 0-9 und einfacher Interpunktion ( .,'()&)

  • Sie können davon ausgehen, dass kein Wortfragment länger als die Zielbreite ist und dass es immer möglich ist, Zeilen gemäß den Regeln zu füllen (dh, auf jeder Zeile befinden sich mindestens 2 Wortfragmente oder 1 Wortfragment, das die Zeile ausfüllt perfekt)

  • Sie müssen Silbentrennzeichen auswählen, die die Anzahl der Wortzeichen in früheren Zeilen maximieren (dh Wörter müssen gierig von Zeilen konsumiert werden), zum Beispiel:

    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.
    
  • Kürzester Code in Bytes gewinnt

Beispiele

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!
Dave
quelle
Ja, endlich wieder eine (textbasierte) Typografie- Herausforderung :-)
ETHproductions
1
@Adám ja zu builtins: es gibt keine Code-Einschränkungen und kürzester Code gewinnt. Natürlich könnte dies eine langweilige Antwort sein! Bei Bibliotheken können Sie, solange die Bibliothek frei verfügbar ist, Ihre Antwort als "Sprache + Bibliothek" markieren. Auch die Bibliotheksversion muss diese Herausforderung vorwegnehmen.
Dave
1
Falls eine Zeile mit einem Bindestrich oder einem einzelnen Zeichen enden kann, z. B. anybod-ymit der Breite 7, können wir entweder anybodyoder ausgeben anybod-\ny?
darrylyeo
1
@ JonathanAllan ja; Entschuldigung, ich werde das beheben
Dave
3
@darrylyeo nein, in diesem Fall müssen Sie das vollständige Wort ausgeben, da es gierig so viele Wortzeichen wie möglich in jeder Zeile enthalten muss.
Dave

Antworten:

7

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

Übernimmt Argumente in currying syntax ( f(width)(text)) und die Texteingabe erfolgt in dem in der Challenge beschriebenen Double-Array-Format. Strings werden über in dieses Format konvertiert .split` `.map(a=>a.split`-`)). Außerdem sind die Zeilenumbrüche wörtliche Zeilenumbrüche in Vorlagenzeichenfolgen.

Ungespielt und neu arrangiert

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
}

Die Idee dabei war, jeden Teil der gesamten Saite zu durchlaufen und jede Zeile einzeln aufzubauen. Sobald eine Zeile vollständig ist, wird der Wortabstand von links nach rechts vergrößert, bis alle zusätzlichen Leerzeichen platziert sind.

Testschnipsel

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>

Justin Mariner
quelle
8

GNU sed -r, 621 Bytes

Nimmt die Eingabe in zwei Zeilen vor: Die Breite wird zuerst als unäre Zahl und die Zeichenfolge als zweite.

Ich bin sicher, dass dies viel mehr Golf spielen könnte, aber ich habe bereits viel zu viel Zeit investiert.

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/

Probieren Sie es online!

Erläuterung

Das Programm arbeitet in zwei Phasen: 1. Teilen und 2. Begründen. Nehmen wir für das Folgende an, unsere Eingabe ist:

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

Installieren

Zuerst lesen wir die Eingabe, indem wir die erste Zeile (die Breite als eine unäre Zahl) in den Haltebereich ( x) verschieben, dann die nächste Zeile ( N) anhängen und dann eine Kopie der Breite aus dem Haltebereich ( G) in den Musterbereich. Da Nwir eine Führungslinie hinterlassen haben, \nersetzen wir diese durch eine !@, die wir in Phase 1 als Cursor verwenden werden.

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

Nun ist der Inhalt des Speicherbereichs 1111111111111(und wird sich von nun an nicht mehr ändern) und der Musterbereich (im Format von seds lBefehl "Unmissverständlich drucken" ):

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

Phase 1

In Phase 1 @rückt der Hauptcursor jeweils um ein Zeichen vor, und für jedes Zeichen wird a 1am Ende des Musterraums vom "Zähler" entfernt. Mit anderen Worten @foo\n111$, f@oo\n11$, fo@o\n1$etc.

Der !Cursor bewegt sich hinter dem @Cursor und markiert Stellen, die wir durchbrechen könnten, wenn der Zähler in der Mitte der Zeile den Wert 0 erreicht. Ein paar Runden würden so aussehen:

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

Hier gibt es ein Muster, das wir erkennen: ein Leerzeichen, dem der @Cursor unmittelbar folgt . Da der Zähler größer als 0 ist, bewegen wir den Break-Marker weiter und den Hauptcursor weiter:

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$

Ist hier ein anderes Muster: -@und wir haben noch 7 im Kostenzähler, also rücken wir den Bruchcursor wieder vor und rücken weiter vor:

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

Hier ist ein anderes Muster: Ein Bindestrich unmittelbar vor dem Unterbrechungscursor und ein anderer vor dem Hauptcursor. Wir entfernen den ersten Bindestrich, setzen den Umbruchcursor vor und addieren 1 zum Zähler, da wir ein Zeichen entfernt haben.

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

Wir bewegen den Hauptcursor weiter:

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

Ähnlich wie zuvor, aber diesmal steht der Hauptcursor vor einem Leerzeichen, anstatt einem Bindestrich zu folgen. Wir entfernen den Bindestrich, aber da wir auch den Hauptcursor vorrücken, erhöhen wir weder den Zähler noch verringern wir ihn.

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$

Endlich hat unser Zähler Null erreicht. Da das Zeichen nach dem Hauptcursor ein Leerzeichen ist, fügen wir eine neue Zeile ein und setzen beide Cursor unmittelbar danach. Dann füllen wir den Zähler auf ( G) und fangen von vorne an.

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

Phase 1 setzt sich fort, indem die Cursor vorgerückt und verschiedene Muster abgeglichen werden, bis der @Cursor das Ende der Zeichenfolge erreicht.

# 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

Am Ende von Phase 1 sieht unser Musterraum folgendermaßen aus:

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

Oder:

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

Phase 2

In Phase 2 verwenden wir %als Cursor und verwenden den Zähler auf ähnliche Weise, beginnend wie folgt:

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

Zuerst zählen wir die Zeichen in der ersten Zeile, indem wir den Cursor bewegen und 1s vom Zähler entfernen.

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

Da der Zähler 0 ist, machen wir in dieser Zeile nichts anderes. Die zweite Zeile hat auch die gleiche Anzahl von Zeichen wie der Zähler. Gehen wir also zur dritten Zeile über:

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

Der Zähler ist größer als 0, also bewegen wir den Cursor zurück zum Zeilenanfang. Dann finden wir den ersten Durchlauf von Leerzeichen und fügen ein Leerzeichen hinzu, wodurch der Zähler dekrementiert wird.

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

Der Zähler ist größer als 0; Da sich der Cursor bereits in der letzten (einzigen) Zeile mit Leerzeichen befindet, verschieben wir ihn an den Zeilenanfang und wiederholen ihn:

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

Jetzt ist der Zähler 0, also bewegen wir den Cursor an den Anfang der nächsten Zeile. Wir wiederholen dies für jede Zeile mit Ausnahme der letzten. Das ist das Ende von Phase 2 und das Ende des Programms! Das Endergebnis ist:

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/
Jordan
quelle
Das ist unglaublich, aber wenn ich es mit gsed (GNU sed) 4.4starte, bekomme ich gsed: -e expression #1, char 16: ":" lacks a label. Können Sie genau angeben, wie Sie es aufrufen? (Ich benutze printf "%s\n%s" "$1" "$2" | gsed -r '<code here>';)
Dave
@ Dave Das funktioniert bei mir in GNU sed 4.2. Hier ist eine kurze Zusammenfassung: gist.github.com/jrunning/91a7584d95fe10ef6b036d1c82bd385c Beachten Sie, dass die sed-Seite von TiO die -rFlagge nicht zu respektieren scheint, weshalb der TiO-Link oben auf die bash-Seite verweist.
Jordanien
Ah, ich hatte den TiO-Link nicht bemerkt. Das wird für mich tun; habe eine +1! Beim letzten Beispiel gibt es jedoch zwei kleine Fehler (das "schwarze Biest"): Es gibt die vorletzte Zeile mit einem Zeichen weniger als das letzte aus !(obwohl ich es in !der Liste der möglichen Sonderzeichen verpasst habe , I) Ich halte das nicht dagegen.
Dave
5

JavaScript (ES6), 147 Byte

Übernimmt die Eingabe als (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)

Probieren Sie es online!

Kommentiert

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
Arnauld
quelle
4

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

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

Probieren Sie es online!

ngn
quelle
1

Python 2 , 343 Bytes

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

Probieren Sie es 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.
mdahmoune
quelle
Obwohl die Eingabe in einem beliebigen Format erfolgen kann, sollte sie dennoch von STDIN oder Parametern stammen. Siehe Standardwerte für I / O . Wir erlauben im Allgemeinen nicht, dass "Eingaben" von vorab zugewiesenen Variablen stammen.
mbomb007
Sie können ein Byte speichern, indem Sie print'\n'.join(L[:-1])anstelle vonfor e in L[:-1]:print e
mbomb007
@ mbomb007 ok ja ich werde die nötigen Änderungen vornehmen um die I / O zu respektieren
mdahmoune