Ao usar o Markup, como na rede SE, um recuo de quatro espaços antes de uma linha de texto indica isso como parte de um bloco de código, como espero que você saiba. Caso contrário, veja um exemplo (com a .representação de um espaço):

.... Code
.... Mais código

resulta em

Code
More code

O problema é que, quando você copia e cola o código em uma resposta, precisa recuar cada linha manualmente. Isso é especialmente difícil quando se trabalha com código não-bloqueado, pois provavelmente já está recuado e pode causar confusão. Você pode apenas selecionar seu código e clicar Ctrl + K, ao que parece. Horas da minha vida desperdiçadas sem motivo aparte ...

Portanto, seu objetivo é, com uma entrada, retornar com quatro espaços antes de cada linha. No espírito de economizar tempo em copiar e colar, você deve processar toda a entrada como uma única sequência (desde que seu idioma possa analisá-la). Se o seu idioma não puder processar um caractere (como novas linhas) em strings, você poderá assumir que ele é indicado / escapado por algum outro método suportado pelo idioma; no entanto, a saída deve gerar cada linha em sua própria linha (para não passar algo parecido ....foo\n....bar).

Não são permitidas brechas padrão. Como esse é o código-golfe , a resposta mais curta em bytes vence. Boa sorte!

V , 4 bytes

Î4É 

Experimente online!

(Observe o espaço à direita)

V é codificado em Latin1, onde é codificado da seguinte forma:

00000000: ce34 c920                                .4. 

Explicação

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

Aqui está uma solução que também possui 4 bytes em UTF-8!

VG4>

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

Giz de cera , 7 bytes

`¤q;3xq

Experimente online!

Explicação

Crayon é uma linguagem baseada em pilha projetada para criar arte ASCII. Ainda está nos estágios iniciais de desenvolvimento, mas sabe o suficiente para concluir esse desafio com uma contagem de bytes bastante baixa:

         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

Desenhar o espaço sem quebra é necessário porque o Crayon apara automaticamente a saída em um retângulo; portanto, sem o NBSP, apenas imprimiria a entrada original.

Retina , 8 bytes

%`^

Experimente online!

Existem quatro espaços na segunda linha. Soluções alternativas usam m`^ou %1`ou 1%`na primeira linha. Tudo isso corresponde à posição no início de cada linha e a substitui por quatro espaços.

Cheddar, 31 bytes

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

Simplesmente, mas postei porque mostra os novos operadores funcionais.

(" ":+)é o mesmo que A -> " " + A. (ou seja, +op como uma função " "vinculada ao LHS).

Eu acho que nem precisa de explicação

Python ,  44  39 bytes

Riscado & nbsp; 44 & nbsp; já não é 44 :)

-5 bytes graças a ovs (evite desenfileirar com um prefpend)

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

Experimente online!

JavaScript, 26 bytes

Obrigado @Conor O'Brien por jogar fora 8 bytes

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

Substitua por uma regex por / g substitui todas as instâncias. m faz o regex tratar cada linha separadamente para o início da string ^.

Experimente online!

Python 2, 87 45 bytes

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

A entrada é tomada como 'Line1\nLine2\nLine3...'(Cotações necessárias)

Agradeço ao @WheatWizard por me dar uma idéia que me ajudou a obter 42 bytes de golfe.

Gelatina , 8 bytes

Ỵṭ€⁶ẋ4¤Y

Experimente online!

Quão?

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

Algumas outras variantes de 8 bytes são:
Ỵṭ€⁶Yµ4¡(4 repetições de divisão em novas linhas, preencha um único espaço);
⁶ḤḤ;ЀỴY(dobrar duas vezes é como multiplicar por 4, Ѐmapeia o argumento correto, para que possamos concatenar em vez de alinhar);
e outros rearranjos.

Emacs, 5 teclas, 5 bytes

C-x h M-4 C-x tab

Em pelo menos uma codificação comumente usados para a entrada do teclado, cada uma destas keychords é um único byte: 18 68 b4 18 09. As entradas do Emacs tendem a ser muito pesadas para keychord, pois cada caractere ASCII imprimível representa a si próprio, exceto como um caractere subseqüente de um comando com vários caracteres (o que significa que apenas os keychords podem ser usados ​​para fornecer comandos reais).

Não tenho certeza de como isso se compara ao Vim (ao contrário de V). Mas o Vim é bastante usado no PPCG e, por isso, pensei que o outro lado da guerra de editores também merece seu tempo de destaque.

Isso pressupõe que a E / S seja feita através do buffer (o equivalente às convenções normais de E / S para o vim), ou obtida de um arquivo e gerada na tela (que é a mesma coisa). Se você fizer E / S pela região, o que é natural para algumas formas de programa, você poderá remover os dois caracteres iniciais, com uma pontuação de 3 bytes; no entanto, não acho que esteja em conformidade com as regras do PPCG.

Explicação

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

O último built-in usado aqui é, obviamente, incrivelmente útil para esse desafio; o resto é apenas estrutura.

PowerShell, 29 28 bytes

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

-1 Graças ao fergusq, usando uma nova linha real em vez do `n

