Wenn Sie Markup wie im SE-Netzwerk verwenden, wird es, wie Sie vielleicht wissen, durch einen Einzug von vier Leerzeichen vor einer Textzeile als Teil eines Codeblocks gekennzeichnet. Wenn nicht, hier ein Beispiel (mit .Darstellung eines Leerzeichens):

.... Code
.... Mehr Code

Ergebnisse in

Code
More code

Das Problem ist, dass Sie beim Kopieren und Einfügen von Code in eine Antwort jede Zeile manuell einrücken müssen. Dies ist besonders schwierig, wenn Sie mit ungolfed Code arbeiten, da dieser wahrscheinlich bereits eingerückt ist und Verwirrung stiften kann. Sie können einfach Ihren Code auswählen und drücken Ctrl + K, es stellt sich heraus. Stunden meines Lebens ohne Grund verschwendet ...

Ihr Ziel ist es also, eine Eingabe mit vier Leerzeichen vor jeder Zeile zurückzugeben. Um Zeit beim Kopieren und Einfügen zu sparen, müssen Sie die gesamte Eingabe als einzelne Zeichenfolge verarbeiten (sofern Ihre Sprache sie analysieren kann). Wenn Ihre Sprache ein Zeichen (z. B. Zeilenumbrüche) in Zeichenfolgen nicht verarbeiten kann, können Sie davon ausgehen, dass es durch eine andere von der Sprache unterstützte Methode gekennzeichnet / maskiert wird. Die Ausgabe muss jedoch jede Zeile in einer eigenen Zeile ausgeben (also keine Übergabe wie ....foo\n....bar).

Standardlücken sind nicht erlaubt. Da es sich um Code-Golf , die kürzeste Antwort in Bytes gewinnt. Viel Glück!

V , 4 Bytes

Î4É 

Probieren Sie es online!

(Beachten Sie das nachfolgende Leerzeichen)

V ist in Latin1 codiert, wobei dies folgendermaßen codiert ist:

00000000: ce34 c920                                .4. 

Erläuterung

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

Hier ist eine Lösung, die auch 4 Bytes in UTF-8 ist!

VG4>

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

Buntstift , 7 Bytes

`¤q;3xq

Probieren Sie es online!

Erläuterung

Crayon ist eine stapelbasierte Sprache zum Erstellen von ASCII-Grafiken. Es befindet sich noch im Anfangsstadium der Entwicklung, aber es weiß gerade genug, um diese Herausforderung mit einer relativ geringen Anzahl von Bytes abzuschließen:

         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

Das Zeichnen des geschützten Bereichs ist erforderlich, da Crayon die Ausgabe automatisch auf ein Rechteck zuschneidet. Ohne NBSP wird nur die ursprüngliche Eingabe gedruckt.

Retina , 8 Bytes

%`^

Probieren Sie es online!

In der zweiten Zeile stehen vier Leerzeichen. Alternative Lösungen verwenden entweder m`^oder %1`oder 1%`in der ersten Zeile. All dies stimmt mit der Position am Anfang jeder Zeile überein und ersetzt sie durch vier Leerzeichen.

Cheddar, 31 Bytes

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

Wirklich einfach, aber ich habe gepostet, weil es die neuen Funktionsoperatoren zeigt.

(" ":+)ist das gleiche wie A -> " " + A. (dh +op als eine Funktion mit " "gebunden an LHS).

Ich glaube nicht, dass es einer Erklärung bedarf

Python ,  44  39 Bytes

Durchgestrichen & nbsp; 44 & nbsp; ist nicht mehr 44 :)

-5 Bytes dank Ovs (Vermeiden Sie das Löschen mit einem Prepend)

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

Probieren Sie es online!

JavaScript, 26 Bytes

Vielen Dank an @Conor O'Brien, dass er 8 Bytes abgespielt hat

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

Durch einen regulären Ausdruck mit / g ersetzen ersetzt alle Instanzen. m veranlasst den Regex, jede Zeile für den Beginn der Zeichenfolge ^ separat zu behandeln.

Probieren Sie es online!

Python 2, 87 45 Bytes

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

Eingabe wird als genommen 'Line1\nLine2\nLine3...'(Anführungszeichen erforderlich)

Vielen Dank an @WheatWizard, dass Sie mir eine Idee gegeben haben, die mir beim Golfen von 42 Bytes geholfen hat.

Gelee , 8 Bytes

Ỵṭ€⁶ẋ4¤Y

Probieren Sie es online!

Wie?

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

Einige andere 8-Byte-Varianten sind:
Ỵṭ€⁶Yµ4¡(4 Teilungswiederholungen in Zeilenumbrüchen, ein einzelnes Leerzeichen anheften);
⁶ḤḤ;ЀỴY(Zweimaliges Verdoppeln ist wie das Multiplizieren mit 4, ЀKarten über dem richtigen Argument, damit wir verketten können, anstatt zu heften);
und andere Umlagerungen davon.

Emacs, 5 Keychords, 5 Bytes

C-x h M-4 C-x tab

In zumindest einer häufig verwendeten Codierung für die Tastatureingabe, jede dieser keychords ist ein einzelnes Byte: 18 68 b4 18 09. Emacs-Einträge sind in der Regel sehr keychordlastig, da jedes druckbare ASCII-Zeichen für sich selbst steht, außer als nachfolgendes Zeichen eines Befehls mit mehreren Zeichen (dh, nur Keychords können verwendet werden, um tatsächliche Befehle zu geben).

Ich bin mir nicht sicher, wie dies mit Vim verglichen wird (im Gegensatz zu V). Aber Vim wird ziemlich häufig für PPCG verwendet, und deshalb dachte ich, dass die andere Seite des Editor-Krieges es verdient, auch im Rampenlicht zu stehen.

Dies setzt voraus, dass die E / A über den Puffer (das Äquivalent der normalen E / A-Konventionen für vim) oder aus einer Datei entnommen und auf dem Bildschirm ausgegeben wird (was dasselbe ist). Wenn Sie die E / A-Vorgänge stattdessen über die Region ausführen, was für einige Programmarten selbstverständlich ist, können Sie die beiden führenden Zeichen entfernen, um eine Punktzahl von 3 Byte zu erzielen. Ich glaube jedoch nicht, dass dies den PPCG-Regeln entspricht.

Erläuterung

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

Der letzte hier verwendete Build ist natürlich unglaublich nützlich für diese Herausforderung; der rest ist nur struktur.

PowerShell, 29 28 Bytes

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

-1 Dank fergusq wird anstelle des `n ein tatsächlicher Zeilenumbruch verwendet

