Turing β-0.10

by Tom Niget//Versions

Turing β-0.10 est disponible !

Changelog
  • Corrections de bugs
    • Correction d’un débordement de type entier NumPy
    • L’utilisateur peut maintenant saisir une entrée avant la fin de l’animation
    • L’évaluation dangereuse est maintenant désactivée par défaut
    • La fonction d’intervalle inclusif est maintenant inclusive
    • L’opérateur NON ne marchait pas dans certains cas
    • La fonction arrondir() vérifiait les types de manière incorrecte
    • Le wrapper de l’entrée passe maintenant les kwargs
    • Le fix du bug de Qt ne marchait pas tout le temps
  • Nouveautés
    • Fonctions sans paramètres en pseudocode
    • Fonction de choix aléatoire de liste
    • Fonction de gestion de casse (majuscule, minuscule)
    • Paramètre “Texte seulement” pour l’instruction Entrée
    • Afficher explicitement les retours à la ligne après les instructions Afficher
    • Les chaînes der caractères peuvent maintenant être comparées
    • Nouvelle page d’accueil
    • Les onglets sont maintenant changés automatiquement lors de la création ou de l’ouverture d’un fichier
    • Le bouton “Effacer récents” fonctionne
    • Le code Python converti est maintenant reformatté automatiquement
Code source

Conception d’un jeu : Le juste prix

by Léo Joly//Débutants, Tutoriels

Bienvenue dans ce tutoriel sur comment créer un Juste Prix en utilisant le mode Algorithme de notre logiciel Turing !

Ne nous attardons pas sur les formalités et commençons les explications.

C’est Parti :

Nous allons donc dès à présent créer un nouveau fichier et entrer dans l’onglet “Algorithme”. Une fois cela fait, il faut créer une variable qui va s’approprier la valeur d’un nombre entier aléatoire. Pour cela il existe exactement ce qu’il nous faut :

image provenant de la bibliothèque des fonction mise à votre disposition dans le logiciel

En appuyant sur Affecter une variable, on crée une nouvelle variable Prix à laquelle on donne la valeur randint(0, 1000) :

De plus il faut Ajouter une variable qui va demander a l’utilisateur d’entrer un nombre pour vérifier qu’il s’approche du prix. On défini alors la variable que l’on appellera X ici, puis on demande a l’utilisateur de la saisir :

Maintenant il faut vérifier si la variable saisie par l’utilisateur est plus grande, plus petite ou égale au prix, pour cela nous allons cliquer sur l’onglet Blocs à droite et sélectionner Bloc Si. On va vérifier la condition si x< Prix en premier lieu et ajouter un texte qui signale a l’utilisateur que X est trop petit :

On va utiliser le Bloc Sinon pour directement vérifier que X > Prix :

Tout cela est bien gentil mais lorsqu’on essais notre programme, on s’aperçoit qu’il ne vérifie le prix qu’une seule fois, il faut alors ajouter une boucle infinie a notre logiciel qui s’arrêtera uniquement si X = Prix : La boucle Tant que est idéale pour ça :

Attention !!! Ne pas oublier d’indenter, ces’t à dire d’utiliser le bouton   sur saisir et les 2 blocs Si et SINON pour les insérés dans la boucle TANT QUE !!

Par contre il y a un problème, quand on exécute le programme on a une erreur qui dit que X n’existe pas, parce que au départ la boucle vérifie “Tant Que X != Prix” or X n’existe pas encore car il n’est créé qu’à l’intérieur de la boucle. Il faut donc « initialiser » X au début en lui donnant une valeur impossible pour que la boucle s’exécute au moins une fois.

Notre programme est presque terminé, il faut ajouter un texte montrant que le joueur a gagné et une varible qui compte le nombre d’essais :

Bravo !!! Vous avez terminer ce jeu du juste prix, voici tout de même la sauvegarde du fichier et n’hésitez pas a créer d’autres jeux encore plus incroyables et à suivre d’autres tuto sur notre site !

Juste Prix

Vive Turing !!!

Écriture d’un jeu du pendu

by Tom Niget//Confirmés, Tutoriels

Dans ce tutoriel, nous aborderons l’écriture d’un jeu assez connu : le pendu. Pour rappel, le jeu du pendu consiste à trouver, lettre par lettre, un mot qui n’est pas révélé au joueur, et ce avec un nombre limité d’essais. Il est généralement accompagné d’un petit dessin mais nous nous limiterons à du texte ici pour des raisons de simplicité.

Attention : ce tutoriel présuppose que vous avez déjà des connaissances basiques en programmation (notion de variable, de boucle, etc).

Le meilleur moyen d’écrire un programme rapidement et efficacement est de l’écrire étape par étape, de manière modulaire.

Ici, on veut faire un jeu du pendu.

