#!/usr/bin/env python
# coding: utf-8

# In[1]:


from __future__ import division, print_function


# # 13 Boucle for

# Syntaxe :
# ```
# for ELEMENT in LISTE:       # ligne d'en-tête se terminant par ":"
#     INSTRUCTION #1          # bloc d'instructions indenté de 4 espaces
#     INSTRUCTION #2
#     INSTRUCTION #3
# ```

# # 14 Conditions if

# Syntaxe :
# ```
# if CONDITION_1:               # ligne d'en-tête se terminant par ":"
#     INSTRUCTION #1            # bloc d'instructions indenté de 4 espaces
#     INSTRUCTION #2
#     INSTRUCTION #3
# elif CONDITION_2:
#     INSTRUCTION #4            # bloc d'instructions indenté de 4 espaces
#     INSTRUCTION #5
#     INSTRUCTION #6
# else:
#     INSTRUCTION #7            # bloc d'instructions indenté de 4 espaces
#     INSTRUCTION #8
#     INSTRUCTION #9
# ```

# ### 14.5 Syntaxe compacte d'une assignation conditionnelle

# In[6]:


a = 6
b = 15
if a < b:
    m = a
else:
    m = b    


# In[7]:


m


# In[3]:


m = a if a < b else b


# In[5]:


m


# # 15 Fonctions def

# Syntaxe :
# ```
# def FONCTION(PARAMETRES):      # ligne d'en-tête se terminant par ":"
#     INSTRUCTION #1             # bloc d'instructions indenté de 4 espaces
#     INSTRUCTION #2
#     INSTRUCTION #3
# ```

# # 16 La boucle while

# La boucle `while` peut être utile lorsqu'on ne sait pas combien d'itérations on doit faire.

# Syntaxe :
# ```
# while CONDITION:            # ligne d'en-tête se terminant par ":"
#     INSTRUCTION #1          # bloc d'instructions indenté de 4 espaces
#     INSTRUCTION #2
#     INSTRUCTION #3
# ```

# Écrire un programme qui affiche les puissances de deux inférieures à un milliard.

# In[8]:


k = 1
while k < 10**9:
    print(k)
    k = k * 2


# Pour un nombre $x\geq1$, trouver l'unique valeur entière $n$ vérifiant $$2^{n−1} < x < 2^n,$$ c’est-à-dire le plus petit entier $n$ vérifiant $x < 2^n$.

# In[9]:


k = 1
n = 0
while k < 10**9:
    k = k * 2
    n = n + 1
print(n)


# ### 16.1 Interrompre une boucle avec break

# Écrire un programme qui affiche les puissances de deux inférieures à un milliard et arrêter le programme si une puissance termine par 88.

# In[11]:


k = 1
while True:
    k = 2*k
print(k)


# ### 16.2 Continuer une boucle à l'itération suivante avec continue

# Écrivez un programme qui calcule les 50 premiers termes de la table de multiplication par 13, mais n’affiche que ceux qui sont des multiples de 7.

# In[13]:


for i in range(10):
    if i == 7:
        continue
    print(i)


# # 17 Exemples (def + while + for + if)

# ### 17.1 Conjecture de Syracuse

# En mathématiques, on appelle suite de Syracuse une suite d'entiers naturels définie de la manière suivante :
# 
# On part d'un nombre entier plus grand que zéro ; s’il est pair, on le divise par 2 ; s’il est impair, on le multiplie par 3 et on ajoute 1. En répétant l’opération, on obtient une suite d'entiers positifs dont chacun ne dépend que de son prédécesseur.
# 
# Par exemple, à partir de 14, on construit la suite des nombres : 14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2... C'est ce qu'on appelle la suite de Syracuse du nombre 14.
# 
# https://fr.wikipedia.org/wiki/Conjecture_de_Syracuse
# 
# Écrire une fonction qui calcule la suite de Syracuse d'un nombre et retourne ce résultat sous la forme d'une liste.

# In[14]:


def syracuse(n):
    if n % 2 == 0:
        return n // 2
    else:
        return 3 * n + 1


# In[15]:


syracuse(13)


# In[16]:


syracuse(40)


# In[23]:


n = 1234097125
while n != 1:
    n = syracuse(n)
    print(n, end=' ')


# In[25]:


n = 1234097125
while n != 1:
    print(n, end=' ')
    n = syracuse(n)
print(n)


# In[ ]:





# ### 17.2 Énumérer les diviseurs d'un nombre entier

# In[28]:


n = 12
L = []
for i in range(1, n+1):
    reste = n % i
    if reste == 0:
        L.append(i)
print(L)


# In[36]:


from math import sqrt
def diviseurs(n):
    L = []
    sq = int(sqrt(n))
    for i in range(1, sq+1):
        reste = n % i
        if reste == 0:
            L.append(i)
            L.append(n//i)
    return L


# In[37]:


diviseurs(12)


# In[38]:


diviseurs(7)


# ### 17.3 Tester si un nombre est premier

# Écrire une fonction `est_premier(n)` qui renvoie `True` si `n` est premier et `False` sinon.

# In[39]:


def est_premier(n):
    div = diviseurs(n)
    return len(div) == 2


# In[40]:


est_premier(12)


# In[41]:


est_premier(13)


# In[45]:


def est_premier_2(n):
    sq = int(sqrt(n))
    for i in range(2, sq+1):
        if n % i == 0:
            return False
    return True


# In[46]:


est_premier_2(12)


# In[47]:


est_premier_2(13)


# ### 17.4 Trouver les nombres premiers jumeaux

# In[ ]:





# ### 17.5 Séparer une liste en deux selon la parité

# Écrivez un programme qui analyse un par un tous les éléments d’une liste de nombres pour générer deux nouvelles listes. L’une contiendra seulement les nombres pairs de la liste initiale, et l’autre les nombres impairs. 

# In[ ]:


L = [123, 535, 74764, 14379, 56452546, 2356, 3, 4, 8]


# ### 17.5 Séparer une liste en deux selon la parité

# Existe-t-il deux nombres entiers positifs x et y tels que $x^2 − 61y^2 = 1$ ?

# In[ ]:





# # 18 Autres structures de données

# In[ ]:





# ### 18.1 Tuples (type tuple)

# In[ ]:





# ### 18.2 Emballage et déballage d'un tuple

# In[ ]:





# ### 18.3 Dictionnaires (type dict)

# In[ ]:





# ### 18.4 Ensembles (type set)

# In[ ]:





# In[ ]: