Skip to content

Commit a6c3e9f

Browse files
shabirjanshabirjan
committed
Fix indentation to 2 spaces
1 parent be78323 commit a6c3e9f

File tree

2 files changed

+154
-154
lines changed

2 files changed

+154
-154
lines changed

‎Knuth-Morris-Pratt/KnuthMorrisPratt.playground/Contents.swift

Lines changed: 96 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -6,115 +6,115 @@ print("Hello, Swift4!")
66
#endif
77

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

68+
let text = Array(self.characters)
1069
let pattern = Array(ptnr.characters)
70+
71+
let textLength: Int = text.count
1172
let patternLength: Int = pattern.count
1273

1374
guard patternLength > 0 else {
14-
return nil
75+
return nil
1576
}
1677

17-
var zeta: [Int] = [Int](repeating: 0, count: patternLength)
18-
19-
var left: Int = 0
20-
var right: Int = 0
21-
var k_1: Int = 0
22-
var betaLength: Int = 0
78+
var suffixPrefix: [Int] = [Int](repeating: 0, count: patternLength)
2379
var textIndex: Int = 0
2480
var patternIndex: Int = 0
81+
var indexes: [Int] = [Int]()
2582

26-
for k in 1 ..< patternLength {
27-
if k > right {
28-
patternIndex = 0
29-
30-
while k + patternIndex < patternLength &&
31-
pattern[k + patternIndex] == pattern[patternIndex] {
32-
patternIndex = patternIndex + 1
33-
}
34-
35-
zeta[k] = patternIndex
36-
37-
if zeta[k] > 0 {
38-
left = k
39-
right = k + zeta[k] - 1
40-
}
41-
} else {
42-
k_1 = k - left + 1
43-
betaLength = right - k + 1
44-
45-
if zeta[k_1 - 1] < betaLength {
46-
zeta[k] = zeta[k_1 - 1]
47-
} else if zeta[k_1 - 1] >= betaLength {
48-
textIndex = betaLength
49-
patternIndex = right + 1
50-
51-
while patternIndex < patternLength && pattern[textIndex] == pattern[patternIndex] {
52-
textIndex = textIndex + 1
53-
patternIndex = patternIndex + 1
54-
}
55-
zeta[k] = patternIndex - k
56-
left = k
57-
right = patternIndex - 1
58-
}
59-
}
83+
/* Pre-processing stage: computing the table for the shifts (through Z-Algorithm) */
84+
let zeta = ZetaAlgorithm(ptnr: ptnr)
85+
86+
for patternIndex in (1 ..< patternLength).reversed() {
87+
textIndex = patternIndex + zeta![patternIndex] - 1
88+
suffixPrefix[textIndex] = zeta![patternIndex]
6089
}
61-
return zeta
62-
}
63-
64-
extension String {
6590

66-
func indexesOf(ptnr: String) -> [Int]? {
67-
68-
let text = Array(self.characters)
69-
let pattern = Array(ptnr.characters)
70-
71-
let textLength: Int = text.count
72-
let patternLength: Int = pattern.count
73-
74-
guard patternLength > 0 else {
75-
return nil
76-
}
77-
78-
var suffixPrefix: [Int] = [Int](repeating: 0, count: patternLength)
79-
var textIndex: Int = 0
80-
var patternIndex: Int = 0
81-
var indexes: [Int] = [Int]()
82-
83-
/* Pre-processing stage: computing the table for the shifts (through Z-Algorithm) */
84-
let zeta = ZetaAlgorithm(ptnr: ptnr)
85-
86-
for patternIndex in (1 ..< patternLength).reversed() {
87-
textIndex = patternIndex + zeta![patternIndex] - 1
88-
suffixPrefix[textIndex] = zeta![patternIndex]
89-
}
90-
91-
/* Search stage: scanning the text for pattern matching */
92-
textIndex = 0
93-
patternIndex = 0
94-
95-
while textIndex + (patternLength - patternIndex - 1) < textLength {
96-
97-
while patternIndex < patternLength && text[textIndex] == pattern[patternIndex] {
98-
textIndex = textIndex + 1
99-
patternIndex = patternIndex + 1
100-
}
101-
102-
if patternIndex == patternLength {
103-
indexes.append(textIndex - patternIndex)
104-
}
105-
106-
if patternIndex == 0 {
107-
textIndex = textIndex + 1
108-
} else {
109-
patternIndex = suffixPrefix[patternIndex - 1]
110-
}
111-
}
112-
113-
guard !indexes.isEmpty else {
114-
return nil
115-
}
116-
return indexes
91+
/* Search stage: scanning the text for pattern matching */
92+
textIndex = 0
93+
patternIndex = 0
94+
95+
while textIndex + (patternLength - patternIndex - 1) < textLength {
96+
97+
while patternIndex < patternLength && text[textIndex] == pattern[patternIndex] {
98+
textIndex = textIndex + 1
99+
patternIndex = patternIndex + 1
100+
}
101+
102+
if patternIndex == patternLength {
103+
indexes.append(textIndex - patternIndex)
104+
}
105+
106+
if patternIndex == 0 {
107+
textIndex = textIndex + 1
108+
} else {
109+
patternIndex = suffixPrefix[patternIndex - 1]
110+
}
111+
}
112+
113+
guard !indexes.isEmpty else {
114+
return nil
117115
}
116+
return indexes
117+
}
118118
}
119119

