Tor

Ersetzen Sie alle Kommentare in C, C ++ oder Java Code durch den Kommentar // Do the needful.

Besonderheiten

Diese Codierungsherausforderung ist einfach. Nehmen Sie als Eingabe den Namen einer Datei. Die Eingabedatei muss C-, C ++ - oder Java-Code enthalten. Der Code muss einen oder mehrere Kommentare enthalten. Die Kommentare können einzeilig /* */oder //begrenzt sowie mehrzeilig /* */begrenzt sein. Die Ausgabe des Programms sollte mit der Eingabe identisch sein, außer dass alle Kommentare in konvertiert werden sollten // Do the needful.

Zum Beispiel, wenn die Eingabedatei lautet:

#include <iostream.h>

int   result;    // the result of the calculations 
char  oper_char; // the user-specified operator 
int   value;     // value specified after the operator

/* standard main function */     
int main()
{
    result = 0; // initialize the result 

    // Loop forever (or till we hit the break statement) 
    while (1) {
        cout << "Result: " << result << '\n';

        /* This code outputs display and requests
           input from the user */
        cout << "Enter operator and number: ";
        cin >> oper_char;
        cin >> value;

        if (oper_char = '+') {
            result += value;
        } else {
            cout << "Unknown operator " << oper_char << '\n';
        }
    }
    return (0);
}

Die Ausgabe des Programms sollte lauten

#include <iostream.h>

int   result;    // Do the needful
char  oper_char; // Do the needful
int   value;     // Do the needful

// Do the needful
int main()
{
    result = 0; // Do the needful

    // Do the needful
    while (1) {
        cout << "Result: " << result << '\n';

        // Do the needful
        cout << "Enter operator and number: ";
        cin >> oper_char;
        cin >> value;

        if (oper_char = '+') {
            result += value;
        } else {
            cout << "Unknown operator " << oper_char << '\n';
        }
    }
    return (0);
}

Wertung

Dies ist ein Beliebtheitswettbewerb. Sie erhalten zwei zusätzliche Stimmen zu Ihrer Punktzahl hinzugefügt, wenn in keinem Fall eines der folgenden Wörter in Ihrem Programm erscheint : {"do", "the", "needful"}. Die Punktzahl ist die Anzahl der Stimmen plus ggf. der Bonus.

Zulagen

Wenn Kommentare in Zeichenfolgenliteralen angezeigt werden, können sie auch in konvertiert werden // Do the needful. Immerhin ... kann man nie genug Bedürftiges haben.

CoffeeScript (66 Bytes)

(c)->c.replace /\/\/.*\n?|\/\*[^]*?\*\//g,"// D\o t\he needfu\l\n"

Dieser Code analysiert Zeichenfolgen, aber es gibt einen guten Grund. Sie sehen, es besteht die Möglichkeit, dass eine Vorlage einen Kommentar enthält, der C- /**/Kommentare generiert .

Dieser bekommt den Bonus, da es genaue Groß- und Kleinschreibung Treffer für vermeidet Do, theund needful. Es verwendet auch den ES5- [^]Operator candle ( ), um Dinge zu erledigen. Ich würde einen Kommentar Do the needfulin dieses Programm einfügen, aber das würde den Bonus entfernen.

Perl, 68 Zeichen

perl -0pe's@((//).*?(\n)|(/\*).*?(\*/))@\2\4 Do the needful \3\5@sg'

Dies erfordert einige Freiheiten bei der Spezifikation und behält den ursprünglichen Kommentarstil bei. Dadurch wird das Problem vermieden, dass /* ... */Kommentare vor dem Zeilenende angezeigt werden.

Es wird kein Versuch unternommen, Kommentare in String-Literalen zu vermeiden, und es wird kein Anspruch auf die Bonuspunkte erhoben.

Perl

Erste Welt Anarchie! :) :)

"Man kann nie genug Bedürftiges haben"

