Exercice type 2 - 2014

# -*- coding: utf-8 -*-
# Katia Barré - Lycée Lesage Vannes

#--- question 1 ----------------------------------------------------------------
print
('\n --- Question 1 --- ')

# --- création de la matrice M des distances du graphe G ---
M
= [[0, 9, 3, -1, 7],[9, 0, 1, 8, -1],[3, 1, 0, 4, 2],[-1, 8, 4, 0, -1],[7, -1, 2, -1, 0]]

# --- affichage de la matrice M ---
print
('Matrice M des distances du graphe G : ')
for
ligne in M:
   
for coeff in ligne:
       
print('{:>2}'.format(coeff), end = ' ')
   
print()
print
()

#--- question 2 ----------------------------------------------------------------
print
('\n --- Question 2 --- ')

voisins_4 = []
for
j in range(5):
   
if M[4][j] > 0:
        voisins_4
.append(j)

print('Liste des voisins du sommet 4 :', voisins_4)

#--- question 3 ----------------------------------------------------------------
print
('\n --- Question 3 --- ')

def voisin(i):
   
"""

    i : entier sommet de [0,4]
    retourne la liste vois_i des voisins du sommet i

   
"""

    global M
    vois_i
= []
   
for j in range(5):
       
if M[i][j] > 0:
            vois_i
.append(j)
   
return vois_i

for i in range(5):
   
print('Liste des voisins du sommet {} : {}'.format(i, voisin(i)))

#--- question 4 ----------------------------------------------------------------
print
('\n --- Question 4 --- ')

def degre(i):
   
"""

    i : entier sommet de [0,4]
    retourne le nombre de voisins du sommet i

   
"""
   
global M
    deg_i
= 0
   
for j in range(5):
       
if M[i][j] > 0:   # ou bien deg_i += (M[i][j] > 0) - confusion bool <-> int
            deg_i
+= 1

    return deg_i

for i in range(5):
   
print('Degré du sommet {} : {}'.format(i, degre(i)))

#--- question 5 ----------------------------------------------------------------
print
('\n --- Question 5 --- ')

def longueur(L):
   
"""

    L : liste de sommets
    renvoie la longueur du trajet décrit par la liste -si possible -

   
"""
   
global M
    n
= len(L)

    if n <= span=""> 1:
       
return -1
    long
= 0
   
for i in range(n-1):
        dist
= M[L[i]][L[i+1]]
       
if dist > 0:
            long
+= dist
       
else :
           
return -1
   
return long

def affiche_longueur(L):
   
print('Longueur du trajet de {} : {}'.format(L, longueur(L)))

affiche_longueur([0])
affiche_longueur
([0,0])
affiche_longueur
([0,1,0])
affiche_longueur
([0,1,4,0])
affiche_longueur
([0,1,3,2,4])

affiche_longueur([0,1,4])

 

--- Question 1 ---

Matrice M des distances du graphe G :

 0  9  3 -1  7
 9  0  1  8 -1
 3  1  0  4  2
-1  8  4  0 -1
 7 -1  2 -1  0

 

 

 --- Question 2 ---

Liste des voisins du sommet 4 : [0, 2]

 --- Question 3 ---

Liste des voisins du sommet 0 : [1, 2, 4]
Liste des voisins du sommet 1 : [0, 2, 3]
Liste des voisins du sommet 2 : [0, 1, 3, 4]
Liste des voisins du sommet 3 : [1, 2]
Liste des voisins du sommet 4 : [0, 2]

 --- Question 4 ---

Degré du sommet 0 : 3
Degré du sommet 1 : 3
Degré du sommet 2 : 4
Degré du sommet 3 : 2
Degré du sommet 4 : 2

--- Question 5 ---

Longueur du trajet de [0] : -1
Longueur du trajet de [0, 0] : -1
Longueur du trajet de [0, 1, 0] : 18
Longueur du trajet de [0, 1, 4, 0] : -1
Longueur du trajet de [0, 1, 3, 2, 4] : 23
Longueur du trajet de [0, 1, 4] : -1

Exercice type 1 - 2014

# -*- coding: utf-8 -*-
# Katia Barré - Lycée Lesage Vannes

import matplotlib.pyplot as plt
import
scipy.integrate as integ

#--- question 1 ----------------------------------------------------------------
print('\n --- Question 1 --- ')

#------------- lecture des données -------------

fichier = open('data/ex_001.csv', 'r')

LX
= []       # liste des abscisses
LY
= []       # liste des ordonnées

for ligne in fichier:
    donnee
= ligne.split(';')
   
LX.append(float(donnee[0]))
    LY
.append(float(donnee[1]))

