Générer / * commentaires de numéro de ligne * /


12

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 , donc la réponse la plus courte (en octets) l'emporte.


7
Rendre les commentaires dépendants de la langue complique les choses. Vous deviez déjà créer une règle spéciale pour Python. Qu'en est-il de toutes les autres langues qui n'ont pas de commentaires sur plusieurs lignes? Qu'en est-il des langues qui n'ont pas du tout de commentaires. Qu'en est-il des chaînes multilignes où les commentaires ne peuvent pas être placés sans effets secondaires?
Dennis

4
Fait amusant: la règle "supprimer le commentaire ne doit pas modifier le programme" disqualifie immédiatement toute réponse Python, car le code, y compris les commentaires, peut être examiné à l'exécution. J'ai vu cela en jeu dans un système de production: un morceau de code soulèverait un à AssertionErrormoins que la trace de la pile ne contienne la phrase foo.py, qui devait provenir d'un nom de fichier mais pourrait également apparaître comme un commentaire de ligne dans le contexte.
wchargin

2
« Le commentaire ne peut contenir que des nouvelles lignes à la fin de celui - ci » est incompatible avec le C « de cas de test ».
Peter Taylor

2
Qu'en est-il des langs sans commentaires?
NoOneIsHere

4
La modification ne corrige pas l'incohérence.
Peter Taylor

Réponses:


5

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.


16

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.


Pouvez-vous expliquer comment cela fonctionne?
Adám

Sûr. J'ai expliqué le fonctionnement des fonctionnalités pertinentes du langage Perl dans un style de didacticiel, étant donné qu'il s'agit d'un programme Perl très basique qui n'utilise pas vraiment la puissance du langage. Je dois cependant me rappeler que tout le monde ne sait pas comment fonctionne une -pboucle ou un numéro de ligne à mise à jour automatique.

Notez que say"$.;"cela fonctionnerait également, car la question spécifiait que «vous pouvez supposer que chaque instruction du code occupera au plus l'intégralité d'une ligne».
msh210

Ce n'est pas vraiment un commentaire, cependant; bien qu'il ne fasse rien d'utile, il se retrouve dans l'AST (et parce que l'optimiseur de Perl est un peu nul, je pense que cela finira par ralentir le programme, quelque chose que vous ne voudriez pas vraiment qu'un commentaire fasse).

Ne fonctionne pas pour la règle Il n'est pas nécessaire de mettre des numéros de ligne pour les lignes qui ne contiennent que des espaces et des commentaires.
Denis Ibaev

9

Javascript, 43 39 octets

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

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


41 octets: a => (b = 0, a.replace (/ ^ / gm, _ => /*${++b}*/)) (utilisez une chaîne de formatage)
Conor O'Brien

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


3

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.


3

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. \
                    ')
                 )
      )

Je ne connais pas Lua, mais êtes-vous sûr que cela générera toujours des commentaires de même longueur? Par exemple, si un programme est de 10 lignes de long que le dernier commentaire sera --[[10]]qui est 1 caractère plus long que --[[9]]si vous le remplissez correctement avec des espaces.
Esolanging Fruit

1
Oh, je n'ai pas remarqué cette règle. Cela semble ... Un peu redondant ...
ATaco

1
Oui. Je vais peut-être le supprimer ... [EDIT]: supprimé.
Esolanging Fruit du

3

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.


Mais ne pourriez-vous pas insérer une chaîne et avoir du code autour d'elle, ce qui la rend ignorée?
Adám

Vous voulez dire sorte de e=3transformé au if (false) { 1 }; e=3lieu du courant !1␤e=3? Oui, il y aurait une solution de contournement longue de 19 caractères.
manatwork

2

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

1
Cela fait longtemps que je n'ai pas utilisé QBasic, mais cela ne fait-il pas du texte du programme un commentaire plutôt que des numéros de ligne? Ou est-ce que je me souviens mal de quelque chose?

Merci pour la contribution! En fait, le «commente juste ce qui suit sur la ligne.
anonymous2

4
Oui, c'est pourquoi je pense que cela transforme le programme en commentaires. Plutôt que d'ajouter simplement des numéros de ligne, il change la signification en un programme qui ne fait rien. (Honnêtement, ce serait cool pour une entrée dans un dialecte BASIC d'ajouter des vrais numéros de ligne et de renuméroter le programme s'il a déjà des numéros, mais ce n'est probablement pas vraiment nécessaire.)

2

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


2

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

{print"#"NR}1ou $0="#"NR RS$0?
manatwork

@manatwork j'ai honte et je suis reconnaissant de découvrir ces subtilités
Adam

2

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

1

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.


oNopeut être remplacé par nsur TIO.
Esolanging Fruit du

1

Mathematica, 58 octets

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

1

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!

Chers codeurs Perl et Ruby, veuillez observer les jq input_line_number. Être Thanksgiving, un sentiment spécial à exprimer $.?
manatwork

1

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.


1

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}"));

1
Techniquement 64 depuis op n'a pas mentionné de remplissage avec des zéros. Vous pouvez également économiser 1 octet de plus en raccordant: $ "/ * {i} * /" + l. (Déplacement du paramètre L hors de l'interpolation.)
CSharpie

Vous avez raison ^^ mais cela détruit mon "mauvais score" hehe
Stefan

0

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
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.