Project 3

project-3/regex/code/code1.py

@@ -0,0 +1,15 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    var_3 = 0
+    while var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+    return var_3
+    print(var_3)

project-3/regex/code/code10.py

@@ -0,0 +1,16 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 13
+    i = 7
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    n = 0
+    pi = 0
+    while n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    return pi
+    print(pi)

project-3/regex/code/code100.py

@@ -0,0 +1,6 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    print(sum)

project-3/regex/code/code1000.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if var_1 == 0:
+        return 4
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print((4*var_2))
+    return(4*var_2)

project-3/regex/code/code1001.py

@@ -0,0 +1,11 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    print(4*pi)

project-3/regex/code/code1002.py

@@ -0,0 +1,10 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    print(4*pi)

project-3/regex/code/code1003.py

@@ -0,0 +1,10 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_1) / ((2*var_1)+1))
+    print(4*var_2)

project-3/regex/code/code1004.py

@@ -0,0 +1,5 @@
+def approx_pi(i):        
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    print(4*pi)

project-3/regex/code/code1005.py

@@ -0,0 +1,6 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)
+    print((4*var_2))

project-3/regex/code/code1006.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print(4*var_2)

project-3/regex/code/code1007.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)

project-3/regex/code/code1008.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+        return(4*var_2)

project-3/regex/code/code1009.py

@@ -0,0 +1,6 @@
+def approx_pi(var_1):        
+    var_1 = 2
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)

project-3/regex/code/code101.py

@@ -0,0 +1,6 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1010.py

@@ -0,0 +1,6 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print((4*var_2))
+    return(4*var_2)

project-3/regex/code/code1011.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)

project-3/regex/code/code1012.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)

project-3/regex/code/code1013.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        return(4*pi)

project-3/regex/code/code1014.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    print(4*pi)

project-3/regex/code/code1015.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    return(4*pi)

project-3/regex/code/code1016.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    i = 16
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    return(4*pi)

project-3/regex/code/code1017.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    return(4*pi)
+    print((4*pi))

project-3/regex/code/code1018.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    print((4*pi))
+    return(4*pi)

project-3/regex/code/code1019.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    return(4*pi)

project-3/regex/code/code102.py

@@ -0,0 +1,6 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1020.py

@@ -0,0 +1,7 @@
+def approx_pi(var_1):        
+    if var_1 == 0:
+        print(4)
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    return(4*var_2)

project-3/regex/code/code1021.py

@@ -0,0 +1,22 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if var_1 == 0:
+        print(4)
+    else:
+        if var_1 == 1:
+            print(2.666666666)
+        else:
+            if var_1 == 2:
+                print(3.46666666)
+            else:
+                if var_1 == 3:
+                    print(2.8952381)
+                else:
+                    var_2 = 0
+                    for var_3 in range(var_1+1) :
+                        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+                    print(4*var_2)

project-3/regex/code/code1022.py

@@ -0,0 +1,23 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 11
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        print(4)
+    else:
+        if i == 1:
+            print(2.666666666)
+        else:
+            if i == 2:
+                print(3.46666666)
+            else:
+                if i == 3:
+                    print(2.8952381)
+                else:
+                    pi = 0
+                    for j in range(i+1) :
+                        pi += (((-1)**j) / ((2*j)+1))
+                    print(4*pi)

project-3/regex/code/code1023.py

@@ -0,0 +1,22 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        print(4)
+    else:
+        if i == 1:
+            print(2.666666666)
+        else:
+            if i == 2:
+                print(3.46666666)
+            else:
+                if i == 3:
+                    print(2.8952381)
+                else:
+                    pi = 0
+                    for j in range(i+1) :
+                        pi += (((-1)**i) / ((2*i)+1))
+                    print(4*pi)

project-3/regex/code/code1024.py

@@ -0,0 +1,17 @@
+def approx_pi(i):        
+    if i == 0:
+        print(4)
+    else:
+        if i == 1:
+            print(2.666666666)
+        else:
+            if i == 2:
+                print(3.46666666)
+            else:
+                if i == 3:
+                    print(2.8952381)
+                else:
+                    pi = 0
+                    for j in range(i+1) :
+                        pi += (((-1)**j) / ((2*j)+1))
+                    print(4*pi)

