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:

• Richten Sie einen Text durch Hinzufügen von Leerzeichen aus
• Richten Sie den Text an einem Block aus
• In gewisser Weise kann dies als nächster Schritt in Textverarbeitung Nr. 1 betrachtet werden: Silbentrennung (die anscheinend noch nie veröffentlicht wurde).

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!

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>

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/

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

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}

Probieren Sie es online!

Stax , 51 50 Bytes

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

Führen Sie es aus und debuggen Sie es

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.