On one of my previous courseworks, I was faced with the following problem, which I think is unrealistic when using a direct / straightforward approach that usually algorithms have by leveraging certain data structures like dictionaries, etc.

Design an O(log n) algorithm whose input is a sorted list A. The algorithm should return true if A contains at least 4 distinct elements. Otherwise the algorithm should return false.

My lecturer came up with the following solution:

def ThreeDiff(A):
 if A[0]==A[len(A)-1]:
  return -1

 minind=0
 maxind=len(A)-1

 while maxind-mind>1:
  midind=int((minind+maxind)/2)
  if A[midind]>A[minind] and A[midind]<A[maxind]:
   return midind
  if A[midind]==A[minind]:
   minind=midind
  else
   maxind=midind
return -1

def FourDiff(A):
  midind=ThreeDiff(A)
  if midind==-1:
   return false
  return ThreeDiff(A[0:midind+1])!=- 1 or ThreeDiff(A[midind:len(A)]) != -1

Is there a cleaner or better way to solve this problem?

On one of my previous courseworks, I was faced with the following problem, which I think is unrealistic when using a direct / straightforward approach that usually algorithms have by leveraging certain data structures like dictionaries, etc.

Design an O(log n) algorithm whose input is a sorted list A. The algorithm should return true if A contains at least 4 distinct elements. Otherwise the algorithm should return false.

My lecturer came up with the following solution:

def ThreeDiff(A):
  if A[0]==A[len(A)-1]:
    return -1

  minind=0
  maxind=len(A)-1

  while maxind-mind>1:
    midind=int((minind+maxind)/2)
    if A[midind]>A[minind] and A[midind]<A[maxind]:
      return midind
    if A[midind]==A[minind]:
      minind=midind
    else:
     maxind=midind
  return -1

def FourDiff(A):
  midind=ThreeDiff(A)
  if midind==-1:
    return false
  return ThreeDiff(A[0:midind+1])!=- 1 or ThreeDiff(A[midind:len(A)]) != -1

Is there a cleaner or better way to solve this problem?

On one of my previous courseworks, I was faced with the following problem, which I think is unrealistic when using a direct / straightforward approach that usually algorithms have by leveraging certain data structures like dictionaries, etc.

Design an O(log n) algorithm whose input is a sorted list A. The algorithm should return true if A contains at least 4 distinct elements. Otherwise the algorithm should return false.

My lecturer came up with the following solution:

def ThreeDiff(A):
 if A[0]==A[len(A)-1]:
  return -1

 minind=0
 maxind=len(A)-1

 while maxind-mind>1:
  midind=int((minind+maxind)/2)
  if A[midind]>A[minind] and A[midind]<A[maxind]:
   return midind
  if A[midind]==A[minind]:
   minind=midind
  else
   maxind=midind
return -1

def FourDiff(A):
  midind=ThreeDiff(A)
  if midind==-1:
   return false
  return ThreeDiff(A[0:midind+1])!=- 1 or ThreeDiff(A[midind:len(A)]) != -1

Is there a cleaner way to solve this problem?

On one of my previous courseworks, I was faced with the following problem, which I think is unrealistic when using a direct / straightforward approach that usually algorithms have by leveraging certain data structures like dictionaries, etc.

Design an O(log n) algorithm whose input is a sorted list A. The algorithm should return true if A contains at least 4 distinct elements. Otherwise the algorithm should return false.

My lecturer came up with the following solution:

def ThreeDiff(A):
 if A[0]==A[len(A)-1]:
  return -1

 minind=0
 maxind=len(A)-1

 while maxind-mind>1:
  midind=int((minind+maxind)/2)
  if A[midind]>A[minind] and A[midind]<A[maxind]:
   return midind
  if A[midind]==A[minind]:
   minind=midind
  else
   maxind=midind
return -1

def FourDiff(A):
  midind=ThreeDiff(A)
  if midind==-1:
   return false
  return ThreeDiff(A[0:midind+1])!=- 1 or ThreeDiff(A[midind:len(A)]) != -1

Is there a cleaner or better way to solve this problem?

On one of my previous courseworks, I was faced with the following problem, which I think is unrealistic when using a direct / straightforward approach that usually algorithms have by leveraging certain data structures like dictionaries, etc.

Design an O(log n) algorithm whose input is a sorted list A. The algorithm should return true if A contains at least 4 distinct elements. Otherwise the algorithm should return false.

My lecturer came up with the following solution:

def ThreeDiff(A):
 if A[0]==A[len(A)-1]:
  return -1

 minind=0
 maxind=len(A)-1

 while maxind-mind>1:
  midind=int((minind+maxind)/2)
  if A[midind]>A[minind] and A[midind]<A[maxind]:
   return midind
  if A[midind]==A[minind]:
   minind=midind
  else
  maxind=midind
return -1

def FourDiff(A):
  midind=ThreeDiff(A)
  if midind==-1:
   return false
  return ThreeDiff(A[0:midind+1])!=- 1 or ThreeDiff(A[midind:len(A)]) != -1

Is there a cleaner way to solve this problem?

On one of my previous courseworks, I was faced with the following problem, which I think is unrealistic when using a direct / straightforward approach that usually algorithms have by leveraging certain data structures like dictionaries, etc.

Design an O(log n) algorithm whose input is a sorted list A. The algorithm should return true if A contains at least 4 distinct elements. Otherwise the algorithm should return false.

My lecturer came up with the following solution:

def ThreeDiff(A):
 if A[0]==A[len(A)-1]:
  return -1

 minind=0
 maxind=len(A)-1

 while maxind-mind>1:
  midind=int((minind+maxind)/2)
  if A[midind]>A[minind] and A[midind]<A[maxind]:
   return midind
  if A[midind]==A[minind]:
   minind=midind
  else
   maxind=midind
return -1

def FourDiff(A):
  midind=ThreeDiff(A)
  if midind==-1:
   return false
  return ThreeDiff(A[0:midind+1])!=- 1 or ThreeDiff(A[midind:len(A)]) != -1

Is there a cleaner way to solve this problem?