(Sujet1,Sujet2)

## Q 1.1

# Indices 2 et 7

## Q 1.2

def chaines_egales(chaine1,chaine2):
  n = len(chaine1)
  i = 0
  while i<n:
      if chaine1[i] != chaine2[i]:
          return False
      i += 1
  return True

## Q 1.3

def liste_occurences(texte,mot):
  res = []
  n = len(mot)
  for i in range(len(texte)-n+1):
      if chaines_egales(mot,texte[i:i+n]):
          res.append(i)
  return res

## Q 1.4

def premiere_occurence(texte,mot):
  l = liste_occurences(texte,mot)
  if l == []:
      return None
  else:
      return l[0]

## Q 2.1

# ATTAC

## Q 2.2

def longueur_bord(ch):
  n = len(ch)
  jmax = 0
  for j in range(1,n):
      if chaines_egales(ch[:j],ch[n-j:]):
          jmax = j
  return jmax

## Q 2.3

def longueur_bords_prefixes(ch):
  B = []
  for j in range(len(ch)):
      B.append(longueur_bord(ch[:i+1]))
  return B

## Q 2.

# [0,1,0,0,0,1,2,3]

## Q 5

def kmp(texte,mot):
  n = len(texte)
  p = len(mot)
  B = longueur_bords_prefixes(mot)
  i = 0
  j = 0
  while i <= n-p:
      while j<p and mot[j] == texte[i+j]:
          j += 1
      if j == p:
          return i
      if j == 0:
          i = i+1
      else:
          i = i+j - B[j-1]
          j = B[j-1]
  return None

##1,2,3,4
L = [[200, 100, 155], [0, 254, 255]]

print(L[1],L[1][1],len(L),len(L[1]))
##5
def mz(n,m):
  return [m * [0] for k in range (n)]

print(mz(2,3))

##6

def taille(L):
  return len(L)*len(L[1])

##7

def negatif(L):
  N = mz(len(L),len(L[0]))
  n = len(L)
  m = len(L[0])
  for i in range(n):
      for j in range(m):
          N[i][j] = 255 - L[i][j]
  return N

##8

def monochrome(L,s):
  M=mz(len(L),len(L[0]))
  n = len(L)
  m = len(L[0])
  for i in range(n):
      for j in range(m):
          if L[i][j]  >= s:
              M[i][j] = 255
  return M

##9

def reflexion(L):
  R = mz(len(L),len(L[0]))
  n = len(L)
  m = len(L[0])
  for i in range(n):
      for j in range(m):
          R[i][j] = L[i][m - j-1]
  return R

##10

def transpose(L):
  T=mz(len(L[0]),len(L))
  R = mz(len(L),len(L[0]))
  n = len(L)
  m = len(L[0])
  for i in range(n):
      for j in range(m):
          T[i][j] = L[j][i]
  return T

##11
def indmin(L):
  k = 0
  n=len(L)
  for i in range(n):
      if L[i]<L[k]:
          k = i
  return k

def selection(L):
  n= len(L)
  for i in range(n):
      k = i+indmin(L[i:])
      L[i],L[k] = L[k],L[i]
  return L

def selection_rec(L):
  n = len(L)
  if n==0 or n==1:
      return L
  else:
      k = indmin(L)
      L[0],L[k] = L[k],L[0]
      return [L[0]]+selection_rec(L[1:])

##12

def indminPhoto(L):
  k = 0
  n=len(L)
  for i in range(n):
      if L[i][1]<L[k][1]:
          k = i
  return k

def selectionPhoto(L):
  n= len(L)
  for i in range(n):
      k = i+indminPhoto(L[i:])
      L[i],L[k] = L[k],L[i]
  return L

##13
def dicho(x,T):
  a=0
  b=len(T)-1
  while a < b:
      m=(a+b)//2
      if x==T[m]:
          return True
      elif x<T[m]:
          b=m
      else:
          a=m
  return False

##14
def dichoPhoto(d,photos):
  a=0
  b=len(T)-1
  while a < b:
      m=(a+b)//2
      if x==T[m][1]:
          return True
      elif x<T[m][1]:
          b=m
      else:
          a=m
  return False

##15
def nomPatients(images):
  noms=[]
  for key in images:
      n = images[key][2]
      if n not in noms:
          noms.append(n)
  return noms

##16
def nombreDate(images,date):
  i = 0
  for key in images:
      if images[key][1]==date:
          i = i+1
  return i

##17
def fracture(images):
  lab = []
  for key in images:
      l = images[key][3]
      f = (images[key][4]=='FRACTURE')
      if f and l not in lab:
          lab.append(l)
  return lab

images ={
109:[2.9 ,20221223 , "DUKIC","OCEANA","",""],
203:[1.2 ,20221005 ,"MOING","RADIO1","FRACTURE", "TROUSSEAU"],
405:[6.9 ,20230178 ,"KARL","RADIO2","ARTHROSE", "JENNER"],
108:[4.1 ,20230206 ,"DUKIC","OCEANA","FRACTURE","PARE"],
406:[2.0 ,20230612 ,"KARL", "RADIO2", "TENDINITE", "JENNER"]}

(Sujet)

## Tri par Insertion

def triInsertion(l):
    ll = l[:]
    n = len(ll)
    for i in range(n):
        element = ll[i]
        j = i
        while (j>0 and ll[j-1] > element):
            ll[j] = ll[j-1]
            j = j-1
        ll[j] = element
    return ll

def triInsertionMieux(l):
    ll = l[:]
    n = len(ll)
    for i in range(n):
        element = ll[i]
        j = i
        while (j>0 and ll[j-1] > element):
            j = j-1
        ll.insert(j,element)
        del(ll[i+1])
    return ll

## Tri fusion

def divise(l):
    n=len(l)
    return l[:n//2],l[n//2:]

def fusion(l1,l2):
    if l1 == []: return l2
    if l2 == []: return l1
    if l1[0] <= l2[0]:
        return [l1[0]] + fusion(l1[1:],l2)
    else:
        return [l2[0]] + fusion(l1,l2[1:])

def fusion(l1,l2):
    l = []
    while (l1!=[] and l2!=[]):
        if l1[0] > l2[0]:
            l.append(l2[0])
            del(l2[0])
        else:
            l.append(l1[0])
            del(l1[0])
    if l1==[]:
        return l + l2
    else:
        return l+l1

def triFusion(l):
    n = len(l)
    if n<=1:
        return l
    else:
        lg,ld = divise(l)
        lg,ld = triFusion(lg),triFusion(ld)
        return fusion(lg,ld)

## Quicksort

def partition(l):
    lg = []
    ld = []
    pivot = l[0]
    for elem in l[1:]:
        if elem < pivot:
            lg.append(elem)
        else:
            ld.append(elem)
    return lg,ld,pivot

def quicksort(l):
    n = len(l)
    if n <= 1:
        return l
    else:
        lg,ld,pivot = partition(l)
        lg = quicksort(lg)
        ld = quicksort(ld)
        return lg+[pivot]+ld

## Quicksort + insertion

def sedgesort(l):
    n = len(l)
    if n<=15:
        return triInsertionMieux(l)
    else:
        lg,ld,pivot = partition(l)
        lg = sedgesort(lg)
        ld = sedgesort(ld)
        return(lg+[pivot]+ld)

## Mediane

def nth_least(l,n):
    lg,ld,pivot = partition(l)
    kg = len(lg)
    if n==kg:
        return pivot
    elif n<kg:
        return nth_least(lg,n)
    else:
        return nth_least(ld,n-(kg+1))

def mediane(l):
    n = len(l)
    return nth_least(l,n//2)

## Test
import random as rd
import time
l = [rd.randint(-499,499) for _ in range(20000)]

t = time.time()
l_insert = triInsertion(l)
print("Tri par insertion :",time.time() - t)
t = time.time()
l_insertmieux = triInsertionMieux(l)
print("Tri par insertion mieux :",time.time() - t)
t = time.time()
l_fusion = triFusion(l)
print("Tri fusion :",time.time() - t)
t = time.time()
l_qs = quicksort(l)
print("Tri rapide :",time.time() - t)
t = time.time()
l_sedge = sedgesort(l)
print("Tri Sedge :",time.time() - t)
t = time.time()
l_sort = sorted(l)
print("Tri Python :",time.time() - t)
t = time.time()