Pattern Matching 1 Pattern Matching Strings A

Pattern Matching 1 Pattern Matching

Strings A string is a sequence of characters Examples of strings: 2 ASCII Unicode {0, 1} {A, C, G, T} Let P be a string of size m Java program HTML document DNA sequence Digitized image An alphabet S is the set of possible characters for a family of strings Example of alphabets: A substring P[i. . j] of P is the subsequence of P consisting of the characters with ranks between i and j A prefix of P is a substring of the type P[0. . i] A suffix of P is a substring of the type P[i. . m - 1] Given strings T (text) and P (pattern), the pattern matching problem consists of finding a substring of T equal to P Applications: Text editors Search engines Biological research Pattern Matching

Brute-Force Algorithm 3 Algorithm Brute. Force. Match(T, P) The brute-force pattern Input text T of size n and pattern matching algorithm compares the P of size m pattern P with the text T for each possible shift of P relative Output starting index of a to T, until either substring of T equal to P or -1 a match is found, or if no such substring exists all placements of the pattern have for i 0 to n - m been tried { test shift i of the pattern } Brute-force pattern matching j 0 runs in time O(nm) while j < m T[i + j] = P[j] Example of worst case: j j+1 T = aaa … ah if j = m P = aaah may occur in images and DNA return i {match at i} sequences else unlikely in English text break while loop {mismatch} return -1 {no match anywhere} Pattern Matching

Boyer-Moore Heuristics The Boyer-Moore’s pattern matching algorithm is based on two heuristics Start at the end: Compare P with a subsequence of T moving backwards Character-jump heuristic: When a mismatch occurs at T[i] = c 4 If P contains c, shift P to align the last occurrence of c in P with T[i] Else, shift P to align P[0] with T[i + 1] Example Pattern Matching

Last-Occurrence Function Boyer-Moore’s algorithm preprocesses the pattern P and the alphabet S to build the last-occurrence function L mapping S to integers, where L(c) is defined as the largest index i such that P[i] = c or -1 if no such index exists Example: 5 P = abacab S = {a, b, c, d} c a b c d L(c) 4 5 3 -1 The last-occurrence function can be represented by an array indexed by the numeric codes of the characters The last-occurrence function can be computed in time O(m + s), where m is the size of P and s is the size of S Pattern Matching

The Boyer-Moore Algorithm Boyer. Moore. Match(T, P, S) L is last. Occurence. Function(P, S ) i m-1 j m-1 repeat if T[i] = P[j] if j = 0 return i { match at i } else i i-1 j j-1 else { character-jump } last L[T[i]] i i + m – min(j, last+ 1) j m-1 until i > n – 1 // beyond text length return -1 { no match } 6 Last is abbreviated “l” in figs Case 1: j 1 + l Case 2: 1 + l j Pattern Matching

Update function? i i + m – min(j, last +1) Why the min? If the last character is to the left of where you are looking, you will just shift so that the characters align. That amount is (m 1 ast+l). If the last character is to the right of where you are looking, that would require a NEGATIVE shift to align them. That is not good. In that case, the whole pattern just shifts 1. HOWEVER, the code to do that is NOT obvious. 7 Recall j starts out at m-1 and then decreases. i also starts out at the end of the pattern and decreases. Thus, if you add to i m-j, you are really moving the starting point to just one higher than the starting value for i for the current pass. Try it with some numbers to see. Pattern Matching

Example i=4 j=3 last(a) = 4 j

Analysis Boyer-Moore’s algorithm runs in time O(nm + | |) The | | comes from initialzing the last function. We expect | | to be less than nm, but if it weren’t we add it to be safe. Example of worst case: 9 T = aaa … a P = baaa The worst case may occur in images and DNA sequences but is unlikely in English text Boyer-Moore’s algorithm is significantly faster than the bruteforce algorithm on English text Pattern Matching

} The KMP Algorithm - Motivation Knuth-Morris-Pratt’s algorithm compares the pattern to the text in left-to-right, but shifts the pattern more intelligently than the brute-force algorithm. It takes advantage of the fact that we KNOW what we have already seen in matching the pattern. When a mismatch occurs, what is the most we can shift the pattern so as to avoid redundant comparisons? Answer: the largest prefix of P[0. . j] that is a suffix of P[1. . j] 10 At this point, the prefix of the pattern matches the suffix of the PARTIAL pattern. . a b a a b x. . a b a j a b a No need to repeat these comparisons Pattern Matching Resume comparing here by setting j to 2 .

