Come celebrazione del buon vecchio Blocco note , tratteremo i ritorni a capo e i feed di riga come ciò che intendevano originariamente, piuttosto che come sono (ab-) utilizzati oggi.

Data una stringa costituita ASCII stampabile, più feed di linea (␊; LF; esc \n; hex 0A; 10 dicembre) e ritorni a capo (␍; CR; esc \r; hex 0D; 13 dicembre), causa Prova in linea per mostrare come il caratteri stampabili verrebbe posizionato se stampato su una stampante che prende letteralmente quei due caratteri di controllo:

1. su un avanzamento riga, continuare a stampare una riga più in basso
2. su un ritorno a capo continuare a stampare dal bordo sinistro
3. più ritorni a capo consecutivi si comportano come un ritorno a capo singolo

A causa dei moderni dispositivi che hanno problemi con l' overtriking , una corsa di uno o più ritorni a capo, tranne all'inizio dell'ingresso, non si verificherà mai senza almeno un avanzamento riga precedente e / o successivo. Tuttavia, due ritorni di ritorni a capo possono essere separati da un feed a riga singola.

È accettabile qualsiasi quantità di spazio bianco finale aggiuntivo, sia sul lato destro di qualsiasi riga sia sotto l'intero testo, purché sia ​​preservata almeno la quantità di spazio bianco fornita nell'input.

Esempi (utilizzo \ne \rper avanzamento riga e ritorno a capo)

Lorem ipsum dolor sit amet,

Lorem ipsum dolor sit amet,

consectetur adipiscing\nelit, sed

consectetur adipiscing
                      elit, sed

do eiusmod\r\ntempor incididunt\n\n ut labore

do eiusmod
tempor incididunt

                  ut labore

et dolore\n\rmagna \r\r\naliqua. Ut (notare gli spazi finali)

et dolore
magna          
aliqua. Ut

\nenim ad minim veniam,\n\r quis nostrud

enim ad minim veniam,
     quis nostrud

\rexercitation\r\n\rullamco laboris\n\r\nnisi ut aliquip ex\n\n\rea commodo consequat.\n\n

esercitazioni
ullamco laboris

nisi ut aliquip ex

ea commodo consequat.

Carbone , 10 byte

ＵＴＦθ«ι≡ι⸿↑

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

ＵＴ

Disabilita l'imbottitura corretta.

Ｆθ«

Passa sopra l'ingresso.

ι

Stampa il personaggio attuale. Questo gestisce automaticamente \n(che tratta il carbone come \vin questo contesto) ma il carbone si traduce \rin \r\n, quindi ...

≡ι⸿

... cerca un \r...

↑

... e in tal caso, tornare indietro di una riga.

Rubino , 24 17 byte

->s{s.tr $/,"\v"}

Provalo online!

Non funziona su TIO, ma funziona sulla console Linux.

Java 10, 211 207 206 byte

s->{var a=s.replace("\r\n","\n\r").split("(?<=\n)");int i=0,p=0,j;for(var x:a){for(j=x.charAt(0)<14?0:p;j-->0;x=" "+x);j=(a[i++]=x.replace("\r","")).length()-1;p=x.matches("\\s+")?p:j;}return"".join("",a);}

Provalo online.

Spiegazione:

s->{                      // Method with String as both parameter and return-type
  var a=s.replace("\r\n","\n\r")
                          //  Replace all "\r\n" with "\n\r"
        .split("(?<=\n)");//  Create String-array split by "\n",
                          //  without removing the trailing "\n" delimiter
  int i=0,                //  Index integer
      p=0,                //  Previous line-length, starting at 0
      j;                  //  Temp integer
  for(var x:a){           //  Loop over the String-array
    for(j=x.charAt(0)<14?0//   If the current line starts with either '\r' or '\n':
        0                 //    Prepend no spaces
       :                  //   Else:
        p;j-->0;x=" "+x); //    Prepand `p` amount of spaces for the current item
    j=(a[i++]=x.replace("\r",""))
                          //   Remove all "\r" from the current line
       .length()-1;       //   Set `j` to the current line-length (minus the trailing '\n')
    p=x.matches("\\s+")?  //   If the current line only contains '\r', '\n' and/or spaces:
       p                  //    Leave `p` unchanged
      :                   //   Else:
       j;}                //    Change `p` to this line-length minus 1
  return"".join("",a);}   //  Return the String-array joined together

Vecchia risposta prima che la sfida fosse cambiata 151 148 byte :

s->{String a[]=s.replace("\r\n","\n\r").split("(?<=\n)"),r="";int p=0,i;for(var x:a){for(i=p;i-->0;r+=" ");i=x.length()-1;p=i<1?p:i;r+=x;}return r;}

Spiegazione:

