Java - ASCII art.

ASCII art.

Publicado por Javier (18 intervenciones) el 13/12/2022 15:33:31

Hola compañeros. Nuestros profes se están poniendo originales este año. Nos han mandado una actividad en el tema de arrays en el que nos piden hacer arte ascii. Os pongo el enunciado a ver si teneis alguna idea. Por supuesto muchas gracias por vuestras molestias.

se ha declarado un array bidimensional de String donde la primera dimensión tendrá siete elementos (cada una de las "capas" o "pisos" de los siete caracteres de altura que va a tener cada cifra).
cada uno de esos elementos será a su vez un array unidimensional de String de diez elementos. Cada uno de esos diez elementos es una parte del patrón de las cifras del 0 al 9 (la "capa" o "piso" del dígito que corresponde a cada nivel).
El array tendrá el siguiente contenido:

imagen en la foto

Este array lo puedes copiar y pegar a tu código como variable auxiliar que contiene los modelos ASCII de las cifras. En esta estructura tendremos toda la información necesaria para poder representar "en grande" o tamaño "gigante" cada carácter numérico del 0 al 9. Se trata, por tanto, de que escribas un programa en Java que, dada una entrada numérica por teclado, genere una cadena de caracteres que lo represente de manera "gigante". Por ejemplo, si se introdujera por teclado el número 51628, se generaría una cadena que al imprimirla por pantalla tendría el siguiente aspecto:

imagen en la foto

Y así con cualquier otro texto formado únicamente por cifras que se introdujera desde teclado.

Para ello tendrás que escribir un programa en Java que:

Declare un array bidimensional de objetos String que contenga los modelos ASCII de las cifras numéricas en tamaño "gigante". Se trata del array anterior (String[][] plantillaNumeros), que simplemente tendrás que insertar en tu código (por ejemplo, en la sección de variables auxiliares).
Solicite un número entero no negativo de como máximo diez cifras. Se deben admitir ceros a la izquierda. Si no se introduce un valor válido, se volverá a pedir hasta que lo sea. Utilizar como entrada una cadena de caracteres (no un valor entero) y usar como filtro de comprobación una expresión regular.
Genere la cadena final (de siete líneas) que contendrá la representación "gigante" del número.
Muestre por pantalla esa cadena.

Las imagenes no las puedo poner en el mensaje. Adjunto foto.
ascii-art

Valora esta pregunta

Me gusta: Está pregunta es útil y esta clara

No me gusta: Está pregunta no esta clara o no es útil

Responder

Pos: 142

Val: 26

ASCII art.

Publicado por antonio (32 intervenciones) el 14/12/2022 12:38:38

Hola buenas este seria un ejemplo pero hace falta las comprobaciones que lo introducido es un numero y que sea mayor que 0 y sobre todo que el numero solo puede tener como máximo 25 dígitos eso puedes cambiarlo:

import java.util.Scanner;

public class pruebas{

    String[][] plantillaNumeros ={{"   ###   ","    #    ","  #####  ","  #####  "," #       "," ####### ","  #####  "," ####### ","  #####  ","  #####  "},

                                  {"  #   #  ","   ##    "," #     # "," #     # "," #    #  "," #       "," #     # "," #    #  "," #     # "," #     # "},

                                  {" #     # ","  # #    ","       # ","       # "," #    #  "," #       "," #       ","     #   "," #     # "," #     # "},

                                  {" #     # ","    #    ","  #####  ","  #####  "," #    #  "," ######  "," ######  ","    #    ","  #####  ","  ###### "},

                                  {" #     # ","    #    "," #       ","       # "," ####### ","       # "," #     # ","   #     "," #     # ","       # "},

                                  {"  #   #  ","    #    "," #       "," #     # ","      #  "," #     # "," #     # ","   #     "," #     # "," #     # "},

                                  {"   ###   ","  #####  "," ####### ","  #####  ","      #  ","  #####  ","  #####  ","   #     ","  #####  ","  #####  "}};

