Affichage d'un sablier

Version imprimable

07/01/2018, 10h20
Stivano

Affichage d'un sablier

Bonjour,

J'ai besoin d'un code source pour un sablier qui marche avec le temp, svp.
Et merci d'avance.
07/01/2018, 11h06
Alcatîz

Bonjour et bienvenue,

Pourrais-tu être plus précis dans ta demande ? S'agit-il d'afficher un curseur d'attente pendant une opération, ou autre chose ?

1 pièce(s) jointe(s)

J'ai un exemple en C++.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/*
	File: hourglass.cpp
	Created by: 
	Creation Date: 10/8/2014
	Synopsis: prints an hour glass using 
	  asterisks and an maximum top row from user
*/
 
#include <iostream>
#include <cmath>
using namespace std;
 
int main()
{
 
  // Declare and initialize variables
 
	int row_top(0);
	int row(0);
	int i(0);
	int k(0);
	int j(0);
 
 
  // Repeatedly prompt for top row size until valid value is entered
 
cout << "Enter size of the top row: " ;
cin >> row_top;
 
	while(row_top < 3)
	{
	cout << "Size of the top tow must be at least three." << endl;
	cout << "Enter size of the top row again: "; 
	cin >> row_top;
	}
 
 
  // Repeatedly prompt for the number of rows until valid value is entered
 
cout << "Enter number of rows: ";
cin >> row;
 
	while(row == 0 || row_top/row < 2.0  || row < 1.0 )
	{
	cout << "Invalid number of rows." << endl;
	cout << "Enter number of top row again: "; 
	cin >> row;
	}
 
 
  // Print the hour glass
cout << endl;
 
	for (i=1; i <= row * 2 ; i++)
	{
		if (i <= row+1)
		{	for (j=1; j <= i-1; j++)
			{ 
			cout << " ";
			}
 
 
 
			for (k=1; k <= row_top-(i*2-2); k++)
			{
			cout << "*";
			}
			if (row != i)
			{
			cout << endl;
			}
		}
		else 
		{
			for (j=row;  j >= i-(row-1); j--)
			{ 
			cout << "o";
			}
 
 
 
			for (k=1; k >= row_top-(i*2-2); k--)
			{
			cout << "*";
			}
			cout << endl;	
		}
	}
 
 
  // end program
  return 0;
}

Pièce jointe 340272

08/01/2018, 20h47
Alcatîz

L'idéal quand on aborde ce genre de problème, c'est de tenter de le résoudre sur une feuille de papier, en essayant de trouver un algorithme que l'on transpose ensuite en Pascal.

Tu peux t'inspirer de ce petit exercice, qui consiste en l'affichage d'un carré (mais qui nécessite deux boucles imbriquées) : https://www.developpez.net/forums/d1...l-utilisateur/. Exécute-le sur papier puis vois comment passer du carré au sablier.

;)
09/01/2018, 23h11
Stivano

mrc alcatiz
03/02/2018, 00h28
wiwaxia

1 pièce(s) jointe(s)

Affichage d'un sablier

Bonjour, :D

Je vois trois questions à résoudre dans le cas de ton projet:

1°) La définition de la zone de l'écran texte occupée par le sablier: ici deux trapèzes adjacents, soit pas moins de 7 frontières rectilignes à définir ! Pas très simple finalement, pour un schéma d'apparence élémentaire ... Cependant la symétrie permet des simplifications.

Pièce jointe 348111

2°) Le transfert progressif des (N) "particules" de sable (ici des caractères) de la moitié supérieure du domaine à l'autre, réalisable à l'aide d'un tableau de coordonnées (x, y) de longueur supérieure à (2*N); cette question est de fait intimement liée à la précédente, dans la mesure où la liste en question mémorise, au-delà de l'ensemble des positions actuelles des particules, celui des positions possibles - soit par conséquent la forme du sablier.
Il faut d'ailleurs, à ce stade, régler un petit détail: la figure doit comporter non pas un mais deux sortes de caractères , afin de bien distinguer les cases occupées ('*', 'o' ou 'O') de celles qui sont vides (' ' ou '█').

