(Hinweis: Dies ist meine allererste Code-Golf-Frage, aber soweit ich das beurteilen kann, hat niemand anderes genau das getan, also sollte ich gut sein.)

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu erstellen, die eine Zeichenfolge sund eine Ganzzahl enthältn und den in mehrere Zeilen eingeschlossenen Text zurückgibt oder ausgibt. Jedes Wort muss vollständig in einer Zeile stehen. dh keine Wörter in der Mitte geteilt. Jede Zeile darf nicht länger als nZeichen sein, und Sie müssen so viele Wörter wie möglich in jede Zeile einfügen.

Beispiel:

s = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat." 
n = 50

output:
Lorem ipsum dolor sit amet, consectetur adipiscing
elit. Sed eget erat lectus. Morbi mi mi, fringilla
sed suscipit ullamcorper, tristique at mauris.
Morbi non commodo nibh. Pellentesque habitant
morbi tristique senectus et netus et malesuada
fames ac turpis egestas. Sed at iaculis mauris.
Praesent a sem augue. Nulla lectus sapien, auctor
nec pharetra eu, tincidunt ac diam. Sed ligula
arcu, aliquam quis velit aliquam, dictum varius
erat.

Ihre Ausgabe kann ein Array von Zeichenfolgen oder eine einzelne Zeichenfolge mit Zeilenumbrüchen sein. Sie können auch davon ausgehen, dass keine Wörter länger sind alsn , machen Sie sich also keine Sorgen um seltsame Fälle.

Es gelten Standard-E / A-Regeln, und Standard-Regelungslücken sind nicht zulässig. Nachgestellte Leerzeichen sind erlaubt.

Da dies Code-Golf ist , gewinnt die Shortes-Lösung in Bytes.

Hier ist ein Beispielprogramm in Python, das funktionieren würde.

Python 2 , 26 Bytes

from textwrap import*
fill

Probieren Sie es online!

Meh ... Built-Ins sind langweilig ... stattdessen haben Sie eine schöne 87-Byte-Lösung hier:

s,n=input()
x=''
for i in s.split():c=n<len(x+i);exec'print x'*c;x=x*-~-c+i+' '
print x

Probieren Sie es online!

Gibt nachfolgende Leerzeichen aus.

PHP , 8 Bytes

Zugegeben, nicht die originellste Lösung, aber PHP hat eine native Funktion, die perfekt zu Ihren Anforderungen passt!

wordwrap:

string wordwrap ( string $str [, int $width = 75 [, string $break = "\n" [, bool $cut = FALSE ]]] )

Bricht einen String mit einem String-Umbruchzeichen in eine bestimmte Anzahl von Zeichen um.

Verwenden Sie wie folgt:

$str = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.";
echo wordwrap($str, 50);

Oder versuchen Sie es online!

JavaScript (ES6),  75 73  72 Byte

Übernimmt die Eingabe als (string)(n).

s=>n=>s.split` `.map(w=>r=(u=r?r+' '+w:w)[n]?(o+=r+`
`,w):u,o=r='')&&o+r

Probieren Sie es online!

Variablen

Die formatierte Ausgabe wird in $o$ (unten in grün) gespeichert .

Die aktualisierte Zeile $u$ ist definiert als die Verkettung von:

• die aktuelle Zeile $r$ (in schwarz unten)
• ein Leerzeichen, wenn $r$ nicht leer ist oder nichts anderes (in orange unten)
• das neue Wort $w$ (in blau unten)

Wir müssen einen Zeilenumbruch einfügen, wenn das $n$ te Zeichen von $u$ gesetzt ist (0-indiziert, unten rot).

Beispiel

$n=16$ und$s$ = "LOREM IPSUM DOLOR"

Hinzufügen von "LOREM":

Hinzufügen von "IPSUM":

Hinzufügen von "DOLOR":

Perl 6 , 46 29 Bytes

{;*.comb(/.**{1..$_}[\s|$]/)}

Probieren Sie es online!

Regex-basierte Lösung, die Input wie Curry nimmt f(n)(s) und eine Liste von Zeilen zurückgibt. Jede Zeile mit Ausnahme der letzten hat ein Leerzeichen am Ende

Erläuterung:

{;*                         }   # Anonymous code block that returns a Whatever lambda
   .comb(/                /)    # Split the string by
          .**{1..$_}            # Up to n characters
                    [\s|$]      # Terminated by a whitespace char or the end of the string