project-3/regex/code/code1025.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    print(sum)
+    return sum
+    print(sum)

project-3/regex/code/code1026.py

@@ -0,0 +1,12 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_1)/((2*var_1)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1027.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1028.py

@@ -0,0 +1,12 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1029.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum
+    print(sum)
+    print(sum)

project-3/regex/code/code103.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    print(sum)
+    return sum

project-3/regex/code/code1030.py

@@ -0,0 +1,12 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    print(sum)
+    print(sum)

project-3/regex/code/code1031.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 11
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1032.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1033.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1034.py

@@ -0,0 +1,12 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if var_1 == 0:
+        return 4
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_1) / ((2*var_1)+1))
+        return(4*var_2)

project-3/regex/code/code1035.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1036.py

@@ -0,0 +1,12 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1037.py

@@ -0,0 +1,12 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        print(4*pi)

project-3/regex/code/code1038.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        print((4*pi))
+        return(4*pi)

project-3/regex/code/code1039.py

@@ -0,0 +1,12 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 9
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    ### VOTRE REPONSE
+    var_2 = 0
+    for var_3 in range(var_1+1):
+        var_2+=4*((-1)**var_3/(2*var_3+1))
+    print(var_2)

project-3/regex/code/code104.py

@@ -0,0 +1,6 @@
+def approx_pi(var_1):        
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_1)/((2*var_1)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1040.py

@@ -0,0 +1,11 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    ### VOTRE REPONSE
+    var_2 = 0
+    for var_3 in range(var_1+1):
+        var_2+=4*((-1)**var_3/(2*var_3+1))
+    print(var_2)

project-3/regex/code/code1041.py

@@ -0,0 +1,11 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    ### VOTRE REPONSE
+    var_2 = 0
+    for var_3 in range(var_1+1):
+        var_2+=4*((-1)**var_3/(2*var_3+1))
+    print(var_2)

project-3/regex/code/code1042.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1):
+        var_2+=4*((-1)**var_3/(2*var_3+1))
+    print(var_2)

project-3/regex/code/code1043.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1044.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**x)/((2*x)+1)
+    sum=4*sum
+    print(sum)

project-3/regex/code/code1045.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 6
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**x)/((2*x)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1046.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 18
+    var_1 = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_2)/((2*var_2)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1047.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**x)/((2*x)+1)
+    sum=4*sum
+    print(sum)
+    return sum

project-3/regex/code/code1048.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**x)/((2*x)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1049.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        
+    i = 18
+    i = 5
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**x)/((2*x)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code105.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    i = 1
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum

project-3/regex/code/code1050.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1051.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    return(4*pi)

project-3/regex/code/code1052.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    return(4*pi)
+    print((4*pi))

project-3/regex/code/code1053.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    print((4*pi))
+    return(4*pi)

project-3/regex/code/code1054.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    print(4*pi)

project-3/regex/code/code1055.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if var_1 == 0:
+        return 4
+        print(4)
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_1) / ((2*var_1)+1))
+    return(4*var_2)

project-3/regex/code/code1056.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    return(4*pi)

project-3/regex/code/code1057.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 0
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+    return(4*pi)

project-3/regex/code/code1058.py

@@ -0,0 +1,11 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 19
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print(4*var_2)

project-3/regex/code/code1059.py

@@ -0,0 +1,5 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print(4*var_2)

project-3/regex/code/code106.py

