Inscription / Connexion Nouveau Sujet
Algorithme sur Algobox
Bonjour/bonsoir à tous !
Je pense avoir besoin d'aide sur Algobox !
Ma question est assez simple mais je ne trouve malheureusement aucune réponse :
Est-il possible de conserver la valeur d'une variable d'un pas à un autre si celle si est susceptible de se modifier durant les pas ?
Ma variable est EN, au début de l'algorithme elle repasse à 5 qui est une valeur inutilisé et qui ne pose pas de problème dans mon cas (0 étant déjà assigné). Celle-ci sera modifié à la fin du pas par une valeur aléatoire.
Imaginons que cette valeur soit 3, EN passera donc de 5 en début de pas à 3 en fin de pas, cependant je voudrais qu'elle reste 3 au pas suivant puis même démarche elle pourra devenir 0,1,2... aléatoirement. Le problème étant que je n'arrive pas à définir EN au tout début par 5 puis la laisser varié puisqu'elle ce transforme en 5 à tout les pas ce qui me bloque sur ma démarche (et que je ne veut pas perdre un défi de mon prof !).
Merci de votre aide, je m'excuse de ne pas fournir le code, je ne trouve pas de moyen de le copier coller et celui-ci est assez long ce qui me prendrait 1 heures de recopiage.
C'est actuellement le cas mais j'aimerais affecter une valeur uniquement au premier pas,
les suivant se baserais sur la valeur de EN au pas précédent (c'est pour cela que j'affecte une valeur au pas n°1 car si je ne lui donne aucune valeur, Algobox refuse le programme)
FONCTIONS_UTILISEES
2 VARIABLES
3 pas EST_DU_TYPE NOMBRE
4 i EST_DU_TYPE NOMBRE
5 a EST_DU_TYPE NOMBRE
6 x EST_DU_TYPE NOMBRE
7 y EST_DU_TYPE NOMBRE
8 EN EST_DU_TYPE NOMBRE
9 DEBUT_ALGORITHME
10 LIRE pas
11 EN PREND_LA_VALEUR 5
12 x PREND_LA_VALEUR 0
13 y PREND_LA_VALEUR 0
14 POUR i ALLANT_DE 1 A pas
15 DEBUT_POUR
16 a PREND_LA_VALEUR ALGOBOX_ALEA_ENT(0,3)
17 SI (a==0) ALORS
18 DEBUT_SI
19 SI (EN!=0) ALORS
20 DEBUT_SI
21 TRACER_SEGMENT (x,y)->(x+1,y)
22 x PREND_LA_VALEUR x+1
23 FIN_SI
24 FIN_SI
25 SINON
26 DEBUT_SINON
27 SI (a==1) ALORS
28 DEBUT_SI
29 SI (EN!=1) ALORS
30 DEBUT_SI
31 TRACER_SEGMENT (x,y)->(x,y+1)
32 y PREND_LA_VALEUR y+1
33 FIN_SI
34 FIN_SI
35 SINON
36 DEBUT_SINON
37 SI (a==2) ALORS
38 DEBUT_SI
39 SI (EN!=2) ALORS
40 DEBUT_SI
41 TRACER_SEGMENT (x,y)->(x-1,y)
42 x PREND_LA_VALEUR x-1
43 FIN_SI
44 FIN_SI
45 SINON
46 DEBUT_SINON
47 SI (a==3) ALORS
48 DEBUT_SI
49 SI (EN!=3) ALORS
50 DEBUT_SI
51 TRACER_SEGMENT (x,y)->(x,y-1)
52 x PREND_LA_VALEUR y-1
53 FIN_SI
54 SINON
55 DEBUT_SINON
56 SI (EN==0) ALORS
57 DEBUT_SI
58 TRACER_SEGMENT (x,y)->(x,y+1)
59 y PREND_LA_VALEUR +1
60 FIN_SI
61 SINON
62 DEBUT_SINON
63 SI (EN==1) ALORS
64 DEBUT_SI
65 TRACER_SEGMENT (x,y)->(x+1,y)
66 x PREND_LA_VALEUR x+1
67 FIN_SI
68 SINON
69 DEBUT_SINON
70 SI (EN==2) ALORS
71 DEBUT_SI
72 TRACER_SEGMENT (x,y)->(x,y-1)
73 y PREND_LA_VALEUR y-1
74 FIN_SI
75 SINON
76 DEBUT_SINON
77 TRACER_SEGMENT (x,y)->(x-1,y)
78 x PREND_LA_VALEUR x-1
79 FIN_SINON
80 FIN_SINON
81 FIN_SINON
82 FIN_SINON
83 FIN_SI
84 FIN_SINON
85 FIN_SINON
86 FIN_SINON
87
88 EN PREND_LA_VALEUR a
89 FIN_POUR
90 FIN_ALGORITHME
J'ai trouvé un moyen de vous fournir mon programme, celui-ci à pour but de construire un chemin vers des directions aléatoire sans jamais faire un demi tour et donc sans jamais repasser sur le même chemin.
Et si tu affectes la valeur obtenu dans ton pas dans ta variable initiale, il va remplacer la valeur initiale par celle obtenu et il va utiliser cette valeur pour le pas suivant et à chaque pas tu reaffectes ta variable pour le pas suivant
Je voudrais que EN soit tout d'abord égal à 5 pour ne pas gêner le code puis il deviendrait ensuite de même valeur que a du pas précédent qui est aléatoire et change à chaque pas, cela me permettra de refuser de construire un segment si celui-ci repasse sur le segment précédent
Si tu affectes à a la valeur 5 puis que tu met ta ligne 80 entre la ligne 15 et 16( juste après le début de la boucle FOR) il va l'affecter juste avant d'effectuer la boucle à chaque fois
C'est un essai
Bonjour,
pour recopier du code algobox il suffit de se placer en mode "éditeur"
(ou de l'exporter en texte et de copier coller le texte depuis le fichier texte)
ce que tu racontes est incompréhensible
moi j'en tire l'impression que tu ne sais pas ce que c'est vraiment qu'une variable dans un programme, Algobox ou pas.
et que tu penses qu'une variable c'est pour remplacer une valeur, comme une espèce de calcul littéral en maths.
alors que en vrai une variable c'est pour contenir une valeur.
une espèce de boite dans laquelle on met une valeur.
si on veut conserver la valeur d'une variable pour plus tard après des calculs qui l'auraient détruite (cette variable), et bien on utilise une deuxième variable dans laquelle on recopie le contenu de la première.
EN a une certaine valeur à cet instant
exEN prend la valeur de EN (pour rester dans ce magma qu'est Algobox)
ici des calculs qui détruisent le contenu de EN
la valeur de départ elle est toujours dans exEN !! (si on n'a pas touché à cette variable exEN)
si je veux la remettre dans EN :
EN prend la valeur de exEN
Je m'excuse d'avoir été flou dans mes explications, je vais donc essayer de m'expliquer d'une meilleurs manière.
Mon programme consiste à créer un chemin de longueur=pas. Si je sélectionne pas=5 j'aurais alors un chemin de 5 segments de long. Ce chemin peut se diriger dans les 4 direction d'un repère qui sont x,y,-x,-y. je donne donc un nombre aléatoire entre 0 et 3 pour choisir une des directions à prendre puis je fais apparaître les segments.
Seulement un problème apparu, parfois le pas 1 donnait un segment X+1 et le pas 2 donnait X-1 ce qui faisait un allé-retour et n'affichait visuellement qu'un segment.
J'ai donc voulu créer une variable EN qui retiendrait la direction prise pas le dernier pas pour ne pas retourner en arrière. Et c'est là que je me suis retrouver en incapacité du fait de mes connaissances à proposer une variable EN fonctionnant comme je le souhaitais. J'espère avoir été plus claire !
pour le programme il fonctionne. Dans un premier temps la variable a recherche l'accès à un bloque Si et si cette variable trouve un accès dans un bloque mais qu'elle est égal à la valeur EN, elle se retrouve bloqué pour ne pas faire demi tour et se retrouvera dans la deuxième partie du programme qui donnera une direction à la valeur a sachant que celle-ci fut refusé précédemment de façon à ce qu'elle ne fasse pas demi tour.
bon , discussion entre temps pendant que je tapais
celui-ci à pour but de construire un chemin vers des directions aléatoire sans jamais faire un demi tour et donc sans jamais repasser sur le même chemin.
à mon avis il n'y a pas que des demi-tours qui feraient repasser par le même chemin !!
(on peut aussi "tourner en rond")
moralité :
les points par lesquels tu es déja passé, ce n'est pas une valeur qu'il faut mémoriser mais une liste de valeurs. (dans une variable de type liste)
edit suite à message intercallé : les positions par lesquelles tu es passé et pas les directions.
moralité bis : ton programme est totalement illisible parce qu'il n'est pas construit pas à pas par une démarche logique en commençant par "ses grandes lignes" puis entrer petit à petit dans les détails
ceci permet (et oblige) à mettre des "commentaires" dans son code annonçant quel est le but de chaque partie du code et de chaque variable
en l'absence de ces commentaires il est totalement impossible de s'y retrouver si le programme fait plus de 10 lignes. et même ...
9 DEBUT_ALGORITHME
// que représente "pas" ?
10 LIRE pas
// que représente la variable EN pourquoi la met on à 5 ?
11 EN PREND_LA_VALEUR 5
// position de départ, ok
12 x PREND_LA_VALEUR 0
13 y PREND_LA_VALEUR 0
// le "pas" est donc subdivisé en "petits pas" ???
14 POUR i ALLANT_DE 1 A pas
etc
edit avant envoi suite au dernier message :
ces explications (toujours confuses et peu compréhensibles) sur ce que fait le programme et comment il le fait doivent figurer explicitement sous forme de commentaires dans le programme lui-même
tu parles de "bloque" (? bloc ? ) sans avoir défini ce que c'est.
la première chose à faire avant de se lancer dans l'algorithme est déja de définir précisément ce dont on parle !
D'accord, je vais reprendre le programme de zéro et essayer de bien définir son objectif.
Je vais travailler sur ça et je reviens vers vous quand tout sera bien organisé.
Le forum autorise t-il que je poste la suite dans 1/2 jours le temps que j'approfondisse tout cela ou devrais-je remettre un nouveau post ?
Merci pour votre aide et je l'espère à bientôt pour la suite.
pas de problème, toute suite sur ce sujet est à mettre en réponse dans cette discussion-ci
le sujet étant de toute façon ouvert jusqu'à la fin des temps en général.
(seuls les sujets qui dérapent vers du troll ou des trucs sans aucun rapport avec le forum sont susceptibles d'être verrouillés par un modérateur)
pas avancé sur le sujet ?
un algorithme de principe :
point de départ x = y = 0
le mémoriser dans la liste
tant que le nombre de pas n'est pas atteint et qu'on n'est pas bloqué
choisir une direction aléatoire
tant que le point d'arrivée est dans la liste
choisir la direction suivante (modulo 4)
si on n'en a pas trouvé de libre, on est bloqué
sinon effectuer ce déplacement et mettre le point d'arrivée dans la liste
rechercher si une position est dans la liste ou pas est elle même une boucle (balayer la liste)
exemples d'exécution :
Entrer long : 20
+x +x +y +y -x +y -x +y -x -y -y -y +x +x
bloqué après 14 pas !
le plus souvent on n'est pas bloqué :
Entrer long : 20
+y +y -x -x -y +x -y -x -y +x +x +x +y +y +y +y -x +y -x -y
les 20 trajets ont été effectués avec succès !
Annuler
connectez vous