Generate /* line number comments */

Question

Your task is to write a program (or function) that will take a string as input and append text to the beginning of every line that satisfy the following rules:

• The text appended must contain the line number. You may use 0- or 1-based indexing.
• The text must be a comment in your language. A comment is defined as a syntacticly valid piece of code that makes no changes to the program's state. Removing the comment should make no change to the program.
• The comment may only contain newlines at the end of it.
• You do not have to put line numbers for lines that contain just whitespace and comments.

Specifications

• You may assume that the input will be a valid program in your language.
• In indentation-sensitive languages like Python, you may place the line number comment after all indentation. You may choose either tabs or spaces to be your indentation character, but you must specify on your post.
• You may assume that every statement in the code will take up at most the entirety of 1 line; i.e. no multi-line strings or backslash-continuation.

Test Cases

Python:

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

C: (Honestly, I'm surprised this compiles)

/*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*/}

This is code-golf, so the shortest answer (in bytes) wins.

Answer 1

Pyke, 7 bytes

o\Kz++r

Try it here!

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

I'm declaring integer comments to be the integer followed by the character K and then the line. An extra byte is used to stop the newline opcode from kicking in and printing an extra thing.

Answer 2

Perl, 8+1 = 9 bytes

say"#$."

Run with -p (1 byte penalty). (Note to people unfamiliar with PPCG rules; you also need to specify a modern version of Perl syntax using -M5.010, but we decided that options to select language versions are free and don't incur a byte penalty, so I didn't mention it in the original version of this post.)

-p places the program into an implicit loop; it basically causes the program to become a filter that processes each line separately (i.e. the entire program is run on the first line, then the second, then the third, and so on). Perl also keeps track of a line number, called $., that records how many lines of input have been read. So all the program's doing is letting -p read a line of input; output a #, the current line number ($.), and a newline (say adds a newline by default, which is helpful in this case, and is also shorter than the more commonly seen print); and then letting -p output the original line of code that it read (typically a program using -p would do some sort of processing on the input, but because we didn't, it's just output unchanged). Comments in Perl run from # to a newline (the # in the program itself doesn't start a comment because it's inside a string literal), so what we're basically doing is taking the opportunity to write comment lines into the file as we process it, without disturbing the "natural" read and write cycle of -p.

Answer 3

Javascript, 43 39 bytes

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

Thanks to ETH and Conor for saving 4 bytes.

Answer 4

V, 10 bytes

O:1òYjjP

Try it online!

Answer 5

Lua, 80 75 Bytes

Saved some bytes by abusing the langauge.

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

Simple enough starter answer.

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. \
                    ')
                 )
      )

Answer 6

Batch, 91 bytes

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

Batch doesn't have a way of reading STDIN until EOF, so instead the file name has to be passed as a command-line parameter.

Answer 7

Gema, 16 15 characters

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

In Gema there are only line comments, starting with !.

Sample run:

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!

The following are to answer Adám's question, whether is possible to add the line number in kind of ignored code.

Gema code is essentially a collection of from=to transformation rules, or template=action in Gema terms. I see no way to define a template that will never ever match anything, this alone not seems to be the way.

Gema, 18 characters

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

Transforms e=3 into c:=1;:e=3.

Luckily in Gema there are domains, kind of namespaces. The above code defines the dummy rules in namespace c, that we never use. Unfortunately a mentioned domain remains in effect until the end of line, so we have to explicitly to switch back to default domain.

Gema, 18 characters

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

Transforms e=3 into 1=$0;e=3.

A less complicated alternative is to use effectless code instead of ignored one. I mean to put back exactly what was matched.

Answer 8

Kotlin extension function, 69 60 bytes

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

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

Example usage:

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

Output:

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

Answer 9

Qbasic, 91 89 bytes

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

Input:

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

Output:

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

Answer 10

BASH (+ GNU sed) 27 bytes

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

The first part (i# \n =) almost works in GNU sed (for 4 bytes), but it puts a newline after the #.

Answer 11

awk (19 13 bytes)

19 bytes : This insert "#"+line number above each line of code

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

13 bytes : Credit & thanks to @manatwork for two 13 bytes solution

As 1 action defaults to print $0:

{print"#"NR}1

Or by replacing $0 content

$0="#"NR RS$0

Answer 12

CJam, 21 Bytes

I am not well-versed in CJam at all, but I knew for a fact it has comments :)

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

Explanation coming soon.

Answer 13

Mathematica, 58 bytes

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

Answer 14

jq, 31 characters

(27 characters code + 4 characters command line options.)

"#\(input_line_number)\n"+.

In jq there are only line comments, starting with #.

Sample run:

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!

Answer 15

C# 6, 66 61 bytes

Thanks to CSharpie

(666, devils code ^^) not any more ...

This works for all languages using "C style comments" (C, C++, C#, Java, ....)

It simply splits the string into lines, prepends every line with its index and joins the edited lines again with new line characters.

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

old version:

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

Answer 16

GolfScript, 23 Bytes

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

There are only line comments starting with "#".

Ungolfed & explained:

           # 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 am pretty sure that this can be further simplified, especially the i can probably be left out.

You can test it here: https://golfscript.apphb.com/ Because this site doesn't support adding inputs, you'll have to put a string surrounded with double quotes in front of the code. '\n' will be a newline. Be aware of the fact, that there are other escape sequences as well. User '\\' if you are not sure.

Answer 17

Python 2, 82 bytes

Works for space-only indentation

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

Indentation-less version for 56 bytes

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