logo

Programas para imprimir patrones piramidales en Java.

Este artículo tiene como objetivo brindar una implementación Java para la impresión de patrones. 

hacer mientras bucle java

Patrón piramidal simple

Java
import java.io.*; // Java code to demonstrate star patterns public class GeeksForGeeks {  // Function to demonstrate printing pattern  public static void printStars(int n)  {  int i j;  // outer loop to handle number of rows  // n in this case  for(i=0; i<n; i++)  {  // inner loop to handle number of columns  // values changing acc. to outer loop   for(j=0; j<=i; j++)  {  // printing stars  System.out.print('* ');  }  // ending line after each row  System.out.println();  }  }  // Driver Function  public static void main(String args[])  {  int n = 5;  printStars(n);  } } 

Producción
* * * * * * * * * * * * * * * 

Complejidad del tiempo: O (n ^ 2)
Complejidad espacial: O(1)



Método: usar el bucle while 

Java
// java program to print simple pyramid pattern using while // loop import java.io.*; class GFG {  public static void main(String[] args)  {  int r = 1 c = 0 n = 5;  // the while loop check the conditions until the  // condition is false. if it is true then enter in  // to loop and execute the statements  while (r <= n) {  while (c <= r - 1) {  // printing the required pattern  System.out.print('* ');  c++;  }  r++;  c = 0;  // new line after each row  System.out.println();  }  } } // this code is contributed by gangarajula laxmi 

Producción
* * * * * * * * * * * * * * * 

Complejidad del tiempo: O(N^2) El bucle while externo itera N veces mientras que el bucle while interno itera N-1 veces. Por tanto, la complejidad temporal total del programa será O(N2).
Complejidad espacial: O(1) No se requiere espacio adicional.
 

Método n.º 2: uso de la recursividad

Java
// Java code to demonstrate star pattern // using Recursion import java.io.*; class GFG {  // function to print a row  static void printRow(int num)  {  // base case  if (num == 0)  return;  System.out.print('* ');  // recursively calling printRow()  printRow(num - 1);  }  // function to print the pattern  static void pattern(int n int i)  {  // base case  if (n == 0)  return;  printRow(i);  System.out.println();  // recursively calling pattern()  pattern(n - 1 i + 1);  }  // Driver code  public static void main(String[] args)  {  int n = 5;  pattern(n 1);  } } // this code is contributed by Shivesh Kumar Dwivedi 

Producción
* * * * * * * * * * * * * * * 

Complejidad del tiempo: O(N^2)

Espacio auxiliar: O(N^2)

Después de una rotación de 180 grados

Java
import java.io.*; // Java code to demonstrate star pattern public class GeeksForGeeks {  // Function to demonstrate printing pattern  public static void printStars(int n)  {  int i j;  // outer loop to handle number of rows  // n in this case  for(i=0; i<n; i++)  {  // inner loop to handle number spaces  // values changing acc. to requirement  for(j=2*(n-i); j>=0; j--)  {  // printing spaces  System.out.print(' ');  }    // inner loop to handle number of columns  // values changing acc. to outer loop  for(j=0; j<=i; j++)  {  // printing stars  System.out.print('* ');  }    // ending line after each row  System.out.println();  }  }  // Driver Function  public static void main(String args[])  {  int n = 5;  printStars(n);  } } 

Producción
 * * * * * * * * * * * * * * * 

El complejidad del tiempo del programa es O(n^2) porque hay dos bucles anidados, cada uno de los cuales se ejecuta n veces. 

largo para encadenar java

El complejidad espacial es O(1).

Método n.º 3: uso de la recursividad

Java
// Java code to demonstrate star pattern //using Recursion import java.util.*;   public class GeeksForGeeks {    // function to print spaces  static void printSpace(int space)  {  // base case  if (space == 0)  {  return;  }  System.out.print(' ' + ' ');    // recursively calling printSpace()  printSpace(space - 1);  }    // function to print stars  static void printStars(int star)  {  // base case  if (star == 0)  {  return;  }  System.out.print('* ');    // recursively calling printStars()  printStars(star - 1);  }    // function to print the pattern  static void pattern(int n int num)  {  // base case  if (n == 0)  {  return;  }  printSpace(n - 1);  printStars(num - n + 1);  System.out.println();    // recursively calling pattern()  pattern(n - 1 num);  }    // Driver code  public static void main(String args[])  {  int n = 5;  pattern(n n);  } } //this code is contributed by Shivesh Kumar Dwivedi 

Producción
 * * * * * * * * * * * * * * * 

Triángulo de impresión

Java
import java.io.*; // Java code to demonstrate star pattern public class GeeksForGeeks {  // Function to demonstrate printing pattern  public static void printTriangle(int n)  {  // outer loop to handle number of rows  // n in this case  for (int i=0; i<n; i++)  {  // inner loop to handle number spaces  // values changing acc. to requirement  for (int j=n-i; j>1; j--)  {  // printing spaces  System.out.print(' ');  }    // inner loop to handle number of columns  // values changing acc. to outer loop  for (int j=0; j<=i; j++ )  {  // printing stars  System.out.print('* ');  }    // ending line after each row  System.out.println();  }  }    // Driver Function  public static void main(String args[])  {  int n = 5;  printTriangle(n);  } } 

Producción
 * * * * * * * * * * * * * * * 

Método n.º 4: uso de la recursividad

