sBest ← s0
bestCandidate ← s0
tabuList ← []
tabuList.push(s0)
while (not stoppingCondition())
    sNeighborhood ← getNeighbors(bestCandidate)
    bestCandidateFitness ← -∞
    for (sCandidate in sNeighborhood)
        if ( (not tabuList.contains(sCandidate)) 
            and (fitness(sCandidate) > bestCandidateFitness) )
            bestCandidate ← sCandidate
            bestCandidateFitness ← fitness(bestCandidate)
        end
    end
    if (bestCandidateFitness is -∞)
        break;
    end
    if (bestCandidateFitness > fitness(sBest))
        sBest ← bestCandidate
    end
    tabuList.push(bestCandidate)
    if (tabuList.size > maxTabuSize)
        tabuList.removeFirst()
    end
end
return sBest

# runtime > O(log) : logarithmic time
def binary_search(list, item):
 low = 0
 high = len(list) -1
 step = 0
 while low <= high:
    step = step + 1
    mid = (low + high)
    guess = list[mid]
    if guess == item:
        print("number of steps :" , step)
        return mid
    if guess > item:
        high = mid - 1
    else:
        low = mid + 1
 return None 


# runtime > O(n) : linear time 
def linear_search(list , item):
   step = 0
   for x in list :
      step = step + 1
      if x == item :
         print("number of steps : ",  step)
         return item
    
   return None
 
mylist = [1 , 3 , 5 , 12 , 15 , 21, 22 , 23 , 24 ,25 ]
print ("len array : " ,  mylist.__len__())


# Selection sorts
# operation runtime O(n2) because it takes 2 operations + a O(1) : constant time for looping and making the task done.
def find_smallest(arr):
   smallest = arr[0]
   smallest_index = 0
   for i in range(1, len(arr)):
      if arr[i] < smallest:
         smallest = arr[i]
         smallest_index = i
   return smallest_index

def selection_sort(arr):
   newArr = []
   for i in range(len(arr)):
      smallest = find_smallest(arr)
      newArr.append(arr.pop(smallest))
   return newArr
###
import random
newlist = sorted(mylist, key=lambda x: random.random())
print("new list :" , newlist)
newlist = selection_sort(newlist)
print("sorted list using selection sort :" , newlist)



# O(log n) is faster than O(n), but it gets a lot faster as the list of items 
# you’re searching grows.
print(binary_search(mylist , 22))

print(linear_search(mylist , 25))

def binary_search_recv(list, number , low , high):
   if low > high:
      return -1

   mid = (low + high)
   guess = list[mid]

   if guess == number:
      return mid

   if guess > number:
      return binary_search_recv(list , number , low , mid - 1)
   else:
      return binary_search_recv(list, number , mid + 1 , high)

from abc import ABC, abstractmethod


class FormatNotFound(Exception):
    pass

class File(ABC):
    def __init__(self, file):
        self.file = file

    @abstractmethod
    def make(self):
        pass

    def call_edit(self):
        product = self.make()
        result = product.edit(self.file)
        return result


class JsonFile(File):
    def make(self):
        return Json()


class XmlFile(File):
    def make(self):
        return Xml()


class Json:
    def edit(self, file):
        return f'working on {file}.json'


class Xml:
    def edit(self, file):
        return f'working on {file}.xml'


def client(file, format):
    try:

        formats = {
        'json': JsonFile
        , 'xml': XmlFile
    }
        result = formats[format](file)
        return result.call_edit()
    except KeyError:
        raise FormatNotFound



if __name__ == '__main__':
    print(client('test', 'json'))