3°) Le couplage éventuel de l'évolution de la figure affichée à l'horloge interne, algorithme qui bien que peu décrit n'est pas très difficile.

Tu pourrais justement commencer par ce dernier point, en t'en tenant provisoirement à un ensemble d'étoiles alignées.
Tu trouveras ici le lien vers un programme classique de Turbo Pascal, sur un sujet apparenté; il te suffit de n'en retenir que ce qui est en lien direct avec la procédure GetTime.

Si cela te paraît trop compliqué, il te reste encore une solution très simple, qui consiste à intercaler un délai d'attente entre deux déplacements d'étoiles, par l'instruction Delay(1000) - dont la durée vaut ici 1000 ms = 1s .

3 pièce(s) jointe(s)

Affichage d'un sablier

Les caractéristiques de la figure envisagée relèvent d'un calcul simple au niveau des constantes, et à partir de quelques unes d'entre elles.

Pièce jointe 349220

1°) Elle s'inscrit dans un rectangle dont la base est paire (2*5) et la hauteur impaire(9); de plus, comme l'on peut choisir les coordonnées (X1, Y1) de son coin supérieur gauche, il est déjà possible d'exprimer quelques termes en fonction de la demi-largeur (Lx), ici égale à (5):
Code:

1 2 3 CONST Lx = 5; Lx2 = 2 * Lx; X1 = 51; X2 = X1 + (Lx2 - 1); Y1 = 2; Y2 = Y1 + (Lx2 - 2);
2°) Le tracé du sablier relève d'un balayage ligne par ligne, entre deux bornes (Xmin, Xmax) qu'il convient de définir conformément au contour de l'objet:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 (y - Y1) (Xmin - X1) (X2 - Xmax) 0 0 0 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 4 4 7 3 3 8 2 2 9 1 1 10 0 0
Le décalage entre ces bornes et les abscisses extrêmes (X1, X2) de la figure dépend linéairement (en deux morceaux) de l'ordonnée (y) de la ligne considérée; c'est tout simplement le plus petit des écarts (y - Y1, Y2 - y), soit:
h = Min(y - Y1, Y2 - y) - propriété qui interviendra dans l'inventaire des cases.

3°) Le nombre de particules occupant complètement la partie supérieure du sablier, au-dessus du secteur le plus étroit, est:
Npart = 2*((1+2+3+4+5) - 1) = 2*((5*6/2) - 1) = 5*6 - 2 = Lx*(Lx + 1) - 2 (ici 28);
l'étendue du sablier (nombre total de cases disponibles): NcSab = 2*Npart + 2 (ici 58);
d'où la panoplie complète des constantes intervenant dans le programme - la dernière ligne concernant le temps total d'écoulement du sablier, et la représentation des particules
Code:

1 2 3 4 5 6 CONST Lx = 5; Lx2 = 2 * Lx; X1 = 51; X2 = X1 + (Lx2 - 1); Y1 = 2; Y2 = Y1 + (Lx2 - 2); NpMax = Lx * (Lx + 1) - 2; // Npart = 5*6 - 2 = 28 Nmax = 2 * NpMax + 2; // Nsab = 2*28 + 2 = 58 Tmin = 1; Tms = Tmin * 60000; o = 'o';
Les positions des cases et des particules seront mémorisées dans un liste
Code:

1 2 TYPE Point = RECORD t: Bool; u, v: Byte END; LstP = ARRAY[1..Nmax] OF Point;
dont tous les termes seront initialisés à (False, 0, 0); un booléen de valeur True correspondant à la présence d'une particule à l'endroit considéré (x = u, y = v).

Ces instructions préliminaires permettent de passer facilement à un sablier de taille quelconque, par la seule modification de la demi-largeur (Lx) de la figure:

Pièce jointe 349245_Pièce jointe 349249