Après avoir augmenté de 20%, le prix d’un article diminue de 10%. Est-il vrai que l’augmentation globale de son prix est 10% ?

Pour vérifier ou infirmer cette hypothèse, on peut écrire le programme suivant :

Le prix initial de l’article est arbitrairement fixé à 80 €, mais il peut facilement être changé grâce à une variable nommée « prix ». Pour introduire cette variable et lui affecter une valeur, on peut procéder ainsi :

• cliquer sur le menu Variables, puis choisir le bloc « fixer element à » et l’amener sur le plan de travail.
• cliquer sur le nom « element » de la variable, puis choisir « créer une variable » et nommer celle-ci « prix ».
• cliquer sur le menu Math, afin de sélectionner le bloc représentant les constantes (initialement 0) et de l’attacher au bloc « fixer ».
• remplacer la constante 0 par 80

Les deux blocs suivants, permettant d’augmenter et de diminuer la variable d’un pourcentage, illustrent l’apport de Sofus par rapport à la version standard de Blockly. Ils sont disponibles dans le sous-menu sofus du menu Math. Le dernier bloc, qui affiche la valeur de la variable « prix », est disponible dans le menu Entrées-sorties.

Il ne reste plus qu’à exécuter le programme (bouton Exécuter) qui affiche alors « 86.4 ». Ceci donne la réponse au problème : l’augmentation globale n’est pas de 10%, car sinon l’affichage serait 88 €.

On aurait aussi pu faire la vérification en transformant le programme Blockly en un programme Python :

• cliquer sur le bouton Editeur, ce qui fait apparaître la traduction Python dans un éditeur de texte et masque le programme Blockly
• cliquer sur le bouton Exécuter

Pour faire réapparaître le programme Blockly, il suffit de cliquer sur le bouton Blockly. Mais attention : si vous avez modifié le programme Python sans le sauvegarder, vous le perdrez.

Voici le code Python engendré :

prix = None
element = None
prix = 80
prix = prix + prix * 20 / float(100)
prix = prix - prix * 10 / float(100)
print(prix)

prix = 80
prix = prix + prix * 20 / float(100)
prix = prix - prix * 10 / float(100)
print(prix)

Est-ce que 50 augmentations successives de 1% donnent une augmentation globale

de 50% ?

de moins que 50% ?

de plus que 50% ?

Pour répondre à cette question, on peut fixer le prix initial à 100 €, puis répéter 50 augmentations de 1% à l’aide d’une boucle :

L’exécution du script montre que l’augmentation globale est d’environ 64,46% et le script Python obtenu, une fois épuré des premières lignes superflues, montre la syntaxe des boucles dans Python :

prix = 100
for count in range(50):
    prix = prix + prix * 1 / float(100)
print(prix)

De quel pourcentage doit-on alors augmenter 50 fois de suite un prix, pour que l’augmentation globale soit 50% ? Il est facile de remplacer dans le script Python 1 par d’autres nombres, jusqu’à ce que le résultat affiché soit proche de 150 € (au centime près par exemple).

Cet exercice s’inspire du Capes 2017 : l’aire d’un quart de disque est égale à l’intégrale ∫₀¹√(1-x²)dx.

Cela fournit un moyen de « calculer π » : on multiplie par 4 cette intégrale, après avoir évalué celle-ci par la méthode des rectangles. Cela permet également de montrer comment on programme une fonction dans Blockly ou dans Python.

Définition de la fonction avec Blockly

Il y a dans le menu Sous-programmes un bloc permettant de définir une fonction [1]. Après l’avoir introduit dans le plan de travail, il faut cliquer sur la roue dentée et ajouter un paramètre que nous nommerons « t » (et pas « x » [2]) :

Un nouveau clic sur la roue dentée permet de fermer la bulle. Pour finir, on fabrique une expression algébrique en cherchant et assemblant des blocs du menu Math, et on greffe cet arbre sur l’entrée « retourner » :

Utilisation de la fonction avec Blockly

La définition de la fonction « f » fait apparaître dans le menu Sous-programmes un nouveau bloc (« f avec t ») qu’il faut glisser dans le programme implémentant la méthode des rectangles :

Pour calculer l’intégrale de f entre 0 et 1 :

• on initialise la variable x à 0 (borne inférieure de l’intégrale) ;
• on initialise I (variable représentant l’intégrale) à 0 ;
• on boucle jusqu’à ce que x dépasse 1 (borne supérieure de l’intégrale) ; dans cette boucle :
  • on augmente I de f(x)×dx, et
  • on augmente x de dx.

En fait, dx est une constante mais elle est traitée ici comme une variable (histoire qu’elle ait un nom). Il ne reste plus qu’à quadrupler l’intégrale à la fin pour calculer une valeur approchée de π.

Python

L’export en Python donne ce script (une fois un peu allégé) :

import math

def f(t):
    return math.sqrt(1 - t ** 2)

dx = 0.0025
x = 0
I = 0
while not x >= 1:
    I = I + f(x) * dx
    x = x + dx
print(I * 4)

Maintenant on peut relancer le programme après avoir changé la valeur de dx, pour voir l’effet produit sur la vitesse d’exécution et la précision.

On peut comparer avec ce TP qui a été donné, sur ce sujet, en première année de BTS SN :

Et, « pour aller plus loin », on peut modifier le script pour qu’il utilise le module decimal et calcule sur un plus grand nombre de chiffres. Mais on ne peut pas l’exécuter avec l’interpréteur Python de SofusPy, car il ne gère pas ce module.

Sofus et Python ont autre chose en commun : la tortue.

Voici comment celle de Sofus peut dessiner une spirale logarithmique :

L’export en Python donne ce script (une fois un peu allégé) :

from turtle import * 
reset()
L = 40
for count in range(200):
    left(15)
    forward(L)
    L = L - L * 5 / float(100)

Si on exécute le programme par blocs, l’affichage de la spirale est instantané alors qu’on voit la tortue se déplacer en exécutant le code Python.