fichier.close()

#------------- affichage des données ------------
print
('abscisses x | ordonnées y ')
print
('-' * 25)

for i in range(len(LX)):
   
print('{}         | {}'.format(LX[i], LY[i]))
print
()

#--- question 2 ----------------------------------------------------------------
print('\n --- Question 2 --- ')

plt.plot(LX, LY, marker = 'D')
plt
.xlabel('$x$')
plt
.ylabel('$y$')
plt
.grid()
plt
.show()

#--- question 3 ----------------------------------------------------------------
print('\n --- Question 3 --- ')

def trapeze(x, y):
   
"""

    x et y : deux listes numériques de même longueur n
    renvoie la somme des (x_i-x_(i-1)) * (y_i + y_(i-1)) / 2 pour 0 < i < n

    """

    trap
= 0           # contiendra la somme voulue
   
for i in range(1,len(x)):
       
trap += (x[i] - x[i-1]) * (y[i] + y[i-1]) / 2
   
return trap

   '''
   # que nous pourrions remplacer par :

    
return sum(x[i] - x[i-1]) * (y[i] + y[i-1]) / 2 for i in range(1,n))
  
'''

print('Valeur de trapeze(LX, LY) : ')
print
(trapeze(LX, LY), end = '\n\n')

#--- question 4 ----------------------------------------------------------------
print('\n --- Question 4 --- ')

print('Valeur avec trapz de scipy.integrate :')

print(integ.trapz(LY, LX))

---- Question 1 ---

abscisses x | ordonnées y
-------------------------
0.0         | 1.00988282142
0.1         | 1.07221264497
0.2         | 1.11111111111
0.3         | 1.21212212121
0.4         | 1.0101010101
0.5         | 0.99999991111
0.6         | 0.95000011111
0.7         | 0.82323232323
0.8         | 0.66666666666
0.9         | 0.42323232323
1.0         | 0.55555555555
1.1         | 0.88888888888
1.2         | 0.96969696969
1.3         | 1.22222222222
1.4         | 1.55555555555

 --- Question 2 ---

--- Question 3 ---

Valeur de trapeze(LX, LY) :
1.3187761047555

 --- Question 4 ---

Valeur avec trapz de scipy.integrate :
1.31877610476

Exercice type 0 - 2014

# -*- coding: utf-8 -*-
# Katia Barré - Lycée Lesage Vannes

 

#--- question 1 ----------------------------------------------------------------
print
('\n --- Question 1 --- ')
n
= 1234
q
= 1234 // 10   # quotient de n par 10
r
= 1234 % 10    # reste de n par 10 = chiffre des unités
q1
= q // 10     # reste de q par 10
r1
= q % 10      # reste de q1 par 10 = chiffre des dizaines

print('n = {}, q = {}, r = {}, q1 = {}, r1 = {}'.format(n, q, r, q1, r1))
print
('Les restes successifs contiendront les chiffres de n')

#--- question 2 ----------------------------------------------------------------
print
('\n --- Question 2 --- ')

s = r**3 + r1**3           # contiendra la somme des cubes des chiffres
q2
= q1 // 10
s
+= (q1 % 10)**3
s
+= (q2 % 10)**3

print('Somme des cubes des chiffres de {} : {}'.format(n, s))

#--- question 3 ----------------------------------------------------------------
print
('\n --- Question 3 --- ')

def somcube(n):
   
"""

    n : entier naturel
    renvoie la somme des cubes des chiffres de l'écriture décimale de n

    """

    s
= 0   # contiendra la somme des cubes des chiffres
    q
= n   # contiendra les quotients successifs par  10
           
# la boucle stoppe lorsque q = 0
   
while q:
        s
+= (q % 10)**3
        q
= q // 10            # que l'on peut écrire q //= 10
   
return s

print('Somme des cubes de 1234 : ', somcube(1234))

#--- question 4 ----------------------------------------------------------------
print
('\n --- Question 4 --- ')

maxi = 1000
print
('Les chiffres inférieurs à  {} égaux à la somme des cubes de leurs\
chiffres :'.format(maxi))
for
i in range(maxi + 1):
   
if i == somcube(i):
       
print(i, end = ', ')
print
()

#--- question 5 ----------------------------------------------------------------
print
('\n --- Question 5 --- ')

def somcube2(n):
   
"""

    n : entier naturel
    renvoie la somme des cubes des chiffres de l'écriture décimale de n

    """

    chiffres_str
= str(n)      # chaîne de caractères des chiffres de n
    somme
= 0
   
for c in chiffres_str:
        somme
+= int(c)**3
   
return somme         # ou bien : return sum(int(c)**3 for c in chiffres_str )

