Lorsque vous utilisez le balisage, comme sur le réseau SE, une indentation de quatre espaces avant une ligne de texte le désigne comme faisant partie d'un bloc de code, comme j'espère que vous le savez. Si vous ne le faites pas, voici un exemple (avec .représentation d'un espace):

.... Code
.... Plus de code

résulte en

Code
More code

Le problème est que lorsque vous copiez-collez du code dans une réponse, vous devez indenter manuellement chaque ligne. Cela est particulièrement difficile lorsque vous travaillez avec du code non golfé, car il est probablement déjà en retrait et peut provoquer de la confusion. Vous pouvez simplement sélectionner votre code et frapper Ctrl + K, il s'avère. Des heures de ma vie perdues sans raison de côté ...

Donc, votre objectif est, étant donné une entrée, de le renvoyer avec quatre espaces avant chaque ligne. Dans un souci d'économie de temps de copier-coller, vous devez traiter l'intégralité de l'entrée en une seule chaîne (tant que votre langue peut l'analyser). Si votre langue n'est pas en mesure de traiter un caractère (comme les sauts de ligne) dans les chaînes, vous pouvez supposer qu'il est indiqué / échappé par une autre méthode prise en charge par la langue; cependant, la sortie doit sortir chaque ligne sur sa propre ligne (donc ne pas passer quelque chose comme ....foo\n....bar).

Les échappatoires standard ne sont pas autorisées. Comme il s'agit de code-golf , la réponse la plus courte en octets l'emporte. Bonne chance!

V , 4 octets

Î4É 

Essayez-le en ligne!

(Notez l'espace de fin)

V est codé en Latin1, où cela est codé comme suit:

00000000: ce34 c920                                .4. 

Explication

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

Voici une solution qui fait également 4 octets en UTF-8!

VG4>

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

Crayon , 7 octets

`¤q;3xq

Essayez-le en ligne!

Explication

Crayon est un langage basé sur la pile conçu pour créer de l'art ASCII. Il est encore aux premiers stades de développement, mais il en sait juste assez pour terminer ce défi avec un nombre d'octets plutôt faible:

         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

Le dessin de l'espace insécable est nécessaire car Crayon découpe automatiquement la sortie en rectangle, donc sans le NBSP, il imprimerait simplement l'entrée d'origine.

Rétine , 8 octets

%`^

Essayez-le en ligne!

Il y a quatre espaces sur la deuxième ligne. Les solutions alternatives utilisent soit m`^ou %1`soit 1%`en première ligne. Tous ces éléments correspondent à la position au début de chaque ligne et la remplacent par quatre espaces.

Cheddar, 31 octets

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

Vraiment simplement, mais j'ai posté car ça montre les nouveaux opérateurs fonctionnels.

(" ":+)est le même que A -> " " + A. (c'est-à-dire +op en fonction avec " "lié à LHS).

Je ne pense même pas avoir besoin d'explication

Python ,  44  39 octets

Biffé & nbsp; 44 & nbsp; n'a plus 44 ans :)

-5 octets grâce aux ovs (éviter la mise en file d'attente avec un préfixe)

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

Essayez-le en ligne!

JavaScript, 26 octets

Merci @Conor O'Brien d'avoir joué au golf sur 8 octets

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

Remplacer par une expression régulière avec / g remplace toutes les instances. m fait que l'expression régulière traite chaque ligne séparément pour le début de la chaîne ^.

Essayez-le en ligne!

Python 2, 87 45 octets

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

L'entrée est prise comme 'Line1\nLine2\nLine3...'(Citations nécessaires)

Merci à @WheatWizard de m'avoir donné une idée qui m'a aidé à jouer au golf 42 octets.

Gelée , 8 octets

Ỵṭ€⁶ẋ4¤Y

Essayez-le en ligne!

Comment?

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

Quelques autres variantes de 8 octets sont:
Ỵṭ€⁶Yµ4¡(4 répétitions de split sur les nouvelles lignes, clouent un seul espace);
⁶ḤḤ;ЀỴY(doubler deux fois, c'est comme multiplier par 4, Ѐmappe sur le bon argument, donc nous pouvons concaténer au lieu de clouer);
et autres réarrangements de ceux-ci.

Emacs, 5 clés, 5 octets

C-x h M-4 C-x tab

Dans au moins un codage couramment utilisé pour la saisie au clavier, chacun de ces accords est un octet unique: 18 68 b4 18 09 . Les entrées Emacs ont tendance à être très lourdes, car chaque caractère ASCII imprimable se distingue par lui-même, sauf en tant que caractère ultérieur d'une commande à plusieurs caractères (ce qui signifie que seuls les accords peuvent être utilisés pour donner des commandes réelles).

Je ne sais pas comment cela se compare à Vim (par opposition à V). Mais Vim est assez couramment utilisé sur PPCG, et j'ai donc pensé que l'autre côté des guerres de l'éditeur méritait également son temps sous les projecteurs.

Cela suppose que les E / S sont effectuées via le tampon (l'équivalent des conventions d'E / S normales pour vim), ou extraites d'un fichier et sorties sur l'écran (ce qui revient au même). Si vous effectuez des E / S via la région à la place, ce qui est naturel pour certaines formes de programme, vous pouvez supprimer les deux premiers caractères, pour un score de 3 octets; cependant, je ne pense pas que cela soit conforme aux règles du PPCG.

Explication

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

Le dernier builtin utilisé ici est, bien sûr, incroyablement utile pour ce défi; le reste n'est que structure.

PowerShell, 29 28 octets

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

-1 Merci à fergusq, en utilisant une nouvelle ligne réelle au lieu du `n

prend l' "$args"entrée sous forme de chaîne (transtypée à l'aide de "s) et la -splitplace sur une nouvelle ligne, puis la boucle ( %{}) à travers elle, en ajoutant quatre espaces ( " "*4) et la ligne ( $_) puis la renvoie implicitement.

Pyth, 10 octets

jm+*4\ d.z

Essayez!

Si l'entrée en tant que liste de lignes était autorisée, je pourrais le faire en 7 octets:

jm+*4\ 

Essayez ça

solutions plus longues:

12 octets:

+*4d:Eb+b*4d

12 octets:

+*4dj+b*4d.z

13 octets:

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

Röda , 21 octets

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

Essayez-le en ligne!

Il s'agit d'une fonction anonyme. L'entrée est extraite du flux.

Explication:

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

Perl 5 , 11 + 1 = 12 octets

11 octets de code + -pindicateur.

s/^/    /mg

Essayez-le en ligne!

Pour une fois, les explications seront courtes: l'expression régulière remplace chaque début de ligne ( ^combiné avec le /mmodificateur) par quatre espaces - la fin.

Perl 6 , 11 octets

*.indent(4)

Essayez-le

Étendu:

*\       # 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 octets

s/^/    /

Essayez-le en ligne!

Modifications

Réduction de la taille de la solution de 16 à 10 octets grâce à Kritixi Lithos .

-1 octet grâce à seshoumara .

Java 7, 58 octets

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

Explication:

Essayez-le ici.

• Ajouter avec quatre espaces principaux
• Remplacez chaque nouvelle ligne par une nouvelle ligne + quatre espaces

Brain-Flak , 109103 octets

-6 grâce à Wheat Wizard

Comprend +1 pour -c

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

Essayez-le en ligne!

((()()()()()){})        # 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 octets

<?="    ".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!