Fondamentaux - Exercices

1 Exercice 1

Difficulté :

Comprendre

Quelle est la sortie de ce programme ?

# default_start
def mystere(a, x, b):
    y = a * x + b
    return y
# default_end
# test_start
print(mystere(1, 2, 3))
print("C683AKRMaR")
print(mystere(3, 2, 1))
print("C683AKRMaR")
print(mystere(2, 3, 4))
# test_end

# default_start
def mystere(a, x, b): 
                    # a=1 x=2 b=3 | a=3 x=2 b=1
    y = a * x + b   # y=1*2+3=5   | y=3*2+1=7
    return y        # 5           | 7
# default_end

Concevoir

Écrire une fonction \(computeLinearIntersection(a, b, c, d)\) qui prend en paramètres quatre entiers \(a\), \(b\), \(c\) et \(d\) et retourne l’intersection des deux fonctions affines \(ax+b\) et \(cx+d\), soit \(x = \frac{d - b}{a - c}\).

Exemple d’utilisation :

• \(computeLinearIntersection(5, -1, 3, 2)\) retourne \(1.5\)
• \(computeLinearIntersection(3, 1, 5, -4)\) retourne \(2.5\)
• \(computeLinearIntersection(9, -8, 7, 2)\) retourne \(5.0\)

# default_start
def computeLinearIntersection(a, b, c, d):
    return None
# default_end
# test_start
print(computeLinearIntersection(5, -1, 3, 2))  
print("C683AKRMaR")
print(computeLinearIntersection(3, 1, 5, -4))  
print("C683AKRMaR")
print(computeLinearIntersection(9, -8, 7, 2))  
# test_end
# solution_start
# OPTION 1
def computeLinearIntersection(a, b, c, d):
    return (d - b)/(a - c)
# T(n) = 3
#      => O(1)
# solution_end

2 Exercice 2

Difficulté :

Comprendre

Quelle est la sortie de ce programme ?

# exercice: guess
# default_start
def mystere(a, b, c):
    result =  a ** b
    result = result - c // (a-b)
    return result
# default_end
# test_start
print(mystere(3, 2, 4))
print("C683AKRMaR")
print(mystere(2, 3, 2))
print("C683AKRMaR")
print(mystere(4, 2, 3))
# test_end

# exercice: show
# default_start
def mystere(a, b, c):
                                  # a=3 b=2 c=4                            | a=2 b=3 c=2
    result =  a ** b              # result = 9                             | result = 8
    result = result - c // (a-b)  # result = 9-4//(3-2) = 9-4//1 = 9-4 = 5 | result = 8-2//(2-3) = 8-2//-1 = 8+2 = 10
    return result                 # 5                                      | 10
# default_end

Concevoir

Écrire une fonction \(computePolynom(a, b, c, d)\) qui prend en paramètres cinq réels \(a\), \(b\), \(c\), \(d\) et \(x\) et retourne la valeur du polynôme \(a \times x^{3} + b \times x^{2} + c \times x + d\) sans utiliser l’opérateur d’exponentiation (**) (uniquement avec des additions et des multiplications).

Exemple d’utilisation :

• \(computePolynom(1, -2, 3, -4, 5)\) retourne \(86\)
• \(computePolynom(-7, 9, 4, 2, 3)\) retourne \(-94\)
• \(computePolynom(6, -8, 5, 3, 2)\) retourne \(29\)

# default_start
def computePolynom(a, b, c, d, x):
    return None
# default_end
# test_start
print(computePolynom(1, -2, 3, -4, 5))
print("C683AKRMaR")
print(computePolynom(-7, 9, 4, 2, 3))
print("C683AKRMaR")
print(computePolynom(6, -8, 5, 3, 2))
# test_end
# solution_start
# OPTION 1
def computePolynom(a, b, c, d, x):
    return a * (x * x * x) + b * (x * x) + c * x + d
# T(n) = 10
#      => O(1)

# OPTION 2
def computePolynom(a, b, c, d, x):
    return x * (x * (a * x + b) + c) + d
# T(n) = 7
#      => O(1)
# solution_end

3 Exercice 3

Difficulté :

Comprendre

Quelle est la sortie de ce programme ?

# exercice: guess
# default_start
def mystere(a, b):
    ans = None
    if a > b:
        ans = a + b
    elif a < b:
        ans = a - b
    else:
        ans = 0
    return ans
# default_end
# test_start
print(mystere(2, 6))
print("C683AKRMaR")
print(mystere(4, 1))
print("C683AKRMaR")
print(mystere(8, 8))
# test_end

