Skip to content

Commit cf0d1b5

Browse files
kelvinlauKLkelvinlauKL
committed
Modified Z-Algorithm to conform to our style guide.
1 parent c7829e1 commit cf0d1b5

File tree

3 files changed

+161
-161
lines changed

3 files changed

+161
-161
lines changed

‎Z-Algorithm/ZAlgorithm.swift

Lines changed: 58 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -1,66 +1,66 @@
11
/* Z-Algorithm for pattern/string pre-processing
2-
3-
The code is based on the book:
4-
"Algorithms on String, Trees and Sequences: Computer Science and Computational Biology"
5-
by Dan Gusfield
6-
Cambridge University Press, 1997
7-
*/
2+
3+
The code is based on the book:
4+
"Algorithms on String, Trees and Sequences: Computer Science and Computational Biology"
5+
by Dan Gusfield
6+
Cambridge University Press, 1997
7+
*/
88

99
import Foundation
1010

1111
func ZetaAlgorithm(ptrn: String) -> [Int]? {
12-
13-
let pattern = Array(ptrn.characters)
14-
let patternLength: Int = pattern.count
15-
16-
guard patternLength > 0 else {
17-
return nil
18-
}
19-
20-
var zeta: [Int] = [Int](repeating: 0, count: patternLength)
21-
22-
var left: Int = 0
23-
var right: Int = 0
24-
var k_1: Int = 0
25-
var betaLength: Int = 0
26-
var textIndex: Int = 0
27-
var patternIndex: Int = 0
28-
29-
for k in 1 ..< patternLength {
30-
if k > right {
31-
patternIndex = 0
32-
33-
while k + patternIndex < patternLength &&
34-
pattern[k + patternIndex] == pattern[patternIndex] {
35-
patternIndex = patternIndex + 1
36-
}
37-
38-
zeta[k] = patternIndex
39-
40-
if zeta[k] > 0 {
41-
left = k
42-
right = k + zeta[k] - 1
43-
}
44-
} else {
45-
k_1 = k - left + 1
46-
betaLength = right - k + 1
47-
48-
if zeta[k_1 - 1] < betaLength {
49-
zeta[k] = zeta[k_1 - 1]
50-
} else if zeta[k_1 - 1] >= betaLength {
51-
textIndex = betaLength
52-
patternIndex = right + 1
53-
54-
while patternIndex < patternLength && pattern[textIndex] == pattern[patternIndex] {
55-
textIndex = textIndex + 1
56-
patternIndex = patternIndex + 1
57-
}
58-
59-
zeta[k] = patternIndex - k
60-
left = k
61-
right = patternIndex - 1
62-
}
12+
13+
let pattern = Array(ptrn.characters)
14+
let patternLength = pattern.count
15+
16+
guard patternLength > 0 else {
17+
return nil
18+
}
19+
20+
var zeta = [Int](repeating: 0, count: patternLength)
21+
22+
var left = 0
23+
var right = 0
24+
var k_1 = 0
25+
var betaLength = 0
26+
var textIndex = 0
27+
var patternIndex = 0
28+
29+
for k in 1 ..< patternLength {
30+
if k > right {
31+
patternIndex = 0
32+
33+
while k + patternIndex < patternLength &&
34+
pattern[k + patternIndex] == pattern[patternIndex] {
35+
patternIndex = patternIndex + 1
36+
}
37+
38+
zeta[k] = patternIndex
39+
40+
if zeta[k] > 0 {
41+
left = k
42+
right = k + zeta[k] - 1
43+
}
44+
} else {
45+
k_1 = k - left + 1
46+
betaLength = right - k + 1
47+
48+
if zeta[k_1 - 1] < betaLength {
49+
zeta[k] = zeta[k_1 - 1]
50+
} else if zeta[k_1 - 1] >= betaLength {
51+
textIndex = betaLength
52+
patternIndex = right + 1
53+
54+
while patternIndex < patternLength && pattern[textIndex] == pattern[patternIndex] {
55+
textIndex = textIndex + 1
56+
patternIndex = patternIndex + 1
6357
}
58+
59+
zeta[k] = patternIndex - k
60+
left = k
61+
right = patternIndex - 1
62+
}
6463
}
65-
return zeta
64+
}
65+
return zeta
6666
}

‎Z-Algorithm/ZetaAlgorithm.playground/Contents.swift

Lines changed: 75 additions & 75 deletions
Original file line numberDiff line numberDiff line change
@@ -2,88 +2,88 @@
22

33

44
func ZetaAlgorithm(ptrn: String) -> [Int]? {
5-
6-
let pattern = Array(ptrn.characters)
7-
let patternLength: Int = pattern.count
8-
9-
guard patternLength > 0 else {
10-
return nil
11-
}
12-
13-
var zeta: [Int] = [Int](repeating: 0, count: patternLength)
14-
15-
var left: Int = 0
16-
var right: Int = 0
17-
var k_1: Int = 0
18-
var betaLength: Int = 0
19-
var textIndex: Int = 0
20-
var patternIndex: Int = 0
21-
22-
for k in 1 ..< patternLength {
23-
if k > right {
24-
patternIndex = 0
25-
26-
while k + patternIndex < patternLength &&
27-
pattern[k + patternIndex] == pattern[patternIndex] {
28-
patternIndex = patternIndex + 1
29-
}
30-
31-
zeta[k] = patternIndex
32-
33-
if zeta[k] > 0 {
34-
left = k
35-
right = k + zeta[k] - 1
36-
}
37-
} else {
38-
k_1 = k - left + 1
39-
betaLength = right - k + 1
40-
41-
if zeta[k_1 - 1] < betaLength {
42-
zeta[k] = zeta[k_1 - 1]
43-
} else if zeta[k_1 - 1] >= betaLength {
44-
textIndex = betaLength
45-
patternIndex = right + 1
46-
47-
while patternIndex < patternLength && pattern[textIndex] == pattern[patternIndex] {
48-
textIndex = textIndex + 1
49-
patternIndex = patternIndex + 1
50-
}
51-
52-
zeta[k] = patternIndex - k
53-
left = k
54-
right = patternIndex - 1
55-
}
5+
6+
let pattern = Array(ptrn.characters)
7+
let patternLength = pattern.count
8+
9+
guard patternLength > 0 else {
10+
return nil
11+
}
12+
13+
var zeta = [Int](repeating: 0, count: patternLength)
14+
15+
var left = 0
16+
var right = 0
17+
var k_1 = 0
18+
var betaLength = 0
19+
var textIndex = 0
20+
var patternIndex = 0
21+
22+
for k in 1 ..< patternLength {
23+
if k > right {
24+
patternIndex = 0
25+
26+
while k + patternIndex < patternLength &&
27+
pattern[k + patternIndex] == pattern[patternIndex] {
28+
patternIndex = patternIndex + 1
29+
}
30+
31+
zeta[k] = patternIndex
32+
33+
if zeta[k] > 0 {
34+
left = k
35+
right = k + zeta[k] - 1
36+
}
37+
} else {
38+
k_1 = k - left + 1
39+
betaLength = right - k + 1
40+
41+
if zeta[k_1 - 1] < betaLength {
42+
zeta[k] = zeta[k_1 - 1]
43+
} else if zeta[k_1 - 1] >= betaLength {
44+
textIndex = betaLength
45+
patternIndex = right + 1
46+
47+
while patternIndex < patternLength && pattern[textIndex] == pattern[patternIndex] {
48+
textIndex = textIndex + 1
49+
patternIndex = patternIndex + 1
5650
}
51+
52+
zeta[k] = patternIndex - k
53+
left = k
54+
right = patternIndex - 1
55+
}
5756
}
58-
return zeta
57+
}
58+
return zeta
5959
}
6060

6161

6262
extension String {
63-
64-
func indexesOf(pattern: String) -> [Int]? {
65-
let patternLength: Int = pattern.characters.count
66-
let zeta = ZetaAlgorithm(ptrn: pattern + "💲" + self)
67-
68-
guard zeta != nil else {
69-
return nil
70-
}
71-
72-
var indexes: [Int] = [Int]()
73-
74-
/* Scan the zeta array to find matched patterns */
75-
for i in 0 ..< zeta!.count {
76-
if zeta![i] == patternLength {
77-
indexes.append(i - patternLength - 1)
78-
}
79-
}
80-
81-
guard !indexes.isEmpty else {
82-
return nil
83-
}
84-
85-
return indexes
63+
64+
func indexesOf(pattern: String) -> [Int]? {
65+
let patternLength = pattern.characters.count
66+
let zeta = ZetaAlgorithm(ptrn: pattern + "💲" + self)
67+
68+
guard zeta != nil else {
69+
return nil
70+
}
71+
72+
var indexes: [Int] = []
73+
74+
/* Scan the zeta array to find matched patterns */
75+
for i in 0 ..< zeta!.count {
76+
if zeta![i] == patternLength {
77+
indexes.append(i - patternLength - 1)
78+
}
79+
}
80+
81+
guard !indexes.isEmpty else {
82+
return nil
8683
}
84+
85+
return indexes
86+
}
8787
}
8888

8989
/* Examples */

‎Z-Algorithm/ZetaAlgorithm.swift

Lines changed: 28 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -1,36 +1,36 @@
11
/* Z-Algorithm based algorithm for pattern/string matching
2-
3-
The code is based on the book:
4-
"Algorithms on String, Trees and Sequences: Computer Science and Computational Biology"
5-
by Dan Gusfield
6-
Cambridge University Press, 1997
7-
*/
2+
3+
The code is based on the book:
4+
"Algorithms on String, Trees and Sequences: Computer Science and Computational Biology"
5+
by Dan Gusfield
6+
Cambridge University Press, 1997
7+
*/
88

99
import Foundation
1010

1111
extension String {
12+
13+
func indexesOf(pattern: String) -> [Int]? {
14+
let patternLength = pattern.characters.count
15+
let zeta = ZetaAlgorithm(ptrn: pattern + "💲" + self)
16+
17+
guard zeta != nil else {
18+
return nil
19+
}
20+
21+
var indexes: [Int] = [Int]()
1222

13-
func indexesOf(pattern: String) -> [Int]? {
14-
let patternLength: Int = pattern.characters.count
15-
let zeta = ZetaAlgorithm(ptrn: pattern + "💲" + self)
16-
17-
guard zeta != nil else {
18-
return nil
19-
}
20-
21-
var indexes: [Int] = [Int]()
22-
23-
/* Scan the zeta array to find matched patterns */
24-
for i in 0 ..< zeta!.count {
25-
if zeta![i] == patternLength {
26-
indexes.append(i - patternLength - 1)
27-
}
28-
}
29-
30-
guard !indexes.isEmpty else {
31-
return nil
32-
}
33-
34-
return indexes
23+
/* Scan the zeta array to find matched patterns */
24+
for i in 0 ..< zeta!.count {
25+
if zeta![i] == patternLength {
26+
indexes.append(i - patternLength - 1)
27+
}
3528
}
29+
30+
guard !indexes.isEmpty else {
31+
return nil
32+
}
33+
34+
return indexes
35+
}
3636
}

0 commit comments

Comments
 (0)