¿Hacer lo necesario? [cerrado]


8

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.


55
¿Sabes que la bonificación se adquiere fácilmente usando "d" + "o", "t" + "he"y "need" + "ful"? Además, ¿el envío tiene que ser capaz de manejar algún código C, C ++ o Java válido? Eso es bastante duro y equivale a escribir un lexer para los tres idiomas (estoy pensando en comentarios literales en cadenas y viceversa). Si es así, ¿qué pasa con las bibliotecas de lexer de terceros?
Martin Ender

2
¿Qué debe hacer el programa cuando un /* ... */precede a un no comentario en una línea?
Greg Hewgill

1
¿Necesitamos considerar casos como char str[]="/**///";o /*aparece una secuencia de inicio de comentario en un /*comentario, o aparece una barra diagonal inversa-nueva línea en un //comentario, o un //comentario dentro de un /**/comentario?
user12205

3
¿Por qué hacer de esto un concurso de popularidad y no codificar golf? Funciona bien como el golf.
Aaronaught

2
finalmente, muchas soluciones se basan en el mismo reemplazo de expresiones regulares. ¿Qué pasa con algunos puntos de bonificación para soluciones que no son expresiones regulares?
CousinCocaine

Respuestas:


4

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.


6

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.


Estoy teniendo una pelota usando esto en el código fuente!
ojblass

2
Diría que mejora algunos estilos de comentarios.
Greg Hewgill

Puede obtener el punto de bonificación como este
ojblass

perl -0pe 's / ((\ / \ /). *? (\ n) | (\ / *). *? (* \ /)) / \ 2 \ 4 D \ coo th \ coe needfu \ cul \ 3 \ 5 / sg '
ojblass

1
@FDinoff: Sí, esa fue una libertad que tomé para simplificar el problema, de lo contrario, tiene que descubrir qué hacer con las líneas de código donde un /* ... */comentario precede al código real (no puede convertirlo ingenuamente en un //comentario).
Greg Hewgill

5

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

4

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()))

2

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

2

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

2

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.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.