Su tarea es escribir un programa (o función) que tomará una cadena como entrada y agregará texto al comienzo de cada línea que satisfaga las siguientes reglas:

• El texto adjunto debe contener el número de línea. Puede usar indexación basada en 0 o 1.
• El texto debe ser un comentario en su idioma. Un comentario se define como un fragmento de código sintácticamente válido que no realiza cambios en el estado del programa. Eliminar el comentario no debería hacer ningún cambio en el programa.
• El comentario solo puede contener nuevas líneas al final.
• No tiene que poner números de línea para las líneas que contienen solo espacios en blanco y comentarios.

Especificaciones

• Puede suponer que la entrada será un programa válido en su idioma.
• En lenguajes sensibles a la sangría como Python, puede colocar el comentario del número de línea después de toda sangría. Puede elegir pestañas o espacios para ser su carácter de sangría, pero debe especificarlo en su publicación.
• Puede suponer que cada declaración en el código ocupará como máximo la totalidad de 1 línea; es decir, sin cadenas de varias líneas o barra diagonal inversa-continuación.

Casos de prueba

Pitón:

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

C: (Honestamente, me sorprende que esto compile)

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

Este es el código de golf , por lo que gana la respuesta más corta (en bytes).

Pyke, 7 bytes

o\Kz++r

Pruébalo aquí!

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

Estoy declarando que los comentarios enteros son los enteros seguidos por el carácter Ky luego la línea. Se utiliza un byte adicional para evitar que el código de operación de nueva línea entre e imprima algo adicional.

Perl, 8 + 1 = 9 bytes

say"#$."

Corre con -p(penalización de 1 byte). (Nota para las personas que no están familiarizadas con las reglas de PPCG; también debe especificar una versión moderna de la sintaxis de Perl -M5.010, pero decidimos que las opciones para seleccionar versiones de idioma son gratuitas y no incurren en una penalización de bytes, por lo que no lo mencioné en la versión original de esta publicación)

-pcoloca el programa en un bucle implícito; Básicamente, hace que el programa se convierta en un filtro que procesa cada línea por separado (es decir, todo el programa se ejecuta en la primera línea, luego en la segunda, luego en la tercera, etc.). Perl también realiza un seguimiento de un número de línea, llamado $., que registra cuántas líneas de entrada se han leído. Entonces, todo lo que hace el programa es dejar -pleer una línea de entrada; salida a #, el número de línea actual ( $.) y una nueva línea ( sayagrega una nueva línea por defecto, que es útil en este caso, y también es más corta que la más comúnmente vista print); y luego dejando -psalir la línea de código original que leyó (típicamente un programa que usa-pharía algún tipo de procesamiento en la entrada, pero debido a que no lo hicimos, es solo la salida sin cambios). Los comentarios en Perl se ejecutan desde #una nueva línea ( #en el programa en sí no se inicia un comentario porque está dentro de un literal de cadena), por lo que básicamente lo que estamos haciendo es aprovechar la oportunidad para escribir líneas de comentarios en el archivo a medida que lo procesamos , sin perturbar el ciclo de lectura y escritura "natural" de -p.

Javascript, 43 39 bytes

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

Gracias a ETH y Conor por guardar 4 bytes.

V , 10 bytes

O:1òYjjP

Pruébalo en línea!

Lote, 91 bytes

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

Batch no tiene una forma de leer STDIN hasta EOF, por lo que el nombre del archivo debe pasarse como un parámetro de línea de comandos.

Lua, 80 75 bytes

Guardado algunos bytes al abusar del idioma.

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

Respuesta inicial lo suficientemente simple.

Sin golf, +

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 caracteres

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

En Gema solo hay comentarios de línea, comenzando con !.

Ejecución de muestra:

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!

Las siguientes son para responder la pregunta de Adám , si es posible agregar el número de línea en una especie de código ignorado.

El código de Gema es esencialmente una colección de reglas de transformación from = to , o template = action en términos de Gema. No veo forma de definir una plantilla que nunca coincida con nada, esto solo no parece ser el camino.

Gema, 18 personajes

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

Se transforma e=3en c:=1;:e=3.

Afortunadamente en Gema hay dominios , tipos de espacios de nombres. El código anterior define las reglas ficticias en el espacio de nombres c, que nunca usamos. Desafortunadamente, un dominio mencionado permanece vigente hasta el final de la línea, por lo que tenemos que cambiar explícitamente al dominio predeterminado.

Gema, 18 personajes

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

Se transforma e=3en 1=$0;e=3.

Una alternativa menos complicada es usar código sin efecto en lugar de ignorado. Me refiero a volver a poner exactamente lo que coincidió.

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

Entrada:

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

Salida:

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

BASH (+ GNU sed) 27 bytes

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

La primera parte ( i# \n =) casi funciona en GNU sed (para 4 bytes), pero pone una nueva línea después de #.

awk ( 19 13 bytes)

19 bytes : este inserto "#" + número de línea sobre cada línea de código

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

13 bytes : crédito y gracias a @manatwork por dos soluciones de 13 bytes

Como 1acción por defecto es print $0:

{print"#"NR}1

O reemplazando $0contenido

$0="#"NR RS$0

Función de extensión Kotlin, 69 60 bytes

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

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

Ejemplo de uso:

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

Salida:

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

CJam, 21 bytes

No estoy muy versado en CJam en absoluto, pero sabía de hecho que tiene comentarios :)

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

Explicación próximamente.

Mathematica, 58 bytes

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

jq, 31 caracteres

(Código de 27 caracteres + opciones de línea de comando de 4 caracteres).

"#\(input_line_number)\n"+.

En jq solo hay comentarios de línea, comenzando por #.

Ejecución de muestra:

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 bytes

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

Solo hay comentarios de línea que comienzan con "#".

Ungolfed y explicado:

           # 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

Estoy bastante seguro de que esto se puede simplificar aún más, especialmente el ique probablemente se pueda omitir.

Puede probarlo aquí: https://golfscript.apphb.com/ Debido a que este sitio no admite agregar entradas, deberá colocar una cadena entre comillas dobles delante del código. '\n'Será una nueva línea. Tenga en cuenta el hecho de que también hay otras secuencias de escape. Usuario '\\'si no está seguro.

C # 6, 66 61 bytes

Gracias a CSharpie

(666, código de demonios ^^) ya no ...

Esto funciona para todos los lenguajes que usan "comentarios de estilo C" (C, C ++, C #, Java, ....)

Simplemente divide la cadena en líneas, antepone cada línea con su índice y vuelve a unir las líneas editadas con nuevos caracteres de línea.

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

versión antigua:

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

Python 2, 82 bytes

Funciona para sangría solo en espacio

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

Versión sin sangría para 56 bytes

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