Enrol to start learning
Reading is open to everyone. Enrolling is free, and it is what unlocks the audio lessons, practice tests and progress tracking.
16.2.1. Counting Bad Strings
Learn content
Interactive Audio Lesson
Unlock the classroom podcast
The transcript is free to read. A free account plays the conversation back.
Today, we are talking about 'bad strings' in binary sequences, specifically those containing '000'. Can anyone tell me what a bad string would be?
I think a bad string would be like '0001' or '10000'.
Exactly! Those strings are invalid because they contain the substring '000'. Now, how can we count these bad strings?
Could we count all the binary strings and subtract the good ones?
Yes! We will use that strategy. First, we need to identify good strings, which do not contain '000'.
How do you even start counting the good strings then?
Great question! We'll categorize them based on their initial characters. If a string starts with '1', what can we say about the remainder?
The remainder must also be a good string!
Precisely! This starts forming a recurrence relation for good strings.
To summarize, we begin with the definition of bad strings as those containing '000' and outline our plan to count the valid (good) strings first.
Unlock the classroom podcast
The transcript is free to read. A free account plays the conversation back.
Now, let's talk about the three disjoint cases for good strings. If we have a string of length n, and it starts with '1', that leaves us with g(n-1) valid strings, correct?
Right, because the first character is fixed to '1'.
Now, what if it starts with '01'?
Then we have g(n-2) because we're left with the next character and need to ensure no '000' substrings.
Great! Finally, if it starts with '00', what do we end up with?
The next character can only be '1'. So we have to count the good strings of length n-3, right? It's g(n-3).
Exactly! If we sum these, we can express our relationship as g(n) = g(n-1) + g(n-2) + g(n-3).
Recap: We've derived our function for good strings based on three cases by examining their leading characters.
Unlock the classroom podcast
The transcript is free to read. A free account plays the conversation back.
Before we calculate our bad strings, we need to know some initial conditions. What do you think are the counts for g(0), g(1), and g(2)?
For g(0), there's one string, which is the empty string.
Correct! And g(1) includes '0' and '1'. How many are they?
That would make 2 for g(1).
Good. And what about g(2)? Which strings do we consider?
'00', '01', '10', '11.' Still no bad strings!
Excellent! So g(2) equals 4, making our initial conditions: g(0)=1, g(1)=2, g(2)=4.
To recap, we've derived our recurrence and established initial conditions—all vital to determine the number of bad strings next!
Unlock the classroom podcast
The transcript is free to read. A free account plays the conversation back.
Now, let’s compute our bad strings! What’s the relation established for bad strings?
Isn't it that f(n) = 2^n - g(n)?
Exactly! So we need to derive g(n) to find bad strings. Can you calculate for n=3?
Using our relation, g(3) = g(2) + g(1) + g(0) = 4 + 2 + 1, which equals 7.
Correct! And how many total strings do we have for n=3?
For n=3, that's 2^3 = 8.
Thus, f(3) = 8 - 7 = 1, meaning there’s only one bad string of length 3.
To summarize, we computed the bad strings as f(n) = 2^n - g(n) and used initial conditions to help evaluate specific cases.
Overview
Short Summary
This section discusses how to count sequences of binary strings while considering specific patterns ('bad' strings that contain substring '000').
Medium Summary
The section introduces the concept of bad strings in binary sequences, particularly focusing on counting strings of a given length that contain the substring '000'. It presents a recurrence relation as a method for establishing the number of invalid strings by breaking them down into manageable categories.
Detailed Summary
Detailed Summary
In this section, we focus on counting binary strings of length n that do not contain the substring '000'. Rather than directly counting the desired strings, we employ a more effective strategy: counting the complementary set — that is, the strings that do not contain '000' and then using the total number of possible strings to derive the count of bad strings.
We denote the number of bad strings of length n (strings containing '000') as 'f(n)'. We establish that the total number of n-length binary strings is given by '2^n'. The main task becomes to formulate a recurrence relation for 'g(n)', the number of good strings (those that do not contain '000').
More specifically, we categorize binary strings into three disjoint cases based on their prefix:
- Strings starting with '1' — the remainder of the string should not contain '000'. This gives us
g(n-1)strings. - Strings starting with '01' — the remaining string, of size
n-2, should also exclude '000', givingg(n-2)strings. - Strings starting with '00' — here, the next character cannot be '0'; thus it must be '1', meaning the remaining string can be any valid string of size
n-3, giving usg(n-3)valid configurations.
From these categories, we derive a recurrence relation:
g(n) = g(n-1) + g(n-2) + g(n-3)This relation shows that the current number of good strings is the sum of good strings from previous lengths. The first few values help establish initial conditions:
- g(0) = 1, g(1) = 2, g(2) = 4.
To find the original 'f(n)', we use the total binary strings minus valid strings: f(n) = 2^n - g(n).
Reference YouTube Videos
Audio Book
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountIn question 2 you have to find out the recurrence relation for the number of bit strings of length n that contain the substring '000'. It might have more than 1 occurrence of '000' as well. In fact, a string of length n consisting of all 0’s is a valid string.
Detailed Explanation
In this section, we are tasked with determining how many bit strings of a specific length (n) include the substring '000'. A string like '00000' would be considered valid because it contains multiple instances of '000'. This exploration helps us understand how to quantify and analyze strings that meet specific criteria, which is common in combinatorial problems.
Examples & Analogies
Imagine building a tower with blocks, where each type of block represents a distinct bit (0 or 1). The requirement is to ensure that somewhere in your tower, there exists a sequence of three consecutive blocks of type '0'. Just as you would check for the placement of blocks in your physical tower, we check arrangements of bits in strings.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountInstead of counting the number of strings containing '000', we will count the number of strings of length n not containing '000'. Here, the term bad string denotes strings that do not have an occurrence of '000'. So, I call or denote the sequence of all n length bit strings not containing '000' by this sequence and this is the n-th term of such sequence.
Detailed Explanation
To simplify the counting process, we switch our focus from the number of strings containing '000' to those that do not contain it, referred to as 'bad strings'. This approach allows for a clearer perspective in formulating a recurrence relation, as it's often easier to assess what is NOT present than to track multiple valid occurrences.
Examples & Analogies
Think of a game where you try to keep your room clean by avoiding clutter. Instead of counting the items (toys, clothes) you want to keep, you count the clutter you don't want. This is an easier task and can provide insight into how to maintain a tidy space.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountThere are 3 disjoint categories of bit strings of length n not containing '000'. Category 1 consists of those strings of length n that start with 1. If it starts with 1, then the remaining portion must not have any occurrence of '000'.
Detailed Explanation
We categorize bad strings into three groups to systematically approach counting. The first category includes those that start with '1'. The crucial point here is that after placing '1', the rest of the string must independently avoid forming '000', allowing us to apply previous findings to this smaller problem.
Examples & Analogies
Imagine sorting fruits. If you decide to place a specific fruit (like an apple) at the front, the rest of your basket (the remaining fruits) must still be arranged in a particular way (without letting any rotten fruits group together).
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountCategory 2 of bad strings are those that start with '01' and in that case, the remaining n-2 bit positions should not have any occurrence of '000'. Category 3 of bad strings where the first 2 positions are 0, and in that case, the third position cannot be 0.
Detailed Explanation
The second category allows strings beginning with '01', maintaining that the rest of the string avoids '000'. The third category has two starting 0s, followed by a required 1 to ensure the sequence remains 'bad'. Each category gives a clear structure to the overall counting process, ensuring we systematically consider all cases.
Examples & Analogies
Continuing with the fruit basket analogy, if the first two fruits are bananas, you can’t put another banana next, but must present a different fruit (like an orange) to avoid spoiling the pattern. This shows us how we can carefully curate our selections.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountThe number of bad strings of length n will be the sum of the number of bad strings of length n-1, n-2, and n-3, leading to our recurrence equation for the sequence.
Detailed Explanation
By analyzing each category, we find the total number of non-'000' strings of length n is simply the sum of valid counts from previous lengths (n-1, n-2, and n-3). This method unveils a recurrence relation that will help calculate the number of bad strings more efficiently by using previous results.
Examples & Analogies
Consider the incremental building of a wall with different blocks. Each layer (n) can only be built by correctly stacking the previous layers (n-1, n-2, and n-3) without repeating certain patterns. The walls built in previous attempts serve as a model for your current project.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountSince this is an equation of degree 3, we need 3 initial conditions: s(1) = 2, s(2) = 4, and s(3) = 7.
Detailed Explanation
To use the recurrence effectively, we need initial conditions that anchor our calculations and serve as a base for future results. These conditions represent the number of bad strings for smaller lengths—providing a clear starting point for extending to greater lengths.
Examples & Analogies
Imagine starting a construction project. You first lay out the foundation (initial conditions) properly to ensure that subsequent floors (larger string lengths) can be built reliably using the pattern set by the base.
--
Key concepts
Core takeaways and short definitions to help you quickly recall the key ideas from this section.
- Bad Strings:
Defined as binary strings that contain the pattern '000'.
- Good Strings:
Binary strings that do not contain the '000' pattern.
- Recurrence Relation:
A way to count sequences based on previous terms.
- Initial Conditions:
Values needed to start calculating further terms.
Examples
Memory aids
Imagine a garden where the flowers never grow '000'. The good flowers only bloom when they are free from this pattern.
Flash Cards
Glossary
Bad String
A binary string that contains the substring '000'.
Good String
A binary string that does not contain the substring '000'.
Recurrence Relation
An equation that recursively defines a sequence based on previous terms.
Binary String
A sequence of digits comprising only 0s and 1s.
Initial Conditions
The starting values required to compute further terms in a recursive sequence.