Categories
Logique Réflexion

Tests de logique

Logique ou non

Aujourd’hui, j’ai décidé de tester ma logique…


Pour quoi faire ?

Tout simplement pour voir si mon cerveau a (acquis) les principes de logique nécessaires pour écrire un code et/ou faire de la programmation.

En cherchant les tests de logiques demandés lors de l’embauche des développeurs, je suis tombée sur un site de tests psychotechniques –  mon-QI.com – qui est très intéressant.
Ce site permet de tester sa logique de diverses façons (représentation spatiale, suite de nombres, observation, etc.). Il propose aussi d’autres tests de français, mathématiques, de cartes, etc.

Et alors, on en retire quoi ?

C’est très intéressant de faire ces tests (je n’ai fait que les tests de logique 😉 ), car ça m’a vraiment permis de voir ce qui me posait problème ou me demandait plus de réflexion sur des exercices de logique.
Par exemple, je suis moins à l’aise sur des suites de chiffres, car je n’ai pas l’idée systématique de les additionner, de les soustraire ou les multiplier pour arriver au résultat attendu. Ça me prend donc plus de temps pour y arriver !

Finalement, ces tests permettent de comprendre et de réfléchir sur notre capacité à sortir de ce que l’on pense logique.
Ils permettent aussi de nous remettre en question sur notre fonctionnement. Et de découvrir ce que l’on peut améliorer dans notre « esprit logique ».

Conclusion…

Avec tous les tests que j’ai effectués, j’en ai conclu que j’ai une très bonne vision globale (une « logique » visuelle).
Et qu’il faut que je travaille encore mon raisonnement mathématique pour m’améliorer ! :)


Et vous, qu’est ce que ces tests vous ont apportés ?


Bonus…

J’ai aussi sur mon téléphone des jeux qui permettent de développer ma logique en s’amusant :
Connect it! Wooden Puzzle
Find a Way: Addictive Puzzle
Plombier
Des Tentes et des Arbres Puzzles

Les liens sont ceux du Play Store, car je suis sous Android… Mais je suis sure que vous pouvez trouver ce type de jeux sur l’Apple Store !

Categories
Apprentissage Découverte Python

Le jeu du Pong

Vous connaissez tous le jeu du Pong ?

Mais si, le jeu du Pong c’est ce jeu où l’on doit faire rebondir une balle entre deux barres…
Vous ne voyez toujours pas ?

PongGame

Le voici :


Aujourd’hui je suis allée voir un tuto sur YouTube de FreeCodeCamp : https://youtu.be/XGf2GcyHPhc pour réaliser le jeu du Pong.

J’ai réalisé le jeu en même temps que la vidéo.
C’était ma petite partie récréative pour me réconcilier avec Python (car en ce moment j’ai une overdose du cours que je suis sur OpenClassrooms; et surtout des classes et méthodes qui sont pour moi imbuvables ! 😉 )

Alors le principe est simple : il faut créer une fenêtre avec des dimensions précises, des barres et une balle. Puis programmer pour que tout se déplace, que la balle rebondisse et que les scores s’affichent…

Simple comme bonjour ? Presque…

J’ai suivi la vidéo et j’ai dû faire quelques modifications pour que le programme marche sur mon ordinateur !

  • Tout d’abord, j’ai fait des erreurs de frappe. Par exemple pour le déplacement des barres, j’ai oublié de mettre le signe négatif pour le déplacement en bas… Ce qui fait que, quelle que soit la touche paramétrée utilisée, ma barre se déplaçait uniquement en haut !
# Function
def paddle_a_up():
    y = paddle_a.ycor()
    y += 20
    paddle_a.sety(y)

def paddle_a_down():
    y = paddle_a.ycor()
    y += -20
    paddle_a.sety(y)
  • Le déplacement de la balle était bien trop rapide avec une valeur de 2. J’ai donc diminué progressivement jusqu’à 0.1 pour que la balle se déplace suffisamment lentement pour pouvoir jouer sans perdre dès le début !
ball.dx = 0.1			# speed
ball.dy = -0.1			# speed
  • Lorsque je suis passée au codage du déplacement de la balle, la balle doit toujours se retrouver au milieu après être sortie sur un côté. Mon code a marché lorsque j’ai supprimé les espaces dans la ligne.
if ball.xcor() > 390:  # right side of the screen
    ball.goto(0,0)
    ball.dx *= -1

if ball.xcor() < -390:  # left side of the screen
    ball.goto(0,0)
    ball.dx *= -1
  • Pour les conditions permettant à la balle de « rebondir » sur les barres, je n’avais pas mis toutes les parenthèses nécessaires. Ce qui provoquait un arrêt du programme…
