Votre tâche consiste à écrire un programme (ou une fonction) qui prendra une chaîne en entrée et ajoutera du texte au début de chaque ligne qui satisfait aux règles suivantes:

• Le texte ajouté doit contenir le numéro de ligne. Vous pouvez utiliser une indexation basée sur 0 ou 1.
• Le texte doit être un commentaire dans votre langue. Un commentaire est défini comme un morceau de code syntaxiquement valide qui n'apporte aucune modification à l'état du programme. La suppression du commentaire ne devrait pas modifier le programme.
• Le commentaire ne peut contenir que des sauts de ligne à la fin de celui-ci.
• Il n'est pas nécessaire de mettre des numéros de ligne pour les lignes qui contiennent uniquement des espaces et des commentaires.

Caractéristiques

• Vous pouvez supposer que l'entrée sera un programme valide dans votre langue.
• Dans les langages sensibles à l'indentation comme Python, vous pouvez placer le commentaire du numéro de ligne après toute indentation. Vous pouvez choisir des tabulations ou des espaces comme caractère d'indentation, mais vous devez le spécifier sur votre message.
• Vous pouvez supposer que chaque instruction du code occupera au maximum l'intégralité d'une ligne; c'est-à-dire pas de chaînes multi-lignes ou de poursuite de barre oblique inverse.

Cas de test

Python:

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

C: (Honnêtement, je suis surpris que cela 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*/}

Il s'agit de code-golf , donc la réponse la plus courte (en octets) l'emporte.

Pyke, 7 octets

o\Kz++r

Essayez-le ici!

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

Je déclare les commentaires entiers comme étant l'entier suivi du caractère Kpuis de la ligne. Un octet supplémentaire est utilisé pour empêcher l'opcode newline de se déclencher et d'imprimer une chose supplémentaire.

Perl, 8 + 1 = 9 octets

say"#$."

Exécutez avec -p(1 octet de pénalité). (Remarque pour les personnes qui ne connaissent pas les règles PPCG; vous devez également spécifier une version moderne de la syntaxe Perl à l'aide -M5.010, mais nous avons décidé que les options de sélection des versions linguistiques sont gratuites et n'encourent pas de pénalité d'octet, donc je ne l'ai pas mentionné dans la version originale de cet article.)

-pplace le programme dans une boucle implicite; il fait essentiellement que le programme devienne un filtre qui traite chaque ligne séparément (c'est-à-dire que le programme entier est exécuté sur la première ligne, puis la deuxième, puis la troisième, etc.). Perl garde également la trace d'un numéro de ligne, appelé $., qui enregistre le nombre de lignes d'entrée lues. Donc, tout ce que fait le programme est de laisser -plire une ligne d'entrée; sortie a #, le numéro de ligne actuel ( $.) et un retour à la ligne ( sayajoute un retour à la ligne par défaut, ce qui est utile dans ce cas, et est également plus court que le plus souvent vu print); puis en laissant -psortir la ligne de code d'origine qu'il a lue (généralement un programme utilisant-pferait une sorte de traitement sur l'entrée, mais parce que nous ne l'avons pas fait, c'est juste une sortie inchangée). Les commentaires en Perl vont de #à une nouvelle ligne (le #dans le programme lui-même ne démarre pas de commentaire car il est à l'intérieur d'un littéral de chaîne), donc ce que nous faisons essentiellement est de saisir l'occasion d'écrire des lignes de commentaires dans le fichier pendant que nous le traitons , sans perturber le cycle de lecture et d'écriture "naturel" de -p.

Javascript, 43 39 octets

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

Merci à ETH et Conor pour avoir économisé 4 octets.

V , 10 octets

O:1òYjjP

Essayez-le en ligne!

Lot, 91 octets

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

Batch n'a aucun moyen de lire STDIN jusqu'à EOF, donc le nom de fichier doit être passé en tant que paramètre de ligne de commande.

Lua, 80 75 octets

Enregistré quelques octets en abusant de la jauge.

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

Réponse de démarrage assez simple.

Non golfé, +

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 caractères

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

Dans Gema, il n'y a que des commentaires de ligne, en commençant par !.

Exemple d'exécution:

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!

Ce qui suit est de répondre à la question d' Adám , s'il est possible d'ajouter le numéro de ligne en nature de code ignoré.

Code Gema est essentiellement une collection de de = à des règles de transformation, ou modèle = mesures en termes Gema. Je ne vois aucun moyen de définir un modèle qui ne correspondra jamais à rien, cela ne semble pas être le seul moyen.

Gema, 18 personnages

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

Se transforme e=3en c:=1;:e=3.

Heureusement, à Gema, il existe des domaines , une sorte d'espaces de noms. Le code ci-dessus définit les règles factices dans l'espace de noms c, que nous n'utilisons jamais. Malheureusement, un domaine mentionné reste en vigueur jusqu'à la fin de la ligne, nous devons donc explicitement revenir au domaine par défaut.

Gema, 18 personnages

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

Se transforme e=3en 1=$0;e=3.

Une alternative moins compliquée consiste à utiliser du code sans effet au lieu d'en ignorer un. Je veux remettre exactement ce qui était assorti.

Qbasic, 91 89 octets

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

Contribution:

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

Production:

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

BASH (+ GNU sed) 27 octets

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

La première partie ( i# \n =) fonctionne presque dans GNU sed (pour 4 octets), mais elle met une nouvelle ligne après le #.

awk ( 19 13 octets)

19 octets : cet insert "#" + numéro de ligne au-dessus de chaque ligne de code

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

13 octets : crédit et merci à @manatwork pour deux solutions de 13 octets

Par 1défaut, l'action est print $0:

{print"#"NR}1

Ou en remplaçant le $0contenu

$0="#"NR RS$0

Fonction d'extension Kotlin, 69 60 octets

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

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

Exemple d'utilisation:

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

Production:

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

CJam, 21 octets

Je ne connais pas du tout CJam du tout, mais je savais pertinemment qu'il a des commentaires :)

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

Explication à venir.

Mathematica, 58 octets

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

jq, 31 caractères

(Code de 27 caractères + options de ligne de commande de 4 caractères.)

"#\(input_line_number)\n"+.

Dans jq, il n'y a que des commentaires de ligne, en commençant par #.

Exemple d'exécution:

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 octets

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

Il n'y a que des commentaires de ligne commençant par "#".

Non golfé et expliqué:

           # 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

Je suis à peu près sûr que cela peut être encore simplifié, en particulier le ipeut probablement être omis.

Vous pouvez le tester ici: https://golfscript.apphb.com/ Parce que ce site ne prend pas en charge l'ajout d'entrées, vous devrez mettre une chaîne entourée de guillemets doubles devant le code. '\n'sera une nouvelle ligne. Soyez conscient du fait qu'il existe également d'autres séquences d'échappement. Utilisateur '\\'si vous n'êtes pas sûr.

C # 6, 66 61 octets

Merci à CSharpie

(666, code des diables ^^) plus ...

Cela fonctionne pour tous les langages utilisant des "commentaires de style C" (C, C ++, C #, Java, ....)

Il divise simplement la chaîne en lignes, ajoute chaque ligne à son index et joint à nouveau les lignes modifiées avec de nouveaux caractères de ligne.

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

ancienne version:

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

Python 2, 82 octets

Fonctionne pour l'indentation d'espace uniquement

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

Version sans indentation pour 56 octets

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