KMP Failure Function Knuth-Morris-Pratt’s algorithm preprocesses the pattern to find matches of prefixes of the pattern with the pattern itself The failure function F(j) is defined as the size of the largest prefix of the pattern that is also a suffix of the partial pattern P[1. . j] Knuth-Morris-Pratt’s algorithm modifies the brute-force algorithm so that if a mismatch occurs at P[j] T[i] we set j F(j - 1), which resets where we are in the pattern. Notice we don’t reset i, but just continue from this point on. 11 j 0 1 2 3 4 5 P[j] a b a F(j) 0 0 1 1 2 3 Pattern Matching

The KMP Algorithm At each iteration of the while-loop, either i increases by one, or it doesn’t the shift amount i - j increases by at least one (observe that F(j - 1) < j) One worries that they may be stuck in the section where i doesn’t increase. Amortized Analysis: while sometimes we just shift the pattern without moving i, we can’t do that forever, as we have to have moved forward in i and j before we can just shift the pattern. Hence, there are no more than 2 n iterations of the while-loop Thus, KMP’s algorithm runs in optimal time O(n) plus the cost of computing the failure function. 12 Algorithm KMPMatch(T, P) F failure. Function(P) i 0 j 0 while i < n if T[i] = P[j] if j = m - 1 return i - j { match } else // keep going i i+1 j j+1 else if j > 0 j F[j - 1] else // at first position can’t // use the failure function i i+1 return -1 { no match } Pattern Matching

Computing the Failure Function The failure function can be represented by an array and can be computed in O(m) time The construction is similar to the KMP algorithm itself At each iteration of the while-loop, either i increases by one, or the shift amount i - j increases by at least one (observe that F(j - 1) < j) Hence, there are no more than 2 m iterations of the while-loop So the total complexity of KMP is O(m+n) 13 Algorithm failure. Function(P) F[0] 0 i 1 j 0 while i < m if P[i] = P[j] {we have matched j + 1 chars} F[i] j + 1 i i+1 j j+1 else if j > 0 then {use failure function to shift P} j F[j - 1] else F[i] 0 { no match } i i+1 Pattern Matching

Example Fail at 6, reset j to 1 (F of prev loc) Note, we start comparing from the left. Fail at 7, reset j to 0 (F of prev loc) Fail at 12, reset j to 0 (F of prev loc) j 0 1 2 3 4 5 P[j] a b a c a b F(j) 0 0 1 2 14 Fail at 13, reset j to 0 Pattern Matching

Binary Failure Function Your programming assignment (due 10/29) extends the idea of the KMP string matching. If the input is binary in nature (only two symbols are used - such as x/y or 0/1), when you fail to match an x, you know you are looking at a y. Normally, when you fail, you say – “How much of the PREVIOUS pattern matches? ” And then check the current location again. With binary input, you can say, “How much of the string including the real value of what I was trying to match can shift on top of each other? ” 15 Pattern Matching

Example Text String x y x x y y x x x Pattern x x y x y Compare 0 0 0 0 ^ Shift x x y x y Compare 0 0 ^ Shift x x y x y Compare 0 ^ Shift x x y x y Compare 16 x ^ Pattern Matching

Can you find the Binary Failure Function (given the regular failure function? ) for the TWO pattern strings below? i 0 1 2 3 4 5 6 7 8 9 10 11 i 0 1 2 3 4 5 6 7 8 9 17 P[i] x x y x y x y p[i] a a b a a a b Bfail F 0 1 2 3 4 0 1 0 Bfail F 0 1 2 3 4 5 2 3 Pattern Matching

Can you find the Binary Failure Function (given the regular failure function? ) i 0 1 2 3 4 5 6 7 8 9 10 11 i 0 1 2 3 4 5 6 7 8 9 18 P[i] x x y x y x y p[i] a a b a a a b Bfail 0 0 2 0 5 0 2 F 0 1 2 3 4 0 1 0 Bfail 0 0 2 0 0 6 2 F 0 1 2 3 4 5 2 3 Pattern Matching

Tries 19 Tries 3/19/2018 8: 18 PM

