Il tuo compito è quello di scrivere un programma (o una funzione) che prenderà una stringa come input e accluda il testo all'inizio di ogni riga che soddisfi le seguenti regole:

• Il testo allegato deve contenere il numero di riga. È possibile utilizzare l'indicizzazione basata su 0 o 1.
• Il testo deve essere un commento nella tua lingua. Un commento è definito come un pezzo di codice sintatticamente valido che non modifica lo stato del programma. La rimozione del commento non dovrebbe apportare modifiche al programma.
• Il commento può contenere solo nuove righe alla fine.
• Non è necessario inserire numeri di riga per le righe che contengono solo spazi bianchi e commenti.

specificazioni

• Puoi presumere che l'ingresso sarà un programma valido nella tua lingua.
• In linguaggi sensibili al rientro come Python, è possibile inserire il commento del numero di riga dopo tutto il rientro. Puoi scegliere le schede o gli spazi come carattere di rientro, ma devi specificare nel post.
• Si può presumere che ogni istruzione nel codice occuperà al massimo l'intera riga 1; cioè nessuna stringa multi-linea o continuazione della barra rovesciata.

Casi test

Pitone:

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

C: (Onestamente, sono sorpreso che questo compili)

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

Questo è code-golf , quindi vince la risposta più breve (in byte).

Pyke, 7 byte

o\Kz++r

Provalo qui!

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

Sto dichiarando i commenti di numeri interi come numeri interi seguiti dal carattere Ke quindi dalla riga. Un byte aggiuntivo viene utilizzato per impedire che il codice operativo newline si avvii e stampi qualcosa in più.

Perl, 8 + 1 = 9 byte

say"#$."

Esegui con -p(penalità di 1 byte). (Nota per le persone che non hanno familiarità con le regole PPCG; è inoltre necessario specificare una versione moderna della sintassi Perl utilizzando -M5.010, ma abbiamo deciso che le opzioni per selezionare le versioni della lingua sono gratuite e non comportano una penalità di byte, quindi non ne ho parlato in la versione originale di questo post.)

-pinserisce il programma in un ciclo implicito; fondamentalmente fa sì che il programma diventi un filtro che elabora ciascuna riga separatamente (ovvero l'intero programma viene eseguito sulla prima riga, quindi sulla seconda, quindi sulla terza e così via). Perl tiene anche traccia di un numero di riga, chiamato $., che registra quante righe di input sono state lette. Quindi tutto ciò che sta facendo il programma è -pleggere una riga di input; output a #, il numero di riga corrente ( $.) e una nuova riga ( sayaggiunge una nuova riga per impostazione predefinita, che è utile in questo caso ed è anche più breve di quella più comunemente vista print); e quindi lasciando in -poutput la riga di codice originale che legge (in genere un programma che utilizza-pfarebbe una sorta di elaborazione sull'input, ma poiché non lo abbiamo fatto, l'output è rimasto invariato). I commenti in Perl vengono eseguiti da #una nuova riga (il #programma stesso non avvia un commento perché si trova all'interno di una stringa letterale), quindi quello che stiamo fondamentalmente facendo è cogliere l'opportunità di scrivere righe di commento nel file mentre lo elaboriamo , senza disturbare il ciclo "naturale" di lettura e scrittura di -p.

Javascript, 43 39 byte

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

Grazie a ETH e Conor per il salvataggio di 4 byte.

V , 10 byte

O:1òYjjP

Provalo online!

Lotto, 91 byte

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

Batch non ha modo di leggere STDIN fino a EOF, quindi il nome del file deve essere passato come parametro della riga di comando.

Lua, 80 75 byte

Salvati alcuni byte abusando della lingua.

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

Risposta iniziale abbastanza semplice.

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 caratteri

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

In Gema ci sono solo commenti di linea, a cominciare da !.

Esecuzione di esempio:

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!

Di seguito è possibile rispondere alla domanda di Adám , se è possibile aggiungere il numero di riga in una specie di codice ignorato.

Il codice Gema è essenzialmente una raccolta di regole da = a trasformazione, o template = azione in termini di Gema. Non vedo alcun modo per definire un modello che non corrisponderà mai a nulla, questo da solo non sembra essere il modo.

Gema, 18 personaggi

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

Si trasforma e=3in c:=1;:e=3.

Fortunatamente in Gema ci sono domini , tipi di spazi dei nomi. Il codice sopra definisce le regole fittizie nello spazio dei nomi c, che non usiamo mai. Sfortunatamente un dominio menzionato rimane in vigore fino alla fine della linea, quindi dobbiamo esplicitamente tornare al dominio predefinito.

Gema, 18 personaggi

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

Si trasforma e=3in 1=$0;e=3.

Un'alternativa meno complicata è usare il codice senza effetto invece di uno ignorato. Voglio dire rimettere esattamente ciò che è stato abbinato.

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

Ingresso:

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

Produzione:

 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'

La prima parte ( i# \n =) funziona quasi in GNU sed (per 4 byte), ma inserisce una nuova riga dopo il #.

awk ( 19 13 byte)

19 byte : questo inserisce "#" + numero di riga sopra ogni riga di codice

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

13 byte : credito e grazie a @manatwork per due soluzioni da 13 byte

Come 1azione, per impostazione predefinita print $0:

{print"#"NR}1

O sostituendo il $0contenuto

$0="#"NR RS$0

Funzione di estensione di 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")}}

Esempio di utilizzo:

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

Produzione:

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

CJam, 21 byte

Non sono affatto esperto in CJam, ma sapevo per certo che ha commenti :)

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

Spiegazione in arrivo.

Mathematica, 58 byte

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

jq, 31 caratteri

(27 caratteri di codice + 4 caratteri opzioni della riga di comando.)

"#\(input_line_number)\n"+.

In jq ci sono solo commenti di riga, a partire da #.

Esecuzione di esempio:

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*

Ci sono solo commenti di riga che iniziano con "#".

Ungolfed e spiegato:

           # 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

Sono abbastanza sicuro che questo possa essere ulteriormente semplificato, in particolare iprobabilmente può essere lasciato fuori.

Puoi provarlo qui: https://golfscript.apphb.com/ Poiché questo sito non supporta l'aggiunta di input, dovrai mettere una stringa racchiusa tra virgolette davanti al codice. '\n'sarà una newline. Sii consapevole del fatto che ci sono anche altre sequenze di escape. Utente '\\'se non sei sicuro.

C # 6, 66 61 byte

Grazie a CSharpie

(666, codice diavoli ^^) non più ...

Funziona con tutti i linguaggi che usano "commenti in stile C" (C, C ++, C #, Java, ....)

Divide semplicemente la stringa in righe, antepone ogni riga con il suo indice e unisce nuovamente le righe modificate con i nuovi caratteri di riga.

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

vecchia versione:

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

Python 2, 82 byte

Funziona per il rientro solo spaziale

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

Versione senza rientro per 56 byte

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