Markup kullanırken, SE ağında olduğu gibi, bir metin satırından önce dört boşluğun girintisi, bildiğiniz gibi, bir kod bloğunun parçası olarak ifade eder. Yapmazsanız, bir örnek ( .bir alanı temsil eden):

.... Kod
.... Daha fazla kod

sonuç

Code
More code

Sorun, kodu bir cevaba kopyalayıp yapıştırdığınızda, her satırı elle girintilemenizdir. Bu, özellikle girintisiz kodla çalışırken, zaten girintili olduğu ve karışıklığa neden olabileceği için özellikle zordur. Sadece kodunuzu seçip vurabilir Ctrl + K, ortaya çıkıyor. Hayatımın saatleri, sebepsiz yere boşa harcandı ...

Yani, hedefiniz, bir girdi verildiğinde, her satırdan önce dört boşlukla döndürmektir. Kopya yapıştırmadan tasarruf etme ruhuyla, tüm girdiyi tek bir dize olarak işleyeceksiniz (diliniz ayrıştırabildiği sürece). Diliniz dizelerde bir karakteri (yeni satırlar gibi) işleyemiyorsa, dil tarafından desteklenen başka bir yöntemle belirtildiğini / kaçıldığını varsayabilirsiniz; ancak, çıktı her satırı kendi satırında çıktılamalıdır (yani böyle bir şey iletilmemelidir ....foo\n....bar).

Standart boşluklara izin verilmez. Bu kod golf olduğundan , bayt cinsinden en kısa cevap kazanır. İyi şanslar!

V , 4 bayt

Î4É 

Çevrimiçi deneyin!

(Sondaki boşluğa dikkat edin)

V, Latin1 ile kodlanmıştır, burada bu şekilde kodlanmıştır:

00000000: ce34 c920                                .4. 

açıklama

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

İşte UTF-8'de 4 baytlık bir çözüm!

VG4>

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

Pastel boya , 7 bayt

`¤q;3xq

Çevrimiçi deneyin!

açıklama

Crayon, ASCII-art yaratmak için tasarlanmış, yığın tabanlı bir dildir. Hala gelişimin erken aşamalarında, ancak bu zorluğu oldukça düşük bir bayt sayısıyla bitirmek için yeterli biliyor:

         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

Kesintisiz alanın çizilmesi gereklidir çünkü Crayon çıktıyı otomatik olarak bir dikdörtgene keser, bu nedenle NBSP olmadan sadece orijinal girişi basar.

Retina , 8 bayt

%`^

Çevrimiçi deneyin!

