How Binary Search Works: A Simple Guide
Edited By
Emily Carter
Preface
Binary search isn’t just another tool in your coding toolbox—it's a straightforward yet powerful way to quickly find an item in a sorted list. Imagine you’re skimming through a phonebook looking for a name. Instead of flipping through every page, you’d probably jump near the middle, figure out if the name you're after is before or after, then cut your search area in half each time. That’s exactly what binary search does, but with data.
Understanding this algorithm is especially useful for anyone working with large datasets, like financial analysts or traders who deal with voluminous stock price histories or real-time market feeds. Knowing how to efficiently search through sorted data speeds up your computations and sharpens your ability to get quick insights.
This guide will break down how the binary search algorithm works, show you step-by-step how to implement it, and explore its strengths and limitations. We’ll also compare it with other search methods you might know, pointing out situations where it shines or struggles.
Mastering binary search is a foundation for smarter, faster data handling and sets a base for more complex algorithms.
Whether you’re coding an investment tool or teaching students about efficient searching techniques, this article will give you the practical know-how to apply binary search where it counts.
What Binary Search Is and Why It Matters
Binary search is a methodical technique used to quickly locate a specific value within a sorted collection of data. Imagine you’re flipping through a thick notebook looking for a phone number; instead of checking each name line by line, you open the book roughly at the middle and decide which half to search next based on alphabetical order. This strategy, when applied to data, sharply reduces the search time compared to a simple linear approach.
For investors and traders, this kind of efficiency matters a lot. Speedy data retrieval can mean the difference between catching a market trend early or missing it by seconds. Financial analysts sifting through vast datasets also rely on quick searches to run models and analyze results promptly.
What makes binary search stand out is its ability to handle large datasets with minimal delay, making it an essential tool in today's fast-paced world filled with data. It also requires certain conditions to be met for it to work effectively, which we’ll cover shortly.
The Basic Idea Behind Binary Search
The core concept behind binary search is fairly straightforward: you begin by comparing the target value to the middle item in a sorted list. Based on whether the target is smaller or larger, you eliminate half of the list from consideration and repeat the process on the remaining half. This splitting continues until the target is found or until there are no more elements left to check.
Picture searching for a specific stock ticker in a sorted list of hundreds of them — instead of going through each one, binary search quickly narrows down the possibilities by chopping the list over and over. This approach cuts down the workload dramatically compared to checking stock by stock.
When Binary Search Is Useful
Binary search excels mostly when dealing with large collections of data that are sorted and where access to any part of the data is fast and direct. You’ll often see it applied in scenarios like:
Financial databases: Quickly finding historical prices or transaction records.
Trading platforms: Retrieving order book entries or specific trade records.
Educational tools: Looking up terms or definitions in sorted glossaries related to finance.
However, binary search isn’t the go-to for small or unsorted datasets because the overhead of sorting or setup may outweigh the speed gains.
Requirements for Binary Search to Work
Sorted Data Lists
For binary search to work, the list must be sorted. This means the data needs to be arranged in proper order — either ascending or descending. For example, a sorted list of stock closing prices or alphabetical company names makes it easy to predict where the target might lie.
Without order, binary search loses its edge because the decision about which half to discard depends completely on knowing the data's sequence. If the market prices you’re dealing with are scattered without order, you’d have to revert to simpler search methods or sort them first before using binary search.
Random Access Capability
Besides sorted order, binary search requires the ability to instantly access any element in the list by its index. This is known as random access. Think of it like having a filing cabinet where you can open any drawer directly instead of flipping through files one by one.
In practical terms, data structures like arrays or lists support efficient random access, while linked lists do not, because linked lists require sequential traversal. For financial analysts working with large datasets in arrays or databases optimized for quick indexing, random access makes binary search feasible and highly efficient.
Without random access, the speed advantage of binary search diminishes significantly as you lose direct reach to data points, forcing slower traversal.
Together, these requirements ensure that binary search operates at peak efficiency, trimming down search times from potentially minutes to milliseconds in real-world applications.
Step-By-Step Walkthrough of the Binary Search Algorithm
Getting a feel for binary search goes beyond just knowing what it does — it’s about understanding how each step fits together. This section breaks down the algorithm piece by piece, highlighting the why and how behind it. For investors or traders scanning through vast datasets or financial analysts handling sorted performance indexes, mastering this makes information retrieval quicker and less error-prone.
Knowing the step-by-step process helps avoid typical mistakes and makes your implementation tight. For example, if you’re searching a sorted array of stock prices, understanding how binary search adjusts its search window based on comparisons can save precious milliseconds in automated trading algorithms.
Setting the Search Boundaries
Before any searching begins, you need to pin down the area where the algorithm will look. This is done by defining the low and high indexes — effectively, the start and end points of the segment in your sorted list where the target might be.
Think of it like looking for a particular book within a shelf of arranged titles. You first decide which part of the shelf to check. Initially, the entire shelf is under consideration, so the low index is at the start (0), and the high index is at the end (length of list minus one). This range will shrink with each step, zeroing in on the target.
Defining these boundaries precisely is key: it sets your search limits and prevents you from wandering outside your intended range, which could cause wrong results or errors. It also makes sure the algorithm knows when to stop — when the low index surpasses the high one, the search area is empty.
Finding the Middle Element
Once your boundaries are set, the next step is identifying the middle element. This middle acts as the checkpoint to decide where to search next.
You find it by calculating the average of low and high indexes, typically as mid = low + ((high - low) // 2). This way avoids overflow issues in languages where summing large indexes might cause problems.
For instance, if you're looking in a data list from index 0 to 99, the middle element starts at index 49. Comparing your target to this middle will determine which half to discard.
Comparing Target with Middle Element
At this point, you pit your target value against the middle element’s value. This comparison answers the critical question: is your target equal to, less than, or greater than this middle value?
If the target matches, then congratulations — the search ends successfully.
When it comes to financial datasets, imagine you’re looking for a specific price point or timestamp. Comparing at the midpoint quickly informs whether you need to shift your focus to the earlier or later part of the data.
Adjusting the Search Range
How you tweak your search boundaries depends on that comparison.
If Target Is Smaller:
When the target is less than the middle element, it means all items beyond the mid can be safely ignored. So, set the high index to
mid - 1. Your new search range shrinks to the left half. This step cuts down the leftover list, speeding the search substantially.If Target Is Larger:
Conversely, if the target is larger than the middle element, the lower half is out of the picture. Now, set the low index to
mid + 1. Focus moves right, effectively dropping the already checked part.
Both cases work together to narrow down the hunt efficiently. In real-world terms, say you’re scanning sorted dates within a financial report; each adjustment skips irrelevant chunks quickly instead of scanning every date tediously.
Repeating Until Target Is Found or Range Is Empty
You repeat this cycle: find middle, compare, adjust boundaries — until either your target is found or the search range disappears (low index crosses high index).
This repetition ensures exhaustive but efficient searching, typically performing way faster than a simple linear scan, especially with large datasets.
In summary, the step-by-step method lets you slice and dice information smartly, making searches quick and reliable — a valuable skill when dealing with heaps of sorting financial or market data. Keep practicing these steps, and binary search becomes second nature.
How to Write Binary Search in Code
Writing binary search in code is where all the theory meets practice. Once you understand the concept, coding lets you apply the algorithm effectively, whether for sorting stocks, data lookup, or any other scenario where quick search is needed. This section breaks down how to put binary search into action, discussing two main approaches: procedural and recursive. Each approach has its own use cases and trade-offs, so getting to grips with both gives you flexibility.
Binary Search in a Procedural Language
Example in Python
Python offers a straightforward way to implement binary search, thanks largely to its clean syntax and list handling. Here’s a simple example showing the core logic:
python def binary_search(arr, target): low, high = 0, len(arr) - 1
while low = high:
mid = (low + high) // 2
if arr[mid] == target:
return mid
elif arr[mid] target:
low = mid + 1
else:
high = mid - 1
return -1
In this snippet, notice how we keep adjusting `low` and `high` based on the target comparison, narrowing down the search scope. This is a practical method for anyone dealing with sorted arrays as it’s both efficient and easy to read.
#### Iterative Approach
The iterative approach, as above, involves a loop that updates the search boundaries until the target is found or the segment is empty. This method is generally preferred in environments where function call overhead matters. It keeps memory use low since it doesn’t add layers of function calls to the call stack, which can be crucial in resource-limited systems.
The iterative method fits well into many day-to-day coding tasks where stability and predictability are important. For example, in trading platforms where quick query response is a must, avoiding recursion depth issues is beneficial.
### Binary Search Using Recursion
#### How Recursive Calls Work
Recursion solves the binary search problem by breaking it down into smaller versions of itself. Each recursive call narrows the search window, similar to the iterative process, but it does so by calling the same function again with modified parameters:
```python
def recursive_binary_search(arr, target, low, high):
if low > high:
return -1
mid = (low + high) // 2
if arr[mid] == target:
return mid
elif arr[mid] target:
return recursive_binary_search(arr, target, mid + 1, high)
else:
return recursive_binary_search(arr, target, low, mid - 1)Here, the function keeps calling itself until it finds the target or determines the target isn't present. This approach feels very intuitive because it aligns with the mathematical definition of binary search.
Benefits and Drawbacks
Recursive binary search shines with its elegance and simplicity. The code is often shorter and easier to understand. However, the downside can be seen in larger datasets or tight hardware environments: excessive recursion can lead to stack overflow.
For practical applications, especially in financial systems processing vast datasets, careful consideration is needed before choosing recursion.
Pros:
Cleaner code structure
Easy to follow logic
Cons:
Uses more memory due to call stack
Risk of hitting recursion limits on large arrays
In summary, knowing when to use the iterative or recursive binary search depends on the specific constraints of your project — memory, data size, and ease of maintenance all play a part.
Common Mistakes and Challenges When Implementing Binary Search
Binary search looks simple on paper, but the real challenge often comes down to nailing the details during implementation. Even the smallest slip-ups can make your search unreliable, slow, or downright wrong. Understanding common pitfalls helps traders, analysts, and coders avoid hours of debugging and ensures your algorithm runs smoothly with accuracy you can trust.
Let’s break down the usual suspects that trip up many when coding binary search.
Off-By-One Errors
Off-by-one errors are the bane of many programmers’ lives in binary search. They happen when the boundary indexes (like low, high, or mid) aren't updated correctly, causing your search to miss the target or result in an infinite loop.
For example, if your code sets mid = (low + high) / 2 and after comparing, you update low = mid instead of low = mid + 1 when the target is greater than the middle element, you’ll keep checking the same element repeatedly. This seemingly tiny mistake stalls the search.
A quick way to avoid this is to clearly define whether your search interval is inclusive or exclusive on either end and be consistent in updating the indices. Drawing a quick diagram or using a debugger to watch the changing low and high values often helps catch this.
Incorrect Update of Bounds
Incorrect adjustment of the search boundaries is a close cousin to off-by-one errors but deserves its own spotlight because it can also arise from misunderstanding the comparison logic.
Imagine you're looking for a number in a sorted list, and after comparing the middle element, you mistakenly shrink the search to low = mid + 1 when the target is actually smaller than the middle element. This moves the lower bound in the wrong direction, skipping the potential target zone.
This is why it's critical to clearly establish what part of the list is discarded after each comparison. The update must always restrict the search to the side where the target could logically be found.
Not Handling Empty Lists Properly
An empty list is a simple case that can easily lead to bugs if overlooked. The binary search expects at least one element to check against, but sometimes input data might be empty or dynamically changing.
Failing to verify the list length before starting can cause your algorithm to attempt accessing nonexistent elements, leading to runtime errors or crashes—definitely not what you want, especially in high-stakes trading software or financial analysis tools.
Always include a check at the very start:
python if len(data) == 0: return -1# or a suitable indicator that means 'not found'
This prevents errors and makes your code more robust.
> Carefully handling these common issues ensures your binary search implementation is both reliable and efficient, which is essential when speed and precision matter, like in financial computations or data-heavy applications.
## Understanding Binary Search Complexity and Performance
Understanding the complexity and performance of binary search isn't just academic—it directly affects how efficiently you handle data. Whether you're crunching numbers in a stock database or filtering through large volumes of trading signals, knowing what makes binary search tick helps you make informed choices about when and how to use it.
Binary search shines because it drastically cuts down the number of comparisons you need to find a result. In big data environments where every millisecond counts, the difference between searching linearly versus using binary search can be the difference between a timely trade and a missed opportunity. Before we dive deeper, it's worth highlighting that the gains in speed come with some conditions, like the need for sorted data and random access, but those are small prices to pay when the dataset grows large.
### Time Complexity Explained
Binary search runs in logarithmic time, often expressed as O(log n). This means that with every step, you halve the number of items left to check, rather than looking at each item one by one. Imagine you have a sorted ledger of 1,000 stock prices. Instead of examining prices from top to bottom, binary search checks the middle price first. If that's not your target, you discard half the list instantly. Repeat this a few times, and you'll narrow down your search super quick—usually requiring just around 10 steps even for 1,000 entries.
This shrinking by halves is what makes binary search stand out. In real-world finance systems where databases might contain millions of entries, this approach saves a chunk of time compared to linear search. Understanding this helps you optimize your code for speed by choosing the right algorithm when dealing with large sorted datasets.
> *Remember: the efficiency gain depends on the list being sorted. If you skew this, binary search won’t work properly.*
### Space Complexity Overview
When it comes to space, binary search is pretty light on its feet. The iterative version of binary search doesn’t require any extra significant space beyond a few variables to keep track of indices—it consumes constant space, noted as O(1). This is beneficial in environments with limited memory, such as embedded trading systems or mobile trading apps.
Recursive binary search, however, involves stack space for function calls. Each recursive call eats up a bit of memory, which adds up to O(log n) space complexity due to the depth of the recursion tree. While this is still efficient, iterative binary search is often preferred in production to avoid stack overflow risks in huge datasets.
### Comparing Binary Search to Linear Search
#### Efficiency Differences
At a glance, linear search seems simpler: start at the beginning, scan through the list, and stop when you find your target. It has a time complexity of O(n), meaning the search time grows linearly with the list size. For small or unsorted datasets, this simplicity might actually save time because there's no need to sort or prepare the list beforehand.
Binary search, by comparison, excels with large and sorted lists. Because it cuts the search space in half each step, it zooms in on the target much quicker. Just think about finding a specific ticker symbol in a sorted list of thousands vs. scanning each one from top to bottom—it can save you seconds, which in fast markets is a big deal.
#### When Linear Search Might Be Better
Despite the benefits of binary search, linear search still has its moments to shine. If the dataset is small (say fewer than 20 items), the overhead of managing the binary search boundaries, or sorting if needed, might overshadow its gains. Similarly, when dealing with unsorted or constantly changing data where sorting isn’t practical, linear search is simpler and more reliable.
Another scenario is when you need to find multiple instances of a value or the list elements are spread over complex data structures (like linked lists), linear search's straightforward nature often wins out. Also, in cases where data arrives in real-time streams and you need to check as it comes in, scanning linearly is sometimes the only option.
In summary, understanding how binary search stacks up against linear search and the complexity involved equips you to use the right search in the right scenario—streamlining your processes whether you’re analyzing daily market moves or preparing large financial reports.
## Practical Applications of Binary Search
Binary search isn’t just a textbook concept; it’s deeply woven into many real-world applications. Its efficiency in quickly narrowing down data makes it a valuable tool, especially in fields like finance and technology where speed and accuracy matter a lot. Understanding its practical uses helps professionals see not only how the algorithm works but also where it fits in daily problem-solving.
### Searching in Large Databases
When dealing with massive databases, say, a stock exchange's daily trade records, binary search saves a ton of time. Imagine a dataset with millions of entries sorted by date or transaction ID. Instead of scanning every record from start to end, binary search rapidly pinpoint the exact entry or range of entries you need. For example, a financial analyst hunting for a specific trade executed at an exact timestamp can use binary search to access the data within milliseconds—a lifesaver compared to a linear search through such a vast set. This method significantly reduces computational load and speeds up querying in systems like Bloomberg terminals or local trading databases.
### Use in Real-Time Systems
In fast-moving environments like live trading platforms, real-time decision-making is non-negotiable. Here, binary search plays a quiet but critical role. For instance, in high-frequency trading (HFT), algorithms must quickly find the best price or match orders within sorted price lists. Binary search allows these systems to promptly adjust bids and offers without lag, which can be the difference between profit and loss. Similarly, risk management tools often use binary search to rapidly locate threshold breaches or trigger alerts based on current market data, ensuring swift responses to changing conditions.
### Finding Boundaries and Thresholds in Data
Binary search is especially useful when you need to find specific boundaries within a dataset rather than an exact match. Take a scenario where a trader wants to identify the first date when a stock price crossed above a certain value. Instead of scanning every price one by one, you can use binary search to locate that precise boundary quickly. Another example is to determine the last occurrence of a price hitting a threshold before a drop—helpful for setting stop-loss limits or spotting trends. This approach is more efficient than linear methods and maintains speed even with large data props.
> Using binary search to identify thresholds helps analysts make informed decisions faster, from setting entry and exit points to triggering automated trades.
In short, binary search powers many behind-the-scenes tasks that keep financial systems snappy and reliable. Its role in handling large, sorted datasets makes it indispensable across various platforms, from databases to real-time trading engines. For investors and analysts, grasping these applications offers a clear advantage in leveraging technology for smarter, quicker decisions.
## Variants and Extensions of the Basic Algorithm
Binary search is a classic, but it’s not one-size-fits-all. Different situations call for tweaks or entirely new takes on the basic idea. These variants and extensions address challenges like rotated arrays, unknown sorting orders, or even leveraging other strategies to speed up searches on non-uniform data. Let's break down some popular variations that come in handy, especially in fast-paced fields like finance and data analysis.
### Binary Search on Rotated Arrays
Imagine you have a sorted list of stock prices but due to some operation — say, a system glitch or reordering for optimization — it's been rotated. A rotated array looks like this: instead of [2, 3, 5, 7, 11], you’d get [7, 11, 2, 3, 5]. The normal binary search would be thrown off because the list isn’t sorted in the usual order.
A binary search variant tailored for rotated arrays tackles this by identifying which half of the window is still sorted. For example, if you take the middle element and find that the left side is sorted, you check if your target lies within that sorted portion. If yes, narrow your search there; if not, shift to the other half. This logic repeats recursively or iteratively until the target is found or the interval vanishes.
Practical use? Think of analyzing rotated transaction logs or time-shifted datasets where the rotation reflects shifts in data sampling or processing. This skill avoids re-sorting data for each query, saving precious processing time.
### Order-Agnostic Binary Search
Sometimes you face the odd scenario that the sorted order isn’t known beforehand—could be ascending or descending. An order-agnostic binary search adapts on the fly. It checks the first and last elements to guess the order, then performs standard binary search accordingly.
Take an example of a portfolio sorted by value, but sometimes value gains mean higher prices are earlier (descending), sometimes the opposite. This variant just rolls with whatever order the data has, without requiring a prior knowledge. It's especially useful in tools or libraries that need to handle data from multiple sources or varying sorting rules.
### Interpolation Search Compared
Linear and binary searches aren’t the only options on the table. Interpolation search can sometimes outshine binary search when data is uniformly distributed. It estimates where the target might be by interpolation, kind of like guessing halfway between a high and low guess, but weighted by values.
For measurement ranges or price bands that follow roughly linear gradations, interpolation search can drastically cut down search time. However, it fails hard with skewed or clustered data, where the guesswork often sends you off course.
> While binary search cuts the search space in half every time, interpolation search tries to predict closer to the target on every guess. Pick your tool based on how your data behaves — no single perfect method exists.
Understanding these variants and when to use them is vital. They boost the efficiency of data retrieval in complex real-world datasets beyond textbook perfect conditions. For traders, analysts, or anyone crunching heaps of numbers, these are the kinds of refinements that turn a decent algorithm into a practical powerhouse.
## Handling Edge Cases in Binary Search
Handling edge cases in binary search is essential to building a reliable and efficient algorithm. It’s easy to get caught up in the ideal flow when the data is exactly what you expect, but real-world datasets often come with quirks. Accounting for these unusual scenarios prevents bugs and ensures the search behaves predictably.
Consider financial data where you might be searching for a specific transaction or price point. If your binary search doesn’t correctly address edge cases, like duplicate values or missing targets, your analysis could be off. Being thorough here saves time and reduces errors in critical applications.
### When the Target Is Not Found
A common scenario is when the target value simply isn’t there. The algorithm needs to handle this gracefully without running into infinite loops or returning misleading results. The most straightforward approach is to return a sentinel value such as `-1` or `null` to indicate absence clearly.
For example, if you’re searching a sorted list of stock closing prices looking for a particular day’s value, you might encounter days when that specific price wasn’t recorded. Your binary search should promptly let you know it’s not found, so your program can decide the next step—whether to alert users or try alternative analysis.
> Properly managing “not found” results avoids confusion and keeps downstream processes smooth.
### Multiple Occurrences of the Target
In many datasets, especially sorted ones, your target value might appear more than once. Knowing exactly *which* occurrence you’re interested in can be important for precise analysis.
#### Finding First Occurrence
If you're tasked with finding the very first instance of a target, standard binary search needs tweaking. Instead of stopping as soon as the target is found, continue searching the left half to check if there’s an earlier match. This is useful when you want to determine the earliest point a threshold was crossed in time series data.
For instance, suppose you have a sorted list of trade execution times where a certain price was hit multiple times. Finding the first occurrence helps identify the moment this price triggered market action.
#### Finding Last Occurrence
Similarly, to find the last occurrence, once a target is found, the search continues on the right half to see if it appears later. This is crucial in use cases like understanding the last moment a price held before a drop.
Using these variations helps tailor binary search to scenarios where duplicates aren’t noise but carry meaningful insights.
### Empty or Very Small Lists
Binary search on an empty list should immediately return a “not found” result without trying to access indices. This prevents errors and unnecessary computation.
For very small lists—say, one or two elements—binary search still works but the boundaries quickly shrink, often resolving in just one or two comparisons. It’s wise to include checks that handle these cases specifically to make your code clean and efficient.
In high-frequency trading systems or real-time financial analysis, lists are sometimes generated or cut down dynamically. Making sure your binary search copes well with these extremes saves headaches.
In summary, addressing edge cases such as missing targets, multiple target occurrences, and minimal or empty inputs sharpens your binary search implementation. These details might seem like minor footnotes, but they make the difference between an algorithm ready for the messy real world and one that fails under pressure.
## Tips for Optimizing Binary Search in Practice
When you’re dealing with binary search, squeezing out every bit of efficiency can save loads of time, especially when working with vast datasets like stock prices or transaction records. This section shines a light on practical ways to make binary search not just work, but work smartly. Whether you’re tinkering with code or analyzing data streams, understanding these tweaks can prevent headaches and make your searches razor-sharp.
### Choosing Between Iterative and Recursive Approaches
Picking between iterative and recursive methods for binary search really depends on your environment and the problem size. Recursive binary search calls itself repeatedly, making the code cleaner and often easier to understand—think of it as neatly folding a map until you find your spot. But watch out: recursion can swell up the call stack, potentially causing stack overflow errors if your data set is enormous.
On the other hand, the iterative approach loops through the data by updating your low and high pointers without extra stack overhead. This usually makes it faster and safe for large inputs. For example, in a live trading system that demands quick response times, an iterative binary search might be the go-to because every microsecond counts.
In sum, use recursion when clarity and simplicity are your goals, and iterative when performance and stability under heavy loads matter more.
### Avoiding Overflow When Calculating Midpoint
A common pitfall in binary search algorithms is integer overflow when calculating the midpoint. Instead of the straightforward `(low + high) / 2`, it’s safer to compute the midpoint like this: `low + (high - low) / 2`. Why? Adding `low` and `high` directly can exceed the maximum value an integer can hold, especially on older or constrained systems.
For instance, imagine searching through a massive sorted array of financial transactions—improper midpoint calculation might crash your program unexpectedly. Using the safer formula helps dodge such risks, ensuring your binary search keeps chugging along no matter the data scale.
> Always prefer the overflow-safe midpoint calculation to make your binary search bulletproof against edge-case failures.
### Using Binary Search in High-Level Languages
High-level languages like Python, Java, or C# often come with built-in utilities or libraries for binary search, such as Python’s `bisect` module or Java’s `Arrays.binarySearch` method. These are usually well-tested, optimized, and handle many edge cases seamlessly.
However, relying solely on built-in functions won’t teach you the nuances of binary search logic. Plus, sometimes those methods may not fit custom requirements like searching in rotated arrays or handling multiple occurrences. In such cases, writing your own version allows greater control.
Also, keep in mind the performance implications. For instance, Python’s built-in binary search works great for lists but might slow down on other data structures due to language internals. So, knowing when to use the standard tools and when to roll your own is key to mastering binary search in real-world applications.
Implementing these tips will have you running binary searches that are not just correct but efficient and reliable, crucial aspects in financial data processing or real-time analytical systems where every millisecond and accuracy count.