-1

You are given a string array named strs with length n, when each string can have the value "good" or "bad". It is also known that exists index i so that:
0<=i<=n-1, strs[0]=strs[1]=...=strs[i-1]="good", strs[i]=strs[i+1]=...=strs[n-1]="bad".
Pay attention that if i=0, it means that strs has only strings with the value "bad".

Write an algorithm to find index i.
Desired run time: O(logn)

My attempt:
I'm sure you need to use binary search here, but for some reason I have a problem with the check of the middle element.
I thought of checking if the middle element has a value of "good" and the middle+1 element has a value of "bad", but this can give out of bounce error.

Any idea how to solve it?

John
  • 861
  • 1
  • 7
  • 19
  • Nope, it can't give an out-of-bounds error because the problem specifies that `i` exists and is in the range `0<=i<=n-1`. – user3386109 Dec 08 '18 at 22:30
  • 2
    You don't need to check 2 elements regardless whether n is odd or even. At each step, you just need to divide the remaining elements in half (or half and half-1). – stark Dec 08 '18 at 22:35
  • @stark, so how do you check for the wanted index in the algorithm? how can you know when it switches from "good" to "bad" without checking 2 elements? – John Dec 08 '18 at 22:42
  • @user3386109, it can get out of bounce in the way I chose to implement it, since in binary search you can get to a situation when left index is equal to right index. That will give out of bounce in my case since I check for two indexes in the array. – John Dec 08 '18 at 22:44
  • In the question, it is stated that *"the middle element has a value of `"good"`"*. If that's the case, then `middle+1` cannot be out of bounds. The problem description guarantees that there is at least one `"bad"` element in the array. – user3386109 Dec 08 '18 at 22:49
  • So the answer is to implement a binary search that ends with `left_index == right_index == middle == index_of_the_first_bad`. That way, as @stark pointed out, you don't need to check `middle+1`. You just need to run the binary search until the indexes are equal. – user3386109 Dec 08 '18 at 22:51
  • @user3386109, I don't understand your suggestion (specifically how you find "index_of_the_first_bad"). Can you write the algorithm as pseudo code? – John Dec 08 '18 at 22:54
  • Don't think in terms of finding the dividing line. Just think in terms of looking for i. That means check middle and eliminate half the numbers at each step. – stark Dec 08 '18 at 22:57

1 Answers1

1

In this answer over here, I explain that when you write a binary search, it's usually better to do a real binary search (making real binary decisions) to find the index where the element you're searching for belongs, and then check to see if it's actually there:

How can I simplify this working Binary Search code in C?

In your case, the index is your desired result, so you don't even need to check:

int findIndex(string[] array)
{
    int minpos=0;  //smallest possible answer (array is all bad)
    int limit=array.length; //largest possible answer (array is all good)

    while(minpos<limit)
    {
        //testpos is guaranteed to be >= minpos and < limit
        int testpos = minpos+((limit-minpos)/2);

        if (array[testpos].equals("good")) //test index is too low
            minpos=testpos+1; //minpos always increases here  
        else
            limit=testpos; //limit always decreases here
    }

    return minpos;
}
Matt Timmermans
  • 53,709
  • 3
  • 46
  • 87