Al usar Markup, como en la red SE, una sangría de cuatro espacios antes de una línea de texto lo denota como parte de un bloque de código, como espero que sepa. Si no lo hace, aquí hay un ejemplo (con la .representación de un espacio):

.... Código
.... Más código

resultados en

Code
More code

El problema es que cuando copia y pega código en una respuesta, necesita sangrar cada línea manualmente. Esto es especialmente difícil cuando se trabaja con código no protegido, ya que probablemente ya esté sangrado y pueda causar confusión.Simplemente puede seleccionar su código y presionar Ctrl + K, resulta. Horas de mi vida desperdiciadas sin ninguna razón aparte ...

Entonces, su objetivo es, dada una entrada, devolverlo con cuatro espacios antes de cada línea.En el espíritu de ahorrar tiempo al copiar y pegar, debe procesar toda la entrada como una sola cadena (siempre que su idioma pueda analizarla). Si su idioma no puede procesar un carácter (como líneas nuevas) en cadenas, puede suponer que se denota / escapa a través de algún otro método admitido por el idioma; sin embargo, la salida debe generar cada línea en su propia línea (por lo que no debe pasar algo parecido ....foo\n....bar).

Lagunas estándar no permitidas. Como se trata de código de golf , gana la respuesta más corta en bytes. ¡Buena suerte!

V , 4 bytes

Î4É 

Pruébalo en línea!

(Tenga en cuenta el espacio final)

V está codificado en Latin1, donde esto se codifica así:

00000000: ce34 c920                                .4. 

Explicación

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

¡Aquí hay una solución que también tiene 4 bytes en UTF-8!

VG4>

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

Crayón , 7 bytes

`¤q;3xq

Pruébalo en línea!

Explicación

Crayon es un lenguaje basado en pila diseñado para crear arte ASCII. Todavía está en las primeras etapas de desarrollo, pero sabe lo suficiente para terminar este desafío con un recuento de bytes bastante bajo:

         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

Dibujar el espacio sin interrupciones es necesario porque Crayon recorta automáticamente la salida a un rectángulo, por lo que sin el NBSP simplemente imprimiría la entrada original.

Retina , 8 bytes

%`^

Pruébalo en línea!

Hay cuatro espacios en la segunda línea. Las soluciones alternativas usan o m`^o %1`o 1%`en la primera línea. Todos estos coinciden con la posición al comienzo de cada línea y la reemplazan con cuatro espacios.

Cheddar, 31 bytes

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

Realmente simple, pero publiqué porque muestra los nuevos operadores funcionales.

(" ":+)es el mismo que A -> " " + A. (es decir, +op como una función con " "enlace a LHS).

Ni siquiera creo que necesite explicación

Python ,  44  39 bytes

Tachado & nbsp; 44 & nbsp; ya no es 44 :)

-5 bytes gracias a los ovs (evitar la cola con un antecedente)

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

Pruébalo en línea!

JavaScript, 26 bytes

Gracias @Conor O'Brien por jugar 8 bytes

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

Reemplazar con una expresión regular con / g reemplaza todas las instancias. m hace que la expresión regular trate cada línea por separado para el inicio de la cadena ^.

Pruébalo en línea!

Python 2, 87 45 bytes

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

La entrada se toma como 'Line1\nLine2\nLine3...'(Citas necesarias)

Gracias a @WheatWizard por darme una idea que me ayudó a jugar golf de 42 bytes.

Jelly, 8 bytes

Ỵṭ€⁶ẋ4¤Y

Try it online!

How?

Ỵṭ€⁶ẋ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

Algunas otras variantes de 8 bytes son:
Ỵṭ€⁶Yµ4¡(4 repeticiones de división en líneas nuevas, agregar un solo espacio);
⁶ḤḤ;ЀỴY(doblar dos veces es como multiplicar por 4, Ѐmapas sobre el argumento correcto, por lo que podemos concatenar en lugar de agregar);
y otros reordenamientos de los mismos.

Emacs, 5 teclados, 5 bytes

C-x h M-4 C-x tab

En al menos una codificación de uso común para la entrada del teclado, cada uno de estos acordes de teclado es un solo byte: 18 68 b4 18 09. Emacs entries tend to be very keychord-heavy, as each printable ASCII character stands for itself except as a subsequent character of a multi-character command (meaning that only keychords can be used to give actual commands).

No estoy seguro de cómo esto se compara con Vim (a diferencia de V). Pero Vim se usa con bastante frecuencia en PPCG, por lo que pensé que el otro lado de las guerras editoriales también merece su tiempo en el centro de atención.

Esto supone que la E / S se realiza a través del búfer (el equivalente de las convenciones de E / S normales para vim), o se toma de un archivo y se envía a la pantalla (que es lo mismo). Si en su lugar realiza E / S a través de la región, lo cual es natural para algunas formas de programa, puede eliminar los dos caracteres iniciales, para una puntuación de 3 bytes; Sin embargo, no creo que cumpla con las reglas de PPCG.

Explicación

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

La última construcción utilizada aquí es, por supuesto, increíblemente útil para este desafío; el resto es solo estructura.

PowerShell, 29 28 bytes

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

-1 Gracias a fergusq, usando una nueva línea real en lugar de la `n

