स्ट्रिंग से एकल पंक्ति और बहुस्तरीय टिप्पणियां निकालें


19

लक्ष्य

अपनी पसंद की प्रोग्रामिंग भाषा का उपयोग करते हुए, C प्रोग्राम का प्रतिनिधित्व करने वाले स्ट्रिंग से टिप्पणियों को समाप्त करने के लिए सबसे छोटा प्रोग्राम लिखें ।


इनपुट

स्ट्रिंग को इनपुट के किसी भी रूप के रूप में लिया जा सकता है, लेकिन इसे एक चर के रूप में भी लिया जा सकता है।


अनुदेश

दो अलग-अलग तरह की टिप्पणियों को हटाया जाना है:

  • बहुस्तरीय टिप्पणी , के साथ शुरू /*और समाप्त*/
  • //लिनक्स शैली लाइन के टूटने (LF \n) के साथ शुरू और समाप्त होने वाली एकल पंक्ति टिप्पणियाँ

स्ट्रिंग्स के भीतर टिप्पणियां नहीं हटाई जानी हैं। इस चुनौती के उद्देश्य के लिए, आपको केवल "-निर्धारित स्ट्रिंग्स पर विचार करने की आवश्यकता है । विशेष रूप से, आप '-delimited चरित्र शाब्दिक की संभावना को अनदेखा कर सकते हैं । आप ट्रिग्राफ और लाइन निरंतरता ( /\<LF>*...) को भी अनदेखा कर सकते हैं ।


उदाहरण

इनपुट:

#include <stdio.h>

int main(int argc, char** argv)
{
    // this comment will be removed
    if (argc > 1) {
        printf("Too many arguments.\n");   // this too will be removed
        return 1;
    }
    printf("Please vist http://this.will.not.be.removed.com\n");
    printf("/* This will stay */\n");
    printf("\"/* This will stay too */\"\n");
    printf("//and so will this\\");
    // but not this
    printf("just \"ano//ther\" test.");
    return 0;
}

आउटपुट:

#include <stdio.h>

int main(int argc, char** argv)
{

    if (argc > 1) {
        printf("Too many arguments.\n");   
        return 1;
    }
    printf("Please vist http://this.will.not.be.removed.com\n");
    printf("/* This will stay */\n");
    printf("\"/* This will stay too */\"\n");
    printf("//and so will this\\");

    printf("just \"ano//ther\" test.");
    return 0;
}

इनपुट:

/*
    this shall disappear
*/
#include <string>
int main(int argc, char** argv)
{
    string foo = ""/*remove that!**/;
    // Remove /* this
    int butNotThis = 42;
    // But do */ remove this
    int bar = 4 /*remove this*/* 3; // but don't remove that 3. */
    return 0;//just a comment
}/*end of the file has been reached.*/

आउटपुट:

#include <string>
int main(int argc, char** argv)
{
    string foo = "";

    int butNotThis = 42;

    int bar = 4 * 3; 
    return 0;
}

1
जहाँ से कोड होना चाहिएprintf("\"/* This will stay too */\"\n"); में दिखाई दिया ?
11

ओह, माफ करना ... यह सिर्फ एक टाइपो था। ध्यान देने के लिए धन्यवाद!
मैथ्यू रोडिक

व्हॉट्सएप की गिनती करते हैं? सामने 4 रिक्त स्थान हैं, // this comment will be removedजो बस गायब हो गए। उसके लिए कोई नियम?
11

1
मैं किसी भी सूचीबद्ध भाषाओं को नहीं जानता जो अच्छी तरह से है, इसलिए किसी प्रकार का स्व-निहित कल्पना अच्छा होगा, साथ में अधिक उदाहरण।
जर्गर्ब

@ मैनटवर्क: व्हॉट्सएप हटाना अनिवार्य नहीं है
मैथ्यू रोडिक

जवाबों:


11

रेटिना , 35 + 1 + 2 = 38 बाइट्स

इस प्रोग्राम में दो फाइलें हैं, इसलिए मैंने दूसरी फाइल के लिए 1-बाइट पेनल्टी शामिल की है ।