Preprocessing Strings Preprocessing the pattern speeds up pattern matching queries If the text is large, immutable and searched for often (e. g. , works by Shakespeare), we may want to preprocess the text instead of the pattern A trie (pronounced TRY) is a compact data structure for representing a set of strings, such as all the words in a text 20 After preprocessing the pattern, KMP’s algorithm performs pattern matching in time proportional to the text size A tries supports pattern matching queries in time proportional to the pattern size Tries 3/19/2018 8: 18 PM

Standard Trie The standard trie for a set of strings S is an ordered tree such that: Each node but the root is labeled with a character The children of a node are alphabetically ordered The paths from the external nodes to the root yield the strings of S Example: standard trie for the set of strings S = { bear, bell, bid, bull, buy, sell, stock, stop } 21 Tries 3/19/2018 8: 18 PM

Standard Trie (cont) A standard trie uses O(n) space and supports searches, insertions and deletions in time O(dm), where: n total size of the strings in S m size of the string parameter of the operation d size of the alphabet 22 Tries 3/19/2018 8: 18 PM

Word Matching with a Trie 23 We insert the words of the text into a trie Each leaf stores the occurrences of the associated word in the text Tries 3/19/2018 8: 18 PM

Compressed Trie 24 A compressed trie has internal nodes of degree at least two It is obtained from standard trie by compressing chains of “redundant” nodes Tries 3/19/2018 8: 18 PM

Compact Representation Compact representation of a compressed trie for an array of strings: Stores at the nodes ranges of indices instead of substrings in order to make nodes a fixed size Uses O(s) space, where s is the number of strings in the array Serves as an auxiliary index structure b e ar 25 id ll s hear u ll to e y e Tries ll ck 3/19/2018 8: 18 PM p

Suffix Trie The compressed tree doesn’t work if you don’t start at the beginning of the word. Suppose you were allowed to start ANYWHERE in the word. The suffix trie of a string X is the compressed trie of all the suffixes of X 26 Tries 3/19/2018 8: 18 PM

Suffix Trie (cont) – showing as numbers Compact representation of the suffix trie for a string X of size n from an alphabet of size d 27 Uses O(n) space Supports arbitrary pattern matching queries in X in O(dm) time, where m is the size of the pattern Tries 3/19/2018 8: 18 PM