# Paddle and ball collisions
if (ball.xcor() > 340 and ball.xcor() < 350) and (ball.ycor() < paddle_b.ycor() + 40 and ball.ycor() > paddle_b.ycor() -40):
    ball.setx(340)
    ball.dx *= -1

if (ball.xcor() < -340 and ball.xcor() > -350) and (ball.ycor() < paddle_a.ycor() + 40 and ball.ycor() > paddle_a.ycor() -40):
    ball.setx(-340)
    ball.dx *= -1

Finalement, ce moment récréatif a été très instructif !
En effet, même en ayant le modèle sous les yeux, j’ai eu quelques bugs qui m’ont permis de réfléchir et donc de m’améliorer !!! 🙂

De plus j’ai découvert une nouvelle bibliothèque : « turtle » qui permet notamment de dessiner des lignes. Et ça c’est top ! 😎


Et voici le code final !

# Simple Pong
# By @TokyoEdTech

import turtle

wn = turtle.Screen()
wn.title("Pong by @TokyoEdTech")
wn.bgcolor("black")
wn.setup(width=800, height=600)
wn.tracer(0)

# Score
score_a = 0
score_b = 0

# Paddle A
paddle_a = turtle.Turtle()
paddle_a.speed(0)
paddle_a.shape("square")
paddle_a.color("white")
paddle_a.shapesize(stretch_wid=5, stretch_len=1)
paddle_a.penup()
paddle_a.goto(-350, 0)

# Paddle B
paddle_b = turtle.Turtle()
paddle_b.speed(0)
paddle_b.shape("square")
paddle_b.color("white")
paddle_b.shapesize(stretch_wid=5, stretch_len=1)
paddle_b.penup()
paddle_b.goto(350, 0)

# Ball
ball = turtle.Turtle()
ball.speed(0)
ball.shape("square")
ball.color("white")
ball.penup()
ball.goto(0, 0)
ball.dx = 0.2			# speed
ball.dy = -0.2			# speed

# Pen
pen = turtle.Turtle()
pen.speed(0)
pen.color("white")
pen.penup()
pen.hideturtle()
pen.goto(0, 260)
pen.write("Player A: 0  Player B: 0", align="center", font=("Courier", 24, "normal"))

# Function
def paddle_a_up():
    y = paddle_a.ycor()
    y += 20
    paddle_a.sety(y)

def paddle_a_down():
    y = paddle_a.ycor()
    y += -20
    paddle_a.sety(y)

def paddle_b_up():
    y = paddle_b.ycor()
    y += 20
    paddle_b.sety(y)

def paddle_b_down():
    y = paddle_b.ycor()
    y += -20
    paddle_b.sety(y)

# Keyboard binding
wn.listen()
wn.onkeypress(paddle_a_up, "a")
wn.onkeypress(paddle_a_down, "q")
wn.onkeypress(paddle_b_up, "p")
wn.onkeypress(paddle_b_down, "m")

# Main game loop
while True:
    wn.update()

    # Move the ball
    ball.setx(ball.xcor() + ball.dx)
    ball.sety(ball.ycor() + ball.dy)

    # Border checking
    if ball.ycor() > 290:    # top of the screen
        ball.sety(290)
        ball.dy *= -1

    if ball.ycor() < -290:   # bottom of the screen
        ball.sety(-290)
        ball.dy *= -1

    if ball.xcor() > 390:  # right side of the screen
        ball.goto(0,0)
        ball.dx *= -1
        score_a += 1
        pen.clear()
        pen.write("Player A: {}  Player  B: {}". format(score_a, score_b), align="center", font=("Courier", 24, "normal"))

    if ball.xcor() < -390:  # left side of the screen
        ball.goto(0,0)
        ball.dx *= -1
        score_b += 1
        pen.clear()
        pen.write("Player A: {}  Player  B: {}". format(score_a, score_b), align="center", font=("Courier", 24, "normal"))

    # Paddle and ball collision
    if (ball.xcor() > 340 and ball.xcor() < 350) and (ball.ycor() < paddle_b.ycor() + 40 and ball.ycor() > paddle_b.ycor() -40):
        ball.setx(340)
        ball.dx *= -1

    if (ball.xcor() < -340 and ball.xcor() > -350) and (ball.ycor() < paddle_a.ycor() + 40 and ball.ycor() > paddle_a.ycor() -40):
        ball.setx(-340)
        ball.dx *= -1
Categories
Découverte

Connaissez vous le Code Golf ?

