Ciclo asterischi

di il
14 risposte

Ciclo asterischi

Mi potete spiegare come funziona righe e colonne??
Ciclo

non riesco a concludere

[code
import java.util.*;

public class CicloEs17 {

public static void main(String[] args) {

/*Si scriva un programma che chieda all'utente di inserire le dimensioni di un triangolo
* (un intero compreso tra 1 e 50). Si utilizza il triangolo mostrando righe di asterischi.
* La prima riga avrà un asterisco solo, la seconda due e cosi via; ciascuna riga avrà
* un asterisco in più della precendente fino a raggiungere il numero di righe indicato dall'utente.
* per le righe successive, il numero di asterischi per riga deve decrescere di uno per ogni nuova riga.
* Suggerimento: si usino dei cicli annidati; il ciclo più esterno deve controllare il numero di righe
* da scrivere, mentre il ciclo interno deve controllare il numero di asterischi da scrivere in una riga.
* per esempio scrive 3 l'output sarà:
*
* *
* **
* ***
* **
* *
*
* */


Scanner tastiera = new Scanner(System.in);
int n = 0;

System.out.println("Inserire le dimensioni di un triangolo: ");
n = tastiera.nextInt();

if(n >= 1 && n <= 50){
for(int i = 1; i <= n; i++){ // il ciclo esterno controlla il numero di righe Altezza

for(int j = 1; j <= i; j++ ){ //ciclo interno controlla il numero di colonne cresce di 1
System.out.print("*");
}



System.out.println(); // inizia una nuova riga Altezza di n
}
}
else {
System.out.println("Inserisci numero intero > 1");
System.exit(0);
}
}
}


][/code]

