Crea un semplice word wrapper


22

(Nota: questa è la mia prima domanda di golf in codice, ma per quanto ne so, nessun altro ha fatto esattamente questo, quindi dovrei essere buono.)

Il tuo compito è creare un programma o una funzione che includa una stringa se un numero intero ne restituisca o generi quel testo racchiuso in più righe. Ogni parola deve essere interamente su una riga; cioè nessuna parola divisa nel mezzo. Ogni riga non può essere più lunga dei ncaratteri e devi inserire quante più parole possibile su ciascuna riga.

Esempio:

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.

L'output può essere una matrice di stringhe o una singola stringa con interruzioni di riga. Inoltre, puoi presumere che nessuna parola sarà più lunga di n, quindi non preoccuparti di trattare casi strani.

Si applicano le regole I / O standard e sono vietate le scappatoie standard. Sono consentiti spazi finali.

Dato che si tratta di , vince la soluzione di short in byte.

Ecco un programma di esempio in Python che funzionerebbe.



3
n è la lunghezza massima della linea? o la lunghezza che dobbiamo raggiungere prima dell'interruzione di linea?
david

1
@david o il numero di righe?
Peter Taylor,

1
28 byte Python è rilevante?
david

3
nè la lunghezza massima della linea, mi dispiace che non fosse chiaro. Chiarirò. Inoltre, le regole sono state ora aggiornate, quindi una semplice suddivisione non funziona.
ATMunn

Risposte:



5

PHP , 8 byte

Certo non è la soluzione più originale, ma PHP ha una funzione nativa che soddisfa perfettamente le tue esigenze!

wordwrap:

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

Avvolge una stringa per un determinato numero di caratteri utilizzando un carattere di interruzione della stringa.

Usa così:

$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);

Oppure provalo online!


5

JavaScript (ES6),  75 73  72 byte

Accetta input come (string)(n).

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

Provalo online!

variabili

L'output formattato è memorizzato in o (in verde sotto).

La riga aggiornata u è definita come la concatenazione di:

  • la riga corrente r (in nero sotto)
  • uno spazio se r non è vuoto o nient'altro (in arancione sotto)
  • la nuova parola w (in blu sotto)

Dobbiamo inserire un'interruzione di riga ogni volta che viene impostato l' n -esimo carattere di u (0-indicizzato, in rosso sotto).

Esempio

n=16 andS = "LOREM IPSUM DOLOR"

Aggiunta di "LOREM":

0001020304050607080910111213141516LOREM

Aggiunta di "IPSUM":

0001020304050607080910111213141516LOREMioPSUM

Aggiunta di "DOLOR":

0001020304050607080910111213141516LOREMioPSUMDOLOR

0001020304050607080910111213141516LOREMioPSUMDOLOR


Sono consentiti spazi finali. forse r+w+' '?
l4m2

5

Perl 6 , 46 29 byte

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

Provalo online!

Soluzione basata su Regex che accetta input al curry, come f(n)(s)e restituisce un elenco di righe. Ogni riga tranne l'ultima ha uno spazio bianco finale

Spiegazione:

{;*                         }   # 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

4

Vim, 15 byte / sequenze di tasti

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

Una domanda di formattazione del testo? Conosco solo lo strumento per il lavoro! E ha anche il mio nome nelle prime due battute: D

<C-r> si intende ctrl-r .

Questo potrebbe mai leggermente più breve in V , ma preferisco rispondere in vaniglia vim per risposte che mostrino davvero quanto può essere conciso vim per la giusta sfida. E la differenza è comunque così piccola.

Questo potrebbe anche essere il seguente per 15 byte:

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

Provalo online!


1
Spiegazione:: DJ:Questo programma è stato realizzato da DJ, il nostro gatto preferito con un diamante al collo. [...]
Erik the Outgolfer,

4

R , 36 27 byte

R ha questo come built-in ( strwrap), restituiamo un vettore di linee di divisione.

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

Provalo online!


1
Sì, dovrebbe essere permesso. Le matrici di linee sono consentite, quindi non vedo perché questo sarebbe diverso.
ATMunn

4

Haskell , 70 byte

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


3

Java (JDK) , 46 44 byte

Fondamentalmente una soluzione regex pura in Java, quasi sicuramente la più breve che abbia mai scritto.

Saluti a Kevin per aver contribuito a ridurre ulteriormente i byte nella regex!

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

Provalo online!

Usando un lamdba al curry, crea una regex per abbinare avidamente fino a ncaratteri seguiti da uno spazio o una fine della stringa. Sostituisce quindi quei personaggi con se stessi seguiti da una nuova riga.


@KevinCruijssen in [ $]realtà corrisponde solo a uno spazio o, $se ricordo bene, piuttosto che alla fine della stringa. Tuttavia sembra funzionare, quindi sembra che possa essere semplicemente spostato in un singolo spazio per ancora meno byte.
Luke Stevens,