Vim, 15 Bytes / Tastenanschläge

DJ:se tw=<C-r>"
gq_

Eine Frage zur Textformatierung? Ich kenne nur das Werkzeug für den Job! Und es hat sogar meinen Namen in den ersten beiden Tastenanschlägen: D

<C-r> meint ctrl-r .

Dies könnte jemals so etwas kürzer in V , aber ich ziehe in Vanille vim für Antworten zu beantworten , die wirklich zeigen , wie präzise vim für die richtige Herausforderung sein kann. Und der Unterschied ist sowieso so gering.

Dies kann auch für 15 Bytes der Fall sein:

:se tw=<C-r><C-w>
ddgq_

Probieren Sie es online!

R , 36 27 Bytes

R hat dies als eingebaute ( strwrap), wir geben einen Vektor von Trennlinien zurück.

function(s,n)strwrap(s,n+1)

Probieren Sie es online!

Haskell , 70 Bytes

s!n|length s<=n=[s]|(t,_:d)<-splitAt(until((<'!').(s!!))pred n)s=t:d!n

Python 2 , 74 Bytes

s,n=input()
while s:i=n;exec"i-=' '<(s+' '*n)[i];"*n;print s[:i];s=s[i+1:]

Probieren Sie es online!

Java (JDK) , 46 44 Bytes

Grundsätzlich eine reine Regex-Lösung in Java, mit ziemlicher Sicherheit die kürzeste, die ich geschrieben habe.

Ein Hoch auf Kevin, der geholfen hat, die Bytes im Regex noch weiter zu reduzieren!

n->s->s.replaceAll(".{1,"+n+"}( |$)","$0\n")

Probieren Sie es online!

Mit einem Curry-Lamdba wird ein regulärer Ausdruck erstellt, der gierig mit nZeichen übereinstimmt, gefolgt von einem Leerzeichen oder einem Ende der Zeichenfolge. Diese Zeichen werden dann durch sich selbst ersetzt, gefolgt von einer neuen Zeile.

Mathematica, 16 Bytes

InsertLinebreaks

Eingebaute Funktion. Nimmt eine Zeichenfolge und eine Ganzzahl als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück.

InsertLinebreaks["string", n]
 Fügt Zeilenumbrüche ein, um keine Zeile länger als n Zeichen zu machen.

Power Shell, 40 83 Bytes

Testfall mit n=80hinzugefügt.

param($s,$n)$s-split' '|%{if(($o+$_|% le*)-lt$n){$o+=' '*!!$o+$_}else{$o;$o=$_}}
$o

Testskript:

$f = {

param($s,$n)$s-split' '|%{if(($o+$_|% le*)-lt$n){$o+=' '*!!$o+$_}else{$o;$o=$_}}
$o

}

@(
,(50, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.",
"Lorem ipsum dolor sit amet, consectetur adipiscing",
"elit. Sed eget erat lectus. Morbi mi mi, fringilla",
"sed suscipit ullamcorper, tristique at mauris.",
"Morbi non commodo nibh. Pellentesque habitant",
"morbi tristique senectus et netus et malesuada",
"fames ac turpis egestas. Sed at iaculis mauris.",
"Praesent a sem augue. Nulla lectus sapien, auctor",
"nec pharetra eu, tincidunt ac diam. Sed ligula",
"arcu, aliquam quis velit aliquam, dictum varius",
"erat.")
,(80, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.",
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus.",
"Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non",
"commodo nibh. Pellentesque habitant morbi tristique senectus et netus et",
"malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue.",
"Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu,",
"aliquam quis velit aliquam, dictum varius erat.")
) | %{
    $n,$s,$expected = $_
    $result = &$f $s $n
    "$result"-eq"$expected"
    # $result   # uncomment this line to dispaly a result
}

Ausgabe:

True
True

C (gcc) , 68 Bytes

i;b(s,n,l)char*s,*l;{for(i=n;*++s;i--||(i=l-s+n,*l=10))l=*s-32?l:s;}

Probieren Sie es online!

Sparen Sie dank ceilingcat 2 Byte, indem Sie global char*lauf parameter verschieben.

Japt , 20 Bytes

¸rÈ+Yi[X·ÌY]¸Ê>V?R:S

Probieren Sie es online!

Vielen Dank an Bubbler und Shaggy für ihre Hilfe

Erläuterung:

