"Suites" d'étoiles sous Java

Version imprimable

27/11/2014, 19h02
Ennydra

"Suites" d'étoiles sous Java
Bonjour, bonsoir...

On a le dessin suivant :
Code:

1 2 3 4 __*___*___* _*_*_*_*_*_ *___*___*__
Les "_" sont en réalité des espaces, mais j'ai mis "_" sinon je n'y me retrouvais plus !

Comme vous pouvez le voir, le dessin comprend 11 colonnes.

On doit coder ce même dessin avec 100 colonnes (je n'ai malheureusement pas l'énoncé exact sous mes yeux, mais en gros c'est ça). Vous suivez ? Je ne sais pas si je suis très claire :ptdr:

Ce que j'ai pu remarquer, c'est que la deuxième ligne comprendra donc une espace, puis une étoile, ce 100 fois. Donc 50 espaces/50 étoiles !
La première ligne comporte 2 espaces, puis une étoile, puis 3 espaces, 1 étoile, 3 espaces, etc.
La dernière ligne comporte 1 étoile, 3 espaces, 1 étoile, etc.

Comment faire pour coder ça ?
Evidemment je dois utiliser les boucles, notamment for (je suppose).

Je m'essaye... On va appeler i le nombre de colonnes (donc allant de 1 à 100), et j le nombre de lignes (donc allant de 1 à 3).
Code:

1 2 for (int i=1; i<=98; i++) { for (int j=1; j<=3; j++) {
Je ne vois vraiment pas comment je pourrais faire...
Pouvez-vous me donner des indications ?

Je vous remercie d'avance.
PS : Je suis débutante, je n'ai jamais fait de programmation.

Bonne soirée.
27/11/2014, 19h49
Nico02

Salut,

Tu n'aurais pas l'énoncé par hasard ? :aie:

Parce que de ce que je vois, on dirait bien que sa représente une fonction sinusoïdale affiché en console :aie:

Ducoup avant de m'embarquer dans des problèmes de math, j'aimerais être sûr que t'a pas une indication dans ton énoncé qui pourrait faire en sorte de résoudre ça plus facilement ^^

Cdt.
27/11/2014, 19h55
Ennydra

Coucou !

Non malheureusement je ne retrouve absolument pas l'énoncé D:

Mais oui, je croie bien que c'est une fonction sinusoïdale. En tous cas on voit bien que le dessin est "régulier".
27/11/2014, 20h36
thelvin

Comme c'est la console, tu ne peux pas commencer à écrire sur une ligne, puis sur une autre, puis revenir à la première etc. Quand tu passes à une nouvelle ligne tu ne peux plus toucher aux précédentes.

Donc il faut,
- d'abord écrire la première ligne
- ensuite écrire la deuxième ligne
- enfin écrire la troisième ligne.

Je ne pense pas que tu doives faire des "boucles dans des boucles". Il faut une boucle, seule, pour la première ligne. Une boucle, seule, pour la deuxième ligne. Une boucle, seule, pour la troisième ligne.

Faire une boucle de 3 pour les 3 lignes obligerait à chercher une formule mathématique. C'est faisable, mais inutilement compliqué tant que c'est pas demandé.
(Et si tu le fais quand même, la boucle de 3 doit contenir la boucle de 100. Puisqu'il faut d'abord écrire la ligne 1, puis la ligne 2, puis la ligne 3)
28/11/2014, 10h13
kolodz
Bonjour,

Personnellement, je réaliserai une fonction qui prend une position (x, y) d'un point d'une fonction (double) et le transforme en une étoile dans l'affichage désiré (Ici , 3 lignes 11 colonnes).

Le plus simple serai d'avoir une représentation matriciel de l'affichage final :

Code:

char[][] graphique = new char[3][11]

Code:

public abstract placePointSurGraphique(double x, double y, char[][] graphique);

Et donc pour l'ensemble de la fonction :
Code:

1 2 3 4 for(double x = 0; x <11;i++){ double y = Math.cos(Math.PI*x); placePointSurGraphique(x,y, graphique); }
Je détail pas l'affiche des lignes ou la fonction qui transforme une coordonnée en une étoile...

Cordialement,
Patrick Kolodziejczyk.

Citation:

Envoyé par Nico02

Parce que de ce que je vois, on dirait bien que sa représente une fonction sinusoïdale affiché en console :aie:

Moi du coup je vois une fonction "triangle" et pas "sin" ;) Mais vu la résolution, c'est rien...

Sinon pour l'inspiration ... (même si comme thelvin le souligne ca ne te semblait pas demander ainsi)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 for (int y = -1 ; y <= 1; y++) { for (int x = 0 ; x <= 100; x++) { double c = Math.cos(Math.PI*x/2); if (Math.abs(c-y)<0.01) System.err.print("*"); else System.err.print("_"); } System.err.println(""); }
qui donne un beau :
Code:

1 2 3 __*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*__ _*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_ *___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*

Et comme c'est vendredi, une version améliorée pour changer aussi la hauteur.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int fact = 1; // Taille en hauteur (modifie aussi la frequence)
 
		for ( fact = 1; fact < 8; fact++)
		{
			System.err.println("FACTEUR = "+fact);
			for (int y = -1*fact ; y <= 1*fact; y++)
			{
				for (int x = 0 ; x <= 100; x++)
				{
					double c = fact*Math.cos(Math.PI*(x)/Math.pow(2, fact));
 
				    if (Math.abs(c-y)<0.5)
						System.err.print("*");
					else
						System.err.print(".");
				}
				System.err.println("");
			}
			System.err.println("");
			System.err.println("");
		}

qui doit donner un truc (mais y'a une petite erreur quelque part...;)

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
 
FACTEUR = 1
..*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*..
.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.
*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*
 
 
FACTEUR = 2
....*.......*.......*.......*.......*.......*.......*.......*.......*.......*.......*.......*.......*
...*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.
..*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*...*..
.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*.....*.*...
*.......*.......*.......*.......*.......*.......*.......*.......*.......*.......*.......*.......*....
 
 
FACTEUR = 3
.......***.............***.............***.............***.............***.............***...........
......*...*...........*...*...........*...*...........*...*...........*...*...........*...*..........
.....*.....*.........*.....*.........*.....*.........*.....*.........*.....*.........*.....*.........
....*.......*.......*.......*.......*.......*.......*.......*.......*.......*.......*.......*.......*
...*.........*.....*.........*.....*.........*.....*.........*.....*.........*.....*.........*.....*.
..*...........*...*...........*...*...........*...*...........*...*...........*...*...........*...*..
**.............***.............***.............***.............***.............***.............***...
 
 
FACTEUR = 4
..............*****...........................*****...........................*****..................
............**.....**.......................**.....**.......................**.....**................
..........**.........**...................**.........**...................**.........**..............
.........*.............*.................*.............*.................*.............*.............
........*...............*...............*...............*...............*...............*............
.......*.................*.............*.................*.............*.................*...........
.....**...................**.........**...................**.........**...................**.........
...**.......................**.....**.......................**.....**.......................**.....**
***...........................*****...........................*****...........................*****..
 
 
FACTEUR = 5
............................*********.......................................................*********
........................****.........****...............................................****.........
......................**.................**...........................................**.............
....................**.....................**.......................................**...............
..................**.........................**...................................**.................
...............***.............................***.............................***...................
.............**...................................**.........................**......................
...........**.......................................**.....................**........................
.........**...........................................**.................**..........................
.....****...............................................****.........****............................
*****.......................................................*********................................
 
 
FACTEUR = 6
........................................................*****************............................
..................................................******.................******......................
.............................................*****.............................*****.................
.........................................****.......................................****.............
......................................***...............................................***..........
..................................****.....................................................****......
...............................***.............................................................***...
...........................****...................................................................***
........................***..........................................................................
....................****.............................................................................
...............*****.................................................................................
.........******......................................................................................
*********............................................................................................
 
 
FACTEUR = 7
.....................................................................................................
.....................................................................................................
.............................................................................................********
......................................................................................*******........
...............................................................................*******...............
.........................................................................******......................
...................................................................******............................
..............................................................*****..................................
........................................................******.......................................
..................................................******.............................................
...........................................*******...................................................
....................................*******..........................................................
............................********.................................................................
................************.........................................................................
****************.....................................................................................

@wax78: On est pas sensé attendre que la personne ai un minimum compris comment résoudre son problème avant de lui donnée la solution super magique ?
En particulier quand celle-ci nous précise qu'elle "juste" besoin d'indication et qu'elle débute en programmation :

Citation:

Je ne vois vraiment pas comment je pourrais faire...
Pouvez-vous me donner des indications ?

Je vous remercie d'avance.
PS : Je suis débutante, je n'ai jamais fait de programmation.

Sinon :

Code:

System.err.println("FACTEUR = "+fact);

Pourquoi tu utilise à sortie d'erreur pour affiché une restitution classique ?
Genre :

Code:

System.out.println("FACTEUR = "+fact);

c'est pas beaucoup plus cher...
Code:

1 2 3 4 if (Math.abs(c-y)<0.5) System.err.print("*"); else System.err.print(".");
Sachant qu'Ennydra début en programmation, on ne devrait pas utiliser les if else sans {/* Le code de ma condition */}Car seul l'instruction suivante est prise le bloc if, ce qui mène à beaucoup d'erreur ou de confusion pour les débutants.
Code:

1 2 3 4 // code démonstration des if / else sans {} if(false) System.out.println("Je ne serai pas affiché ! Car présent dans le bloc if !"); System.out.println("Même avec l'intention, je serai affiché ! Car je ne suis pas dans le bloc if !");
Cordialement,
Patrick Kolodziejczyk.

PS: Sens la fin de semaine !

28/11/2014, 11h23
wax78

Citation:

Envoyé par kolodz

@wax78: On est pas sensé attendre que la personne ai un minimum compris comment résoudre son problème avant de lui donnée la solution super magique ?

ça dépend.

Parfois le lecteur va rendre le truc tel quel a son prof qui lui posera des question et il se fera "petter"
OU
Il va chercher a comprendre, quitte a réécrire un petit bout et sera à même de montrer et d'expliquer le pourquoi du comment et gagnera des points.

Après à chacun de choisir... Il n'est pas obligé de prendre le bout de code magique ;)

Citation:

Envoyé par kolodz

Pourquoi tu utilise à sortie d'erreur pour affiché une restitution classique ?

Parce que j'aime bien, et qu'en plus j'adore le rouge... :p (et que je veux garder l'ordre d'affichage, même si dans ce cas ci c'est inutile puisqu'il n'y a qu'un thread qui ecrit dans la console).
28/11/2014, 19h31
Ennydra

Re coucou et merci pour toutes vos réponses.

J'étais en cours, désolée de n'avoir pas pu répondre plus tôt.

Je viens d'écrire un très long message mais ça m'a déconnectée et j'ai tout perdu, frustrant :(

Merci bcp Wax ainsi que pour les solutions magiques, mais j'avoue que je n'ai pas tout compris :oops:
Donc la fonction cos(pi*2/x) est bien la fonction recherchée, entre -1 et 1.
Mais tout ce qui est Math.abs etc, je ne l'ai pas encore fait...
Du coup ça paraît vraiment très compliqué pour moi, et difficile à comprendre...:oops:

Comme l'a suggéré Thelvin, ce serait peut-être mieux pour moi de m'y prendre pas à pas... Et donc de faire ligne par ligne...
J'ai essayé, mais j'en bave haha!

Pour la première ligne on a deux espaces donc

Code:

System.out.println("__");

Et ensuite j'ai fait ça car étant données les 2 espaces précédents, i va jusqu'à 98 et plus jusqu'à 100 !

Code:

for(int i=1; i<=98; i++) {

Je remarque sur le dessin qu'il y a une étoile lorsque la colonne est la 3, 7, 11, 15, 19, etc. Selon notre boucle i, selon la colonne 1, 5, 9, 13, 17, etc. Donc avec un pas de 4. Donc selon la formule 1+i*4... Mais je n'arrive vraiment pas coder tout ça D:

Edit : Suite dans prochain message.
28/11/2014, 19h53
Ennydra
Je reposte, mais en réfléchissant j'ai un peu l'impression d'être partie dans un délire et m'être complètement mélangée les pinceaux dans mon message précédent...

En fait la variable j ne sert à rien...
Code:

1 2 3 4 5 6 7 8 9 System.out.print("__"); for (int i=1; i<=98; i++){ if (i%4==1){ PrintString("*"); } else { PrintString("_"); } } NewLine();
Effectivement, pour i=1,5,9,13,etc i%4=1 sinon, non...

Est-ce juste ? (pour la première ligne)

Re,

Je n'ai toujours pas de réponse. J'ai tenté de faire le code complet. Je ne sais pas si j'ai juste, s'il y a des points à corriger, ou si je suis totalement à côté de la plaque...

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
class SuiteEtoiles {
 
  public static void main (String args[]) {
     System.out.print("__");
     for(int i=1; i<=98; i++) {
        if(i%4==1) {
           printString("*");
        } else {
           printString("_");
        }
      }
      newLine();
      for (int j=1; j<=100 ; j++) {
        if(j%2==0) {
           printString("*");
         } else {
           printString("_");
         }
      }
      newLine();
      for (int k=1; k<=100; k++) {
         if(k%4==1) {
            printString("*");
         } else {
            printString("_");
         }
      }
      newLine();
  }
 
  public static void printString(String s) {
    System.out.print(s);
  }
 
  public static void newLine() {
    System.out.print("\n");
  }
 
}

Je vous remercie d'avance pour toute aide !
Et si le code fonction, est-ce que certains pourraient me montrer ce que donne l’exécution de mon code (je n'ai pas la possibilité de voir :() ? Merci.

Bonne journée !

02/12/2014, 15h28
joel.drigo
Salut,

Je crois que tu y es arrivée toute seule, car voici le résultat de l'exécution de ton code :
```
__*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*_
_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*
*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___*___
```
Sinon, globalement, je n'ai qu'une chose à dire sur ton code : je trouve ça étrange de traiter un cas particulier au tout début : on peut réaliser la même chose en une boucle (sans faire un print externe), comme par exemple, en décalant les bornes du for (de 2, la longueur du chaîne affichée au début) :

Code:

for(int i=3; i<=102; i++) {

si tu préfères écrire, pour être plus explicite sur le pourquoi des bornes décalées :

Code:

for(int i=1+2; i<=100+2; i++) { // 2 est le décalage de la première étoile

Tu peux faire également le décalage dans le calcul du modulo, si tu préfères.

On pourrait appliquer le même raisonnement pour chaque boucle, afin d'avoir une comparaison du modulo cohérente entre les trois boucles (mais je pinaille un peu là)
02/12/2014, 15h36
kolodz
Le mieux étant de déclaré le 2 dans une constante pour comprends ce qu'elle représente :
Code:

1 2 3 4 // Déclaration int static final DECALAGE = 2; // Utilisation for(int i=1+DECALAGE ; i<=100+DECALAGE ; i++) { // 2 est le décalage de la première étoile
Comme ça, 6 mois après, tu relis le code et tu sais encore pourquoi tu ne commence pas à 1.
Et si tu veux jouer sur le décalage, tu n'as qu'une seul variable à touché !

Cordialement,
Patrick Kolodziejczyk.
02/12/2014, 21h17
Ennydra

Je vous remercie infiniment !

Je n'avais pas pensé à ajouter une nouvelle variable constante pour faire la première boucle. C'est vrai que c'est plus clair que de faire un cas particulier!

Du coup je peux faire passer le sujet en Résolu ;)