120120
/* Examples */

‎Knuth-Morris-Pratt/KnuthMorrisPratt.swift

Lines changed: 58 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -1,65 +1,65 @@
11
/* Knuth-Morris-Pratt 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(ptnr: String) -> [Int]? {
14-
15-
let text = Array(self.characters)
16-
let pattern = Array(ptnr.characters)
17-
18-
let textLength: Int = text.count
19-
let patternLength: Int = pattern.count
20-
21-
guard patternLength > 0 else {
22-
return nil
23-
}
24-
25-
var suffixPrefix: [Int] = [Int](repeating: 0, count: patternLength)
26-
var textIndex: Int = 0
27-
var patternIndex: Int = 0
28-
var indexes: [Int] = [Int]()
29-
30-
/* Pre-processing stage: computing the table for the shifts (through Z-Algorithm) */
31-
let zeta = ZetaAlgorithm(ptnr: ptnr)
32-
33-
for patternIndex in (1 ..< patternLength).reversed() {
34-
textIndex = patternIndex + zeta![patternIndex] - 1
35-
suffixPrefix[textIndex] = zeta![patternIndex]
36-
}
37-
38-
/* Search stage: scanning the text for pattern matching */
39-
textIndex = 0
40-
patternIndex = 0
41-
42-
while textIndex + (patternLength - patternIndex - 1) < textLength {
43-
44-
while patternIndex < patternLength && text[textIndex] == pattern[patternIndex] {
45-
textIndex = textIndex + 1
46-
patternIndex = patternIndex + 1
47-
}
48-
49-
if patternIndex == patternLength {
50-
indexes.append(textIndex - patternIndex)
51-
}
52-
53-
if patternIndex == 0 {
54-
textIndex = textIndex + 1
55-
} else {
56-
patternIndex = suffixPrefix[patternIndex - 1]
57-
}
58-
}
59-
60-
guard !indexes.isEmpty else {
61-
return nil
62-
}
63-
return indexes
12+
13+
func indexesOf(ptnr: String) -> [Int]? {
14+
15+
let text = Array(self.characters)
16+
let pattern = Array(ptnr.characters)
17+
18+
let textLength: Int = text.count
19+
let patternLength: Int = pattern.count
20+
21+
guard patternLength > 0 else {
22+
return nil
23+
}
24+
25+
var suffixPrefix: [Int] = [Int](repeating: 0, count: patternLength)
26+
var textIndex: Int = 0
27+
var patternIndex: Int = 0
28+
var indexes: [Int] = [Int]()
29+
30+
/* Pre-processing stage: computing the table for the shifts (through Z-Algorithm) */
31+
let zeta = ZetaAlgorithm(ptnr: ptnr)
32+
33+
for patternIndex in (1 ..< patternLength).reversed() {
34+
textIndex = patternIndex + zeta![patternIndex] - 1
35+
suffixPrefix[textIndex] = zeta![patternIndex]
36+
}
37+
38+
/* Search stage: scanning the text for pattern matching */
39+
textIndex = 0
40+
patternIndex = 0
41+
42+
while textIndex + (patternLength - patternIndex - 1) < textLength {
43+
44+
while patternIndex < patternLength && text[textIndex] == pattern[patternIndex] {
45+
textIndex = textIndex + 1
46+
patternIndex = patternIndex + 1
47+
}
48+
49+
if patternIndex == patternLength {
50+
indexes.append(textIndex - patternIndex)
51+
}
52+
53+
if patternIndex == 0 {
54+
textIndex = textIndex + 1
55+
} else {
56+
patternIndex = suffixPrefix[patternIndex - 1]
57+
}
58+
}
59+
60+
guard !indexes.isEmpty else {
61+
return nil
6462
}
63+
return indexes
64+
}
6565
}

0 commit comments

Comments
 (0)