¸                       #Split into words
 r                      #For each word, add them to the output in this way:
     i                  # Choose a character using this process:
       X·Ì              #  Get the last line of the output
          Y             #  And the current word
      [    ]¸           #  Join them with a space
             Ê>V?       #  If the resulting line is greater than the allowed length:
                ?R      #   Choose "/n" (newline)
                  :S    #  Otherwise choose " " (space)
     i                  # Add the chosen character to the output
  È+Y                   # Add the current word to the output

Retina 0.8.2 , 37 Bytes

.+$
$*
!`(?=\S.*¶(1)+)(?<-1>.)+(?=\s)

Probieren Sie es online! Nimmt sund nin separaten Zeilen. Erläuterung:

.+$
$*

In Unary konvertieren n.

(?=\S.*¶(1)+)(?<-1>.)+(?=\s)

Passen Sie Nicht-Leerzeichen an, schauen Sie dann nach vorne nund zählen Sie es als $#1. Gehen Sie dann zurück und verwenden Sie eine Bilanzgruppe, um nZeichen gefolgt von Leerzeichen zuzuordnen.

!`

Die Übereinstimmungen als Liste von Zeilen ausgeben.

Holzkohle , 19 Bytes

Ｎθ←Ｆ⪪Ｓ «¿‹⁺ＬιⅈθＭ→⸿ι

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Übernimmt die Eingabe von nund sin separaten Zeilen. Erläuterung:

Ｎθ

Eingabe n.

←

Bewegen Sie den Cursor ein Feld nach links, um die Bewegung nach rechts ab der ersten Iteration der Schleife auszugleichen.

Ｆ⪪Ｓ «

Teilen Sie die Zeichenfolge auf Leerzeichen und ziehen Sie eine Schleife über die Wörter.

¿‹⁺Ｌιⅈθ

Berechnen Sie, ob das nächste Wort die rechte Kante erreicht.

Ｍ→

Wenn dies nicht der Fall ist, bewegen Sie sich ein Feld nach rechts.

⸿

Wenn dies der Fall ist, wird eine neue Zeile gestartet.

ι

Gib das Wort aus.

Rot , 125, 117, 114, 112 Bytes