Commençons d’abord par le plus important : les mots. Pour faire un pendu, il faut une liste de mots et un mot choisi au hasard.

mots = [
    "BONJOUR", 
    "ORDINATEUR", 
    "CLAVIER", 
    "SOURIS", 
    "CHEVAL", 
    "OISEAU", 
    "CHIEN"
]

mot = choix(mots)

Le code ci-dessus crée une liste de mots puis choisit un mot au hasard à l’aide de la fonction choix.

Ensuite, on veut afficher une version « vide » du mot au départ, ou en d’autres termes afficher des _ à la place des lettres.

saisi = ["_"] * taille(mot)

Le code ci-dessus crée une liste contenant un tiret-bas puis la « multiplie » par la longueur du mot. Ici, cela va donner une liste contenant autant d’éléments que de lettres dans le mot, et où chaque élément est un tiret-bas. On se servira de cette liste pour stocker l’état actuel de la partie.

Il faut également stocker le nombre d’essais restants.

essais = 10

Jusqu’ici, ça donne ça :

mots = [
    "BONJOUR", 
    "ORDINATEUR", 
    "CLAVIER", 
    "SOURIS", 
    "CHEVAL", 
    "OISEAU", 
    "CHIEN"
]

mot = choix(mots)

saisi = ["_"] * taille(mot)

essais = 10

Maintenant, on va commencer le code du jeu. Le jeu consiste en une répétition d’actions :

  • Afficher le mot « actuel » et le nombre d’essais restants
  • Demander une lettre
  • Vérifier si la lettre est bonne
  • Répéter

En code, cela donne ceci :

while True:
    # afficher le mot
    # demander une lettre
    # vérifier la lettre

Procédons étape par étape. D’abord, afficher le mot et le nombre d’essais :

print(" ".join(saisi))

Le code " ".join(...) permet d’afficher tous les éléments, séparés par des espaces.

print("%d essais restants" % essais)

Le %d indique qu’il faut insérer ici le nombre d’essais.

Ensuite, on veut demander une lettre.

lettre = input("? ")

Le programme affichera un point d’interrogation puis demandera à l’utilisateur de saisir une lettre.

Pour terminer, on doit vérifier si la lettre est ou non dans le mot à trouver. Pour cela, on va vérifier, pour chaque lettre du mot, si celle-ci est identique à la lettre saisie par l’utilisation, auquel cas on remplace le _ par la lettre en question.

for i in range(taille(mot)):
    if mot[i] == lettre:
        saisi[i] = lettre

Voici le code actuel de la boucle :

while True:
    print(" ".join(saisi))
    print("%d essais restants" % essais)

    lettre = input("? ")

    for i in range(taille(mot)):
        if mot[i] == lettre:
            saisi[i] = lettre

On se rapproche du but, mais il reste encore quelques problèmes à régler :

  • Il faut que le jeu s’arrête si on dépasse les 10 essais ou si on trouve le mot
  • Il faut que ça fonctionne peu importe si l’utilisateur écrit en majuscules ou en minuscules
  • Il faut que ça affiche le mot si l’utilisateur perd

Procédons dans l’ordre. D’abord, arrêter le jeu si on dépasse les 10 essais, et afficher le mot.

while True:
    if essais <= 0:
        print("Vous avez perdu !")
        print("Le mot était : " + mot)
        break
    
    ...

break sert à sortir de la boucle while.

Il faut aussi enlever 1 au nombre d’essais restants, mais si et seulement si l’utilisateur entre une lettre qui n’est pas dans le mot.

while True:
    ...

    if lettre not in mot:
        essais -= 1

Le code est assez explicite, not in signifie littéralement « pas dans » en anglais. Si la lettre n’est pas dans le mot, c’est une faute.

Ensuite, il faut arrêter le jeu si on a trouvé le mot.

while True:
    ...

    if saisi == list(mot):
        print("Vous avez gagné !")
        break
    
    ...

Ici, saisi est une liste tandis que mot est une chaîne de caractères, il faut donc convertir l’un ou l’autre (on ne peut comparer deux objets que s’ils sont du même type).

On veut aussi ignorer la casse de l’entrée (pour que ça marche avec les majuscules et les minuscules). Vu que nos mots sont en majuscule, on n’a qu’à convertir ce que l’utilisateur tape en majuscules :

while True:
    ...

    lettre = maju(input("? "))

    ...

Et on ajoute ceci pour mettre de l’espacement entre chaque tour :

while True:
    ...

    print(" ")

Voici à quoi ressemble le code final :

mots = [
    "BONJOUR", 
    "ORDINATEUR", 
    "CLAVIER", 
    "SOURIS", 
    "CHEVAL", 
    "OISEAU", 
    "CHIEN"
]

mot = choix(mots)

saisi = ["_"] * taille(mot)

essais = 10

