При использовании разметки, как в сети SE, отступ в четыре пробела перед строкой текста обозначает ее как часть блока кода, как я надеюсь, вы знаете. Если вы этого не сделаете, вот пример (с .представлением пробела):

.... код
.... больше код

результаты в

Code
More code

Проблема в том, что когда вы копируете и вставляете код в ответ, вам нужно делать отступ каждой строки вручную. Это особенно сложно при работе с кодом без кода, поскольку он, вероятно, уже имеет отступ и может вызвать путаницу. Вы можете просто выбрать свой код и нажать Ctrl + K, оказывается. Часы моей жизни впустую без причины ...

Итак, ваша цель, учитывая ввод, вернуть его с четырьмя пробелами перед каждой строкой. В духе экономии времени при вставке копии вы должны обрабатывать весь ввод как одну строку (при условии, что ваш язык может ее анализировать). Если ваш язык не может обработать символ (например, новые строки) в строках, вы можете предположить, что он обозначается / экранируется с помощью другого метода, поддерживаемого языком; однако выходные данные должны выводить каждую строку в отдельной строке (поэтому не нужно передавать что-то подобное ....foo\n....bar).

Стандартные лазейки не допускаются. Поскольку это код-гольф , выигрывает самый короткий ответ в байтах. Удачи!

V , 4 байта

Î4É 

Попробуйте онлайн!

(Обратите внимание на завершающий пробел)

V кодируется в Latin1, где это кодируется так:

00000000: ce34 c920                                .4. 

объяснение

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

Вот решение, которое также составляет 4 байта в UTF-8!

VG4>

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

Crayon , 7 байтов

`¤q;3xq

Попробуйте онлайн!

объяснение

Crayon - это стековый язык, предназначенный для создания ASCII-арта. Он все еще находится на ранней стадии разработки, но он знает достаточно, чтобы завершить эту задачу с довольно низким количеством байтов:

         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

Рисование неразрывного пробела необходимо, потому что Crayon автоматически обрезает вывод в прямоугольник, поэтому без NBSP он просто напечатает исходный ввод.

Сетчатка , 8 байт

%`^

Попробуйте онлайн!

На второй строке четыре пробела. Альтернативные решения используют либо m`^или, %1`либо 1%`в первой строке. Все они соответствуют позиции в начале каждой строки и заменяют ее четырьмя пробелами.

Чеддер, 31 байт

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

Действительно просто, но я написал, потому что это демонстрирует новые функциональные операторы.

(" ":+)так же, как A -> " " + A. (т.е. +оп как функция с " "привязкой к LHS).

Я не думаю, что даже нуждается в объяснении

Python ,  44  39 байт

Вычеркнуто 44 & NBSP; больше не 44 :)

-5 байт благодаря ovs (избегайте удаления с предприставкой)

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

Попробуйте онлайн!

JavaScript, 26 байт

Спасибо @Conor O'Brien за игру в 8 байт

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

Заменить на регулярное выражение с / g заменяет все экземпляры. m заставляет регулярное выражение обрабатывать каждую строку отдельно для начала строки ^.

Попробуйте онлайн!

Python 2, 87 45 байт

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

Ввод принимается как 'Line1\nLine2\nLine3...'(необходимо цитаты)

Спасибо @WheatWizard за предоставленную мне идею, которая помогла мне сыграть в гольф 42 байта.

Желе , 8 байт

Ỵṭ€⁶ẋ4¤Y

Попробуйте онлайн!

Как?

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

Некоторые другие 8-байтовые варианты:
Ỵṭ€⁶Yµ4¡(4 повторения разбиения на новых строках, вставьте один пробел);
⁶ḤḤ;ЀỴY(удвоение в два раза похоже на умножение на 4, Ѐсопоставление с правильным аргументом, поэтому мы можем объединять вместо привязки);
и другие их перестановки.

Emacs, 5 брелоков, 5 байт

C-x h M-4 C-x tab

По крайней мере, в одной обычно используемой кодировке для ввода с клавиатуры каждая из этих цепочек ключей представляет собой один байт: 18 68 b4 18 09 . Записи в Emacs, как правило, очень тяжелы для ключей, так как каждый печатный символ ASCII обозначает себя, за исключением последующего символа многосимвольной команды (это означает, что только действующие команды могут использоваться только для ключей).

Я не уверен, как это сравнивается с Vim (в отличие от V). Но Vim довольно широко используется в PPCG, и поэтому я подумал, что другая сторона войн редакторов также заслуживает своего времени в центре внимания.

Это предполагает, что ввод / вывод осуществляется через буфер (эквивалент нормальных соглашений ввода / вывода для vim) или берется из файла и выводится на экран (что аналогично). Если вместо этого вы выполняете ввод-вывод через регион, что является естественным для некоторых форм программы, вы можете удалить два первых символа, чтобы получить оценку 3 байта; Однако я не думаю, что это соответствует правилам PPCG.

объяснение

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

Последнее встроенное здесь, конечно, невероятно полезно для этой задачи; остальное просто структура.

PowerShell, 29 28 байт

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

-1 Благодаря fergusq, используя реальный перевод строки вместо `n