Ah, può davvero essere solo uno spazio, dal momento che aggiungi nuove righe e non devi aggiungere un'altra riga finale alla fine.
Kevin Cruijssen,

1
Puoi golf altri 2 byte rimuovendo la parentesi nella regex e usare $0invece di $1.
Kevin Cruijssen,

@KevinCruijssen Nice one! È solo un peccato che replaceAllsia così prolisso!
Luke Stevens,

2
Per me è sbagliato, appare se modifico la frase latina dell'esercizio nel modo in cui termina con "... dictum varius abc erat". C'è una nuova riga non necessaria dopo la lettera c ...
RosLuP

2

Mathematica, 16 byte

InsertLinebreaks

Funzione integrata. Accetta una stringa e un numero intero come input e restituisce una stringa come output.

InsertLinebreaks["string", n]
 inserisce i caratteri di nuova riga per rendere non più lunga di n caratteri.


2

Powershell, 40 83 byte

Caso di prova con n=80aggiunta.

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

Script di prova:

$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
}

Produzione:

True
True


Grazie. Il finto ternario è un'espressione. Questo script contiene un implicito returnnella elseparte e un'istruzione nella thenparte.
mazzy,


2

Japt , 20 byte

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

Provalo online!

Grazie a Bubbler e Shaggy per il loro aiuto

Spiegazione:

¸                       #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

24 byte con [X,Y].join(...).
Bubbler


1

Retina 0.8.2 , 37 byte

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

Provalo online! Prende se nsu linee separate. Spiegazione:

.+$
$*

Converti nin unario.

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

Abbina gli spazi non bianchi, quindi guarda avanti ne contalo come $#1. Quindi tornare indietro e utilizzare un gruppo di bilanciamento per abbinare i ncaratteri seguiti da spazi bianchi.