Java
// Java code to demonstrate star pattern // using recursion import java.util.*; public class GeeksForGeeks {  // function to print spaces  static void printSpace(int space)  {  // base case  if (space == 0)  return;  System.out.print(' ');  // recursively calling printSpace()  printSpace(space - 1);  }  // function to print asterisks  static void printStar(int asterisk)  {  // base case  if (asterisk == 0)  return;  System.out.print('* ');  // recursively calling printStar()  printStar(asterisk - 1);  }  // function to print the pattern  static void pattern(int n int num)  {  // base case  if (n == 0)  return;  printSpace(n - 1);  printStar(num - n + 1);  System.out.println('');  // recursively calling pattern()  pattern(n - 1 num);  }  // Driver code  public static void main(String[] args)  {  int n = 5;  pattern(n n);  } } // this code is contributed by Shivesh Kumar Dwivedi 

Producción
 * * * * * * * * * * * * * * * 

Imprimir reverso de la pirámide

Java
//MainFunction public class ReversePyramid {  public static void main(String[] args)   {  int rows = 6; // Number of Rows we want to print        //Printing the pattern  for (int i = 1; i <= rows; i++)   {  for (int j = 1; j < i; j++)   {  System.out.print(' ');  }   for (int j = i; j <= rows; j++)   {   System.out.print(j+' ');   }   System.out.println();   }       }    } 

Producción
1 2 3 4 5 6 2 3 4 5 6 3 4 5 6 4 5 6 5 6 6 

Patrón de número con imagen de espejo

descargar vlc youtube
Java
//MainFunction public class ReversePattern {  public static void main(String[] args)   {  int rows = 7; // Number of Rows we want to print        //Printing the pattern  for (int i = 1; i <= rows; i++)   {  for (int j = 1; j < i; j++)   {  System.out.print(' ');  }   for (int j = i; j <= rows; j++)   {   System.out.print(j+' ');   }   System.out.println();   }     //Printing the reverse pattern  for (int i = rows-1; i >= 1; i--)   {  for (int j = 1; j < i; j++)   {  System.out.print(' ');  }   for (int j = i; j <= rows; j++)  {  System.out.print(j+' ');  }   System.out.println();  }    } } 

Producción
1 2 3 4 5 6 7 2 3 4 5 6 7 3 4 5 6 7 4 5 6 7 5 6 7 6 7 7 6 7 5 6 7 4 5 6 7 3 4 5 6 7 2 3 4 5 6 7 1 2 3 4 5 6 7 

Patrón numérico

Java
import java.io.*; // Java code to demonstrate number pattern public class GeeksForGeeks {  // Function to demonstrate printing pattern  public static void printNums(int n)  {  int i jnum;  // outer loop to handle number of rows  // n in this case  for(i=0; i<n; i++)  {  // initialising starting number  num=1;  // inner loop to handle number of columns  // values changing acc. to outer loop  for(j=0; j<=i; j++)  {  // printing num with a space   System.out.print(num+ ' ');  //incrementing value of num  num++;  }  // ending line after each row  System.out.println();  }  }  // Driver Function  public static void main(String args[])  {  int n = 5;  printNums(n);  } } 

Producción
1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 

Método 5: usar el bucle while

Java
// java program to print number pattern using while // loop import java.io.*; class GFG {  public static void main(String[] args)  {  int r = 1 c = 1 n = 5;  // the while loop check the conditions until the  // condition is false. if it is true then enter in  // to loop and execute the statements  while (r <= n) {  while (c <= r ) {  // printing the required pattern  System.out.print(c+' ');  c++;  }  r++;  c = 1;  // new line after each row  System.out.println();  }  } } 

Producción
1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 

Números sin reasignar

Java
import java.io.*; // Java code to demonstrate star pattern public class GeeksForGeeks {  // Function to demonstrate printing pattern  public static void printNums(int n)  {  // initialising starting number  int i j num=1;    // outer loop to handle number of rows  // n in this case  for(i=0; i<n; i++)  {  // without re assigning num  // num = 1;  for(j=0; j<=i; j++)  {  // printing num with a space  System.out.print(num+ ' ');    // incrementing num at each column  num = num + 1;  }  // ending line after each row  System.out.println();  }  }    // Driver Function  public static void main(String args[])  {  int n = 5;  printNums(n);  } } 

Producción
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 

Imprimir árbol de Navidad usando pirámide

clase vs objeto java
Java
class PrintChristmasTree{  //Value 5 is permanently provided to height variable  public static final int height = 5;    //Main Function  public static void main(String[] args) {    //Assigning Width   int width = 5;  //Assigning Space  int space = width*5;  int x = 1;  //Code to Print Upper Part of the Tree i.e. Pyramids.  for(int a = 1;a <= height ;a++){  for(int i = x;i <= width;i++){  for(int j = space;j >= i;j--){  System.out.print(' ');  }  for(int k = 1;k <= i;k++){  System.out.print('* ');  }  System.out.println();  }  x = x+2;  width = width+2;  }  //Printing Branch of Christmas Tree  for(int i = 1;i <= 4;i++){  for(int j = space-3;j >= 1;j--){    System.out.print(' ');  }  for(int k= 1;k <= 4;k++){  System.out.print('* ');  }  System.out.println();  }  } } 

Producción
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 

Complejidad del tiempo: O(h*w*w) para una altura dada h y ancho w

Espacio auxiliar: O(1)


 

Crear cuestionario