Quando si utilizza Markup, come sulla rete SE, un rientro di quattro spazi prima di una riga di testo lo indica come parte di un blocco di codice, come spero che tu sappia. In caso contrario, ecco un esempio (con la .rappresentazione di uno spazio):

.... Codice
.... Altro codice

risultati in

Code
More code

Il problema è che quando si copia e incolla il codice in una risposta, è necessario rientrare manualmente ciascuna riga. Ciò è particolarmente difficile quando si lavora con codice non salvato, poiché è probabilmente già rientrato e può causare confusione. Puoi semplicemente selezionare il codice e premere Ctrl + K, si scopre. Ore della mia vita sprecate senza motivo a parte ...

Quindi, il tuo obiettivo è, dato un input, restituirlo con quattro spazi prima di ogni riga. Nello spirito di risparmiare tempo per copiare e incollare, devi elaborare l'intero input come una singola stringa (purché la tua lingua possa analizzarlo). Se la tua lingua non è in grado di elaborare un carattere (come le nuove righe) nelle stringhe, puoi supporre che sia indicato / sfuggito attraverso qualche altro metodo supportato dalla lingua; tuttavia, l'output deve emettere ogni riga sulla propria riga (quindi non passare qualcosa di simile ....foo\n....bar).

Scappatoie standard non consentite. Dato che si tratta di code-golf , vince la risposta più breve in byte. In bocca al lupo!

V , 4 byte

Î4É 

Provalo online!

(Nota lo spazio finale)

V è codificato in latino1, dove è codificato in questo modo:

00000000: ce34 c920                                .4. 

Spiegazione

Î            " On every line
 4É<space>   " Prepend 4 spaces

Ecco una soluzione che è anche 4 byte in UTF-8!

VG4>

VG          " Select everything
   >        " Indent
  4         " 4 times (with spaces)

Pastello , 7 byte

`¤q;3xq

Provalo online!

Spiegazione

Crayon è un linguaggio basato su stack progettato per la creazione di arte ASCII. È ancora nelle prime fasi di sviluppo, ma sa quanto basta per completare questa sfida con un numero di byte piuttosto basso:

         Implicit: input string is on the stack
`¤       Push a non-breaking space to the stack.
  q;     Draw this at the cursor (0,0 by default) and pop it.
    3x   Move three more spaces to the right.
      q  Draw the input string here (at 4,0).
         Implicit: output the canvas, trimmed to a rectangle

Disegnare lo spazio non interrotto è necessario perché Crayon ritaglia automaticamente l'output in un rettangolo, quindi senza NBSP stampa solo l'input originale.

Retina , 8 byte

%`^

Provalo online!

Ci sono quattro spazi sulla seconda riga. Le soluzioni alternative utilizzano m`^o %1`o 1%`sulla prima riga. Tutti questi corrispondono alla posizione all'inizio di ogni riga e la sostituiscono con quattro spazi.

Cheddar, 31 byte

@.lines.map(("    ":+)).asLines

Davvero semplicemente, ma ho pubblicato perché mette in mostra i nuovi operatori funzionali.

(" ":+)è lo stesso di A -> " " + A. (ovvero +op come funzione " "associata a LHS).

Non penso nemmeno che abbia bisogno di spiegazioni

Python ,  44  39 byte

Barrato & nbsp; 44 & nbsp; non ha più 44 anni :)

-5 byte grazie agli ovs (evita il dequeue con un prepend)

lambda s:' '*4+s.replace('\n','\n    ')

Provalo online!

JavaScript, 26 byte

Grazie @Conor O'Brien per il golf off 8 byte

x=>x.replace(/^/gm,"    ")

Sostituisci con una regex con / g sostituisce tutte le istanze. m fa in modo che regex tratti ciascuna riga separatamente per l'inizio della stringa ^.

Provalo online!

Python 2, 87 45 byte

print' '*4+'\n    '.join(input().split('\n'))

L'immissione è considerata come 'Line1\nLine2\nLine3...'(virgolette necessarie)

Grazie a @WheatWizard per avermi dato un'idea che mi ha aiutato a golf 42 byte.

Gelatina , 8 byte

Ỵṭ€⁶ẋ4¤Y

Provalo online!

Come?

Ỵṭ€⁶ẋ4¤Y - Main link: string
Ỵ        - split on newlines
      ¤  - nilad followed by ink(s) as a nilad:
   ⁶     -     a space character
    ẋ4   -     repeated four times
 ṭ€      - tack for €ach
       Y - join with newlines

