Objetivo

Substitua todos os comentários em C, C ++ ou Java Code pelo comentário // Do the needful.

Específicos

Esse desafio de codificação é simples. Tome como entrada o nome de um arquivo. O arquivo de entrada deve conter código C, C ++ ou Java. O código deve conter um ou mais comentários. Os comentários podem ser delimitados por uma única linha /* */ou //delimitados por várias linhas /* */. A saída do programa deve ser idêntica à entrada, exceto que todos os comentários devem ser convertidos em // Do the needful.

Por exemplo, se o arquivo de entrada for:

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

A saída do programa deve ler

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

Pontuação

Este é um concurso de popularidade. Você ganha dois votos extras adicionados a sua pontuação se nenhuma das seguintes palavras aparece em seu programa em qualquer variação caso: {"do", "the", "needful"}. Pontuação é o número de votos mais bônus, se aplicável.

Subsídios

Se os comentários aparecerem em literais de string, é aceitável convertê-los // Do the needfultambém. Afinal ... você nunca pode ter o suficiente necessário.

CoffeeScript (66 bytes)

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

Esse código analisará as strings, mas há um bom motivo. Veja bem, existe a possibilidade de haver um comentário em um modelo que gera /**/comentários em C.

Este recebe o bônus, pois evita casos exata partidas insensíveis para Do, the, e needful. Ele também usa o [^]operador vela do ES5 ( ) para fazer as coisas. Eu colocaria um comentário Do the needfulneste programa, mas isso removeria o bônus.

Perl, 68 caracteres

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

Isso requer algumas liberdades com a especificação e mantém o estilo de comentário original. Isso evita o problema com /* ... */comentários que aparecem antes do final da linha.

Nenhuma tentativa é feita para evitar comentários dentro de literais de string e nenhuma reivindicação é feita para os pontos de bônus.

Perl

Anarquia do primeiro mundo! :)

"você nunca pode ter o suficiente necessário"

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

Como não é um código de golfe, não me preocupei com o tamanho do código. Nada impressionante, mas eu me diverti lembrando / reaprendendo noções básicas sobre regex.

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

Poderia ser melhorado. Eu aprendi muito sobre sed enquanto fazia isso.

Lê da entrada padrão, saídas para saída padrão. Pressupõe entrada válida - se você tiver comentários não terminados, não será tratado como um comentário.

Testado no GNU sed v4.2.2.

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

E o prêmio de legibilidade vai para ....?

Versão de uma linha:

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

Explicação

O fluxo de controle salta bastante, por meio de instruções GOTO (sim, o sed as possui!). O sed não possui loops ou declarações condicionais 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

Sim, o BrainFuck é uma linguagem completa de Turing.
Boa sorte para entender este código.

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

Basicamente, o pseudocódigo é:

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
}

Algum intérprete online está quebrado.
Tente aqui com o exemplo dado pelo OP (terminado com null-char para interromper o loop corretamente):

#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

Não é código de golfe, então eu vou ser prolixo.

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 razões políticas, estou pressionando COMBINE aqui, mas ainda não é padrão . Portanto, se você realmente deseja executar isso, use REJOIN. Mas eu odeio REJOIN. Uma verruga em uma linguagem de outra maneira bonita! leva a me ouvir. Obrigado.)

PARSE é um dialeto, ou idioma dentro de um idioma, em Rebol e Red. Ele torce as coisas, por isso, por exemplo, os tipos de símbolos que são usados para atribuição (o terminator:no terminator: newline) assume um novo significado quando utilizados no código-as-dados paradigma ... ele salva a posição de análise atual em uma variável com esse nome . Você pode ler mais sobre por que é legal aqui .

ATUALIZAÇÃO: Ah, tudo bem, eu também vou jogar golfe. No Rebmu , 72 caracteres ... usando rebmu / args, que injeta A como argumento:

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

Exatamente o mesmo programa.