    public void dibujar(int [] stack){

        for(int i=0;i<7;i++){

            for(int j=stack.length-1;j>-1;j--){

                System.out.print(plantillaNumeros[i][stack[j]]);

           System.out.println();

    int stack[];

    public static void main(String args[]){

    pruebas prueba = new pruebas();

    int numero;

    Scanner leer=new Scanner(System.in);

    System.out.println("Introduce el numero que quieres mostrar");

    numero=leer.nextInt();

    if(numero==0){

        int[] stack = new int[1];

        stack[0]=numero % 10;

        prueba.dibujar(stack);

    else{

        int[] stack = new int[25];

        int i=0;

        while(numero > 0){

            stack[i]= numero % 10;

            numero = numero / 10;

            i++;

        int [] stack2 = new int[i];

        for(int j=0;j<stack2.length;j++){

            stack2[j] = stack[j];

        prueba.dibujar(stack2);

Valora esta respuesta

Me gusta: Está respuesta es útil y esta clara

No me gusta: Está respuesta no esta clara o no es útil

Comentar

ASCII art.

Publicado por Javier (18 intervenciones) el 15/12/2022 00:02:51

Muchas gracias Antonio, a ver si soy capaz de pulirlo para que me funcione como quieren.
Un saludo y gracias de nuevo

Valora esta respuesta

Comentar

ASCII art.

Publicado por Javier (18 intervenciones) el 18/12/2022 01:48:52

Hola compañeros. Pues de nuevo estoy por aqui.
Por lo que se ve, a mi profesora no le gusta que me salga de su guion establecido y me "comenta" que si no sigo el patrón que ahora os pongo, no evaluará la actividad.
Alguna sugerencia?

public class Ejercicio03 {

public static void main(String[] args) {

//----------------------------------------------
// Declaración de variables
//----------------------------------------------
// Variables de entrada

// Variables de salida

// Variables auxiliares
// 1. Declaramos el array con los modelos ASCII de las cifras

// Clase Scanner para petición de datos de entrada
Scanner teclado = new Scanner(System.in);

//----------------------------------------------
// Entrada de datos
//----------------------------------------------
System.out.println("CIFRAS GIGANTES");
System.out.println("---------------");
// 2. Solicitamos un número entero no negativo de como máximo diez cifras

//----------------------------------------------
// Procesamiento
//----------------------------------------------
// 3. Generamos el resultado final

// 3.1. Declaramos un array de cadenas para almacenar temporalmente cada nivel del texto final

// 3.2. Recorremos cada nivel del array de patrones

// 3.3. Una vez rellenados todos los niveles del array temporal, recorremos ese array

// 3.3.1. Vamos concatenando en una única variable final todos los niveles, separándolos por medio de un avance de línea ('\n')

//----------------------------------------------
// Salida de resultados
//----------------------------------------------
System.out.println();
System.out.println("RESULTADO");
System.out.println("---------");
// 4. Mostramos por pantalla un único String que contiene el número "gigante"

}
}

Como siempre, muchas gracias por adelantado

Valora esta respuesta

Comentar

ASCII art.

Publicado por Javier (18 intervenciones) el 18/12/2022 23:58:08

De hecho me dice que solo puedo utilizar el metodo main, vaya tela.

Valora esta respuesta

Comentar

Pos: 142

Val: 26

ASCII art.

Publicado por antonio (32 intervenciones) el 20/12/2022 17:18:21

Pues tienes que hacer todo seguido te envio un ejemplo:

100

101

102

103

104

105

106

107

108

import java.util.Scanner;

 public class Ejercicio03 {

    public static void main(String[] args) {

    //----------------------------------------------

    // Declaración de variables

    //----------------------------------------------

    // Variables de entrada

    int numero;

    // Variables de salida

    // Variables auxiliares

    // 1. Declaramos el array con los modelos ASCII de las cifras

    String[][] plantillaNumeros ={{"   ###   ","    #    ","  #####  ","  #####  "," #       "," ####### ","  #####  "," ####### ","  #####  ","  #####  "},

                                  {"  #   #  ","   ##    "," #     # "," #     # "," #    #  "," #       "," #     # "," #    #  "," #     # "," #     # "},

                                  {" #     # ","  # #    ","       # ","       # "," #    #  "," #       "," #       ","     #   "," #     # "," #     # "},

                                  {" #     # ","    #    ","  #####  ","  #####  "," #    #  "," ######  "," ######  ","    #    ","  #####  ","  ###### "},

                                  {" #     # ","    #    "," #       ","       # "," ####### ","       # "," #     # ","   #     "," #     # ","       # "},

                                  {"  #   #  ","    #    "," #       "," #     # ","      #  "," #     # "," #     # ","   #     "," #     # "," #     # "},

                                  {"   ###   ","  #####  "," ####### ","  #####  ","      #  ","  #####  ","  #####  ","   #     ","  #####  ","  #####  "}};

    int[] stack = new int[10];

    int i=0;

    // Clase Scanner para petición de datos de entrada

    Scanner teclado = new Scanner(System.in);

    //----------------------------------------------

    // Entrada de datos

    //----------------------------------------------

    System.out.println("CIFRAS GIGANTES");

    System.out.println("---------------");

    // 2. Solicitamos un número entero no negativo de como máximo diez cifras

    System.out.println("Introduce el numero que quieres mostrar");

    numero=teclado.nextInt();

    if(numero==0){

        for(int j=0;j<7;j++){

                System.out.println(plantillaNumeros[j][0]);

    else{

        while(numero > 0){

            stack[i]= numero % 10;

            numero = numero / 10;

            i++;

        int [] stack2 = new int[i];

        for(int j=0;j<stack2.length;j++){

            stack2[j] = stack[j];

    //----------------------------------------------

    // Procesamiento

    //----------------------------------------------

    // 3. Generamos el resultado final

    // 3.1. Declaramos un array de cadenas para almacenar temporalmente cada nivel del texto final

    // 3.2. Recorremos cada nivel del array de patrones

    // 3.3. Una vez rellenados todos los niveles del array temporal, recorremos ese array

    // 3.3.1. Vamos concatenando en una única variable final todos los niveles, separándolos por medio de un avance de línea ('\n')

    //----------------------------------------------

    // Salida de resultados

    //----------------------------------------------

    System.out.println();

    System.out.println("RESULTADO");

    System.out.println("---------");

    // 4. Mostramos por pantalla un único String que contiene el número "gigante"

     for(int j=0;j<7;j++){

            for(int k=stack2.length-1;k>-1;k--){

                System.out.print(plantillaNumeros[j][stack2[k]]);

           System.out.println();

Valora esta respuesta

Comentar

ASCII art.

Publicado por Javier (18 intervenciones) el 21/12/2022 22:40:18

Pues muchisimas gracias de verdad. Da gusto con gente como vosotros.

Valora esta respuesta

Comentar

ASCII art.

Publicado por Antonio (5 intervenciones) el 02/01/2023 13:42:01

Buenas, puedes ayudar con el código por favor

Valora esta respuesta

Comentar

Pos: 142

Val: 26

ASCII art.

Publicado por antonio (32 intervenciones) el 03/01/2023 13:12:24

Hola buenas otro Antonio ya explique que este código no tiene en cuenta si introduces un carácter esto no esta desarrollado el otro error que dices no entiendo lo he probado varias veces sin caracteres y funciona:

Captura

Valora esta respuesta

Comentar

ASCII art.

Publicado por Antonio (5 intervenciones) el 27/12/2022 12:09:14

Buenas, el código se me rompe cuando pongo algún carácter, ademas no me sale el primer numero. un saludo

Valora esta respuesta

Comentar

ASCII art.

Publicado por Pedro (1 intervención) el 16/01/2023 12:35:21

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

package tarea4_aguadulce;

import java.util.Arrays;

import java.util.Scanner;

import java.util.regex.Pattern;

/**

 * @author pjbo8

*/

public class Ejercicio3 {

/**

     * @param args the command line arguments

*/

    public static void main(String[] args) {

        //----------------------------------------------

        //          Declaración de variables

        //----------------------------------------------

        // Variables de entrada

        // Variables de salida

        // Variables auxiliares

        // 1. Declaramos el array con los modelos ASCII de las cifras

        String[][] plantillaNumeros ={{"   ###   ","    #    ","  #####  ","  #####  "," #       "," ####### ","  #####  "," ####### ","  #####  ","  #####  "},

                                      {"  #   #  ","   ##    "," #     # "," #     # "," #    #  "," #       "," #     # "," #    #  "," #     # "," #     # "},

                                      {" #     # ","  # #    ","       # ","       # "," #    #  "," #       "," #       ","     #   "," #     # "," #     # "},

                                      {" #     # ","    #    ","  #####  ","  #####  "," #    #  "," ######  "," ######  ","    #    ","  #####  ","  ###### "},

                                      {" #     # ","    #    "," #       ","       # "," ####### ","       # "," #     # ","   #     "," #     # ","       # "},

                                      {"  #   #  ","    #    "," #       "," #     # ","      #  "," #     # "," #     # ","   #     "," #     # "," #     # "},

                                      {"   ###   ","  #####  "," ####### ","  #####  ","      #  ","  #####  ","  #####  ","   #     ","  #####  ","  #####  "}};

        String patronValido = "^[0-9]{1,10}$";

        String entrada;

        // Clase Scanner para petición de datos de entrada

        Scanner teclado = new Scanner(System.in);

        //----------------------------------------------

        //                Entrada de datos

        //----------------------------------------------

        System.out.println("CIFRAS GIGANTES");

        System.out.println("---------------");

        // 2. Solicitamos un número entero no negativo de como máximo diez cifras

do{

            System.out.println("Introduzca la cifra que quiere pintar: ");

            entrada = teclado.nextLine();

        }while (!entrada.matches(patronValido));

        //----------------------------------------------

        //                 Procesamiento

        //----------------------------------------------

        // 3. Generamos el resultado final

        // 3.1. Declaramos un array de cadenas para almacenar temporalmente cada nivel del texto final

        int[] numeros = new int[entrada.length()];

        for (int i=0; i<numeros.length; i++){

            numeros[i] = Character.getNumericValue(entrada.charAt(i));

        String[][] arrayFinal = new String[plantillaNumeros.length][numeros.length];

        // 3.2. Recorremos cada nivel del array de patrones

        for (int i=0; i<numeros.length; i++){

            for (int j=0; j<plantillaNumeros.length; j++){

                for (int k=0; k<plantillaNumeros[j].length; k++){

                    switch (numeros[i]){

                    case 0:

                        arrayFinal[j][i] = plantillaNumeros[j][0];

                        break;

                    case 1:

                        arrayFinal[j][i] = plantillaNumeros[j][1];

                        break;

                    case 2:

                        arrayFinal[j][i] = plantillaNumeros[j][2];

                        break;

                    case 3:

                        arrayFinal[j][i] = plantillaNumeros[j][3];

                        break;

                    case 4:

                        arrayFinal[j][i] = plantillaNumeros[j][4];

                        break;

                    case 5:

                        arrayFinal[j][i] = plantillaNumeros[j][5];

                        break;

                    case 6:

                        arrayFinal[j][i] = plantillaNumeros[j][6];;

                        break;

                    case 7:

                        arrayFinal[j][i] = plantillaNumeros[j][7];

                        break;

                    case 8:

                        arrayFinal[j][i] = plantillaNumeros[j][8];

                        break;

                    default:

                        arrayFinal[j][i] = plantillaNumeros[j][9];

        // 3.3. Una vez rellenados todos los niveles del array temporal, recorremos ese array

            // 3.3.1. Vamos concatenando en una única variable final todos los niveles, separándolos por medio de un avance de línea ('\n')

        //----------------------------------------------

        //              Salida de resultados

        //----------------------------------------------

        System.out.println();

        System.out.println("RESULTADO");

        System.out.println("---------");

        // 4. Mostramos por pantalla un único String que contiene el número "gigante"

        for (int i=0; i<arrayFinal.length; i++){

            for (int j=0; j<arrayFinal[i].length; j++){

                System.out.print(arrayFinal[i][j]);

            System.out.println("");

A ver si esto te vale.

Estoy practicando para el examen de Febrero con tareas de otros institutos. Y me he topado con esta.

Valora esta respuesta

Comentar

Cursos de programación gratuitos

Como obtener el primer y último carácter de una cadena