pega a "$args"entrada como uma seqüência de caracteres (convertida usando "s) e -splita coloca em uma nova linha e, em seguida, faz um loop ( %{}) através dela, acrescentando quatro espaços ( " "*4) e a linha ( $_) e a gera implicitamente.

Pyth, 10 bytes

jm+*4\ d.z

Tente!

Se a entrada como uma lista de linhas for permitida, eu poderia fazê-lo em 7 bytes:

jm+*4\ 

Tente isso

soluções mais longas:

12 bytes:

+*4d:Eb+b*4d

12 bytes:

+*4dj+b*4d.z

13 bytes:

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

Röda , 21 bytes

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

Experimente online!

É uma função anônima. A entrada é retirada do fluxo.

Explicação:

{
    (_/"\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 + -psinalizador.

s/^/    /mg

Experimente online!

Pela primeira vez, as explicações serão breves: A regex substitui cada início de linha ( ^combinado com /mmodificador) por quatro espaços - o final.

Perl 6 , 11 bytes

*.indent(4)

Tente

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

Experimente online!

Editar% s

Tamanho de solução reduzido de 16 para 10 bytes, graças ao Kritixi Lithos .

-1 byte graças a seshoumara .

Java 7, 58 bytes

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

Explicação:

Experimente aqui.

• Anexar com quatro espaços à esquerda
• Substitua cada nova linha por uma nova linha + quatro espaços

Brain-Flak , 109 103 bytes

-6 graças a Wheat Wizard

Inclui +1 para -c

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

Experimente 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    "]);

Empilhados , 13 bytes

'^'4' '*mrepl

Experimente online!

Explicação

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

Oitava, 17 bytes

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

Experimente online!

MATL , 12 bytes

10&Yb"4Z"@gh

Entrada é uma sequência com novas linhas. Para inserir isso, você precisa concatenar o caractere 10 entre os caracteres normais para representar a nova linha (colchetes são concatenação):

['Code' 10 'More code']

Experimente no MATL online!

Explicação

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

corra com php -R <code>. -Rexecuta o código fornecido para cada linha de entrada e $argné alimentado na linha de entrada atual. Portanto, isso simplesmente imprime cada linha com quatro espaços adicionais à sua frente.

V , 3 bytes (não concorrente)

4>G

Esta é a resposta que usa um recurso que eu planejava adicionar há um tempo, mas que acabei de adicionar hoje. Isso torna essa resposta não competitiva e inválida para ganhar. Mas ainda é legal mostrar um recurso tão útil / competitivo!

Experimente online!

Explicação:

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 pressionamentos de tecla

<Ctrl-V>G4I <Esc>

Pressupõe que o cursor esteja no início do arquivo, como se você o abrisse na linha de comando 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

Com um vim configurado para usar 4 espaços de recuo seria 2 teclas: >G.

Japt , 7 6 bytes

Guardado 1 byte graças a @ETHproductions

miS²²R

Experimente online!

Explicação:

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

UberGenes , 62 bytes

Eu tive que enfrentar esse desafio com o UberGenes, pois um programa muito semelhante (que inseriu apenas um espaço) foi um dos primeiros programas que eu já escrevi no idioma, e parecia que seria fácil modificá-lo para esse fim.

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

Como 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

Obrigado a @ Challenger5 por uma correção

qN/{S4*\N}%

Experimente online!

Explicação

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

Explicação

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

Isso se traduz diretamente em (em Ruby):

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

Na verdade , 16 bytes

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

Experimente online!

Explicação:

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

Experimente online!