Ihre Aufgabe ist es, ein Programm (oder eine Funktion) zu schreiben, das eine Zeichenfolge als Eingabe verwendet und Text an den Anfang jeder Zeile anfügt, die die folgenden Regeln erfüllt:

• Der angehängte Text muss die Zeilennummer enthalten. Sie können eine 0- oder 1-basierte Indizierung verwenden.
• Der Text muss ein Kommentar in Ihrer Sprache sein. Ein Kommentar ist als syntaktisch gültiger Code definiert, der den Programmstatus nicht ändert. Durch das Entfernen des Kommentars sollte das Programm nicht geändert werden.
• Der Kommentar darf nur am Ende Zeilenumbrüche enthalten.
• Sie müssen keine Zeilennummern für Zeilen eingeben, die nur Leerzeichen und Kommentare enthalten.

Spezifikationen

• Sie können davon ausgehen, dass die Eingabe ein gültiges Programm in Ihrer Sprache ist.
• In einrückungssensitiven Sprachen wie Python können Sie den Zeilennummernkommentar nach allen Einrückungen einfügen. Sie können entweder Tabulatoren oder Leerzeichen als Einrückungszeichen auswählen, dies müssen Sie jedoch in Ihrem Beitrag angeben.
• Sie können davon ausgehen, dass jede Anweisung im Code höchstens die gesamte Zeile einnimmt. dh keine mehrzeiligen Strings oder Backslash-Fortsetzungen.

Testfälle

Python:

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

C: (Ehrlich gesagt, ich bin überrascht, dass dies kompiliert)

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

Das ist Code-Golf , also gewinnt die kürzeste Antwort (in Bytes).

Pyke, 7 Bytes

o\Kz++r

Probieren Sie es hier aus!

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

Ich erkläre Integer-Kommentare als Integer, gefolgt vom Zeichen Kund der Zeile. Ein zusätzliches Byte wird verwendet, um zu verhindern, dass der Newline-Opcode eintritt und eine zusätzliche Sache druckt.

Perl, 8 + 1 = 9 Bytes

say"#$."

Laufen Sie mit -p (1 Byte Strafe). (Hinweis für Personen, die mit den PPCG-Regeln nicht vertraut sind; Sie müssen auch eine moderne Version der Perl-Syntax mithilfe von angeben. -M5.010Wir haben jedoch entschieden, dass die Optionen zum Auswählen von Sprachversionen kostenlos sind und keine Byte-Strafe verursachen. Ich habe sie daher in nicht erwähnt die Originalversion dieses Beitrags.)

-pplatziert das Programm in eine implizite Schleife; Im Grunde genommen wird das Programm zu einem Filter, der jede Zeile separat verarbeitet (dh das gesamte Programm wird in der ersten Zeile ausgeführt, dann in der zweiten, dann in der dritten usw.). Perl verfolgt auch eine Zeilennummer $., die aufzeichnet, wie viele Eingabezeilen gelesen wurden. Alles, was das Programm tut, ist -p, eine Eingabezeile lesen zu lassen . Ausgabe a #, die aktuelle Zeilennummer ( würde eine Art Verarbeitung für die Eingabe ausführen, aber da dies nicht der Fall ist, wird sie nur unverändert ausgegeben). Kommentare in Perl werden von zu einer neuen Zeile (dem$.gib ) und eine neue Zeile aus ( vornehmensay fügt standardmäßig eine neue hinzu, was in diesem Fall hilfreich ist und auch kürzer als die üblicheren ist print); und dann -pdie ursprüngliche Codezeile ausgeben lassen , die sie gelesen hat (normalerweise ein Programm, das verwendet-p## im Programm selbst startet keinen Kommentar, da es sich um ein String-Literal handelt). Im Grunde genommen nutzen wir also die Gelegenheit, Kommentarzeilen in die Datei zu schreiben, während wir sie verarbeiten , ohne den "natürlichen" Lese- und Schreibzyklus von zu stören -p.

Javascript, 43 39 Bytes

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

Dank an ETH und Conor für die Einsparung von 4 Bytes.

V , 10 Bytes

O:1òYjjP

