Twoim zadaniem jest napisanie programu (lub funkcji), który pobierze ciąg znaków jako dane wejściowe i doda tekst na początku każdego wiersza spełniającego następujące reguły:

• Dołączony tekst musi zawierać numer wiersza. Możesz użyć indeksowania opartego na 0 lub 1.
• Tekst musi być komentarzem w Twoim języku. Komentarz jest zdefiniowany jako poprawny składniowo kod, który nie wprowadza żadnych zmian w stanie programu. Usunięcie komentarza nie powinno powodować zmian w programie.
• Komentarz może zawierać tylko znaki nowej linii na końcu.
• Nie musisz wstawiać numerów linii dla linii, które zawierają tylko białe znaki i komentarze.

Dane techniczne

• Możesz założyć, że dane wejściowe będą prawidłowym programem w Twoim języku.
• W językach wrażliwych na wcięcia, takich jak Python, można wstawić komentarz do numeru wiersza po wszystkich wcięciach. Możesz wybrać tabulatory lub spacje, aby być postacią wcięcia, ale musisz podać to w swoim poście.
• Możesz założyć, że każda instrukcja w kodzie zajmuje maksymalnie 1 linię; tzn. brak ciągów wieloliniowych lub kontynuacji odwrotnego ukośnika.

Przypadki testowe

Pyton:

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

C: (Szczerze, dziwię się, że to się kompiluje)

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

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź (w bajtach).

Pyke, 7 bajtów

o\Kz++r

Wypróbuj tutaj!

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

Deklaruję, że komentarze liczb całkowitych są liczbami całkowitymi, po których następuje znak, Ka następnie wiersz. Dodatkowy bajt służy do zatrzymania nowego kodu operacyjnego linii i drukowania dodatkowej rzeczy.

Perl, 8 + 1 = 9 bajtów

say"#$."

Uruchom z -p(1 bajtowa kara). (Uwaga dla osób niezaznajomionych z zasadami PPCG; musisz także określić nowoczesną wersję składni Perla -M5.010, ale zdecydowaliśmy, że opcje wyboru wersji językowych są bezpłatne i nie wiążą się z karą bajtową, więc nie wspomniałem o tym w oryginalna wersja tego postu).

-pumieszcza program w niejawnej pętli; w zasadzie powoduje, że program staje się filtrem, który przetwarza każdą linię osobno (tzn. cały program jest uruchamiany w pierwszym wierszu, potem w drugim, potem w trzecim itd.). Perl śledzi także numer linii, zwanej $., która rejestruje, ile linii wejściowych zostało odczytanych. Więc wszystko, co program robi, polega na -pczytaniu wiersza wprowadzania; wypisz a #, bieżący numer wiersza ( $.) i nowy wiersz ( saydomyślnie dodaje nowy wiersz, który jest pomocny w tym przypadku i jest również krótszy niż częściej spotykany print); a następnie pozwalając na -pwydrukowanie oryginalnego wiersza kodu, który odczytał (zwykle używa programu-pwykonałby jakieś przetwarzanie danych wejściowych, ale ponieważ tego nie zrobiliśmy, dane wyjściowe pozostały niezmienione). Komentarze w Perlu biegną od #do nowego wiersza ( #sam program nie uruchamia komentarza, ponieważ znajduje się w literale ciągu), więc w zasadzie robimy okazję, aby napisać wiersze komentarza do pliku podczas przetwarzania , bez zakłócania „naturalnego” cyklu odczytu i zapisu -p.

JavaScript, 43 39 bajtów

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

Dzięki ETH i Conorowi za oszczędność 4 bajtów.

V , 10 bajtów

O:1òYjjP

Wypróbuj online!

Partia, 91 bajtów

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

Batch nie ma możliwości odczytu STDIN do EOF, więc zamiast tego nazwa pliku musi zostać przekazana jako parametr wiersza polecenia.

Lua, 80 75 bajtów

Zapisano kilka bajtów, nadużywając langauge.

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

