I programmi a pattern sono spesso utilizzati nei colloqui per comprendere le capacità di pensiero logico del candidato. I modelli a piramide sono molto popolari e una volta compresa la logica di come sono creati, scrivere il codice per ottenere lo stesso risultato è un compito facile.
Programmi a Piramide in Java
Ecco alcuni esempi per creare diverse forme di piramide con numeri, simboli, ecc. Esamineremo anche alcuni esempi di creazione di un programma Java per una piramide invertita. Cercheremo di mantenere il codice semplice in modo che possa essere facilmente compreso.
Modello a Piramide di Numeri
Se osservi il primo modello, ogni riga contiene lo stesso numero stampato lo stesso numero di volte. Tuttavia, ogni riga ha spazi bianchi iniziali il cui conteggio è “righe-i”. Vediamo il programma per stampare questo modello.
package com.journaldev.patterns.pyramid;
import java.util.Scanner;
public class PyramidPattern {
private static void printPattern1(int rows) {
// per ciclo per le righe
for (int i = 1; i <= rows; i++) {
// spazi bianchi all'inizio dei numeri
int numberOfWhiteSpaces = rows - i;
// stampa spazi bianchi iniziali
printString(" ", numberOfWhiteSpaces);
// stampa numeri
printString(i + " ", i);
// passa alla riga successiva
System.out.println("");
}
}
// funzione di utilità per stampare una stringa un certo numero di volte
private static void printString(String s, int times) {
for (int j = 0; j < times; j++) {
System.out.print(s);
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Please enter the rows to print:");
int rows = scanner.nextInt();
// System.out.println("Righe = "+rows);
scanner.close();
System.out.println("Printing Pattern 1\n");
printPattern1(rows);
}
}
Nota che ho creato una funzione di utilità per compiti di stampa di stringhe comuni. Se riesci a dividere il tuo programma in brevi funzioni riutilizzabili, dimostra che non stai solo cercando di scrivere il programma ma anche di garantirne la qualità e la riutilizzabilità. Quando eseguiamo il programma sopra, otteniamo l’output seguente.
Please enter the rows to print:
9
Printing Pattern 1
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
6 6 6 6 6 6
7 7 7 7 7 7 7
8 8 8 8 8 8 8 8
9 9 9 9 9 9 9 9 9
Schema piramidale di numeri crescenti
Ecco la funzione per stampare lo schema 2. Il punto chiave da notare è il numero di spazi bianchi iniziali e poi i numeri vengono stampati in ordine crescente.
/**
*
* Program to print below pyramid structure
* 1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
*/
private static void printPattern2(int rows) {
// per ciclo per le righe
for (int i = 1; i <= rows; i++) {
// spazi bianchi all'inizio dei numeri
int numberOfWhiteSpaces = rows - i;
// stampa spazi bianchi iniziali
printString(" ", numberOfWhiteSpaces);
// stampa numeri
for(int x = 1; x<=i; x++) {
System.out.print(x+" ");
}
// passa alla riga successiva
System.out.println("");
}
}
Piramide di caratteri
Questo è davvero semplice, dobbiamo solo stampare il carattere senza alcun calcolo o manipolazione.
/**
* Program to print following pyramid structure
*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
*/
private static void printPattern3(int rows) {
// per ciclo per le righe
for (int i = 1; i <= rows; i++) {
// spazi bianchi davanti ai numeri
int numberOfWhiteSpaces = rows - i;
// stampa spazi bianchi iniziali
printString(" ", numberOfWhiteSpaces);
// stampa carattere
printString("* ", i);
// passa alla riga successiva
System.out.println("");
}
}
Programma a modello piramidale 4
/**
*
* 1
1 2 1
1 2 3 2 1
1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1
1 2 3 4 5 6 5 4 3 2 1
1 2 3 4 5 6 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1
*/
private static void printPattern4(int rows) {
// per ciclo per le righe
for (int i = 1; i <= rows; i++) {
// spazi bianchi davanti ai numeri
int numberOfWhiteSpaces = (rows-i)*2;
// stampa spazi bianchi iniziali
printString(" ", numberOfWhiteSpaces);
// stampa numeri
for(int x=1; x0; j--) {
System.out.print(j+" ");
}
// passa alla riga successiva
System.out.println("");
}
}
Nota che ogni riga ha 2*r-1 numeri. Quindi avremo (righe-i)*2 spazi bianchi prima di stampare qualsiasi numero. Poi i numeri vanno da 1 a “i” e poi di nuovo a 1. La nostra logica per stampare i numeri richiederebbe due cicli for per raggiungere questo.
Programma a modello piramidale 5 in Java
/**
*
* 9
8 9 8
7 8 9 8 7
6 7 8 9 8 7 6
5 6 7 8 9 8 7 6 5
4 5 6 7 8 9 8 7 6 5 4
3 4 5 6 7 8 9 8 7 6 5 4 3
2 3 4 5 6 7 8 9 8 7 6 5 4 3 2
1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1
*/
private static void printPattern5(int rows) {
// per ciclo per le righe
for (int i = rows; i >= 1; i--) {
// spazi bianchi davanti ai numeri
int numberOfWhiteSpaces = i*2;
// stampa spazi bianchi iniziali
printString(" ", numberOfWhiteSpaces);
// stampa numeri
for(int x=i; x=i; j--) {
System.out.print(j+" ");
}
// passa alla riga successiva
System.out.println("");
}
}
Modello a piramide invertita di caratteri
Ecco lo snippet di codice per il programma della piramide invertita.
/**
*
* * * * * * * * *
* * * * * * * *
* * * * * * *
* * * * * *
* * * * *
* * * *
* * *
* *
*
*/
private static void printPattern6(int rows) {
// ciclo for per le righe
for (int i = rows; i >= 1; i--) {
// spazi bianchi all'inizio dei numeri
int numberOfWhiteSpaces = rows - i;
// stampa spazi bianchi iniziali
printString(" ", numberOfWhiteSpaces);
// stampa carattere
printString("* ", i);
// passa alla riga successiva
System.out.println("");
}
}
Modello a piramide invertita di numeri
Diamo un’occhiata a un esempio di modello a piramide invertita fatto di numeri.
/**
*
9 9 9 9 9 9 9 9 9
8 8 8 8 8 8 8 8
7 7 7 7 7 7 7
6 6 6 6 6 6
5 5 5 5 5
4 4 4 4
3 3 3
2 2
1
*/
private static void printPattern7(int rows) {
// ciclo for per le righe
for (int i = rows; i >= 1; i--) {
// spazi bianchi all'inizio dei numeri
int numberOfWhiteSpaces = rows - i;
// stampa spazi bianchi iniziali
printString(" ", numberOfWhiteSpaces);
// stampa carattere
printString(i+" ", i);
// passa alla riga successiva
System.out.println("");
}
}
Conclusione
Ci sono molti tipi di modelli a forma di piramide. Il punto più importante è capire il modo in cui i numeri e gli spazi bianchi sono organizzati. Una volta chiari sul modello, è possibile scrivere facilmente codice in Java o in qualsiasi altro linguaggio di programmazione. Fammi sapere se stai cercando un programma con uno specifico modello e cercherò di aiutarti.
Approfondimenti
Programmi di Stringhe in Java e Domande di Intervista su Programmazione Java
Puoi controllare il codice completo e altri esempi di programmazione dal nostro Repository GitHub.
Source:
https://www.digitalocean.com/community/tutorials/pyramid-pattern-programs-in-java