Probieren Sie es online!

Batch, 91 Bytes

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

Batch kann STDIN erst nach EOF lesen. Stattdessen muss der Dateiname als Befehlszeilenparameter übergeben werden.

Lua, 80 75 Bytes

Einige Bytes durch Missbrauch der Sprache gespart.

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

Einfach genug Starterantwort.

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 Zeichen

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

In Gema gibt es nur Zeilenkommentare, beginnend mit !.

Probelauf:

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!

Das Folgende soll Adám antworten Frage von beantwortet, ob es möglich ist, die Zeilennummer in Form eines ignorierten Codes hinzuzufügen.

Gema-Code ist im Wesentlichen eine Sammlung von from = to- Transformationsregeln oder template = action in Gema-Begriffen. Ich sehe keine Möglichkeit, eine Vorlage zu definieren , die niemals zu etwas passt. Dies allein scheint nicht der richtige Weg zu sein.

Gema, 18 Zeichen

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

Verwandelt sich e=3inc:=1;:e=3 .

Zum Glück gibt es in Gema Domains , so etwas wie Namespaces. Der obige Code definiert die Dummy-Regeln in Namespace c, die wir nie verwenden. Leider bleibt eine erwähnte Domain bis zum Ende der Zeile in Kraft, so dass wir explizit zur Standard-Domain zurückkehren müssen.

Gema, 18 Zeichen

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

Verwandelt sich e=3in1=$0;e=3 .

Eine weniger komplizierte Alternative besteht darin, wirkungslosen Code zu verwenden, anstatt einen zu ignorieren. Ich meine, genau das zurückzusetzen, was zusammengebracht wurde.

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

Eingang:

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

Ausgabe:

 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'

Der erste Teil ( i# \n =) funktioniert fast in GNU sed (für 4 Bytes), setzt aber eine neue Zeile nach dem #.

awk ( 19 13 bytes)

19 Bytes : Fügen Sie "#" + Zeilennummer über jeder Codezeile ein

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

13 bytes : Dank an @manatwork für zwei 13 bytes Lösung

Als 1Aktion standardmäßig print $0:

{print"#"NR}1

Oder durch Ersetzen von $0Inhalten

$0="#"NR RS$0

Kotlin-Erweiterungsfunktion, 69 bis 60 Bytes

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

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

Beispielverwendung:

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

Ausgabe:

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

CJam, 21 Bytes

Ich bin überhaupt nicht mit CJam vertraut, aber ich wusste, dass es Kommentare gibt :)

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

Erklärung folgt in Kürze.

Mathematica, 58 Bytes

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

jq, 31 Zeichen

(27 Zeichen Code + 4 Zeichen Befehlszeilenoptionen.)

"#\(input_line_number)\n"+.

In jq gibt es nur Zeilenkommentare, beginnend mit # .

Probelauf:

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*

Es gibt nur Zeilenkommentare, die mit "#" beginnen.

Ungolfed & erklärt:

           # 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

Ich bin mir ziemlich sicher, dass dies weiter vereinfacht werden kann, insbesondere ikann das wahrscheinlich weggelassen werden.

Sie können es hier testen: https://golfscript.apphb.com/ Da diese Site das Hinzufügen von Eingaben nicht unterstützt, müssen Sie dem Code eine Zeichenfolge in doppelte Anführungszeichen voranstellen. '\n'wird ein newline sein. Beachten Sie, dass es auch andere Escape-Sequenzen gibt. Benutzer, '\\'wenn Sie sich nicht sicher sind.

C # 6, 66 61 Bytes

Vielen Dank an CSharpie

(666, devils code ^^) nicht mehr ...

Dies funktioniert für alle Sprachen, die Kommentare im C-Stil verwenden (C, C ++, C #, Java, ....).

Die Zeichenfolge wird einfach in Zeilen aufgeteilt, jede Zeile mit einem Index versehen und die bearbeiteten Zeilen erneut mit neuen Zeilenzeichen verbunden.

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

alte Version:

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

Python 2, 82 Bytes

Funktioniert nur für Einrückungen mit Leerzeichen

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

Einrückungsfreie Version für 56 Bytes

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