Encoding Trie A code is a mapping of each character of an alphabet to a binary codeword A prefix code is a binary code such that no code-word is the prefix of another code-word An encoding trie represents a prefix code Each leaf stores a character The code word of a character is given by the path from the root to the leaf storing the character (0 for a left child and 1 for a right child 00 011 10 11 a 28 010 b c d e a d b Tries c 3/19/2018 8: 18 PM e

Encoding Trie (cont) Given a text string X, we want to find a prefix code for the characters of X that yields a small encoding for X Frequent characters should have short code-words Rare characters should have long code-words Example X = abracadabra T 1 encodes X into 29 bits T 2 encodes X into 24 bits T 1 T 2 c d a 29 r b a b c Tries d 3/19/2018 8: 18 PM r

Huffman’s Algorithm Given a string X, Huffman’s algorithm constructs a prefix code that minimizes the size of the encoding of the string. It runs in time O(n + d log d), where n is the size of the string and d is the number of distinct characters of the string A heap-based priority queue is used as an auxiliary structure 30 Algorithm Huffman. Encoding(X) Input string X of size n Output optimal encoding trie for X C distinct. Characters(X) compute. Frequencies(C, X) Q new empty heap for all c C T new single-node tree storing c Q. insert(get. Frequency(c), T) while Q. size() > 1 f 1 Q. min. Key() T 1 Q. remove. Min() f 2 Q. min. Key() T 2 Q. remove. Min() T join(T 1, T 2) Q. insert(f 1 + f 2, T) return Q. remove. Min() Tries 3/19/2018 8: 18 PM

Example 11 2 a b c d r 5 a 5 2 1 1 2 b 2 c 1 d 1 31 b 2 c c d 4 d r 2 r 2 b 6 a 5 Choice of which two Is not unique 2 a 5 6 a X = abracadabra Frequencies a 5 c 2 c 4 d b Tries r 3/19/2018 8: 18 PM b r

At Seats X = catinthehat Frequencies in English text i n b a c t h e 8 8 2 8 3 9 6 12 Create tree Use to decode 32 3/19/2018 8: 18 PM

Text Similarity Detect similarity to focus on, or ignore, slight differences a. DNA analysis b. Web crawlers omit duplicate pages, distinguish between similar ones c. Updated files, archiving, delta files, and editing distance 33 Pattern Matching

Longest Common Subsequence One measure of similarity is the length of the longest common subsequence between two texts. This is NOT a contiguous substring, so it loses a great deal of structure. I doubt that it is an effective metric for all types of similarity, unless the subsequence is a substantial part of the whole text. 34 Pattern Matching

LCS algorithm uses the dynamic programming approach Recall: the first step is to find the recursion. How do we write LCS in terms of other LCS problems? The parameters for the smaller problems being composed to solve a larger problem are the lengths of a prefix of X and a prefix of Y. 35 Pattern Matching

Find recursion: Let L(i, j) be the length of the LCS between two strings X(0. . i) and Y(0. . j). Suppose we know L(i, j), L(i+1, j) and L(i, j+1) and want to know L(i+1, j+1). a. If X[i+1] = Y[j+1] then the best we can do is to get a LCS of L(i, j) + 1. b. If X[i+1] != Y[j+1] then it is max(L[i, j+1], L(i+1, j)) 36 Pattern Matching

Longest Common Subsequence One measure of similarity is the length of the longest common subsequence between two texts. * a b c d g h t h m s * 0 0 0 a 0 1 1 1 1 1 e 0 1 1 1 1 1 d 0 1 1 1 2 2 2 2 f 0 1 1 1 2 2 2 2 h 0 1 1 1 2 2 3 3 3 h 0 1 1 1 2 2 3 3 4 4 4 37 Pattern Matching

This algorithm initializes the array or table for L by putting 0’s along the borders, then is a simple nested loop filling up values row by row. This it runs in O(nm) While the algorithm only tells the length of the LCS, the actual string can easily be found by working backward through the table (and strings), noting points at which the two characters are equal 38 Pattern Matching

Longest Common Subsequence Mark with info to generate string Every diagonal shows what is part of LCS * a b c d g h t h m s * 0 0 0 a 0 1 1 1 1 1 e 0 1 1 1 1 1 d 0 1 1 1 2 2 2 2 f 0 1 1 1 2 2 2 2 h 0 1 1 1 2 2 3 3 3 h 0 1 1 1 2 2 3 3 4 4 4 39 Pattern Matching

Try this one… * i d o n o t l i k e * 0 0 0 n 0 o 0 t 0 i 0 c 0 e 0 40 Pattern Matching

The rest of the material in these notes is not in your text (except as exercises) Sequence Comparisons 41 Problems in molecular biology involve finding the minimum number of edit steps which are required to change one string into another. Three types of edit steps: insert, delete, replace. (replace may cost extra as it is like delete and insert) The non-edit step is “match” – costing zero. Example: abbc babb abbc babc babb (3 steps) abbc babb (2 steps) We are trying to minimize the number of steps. Pattern Matching

Idea: look at making just one position right. Find all the ways you could use. Count how long each would take (using recursion) and figure best cost. Then use dynamic programming. Orderly way of limiting the exponential number of combinations to think about. For ease in coding, we make the last character correct (rather than any other). 42 Pattern Matching

First steps to dynamic programming Think of the problem recursively. Find your prototype – what comes in and what comes out. Int C(n, m) returns the cost of turning the first n characters of the source string (A) into the first m characters of the destination string (B). Now, find the recursion. You have a helper who will do ANY smaller sub-problem of the same variety. What will you have them do? Be lazy. Let the helper do MOST of the work. 43 Pattern Matching

Types of edit steps: insert, delete, replace, match. Consider match to be “free” but the others to cost 1. There are four possibilities (pick the cheapest) 1. If we delete an, we need to change A(0. . n-1) to B(0. . m). The cost is C(n, m) = C(n-1, m) + 1 C(n, m) is the cost of changing the first n of str 1 to the first m of str 2. 2. If we insert a new value at the end of A(n) to match bm, we would still have to change A(n) to B(m-1). The cost is C(n, m) = C(n, m-1) + 1 3. If we replace an with bm, we still have to change A(n-1) to B(m-1). The cost is C(n, m) = C(n-1, m-1) + 1 4. If we match an with bm, we still have to change A(n-1) to B(m-1). The cost is C(n, m) = C(n-1, m-1) 44 Pattern Matching

45 We have turned one problem into three problems - just slightly smaller. Bad situation - unless we can reuse results. Dynamic Programming. We store the results of C(i, j) for i = 1, n and j = 1, m. If we need to reconstruct how we would achieve the change, we store both the cost and an indication of which set of subproblems was used. Pattern Matching

M(i, j) which indicates which of the four decisions lead to the best result. 46 Complexity: O(mn) - but needs O(mn) space as well. Consider changing do to redo: Consider changing mane to mean: Pattern Matching

At your seats try Changing “mane” to “mean” * * m e a 0 m a n e 47 Pattern Matching n

Changing “mane” to “mean” * e a n * 0 I-1 I-2 I-3 I-4 m D-1 M-0 I-1 I-2 I-3 a D-2 D-1 R-1 M-1 I-2 n D-3 D-2 R-2 D-2 M-1 e 48 m D-4 D-3 M-2 D-3 D-2 Pattern Matching

Changing “do” to “redo” Assume: match is free; others are 1. I show the choices as I- or R-, etc, but could have shown with an arrow as well * r e d o * I-0 I-1 I-2 I-3 I-4 d D-1 R-2 M-2 I-3 o D-2 R-2 R-3 M-2 49 Pattern Matching

Another problem: Longest Increasing Subsequence of single list Find the longest increasing subsequence in a sequence of distinct integers. Example: 5 1 10 2 20 30 40 4 5 6 7 8 9 10 11 Why do we care? Classic problem: 1. computational biology: related to MUMmer system for aligning genomes. 2. Card games 3. Airline boarding problem 4. Maximization problem in a random environment. How do we solve? 50 Pattern Matching

Longest Increasing Subsequence of single list Find the longest increasing subsequence in a sequence of distinct integers. Idea 1. Given a sequence of size less than m, can find the longest sequence of it. (Recursion) What is problem? Can we use a subproblem to solve the larger problem? Will the solution to the smaller problem be a part of the solution for the larger problem? Case 1: It either can be added to the longest subsequence or not Case 2: It is possible that it can be added to a non-selected subsequence (creating a sequence of equal length - but having a smaller ending point) Case 3: It can be added to a non-selected sub-sequence creating a sequence of smaller length but successors make it a good choice. Example: 5 1 10 2 20 30 40 4 5 6 7 8 9 10 11 Smallest increasing subsequence of underlined part is not part of complete solution 51 Pattern Matching

Idea 2. Given a sequence of size string < m, we know how to find the longest increasing subsequence for EVERY smaller problem. 52 We don’t know which problem we want to add to. What is the complexity? For each n, we call n-1 subproblems which are 1 smaller. Looks exponential. We would need to store results of subproblems some way. Pattern Matching

Idea: if you have two subsequences of length x, the one with the smaller end value is preferable. BIS: an array of the best (least value) ending point for a subsequence of each length. For s= 1 to n (or recursively the other way) For k = s downto 1 until find correct spot If BIS(k) > As and BIS(k-1) < As BIS(k) = As 53 Pattern Matching

Actually, we don't need the sequential search as can do a binary search. 5 1 10 2 12 8 15 18 45 6 7 3 8 9 Length BIS 1 5 1 2 10 2 3 12 8 6 3 4 15 7 5 18 8 6 54 45 9 To output the sequence would be difficult as you don't know where the sequence is. You would have to reconstruct. You only the length of the longest increasing subsequence. Pattern Matching

Try: 8 1 4 2 9 10 3 5 14 11 12 7 Length End Pos 1 8 1 st 2 nd Replaceme nt nt 1 2 4 2 3 9 3 4 10 5 5 14 11 55 6 12 Pattern Matching 7

Probabilistic Algorithms 56 Suppose we have a collection of items and wanted to find a number that is greater than the median (the number for which half are bigger). How would you solve it? Pattern Matching

Probabilistic Algorithms 57 Suppose we have a collection of items and wanted to find a number that is greater than the median (the number for which half are bigger). We could sort them - O(n log n) and then select one in last half. We could find the biggest - but stop looking half way through. O(n/2) Cannot guarantee one in the upper half in less than n/2 comparisons. What if you just wanted good odds? Pick two numbers, pick the larger one. What is probability it is in the lower half? Pattern Matching

Pick two numbers There are four possibilities: both are lower than median the first is lower the other higher. the first is higher the other lower both are higher. If we pick the larger of the two numbers… We will be right 75% of the time! We only lose if both are in the lowest half. 58 Pattern Matching

Select k elements and pick the biggest, the k. probability of being correct is 1 - 1/2 Good odds controlled odds. Termed a Monte Carlo algorithm. It may give the wrong result with very small probability. The method is called after the city in the Monaco principality, because of a roulette, a simple random number generator. The name and the systematic development of Monte Carlo methods dates from about 1944. Another type of probabilistic algorithm is one that never gives a wrong result, but its running time is not guaranteed. Termed Las Vegas algorithm as you are guaranteed success if you try long enough and don’t care how much you spend. 59 Pattern Matching

A coloring Problem: Las Vegas Style Let S be a set with n elements. (n only effects complexity not algorithm) Let S 1, S 2. . . Sk be a collection of distinct (in some way different) subsets of S, each containing exactly r elements such that k 2 r-2. (We will use this fact to bound the time) GOAL: Color each element of S with one of two colors (red or blue) such that each subset Si contains at least one red and one blue element. 60 Pattern Matching

Idea 61 Try coloring them randomly and then just checking to see if you happen to win. Checking is fast, as you can quit checking each subset when you see one of each. You can quit checking the collection (and announce failure) when any single color subset is found. What is the probability that all items in a set of r elements are red? 1/2 r as equal probability that each of the two colors is assigned and r items in the set. Pattern Matching

What is the probability that any one of the collections is all red? 62 k/2 r = 1/2 r +… + 1/2 r Since we are looking for the or of a set of probabilities, we add. k is bound by 2 r-2 so k*1/2 r <= 1/4 The probability of all blue or all red in a single set is one half. (double probability of all red) If our random coloring fails, we simply try again until success. Our expected number of attempts is 2. Pattern Matching

Finding a Majority 63 Let E be a sequence of integers x 1, x 2, x 3, . . . xn The multiplicity of x in E is the number of times x appears in E. A number z is a majority in E if its multiplicity is greater than n/2. Problem: given a sequence of numbers, find the majority in the sequence or determine that none exists. NOTE: we don’t want to merely find who has the most votes, but determine who has more than half of the votes. Pattern Matching

64 For example, suppose there is an election. Candidates are represented as integers. Votes are represented as a list of candidate numbers. We are assuming no limit of the number of possible candidates. Pattern Matching

Ideas 1. sort the list O(n log n) 2. Go through the list, incrementing the count of each candidate. If I had to look up the candidate, I would need to store them somewhere. If have a balanced tree of candidate names, complexity would be n log c (where c is number of candidates) Note, if we don’t know how many candidates, we can’t give them indices. 3. Quick select. See if median (kth largest item) occurs more than n/2 times. O(n) (Find the median, and then make a pass through seeing how many times it occurs. ) 4. Take a small sample. Find the majority - then count how many times it occurs in the whole list. 5. Make one pass - Discard elements that won’t affect majority. 65 Pattern Matching

Our algorithm will find a possible majority. 66 Algorithm: find two unequal elements. Delete them. Find the majority in the smaller list. Then see if it is a majority in the original list. How do we remove elements? It is easy. We scan the list in order. We are looking for a pair to eliminate. Let i be the current position. All the items before xi which have not been eliminated have the same value. All you really need to keep is the number of times this candidate, C value occurs (which has not been deleted). Pattern Matching

Note: If there is a majority and if xi xj and we remove both of them, then the majority in the old list is the majority in the new list. Reasoning: if xi is the majority, it had to be more than half, so throwing out a subset where it is EXACTLY half, won’t affect the majority. If xi is not a majority, throwing it out won’t matter. If xi is a majority, there are m xi’s out of n, where m > n/2. Notice if we subtract one from both sides, we get m-1 > n/2 -1 = (n-2)/2 If we remove two elements, (m-1 > (n-2)/2). The converse is not true. If there is no majority, removing two may make something a majority in the smaller list: 1, 2, 4, 5, 5. 67 Pattern Matching

For example: List: 1 4 6 3 4 4 4 2 9 0 2 4 1 4 2 2 3 2 4 2 Occurs: X X 1 2 3 2 1 X 1 X 1 2 1 2 Candidate: 1 6 4 4 4 ? 2 ? 1 ? 2 2 2 2 is a candidate, but is not a majority in the whole list. Complexity: n-1 compares to find a candidate. n-1 compares to test if it is a majority. So why do this over other ways? Simple to code. No different in terms of complexity, but interesting to think about. 68 Pattern Matching