Nimmt die "$args"Eingabe als Zeichenfolge (umgewandelt mit "s") und setzt -splitsie in eine neue Zeile, durchläuft sie mit einer Schleife ( %{}), fügt vier Leerzeichen ( " "*4) hinzu und die Zeile ( $_) gibt sie implizit aus.

Pyth, 10 Bytes

jm+*4\ d.z

Versuch es!

Wenn die Eingabe als Liste von Zeilen zulässig wäre, könnte ich dies in 7 Bytes tun:

jm+*4\ 

Versuch das

längere lösungen:

12 Bytes:

+*4d:Eb+b*4d

12 Bytes:

+*4dj+b*4d.z

13 Bytes:

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

Röda , 21 Bytes

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

Probieren Sie es online!

Es ist eine anonyme Funktion. Die Eingabe wird aus dem Stream gezogen.

Erläuterung:

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

Perl 5 , 11 + 1 = 12 Bytes

11 Byte Code + -pFlag.

s/^/    /mg

Probieren Sie es online!

Die Erklärungen sollen einmal kurz sein: Der reguläre Ausdruck ersetzt jeden Zeilenanfang ( ^kombiniert mit dem /mModifikator) durch vier Leerzeichen - das Ende.

Perl 6 , 11 Bytes

*.indent(4)

Versuch es

Erweitert:

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

Probieren Sie es online!

Bearbeitungen

Reduzierte Lösungsgröße von 16 auf 10 Byte dank Kritixi Lithos .

-1 Byte dank Seshoumara .

Java 7, 58 Bytes

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

Erläuterung:

Probieren Sie es hier aus.

• Fügen Sie vier führende Leerzeichen hinzu
• Ersetzen Sie jede neue Zeile durch eine neue Zeile + vier Leerzeichen

Brain-Flak , 109 103 Bytes

-6 dank Weizen-Assistent

Beinhaltet +1 für -c

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

Probieren Sie es 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    "]);

Gestapelt , 13 Bytes

'^'4' '*mrepl

Probieren Sie es online!

Erläuterung

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

Oktave, 17 Bytes

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

Probieren Sie es online!

MATL , 12 Bytes

10&Yb"4Z"@gh

Die Eingabe ist eine Zeichenfolge mit Zeilenumbrüchen. Um dies einzugeben, müssen Sie das Zeichen 10 zwischen den normalen Zeichen verketten, um die Newline darzustellen (eckige Klammern sind die Verkettung):

['Code' 10 'More code']

Probieren Sie es bei MATL online!

Erläuterung

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

renn mit php -R <code>. -Rführt den angegebenen Code für jede Eingabezeile aus und $argnerhält die aktuelle Eingabezeile. Auf diese Weise wird einfach jede Zeile mit vier zusätzlichen Leerzeichen gedruckt.

V , 3 Bytes (nicht konkurrierend)

4>G

In dieser Antwort wird eine Funktion verwendet, die ich schon seit einiger Zeit hinzufügen möchte, die ich aber erst heute hinzugefügt habe. Das macht diese Antwort nicht konkurrierend und ungültig für das Gewinnen. Aber es ist immer noch cool, ein so nützliches / wettbewerbsfähiges Feature zu präsentieren!

Probieren Sie es online!

Erläuterung:

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 Tastenanschläge

<Ctrl-V>G4I <Esc>

Es wird davon ausgegangen, dass sich der Cursor am Anfang der Datei befindet, als ob Sie die Datei von der Befehlszeile aus über geöffnet hätten 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

Mit einem Vim für Einbuchtung 4 verwenden Räume konfiguriert wäre es 2 Tastenanschläge werden: >G.

Japt , 7 6 Bytes

1 Byte dank @ETHproductions eingespart

miS²²R

Probieren Sie es online!

Erläuterung:

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

UberGenes , 62 Bytes

Ich musste mich mit UberGenes dieser Herausforderung stellen, da ein sehr ähnliches Programm (das nur ein Leerzeichen einfügte) eines der ersten Programme war, die ich jemals in der Sprache geschrieben habe, und es schien, als wäre es einfach, es für diesen Zweck zu ändern.

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

Wie es funktioniert:

=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

Danke an @ Challenger5 für die Korrektur

qN/{S4*\N}%

Probieren Sie es online!

Erläuterung

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

Erläuterung

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

Dies übersetzt direkt in (in Ruby):

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

Eigentlich 16 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online!