s->{                            // Method with String as both parameter and return-type
  String a[]=s.replace("\r\n","\n\r") 
                                //  Replace all "\r\n" with "\n\r"
              .split("(?<=\n)"),//  Create String-array split by "\n",
                                //  without removing the trailing "\n" delimiter
         r="";                  //  Result-String, starting empty
  int p=0,                      //  Previous line-length, starting at 0
      i;                        //  Index (and temp) integer
  for(var x:a){                 //  Loop over the String-array
    for(i=p;i-->0;r+=" ");      //   Append `p` amount of spaces to the result
    i=x.length()-1;p=i<1?p:j;   //   If the current line is not empty:
                                //    Replace `p` with the length of this current line
    r+=x;}                      //   Append the current item
  return r;}                    //  Return the result-String

Non funziona su TIO, funziona sul prompt dei comandi di Windows:

JavaScript (Node.js) , 85 byte

s=>s[R='replace'](/(.*)([\n\r]+)/g,(_,t,b)=>t+b[R](/\r/g,_=>s='',s=t[R](/./g,' '))+s)

Provalo online!

Python 2 , 150 128 122 104 103 byte

def f(s):
 i=n=0;l=''
 for c in s:l,n,i=[l,l+c,l+' '*i*n+c,n,1,0,0,i,i+1]['\r\n'.find(c)%3::3]
 print l

Provalo online!

Salvato:

• -1 byte, grazie a Lynn

C (gcc) , 100 94 byte

b,c,d;f(char*s){for(b=13;b;b=*s++)b==13?c=d=0:b-10?d=!printf("%*c",++d,b),++c:putchar(b,d=c);}

Presuppone la codifica ASCII ( '\r'==13, '\n'==10); adattarsi per adattarsi ad altri sistemi.

Provalo online! (richiede Javascript)

Versione leggibile

int c = 0;
int d = 0;

f(char*s)
{
    for (;*s;++s) {
        switch (*s) {
        case'\r':
            c = d = 0;
            break;
        case'\n':
            d = c;
            putchar(*s);
            break;
        default:
            printf("%*s%c", d, "", *s);
            d = 0;
            ++c;
        }
    }
}

cè la posizione corrente della colonna; dè il numero di spazi che devono essere inseriti prima di un carattere stampabile. Si presume che entrambi siano zero quando si accede alla funzione.

Programma di test

int main(int argc, char **argv)
{
    char s[1024];
    if (argc <= 1)
        while (fgets(s, sizeof s, stdin))
               f(s);
    else
        for (int i = 1;  i < argc;  ++i)
            f(argv[i]);
}

Python 3 , 101 94 byte

Basato sulla risposta di TFeld .

def f(s):
 i=n=0
 for c in s:k='\r\n'.find(c);a=k&1;print(end=-k*' '*i*n+c*a);n=k>0;i=i*a-k//2

Provalo online!

Ungolfed

def f(s):
  i=0  # position of the cursor
  n=0  # was the last character LF?
  for c in s:        # iterate over the input
    k='\r\n'.find(c) # k := 0 for CR, 1 for LF and -1 for every other character
    a=k&1            # as (-1)&1 == (1)&1 == 1, this is a := abs(k)
    print(end=-k*' '*i*n+c*a) # If c is a normal character (k == -1) and the last character was LF, 
                              # print leading spaces. If c is not CR, print it
    n=k>0            # n := True if c is LF, False otherwise
    i=i*a-k//2       # If c is either a newline or a printable character (a == 1),
                     # keep the cursor's position and increment it for a printable character ((-1)//2 == -1)

Pulito , 92 91 byte

-1 grazie a Laikoni!

Nota: \ in \rè omesso da bytecount poiché Linux CG gestisce letterali \re \ns.
Nota: Windows CG richiede \ne deve \ressere salvato, quindi +3 se deve essere eseguito su Windows.

import StdEnv
?n['\r':t]= ?0t
?n['
':t]=['
':spaces n]++ ?n t
?n[h:t]=[h: ?(n+1)t]
?_ e=e

?0

Provalo online!

Un'applicazione parziale di ? :: Int [Char] -> [Char]con 0 come primo argomento iniziale. Questo scende attraverso ogni personaggio tenendo traccia di quanti attraversati, il conteggio si azzera quando incontra un ritorno a capo e quando incontra una nuova riga aggiunge spazi pari al numero di caratteri attraversati in quel punto.

Haskell , 93 87 byte

l=0#0
(n#x)(t:r)|t=='\n'=t:(n#1)r|t=='\r'=l$r|m<-n+1=(' '<$[1..n*x])++t:(m#0)r
(_#_)e=e

Provalo online!

Soluzione piuttosto semplice. # è una funzione infix che crea in modo ricorsivo l'output di un carattere alla volta mantenendo un contatore della posizione del carattere (n) e contrassegna quando aggiungere spazi dopo una nuova riga (x).