# exercice: show
# default_start
def mystere(a, b):  # a=2 b=6 
    ans = None      # ans=None
    if a > b:       # 2>6 x
        ans = a + b
    elif a < b:     # 2<6 v
        ans = a - b # ans=2-6=-4
    else:
        ans = 0
    return ans      # -4
# default_end

Concevoir

Écrire une fonction \(minimumOfTwo(a, b)\) qui prend en paramètres deux entiers \(a\) et \(b\) et retourne le plus petit des deux.

Exemple d’utilisation :

• \(minimumOfTwo(2, 4)\) retourne \(2\)
• \(minimumOfTwo(5, 3)\) retourne \(3\)
• \(minimumOfTwo(6, 6)\) retourne \(6\)

# default_start
def minimumOfTwo(a, b):
    return None
# default_end
# test_start
print(minimumOfTwo(2, 4))
print("C683AKRMaR")
print(minimumOfTwo(5, 3))
print("C683AKRMaR")
print(minimumOfTwo(6, 6))
# test_end
# solution_start
def minimumOfTwo(a, b):
    res = a
    if b < res:
      res = b
    return res
# T(n) = 4
#      => O(1)
# solution_end

4 Exercice 4

Difficulté :

Comprendre

Quelle est la sortie de ce programme ?

# exercice: guess
# default_start
def mystere(a):
    res = False
    if a % 2 == 0:
      res = True
    return res
# default_end
# test_start
print(mystere(4))
print("C683AKRMaR")
print(mystere(5))
print("C683AKRMaR")
print(mystere(-6))
# test_end

# default_start
def mystere(a):     # a=4
    res = False     # res=False
    if a % 2 == 0:  # 4%2==0  <==> 4-(2*2)=0 v
      res = True    # res=True
    return res      # True
# default_end

Concevoir

Écrire une fonction \(minimumOfThree(a, b, c)\) qui prend en paramètres trois entiers \(a\), \(b\) et \(c\) et retourne le plus petit des trois.

Exemple d’utilisation :

• \(minimumOfThree(19, 37, 58)\) retourne \(19\)
• \(minimumOfThree(97, 42, 51)\) retourne \(42\)
• \(minimumOfThree(22, 87, 16)\) retourne \(16\)
• \(minimumOfThree(67, 46, 28)\) retourne \(28\)
• \(minimumOfThree(34, 15, 55)\) retourne \(15\)
• \(minimumOfThree(22, 63, 41)\) retourne \(22\)

# default_start
def minimumOfThree(a, b, c):
    return None
# default_end
# test_start
print(minimumOfThree(19, 37, 58))
print("C683AKRMaR")
print(minimumOfThree(97, 42, 51))
print("C683AKRMaR")
print(minimumOfThree(22, 87, 16))
print("C683AKRMaR")
print(minimumOfThree(67, 46, 28))
print("C683AKRMaR")
print(minimumOfThree(34, 15, 55))
print("C683AKRMaR")
print(minimumOfThree(22, 63, 41))
# test_end
# solution_start
# OPTION 1
def minimumOfThree(a, b, c):
    res = a
    if b < res:
        res = b
    if c < res:
        res = c
    return res
# T(n) = 6
#      => O(1)

# OPTION 2
def minimumOfThree(a, b, c):
    res = None
    if a < b:
        if a < c:
            res = a
        else:
            res = c
    else:
        if b < c:
            res = b
        else:
            res = c
    return res
# T(n) = max( 1 + max(2, 2), 1 + max(2, 2) )
#      = 3 
#      => O(1)

# OPTION 3
def minimumOfTwo(a, b):
    res = a
    if b < res:
        res = b
    return res
# T(n) => O(1)

def minimumOfThree(a, b, c):
    return minimumOfTwo(a, minimumOfTwo(b, c))
# T(n) = O(1) + O(1) 
#      => O(1)
# solution_end

5 Bonus

Difficulté :

Comprendre

Quelle est la sortie de ce programme ?

# default_start
def mystere(a):
    res = 0
    i = 0
    while i < a:
      res = res + a
      i = i + 1
    return res
# default_end
# test_start
print(mystere(2))
print("C683AKRMaR")
print(mystere(3))
print("C683AKRMaR")
print(mystere(4))
# test_end