14 Risposte

  • Re: Ciclo asterischi

    robot ha scritto:


    non riesco a concludere
    Chiaramente manca la parte del triangolo che "scende". Ma qui basterebbe un po' di "logica". Se per fare la prima parte che "sale" del triangolo ci vogliono N cicli principali (con input N), per fare anche la parte che scende ci vogliono 2*N-1 cicli. Ma devi anche determinare quando far incrementare e quando decrementare. Basta un test: se i <= N allora la i è appropriata per la salita. Altrimenti la lunghezza la calcoli diversamente:

    Con input N = 3, hai tot cicli=3*2-1 = 5
    1             1
    2             2
    3             3
    4   3-(4-3) = 2
    5   3-(5-3) = 1

    P.S. ma lo puoi anche fare più semplice: basta una variabile in più per la lunghezza. Fino al ciclo N compreso la incrementi, altrimenti la decrementi. Ancora più semplice che logiche matematiche con gli indici.
  • Re: Ciclo asterischi

    Qui invece non ho capito, non riesco a capire che cosa mi vuoi dire, ho bisogno degli esempi e commenti.
    Che non capisco come si fa?
  • Re: Ciclo asterischi

    robot ha scritto:


    Qui invece non ho capito, non riesco a capire che cosa mi vuoi dire, ho bisogno degli esempi e commenti.
    Che non capisco come si fa?
    Una cosa semplice che si può fare:
    Se in input hai 3, fai 3*2=6 e quindi realizzi un ciclo con indice che va da 1 (non 0) e si incrementa finché < 6. Pertanto avrai 1 2 3 4 5 (che sono appunto le cinque righe come nell'esempio.
    Tieni un'altra variabile, inizialmente a 1. Questa la usi per il numero di asterischi nella riga. Poi ad ogni ciclo, finché l'indice è < 3, la incrementi, altrimenti la decrementi. Con questo otterrai 1 2 3 2 1.
    Ovviamente "generalizzalo" tu.
  • Re: Ciclo asterischi

    Mi fai un esempio di codice con commente per capire meglio????
    grazie
  • Re: Ciclo asterischi

    robot ha scritto:


    Mi fai un esempio di codice con commente per capire meglio????
    grazie
    Prova a rileggere quello che ho scritto prima.
    Fai le cose a "pezzi". Innanzitutto il ciclo per le righe, se in input hai 3 dovrai avere 1....5, se in input hai 4 dovrai avere 1....7. Insomma, il numero di righe è sempre dispari (il triangolo di asterischi ha una sola "punta" verso destra" e il resto è speculare).

    Poi per il ciclo interno (che stampa x asterischi in riga) è un banale for, userai quella variabile inizialmente a 1. Poi questa variabile la incrementi o decrementi, dipende da che punto sei del triangolo.
  • Re: Ciclo asterischi

    Grazie.
    Se ho capito bene, questi sono gli step da seguire:
    1: Inserisco L'input n qualsiasi
    2: Creo un ciclo for da 1 <= n e incremento, qui il triangolo inizia a salire
    3:stampo *
    4:creo un altro ciclo for da 1 <= 2* n -1 e decremento, qui il triangolo inizia a scendere
    5:stampo *

    Forse ho interpretato quasi bene il pseudocodice?, se ho sbagliano di nuovo per cortesia correggimi.
  • Re: Ciclo asterischi

    robot ha scritto:


    2: Creo un ciclo for da 1 <= n e incremento, qui il triangolo inizia a salire
    3:stampo *
    4:creo un altro ciclo for da 1 <= 2* n -1 e decremento, qui il triangolo inizia a scendere
    5:stampo *
    Se vuoi "spezzare" la generazione del triangolo in due parti es. parte 1 2 3 e poi parte 2 1 si può anche fare ma hai bisogno di 2 for principali più un for "annidato" per ciascun for principale. Risultato: ben 4 for !

    Se invece segui quello che ho detto prima userai solo 2 for (uno principale, uno interno). Insomma, solo uno per le righe e uno interno per gli asterischi in riga.
  • Re: Ciclo asterischi

    Il secondo ciclo ho inserito 2 * n -1

    ma mi stampa 5 righe lineari.

    Ancora non comprendo

    Grazie che mi stai aiutando.
    
    import java.util.*;
    
    public class CicloEs17 {
    
    	public static void main(String[] args) {
    	
    		/*Si scriva un programma che chieda all'utente di inserire le dimensioni di un triangolo
    		 * (un intero compreso tra 1 e 50). Si utilizza il triangolo mostrando righe di asterischi.
    		 * La prima riga avrà un asterisco solo, la seconda due e cosi via; ciascuna riga avrà
    		 * un asterisco in più della precendente fino a raggiungere il numero di righe indicato dall'utente.
    		 * per le righe successive, il numero di asterischi per riga deve decrescere di uno per ogni nuova riga.
    		 * Suggerimento: si usino dei cicli annidati; il ciclo più esterno deve controllare il numero di righe
    		 * da scrivere, mentre il ciclo interno deve controllare il numero di asterischi da scrivere in una riga.
    		 * per esempio scrive 3 l'output sarà:
    		 * 
    		 *   *
    		 *   **
    		 *   ***
    		 *   **
    		 *   *
    		 *   
    		 * */
    		
    		/*Chiaramente manca la parte del triangolo che "scende". 
    		 * Ma qui basterebbe un po' di "logica". Se per fare la prima parte che "sale" del triangolo 
    		 * ci vogliono N cicli principali (con input N), per fare anche la parte che scende ci vogliono 
    		 * 2*N-1 cicli. Ma devi anche determinare quando far incrementare e quando decrementare. 
    		 * Basta un test: se i <= N allora la i è appropriata per la salita. 
    		 * Altrimenti la lunghezza la calcoli diversamente:
    
    						Con input N = 3, hai tot cicli=3*2-1 = 5
    
    												Codice: Seleziona tutto
    												1             1
    												2             2
    												3             3
    												4   3-(4-3) = 2
    												5   3-(5-3) = 1
    
    P.S. ma lo puoi anche fare più semplice: basta una variabile in più per la lunghezza. 
    Fino al ciclo N compreso la incrementi, altrimenti la decrementi.
     Ancora più semplice che logiche matematiche con gli indici.*/
    		
    	/*Una cosa semplice che si può fare:
    Se in input hai 3, fai 3*2=6 e quindi realizzi un ciclo con indice che va da 1 (non 0) e si incrementa finché < 6. Pertanto avrai 1 2 3 4 5 (che sono appunto le cinque righe come nell'esempio.
    Tieni un'altra variabile, inizialmente a 1. Questa la usi per il numero di asterischi nella riga. Poi ad ogni ciclo, finché l'indice è <= 3, la incrementi, altrimenti la decrementi. Con questo otterrai 1 2 3 2 1.
    Ovviamente "generalizzalo" tu. ;)*/
    		
    		Scanner tastiera = new Scanner(System.in);
    		int n = 0;
    		
    		System.out.println("Inserire le dimensioni di un triangolo: ");
    		n = tastiera.nextInt();
    		
    		if(n >= 1 && n <= 50){
    			for(int i = 1; i <= n; i++){ // Salita del triangolo, il ciclo esterno controlla il numero di righe Altezza				
    					
    				for(int j = 1; j <= 2 * (n - 1); j++ ){ //ciclo interno controlla il numero di colonne cresce di 1
    						System.out.print("*");
    					}
    	
    					System.out.println(); // inizia una nuova riga Altezza di n
    			}
    		}
    		else {
    			System.out.println("Inserisci numero intero > 1");
    			System.exit(0);
    		}
    		
    
    	}
    }
    
    
    
  • Re: Ciclo asterischi

    Molto "pseudo":
    n = input.....
    len = 1
    
    for i da 1 finché minore di n*2 {
        for per stampare asterischi nella riga (qui usi len) { ...... }
    
        se i minore di n, incrementi len, altrimenti decrementi
    }
  • Re: Ciclo asterischi

    Se ho capito bene, ho scritto in questo modo:
    
    System.out.println("Inserire le dimensioni di un triangolo: ");
    		n = tastiera.nextInt();
    		int len = 1;
    		
    		if(n >= 1 && n <= 50){
    			for(int i = 1; i <= n * 2; i++){ // Salita del triangolo, il ciclo esterno controlla il numero di righe Altezza				
    				for(; len <= n; len++ ){ //ciclo interno controlla il numero di colonne
    					
    					if(i < n)
    						len++;
    					else 
    						len--;
    					
    						System.out.print("*");
    					}
    	
    					System.out.println(); // inizia una nuova riga Altezza di n
    			}
    		}
    		else {
    			System.out.println("Inserisci numero intero > 1");
    			System.exit(0);
    		}
    
    
  • Re: Ciclo asterischi

    Non ha senso, mi spiace.
  • Re: Ciclo asterischi

    Dove ho sbagliato??
  • Re: Ciclo asterischi

    robot ha scritto:


    Dove ho sbagliato??
    In "quasi" tutto.

    Innanzitutto hai fatto <= n * 2. Quindi fai un numero di righe "pari" (e non è quanto richiesto).

    Poi hai fatto un ciclo
    for(; len <= n; len++ )

    che non ha affatto senso.

    Poi la logica di incremento/decremento di len l'hai fatta nel ciclo interno. Che non ha senso lì. Quel "len" ti dice nel ciclo principale quanti asterischi devi stampare nella riga. Quindi cosa c'è di difficile nel fare un ciclo con k=0 per k<len (o k=1 per k<=len, c'è sempre questa dualità) e in cui stampi 1 asterisco?? Che serve appunto per stampare len asterischi.

    Poi solo DOPO il for interno allora incrementi/decrementi len in modo appropriato per la successiva riga.


    P.S. scusa ma provi un po' "a caso" o ci metti un po' di ragionamento?
  • Re: Ciclo asterischi

    Ho trovato questa discussione stamattina perchè ero bloccato anche io, un po a tentoni un po logicamente sono arrivato a questa soluzione
    
    
    import java.util.Scanner;
    
    public class Triangolo {
    	
    	public static void main (String[] args) {
    
    		Scanner tastiera = new Scanner(System.in);
    	
    		int triangolo;
    		int conteggio;
    		
    		System.out.println("Valore triangolo da 1 a 50");
    		triangolo = tastiera.nextInt();
    		conteggio = 1;
    		
    		if ((triangolo >= 1) && (triangolo <= 50)) {
    		
    			while (conteggio <= triangolo) {
    				for(int j = 1; j < conteggio; j++)
    				System.out.print("*");
    			
    			conteggio ++;
    			System.out.println();
    			}
    				
    			while (conteggio >= 1) {
    				for(int j = conteggio; j > 1; j--)
    				System.out.print("*");
    				
    			conteggio --;
    			System.out.println();
    			}
    			
    		} else {
    			System.out.println("Inserisci numero da 1 a 50");
    		}
    		
    	
    	}
    }
    
    
Devi accedere o registrarti per scrivere nel forum
14 risposte