Objetivo

Reemplace todos los comentarios en C, C ++ o Java Code con el comentario // Do the needful.

Detalles específicos

Este desafío de codificación es simple. Tomar como entrada el nombre de un archivo. El archivo de entrada deberá contener código C, C ++ o Java. El código deberá contener uno o más comentarios. Los comentarios pueden ser de una sola línea /* */o //delimitados, así como /* */delimitados por varias líneas . La salida del programa debe ser idéntica a la entrada, excepto que todos los comentarios deben convertirse // Do the needful.

Por ejemplo, si el archivo de entrada es:

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

La salida del programa debería leer

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

Puntuación

Este es un concurso de popularidad. Usted consigue dos votos extra añadido a su puntuación si ninguna de las siguientes palabras aparece en su programa en caso de cualquier variación: {"do", "the", "needful"}. El puntaje es el número de votos más el bono si corresponde.

Subsidios

Si los comentarios aparecen en literales de cadena, es aceptable convertirlos // Do the needfultambién. Después de todo ... nunca puedes tener lo suficiente necesario.

CoffeeScript (66 bytes)

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

Este código analizará las cadenas, pero hay una buena razón. Verá, existe la posibilidad de que haya un comentario en una plantilla que genere /**/comentarios en C.

Esto consigue la ventaja, ya que evita casos de juegos compatibles insensibles a Do, they needful. También usa el [^]operador ES5 candle ( ) para hacer cosas. Pondría un comentario Do the needfulen este programa, pero eso eliminaría la bonificación.

Perl, 68 caracteres

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

Esto toma algunas libertades con la especificación y conserva el estilo de comentario original. Esto evita el problema con los /* ... */comentarios que aparecen antes del final de la línea.

No se intenta evitar los comentarios dentro de los literales de cadena, y no se hace ningún reclamo por los puntos de bonificación.

Perl

¡Primera anarquía mundial! :)

"nunca puedes tener lo suficiente necesario"

#!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, expresiones regulares

Como no se trata de un código de golf, no me preocupe por la longitud del código. Nada impresionante, pero me divertí recordando / reaprendiendo lo básico sobre expresiones regulares.

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 caracteres

Podría ser mejorado. Aprendí mucho sobre sed mientras hacía esto.

Lee desde entrada estándar, salidas a salida estándar. Asume una entrada válida: si tiene comentarios no terminados, no lo tratará como un comentario.

Probado en GNU sed v4.2.2.

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

¿Y el premio de legibilidad es para ...?

Versión de una línea:

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

Explicación

El flujo de control salta mucho, por medio de declaraciones GOTO (sí, ¡sed las tiene!). sed no tiene ningún bucle o declaraciones condicionales convenientes 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

Sí, BrainFuck es un lenguaje completo de Turing.
Buena suerte para entender este código.

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

Básicamente, el pseudocódigo es:

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
}

Algunos intérpretes en línea están rotos.
Pruébelo aquí con el ejemplo dado por el OP (finalizado con null-char para romper el bucle correctamente):

#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

No es código golf, así que seré prolijo.

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
 ]

(Nota: por razones políticas, estoy presionando COMBINAR aquí, pero aún no es estándar . Así que si realmente quieres ejecutar esto, usa REJOIN. Pero odio REJUINAR. ¡Una verruga en un lenguaje hermoso! conduce a escucharme. Gracias.)

PARSE es un dialecto, o lenguaje dentro de un idioma, en Rebol y Red. Retorce las cosas, por lo que, por ejemplo, los tipos de símbolos que se usan para la asignación (el terminator:in terminator: newline) adquieren un nuevo significado cuando se usan en el paradigma de código como datos ... guarda la posición de análisis actual en una variable con ese nombre . Puedes leer más sobre por qué es genial aquí .

ACTUALIZACIÓN: Oh, está bien, yo también jugaré golf. En Rebmu , 72 caracteres ... usando rebmu / args que inyecta A como argumento:

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

Exactamente el mismo programa.