func[s n][d: 0 parse s[any[to" "p:" "opt[[to" "| to end]q:(if(-1 - d + index? q)> n[p/1: #"^/"d: index? p])]]]s]

Probieren Sie es online!

05AB1E , 18 Bytes

õs#vDy«g²›i,}yðJ}?

Probieren Sie es online aus.

Erläuterung:

õ                   # Push an empty string "" to the stack
 s                  # Swap to take the (implicit) string input
  #                 # Split it by spaces
   v            }   # For-each `y` over the words:
    D               #  Duplicate the top of the stack
                    #  (which is the empty string in the very first iteration)
     y«             #  Append the current word `y`
       g            #  Get its length
        ²›i }       #  If its lengthy is larger than the second input:
           ,        #   Pop and output the current duplicated value with trailing newline
             yð     #  Push the word `y` and a space " "
               J    #  Join the entire stack together
                 ?  # After the loop, output the last part as well (without newline)

Java 8, 135 Bytes

n->s->{String r="",S[]=s.split(" "),t=r;for(int i=0;i<S.length;)if((t+S[i]).length()>n){r+=t+"\n";t="";}else t+=S[i++]+" ";return r+t;}

Probieren Sie es online aus.

Erläuterung:

n->s->{                      // Method with integer & String parameters and String return
  String r="",               //  Result-String, starting empty
         S[]=s.split(" "),   //  Input-String split by spaces
         t=r;                //  Temp-String, starting empty as well
  for(int i=0;i<S.length;)   //  Loop `i` in the range [0, amount_of_words):
    if((t+S[i]).length()>n){ //   If `t` and the word are larger than the integer input:
      r+=t+"\n";             //    Add `t` and a newline to the result
      t="";}                 //    And reset `t` to an empty String
     else                    //   Else:
       t+=S[i++]+" ";        //    Append the word and a space to `t`
                             //    (and then increase `i` by 1 with `i++` for the next word
                             //     of the next iteration)
  return r+t;}               //  Return the result-String appended with `t` as result

JavaScript, 40 Bytes

s=>n=>eval(`s.match(/.{1,${n}}( |$)/g)`)

Probieren Sie es online!

APL (Dyalog Unicode) , 14 Byte ^SBCS

Infix-Funktion; linkes Argument ist n, rechtes Argument ist n.

⎕CY'dfns'⋄wrap

Probieren Sie es online!

⎕CY c op y in der dfns-bibliothek

⋄ dann

wrap^[c]  benutze die wrap ^[n] Funktion

^[c]  Code dieser Funktion
^[n]  Notizen für diese Funktion

Golf-Version von wrap59 Bytes ^SBCS

{⍺≥≢⍵:⍵⋄(t↑⍵),2↓⎕TC,⍺∇⍵↓⍨t+b⊃⍨t←⊃⌽⍺,g/⍨⍺≥g←⍸(⍺+1)↑b←' '=⍵}

Probieren Sie es online!

{… } Dfn; ⍺ist linkes Argument (Breite), ⍵ist rechtes Argument (Zeichenkette)

 ≢⍵ Tally (Anzahl der Zeichen) der Zeichenfolge

 ⍺≥… : Wenn die Breite größer oder gleich ist, dann:

  ⍵ Gib den String zurück

 ⋄ Andernfalls:

  ' '=⍵ Boolesche Maske, bei der Leerzeichen der Zeichenfolge entsprechen

  b← Speichern in b(für B Lanks)

  (… )↑ Entnehmen Sie daraus folgende Anzahl von Elementen:

   ⍺+1 einer mehr als die Breite

  ⍸ Ich erkenne, wo wahr

  g← store in g(für g aps)

  ⍺≥ Boolesche Maske, bei der die Breite größer oder gleich dieser ist

  g/⍨ filtern Sie die Lückenindizes danach

  ⍺, Hänge das an die Breite an

  ⊃⌽ wähle das letzte Element davon (wähle das erste der umgekehrten)

  t← Speichern in t(für t ake)

  b⊃⍨ Verwenden Sie dies, um ein Element aus der Maske von b Lanks auszuwählen

  t+ füge das hinzu t

  ⍵↓⍨ lösche so viele Zeichen aus der Zeichenkette

  ⍺∇ Verwenden Sie dazu dasselbe Argument für left left

  ⎕TC, append , daß zu der Liste der T erminal c ontrol Zeichen (8: HT, 10: NL, 13: CR)

  2↓ Löschen Sie die ersten beiden Zeichen (lassen Sie nur eine führende 13: CR übrig)

  (… ), Hängen Sie das an:

   t↑⍵ die ersten tZeichen der Zeichenfolge

Dank @Erik the Outgolfer, einer Golfversion:

Python 3 , 94 Bytes

def f(t,n):
 while t:i=n+(t[min(len(t)-1,n)]==" "or-t[n-1::-1].find(' '));print(t[:i]);t=t[i:]

Probieren Sie es online!

# Python 3 , 130 Bytes

def f(t,n):
 l=[]
 while len(t):
  i=(n-t[:n][::-1].find(' '),n+1)[t[min(len(t)-1,n)]==" "]
  l.append(t[:i])
  t=t[i::]
 return l

Probieren Sie es online!

Nicht so Golf Version ...

JavaScript + HTML + CSS, 117 64 Byte

-53 Bytes mit freundlicher Genehmigung von @Neil

n=50
s="Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat."
f=(n,s)=>document.body.innerHTML+=`<tt><p style=width:${n}ch>${s}`
f(n,s)

Gelee , 12 Bytes

ḲŒṖK€€ḣ€ƑƇṪY

Probieren Sie es online!

Leider ist dies zu langsam, um für den bereitgestellten Testfall in weniger als einer Minute über TIO zu funktionieren.

C # (.NET Core) , 162 Byte

string[]t(string n,int a){var g="";for(int i=0;i++<Math.Floor((double)n.Length/a);)g+=$"^.{{{i*a-1}}}|";return Regex.Split(n,$@"(?n)(?<=({g.Trim('|')})\S*)\s");}}

Diese Funktion verwendet einen regulären Ausdruck, der mit dem nächstgelegenen Leerzeichen in der Nähe des n-ten oder vielfachen des n-ten Zeichens übereinstimmt und die darauf basierende Zeichenfolge aufteilt.

Probieren Sie es online!

Die TIO-Verknüpfung ist ein vollständiges Programm, und die Funktion verfügt über ein statisches Schlüsselwort, sodass die Funktion von main aus aufgerufen werden kann.

Testen Sie Regex

C # (Visual C # Interactive Compiler) , 78 Byte

s=>n=>System.Text.RegularExpressions.Regex.Replace(s,".{1,"+n+"}( |$)","$0\n")

Probieren Sie es online!

Dank geht an @LukeStevens für die Entwicklung der Java-Version ... Anscheinend lässt .NET Sie die importieren RegularExpressions Namespace , um ein Ersetzen durchzuführen :(

Hier ist meine ursprüngliche Version, die das Leerzeichen aufteilt und mithilfe von LINQ wieder zusammenfügt:

C # (Visual C # Interactive Compiler) , 91 Byte

s=>n=>s.Split(' ').Aggregate((a,w)=>a+(a.Length-a.LastIndexOf('\n')+w.Length>n?'\n':' ')+w)

Probieren Sie es online!

Dart , 112 Bytes

f(s,n){var l=[''];s.split(' ').forEach((w){if((l.last+w).length<=n)l.last+=w+' ';else l.add(w+' ');});return l;}

Probieren Sie es online!

APL (NARS), 48 Zeichen, 96 Byte

{⊃⍵{⍺≥≢⍵:⊂⍵⋄k←1+⍺-' '⍳⍨⌽r←⍺↑⍵⋄(⊂k↑r),⍺∇k↓⍵}⍨⍺+1}

Prüfung:

  f←{⊃⍵{⍺≥≢⍵:⊂⍵⋄k←1+⍺-' '⍳⍨⌽r←⍺↑⍵⋄(⊂k↑r),⍺∇k↓⍵}⍨⍺+1}
  s←"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat."
  50 f s
Lorem ipsum dolor sit amet, consectetur adipiscing 
elit. Sed eget erat lectus. Morbi mi mi, fringilla 
sed suscipit ullamcorper, tristique at mauris.     
Morbi non commodo nibh. Pellentesque habitant      
morbi tristique senectus et netus et malesuada     
fames ac turpis egestas. Sed at iaculis mauris.    
Praesent a sem augue. Nulla lectus sapien, auctor  
nec pharetra eu, tincidunt ac diam. Sed ligula     
arcu, aliquam quis velit aliquam, dictum varius    
erat.                                              

C 63 Bytes

b(a,n)char*a;{while(strlen(a)>n){for(a+=n;*a-32;--a);*a++=10;}}

Die Funktion dieser Übung b (a, n) würde, wie gesagt, die Zeile "a" unterbrechen, indem sie ihre Länge nicht ändert (wenn wir das Ergebnis als eine Zeichenkette sehen), da einige Leerzeichen in \ n oder eine neue Zeile in geändert werden Ort. Die Eingabezeichenfolge "a" sollte kein \ n Zeichen für die Funktion b () enthalten (sie könnte \ n in der Eingabezeichenfolge für bs () enthalten).

Die Funktion b (a, n) wäre nur deshalb in Ordnung, weil die Einschränkung dieser Übung, die jedes Wort einer "a" - Zeichenkette auferlegt, eine Länge <n hat. Wenn dies nicht zutrifft, kann diese Funktion
zu einer Endlosschleife gehen ... (sehr) falsch in meiner Sichtweise, so kopiere ich auch die Funktion besser, weil in diesem Fall -1 zurückkehren würde und nicht zu einer Endlosschleife gehen würde; es ist bs (a, n) unten) Ich schließe nicht aus, dass beide Funktionen fehlerhaft sind. .

#define R(x,y) if(x)return y
#define U unsigned
U bs(char*a,U n)
{U c,q,r=1,i,j;
 R(!a||n<1||n++>0xFFFF,-1);
 for(j=c=i=0;;++i,++c)
    {R(i==-1,-1);q=a[i];
     if(q==10)goto l;
     if(c>=n){R(i-j>n,-1);a[i=j]=10;l:c=-1;++r;}
     R(!q,r);
     if(q==32)j=i;
    }
}

Ergebnis von b (), das an eine Funktion übergeben wurde, die die Zeilenlänge jeder Zeile hinzufügt

Lorem ipsum dolor sit amet, consectetur adipiscing [50]
elit. Sed eget erat lectus. Morbi mi mi, fringilla [50]
sed suscipit ullamcorper, tristique at mauris. [46]
Morbi non commodo nibh. Pellentesque habitant [45]
morbi tristique senectus et netus et malesuada [46]
fames ac turpis egestas. Sed at iaculis mauris. [47]
Praesent a sem augue. Nulla lectus sapien, auctor [49]
nec pharetra eu, tincidunt ac diam. Sed ligula [46]
arcu, aliquam quis velit aliquam, dictum varius [47]
erat. [5]