Gere / * comentários de número de linha * /

12

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 é , então a resposta mais curta (em bytes) vence.

Esolanging Fruit
fonte
7
Tornar os comentários dependentes do idioma dificulta as coisas. Você já tinha que criar uma regra especial para Python. E quanto aos outros idiomas que não têm comentários de várias linhas? E os idiomas que não têm comentários? E quanto a seqüências de várias linhas em que os comentários não podem ser colocados sem efeitos colaterais?
Dennis
4
Curiosidade: a regra "remover o comentário não deve alterar o programa" desqualifica imediatamente qualquer resposta Python, porque o código - incluindo comentários - pode ser introspectivo em tempo de execução. Eu já vi isso em jogo em um sistema de produção: um pedaço de código aumentaria um AssertionError, a menos que o rastreamento da pilha contivesse a frase foo.py, que era esperada vir de um nome de arquivo, mas também poderia aparecer como um comentário de linha no contexto.
precisa saber é
2
" O comentário só pode conter novas linhas no fim de que " é inconsistente com o "C caso de teste ".
Peter Taylor
2
E quanto a langs sem comentários?
NoOneIsHere
4
A edição não corrige a inconsistência.
Peter Taylor

Respostas:

5

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.

Azul
fonte
16

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.


fonte
Você pode explicar como isso funciona?
Adám 24/11/16
Certo. Eu expliquei a operação dos recursos relevantes da linguagem Perl em um estilo de tutorial, já que é um programa Perl muito básico que realmente não utiliza muito o poder da linguagem. Eu preciso lembrar que nem todo mundo sabe como um -ploop ou um número de linha com atualização automática funciona.
Observe que isso say"$.;"também funcionaria, porque a pergunta especificava que "Você pode assumir que todas as instruções no código ocuparão no máximo 1 linha".
Msh210
Isso não é realmente um comentário; embora não seja útil, ele acaba no AST (e como o otimizador do Perl é meio chato, acho que na verdade acabará atrasando o programa, algo que você realmente não gostaria que um comentário fizesse).
Não está funcionando para a regra Você não precisa colocar números de linhas para linhas que contêm apenas espaço em branco e comentários.
Denis Ibaev 28/11
9

Javascript, 43 39 bytes

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

Agradecimentos a ETH e Conor por salvar 4 bytes.

SuperJedi224
fonte
41 bytes: a => (b = 0, a.replace (/ ^ / g, _ => /*${++b}*/)) (usar uma cadeia de formatação)
Conor O'Brien
1
39 bytes:a=>a.replace(/^/gm,_=>`/*${++b}*/`,b=0)
ETHproductions
3

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.

Neil
fonte
3

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. \
                    ')
                 )
      )
ATaco
fonte
Não conheço Lua, mas você tem certeza de que sempre gerará comentários do mesmo tamanho? Por exemplo, se um programa tiver 10 linhas de comprimento que o último comentário, --[[10]]com 1 caractere a mais que --[[9]]menos que você o preencha corretamente com espaços.
Esolanging Fruit
1
Oh, eu não percebi essa regra. Isso parece ... um pouco redundante ...
Ataco
1
Sim. Talvez eu o remova ... [EDIT]: removido.
Esolanging Fruit
3

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.

homem a trabalhar
fonte
Mas você não pode inserir uma string e ter algum código em torno dela, o que a ignora?
Adám 24/11/16
Você quer dizer que meio que se e=3transformou em if (false) { 1 }; e=3vez da atual !1␤e=3? Sim, haveria uma solução alternativa com 19 caracteres.
manatwork
2

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
anonymous2
fonte
1
Já faz um tempo desde que usei o QBasic, mas isso não faz com que o programa envie um texto para todos os comentários, em vez dos números das linhas? Ou estou me lembrando de algo?
Obrigado pela contribuição! Na verdade, o 'apenas comenta o que se segue na linha.
anonymous2
4
Sim, é por isso que acho que está transformando o programa em comentários. Em vez de apenas adicionar números de linha, ele altera o significado em um programa que não faz nada. (Honestamente, seria legal para uma entrada em um dialeto BASIC para adicionar números de linha real e renumerar o programa se ele já tem números, mas isso provavelmente não é realmente necessário.)
2

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 #.

Riley
fonte
2

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
Adão
fonte
{print"#"NR}1ou $0="#"NR RS$0?
manatwork
@manatwork estou muito envergonhado e grato a descobrir essas sutilezas
Adam
2

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*/}
F. George
fonte
1

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.

Kade
fonte
oNopode ser substituído por nno TIO.
Esolanging Fruit
1

Mathematica, 58 bytes

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

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!
homem a trabalhar
fonte
Caros codificadores Perl e Ruby, observe as jq's input_line_number. Ser dia de Ação de Graças, algum sentimento especial para expressar $.?
manatwork
1

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.

CodenameLambda
fonte
1

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}"));
Stefan
fonte
1
Tecnicamente 64, já que o op não mencionou nenhum preenchimento com zeros. Além disso, você pode economizar mais 1 byte, usando o comando: $ "/ * {i} * /" + l. (Mover o G-parâmetro fora da interpolação.)
CSharpie
Você está certo ^^ mas que destrói o meu "score mal" hehe
Stefan
0

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
Cajado
fonte