print('Somme des cubes de 1234 : ', somcube(1234))

--- Question 1 ---

n = 1234, q = 123, r = 4, q1 = 12, r1 = 3
Les restes successifs contiendront les chiffres de n

 --- Question 2 ---

Somme des cubes des chiffres de 1234 : 100

 --- Question 3 ---

Somme des cubes de 1234 :  100

 --- Question 4 ---

Les chiffres inférieurs à  1000 égaux à la somme des cubes de leurs chiffres :

0, 1, 153, 370, 371, 407,

--- Question 5 ---

Somme des cubes de 1234 :  100

INFORMATIQUE  en  PTSI - PT

Le nouveau programme 2013 fait apparaître une nouvelle discipline: l'Informatique.

Horaires

PTSI : 1h de cours + 1h de TP par semaine toute l'année.
PT : 1h de cours + 1h de TD au premier semestre.

Objectifs de la formation

logoinfopt

  • Analyser et modéliser un problème, une situation.
  • Imaginer et concevoir une solution algorithmique modulaire, utilisant des méthodes de programmation, des structures de données appropriées pour le problème étudié.
  • Traduire un algorithme dans un langage de programmation moderne et généraliste (Python).
  • Spécifier rigoureusement les modules ou fonctions.
  • Evaluer, contrôler, valider des algorithmes et des programmes.
  • Communiquer à l'écrit ou à l'oral, un problématique, une solution ou un algorithme, une documentation.

Capacités développées

Algorithmique

Tours de Hanoï

  • Comprendre un algorithme et expliquer ce qu'il fait.
  • Modifier un algorithme existant pour obtenir un résultat différent.
  • Concevoir un algorithme répondant à un problème précisément posé.
  • Expliquer le fonctionnement d'un algorithme.
  • Ecrire des instructions conditionnelles avec alternatives, éventuellement imbriquées.
  • Justifier qu'une itération - ou boucle - produit l'effet attendu au moyen d'un invariant.
  • Démontrer qu'une boucle se termine effectivement.
  • S'interroger sur l'efficacité temporelle d'un algorithme.
  • Comprendre le fonctionnement d'un algorithme récursif et l'utilisation de la mémoire lors de son exécution.
  • Comprendre les avantages et défauts respectifs des approches récursive et itérative.
  • S'interroger sur l'efficacité algorithmique temporelle d'un algorithme.
  • Distinguer par leurs complexités deux algorithmes résolvant un même problème.

Programmation en Python

  • Choisir un type de données en fonction d'un problème à résoudre.

sierpinski

  • Concevoir l'en-tête - ou spécification - d'une fonction, puis la fonction elle-même.
  • Traduire un algorithme dans un langage de programmation (Python).
  • Gérer efficacement un ensemble de fichiers correspondant à des versions successives d'un fichier source.
  • Rechercher une information au sein d'une documentation en ligne, analyser des exemples fournis dans cette documentation.
  • Documenter une fonctions, un programme plus complexe.

Ingénérie numérique et simulation - Python ou Scilab

  • Réaliser un programme complet structuré allant de la prise en compte de données expérimentales à la mise en forme des résultats permettant de résoudre un problème scientifique donné.

lorenz

  • Etudier l'effet d'une variation des paramètres sur le temps de calcul, sur la précision des résultats, sur la forme des solutions pour des programmes d'ingénierie numérique choisis, tout en contextualisant l'observation du temps de calcul par rapport à la complexité algorithmique de ces programmes.
  • Utiliser les bibliothèques de calcul standard pour résoudre un problème scientifique mis en équation lors des enseignements de chimie, physique, mathématiques, sciences industrielles et de l'ingénieur.
  • Utiliser les bibliothèques standard pour afficher les résultats sous forme graphique.
  • Tenir compte des aspects pratiques comme l'impact des erreurs d'arrondi sur les résultats, le temps de calcul ou le stockage en mémoire.

Initiation aux bases de données relationnelles

  • Utiliser une application offrant une interface graphique pour créer une base de données et l'alimenter.
  • Utiliser une application offrant une interface graphique pour lancer des requêtes sur une base de données.
  • Distinguer les rôles respectifs des machines client, serveur, et éventuellement serveur de données.
  • Traduire dans le langage de l'algèbre relationnelle des requêtes écrites en langage courant.
  • Concevoir une base constituée de plusieurs tables, et utiliser les jointures symétriques pour effectuer des requêtes croisées.

   Vidéos : Gérer une base de données avec MySQL Workbench

 Exercices-type 2014 de l'Oral Banque PT - Mathématiques / Informatique

Demandez le programme !

Programme officiel au format pdf

 

Search