Nhiệm vụ của bạn là viết một chương trình (hoặc hàm) sẽ lấy một chuỗi làm đầu vào và nối văn bản vào đầu mỗi dòng thỏa mãn các quy tắc sau:

• Văn bản được nối phải chứa số dòng. Bạn có thể sử dụng lập chỉ mục dựa trên 0 hoặc 1.
• Các văn bản phải là một nhận xét trong ngôn ngữ của bạn. Một nhận xét được định nghĩa là một đoạn mã hợp lệ cú pháp mà không làm thay đổi trạng thái của chương trình. Xóa bình luận sẽ không làm thay đổi chương trình.
• Nhận xét chỉ có thể chứa các dòng mới ở cuối của nó.
• Bạn không phải đặt số dòng cho các dòng chỉ chứa khoảng trắng và nhận xét.

Thông số kỹ thuật

• Bạn có thể cho rằng đầu vào sẽ là một chương trình hợp lệ trong ngôn ngữ của bạn.
• Trong các ngôn ngữ nhạy cảm thụt lề như Python, bạn có thể đặt nhận xét số dòng sau khi thụt lề. Bạn có thể chọn một trong hai tab hoặc khoảng trắng làm ký tự thụt lề, nhưng bạn phải chỉ định trên bài đăng của mình.
• Bạn có thể giả định rằng mọi câu lệnh trong mã sẽ chiếm tối đa toàn bộ 1 dòng; tức là không có chuỗi nhiều dòng hoặc dấu gạch chéo ngược tiếp tục.

Các trường hợp thử nghiệm

Con trăn

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

C: (Thành thật mà nói, tôi rất ngạc nhiên khi biên dịch này)

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

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Pyke, 7 byte

o\Kz++r

Hãy thử nó ở đây!

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

Tôi đang khai báo các nhận xét số nguyên là số nguyên theo sau là ký tự Kvà sau đó là dòng. Một byte bổ sung được sử dụng để ngăn opcode dòng mới khởi động và in thêm một thứ.

Perl, 8 + 1 = 9 byte

say"#$."

Chạy với -p (1 byte hình phạt). (Lưu ý với những người không quen thuộc với quy tắc PPCG; bạn cũng cần chỉ định một phiên bản hiện đại của cú pháp Perl bằng cách sử dụng-M5.010 , nhưng chúng tôi đã quyết định rằng các tùy chọn để chọn phiên bản ngôn ngữ là miễn phí và không bị phạt byte, vì vậy tôi đã không đề cập đến nó trong phiên bản gốc của bài đăng này.)

-pđặt chương trình vào một vòng lặp ngầm; về cơ bản, nó làm cho chương trình trở thành một bộ lọc xử lý từng dòng riêng biệt (tức là toàn bộ chương trình được chạy trên dòng đầu tiên, sau đó là dòng thứ hai, sau đó là thứ ba, v.v.). Perl cũng theo dõi một số dòng, được gọi $., ghi lại có bao nhiêu dòng đầu vào đã được đọc. Vì vậy, tất cả các hoạt động của chương trình là cho phép -pđọc một dòng đầu vào; đầu ra a #, số dòng hiện tại ( $.) và một dòng mới ( saythêm một dòng mới theo mặc định, rất hữu ích trong trường hợp này và cũng ngắn hơn so với thông thường hơn print); và sau đó cho phép-p xuất dòng mã gốc mà nó đọc (thường là chương trình sử dụng-psẽ thực hiện một số loại xử lý trên đầu vào, nhưng vì chúng tôi đã không làm, nó chỉ là đầu ra không thay đổi). Nhận xét trong Perl chạy từ #một dòng mới ( #trong chính chương trình không bắt đầu nhận xét vì nó nằm trong chuỗi ký tự), vì vậy, về cơ bản, chúng tôi đang làm là tận dụng cơ hội để viết các dòng nhận xét vào tệp khi chúng tôi xử lý nó , mà không làm phiền chu kỳ đọc và viết "tự nhiên" của -p.

Javascript, 43 39 byte

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

Cảm ơn ETH và Conor đã lưu 4 byte.

V , 10 byte

O:1òYjjP

Hãy thử trực tuyến!

Mẻ, 91 byte

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