Alcune altre varianti di 8 byte sono:
Ỵṭ€⁶Yµ4¡(4 ripetizioni di divisione su newline, virata in un unico spazio);
⁶ḤḤ;ЀỴY(raddoppiare due volte è come moltiplicare per 4, Ѐmappe sull'argomento giusto, quindi possiamo concatenare invece di virare);
e altri riarrangiamenti.

Emacs, 5 portachiavi, 5 byte

C-x h M-4 C-x tab

In almeno una codifica comunemente usata per l'immissione da tastiera, ciascuno di questi tasti è un singolo byte: 18 68 b4 18 09 . Le voci di Emacs tendono ad essere molto pesanti, poiché ogni carattere ASCII stampabile rappresenta se stesso tranne che come carattere successivo di un comando multi-carattere (il che significa che solo i tasti chiave possono essere usati per dare comandi effettivi).

Non sono sicuro di come si paragona a Vim (al contrario di V). Ma Vim è abbastanza comunemente usato su PPCG, e quindi ho pensato che anche l'altra parte delle guerre dell'editor meriti il ​​suo tempo sotto i riflettori.

This assumes that I/O is done via the buffer (the equivalent of the normal I/O conventions for vim), or taken from a file and output onto the screen (which comes to the same thing). If you do I/O via the region instead, which is natural for some forms of program, you can remove the leading two characters, for a score of 3 bytes; however, I don't think that complies with PPCG rules.

Explanation

C-x h M-4 C-x tab
C-x h               Specify the entire buffer as the region
      M-4           Give the argument 4 to the next command that runs
          C-x tab   Increase the indentation level of each line by a constant

The last builtin used here is, of course, incredibly useful for this challenge; the rest is just structure.

PowerShell, 29 28 Bytes

"$args"-split"
"|%{" "*4+$_}

-1 Thanks to fergusq, using an actual newline instead of the `n

takes the "$args" input as a string (cast using "s) and -splits it on a newline, then loops (%{}) through it, appending four spaces (" "*4) and the line ($_) then outputs it implicitly.

Pyth, 10 Bytes

jm+*4\ d.z

Try it!

If input as a list of lines would be allowed, I could do it in 7 bytes:

jm+*4\ 

Try that

longer solutions:

12 Bytes:

+*4d:Eb+b*4d

12 Bytes:

+*4dj+b*4d.z

13 Bytes:

t:E"^|
"+b*4d

Röda, 21 bytes

{(_/"
")|[`    $_
`]}

Try it online!

It is an anonymous function. The input is pulled from the stream.

Explanation:

{
    (_/"\n") |        /* Splits the input at newlines */
    ["    ".._.."\n"] /* For each line, prints four spaces before the line */
}

Perl 5, 11+1 = 12 bytes

11 bytes of code + -p flag.

s/^/    /mg

Try it online!

For once, explanations will be short: The regex replaces each beginning of line (^ combined with /m modifier) by four spaces - the end.

Perl 6, 11 bytes

*.indent(4)

Try it

Expanded:

*\       # declare a WhateverCode lambda/closure (this is the parameter)
.indent( # call the `indent` method on the argument
  4      # with the number 4
)

sed, 16 10 9 bytes

s/^/    /

Try it online!

Edits

Reduced solution size from 16 to 10 bytes thanks to Kritixi Lithos.

-1 byte thanks to seshoumara.

Java 7, 58 bytes

String c(String s){return"    "+s.replace("\n","\n    ");}

Explanation:

Try it here.

• Append with four leading spaces
• Replace every new-line for a new-line + four spaces

Brain-Flak, 109 103 bytes

-6 thanks to Wheat Wizard

Includes +1 for -c

((()()()()()){}){(({}<>)[()()((()()()()){})]<(((((({}){}){}))))>){(<{}{}{}{}{}>)}{}<>}<>{({}<>)<>}<>{}

Try it online!

((()()()()()){})        # Add a newline to the beginning
                        # This is needed to get spaces infront of the first line)
{                       # For every character (call it C)
  (({}<>)               #   Move C to the other stack
  [()()((()()()()){})]  #   Push 8 and subtract 10 (\n) from C
  <(((((({}){}){}))))>) #   Push 4 spaces using the 8 from earlier
  )                     #   Push C - 10
  {(<                   #   If C - 10 != 0...
    {}{}{}{}{}          #     Pop the 4 spaces that we added
  >)}{}                 #   End if
  <>                    #   Switch stacks to get the next character
}                       # End while
<>{({}<>)<>}<>          # Reverse the stack (back to the original order)
{}                      # Pop the newline that we added

PHP, 43 Bytes

<?="    ".strtr($_GET[0],["\n"=>"\n    "]);

Stacked, 13 bytes

'^'4' '*mrepl

Try it online!

Explanation

'^'4' '*mrepl      (* input: top of stack *)
        mrepl      perform multiline regex replacements,
'^'                  replacing /^/ with
   4' '*             four spaces

Octave, 17 bytes

@(s)["    "';s']'

Try it online!

MATL, 12 bytes

10&Yb"4Z"@gh

Input is a string with newlines. To enter this, you need to concatenate character 10 between the normal characters to represent newline (square brackets are concatenattion):

['Code' 10 'More code']

Try it at MATL online!

Explanation

10&Yb   % Implicit input. Split at char 10 (newline). Gives cell array of strings
"       % For each
  4Z"   %   Push string of 4 spaces
  @g    %   Push the contents of current cell array, i.e. a string with one of the
        %   original lines
  h     %   Concatenate the two strings horizontally
        % Implicit end. Implicit display

PHP, 16

echo"    $argn";

run with php -R <code>. -R runs the given code for every input line and $argn is fed the current input line. So this simply prints each line with additional four spaces in front of it.

V, 3 bytes (Non-competing)

4>G

This is answer uses a feature that I have been planning on adding for a while, but just got around to adding today. That makes this answer non-competing and invalid for winning. But it's still cool to show off such a useful/competitive feature!

Try it online!

Explanation:

4>   " Add an indent of 4 to...
  G  "   Every line from the current line (0 by default) to the end of the buffer

Vim, 6 keystrokes

<Ctrl-V>G4I <Esc>

Assumes that the cursor is on the beginning of the file, as if you opened the file from from the command line via vim filename.

<Ctrl-V>            " Enter visual block move (enables rectangular selection)
        G           " Move to bottom line (selecting the entire first column)
         4          " Repeat the following action 4 times
          I         " Insert at start of (each selected) line
                    " [input a space]
            <Esc>   " Exit insert mode

With a vim configured to use 4 spaces for indentation it would be 2 keystrokes: >G.

Japt, 7 6 bytes

Saved 1 byte thanks to @ETHproductions

miS²²R

Try it online!

Explanation:

miS²²R
m       // At each char in the input:
 iS²²   //   Prepend " " repeated 4 times
     R  // Rejoin with newlines  

UberGenes, 62 bytes

I had to enter this challenge with UberGenes, as a very similar program (that only inserted one space) was one of the first programs I ever wrote in the language, and it seemed like it would be easy to modify for this purpose.

=aA=p9=z4=cI=AC+a1-z1:pz=Ao:CA:Ii  =b5+b5-bA+a1=d3*d7:db=i0   

How it works:

=aA                                                         Set a to 61
                                                            (Begin main loop)
   =p9                                                      Set p to 9
      =z4                                                   z counts spaces
         =cI                                                Set c to 61
                                                            (Jumping to p jumps here)
            =AC                                             Put the space at position 61
                                                              at position a.
               +a1-z1                                       Move a right and decrement z
                     :pz                                    Jump to p if z is nonzero
                                                            (Jumping to d jumps here)
                        =Ao                                 Read a character to position a.
                           :CA                              Jump to position 32+3 if input
                                                              was nonzero.
                              :Ii                           Otherwise, jump to position 61,
                                                              causing the entire string
                                                              that begins there to be
                                                              printed before halting.
                                                            (This is position 32+3=35)
                                   =b5+b5                   Set b to 10 (newline).
                                         -bA                Subtract the input character to
                                                              compare it with newline.
                                            +a1             Move a right.
                                               =d3*d7       Set d to 21
                                                     :db    Jump to d if not newline.
                                                        =i0 Jump back to begin main loop.
(The 3 spaces at the end position a space character at position 61 so that, after =cI,
C refers to the space character--it will also be the first space printed.)

CJam, 11 bytes

Thanks to @Challenger5 for a correction

qN/{S4*\N}%

Try it online!

Explanation

q              e#  Read whole input as a string with newlines
 N/            e#  Split at newlines, keeping empty pieces. Gives an array of strings
   {     }%    e#  Map this function over the array of strings
               e#  The current string is automatically pushed
    S4*        e#  Push a string of four spaces
       \       e#  Swap. Moves the original string after the four spaces
        N      e#  Push a newline
               e#  Implicity display stack contents

J-uby, 17 16 Bytes

~:gsub&' '*4&/^/

Explanation

~:gsub           # :gsub with reversed arguments: 
                 # (f)[regex,sub,str] == str.gsub(regex, sub)
      &' '*4     # replace with four spaces
            &/^/ # match the start of each line

This directly translates to (in Ruby):

->s{s.gsub(/^/,' '*4)}

Actually, 16 bytes

9uc;§s⌠' 4*+⌡M@j

Try it online!

Explanation:

9uc;§s⌠' 4*+⌡M@j
9uc;              push two newlines
    §s            raw input, split on newlines
      ⌠' 4*+⌡M    for each line:
       ' 4*+        prepend 4 spaces
              @j  join with newlines

C, 66 65 bytes

p(){printf("    ");}f(char*s){for(p();*s;)putchar(*s++)-10||p();}

Try it online!