Dość prosta odpowiedź dla początkujących.

Niegolfowany +

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 znaków

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

W Gema są tylko komentarze liniowe, zaczynające się od !.

Przykładowy przebieg:

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!

Aby odpowiedzieć na pytanie Adáma , czy możliwe jest dodanie numeru wiersza w rodzaju zignorowanego kodu.

Kod Gema jest w istocie zbiorem z = do reguł transformacji lub szablonu = działania w zakresie Gema. Nie widzę sposobu, aby zdefiniować szablon , który nigdy nie będzie pasował do niczego, samo to nie wydaje się być właściwą drogą.

Gema, 18 znaków

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

Przekształca się e=3w c:=1;:e=3.

Na szczęście w Gema istnieją domeny , rodzaj przestrzeni nazw. Powyższy kod definiuje fikcyjne reguły w przestrzeni nazw c, których nigdy nie używamy. Niestety wspomniana domena obowiązuje do końca linii, więc musimy jawnie przełączyć się z powrotem na domenę domyślną.

Gema, 18 znaków

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

Przekształca się e=3w 1=$0;e=3.

Mniej skomplikowaną alternatywą jest użycie kodu bezskutecznego zamiast zignorowanego. Chcę odłożyć dokładnie to, co zostało dopasowane.

Qbasic, 91 89 bajtów

OPEN"I",1,"i"
OPEN"O",2,"o"
DO UNTIL EOF(1)
i=i+1
INPUT#1,a$
PRINT#2,STR$(i)+"'"+a$
LOOP

Wejście:

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

Wynik:

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

BASH (+ GNU sed) 27 bajtów

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

Pierwsza część ( i# \n =) prawie działa w GNU sed (dla 4 bajtów), ale wstawia nową linię po #.

awk ( 19 13 bajtów)

19 bajtów : wstaw „#” + numer wiersza powyżej każdego wiersza kodu

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

13 bajtów : Kredyt i podziękowania dla @manatwork za dwa 13-bajtowe rozwiązanie

Jako 1domyślne działania do print $0:

{print"#"NR}1

Lub zastępując $0treść

$0="#"NR RS$0

Funkcja rozszerzenia Kotlin, 69 60 bajtów

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

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

Przykładowe użycie:

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

Wynik:

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

CJam, 21 bajtów

W ogóle nie jestem dobrze zaznajomiony z CJam, ale wiedziałem, że ma komentarze :)

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

Wyjaśnienie już wkrótce.

Mathematica, 58 bajtów

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

jq, 31 znaków

(27-znakowy kod + 4-znakowe opcje wiersza poleceń.)

"#\(input_line_number)\n"+.

W jq są tylko komentarze liniowe, zaczynające się od #.

Przykładowy przebieg:

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 bajty

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

Są tylko komentarze liniowe zaczynające się od „#”.

Niegolfowane i wyjaśnione:

           # 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

Jestem pewien, że można to jeszcze bardziej uprościć, zwłaszcza że iprawdopodobnie można je pominąć.

Możesz to przetestować tutaj: https://golfscript.apphb.com/ Ponieważ ta strona nie obsługuje dodawania danych wejściowych, będziesz musiał umieścić ciąg otoczony podwójnymi cudzysłowami przed kodem. '\n'będzie nowa linia. Pamiętaj, że istnieją również inne sekwencje ucieczki. Użytkownik, '\\'jeśli nie jesteś pewien.

C # 6, 66 61 bajtów

Dzięki CSharpie

(666, kod diabła ^^) już nie ...

Działa to we wszystkich językach przy użyciu „komentarzy w stylu C” (C, C ++, C #, Java, ....)

Po prostu dzieli ciąg na linie, poprzedza każdą linię indeksem i ponownie łączy edytowane linie z nowymi znakami linii.

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

stara wersja:

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

Python 2, 82 bajty

Działa dla wcięć tylko w przestrzeni

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

Wersja bez wcięć dla 56 bajtów

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