#!perl -p0
sub the { s,(?<=\w)(.*)(\n),$1 // do the needful$2,g }
sub needful { s,//.*\n,\n,g,s,/\*.*?\*/,,msg }

do not do the needful

Python 3.x, Regex

Da es kein Code-Golf ist, habe ich mich nicht um die Code-Länge gekümmert. Nichts Beeindruckendes, aber ich hatte Spaß daran, mich an die Grundlagen von Regex zu erinnern / sie neu zu lernen.

import re
import urllib.request as r
def dTN(filename):
    dtn = re.search(r"(?<=question-hyperlink\">)([A-Za-z \n]*)(?=[?]<)", r.urlopen("http://codegolf.stackexchange.com/questions/28625/").read().decode("utf8")).group(0)
    with open(filename) as f:
        return re.sub(r"//{1}.*", "//{0}".format(dtn), re.sub(r"/\*[A-Za-z \n]*\*/", "// {0}".format(dtn), f.read()))

sed, 90 Zeichen

Könnte verbessert werden. Dabei habe ich viel über sed gelernt.

Liest von der Standardeingabe, die Ausgabe zur Standardausgabe. Nimmt eine gültige Eingabe an. Wenn Sie nicht abgeschlossene Kommentare haben, wird diese nicht als Kommentar behandelt.

Getestet auf GNU sed v4.2.2.

s_/\*.*\*/_//_
tg
s_/\*.*$_//_
tl
:g
s_//.*$_// Do the needful_
P
d
:l
s_.*\*/_//_
tg
N
bl

Und der Preis für Lesbarkeit geht an ....?

Einzeiler-Version:

s_/\*.*\*/_//_;tg;s_/\*.*$_//_;tl;:g;s_//.*$_// Do the needful_;P;d;:l;s_.*\*/_//_;tg;N;bl

Erläuterung

Der Kontrollfluss springt mithilfe von GOTO-Anweisungen viel herum (ja, sed hat sie!). sed hat keine Schleifen oder bequemen bedingten Anweisungen AFAIK.

s_/\*.*\*/_//_              # Substitute /* ... */ with //
tg                          # GOTO g if the substitution occured
s_/\*.*$_//_                # Substitute /*...<ENDOFLINE> with //
tl                          # GOTO l if the substitution occured
:g                          # GOTO-LABEL g
s_//.*$_// Do the needful_  # Replace //...<ENDOFLINE> with // Do the needful
P                           # Print the pattern space (current line with substitutions)
d                           # empty the pattern space and move on to the next line
:l                          # GOTO-LABEL l
s_.*\*/_//_                 # Replace ... */ with //
tg                          # GOTO g if the substitution occured
N                           # take another line from input and add it to the pattern space
bl                          # GOTO l

BrainFuck

Ja, BrainFuck ist eine Turing-vollständige Sprache.
Viel Glück beim Verständnis dieses Codes.

,[.-----------------------------------------------[>+>+<<-]>
>[-<<+>>][-]+<[[-]>-<]>[>,----------------------------------
-------------[>+>+<<-]>>[-<<+>>]<>[-]+<[>-<+++++[>+>+<<-]>>[
-<<+>>]<>[-]+<[>-<++++++++++++++++++++++++++++++++++++++++++
.[-]]>[<+++++++++++++++++++++++++++++++++++++++++++++++.----
-----------.++++++++++++++++++++++++++++++++++++.+++++++++++
++++++++++++++++++++++++++++++++.---------------------------
----------------------------------------------------.+++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++.------------.---.-------------------------
--------------------------------------------.+++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++.---------..-.++.+++++++++++++++.---------.[+++++[,------
------------------------------------],----------------------
-------------------------]>-]<<[-]]>[<++++++++++++++++++++++
+++++++++++++++++++++++++.---------------.++++++++++++++++++
++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++
++.---------------------------------------------------------
----------------------.+++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++.------------
.---.-------------------------------------------------------
--------------.+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++.---------..-.++.++++++++++
+++++.---------.[,----------]++++++++++.[-]>-]<<[-]<<>-]<<,]

Grundsätzlich lautet der Pseudocode:

get input_char
while (input_char is not null)
{
  print input_char
  if (input_char is '/')
  {
    get input_char
    if (input_char is '/')
    {
      print '/ Do the needful'
      get input_char until input_char is '\n'
    }
    else
    {
      if (input_char is '*')
      {
        print '/ Do the needful'
        get input_char until input_char is '*' followed by '/'
      }
      else
      {
        print input_char
      }
    }
  }
  get input_char
}

Einige Online-Dolmetscher sind kaputt.
Versuchen Sie es hier mit dem Beispiel des OP (endete mit null-char , um die Schleife richtig zu unterbrechen):

#include <iostream.h>\n\nint   result;    // the result of the calculations \nchar  oper_char; // the user-specified operator \nint   value;     // value specified after the operator\n\n/* standard main function */     \nint main()\n{\n    result = 0; // initialize the result \n\n    // Loop forever (or till we hit the break statement) \n    while (1) {\n        cout << "Result: " << result << '\\n';\n\n        /* This code outputs display and requests\n           input from the user */\n        cout << "Enter operator and number: ";\n        cin >> oper_char;\n        cin >> value;\n\n        if (oper_char = '+') {\n            result += value;\n        } else {\n            cout << "Unknown operator " << oper_char << '\\n';\n        }\n    }\n    return (0);\n}\0

Rebol

Es ist kein Code Golf, also werde ich wortreich sein.

do-the-needful: function [filename [file!]] [
    parse (data: to-string read filename) [
        ; match the pattern in brackets ANY number of times (zero okay)
        any [
            ; seek the parse position up TO one of the following matches
            ; if a match is hit, following code in parentheses is executed normally
            to [
                "/*" (terminator: "*/")
            | 
                "//" (terminator: newline)
            ]

            ; save parse position in start, seek up THRU terminator and leave parse
            ; position at the end of the terminator match (not the beginning as w/TO)
            start:
            thru terminator
            finish:

            ; Do partial replacement within the input; starting at START
            ; but limited to FINISH.  Again, structure in parentheses is exec'd as code
            (
                change/part start combine ["// Do the needful" newline] finish
            )
        ]
    ]
    return data
 ]

(Hinweis: Aus politischen Gründen drücke ich hier auf COMBINE, aber es ist noch nicht Standard . Wenn Sie dies also tatsächlich ausführen möchten, verwenden Sie REJOIN. Aber ich hasse REJOIN. Eine Warze in einer ansonsten schönen Sprache! Sagen Sie Ihrer freundlichen Nachbarschaft Red dev führt dazu, mir zuzuhören. Danke.)

PARSE ist ein Dialekt oder eine Sprache innerhalb einer Sprache in Rebol und Rot. Es verdreht die Dinge, so dass zum Beispiel die Symboltypen, die für die Zuweisung verwendet werden (das terminator:In terminator: newline), eine neue Bedeutung bekommen, wenn sie im Code-as-Data-Paradigma verwendet werden ... es speichert die aktuelle Analyseposition in einer Variablen mit diesem Namen . Lesen Sie hier mehr darüber, warum es cool ist .

UPDATE: Oh alles klar, ich werde es auch spielen. In Rebmu 72 Zeichen ... mit rebmu / args, das A als Argument einfügt:

pa DtsRDa[anTO["/*"(T"*/")|"//"(Tlf)]SthT F(chpS"// Do the needful^/"f)]d

Genau das gleiche Programm.