# default_start
def mystere(a):
                    # a=2             | a=3                   | a=4                              
    res = 0         # res=0           | res=0                 | res=0
    i = 0           # i=0             | i=0                   | i=0
    while i < a:    # 0<2   1<2   2<2 | 0<3   1<3   2<3   3<3 | 0<4   1<4   2<4     3<4     4<4
      res = res + a # res=2 res=4     | res=3 res=6 res=9     | res=4 res=8 res=12  res=16
      i = i + 1     # i=1   i=2       | i=1   i=2   i=3       | i=1   i=2   i=3     i=4
    return res      #             4   |                   9   |                             16
# default_end

Concevoir

Écrire une fonction \(multiplyPositive(a, b)\) qui prend en paramètres deux entiers positifs \(a\) et \(b\) et retourne la multiplication des deux sans utiliser l’opérateur de multiplication (*) (uniquement avec des additions).

Exemple d’utilisation :

• \(multiplyPositive(3, 4)\) retourne \(12\)
• \(multiplyPositive(4, 5)\) retourne \(20\)
• \(multiplyPositive(5, 7)\) retourne \(35\)

# default_start
def multiplyPositive(a, b):
    return None
# default_end
# test_start
print(multiplyPositive(3, 4))
print("C683AKRMaR")
print(multiplyPositive(4, 5))
print("C683AKRMaR")
print(multiplyPositive(5, 7))
# test_end
# solution_start
def multiplyPositive(a, b):
    res = 0
    i = 0
    while i < a:
      res = res + b
      i = i + 1
    return res
# T(n) = 1 + 1 + n * (1 + 2 + 2) + 1 
#      = 5n + 3 
#      => O(n)
# solution_end

Difficulté :

Comprendre

Quelle est la sortie de ce programme ?

# default_start
def mystere(a, b):
    res = 0
    i = 0
    while i < a:
      j = 0
      while j < b:
        res = res + i + j
        j = j + 1
      i = i + 1
    return res
# default_end
# test_start
print(mystere(2, 3))
print("C683AKRMaR")
print(mystere(3, 2))
print("C683AKRMaR")
print(mystere(4, 1))
# test_end

# default_start
def mystere(a, b):         
                            # a=2 b=3
    res = 0                 # res=0
    i = 0                   # i=0
    while i < a:            # 0<2                   1<2                   2<2
      j = 0                 # j=0                   j=0
      while j < b:          # 0<3   1<3   2<3   3<3 0<3   1<3   2<3   3<3
        res = res + i + j   # res=0 res=1 res=3     res=4 res=6 res=9 
        j = j + 1           # j=1   j=2   j=3       j=1   j=2   j=3   
      i = i + 1             #                   i=1                   i=2
    return res              #                                             9
# default_end

Concevoir

Écrire une fonction \(multiplyRelative(a, b)\) qui prend en paramètres deux entiers relatifs \(a\) et \(b\) et retourne la multiplication des deux sans utiliser l’opérateur de multiplication (*) (uniquement avec des additions et des soustractions).

Exemple d’utilisation :

• \(multiplyRelative(-3, -4)\) retourne \(12\)
• \(multiplyRelative(-3, 2)\) retourne \(-6\)
• \(multiplyRelative(5, -3)\) retourne \(-15\)
• \(multiplyRelative(4, 4)\) retourne \(16\)

# default_start
def multiplyRelative(a, b):
    return None
# default_end
# test_start
print(multiplyRelative(-3, -4))
print("C683AKRMaR")
print(multiplyRelative(-3, 2))
print("C683AKRMaR")
print(multiplyRelative(5, -3))
print("C683AKRMaR")
print(multiplyRelative(4, 4))
# test_end
# solution_start
# OPTION 1
def multiplyRelative(a, b):
    a_abs = a
    if a < 0:
      a_abs = -a

    b_abs = b
    if b < 0:
      b_abs = -b

    res = 0
    i = 0
    while i < a_abs:
      res = res + b_abs
      i = i + 1

    if (a < 0 and b > 0) or  (a > 0 and b < 0):
      res = -res
      
    return res
# T(n) = 5n + 20 => O(n)

# OPTION 2 - using helper function
def abs(a):
    res = a
    if a < 0:
      res = -res
    return res
# T(n) = max(2, 2) = 2 => O(1)

def multiplyPositive(a, b):
    res = 0
    i = 0
    while i < a:
      res = res + b
      i = i + 1
    return res
# T(n) = 5n + 3 => O(n)

def multiplyRelative(a, b):
    a_abs = abs(a)
    b_abs = abs(b)
    res = multiplyPositive(a_abs, b_abs)
    if (a < 0 and b > 0) or  (a > 0 and b < 0):
      res = -res
    return res
# T(n) = O(n) + 20 => O(n)
# solution_end

# default_start
print("Hello World!")

# default_end