[Swift]LeetCode722. 删除注释 | Remove Comments

发布时间：2020-12-14 05:02:28 所属栏目：百科来源：网络整理

导读：Given a C++ program,remove comments from it. The program? source ?is an array where? source[i] ?is the? i -th line of the source code. This represents the result of splitting the original source code string by the newline character? n . I

Given a C++ program,remove comments from it. The program?source?is an array where?source[i]?is the?i-th line of the source code. This represents the result of splitting the original source code string by the newline character?n.

In C++,there are two types of comments,line comments,and block comments.

The string?//?denotes a line comment,which represents that it and rest of the characters to the right of it in the same line should be ignored.

The string?/*?denotes a block comment,which represents that all characters until the next (non-overlapping) occurrence of?*/should be ignored. (Here,occurrences happen in reading order: line by line from left to right.) To be clear,the string?/*/?does not yet end the block comment,as the ending would be overlapping the beginning.

The first effective comment takes precedence over others: if the string?//?occurs in a block comment,it is ignored. Similarly,if the string?/*?occurs in a line or block comment,it is also ignored.

If a certain line of code is empty after removing comments,you must not output that line: each string in the answer list will be non-empty.

There will be no control characters,single quote,or double quote characters. For example,?source = "string s = "/* Not a comment. */";"?will not be a test case. (Also,nothing else such as defines or macros will interfere with the comments.)

It is guaranteed that every open block comment will eventually be closed,so?/*?outside of a line or block comment always starts a new comment.

Finally,implicit newline characters can be deleted by block comments. Please see the examples below for details.

After removing the comments from the source code,return the source code in the same format.

Example 1:

Input: 
source = ["/*Test program */","int main()","{ ","  // variable declaration ","int a,b,c;","/* This is a test","   multiline  ","   comment for ","   testing */","a = b + c;","}"]

The line by line code is visualized as below:
/*Test program */
int main()
{ 
  // variable declaration 
int a,c;
/* This is a test
   multiline  
   comment for 
   testing */
a = b + c;
}

Output: ["int main()","  ","}"]

The line by line code is visualized as below:
int main()
{ 
  
int a,c;
a = b + c;
}

Explanation: 
The string  denotes a block comment,including line 1 and lines 6-9. The string  denotes line 4 as comments./*//

Example 2:

Input: 
source = ["a/*comment","line","more_comment*/b"]
Output: ["ab"]
Explanation: The original source string is "a/*commentnlinenmore_comment*/b",where we have bolded the newline characters.  After deletion,the implicit newline characters are deleted,leaving the string "ab",which when delimited by newline characters becomes ["ab"].

Note:

The length of?source?is in the range?[1,100].
The length of?source[i]?is in the range?[0,80].
Every open block comment is eventually closed.
There are no single-quote,double-quote,or control characters in the source code.

给一个 C++ 程序，删除程序中的注释。这个程序source是一个数组，其中source[i]表示第i行源码。?这表示每行源码由n分隔。

在 C++ 中有两种注释风格，行内注释和块注释。

字符串//?表示行注释，表示//和其右侧的其余字符应该被忽略。

字符串/*?表示一个块注释，它表示直到*/的下一个（非重叠）出现的所有字符都应该被忽略。（阅读顺序为从左到右）非重叠是指，字符串/*/并没有结束块注释，因为注释的结尾与开头相重叠。

第一个有效注释优先于其他注释：如果字符串//出现在块注释中会被忽略。同样，如果字符串/*出现在行或块注释中也会被忽略。

如果一行在删除注释之后变为空字符串，那么不要输出该行。即，答案列表中的每个字符串都是非空的。

样例中没有控制字符，单引号或双引号字符。比如，source = "string s = "/* Not a comment. */";"?不会出现在测试样例里。（此外，没有其他内容（如定义或宏）会干扰注释。）

我们保证每一个块注释最终都会被闭合，所以在行或块注释之外的/*总是开始新的注释。

最后，隐式换行符可以通过块注释删除。有关详细信息，请参阅下面的示例。

从源代码中删除注释后，需要以相同的格式返回源代码。

示例?1:

输入: 
source = ["/*Test program */","}"]

示例代码可以编排成这样:
/*Test program */
int main()
{ 
  // variable declaration 
int a,c;
/* This is a test
   multiline  
   comment for 
   testing */
a = b + c;
}