//.*|/\*[\s\S]*?\*/|("(\\.|[^"])*")
$1

.NET फ्लेवर का उपयोग करते हुए यह एक साधारण रेगेक्स रिप्लेसमेंट है (हालाँकि यह अधिकांश अन्य फ्लेवर्स में भी यही काम करेगा)।

यह विचार टिप्पणी और तार दोनों को मिलाने के लिए है, लेकिन यदि यह एक तार है तो केवल मैच वापस लिखें। स्पष्ट रूप से तारों का मिलान करके, टिप्पणियों की खोज करते समय उन्हें छोड़ दिया जाता है।


1
यह PHP में आश्चर्यजनक रूप से अच्छी तरह से काम करता है: regex101.com/r/kB5kA4/1
Ismael Miguel

1
@IsmaelMiguel हाँ, मैं कुछ भी विशिष्ट सुविधा का उपयोग नहीं किया। केवल यही कारण है कि मैंने .NET को उठाया है क्योंकि रेटिना मुझे रीगेक्स-केवल प्रोग्राम लिखने की अनुमति देता है, जैसे बिना किसी चीज के ओवरहेड preg_replace
मार्टिन एंडर

मुझे यह बात पता है। आपने इसे पहले काफी इस्तेमाल किया है। अगर मैं सही हूं, तो यह आपके द्वारा बनाया गया था। यह जिज्ञासु के लिए था। और यह भी, अब आपके पास एक परीक्षण-सूट है, जहां आप इस प्रश्न में जो भी बदलाव आते हैं, उसका परीक्षण कर सकते हैं (मैं कई भविष्यवाणी करता हूं)
इस्माइल मिगुएल

अच्छा! यह नियमित अभिव्यक्ति अन्य प्रोग्रामिंग भाषाओं के साथ भी काम करती है (जब स्लैश बच जाते हैं)।
मैथ्यू रोडिक

मैंने आपके साथ काम करने की तकनीक का इस्तेमाल एक थर्ड पार्टी लाइब्रेरी को बेहतर बनाने के लिए किया है जिसमें मैं काम करता हूं: Dojo टूलकिट
mbomb007

15

शेल + कोरुटिल्स + जीसीसी संकलक संग्रह, 31 बाइट्स

यह उत्तर थोड़ा शिथिल लग सकता है, लेकिन मैंने विशेष रूप से इस प्रश्न पर प्रतिबंध लगाने के बारे में कुछ भी नहीं देखा।

अनाड़ी नियमित अभिव्यक्तियों का उपयोग करने के बजाय, उस टूल का उपयोग क्यों न करें जो नौकरी के लिए बनाया गया था। इसे सही परिणाम देने में कोई समस्या नहीं होनी चाहिए:

cpp -fpreprocessed -o- -|sed 1d

STDIN से इनपुट लेता है और आउटपुट से STDOUT में जाता है। आम तौर पर ccpसभी प्रीप्रोसेसिंग (हेडर फाइलें, मैक्रो विस्तार, टिप्पणी हटाने आदि) करेंगे, लेकिन -fpreprocessedविकल्प के साथ , यह अधिकांश चरणों को छोड़ देगा, लेकिन यह अभी भी टिप्पणियों को हटा देगा। इसके अलावा, cpp # 1 "<stdin>"आउटपुट की शुरुआत की तरह एक लाइन जोड़ता है , इसलिए sedइसे हटाने के लिए है।


1
यदि इनपुट फ़ाइल में एक्सटेंशन में से एक है .i, .iiया "-fpreprocessed निहित है .mi"। क्या आप a.iझंडे का उपयोग करने के बजाय फ़ाइल को कुछ बचाकर कुछ बाइट्स को बचाने में सक्षम हो सकते हैं ?
मार्टिन एंडर

@ मार्टिनबटनर हां, मैंने देखा कि मैनुअल में भी। इसलिए मुझे उम्मीद है कि कुछ cat>i.i;cpp -o- i.i|sed 1dसमान होगा। लेकिन पूर्ण प्रीप्रोसेसिंग ensues (जैसे stdio.h की पूर्ण सामग्री डाली गई हैं)। संभव gcc बग ??? अच्छी तरह से शायद जब मैं एक मो मिल मैं cpp स्रोत की जाँच करेंगे। '
डिजिटल ट्रामा