while True:
    if essais <= 0:
        print("Vous avez perdu !")
        print("Le mot était : " + mot)
        break

    print(" ".join(saisi))

    if saisi == list(mot):
        print("Vous avez gagné !")
        break

    print("%d essais restants" % essais)

    lettre = maju(input("? "))

    for i in range(taille(mot)):
        if mot[i] == lettre:
            saisi[i] = lettre

    if lettre not in mot:
        essais -= 1

    print(" ")

Voici un exemple de partie :

_ _ _ _ _ _
10 essais restants
? a

_ _ _ _ A _
10 essais restants
? l

_ _ _ _ A L
10 essais restants
? i

_ _ _ _ A L
9 essais restants
? c

C _ _ _ A L
9 essais restants
? r

C _ _ _ A L
8 essais restants
? t

C _ _ _ A L
7 essais restants
? h

C H _ _ A L
7 essais restants
? v

C H _ V A L
7 essais restants
? e

C H E V A L
Vous avez gagné !

fin de l'exécution [0:00:51.610575]

Turing β-0.9

by Tom Niget//Versions

Turing β-0.9 est disponible !

Changelog
  • Corrections de bugs
    • L’IU n’est plus verrouillée quand un programme est lancé
    • Les paramètres “grad” de la fenêtre de graphique sont désormais fonctionnels
    • Les boutons Nouveau et Ouvrir sont désormais désactivés quand un programme est lancé
    • Le binaire Linux est maintenant compatible avec les systèmes plus anciens
    • Le numéro de ligne des messages d’erreurs est maintenant calculé correctement
    • Le pas automatique est désormais fonctionnel
    • Le binaire de l’éditeur est désormais intégré au binaire principal
  • Nouveautés
    • Un binaire macOS est maintenant disponible
    • Nouvelle notation fléchée pour les variables
    • Thème « Candy »
    • Amélioration importante du programme
    • Fonctions Erf et Erfc
    • Fonctions de densité de la loi normale
Code source

Turing β-0.8

by Tom Niget//Versions

Turing β-0.8 est disponible !

Changelog
  • Corrections de bugs
    • La largeur du panneau de droite était calculée avec une méthode qui faisait planter Qt sous Linux
    • Les performances de dessin était limitées à cause de MàJ du canvas trop fréquentes
  • Nouveautés
    • Thèmes + personnalisateur de thèmes
Téléchargements

Tutoriel rapide d’utilisation

by Tom Niget//Tutoriels

Dans ce tutoriel, nous effectuerons étape par étape l’écriture d’un algorithme simple qui calcule la somme de tous les nombres de 1 jusqu’à un nombre entré par l’utilisateur.

Lorsque vous ouvrez Turing, vous devriez voir une fenêtre vide comme dans la capture ci-dessus. Si ce n’est pas le cas, appuyez sur le bouton Nouveau.

Avant d’écrire un algorithme, il faut tout d’abord réfléchir au fonctionnement de celui-ci ; quelles valeurs doit-il prendre en entrée, et que doit il renvoyer en sortie. L’utilisation d’une feuille et d’un crayon est recommandée pour faire un brouillon rapide de la structure globale de l’algorithme, bien que cela ne soit pas nécessaire pour de petits algorithmes telles que celui que nous réaliserons ici.

Examinons l’énoncé : « un algorithme simple qui calcule la somme de tous les nombres de 1 jusqu’à un nombre entré par l’utilisateur ».

Il est vrai qu’il existe des formules permettant de calculer cette somme en une seule ligne (cf. formule de Gauss), mais ici nous le ferons de manière un peu plus simple et compréhensible.

Nous utiliserons ici ce qu’on appelle des variables. Bien que le mot soit utilisé aussi en maths, il s’agit de deux choses fondamentalement différentes. En maths, une variable est une chose, fixe (mais pas forcément connue), qui contient un nombre, et qui peut/doit valider certaines contraintes (on appelle cela une équation). En programmation, une variable est assimilable à une boîte ou à un tiroir dans lequel on met plus ou moins ce qu’on veut. Si je crée une variable nommé A, cela veut dire que je prends un carton, j’y appose l’étiquette « A » et je mets ce carton de côté pour pouvoir y accéder à tout moment. Je peux mettre ce que je veux dans le carton, et je peux retirer ce qu’y s’y trouve pour mettre autre chose à tout moment.

Pour résumer : une variable c’est un truc dans lequel on met ce qu’on veut. On peut en faire autant qu’on veut. On peut mettre ce qu’on veut dedans.

Pour commencer, on va demander à l’utilisateur pour quel nombre il veut effectuer le calcul. Nous allons donc utiliser l’instruction LIRE entrée. Cliquez sur le bouton correspondant :

Une fenêtre va s’afficher :

L’instruction LIRE entrée possède deux options :

  • la variable dans laquelle on va stocker la valeur saisie par l’utilisateur
  • le message à afficher