İkinci satırda dört boşluk vardır. Alternatif çözümler birini kullanabilirsiniz m`^veya %1`veya 1%`ilk satırında. Bunların hepsi, her satırın başındaki konumla eşleşir ve yerine dört boşluk yerleştirilir.

Çedar, 31 bayt

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

Gerçekten basit, ama yeni fonksiyonel operatörleri gösterdiğinden yayınladım.

(" ":+)ile aynıdır A -> " " + A. (yani +LHS'ye " "bağlı bir fonksiyon olarak op ).

Açıklamaya bile ihtiyacı olduğunu sanmıyorum

Python ,  44  39 bayt

Kesildi & nbsp; 44 & nbsp; artık 44 değil :)

Ovs sayesinde -5 bayt (başaşağıdan ayrılmamak)

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

Çevrimiçi deneyin!

JavaScript, 26 bayt

8 bayt golf için teşekkürler @Conor O'Brien

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

/ G ile bir normal ifadeyle değiştir, tüm örnekleri değiştirir. m, normal ifadenin ^ dizesinin başlangıcı için her satıra ayrı ayrı işlem yapmasını sağlar.

Çevrimiçi deneyin!

Python 2, 87 45 bayt

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

Giriş şu şekilde alınır 'Line1\nLine2\nLine3...'(Alıntılar gereklidir)

@WheatWizard bana 42 bayt golf yardımcı bana bir fikir verdiğin için teşekkürler.

Jöle , 8 bayt

Ỵṭ€⁶ẋ4¤Y

Çevrimiçi deneyin!

Nasıl?

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

Diğer 8 bayt varyantları şunlardır:
Ỵṭ€⁶Yµ4¡(yeni satırlarda 4 bölünme, tek bir alanı yapıştırma);
⁶ḤḤ;ЀỴY(iki katına çıkma 4'le çarpmak gibidir Ѐ, doğru argümanla eşleşir, böylece teyel yapmak yerine bitiştirebiliriz);
ve bunların diğer yeniden düzenlemeleri.

Emacs, 5 keychord, 5 bayt

C-x h M-4 C-x tab

Klavye girişi için yaygın olarak kullanılan en az bir kodlamada, bu anahtar kodların her biri tek bir bayttır: 18 68 b4 18 09 . Emacs girişleri, çok karakterli bir komutun müteakip karakteri hariç, her yazdırılabilir ASCII karakteri kendisini temsil ettiğinden (anahtar komutlarının gerçek komutları vermek için kullanılabileceği anlamına gelir) çok keychord-ağır olma eğilimindedir.

Bunun Vim ile nasıl karşılaştırılacağından emin değilim (V yerine). Ancak Vim, PPCG'de oldukça yaygın olarak kullanılıyor ve bu yüzden editör savaşlarının diğer tarafının da spot ışığında zamanını hak ettiğini düşündüm.

Bu, G / Ç'nin tampon (vim için normal G / Ç kurallarının eşdeğeri) yoluyla yapıldığını veya bir dosyadan alındığını ve ekrana (aynı şeye gelir) çıktığını varsayar. Bunun yerine bazı program türleri için doğal olan bölge üzerinden G / Ç yaparsanız, önde gelen iki karakteri 3 baytlık bir puan için kaldırabilirsiniz; ancak bunun PPCG kurallarına uygun olduğunu düşünmüyorum.

açıklama

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

Burada kullanılan son yapı, elbette, bu meydan okuma için inanılmaz derecede faydalıdır; gerisi sadece yapıdır.

PowerShell, 29 28 Bayt

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

-1 fergusq sayesinde `n yerine gerçek bir satırsonu kullanma

alır "$args"(döküm kullanılarak "ler), bir dizi olarak giriş ve -split(o döngüler, bir satır üzerinde s %{}dört boşluk (ekleme, içinden) " "*4) ve hat ( $_dolaylı olarak onun çıkışlarının).

Pyth, 10 Bayt

jm+*4\ d.z

Dene!

Satır listesi olarak girişe izin verilirse, bunu 7 baytta yapabilirim:

jm+*4\ 

Bunu dene

daha uzun çözümler:

12 Bayt:

+*4d:Eb+b*4d

12 Bayt:

+*4dj+b*4d.z

13 Bayt:

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

Röda , 21 bayt

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

Çevrimiçi deneyin!

Anonim bir işlevdir. Giriş akıştan çekilir.

Açıklama:

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

Perl 5 , 11 + 1 = 12 bayt

11 bayt kod + -pbayrak.

s/^/    /mg

Çevrimiçi deneyin!

Bir kez, açıklamalar kısa olacaktır: Normal ifade satırın her başlangıcını ( değiştirici ^ile birlikte /m) dört boşlukla değiştirir - son.

Perl 6 , 11 bayt

*.indent(4)

Dene

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 bayt

s/^/    /

Çevrimiçi deneyin!

Düzenlemeler

Kritixi Lithos sayesinde 16 ila 10 bayt arasında azaltılmış çözelti boyutu .

Seshoumara sayesinde -1 bayt .

Java 7, 58 bayt

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

Açıklama:

Burada deneyin.

• Dört önde gelen boşlukla ekleyin
• 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!