输出: ["int main()","}"]

编排后:
int main()
{ 
  
int a,c;
a = b + c;
}

解释: 
第 1 行和第 6-9 行的字符串 /* 表示块注释。第 4 行的字符串 // 表示行注释。

示例 2:

输入: 
source = ["a/*comment","more_comment*/b"]
输出: ["ab"]
解释: 原始的 source 字符串是 "a/*commentnlinenmore_comment*/b",其中我们用粗体显示了换行符。删除注释后，隐含的换行符被删除，留下字符串 "ab" 用换行符分隔成数组时就是 ["ab"].

注意:

source的长度范围为[1,100].
source[i]的长度范围为[0,80].
每个块注释都会被闭合。
给定的源码中不会有单引号、双引号或其他控制字符。

Runtime:?12 ms

Memory Usage:?19.8 MB

 1 class Solution {
 2     func removeComments(_ source: [String]) -> [String] {
 3         var res:[String] = [String]()
 4         var blocked:Bool = false
 5         var out:String = String()
 6         for line in source
 7         {
 8             var i:Int = 0
 9             while(i < line.count)
10             {
11                 if !blocked
12                 {
13                     if i == line.count - 1
14                     {
15                         out.append(line[i])      
16                     }
17                     else
18                     {
19                         var t:String = line.subString(i,2)                        
20                         if t == "/*" {
21                             blocked = true
22                             i += 1
23                         }
24                         else if t == "//" {break}
25                         else {out.append(line[i])}
26                     }
27                 }
28                 else
29                 {
30                     if i < line.count - 1
31                     {
32                         var t:String = line.subString(i,2)
33                         if t == "*/" {
34                             blocked = false
35                             i += 1
36                         }                        
37                     }                    
38                 }
39                  i += 1
40             }
41             if !out.isEmpty && !blocked
42             {
43                 res.append(out);
44                 out = String()
45             }            
46         }
47         return res
48     }
49 }
50 
51 extension String {    
52     //subscript函数可以检索数组中的值
53     //直接按照索引方式截取指定索引的字符
54     subscript (_ i: Int) -> Character {
55         //读取字符
56         get {return self[index(startIndex,offsetBy: i)]}
57     }
58     
59     // 截取字符串：指定索引和字符数
60     // - begin: 开始截取处索引
61     // - count: 截取的字符数量
62     func subString(_ begin:Int,_ count:Int) -> String {
63         let start = self.index(self.startIndex,offsetBy: max(0,begin))
64         let end = self.index(self.startIndex,offsetBy:  min(self.count,begin + count))
65         return String(self[start..<end]) 
66     }    
67 }

12ms

 1 class Solution {
 2     func removeComments(_ source: [String]) -> [String] {
 3         var res: [String] = []        
 4         var inBlock = false
 5         var resLine = ""
 6         
 7         for s in 0..<source.count {
 8             var blockEndCol = 0
 9             var ca = Array(source[s])
10             var i = 0
11             var lineComment = false
12             while i < ca.count-1 {
13                 if inBlock {
14                     if ca[i] == "*",ca[i+1] == "/" {
15                         blockEndCol = i+2
16                         i += 1
17                         inBlock = false
18                     }
19                 } else {
20                     if ca[i] == "/" {
21                         // line comment,remove the rest of the line
22                         if ca[i+1] == "/" {
23                             if i > blockEndCol {
24                                 resLine += String(ca[blockEndCol...i-1])
25                             }
26                             lineComment = true
27                             break
28                             // start of block comment
29                         } else if ca[i+1] == "*" {
30                             inBlock = true
31                             if i > blockEndCol {
32                                 resLine += String(ca[blockEndCol...i-1])
33                             }
34                             i += 1
35                         }
36                     } else {
37                     }
38                 }
39                         i += 1
40             }
41             // if we aren‘t in a block,add the rest of the line
42             if !inBlock && !lineComment {
43                 if ca.count > blockEndCol {
44                     resLine += String(ca[blockEndCol...ca.count-1])
45                 }
46             }
47             if !inBlock && resLine.count > 0 {
48                 res.append(resLine)
49                 resLine = ""
50             }
51         }
52         return res
53     }
54 }

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!