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

• Добавляемый текст должен содержать номер строки. Вы можете использовать индексацию на основе 0 или 1.
• Текст должен быть комментарием на вашем языке. Комментарий определяется как синтаксически допустимый фрагмент кода, который не вносит изменений в состояние программы. Удаление комментария не должно вносить изменений в программу.
• Комментарий может содержать только новые строки в конце.
• Вам не нужно ставить номера строк для строк, которые содержат только пробелы и комментарии.

Характеристики

• Вы можете предположить, что ввод будет действительной программой на вашем языке.
• В языках, чувствительных к отступам, таких как Python, вы можете разместить комментарий к номеру строки после всех отступов. Вы можете выбрать символы табуляции или табуляции, но вы должны указать это в своем сообщении.
• Вы можете предположить, что каждое утверждение в коде будет занимать не более 1 строки; т.е. нет многострочных строк или продолжения с обратным слешем.

Тестовые случаи

Python:

#0
a = int(input())
#1
while a:
    #2
    print(a)

C: (Честно говоря, я удивлен, что это компилируется)

/*0 */#include <stdio.h>
/*1 */int main()
/*2 */{
/*3 */    char c;
/*4 */    c = getchar();
/*5 */    do
/*6 */    {
/*7 */        putchar(c);
/*8 */    }
/*9 */    while (c);
/*10*/}

Это код-гольф , поэтому выигрывает самый короткий ответ (в байтах).

Пайк, 7 байт

o\Kz++r

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

o       -  o++
 \K     -  "K"
   z    -  input()
    ++  - sum(^)
      r - while no errors: GOTO start

Я объявляю целочисленные комментарии как целое число, за которым следует символ, Kа затем строка. Дополнительный байт используется, чтобы остановить ввод кода операции новой строки и печать дополнительной вещи.

Perl, 8 + 1 = 9 байт

say"#$."

Запустить с -p(штраф 1 байт). (Обратите внимание на людей, незнакомых с правилами PPCG; вам также нужно указать современную версию синтаксиса Perl с использованием -M5.010, но мы решили, что опции для выбора языковых версий бесплатны и не несут в себе байт-штрафа, поэтому я не упомянул об этом в оригинальная версия этого поста.)

-pпомещает программу в неявный цикл; это в основном приводит к тому, что программа становится фильтром, который обрабатывает каждую строку отдельно (т. е. вся программа запускается в первой строке, затем во второй, затем в третьей и т. д.). Perl также отслеживает номер строки по имени $., который записывает, сколько строк ввода было прочитано. Таким образом, все, что делает программа, это позволяет -pпрочитать строку ввода; выведите a #, номер текущей строки ( $.) и символ новой строки ( sayпо умолчанию добавляется символ новой строки, что полезно в данном случае, а также короче, чем обычно print); и затем позволить -pвыводить исходную строку кода, которую он прочитал (обычно программа, использующая-pбудет делать какую-то обработку на входе, но поскольку мы не сделали, это просто вывод без изменений). Комментарии в Perl запускаются с #новой строки (сама #программа не запускает комментарий, потому что он находится внутри строкового литерала), поэтому мы в основном используем возможность записать строки комментариев в файл при его обработке. , не нарушая "естественного" цикла чтения и записи -p.

Javascript, 43 39 байт

a=>a.replace(/^/gm,_=>`/*${++b}*/`,b=0)

Спасибо ETH и Conor за сохранение 4 байта.

V , 10 байт

O:1òYjjP

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

Пакет, 91 байт

@set n=
@for /f "delims= tokens=*" %%a in (%1) do @set/an+=1&call echo @rem %%n%%&echo %%a

Пакетный режим не может считывать STDIN до EOF, поэтому вместо имени файла необходимо указать параметр командной строки.

Луа, 80 75 байт

Сохранение некоторых байтов за счет злоупотребления языком.

x=1print("--[[1]]"..(...):gsub("\n",load('x=x+1return"\\n--[["..x.."]]"')))

Достаточно простой стартовый ответ.

Ungolfed, +

x=1                                                     -- Assign x to 1...
print(                                                  -- Print...
      "--[[1]]"                                         -- The first line number comment...
      ..                                                -- With...
      (...):gsub(                                       -- The input, replacing all...
                 "\n",                                  -- Newlines...
                    load                                -- with a string compiled function...
                    (' \
                    x=x+1                               --Increment x by one... \
                    return"\\n--[["..x.."]]"            -- And return the new linecomment. \
                    ')
                 )
      )

Гема, 16 15 знаков

*\n=\!@line\n$0

В Gema есть только строчные комментарии, начиная с !.

Образец прогона:

bash-4.3$ cat l33t.gema 
e=3
g=9
i=1
o=0
t=7

bash-4.3$ gema -f l33t.gema <<< 'Hello World!'
H3ll0 W0rld!

bash-4.3$ gema '*\n=\!@line\n$0' < l33t.gema > l33t-nr.gema

bash-4.3$ cat l33t-nr.gema
!1
e=3
!2
g=9
!3
i=1
!4
o=0
!5
t=7

bash-4.3$ gema -f l33t-nr.gema <<< 'Hello World!'
H3ll0 W0rld!

Далее следует ответить на вопрос Адама , возможно ли добавить номер строки в виде игнорируемого кода.

Код Gema, по сути, представляет собой набор правил преобразования from = to или template = action в терминах Gema. Я не вижу способа определить шаблон , который никогда не будет соответствовать чему-либо, само по себе это не кажется подходящим.

Гема, 18 знаков

*\n=c:\=@line\;:$0

Превращается e=3в c:=1;:e=3.

