Randomized Binary Search

A secret integer $t$ is selected at random within the range $1 \le t \le n$.
The goal is to guess the value of $t$ by making repeated guesses, via integer $g$. After a guess is made, there are three possible outcomes, in which it will be revealed that either $g \lt t$, $g = t$, or $g \gt t$. Then the process can repeat as necessary.
Normally, the number of guesses required on average can be minimized with a binary search: Given a lower bound $L$ and upper bound $H$ (initialized to $L = 1$ and $H = n$), let $g = \lfloor(L+H)/2\rfloor$ where $\lfloor \cdot \rfloor$ is the integer floor function. If $g = t$, the process ends. Otherwise, if $g \lt t$, set $L = g+1$, but if $g \gt t$ instead, set $H = g – 1$. After setting the new bounds, the search process repeats, and ultimately ends once $t$ is found. Even if $t$ can be deduced without searching, assume that a search will be required anyway to confirm the value.
Your friend Bob believes that the standard binary search is not that much better than his randomized variant: Instead of setting $g = \lfloor(L+H)/2\rfloor$, simply let $g$ be a random integer between $L$ and $H$, inclusive. The rest of the algorithm is the same as the standard binary search. This new search routine will be referred to as a random binary search.
Given that $1 \le t \le n$ for random $t$, let $B(n)$ be the expected number of guesses needed to find $t$ using the standard binary search, and let $R(n)$ be the expected number of guesses needed to find $t$ using the random binary search. For example, $B(6) = 2.33333333$ and $R(6) = 2.71666667$ when rounded to $8$ decimal places.
Find $R(10^{10}) – B(10^{10})$ rounded to $8$ decimal places.

To solve this problem, we can use Python to generate the set $S_k$, find the $k$-Ruff numbers, calculate their sum, and finally take the result modulo $1\,000\,000\,007$.

Let’s break down the steps to solve this problem:

Step 1: Generate the set $S_k$
To generate the set $S_k$, we need to find the first $k$ primes that end in $7$. We can use the `sympy` library in Python to generate prime numbers. Install the `sympy` library if you haven’t already, by running the command `pip install sympy`.

“`python
from sympy import isprime

def generate_S(k):
primes = [7] # Start with 7 since it is already known
n = 11 # First prime number ending in 7

while len(primes) < k: if str(n)[-1] == '7' and isprime(n): primes.append(n) n += 10 # Only check numbers ending in 7 return set(primes) ``` Step 2: Find the $k$-Ruff numbers To find the $k$-Ruff numbers, we need to consider all possible numbers less than the product of $S_k$ such that they are not divisible by any element in $S_k`$ and have the last digit 7. ```python def find_k_ruff_numbers(S): max_number = max(S) k_ruff_numbers = [] for num in range(7, max_number, 10): if all(num % prime != 0 for prime in S): k_ruff_numbers.append(num) return k_ruff_numbers ``` Step 3: Calculate the sum of $k$-Ruff numbers Once we have the list of $k$-Ruff numbers, we can calculate their sum. ```python def calculate_sum_of_k_ruff_numbers(k_ruff_numbers): return sum(k_ruff_numbers) ``` Step 4: Calculate $F(k)$ modulo $1\,000\,000\,007$ Finally, we can calculate $F(k)$ modulo $1\,000\,000\,007$. ```python def calculate_F_k(k): S = generate_S(k) k_ruff_numbers = find_k_ruff_numbers(S) sum_of_k_ruff_numbers = calculate_sum_of_k_ruff_numbers(k_ruff_numbers) return sum_of_k_ruff_numbers % 1000000007 ``` Now, let's calculate $F(97)$ using the defined functions: ```python F_97 = calculate_F_k(97) print(F_97) ``` The output will be the value of $F(97)$ modulo $1\,000\,000\,007$.

More Answers:
First Sort I
Rolling Ellipse
Largest Prime Factors of Consecutive Numbers

Share:

Recent Posts

Don't Miss Out! Sign Up Now!

Sign up now to get started for free!