Le message est optionnel ; si il n’est pas spécifié, un message générique sera affiché à la place.

Le champ Variable doit contenir le nom de la variable désirée. Un nom de variable peut contenir des lettres et des chiffres (mais ne peut pas commencer par un chiffre) et ne peut pas contenir d’espaces. Pour l’exemple, vous pouvez utiliser « x ».

Cliquez ensuite sur OK.

Votre algorithme devrait ressembler à ça :

On va l’essayer, pour vérifier que tout marche bien. Cliquez sur le bouton Exécuter.

Vous devriez voir ceci s’afficher dans la fenêtre Sortie :

Comme vous pouvez le voir, le message générique s’est affiché, et le champ de saisie s’est activé. Saisissez un nombre, comme par exemple 5, puis appuyez sur Entrée ou cliquez sur le petit bouton vert.

La valeur saisie s’est affichée, puis le programme s’est arrêté. Ce qui est plutôt logique compte tenu du fait que c’est là la seule instruction du programme.

Nous pouvons donc continuer l’écriture.

La prochaine étape consiste à faire la somme des nombres de 1 jusqu’à x. On peut voir le problème différemment : on peut dire que cela consiste à mettre le « compteur » à 0 puis à ajouter 1, puis 2, puis 3 et ainsi de suite jusqu’à terminer en ajoutant x au « compteur ».

Ce compteur serait donc en somme une sorte de boîte dans laquelle on met un nombre et qu’on peut modifier à tout moment. Cela ne vous rappelle rien ?

Comme vous l’aurez deviné, nous utiliserons pour cela une variable.

Cliquez donc sur le bouton DÉFINIR variable.

L’instruction possède deux options :

  • la variable à définir
  • la valeur à mettre dedans

Ici, on veut initialiser le compteur à zéro. Cliquez sur OK. L’algorithme devrait ressembler à ça :

Maintenant que le compteur est à zéro, il faut ajouter 1, puis 2, puis 3 et ainsi de suite jusqu’à x. Mis sous formes de lignes, ça donne ça :

  • ajouter 1 au compteur
  • ajouter 2 au compteur
  • ajouter 3 au compteur
  • …
  • ajouter x au compteur

C’est répétitif. C’est très répétitif. C’est trop répétitif.

On a sûrement dû vous dire en 6ème que les matheux sont des fainéants. Il se trouve que l’informatique a été inventé par des matheux. Par induction, on peut donc conclure que les informaticiens sont des fainéants. Et les fainéants, ça n’aime pas les répétitions, parce que c’est tout le temps la même chose, c’est trop monotone. Ainsi, on a inventé un concept qui permet de faire la même chose (ajouter un truc au compteur) plein de fois. Ça s’appelle une boucle.

Comme son nom l’indique, une boucle c’est un truc qui va boucler et re-boucler sur soi même autant de fois que désiré.

Il existe plusieurs types de boucles en programmation. Les deux types de boucles utilisables dans les algorithmes sont :

  • les boucles POUR variable DE début À fin : fait varier variable de début à fin, en ajoutant 1 à chaque coup
  • les boucles TANT QUE condition : pas grand-chose à dire sur celle là, c’est une boucle qui boucle tant que condition est vraie

Vous l’aurez deviné, celle qui nous intéresse ici est la boucle POUR. On va donc en ajouter une. Cliquez sur l’onglet Blocs et sur le bouton Boucle POUR.

Ici, on va faire varier la variable actuel de 1 jusqu’à x.

Cliquez sur OK. Votre algorithme devrait ressembler à ça :

Ensuite, on veut qu’à chaque tour, ça ajoute la valeur au compteur. Cliquez donc sur la ligne de la boucle et cliquez sur le bouton DÉFINIR variable.

Cela signifie que pour chaque valeur de actuel, on ajoute actuel à compteur. Autrement dit, à chaque valeur de actuel, compteur prend la valeur compteur + actuel.

L’algorithme devrait ressembler à ça :

C’est bien, sauf que compteur on en fait quoi ?

Il faut l’afficher à la fin de l’algorithme, autrement le programme va exécuter la boucle puis s’arrêter sans rien dire. Cliquez donc sur le bouton AFFICHER valeur.

Attention : selon comme vous avez fait le programme, l’instruction pourrait s’ajouter comme ceci :

Ce n’est pas ce qu’on veut, car ça veut dire que l’instruction AFFICHER va s’exécuter à chaque tour de la boucle. Cliquez sur la ligne puis sur la flèche située en haut à droite :

L’instruction devrait se mettre au bon endroit et l’algorithme fini devrait ressembler à ça :

On peut donc le tester. Cliquez sur le bouton Exécuter et essayez d’entrer des valeurs au hasard. Par exemple, pour la valeur 100 le programme devrait afficher 5050.

Ça marche ! Merci patatapatito