toma la "$args"entrada como una cadena (se convierte usando "s) y la envía -splita una nueva línea, luego la recorre ( %{}) a través de ella, agregando cuatro espacios ( " "*4) y la línea ( $_) luego la genera implícitamente.

Pyth, 10 bytes

jm+*4\ d.z

¡Intentalo!

Si se permitiera la entrada como una lista de líneas, podría hacerlo en 7 bytes:

jm+*4\ 

Trata eso

soluciones más largas:

12 bytes:

+*4d:Eb+b*4d

12 bytes:

+*4dj+b*4d.z

13 bytes:

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

Röda , 21 bytes

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

Pruébalo en línea!

Es una función anónima. La entrada se extrae de la secuencia.

Explicación:

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

Perl 5 , 11 + 1 = 12 bytes

11 bytes de código + -pbandera.

s/^/    /mg

Pruébalo en línea!

Por una vez, las explicaciones serán breves: la expresión regular reemplaza cada comienzo de línea ( ^combinado con un /mmodificador) por cuatro espacios: el final.

Perl 6 , 11 bytes

*.indent(4)

Intentalo

Expandido:

*\       # 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/^/    /

Pruébalo en línea!

Ediciones

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

Explicación:

Pruébalo aquí

• Añadir con cuatro espacios iniciales
• Replace every new-line for a new-line + four spaces

Brain-Flak , 109103 bytes

-6 gracias a Wheat Wizard

Incluye +1 para -c

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

Pruébalo en línea!

((()()()()()){})        # 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    "]);

Apilado , 13 bytes

'^'4' '*mrepl

Pruébalo en línea!

Explicación

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

Octava, 17 bytes

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

Pruébalo en línea!

MATL , 12 bytes

10&Yb"4Z"@gh

La entrada es una cadena con líneas nuevas. Para ingresar esto, debe concatenar el carácter 10 entre los caracteres normales para representar la nueva línea (los corchetes son concatenación):

['Code' 10 'More code']

Pruébalo en MATL en línea!

Explicación

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

correr con php -R <code>. -Rejecuta el código dado para cada línea de entrada y $argnse alimenta a la línea de entrada actual. Entonces, esto simplemente imprime cada línea con cuatro espacios adicionales en frente.

V , 3 bytes (no competitivos)

4>G

Esta respuesta utiliza una función que he estado planeando agregar por un tiempo, pero que acabo de agregar hoy. Eso hace que esta respuesta no sea competitiva e inválida para ganar. ¡Pero sigue siendo genial mostrar una característica tan útil / competitiva!

Pruébalo en línea!

Explicación:

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 pulsaciones de teclas

<Ctrl-V>G4I <Esc>

Asume que el cursor está al comienzo del archivo, como si abriera el archivo desde la línea de comandos a través de 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

Con un vim configurado para utilizar 4 espacios para el sangrado sería 2 teclas: >G.

Japt , 7 6 bytes

Guardado 1 byte gracias a @ETHproductions

miS²²R

Pruébalo en línea!

Explicación:

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

UberGenes , 62 bytes

Tuve que ingresar a este desafío con UberGenes, ya que un programa muy similar (que solo insertó un espacio) fue uno de los primeros programas que escribí en el idioma, y ​​parecía que sería fácil modificarlo para este propósito.

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

Cómo funciona:

=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

Gracias a @ Challenger5 por una corrección

qN/{S4*\N}%

Pruébalo en línea!

Explicación

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&/^/

Explicación

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

Esto se traduce directamente a (en Ruby):

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

En realidad , 16 bytes

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

Pruébalo en línea!

Explicación:

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

Pruébalo en línea!