@@ -0,0 +1,7 @@
+def approx_pi(i):        
+    sum=0
+    for x in range (0,i+1):
+        sum+=((-1)**i)/((2*i)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1060.py

@@ -0,0 +1,10 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print(4*var_2)

project-3/regex/code/code1061.py

@@ -0,0 +1,10 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+    print(4*var_2)

project-3/regex/code/code1062.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+        return pi

project-3/regex/code/code1063.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    print(pi)

project-3/regex/code/code1064.py

@@ -0,0 +1,8 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    var_3 = 0
+    if var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+    return var_3

project-3/regex/code/code1065.py

@@ -0,0 +1,9 @@
+def approx_pi(i):        
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    return pi
+    print(pi)

project-3/regex/code/code1066.py

@@ -0,0 +1,9 @@
+def approx_pi(i):        
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    print(pi)
+    return pi

project-3/regex/code/code1067.py

@@ -0,0 +1,8 @@
+def approx_pi(i):        
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    return pi

project-3/regex/code/code1068.py

@@ -0,0 +1,9 @@
+def approx_pi(i):        
+    i = 7
+    n = 0
+    pi = 0
+    if n <= i :
+        j = ((-1)**n)/((2*n) +1)
+        pi += 4*j
+        n+=1
+    return pi

project-3/regex/code/code1069.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        return(4*pi)

project-3/regex/code/code107.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 2
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        print(4)
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    return(4*pi)

project-3/regex/code/code1070.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 0
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        return(4*pi)

project-3/regex/code/code1071.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        return(4*pi)

project-3/regex/code/code1072.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**i) / ((2*i)+1))
+        return(4*pi)

project-3/regex/code/code1073.py

@@ -0,0 +1,14 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        print(4)
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        return(4*pi)

project-3/regex/code/code1074.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if var_1 == 0:
+        return 4
+    var_2 = 0
+    for var_3 in range(var_1+1) :
+        var_2 += (((-1)**var_3) / ((2*var_3)+1))
+        return(4*var_2)

project-3/regex/code/code1075.py

@@ -0,0 +1,13 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 15
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+        print(4*pi)

project-3/regex/code/code1076.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    var_3 = 0
+    if var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+        return var_3

project-3/regex/code/code1077.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    var_3 = 0
+    if var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+    return var_3

project-3/regex/code/code1078.py

@@ -0,0 +1,14 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 2
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    var_3 = 0
+    if var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+    return var_3

project-3/regex/code/code1079.py

@@ -0,0 +1,14 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    var_3 = 0
+    if var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+    return var_3
+    print(var_3)

project-3/regex/code/code108.py

@@ -0,0 +1,15 @@
+def approx_pi(i):        # NE PAS EFFACER CETTE LIGNE
+    i = 2
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    if i == 0:
+        return 4
+        print(4)
+        print(4)
+    pi = 0
+    for j in range(i+1) :
+        pi += (((-1)**j) / ((2*j)+1))
+    return(4*pi)

project-3/regex/code/code1080.py

@@ -0,0 +1,14 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    var_3 = 0
+    if var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+    print(var_3)
+    return var_3

project-3/regex/code/code1081.py

@@ -0,0 +1,8 @@
+def approx_pi(var_1):        
+    var_2 = 0
+    var_3 = 0
+    if var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+    return var_3

project-3/regex/code/code1082.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    var_2 = 0
+    var_3 = 0
+    if var_2 <= var_1 :
+        var_4 = ((-1)**var_2)/((2*var_2) +1)
+        var_3 += 4*var_4
+        var_2+=1
+    print(var_3)

project-3/regex/code/code1083.py

@@ -0,0 +1,12 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_2)/((2*var_2)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1084.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_2)/((2*var_2)+1)
+    sum=4*sum
+    print(sum)
+    return sum
+    print(sum)

project-3/regex/code/code1085.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    var_1 = 9
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_2)/((2*var_2)+1)
+    sum=4*sum
+    return sum
+    print(sum)

project-3/regex/code/code1086.py

@@ -0,0 +1,12 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_2)/((2*var_2)+1)
+    sum=4*sum
+    print(sum)
+    print(sum)

project-3/regex/code/code1087.py

@@ -0,0 +1,13 @@
+def approx_pi(var_1):        # NE PAS EFFACER CETTE LIGNE
+    """
+    @pre:   i est un entier tel que i >= 0
+    @post:  retourne une estimation de pi en sommant
+            les i + 1 premiers termes de la série de Gregory-Leibniz
+    """
+    sum=0
+    for var_2 in range (0,var_1+1):
+        sum+=((-1)**var_2)/((2*var_2)+1)
+    sum=4*sum
+    return sum
+    print(sum)
+    print(sum)