|sed 1dयदि आप -Pविकल्प जोड़ते हैं तो आप निकाल सकते हैं । ध्यान दें कि (प्रश्न द्वारा अनुमति दी गई है), क्योंकि यह पूर्व-संसाधित कोड की अपेक्षा करता है, यह ट्रिगर या लाइन निरंतरता को ठीक से संभाल नहीं पाएगा।
शा।

3

जावा 365

String a(String s){String o="";int m=1;for(int i=0;i<s.length();i++){String u=s.substring(i,Math.min(i+2,s.length()));char c=s.charAt(i);switch(m){case 1:m=u.equals("/*")?5:u.equals("//")?4:c=='"'?3:1;break;case 3:m=c=='"'?1:c=='\\'?2:3;break;case 2:m=3;break;case 4:m=c=='\n'?1:4;continue;case 5:m=u.equals("*/")?1:5;i+=m==1?1:0;continue;}o+=m<4?c:"";}return o;}}

Ungolfed

public static final int DEFAULT = 1;
public static final int ESCAPE = 2;
public static final int STRING = 3;
public static final int ONE_LINE_COMMENT = 4;
public static final int MULTI_LINE_COMMENT = 5;

String clear(String s) {
    String out = "";
    int mod = DEFAULT;
    for (int i = 0; i < s.length(); i++) {
        String substring = s.substring(i, Math.min(i + 2 , s.length()));
        char c = s.charAt(i);
        switch (mod) {
            case DEFAULT: // default
                mod = substring.equals("/*") ? MULTI_LINE_COMMENT : substring.equals("//") ? ONE_LINE_COMMENT : c == '"' ? STRING : DEFAULT;
                break;
            case STRING: // string
                mod = c == '"' ? DEFAULT : c == '\\' ? ESCAPE : STRING;
                break;
            case ESCAPE: // string
                mod = STRING;
                break;
            case ONE_LINE_COMMENT: // one line comment
                mod = c == '\n' ? DEFAULT : ONE_LINE_COMMENT;
                continue;
            case MULTI_LINE_COMMENT: // multi line comment
                mod = substring.equals("*/") ? DEFAULT : MULTI_LINE_COMMENT;
                i += mod == DEFAULT ? 1 : 0;
                continue;
        }
        out += mod < 4 ? c : "";
    }

    return out;
}

2

पायथन 2 - 163 134 बाइट्स

import re
def f(s):
 for x in re.findall(r'("[^\n]*"(?!\\))|(//[^\n]*$|/(?!\\)\*[\s\S]*?\*(?!\\)/)',s,8):s=s.replace(x[1],'')
 print s

जैसा कि आप यहां देख सकते हैं , रेगेक्स में 2 वैकल्पिक कैप्चरिंग समूह हैं। पहले वाला सभी उद्धृत तारों को पकड़ता है। दूसरी सभी टिप्पणियाँ।

हमें बस इतना करने की जरूरत है, 2 वें समूह द्वारा कब्जा कर लिया गया सब कुछ हटा रहा है।

उदाहरण:

