Sua tarefa é escrever um programa (ou função) que terá uma string como entrada e anexará texto ao início de cada linha que atenda às seguintes regras:

• O texto anexado deve conter o número da linha. Você pode usar a indexação com base em 0 ou 1.
• O texto deve ser um comentário no seu idioma. Um comentário é definido como um trecho de código sintaticamente válido que não faz alterações no estado do programa. A remoção do comentário não deve alterar o programa.
• O comentário pode conter apenas novas linhas no final.
• Você não precisa colocar números de linhas para linhas que contenham apenas espaço em branco e comentários.

Especificações

• Você pode assumir que a entrada será um programa válido no seu idioma.
• Em linguagens sensíveis ao recuo, como Python, você pode colocar o comentário do número da linha após todo o recuo. Você pode escolher guias ou espaços para ser o seu caractere de indentação, mas você deve especificar na sua postagem.
• Você pode assumir que todas as instruções no código ocuparão no máximo 1 linha; ou seja, sem seqüências de várias linhas ou continuação de barra invertida.

Casos de teste

Pitão:

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

C: (Honestamente, estou surpreso que isso 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*/}

Isso é código-golfe , então a resposta mais curta (em bytes) vence.

Pyke, 7 bytes

o\Kz++r

Experimente aqui!

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

Estou declarando comentários inteiros como o número inteiro seguido pelo caractere Ke depois pela linha. Um byte extra é usado para impedir que o código de operação da nova linha entre em ação e imprima uma coisa extra.

Perl, 8 + 1 = 9 bytes

say"#$."

Corra com -p(penalidade de 1 byte). (Observe para pessoas não familiarizadas com as regras do PPCG; você também precisa especificar uma versão moderna da sintaxe Perl usando -M5.010, mas decidimos que as opções para selecionar versões de idiomas são gratuitas e não incorrem em uma penalidade de bytes, por isso não mencionei isso em a versão original desta postagem.)

-pcoloca o programa em um loop implícito; basicamente faz com que o programa se torne um filtro que processa cada linha separadamente (ou seja, o programa inteiro é executado na primeira linha, depois na segunda, depois na terceira e assim por diante). O Perl também rastreia um número de linha, chamado $., que registra quantas linhas de entrada foram lidas. Então, tudo o que o programa está fazendo é deixar -pler uma linha de entrada; saída a #, o número da linha atual ( $.) e uma nova linha ( sayadiciona uma nova linha por padrão, o que é útil nesse caso e também é mais curto que o mais comum print); e, em seguida, permitindo a -psaída da linha de código original que ela lê (normalmente um programa usando-pfaria algum tipo de processamento na entrada, mas como não o fizemos, é apenas a saída inalterada). Os comentários no Perl são executados #em uma nova linha (o #próprio programa não inicia um comentário porque está dentro de uma cadeia de caracteres literal), então o que estamos fazendo basicamente é aproveitar a oportunidade para escrever linhas de comentário no arquivo enquanto o processamos. , sem perturbar o ciclo "natural" de leitura e gravação de -p.

Javascript, 43 39 bytes

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

Agradecimentos a ETH e Conor por salvar 4 bytes.

V , 10 bytes

O:1òYjjP

Experimente online!

Lote, 91 bytes

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

O lote não tem como ler STDIN até o EOF; portanto, o nome do arquivo deve ser passado como um parâmetro da linha de comando.

Lua, 80 75 bytes

Economizou alguns bytes abusando do idioma.

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

Resposta inicial bastante simples.

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

Gema, 16 15 caracteres

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

No Gema, existem apenas comentários de linha, começando com !.

Exemplo de execução:

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!

A seguir, respondemos à pergunta de Adám , se é possível adicionar o número da linha em tipo de código ignorado.

O código Gema é essencialmente uma coleção de regras de = = para transformação ou template = action em termos de Gema. Não vejo como definir um modelo que nunca corresponda a nada, apenas isso não parece ser o caminho.

Gema, 18 caracteres

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

Transforma e=3em c:=1;:e=3.

Felizmente, no Gema, existem domínios , tipos de namespaces. O código acima define as regras fictícias no espaço de nomes c, que nunca usamos. Infelizmente, um domínio mencionado permanece em vigor até o final da linha, por isso precisamos explicitamente retornar ao domínio padrão.

Gema, 18 caracteres

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

Transforma e=3em 1=$0;e=3.

Uma alternativa menos complicada é usar código sem efeito em vez de código ignorado. Quero colocar de volta exatamente o que foi combinado.

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

Resultado:

 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'

A primeira parte ( i# \n =) quase funciona no GNU sed (por 4 bytes), mas coloca uma nova linha após o #.

awk ( 19 13 bytes)

19 bytes : insira "#" + número da linha acima de cada linha do código

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

13 bytes : crédito e obrigado a @manatwork por duas soluções de 13 bytes

Como 1ação, o padrão é print $0:

{print"#"NR}1

Ou substituindo o $0conteúdo

$0="#"NR RS$0

Função de extensão 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")}}

Exemplo de uso:

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

Resultado:

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

CJam, 21 bytes

Não sou muito versado no CJam, mas sabia que ele tem comentários :)

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

Explicação em breve.

Mathematica, 58 bytes

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

jq, 31 caracteres

(Código de 27 caracteres + opções de linha de comando de 4 caracteres.)

"#\(input_line_number)\n"+.

No jq, existem apenas comentários de linha, começando com #.

Exemplo de execução:

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*

Existem apenas comentários de linha começando com "#".

Ungolfed & explicou:

           # 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

Tenho certeza de que isso pode ser mais simplificado, especialmente o ique provavelmente pode ser deixado de fora.

Você pode testá-lo aqui: https://golfscript.apphb.com/ Como este site não oferece suporte à adição de entradas, você deverá colocar uma string entre aspas duplas na frente do código. '\n'será uma nova linha. Esteja ciente do fato de que também existem outras seqüências de escape. Usuário, '\\'se você não tiver certeza.

C # 6, 66 61 bytes

Graças ao CSharpie

(666, código demônios ^^) não mais ...

Isso funciona para todos os idiomas usando "comentários no estilo C" (C, C ++, C #, Java, ....)

Simplesmente divide a string em linhas, acrescenta cada linha ao seu índice e junta as linhas editadas novamente com novos caracteres de linha.

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

versão antiga:

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

Python 2, 82 bytes

Funciona para recuo somente de espaço

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

Versão sem recuo para 56 bytes

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