К счастью, в Gema есть домены , своего рода пространства имен. Приведенный выше код определяет фиктивные правила в пространстве имен c, которые мы никогда не используем. К сожалению, упомянутый домен остается в силе до конца строки, поэтому мы должны явно переключиться обратно на домен по умолчанию.

Гема, 18 знаков

*\n=@line\=\$0\;$0

Превращается e=3в 1=$0;e=3.

Менее сложная альтернатива - использовать бессмысленный код вместо игнорируемого. Я хочу вернуть именно то, что было найдено.

Qbasic, 91 89 байт

OPEN"I",1,"i"
OPEN"O",2,"o"
DO UNTIL EOF(1)
i=i+1
INPUT#1,a$
PRINT#2,STR$(i)+"'"+a$
LOOP

Входные данные:

CLS
PRINT "Hello!"
a$="Welcome"
INPUT "Type your name: ", b$
PRINT a$; ", "; b$
END

Выход:

 1'CLS
 2'PRINT "Hello!"
 3'a$="Welcome"
 4'INPUT "Type your name: ", b$
 5'PRINT a$; ", "; b$
 6'END

BASH (+ GNU sed) 27 байт

sed 'i#
='|sed 'N;s/\n//;N'

Первая часть ( i# \n =) почти работает в GNU sed (для 4 байтов), но ставит новую строку после #.

awk ( 19 13 байт)

19 байт : эта вставка "#" + номер строки над каждой строкой кода

{print"#"NR"\n"$0}

13 байт : кредит и спасибо @manatwork за два 13-байтовых решения

Как 1действие по умолчанию print $0:

{print"#"NR}1

Или путем замены $0контента

$0="#"NR RS$0

Функция расширения Котлина, 69 60 байт

fun String.a()=lines().mapIndexed{i,s->"/*$i*/$s"}.joinToString("\n")

fun String.a(){lines().mapIndexed{i,s->println("/*$i*/$s")}}

Пример использования:

fun main(args: Array<String>) {
  //language=kotlin
  val code = """fun main(args: Array<String>) {
  println("Hello world!")
}"""
  code.a()
}

Выход:

/*0*/fun main(args: Array<String>) {
/*1*/  println("Hello world!")
/*2*/}

CJam, 21 байт

Я совсем не разбираюсь в CJam, но я точно знал, что у него есть комментарии :)

qN%ee{"e#"o(oNo(oNo}/

Объяснение скоро.

Mathematica, 58 байт

i = 1; StringReplace[#, StartOfLine :> "(*" <> ToString@i++ <> "*)"] &

JQ, 31 символов

(27 символов кода + 4 символа параметров командной строки.)

"#\(input_line_number)\n"+.

В jq есть только строчные комментарии, начиная с #.

Образец прогона:

bash-4.3$ cat l33t.jq 
gsub("e";"3")|
gsub("g";"9")|
gsub("i";"1")|
gsub("o";"0")|
gsub("t";"7")

bash-4.3$ jq -Rr -f l33t.jq <<< 'Hello World!'
H3ll0 W0rld!

bash-4.3$ jq -Rr '"#\(input_line_number)\n"+.' l33t.jq > l33t-nr.jq

bash-4.3$ cat l33t-nr.jq 
#1
gsub("e";"3")|
#2
gsub("g";"9")|
#3
gsub("i";"1")|
#4
gsub("o";"0")|
#5
gsub("t";"7")

bash-4.3$ jq -Rr -f l33t-nr.jq <<< 'Hello World!'
H3ll0 W0rld!

GolfScript, 23 байта

n/0:i;{"#"i):i+n+\+}%n*

Есть только строчные комментарии, начинающиеся с "#".

Разрушил и объяснил:

           # the input is pushed on the stack automatically
n          # n is a predefined variable for "\n"
/          # splits the input string with the previously pushed "\n" as delimiter
0:i;       # i = 0
{          # A code block: It is used for map here (going through the input)
    "#"    # push a "#" onto the stack
    i):i  # save i + 1 in i, the value is again not popped from the stack
    +      # implicitly converts the number i to a string and concatenates "#" with it
    n      # newline
    +      # add a newline (# introduces a *line* comment)
    \      # switch the top to elements (-> yields the comment as the bottom, and the line as the top element on the stack)
    +      # concatenate them
}          # end of the code block
%          # map
n          # newline
*          # join the list with newlines between them
           # outputs are done implicitly

Я почти уверен, что это может быть еще более упрощено, особенно, iвероятно, может быть опущено.

Вы можете проверить это здесь: https://golfscript.apphb.com/ Поскольку этот сайт не поддерживает добавление входных данных, вам придется поместить строку, заключенную в двойные кавычки, перед кодом. '\n'будет перевод строки. Помните о том, что существуют и другие escape-последовательности. Пользователь, '\\'если вы не уверены.

C # 6, 66 61 байт

Благодаря CSharpie

(666, код дьяволов ^^) больше нет ...

Это работает для всех языков, использующих «комментарии в стиле C» (C, C ++, C #, Java, ....)

Он просто разбивает строку на строки, добавляет в каждую строку свой индекс и снова соединяет отредактированные строки с символами новой строки.

s=>string.Join("\n",s.Split('\n').Select((l,i)=>$"/*{i}*/"+l));

старая версия:

s=>string.Join("\n",s.Split('\n').Select((l,i)=>$"/*{i,3}*/{l}"));

Python 2, 82 байта

Работает только для отступов

for i,l in enumerate(input().split('\n')):print l.split(l.lstrip())[0]+'#%d\n'%i+l

Версия без отступов для 56 байт

for x in enumerate(input().split('\n')):print'#%d\n%s'%x