分类导航
iOSAndroidSwiftHybridCocos2d-xFluttersilverlightCordova

[Swift]LeetCode844. 比较含退格的字符串 | Backspace String Compare

Swift   发布时间：2022-04-30  发布网站：大佬教程  code.js-code.com
大佬教程收集整理的这篇文章主要介绍了[Swift]LeetCode844. 比较含退格的字符串 | Backspace String Compare，大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。

Given two Strings S and T, return if they are equal when both are typed into empty text editors. # means a BACkspace character.

Example 1:

Input: S = "ab#c",T = "ad#c" Output: true Explanation: Both S and T become "ac".

Example 2:

Input: S = "ab##",T = "c#d#" Output: true Explanation: Both S and T become "".

Example 3:

Input: S = "a##c",T = "#a#c" Output: true Explanation: Both S and T become "c".

Example 4:

Input: S = "a#c",T = "b" Output: false Explanation: S becomes "c" while T becomes "b".

Note:

  1. 1 <= s.length <= 200
  2. 1 <= T.length <= 200
  3. S and T only contain lowercase letters and ‘#‘ characters.

Follow up:

  • Can you solve it in O(N) time and O(1) space?

给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。

示例 1：

输入：S = "ab#c",T = "ad#c"
输出：true
解释：S 和 T 都会变成 “ac”。

示例 2：

输入：S = "ab##",T = "c#d#"
输出：true
解释：S 和 T 都会变成 “”。

示例 3：

输入：S = "a##c",T = "#a#c"
输出：true
解释：S 和 T 都会变成 “c”。

示例 4：

输入：S = "a#c",T = "b"
输出：false
解释：S 会变成 “c”，但 T 仍然是 “b”。

提示：

  1. 1 <= s.length <= 200
  2. 1 <= T.length <= 200
  3. S 和 T 只含有小写字母以及字符 ‘#‘。
Runtime: 8 ms
Memory Usage: 19.5 MB 
 1 class Solution {
 2     func BACkspaceCompare(_ S: String,_ T: String) -> Bool 
 3     {
 4         var arrS = [Character]()
 5         var arrT = [Character]()
 6         for char in S
 7         {
 8             if char == "#"
 9             {
10                 if arrs.count > @H_160_197@0
11                 {
12                     arrs.removeLast()
13                 }
14             }
15             else
16             {
17                 arrs.append(char)
18             }
19         }
20         
21         for char in T
22         {
23             if char == "#"
24             {
25                 if arrT.count > @H_160_197@0
26                 {
27                     arrT.removeLast()
28                 }
29             }
30             else
31             {
32                 arrT.append(char)
33             }
34         }
35         return arrS == arrT
36     }    
37 }

8ms

 1 class Solution {
 2     // S2: two pointers space Could be 1
 3     // S1: M+N
 4     func BACkspaceCompare(_ S: String,_ T: String) -> Bool {
 5         return process(S) == process(T)    
 6     }
 7     
 8     private func process(_ S: String) -> String {
 9         var stack = [Character]()
10         for c in Array(S) {
11             if c == "#" {
12                 if stack.count > @H_160_197@0 {
13                     stack.removeLast()
14                 }
15             } else {
16                 stack.append(C)
17             }
18         }
19         return String(stack)
20     }
21 }

12ms

 1 class Solution {
 2     func BACkspaceCompare(_ S: String,_ T: String) -> Bool {
 3         var sStack: [Character] = []
 4         var tStack: [Character] = []
 5 
 6         var sArray = Array(S)
 7         var tArray = Array(T)
 8         
 9         for char in sArray {
10             if(char != "#") {
11                 sStack.append(char)
12             } else {
13                 if(!sStack.isEmpty) {
14                     sStack.removeLast()   
15                 }
16             }
17         }
18         
19         for char in tArray {
20             if(char != "#") {
21                 tStack.append(char)
22             } else {
23                 if(!tStack.isEmpty) {
24                     tStack.removeLast()   
25                 }
26             }
27         }
28         
29         print(String(sStack))
30         print(String(tStack))
31         
32         if(String(sStack) == String(tStack)) {
33             return true
34         } else {
35             return false
36         }
37     }
38 }

16ms

 1 class Solution {
 2     func BACkspaceCompare(_ S: String,_ T: String) -> Bool {
 3         var chaRSS = Array(S),charsT = Array(T)
 4         
 5         var i = chaRSS.count - @H_160_197@1,j = charsT.count - @H_160_197@1
 6         var countS = @H_160_197@0,countT = @H_160_197@0
 7         while i >= @H_160_197@0 || j >= @H_160_197@0 {
 8             while i >= @H_160_197@0 && (countS > @H_160_197@0 || chaRSS[i] == "#") { 
 9                 if chaRSS[i] == "#" { 
10                     countS += @H_160_197@1
11                 } else {
12                     countS -= @H_160_197@1
13                 }
14                 
15                 i -= @H_160_197@1
16             }
17             
18             while j >= @H_160_197@0 && (countT > @H_160_197@0 || charsT[j] == "#") { 
19                 if charsT[j] == "#" { 
20                     countT += @H_160_197@1
21                 } else {
22                     countT -= @H_160_197@1
23                 }
24                 
25                 j -= @H_160_197@1
26             }
27             
28             if i >= @H_160_197@0 && j >= @H_160_197@0 && chaRSS[i] == charsT[j] {
29                 i -= @H_160_197@1
30                 j -= @H_160_197@1 
31             } else {
32                 break
33             }
34         }
35         return i < @H_160_197@0 && j < @H_160_197@0
36     }
37 }

24ms

 1 class Solution {
 2     func BACkspaceCompare(_ S: String,_ T: String) -> Bool {
 3         return BACkspace(S) == BACkspace(T)
 4     }
 5     
 6     func BACkspace(_ String: String) -> String {
 7         var s = [Character]()
 8 
 9         String.forEach { c in
10             if c == "#" {
11                 if !s.isEmpty {
12                     s.removeLast()
13                 }
14             } else {
15                 s.append(C)
16             }
17         }
18         return String(s)
19     }
20 }

24ms

 1 class Solution {
 2     func BACkspaceCompare(_ S: String,_ T: String) -> Bool {
 3         let sRe = reStack(str: S)
 4         let tRe = reStack(str: T)
 5         return sRe == tRe;
 6     }
 7     
 8     public func reStack(str: String) -> String {
 9         var result = [Character]()
10         for i in str {
11             if (!result.isEmpty) {
12                 if i != "#" {
13                     result.append(i)
14                 } else {
15                     result.removeLast()
16                 }
17             } else {
18                 if i != "#" {
19                     result.append(i)
20                 }
21             }
22         }
23         return String.init(result);
24     }
25 }
@H_502_1119@

大佬总结

以上是大佬教程为你收集整理的[Swift]LeetCode844. 比较含退格的字符串 | Backspace String Compare全部内容，希望文章能够帮你解决[Swift]LeetCode844. 比较含退格的字符串 | Backspace String Compare所遇到的程序开发问题。

如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。
标签：844backspacecompareleetcodeleetcode844stringswift含字符串比较退格
猜你在找的Swift相关文章
其他相关热搜词更多
phpJavaPython程序员load中如何string使用参数jquery开发安装listlinuxiosandroid工具javascriptcap