binary-search

I am trying to implement a solution using binary search. I have a list of numbers list = [1, 2, 3, 4, 6] value to be searched = 2 I have written something like this def searchBinary(list, sval): low = 0 high = len(list) while low < high: mid = low + math.floor((high - low) / 2) if list[mid] == sval: print("found : ", sval) elif l2s[mid] > sval: high = mid - 1 else: low = mid + 1 but when I am trying to implement this, I am getting an error like: index out of range. Please help in identifying the issue. cs95 A few things. Your naming is inconsistent. Also, do not use list as a variable name,

Hopefully someone knows the answer to this Java-Certification question: public static void main(String[] args) { String[] sa = {"d", "c", "a", "b" }; int x = Arrays.binarySearch(sa, "b"); Arrays.sort(sa); int y = Arrays.binarySearch(sa, "b"); System.out.println(x + " " + y); } Which two results are possible? (Choose two.) A) 7 0 B) 7 1 C) 7 3 D) -1 0 E) -1 1 F) -1 3 The only true answer is E) -1 1, because if you play through the binary-search-algorithm this is the only possible output. But they want me to choose two... So the second one have to be B) 7 1 then, because the second binarySearch

If binarySearch method requires you to sort your array before passing it as parameter to the method call, why not do a sort in the binarySearch method? Binary search works by assuming the middle of the array contains the median value in the array. If it is not sorted, this assumption does not make sense, since the median can be anywhere and cutting the array in half could mean that you cut off the number you were searching for. The reason binary search does not do the sort itself is because it does not need to...the array is already sorted. It is generally considered good programming practice

Is binary search optimal in worst case? My instructor has said so, but I could not find a book that backs it up. We start with an ordered array, and in worst case(worst case for that algorithm), any algorithm will always take more pairwise comparisons than binary search. Many people said that the question was unclear. Sorry! So the input is any general sorted array. I am looking for a proof which says that any search algorithm will take at least log2(N) comparisons in worst case(worst case for the algo in consideration). Yes, binary search is optimal. This is easily seen by appealing to

I noticed that as of Ruby 2.0.0 the array class has a bsearch method that I was testing and I'm not getting the behavior I'd expect. Why does it return a value for 2 and 5 but nil for -1, 1, and 4? arr_in = [-1, 1, 2, 4, 5] arr_in.bsearch { |x| x == 3 } #=> nil arr_in.bsearch { |x| x == -1 } #=> nil arr_in.bsearch { |x| x == 1 } #=> nil arr_in.bsearch { |x| x == 2 } #=> 2 arr_in.bsearch { |x| x == 4 } #=> nil arr_in.bsearch { |x| x == 5 } #=> 5 arr_in = [-1, 1,2,4,5] arr_in.bsearch{ |x| 2 - x } #=> 2 arr_in.bsearch{ |x| -1 - x } #=> -1 arr_in.bsearch{ |x| 3 - x } #=> nil Binary search uses