Python 2.7.9 (default, Dec 11 2014, 04:42:00) 
[GCC 4.9.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import re
>>> def f(s):
...  for x in re.findall(r'("[^\n]*"(?!\\))|(//[^\n]*$|/(?!\\)\*[\s\S]*?\*(?!\\)/)',s,8):s=s.replace(x[1],'')
...  print s
... 
>>> code = r'''#include <stdio.h>
... 
... int main(int argc, char** argv)
... {
...     // this comment will be removed
...     if (argc > 1) {
...         printf("Too many arguments.\n");   // this too will be removed
...         return 1;
...     }
...     printf("Please vist http://this.will.not.be.removed.com\n");
...     printf("/* This will stay */\n");
...     printf("\"/* This will stay too */\"\n");
...     printf("//and so will this\\");
...     // but not this
...     printf("just \"ano//ther\" test.");
...     return 0;
... }
... /*
...     this shall disappear
... */
... #include <string>
... int main(int argc, char** argv)
... {
...     string foo = ""/*remove that!**/;
...     // Remove /* this
...     int butNotThis = 42;
...     // But do */ remove this
...     int bar = 4 /*remove this*/* 3; // but don't remove that 3. */
...     return 0;//just a comment
... }/*end of the file has been reached.*/'''
>>> f(code)
#include <stdio.h>

int main(int argc, char** argv)
{

    if (argc > 1) {
        printf("Too many arguments.\n");   
        return 1;
    }
    printf("Please vist http://this.will.not.be.removed.com\n");
    printf("/* This will stay */\n");
    printf("\"/* This will stay too */\"\n");
    printf("//and so will this\\");

    printf("just \"ano//ther\" test.");
    return 0;
}

#include <string>
int main(int argc, char** argv)
{
    string foo = "";

    int butNotThis = 42;

    int bar = 4 * 3; 
    return 0;
}

1

प्रतिबल - 151

f: func[t][Q:{"}W: complement charset Q parse t[any[[Q any["\\"|"\"Q | W]Q]|[a:[["//"to[lf | end]]|["/*"thru"*/"]]b:(remove/part a b):a skip]| skip]]t]

अनगोल्डेड + कुछ एनोटेशन:

f: func [t] [
    Q: {"}
    W: complement charset Q     ;; any char thats not a double quote

    ; rule to parse t (c program) - it can be ANY of 
    ;     1. string 
    ;     2. OR comment (if so then remove)
    ;     3. OR pass thru

    parse t [
        any [
            ;; 1. String rule
            [Q any ["\\" | "\" Q | W] Q]

            ;; 2. OR comments rule
            | [
                a:  ;; mark beginning of match
                [
                    ;;    // comment    OR  /* comment */
                    ["//" to [lf | end]] | ["/*" thru "*/"]
                ]
                b:  ;; mark end of match 
                (remove/part a b) :a skip   ;; remove comment
            ]

            ;; 3. OR allow thru (so not a String or Comment)
            | skip
        ]
    ]

    t
]

1

पीएचपी

कनवर्ज़न के लिए @Martin एंडर का जवाब प्रस्तुत करना:

$str = preg_replace_callback('/\/\/.*|\/\*[\s\S]*?\*\/|("(\\.|[^"])*")/m', 
  function($matches){
     if(\is_array($matches) && (\count($matches) > 1)){
        return $matches[1];
     }else{
        return '';
     }
  }, $str);

अब $strएकल और बहु-पंक्ति टिप्पणियाँ खो दी हैं । यह JSON डेटा में टिप्पणी करने से पहले स्ट्रिपिंग टिप्पणियों के लिए उपयोगी है json_decode()


शायद आप एक टर्नरी ऑपरेटर का उपयोग करके बाइट्स की संख्या को कम कर सकते हैं?
मैथ्यू रोडिक

0

C # (262 वर्ण):

यह बहुत अच्छा से इतना जवाब:

string a(string i){return Regex.Replace(i, @"/\*(.*?)\*/|//(.*?)\r?\n|""((\\[^\n]|[^""\n])*)""|@(""[^""]*"")+", m => { var v = m.Value; if (v.StartsWith("/*") || v.StartsWith("//")) return v.StartsWith("//") ? "\r\n" : ""; return v; }, RegexOptions.Singleline);

-1

जेएस (ईएस 6), 47 वर्ण (wip)

डेमो: http://codepen.io/anon/pen/dPEMro

a=b=>b.replace(/(\/\*[^]*?\*\/|\/\/.*)\n?/g,"")

मेरे कोडगिन किए गए मिनिफ़ायर से प्रेरित: http://xem.github.io/miniMinifier/

तार में टिप्पणियों को अभी तक नहीं संभालता है ...

मैं यह देखने के लिए उत्सुक हूं कि क्या JS regexes में इसे हासिल करना संभव है।


यदि यह उत्तर आवश्यकताओं को पूरा नहीं करता है, तो इसे या तो ठीक किया जाना चाहिए या हटा दिया जाना चाहिए।
mbomb007
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.