chap2

def insertion_sort(A):
   for i in range(1,len(A)):
      x=A[i];
      j=i-1;
      while( j>=0 and A[j]>x):
         A[j+1]=A[j]
         j-=1
      A[j+1]=x
A=[5,4,3,2,1]
insertion_sort(A);
print(A)
def insertion_sort_decrease(A):
   for i in range(1,len(A)):
      x=A[i]
      j=i-1
      while(j>=0 and A[j]<x):
         A[j+1]=A[j]
         j-=1
      A[j+1]=x
insertion_sort_decrease(A)
print(A)
def linear_search(A,v):
   for i in range(0,len(A)):
      if(A[i]==v):
         return i;
   return None
def int_add(A,B):
   carry=0
   C=[0]*(len(A)+1)
   for i in reversed(range(0,len(A))):
      C[i+1]=carry+A[i]+B[i]
      carry=C[i+1]//10
      C[i+1]=C[i+1]%10
   C[0]=carry
   return C
A=[1,2,3,4,5]
B=[6,7,8,9,1]
C=int_add(A,B)
print(C)
def selection_sort(A):
   for i in range(0,len(A)):
      minj=i
      for j in range(i+1,len(A)):
         if(A[j]<A[minj]):
               minj=j
      A[minj],A[i]=A[i],A[minj]
A=[3,4,3,2,1]
selection_sort(A)
print(A)
def merge(A,p,q,r):
    n1=q-p+1
    n2=r-q
    L=[0]*(n1+1);R=[0]*(n2+1)
    for i in range(0,n1):
        L[i]=A[p+i]
    for j in range(0,n2):
        R[j]=A[q+j+1]
    infinity=10000
    L[n1]=R[n2]=infinity
    i,j=0,0
    for k in range(p,r+1):
        if(L[i]<=R[j]):
            A[k]=L[i]
            i+=1;k+=1
        else:
            A[k]=R[j]
            j+=1;k+=1
def merge_sort(A,p,r):
    if p<r:
        q=(p+r)//2
        merge_sort(A,p,q)
        print(A[p:q+1])
        merge_sort(A,q+1,r)
        print(A[q+1:r+1])
        merge(A,p,q,r)
        print(A[p:r+1])
A=[5,4,3,2,1];
merge_sort(A,0,len(A)-1)
print(A)
def merge2(A,p,q,r):
    L=A[p:q+1];R=R[q+1:r+1];
    i,j=p,q+1
    k=p
    while(i<=q and j<=r):
        if L[i]<=R[j]:
            A[k]=L[i]
            i+=1;k+=1
        else:
            A[k]=R[j]
            j+=1;k+=1
    while(i<=q):
        A[k]=L[i]
        k+=1;i+=1
    while(j<=r):
        A[k]=R[j]
        k+=1;j+=1
def merge_sort2(A,p,r):
    if(p<r):
        q=(p+r)//2
        merge_sort2(A,p,q)
        merge_sort2(A,q+1,r)
A=[5,4,3,2,1]
merge_sort2(A,0,len(A)-1)
print(A)
def insertion_r(A,k):
    # insert A[k] into sorted A[0:k]
    if k<=0:
        return None
    else:
        insertion_r(A,k-1)
        x=A[k]
        j=k-1
        while(j>=0 and A[j]>x):
            A[j+1]=A[j]
            j-=1
        A[j+1]=x
def insertion(A):
    insertion_r(A,len(A)-1)
A=[2,1]
insertion(A)
print(A)
def bsearch(A,v):
   low,high=0,len(A)
   while(low<high):
      q=(low+high)//2
      if(A[q]==v):
         return q
      elif A[q]>v:
         high=q
      else:
         low=q+1
   return None
def bsearch_r(A,low,high,v):
   if(low<high):
      q=(low+high)//2
      if(A[q]==v):
         return q
      elif A[q]>v:
         return bsearch_r(A,low,q,v)
      else:
         return bsearch_r(A,q+1,high,v)
def bsearch_wrap(A,v):
   return bsearch_r(A,0,len(A),v)
A=[1,2,3,4,5]
print(bsearch_wrap(A,2))
def upper_bound(A,v):
   low=-1;high=len(A)
   while(low+1<high):
      q=(low+high)//2
      if(A[q]<=v):
         low=q
      else:
         high=q
   return high
def lower_bound(A,v):
   low=-1;high=len(A)
   while(low<high):
      q=(low+high)//2
      if(A[q]<v):
         low=q
      else:
         high=q
   return low
A=[1,2,2,3,3,3,4]
print(lower_bound(A,3),upper_bound(A,2))
def bsearch(A,low,high,v):
   while(low<high):
      q=(low+high)//2
      if(A[q]==v):
         return True
      elif A[q]<v:
         low=q+1
      else:
         high=q
   return False
def is_adjacent(A,x):
   A.sort()
   for i in range(0,len(A)):
      if A[i]>x:
         return False
      else:
         if(bsearch(A,i+1,len(A),x-A[i])):
            return True
   return False
A=[1,2,3,4,5]
print(is_adjacent(A,910))
k=4
def insertion_sort(A,left,right):
   for i in range(left+1,right):
      x=A[i]
      j=i-1
      while(j>=left and A[j]>x):
         A[j+1]=A[j]
         j-=1
      A[j+1]=x
def merge_insertion_sort(A,p,r):
   if(r-p<=k):
      insertion_sort(A,p,r)
   else:
      q=(p+r)//2
      merge_insertion_sort(A,p,q)
      merge_insertion_sort(A,q,r)
      merge(A,p,q,r)
def merge(A,p,q,r):
   L=A[p:q];R=A[q:r]
   infinity=1000000
   L.append(infinity);R.append(infinity);
   i,j=0,0
   for k in range(p,r):
      if L[i]<=R[j]:
         A[k]=L[i]
         i+=1;k+=1
      else:
         A[k]=R[j]
         j+=1;k+=1
A=list(reversed(range(1,10)))
print(A)
merge_insertion_sort(A,0,len(A))
print(A)
def bubble_sort(A):
   for i in range(0,len(A)):
      for j in reversed(range(i+1,len(A))):
         if A[j]<A[j-1]:
            A[j],A[j-1]=A[j-1],A[j]
A=list(reversed(range(1,20)))
bubble_sort(A)
print(A)
def horner(A,x):
   y=0
   for i in range(n,-1,-1):
      y=A[i]+x*y
def inversion(A,p,r):
   #inversion return inversion num and sort the arr
   if(r-p<=1):
      return 0
   else:
      q=(p+r)//2
      n1,n2=inversion(A,p,q),inversion(A,q,r)
      n3=0
      L=A[p:q];R=A[q:r]
      infinity=100000
      L.append(infinity);R.append(infinity)
      i,j=0,0
      for k in range(p,r):
         if L[i]<=R[j]:
            A[k]=L[i]
            i+=1;k+=1
         else:
            A[k]=R[j]
            j+=1;k+=1
      return n1+n2+n3
A=[2,3,8,6,1]
print(inversion(A,0,len(A)))
print(A)