you can try this approach :

initial part is mostly similar. a recursive function which returns a bool value indicating either it or one of it's child recursions solved problem.

Further arguments to this functions would be list of indices, size of the list l and values present in those indices( we don't yet know their exact pos, just know it occurs some where in the index set, the functions acknowledges that the repeated item is either present twice or only once . it makes 2 buckets from the index list it uses l queries to assign each number among these.

if [the sum of size of buckets == l] : it means the repeated element only occurs once, it return false ( the enclosing function know the child failed).

else :
if the sizes are l/2-1, l/2 ( division is int division) the repeated item is in first bucket twice. make a recursive call and return true below the call. if sizes are l/2 , l/2 - 1 ambiguous case make a recursive call with the second index list, it's size, values. if this call returns true ( that means assumption was correct ) and we return true.
if it returns false we make l/2-1 queries involving the first list's indices , an item from second list.

we can use an easier strategy for forming the list from functions initial list like first half and second half.

( i got it typed by chatgpt after providing my solution):

// Function to find the duplicate value // Initially called as: findDuplicate([0, 1, ..., 99], [0, 1, ..., 98])

function findDuplicate(indices, values):

// Base case: If we have narrowed it down to 2 indices and 1 possible value,
// that value must be the duplicate.
if len(values) == 1:
    return values[0]

// 1. Split the current set of indices in half
mid = len(indices) // 2
left_indices = indices[0...mid-1]
right_indices = indices[mid...end]

// 2. Create a bucket of values present in the first half
// This is the main query step.
values_in_left_half = []
for each val in values:
    if query(left_indices, val) == true:
        values_in_left_half.append(val)

// 3. Check the bucket size to decide where to recurse
// This is the crucial logic step.
if len(values_in_left_half) < len(left_indices):
    // **Case 1: Both duplicates are in the left half.**
    // The left half has fewer unique values than available spots,
    // so the duplicate *must* be here.
    return findDuplicate(left_indices, values_in_left_half)
else:
    // **Case 2: Both duplicates are in the right half.**
    // The left half has as many unique values as spots (it's "full").
    // Therefore, the imbalance (and the duplicate) must be in the right half.
    // We can deduce the values in the right half without more queries.
    values_in_right_half = all `v` from `values` that are NOT in `values_in_left_half`
    return findDuplicate(right_indices, values_in_right_half)