принимает "$args"входные данные в виде строки (приведенной с использованием "s") и -splitпомещает ее на новую строку , затем %{}перебирает ( ) через нее, добавляя четыре пробела ( " "*4) и строка ( $_) затем выводит ее неявно.

Pyth, 10 байт

jm+*4\ d.z

Попытайся!

Если бы вход в виде списка строк был разрешен, я мог бы сделать это в 7 байтов:

jm+*4\ 

Попробуй это

более длинные решения:

12 байт:

+*4d:Eb+b*4d

12 байт:

+*4dj+b*4d.z

13 байт:

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

Рёда , 21 байт

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

Попробуйте онлайн!

Это анонимная функция. Вход извлекается из потока.

Объяснение:

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

Perl 5 , 11 + 1 = 12 байт

11 байт кода + -pфлаг.

s/^/    /mg

Попробуйте онлайн!

На этот раз объяснения будут короткими: регулярное выражение заменяет каждое начало строки (в ^сочетании с /mмодификатором) на четыре пробела - конец.

Perl 6 , 11 байт

*.indent(4)

Попытайся

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 байт

s/^/    /

Попробуйте онлайн!

Правки

Уменьшен размер решения с 16 до 10 байт благодаря Kritixi Lithos .

-1 байт благодаря сешумаре .

Java 7, 58 байт

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

Объяснение:

Попробуй это здесь.

• Добавить с четырьмя ведущими пробелами
• Заменить каждую новую строку на новую строку + четыре пробела

Brain-Flak , 109 103 байта

-6 благодаря Мастеру Пшеницы

Включает +1 для -c

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

Попробуйте онлайн!

((()()()()()){})        # 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 байта

<?="    ".strtr($_GET[0],["\n"=>"\n    "]);

С накоплением , 13 байтов

'^'4' '*mrepl

Попробуйте онлайн!

объяснение

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

Октава, 17 байт

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

Попробуйте онлайн!

MATL , 12 байт

10&Yb"4Z"@gh

Ввод - это строка с символами новой строки. Чтобы ввести это, вам нужно объединить символ 10 между обычными символами для представления новой строки (квадратные скобки являются конкатенацией):

['Code' 10 'More code']

Попробуйте это в MATL онлайн!

объяснение

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

беги с php -R <code>. -Rзапускает данный код для каждой строки ввода и $argnполучает текущую строку ввода. Так что это просто печатает каждую строку с дополнительными четырьмя пробелами перед ней.

V , 3 байта (не конкурирует)

4>G

В этом ответе используется функция, которую я планировал добавить некоторое время, но только что нашел способ добавить сегодня. Это делает этот ответ неконкурентным и недействительным для победы. Но все же здорово показать такую ​​полезную / конкурентоспособную особенность!

Попробуйте онлайн!

Объяснение:

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 нажатий клавиш

<Ctrl-V>G4I <Esc>

Предполагается, что курсор находится в начале файла, как если бы вы открывали файл из командной строки с помощью 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

С ВИМ настроен для использования 4 пробела для отступа было бы 2 нажатия клавиш: >G.

Japt , 7 6 байт

Сохранено 1 байт благодаря @ETHproductions

miS²²R

Попробуйте онлайн!

Объяснение:

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

UberGenes , 62 байта

Мне пришлось вступить в эту проблему с UberGenes, так как очень похожая программа (в которую вставлен только один пробел) была одной из первых программ, которые я когда-либо писал на языке, и казалось, что ее будет легко изменить для этой цели.

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

Как это устроено:

=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 байт

Благодаря @ Challenger5 за исправление

qN/{S4*\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 байт

~:gsub&' '*4&/^/

объяснение

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

Это прямо переводит на (в Ruby):

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

На самом деле , 16 байтов

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

Попробуйте онлайн!

Объяснение:

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 байт

p(){printf("    ");}f(char*s){for(p();*s;)putchar(*s++)-10||p();}

Попробуйте онлайн!