!`

Emetti le partite come un elenco di righe.


C'è un modo in Retina di mettere il primo input in una regex che usiamo con il secondo input? Quindi qualcosa del genere: .{1,50} e$0¶ , ma dove 50viene invece ricevuto come input?
Kevin Cruijssen,

@KevinCruijssen In Retina 1 probabilmente puoi usare uno stadio Eval per dare un risultato simile, ma è noioso, quindi non mi sono preoccupato.
Neil,

1

Carbone , 19 byte

Nθ←F⪪S «¿‹⁺LιⅈθM→⸿ι

Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta input di ne ssu righe separate. Spiegazione:

Nθ

Input n.

Spostare il cursore a sinistra di un quadrato per bilanciare il movimento destro dalla prima iterazione del loop.

F⪪S «

Dividi la stringa negli spazi e passa sopra le parole.

¿‹⁺Lιⅈθ

Calcola se la parola successiva raggiungerà il bordo destro.

M→

Se non si sposta quindi di un quadrato a destra.

⸿

Se inizierà quindi una nuova linea.

ι

Emetti la parola.



1

05AB1E , 18 byte

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

Provalo online.

Spiegazione:

õ                   # 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)

1

Java 8, 135 byte

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;}

Provalo online.

Spiegazione:

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


1

APL (Dyalog Unicode) , SBCS da 14 byte

Funzione Infix; l'argomento left è n, l'argomento right è n.

CY'dfns'wrap

Provalo online!

⎕CYc op y nella libreria dfns

 poi

wrap[c]  usano la pellicola [n] la funzione

[c]  codice di quella funzione
[n]  note per quella funzione


Versione golfizzata di SBCS dawrap 59 byte

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

Provalo online!

{... } dfn; è argomento a sinistra (larghezza), è argomento a destra (stringa)

≢⍵ riscontro (numero di caratteri) della stringa

⍺≥... : se la larghezza è maggiore o uguale a quella, allora:

   restituisce la stringa

 altrimenti:

  ' '=⍵ Maschera booleana in cui gli spazi vuoti sono uguali alla stringa

  b← conservare in b(per b lanks)

  (... )↑ prendi il seguente numero di elementi da quello:

   ⍺+1 uno in più rispetto alla larghezza

  I ndices dove la vera

  g← conservare in g(per g aps)

  ⍺≥ Maschera booleana in cui la larghezza è maggiore o uguale a quella

  g/⍨ filtrare gli indici di gap da quello

  ⍺, aggiungilo alla larghezza

  ⊃⌽ scegli l'ultimo elemento di quello (lett. scegli il primo dell'inverso)

  t← conservare in t(per t ake)

  b⊃⍨usalo  per scegliere un elemento dalla maschera di b lanks

  t+ aggiungilo a t

  ⍵↓⍨ lascia cadere tanti caratteri dalla stringa

  ⍺∇ fare affidamento su quello con lo stesso argomento a sinistra

  ⎕TC, accodamento che alla lista dei t erminal c ontrollo caratteri (8: HT, 10: NL, 13: CR)

  2↓ rilasciare i primi due personaggi da quello (lasciando solo un 13: CR iniziale)

  (... ), aggiungilo a quanto segue:

   t↑⍵ i primi tcaratteri della stringa


0

Grazie a @Erik the Outgolfer, una versione giocata a golf:

Python 3 , 94 byte

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:]

Provalo online!

# Python 3 , 130 byte

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

Provalo online!

Versione non tanto giocata a golf ...


1
Alcuni golf. (stampa su STDOUT, non ritorna).
Erik the Outgolfer,

0

JavaScript + HTML + CSS, 117 64 byte

-53 byte per gentile concessione di @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)


1
Almeno nel mio browser è possibile ridurlo a (n,s)=>document.body.innerHTML+=`<p style=width:${n}ch><tt>${s}</tt></p>` 74 byte. Se sei disposto a scavare vecchie versioni di Firefox puoi salvare altri 8 byte con (n,s)=>document.body.innerHTML+=`<pre wrap width=${n}>${s}</pre>` .
Neil

@Neil Bel uso delle chunità. Firefox 65 calcola 50chcome 500px; Il cromo 70 viene calcolato 50chcome400px
guest271314 il

Questa risposta è sbagliata elit. Sed eget erat lectus. Morbi mi mi, fringilla sed(2a riga) è più di 50 caratteri. Sto usando il nuovissimo Chrome.
mbomb007,

Sono stato in grado di modificare il mio suggerimento originale di lavorare in Chrome inserendo l' <p>interno <tt>.
Neil



0

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");}}

Questa funzione usa una regex che corrisponde allo spazio bianco più vicino vicino all'ennesimo o multiplo dell'ennesimo carattere e divide la stringa in base ad essa.

Provalo online!

Il collegamento TIO è un programma completo e la funzione ha una parola chiave statica, quindi la funzione può essere chiamata dal principale.

Test Regex


Questo non fornisce l'output giusto per il test case: alcune righe sono più lunghe di 50 caratteri. Vuoi "prima" non "vicino", e anche la divisione in un punto deve dipendere da dove è stata divisa in precedenza.
Ørjan Johansen,

0

C # (compilatore interattivo Visual C #) , 78 byte

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

Provalo online!

Il merito va a @LukeStevens per aver inventato la versione Java ... Apparentemente .NET ti fa importare RegularExpressions spazio nomi per fare un rimpiazzo :(

Ecco la mia versione originale che si divide sul personaggio spaziale e usa LINQ per unirli di nuovo:

C # (compilatore interattivo Visual C #) , 91 byte

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

Provalo online!


0

Dardo , 112 byte

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

Provalo online!


0

APL (NARS), 48 caratteri, 96 byte

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

test:

  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.                                              

Non lo so in "{⊃⍵ {⍺≥≢⍵: ⊂⍵⋄ ..." Se è giusto ≥ o è proprio lì> ...
RosLuP

0

C, 63 byte

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

La funzione di questo esercizio b (a, n) spezzerebbe la linea "a" come detto esercizio, nel modo in cui non cambierebbe la sua lunghezza (se vediamo il risultato come una stringa) perché cambierà alcuni spazi in \ n o la nuova linea in posto. La stringa di input "a" non dovrebbe contenere anche un carattere \ n per la funzione b () (potrebbe avere \ n nella stringa di input per bs ())

La funzione b (a, n) sarebbe ok solo perché la restrizione di questo esercizio, che impone ogni parola di una stringa "a" ha lunghezza <n se ciò non è vero, quella funzione può andare
in un ciclo infinito ... (molto sbagliato nel mio modo di vedere, quindi copio anche la funzione più bene perché in quel caso restituirebbe -1 e non andrebbe in un ciclo infinito; è bs (a, n) di seguito) Non escludo che entrambe le funzioni siano infastidite .. .

#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;
    }
}

il risultato di b () ha passato una funzione che aggiunge la lunghezza di ogni riga

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]

@ceilingcat ok, sopra il codice prenderebbe in considerazione anche \ n ... un bug che ho trovato con il codice era che l'ultima riga non era stata stampata correttamente ... perché non scrivi la tua risposta C come altra? Vincerebbe sul mio perché è più breve ... per dire il vero io uso la prima riga (o istruzione ";") per il controllo dell'input solo perché per me l'input deve essere verificato anche se è un po 'più lungo; Non ho provato a scrivere la funzione in APL ...
RosLuP il

@ceilingcat nell'ultima risposta, visto che la domanda non dice se la stringa di input ha o meno deve avere '\ n' char e visto che l'esempio non ha '\ n' Suppongo che la stringa di input non contenga un nuovo carattere di riga ...
RosLuP l'

Solo 83 ... Sì, devo vedere se guadagno 3 caratteri usando la vecchia definizione della funzione ...
RosLuP

Solo 81 .... .... ....
RosLuP

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.