Je trouvais que mes codes étaient un peu longs. Du coup, je me suis demandée s’il n’y avait pas moyen de faire plus court…
Et c’est là que j’ai appris qu’il existait un concours récréatif de programmation pour avoir le code le plus court : le « Code Golf  »

Alors, qu’est-ce que c’est le « Code Golf » ?

C’est un concours, aussi connu sous le nom de « Golf scripting ». Son nom fait référence aux règles du jeu du Golf.
En effet, les golfeurs doivent finir leur parcours en moins de coups possibles.
Tout comme les participants du « Code Golf » qui doivent rédiger un programme très court (le plus court possible, même !) permettant d’exécuter une action.

Un peu d’histoire…

Le programme le plus court produisant une donnée a été rédigé en 1963 par Andrey Kolmogorov. Il est nommé Complexité de Kolmogorov.

De nombreux développeurs se sont ensuite lancés dans un concours informel pour rivaliser d’ingéniosité sur la rédaction d’un code.
Ce concours est devenu populaire avec le langage Perl et principalement grâce aux hackers en APL.
Le nom de « Code Golf » serait apparu en 1999. Le concours peut aussi prendre le nom du langage testé, par exemple « Perl Golf » !

Depuis, de nombreux langages spécifiques à ce concours ont été créés. Comme le Golf Script (en décembre 2007) ou le Flogscript.
Le code devant être le plus court possible, l’inconvénient majeur de ces programmes est un manque de lisibilité et de compréhension au premier coup d’œil !
Mais quand il faut rédiger rapidement un programme, on est moins regardant sur la forme que sur le fond, non ? 😉


Une chose est sûre : je ne suis pas assez mordue pour me lancer dans ce concours… L’idée ne m’a d’ailleurs même pas effleuré l’esprit lors de mes recherches sur le sujet !!! 🙂

Et vous, vous aimeriez tenter cette aventure ? Si oui, il existe une plateforme permettant de s’entraîner : Codewars.

Categories
Apprentissage Python

Deuxième TP, deuxième casse-tête !

Bonjour à tous ! 🙂

Voilà 3 jours que je travaille sur mon deuxième TP (quel casse-tête!) : le jeu du Pendu…
Et je vous avouerais que j’ai fait face à de nombreuses difficultés !

Après avoir bien visualisé mon code, puis commencé la rédaction simplifiée, je me suis lancée dans l’écriture complète du programme.
J’ai réalisé beaucoup d’essais pour réussir à faire fonctionner mon jeu.
Et notamment pour trouver comment :

Afficher le mot sous forme de mot mystère (avec des étoiles)

J’ai d’abord mis le mot sélectionné sous forme de liste en utilisant la recherche dans une chaîne de caractères :

mon_mot = [ lettre for lettre in m]

Ici, la liste – que j’ai nommée « mon_mot » – va être créée en prenant le mot « m » lettre après lettre et en ajoutant chaque caractère comme un objet de la liste.

Sur le même principe, j’ai créé le mot mystère comme étant une liste où chaque objet (lettre) de « mon_mot » est remplacé par une étoile.

mystere = [" * " for lettre in mon_mot]

Bonus : pour un affichage sans les crochets caractéristiques de la liste, j’ai utilisé le paramètre « en liste » lors de l’exécution de « print » :

print(*mystere)
Trouver la lettre demandée dans le mot (surtout quand il y a plusieurs fois la même lettre !)

Ici, j’ai créé une boucle de recherche dans toute la liste pour que toutes les lettres identiques puissent être trouvées.

J’ai d’abord demandé de compter le nombre de lettres identiques dans le mot :

compte_lettre = m.count(choix_lettre)

Puis j’ai mis comme paramètre d’arrêt de la boucle sur ce nombre :

i=0
while i != compte_lettre :
    rech_lettre = mon_mot.index(choix_lettre)
    mon_mot[rech_lettre] = "*"
    mystere[rech_lettre] = choix_lettre
    i += 1
Arrêter le programme lorsque le mot est trouvé

Ce point fut plus compliqué à démêler, car j’arrivais à finir le mot sans que le programme passe ensuite au calcul des scores…

Dans un premier temps, il faut arrêter la recherche de lettre.
Pour ça, il faut qu’à chaque lettre trouvée la longueur du mot « m » diminue.
Et j’ai mis une condition « if » sur cette longueur qui doit être strictement inférieure à 1 (si c’est à 0, après avoir trouvé toutes les lettres, le programme me demande encore une lettre !) :

long = len(m)
compte_lettre = m.count(choix_lettre)
if long > 1 :
    # recherche et remplacement de la lettre - voir au dessus #
    long = long - compte_lettre