Batch không có cách đọc STDIN cho đến EOF, vì vậy thay vào đó tên tệp phải được truyền dưới dạng tham số dòng lệnh.

Lua, 80 75 byte

Đã lưu một số byte bằng cách lạm dụng langauge.

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

Câu trả lời khởi đầu đủ đơn giản.

Ung dung, +

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

Gema, 16 15 ký tự

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

Trong Gema chỉ có dòng bình luận, bắt đầu bằng !.

Chạy mẫu:

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!

Sau đây là để trả lời Adám , liệu có thể thêm số dòng bằng loại mã bị bỏ qua hay không.

Mã Gema về cơ bản là một tập hợp từ = đến quy tắc chuyển đổi hoặc template = hành động theo thuật ngữ Gema. Tôi thấy không có cách nào để xác định một mẫu sẽ không bao giờ khớp với bất cứ thứ gì, điều này một mình dường như không phải là cách.

Gema, 18 ký tự

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

Biến e=3thành c:=1;:e=3.

May mắn thay trong Gema có các miền , loại không gian tên. Đoạn mã trên xác định các quy tắc giả trong không gian tên c, mà chúng ta không bao giờ sử dụng. Thật không may, một tên miền được đề cập vẫn có hiệu lực cho đến cuối dòng, vì vậy chúng tôi phải rõ ràng để chuyển trở lại tên miền mặc định.

Gema, 18 ký tự

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

Biến e=3thành 1=$0;e=3.

Một thay thế ít phức tạp hơn là sử dụng mã vô hiệu thay vì bỏ qua. Tôi có nghĩa là để đặt lại chính xác những gì đã được khớp.

Qbasic, 91 89 byte

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

Đầu vào:

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

Đầu ra:

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

BASH (+ GNU sed) 27 byte

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

Phần đầu tiên (i# \n = ) gần như hoạt động trong GNU sed (cho 4 byte), nhưng nó đặt một dòng mới sau #.

ôi ( 19 13 byte)

19 byte : Chèn "#" + số dòng trên mỗi dòng mã

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

13 byte : Tín dụng & cảm ơn @manatwork cho hai giải pháp 13 byte

Khi 1hành động mặc định là print $0:

{print"#"NR}1

Hoặc bằng cách thay thế $0nội dung

$0="#"NR RS$0

Hàm mở rộng Kotlin, 69 60 byte

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

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

Ví dụ sử dụng:

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

Đầu ra:

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

CJam, 21 byte

Tôi không rành về CJam chút nào, nhưng tôi biết thực tế là nó có ý kiến ​​:)

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

Giải thích đến sớm.

Toán học, 58 byte

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

jq, 31 ký tự

(Mã 27 ký tự + 4 ký tự tùy chọn dòng lệnh.)

"#\(input_line_number)\n"+.

Trong jq chỉ có nhận xét dòng, bắt đầu bằng # .

Chạy mẫu:

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 byte

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

Chỉ có nhận xét dòng bắt đầu bằng "#".

Ungolfed & giải thích:

           # 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

Tôi khá chắc chắn rằng điều này có thể được đơn giản hóa hơn nữa, đặc biệt là i có thể bị bỏ lại.

Bạn có thể kiểm tra nó tại đây: https://golfscript.apphb.com/ Vì trang web này không hỗ trợ thêm đầu vào, bạn sẽ phải đặt một chuỗi được bao quanh với dấu ngoặc kép ở phía trước mã. '\n'sẽ là một dòng mới. Hãy nhận biết thực tế, rằng có những chuỗi thoát khác là tốt. Người dùng '\\'nếu bạn không chắc chắn.

C 6, 66 61 byte

Cảm ơn CSharpie

(666, mã quỷ ^^) không còn nữa ...

Điều này hoạt động cho tất cả các ngôn ngữ sử dụng "nhận xét kiểu C" (C, C ++, C #, Java, ....)

Nó chỉ đơn giản là chia chuỗi thành các dòng, thêm vào mỗi dòng với chỉ mục của nó và nối lại các dòng đã chỉnh sửa với các ký tự dòng mới.

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

phiên bản cũ:

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

Python 2, 82 byte

Hoạt động cho thụt chỉ không gian

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

Phiên bản không thụt lề cho 56 byte

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