La fin de la condition « if » ainsi créée permet ensuite de sortir du programme en ayant trouvé le mot. Et pour arrêter complètement la boucle, j’ai utilisé la fonction « break » :

else :
    print("\nBravo, vous avez trouvé le mot mystere : ", m )
    break

Casse-tête résolu ! 🙂
J’ai donc sorti un programme permettant de jouer au Pendu, dont voici le code :

# -*-coding:Latin-1 -*

# ************* Programme du jeu du Pendu ***************
import os
import random

print("Bienvenue dans le jeu du Pendu ! \n")

pseudo = input("Quel est votre nom ? ")  #*** joueur
score = 0   #*** score nul pour débuter
print("\nL'ordinateur va choisir aléatoirement un mot à découvrir.\n\
      Vous avez 8 chances pour y arriver ! \n\
      C'est parti...")
mot_mystere = ["vision", "bateau", "chouette", "bonjour", "amour", "festival"]
no_mot = random.randrange(6) # **** recherche aléatoire du mot dans liste données
m=mot_mystere[no_mot]
long = len(m)
print("\nLe mot mystère comporte ", long, " lettres à trouver :")
mon_mot = [ lettre for lettre in m]   # *** extraire le mot sous forme de liste par lettre
mystere = [" * " for lettre in mon_mot]   # *** remplace les lettres par une *
print(*mystere)
print("\nA vous de le trouver ! ")
essai = 8
while essai > 0 :
    choix_lettre = input("\nTapez une lettre :   ")
    choix_lettre = choix_lettre.lower()  # *** mettre la mettre en minuscule
    compte_lettre = m.count(choix_lettre)
    try :
        rech_lettre = mon_mot.index(choix_lettre)   # *** recherche la lettre dans le mot
    except ValueError :  # *** si la lettre n'est pas dans le mot
        try :
            choix_lettre != int(choix_lettre)  # *** vérifie que ce n'est pas un nombre
        except ValueError :
            print("Cette lettre n'est pas dans le mot mystère")
            essai = essai -1
            print("Il vous reste ", essai, " coups")
            coup_rest = essai
        else :
            print("Etes vous sûr de votre frappe ?")
    else :  
        if long > 1 :
            i=0
            while i != compte_lettre :   # *** si lettre ds mot, remplacer *
                rech_lettre = mon_mot.index(choix_lettre)
                mon_mot[rech_lettre] = "*"
                mystere[rech_lettre] = choix_lettre
                i += 1
            long = long - compte_lettre
        else :  # *** mot entièrement trouvé
            print("\nBravo, vous avez trouvé le mot mystere : ", m )
            break
        print(*mystere)
        print("Il vous reste ", essai, " coups")
# *** calcul du score
score = score + coup_rest
if coup_rest == 0 :  # *** mention spéciale si le mot n'a pas été trouvé
    print("\nVous avez perdu ! Le mot mystère était : ", m)
print("\n", pseudo, " , votre score est de : ", score, " points")

os.system("pause")   # met en pause le système Windows

Pour mémoire, voici le lien de l’énoncé : https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/232565-tp-realisez-un-bon-vieux-pendu


Je vous vois venir…
Vous allez me dire :  » c’est bien beau tout ça, mais tu n’as pas réalisé le TP exactement comme demandé dans le cours ! »
Exact !
Tout simplement parce que je voulais vous proposer un début de solution à ce casse-tête avant de continuer à bosser dessus… Car je dois faire des recherches plus approfondies sur la lecture/écriture dans un fichier !


La suite dans un prochain post ! 😉

Categories
Apprentissage Conseil Python

Faire travailler ses méninges !

Aujourd’hui, j’ai travaillé d’arrache-pied sur mon 2ème TP : le jeu du Pendu.
Et pour une débutante comme moi, il y a beaucoup de travail… J’ai donc pas mal fait travailler mes méninges ! 😉

Pour mémoire, voici le lien vers le TP :
https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/232565-tp-realisez-un-bon-vieux-pendu 

Après avoir visualisé mon code, j’ai commencé à l’écrire.
J’ai d’abord codé les passages les plus faciles pour moi, et j’ai mis des commentaires pour les passages sur lesquels j’avais du mal.

Ensuite, j’ai fait des petits morceaux de tests pour vérifier que mon code fonctionnait comme demandé dans l’énoncé…
J’ai aussi fait des recherches sur les différentes fonctions à utiliser pour compléter certaines parties…

Petit à petit, mon code prend forme.
Et il va me falloir encore travailler quelques heures et faire plusieurs recherches pour le finaliser !


Je mets cette citation ici pour ne pas oublier que rien n’est désespéré !