Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Hola compañeros, alguien podria ayudarme a solucionar los siguiente pseucodigos, la verdad ahora si, no tengo idea de como hacerlo,lo neesito hacer con pilas en netbeans, de antemano gracias

//////////////////////////////////////////////////////////
Conversión de Infija a Postfija
• Pseudocódigo
1. Inicializar la pila
2. Repetir hasta que no haya caracteres en la expresión de
entrada
2.1 Leer un carácter de la expresión
2.2 Si es un operando se pasa a la expresión postfija de salida
2.3 Si el elemento es un operador distinto de ‘)’ entonces:
2.3.1 Si la pila está vacía se mete en la pila.
2.3.2 Si la pila NO está vacía
• Si la prioridad del operador es mayor que la prioridad del
operador de la cima de la pila ⇒ se mete en la pila
• Si la prioridad del operador es menor o igual que la prioridad
del operador de la cima de la pila ⇒ se saca el operador de la
cima y se coloca en la expresión postfija. Volvemos a 2.3
2.4 Si el elemento es el operador ‘)’ entonces:
2.4.1 Se sacan operadores de la pila hasta encontrar el paréntesis ‘(‘
que se elimina (las expresiones postfijas no llevan paréntesis)
3. Al finalizar el recorrido por la expresión aritmética se pasa todo
el contenido de la pila a la expresión postfija
///////////////////////////////////////////////////////////////////
Pilas
Evaluación de una Notación Postfija
• Pseudocódigo
1. Inicializar la pila
2. Repetir hasta que no haya caracteres en la expresión
a evaluar
2.1 Obtener el siguiente item de la expresión
2.2 Si el elemento es un operando se mete en la pila
2.3 Si el elemento es un operador (denominado &) entonces:
2.3.1 Se extraen los dos elementos superiores de la pila,
denominados Op2 y Op1 respectivamente.
2.3.2 Se evalúa el resultado de Op1 & Op2 y se almacena en Z
2.3.3 Se introduce Z en la cima de la pila
3. Obtener el valor de la expresión de la cima de la pila

Hola compañeros, espero puedan ayudarme,  me quede atorado del punto 4 en adelante, de antemano muchas gracia, esta es la practica que tengo que hacer,:

Excepciones_Matriz:
La clase debe tener los siguientes atributos:
* 3 matices de tipo entero
*Un atributo para renglones y otro para columnas
*Un atributo para contar las excepciones generadas.

Los métodos y el constructor tendrán las siguientes especificaciones:
1. Constructor: En base a un par de variables leídas por teclado en el método main de la clase Principal, se deben inicializar los atributos para renglones y columnas, usar polimorfismo con el comando this, por ejemplo:
this.columnas = columnas;
this.renglones = renglones;
Una vez inicializado los atributos anteriores, inicializar cada una de las matrices con las dimensiones que dio el usuario.
2. Llenado_Aleatorio: Mediante un objeto de la clase Random llenar las matrices. La matriz A se llenará con números aleatorios en un rango de [0, 20] y la matriz B se llenará con números aleatorios en un rango de [0, 10]
3. Desplegar_Matrices: Se deben desplegar los valores aleatorios con los cuales fueron llenadas las matrices A y B.
4. Division_Matrices: La idea general de este método es llenar las localidades de la matriz C con la división entre cada localidad 𝑖,𝑗 ∀ 𝑖=0,1,…,𝑛−1 y
𝑗=0,1,…,𝑚−1. Se puede ver que puede haber el caso en el que la división no se pueda representar, por ejemplo supónganse que para la casilla [2][3] en la matriz A hay un 12 y en la matriz B hay un 0, claramente se puede ver que la división no se puede realizar y generaría una Excepción de tipo ArithmeticException.
Es por esto que, en este método para llenar las localidades de la matriz C, se invocará una función que se debe llamar Divide, el cual será descrito a continuación.
5. Divide: En esta función se debe implementar un bloque try – catch para poderle hacerle frente a cada una de las excepciones que se puedan presentar en la división de las localidades de la matriz, es aquí donde el atributo para contar excepciones se incrementara cuando se presente una excepción mostrando en pantalla el número de excepciones.
Dado que es una función, se debe regresar la división cuando sea permitida (dentro del bloque try) o -1 cuando se genere una excepción (bloque catch)
Cabe mencionar que la función Divide tendrá un grado de visibilidad privado.
Principal:
En esta clase se debe crear el método main y dentro crear un objeto de la clase Excepciones_Matriz. Se deben pedir al usuario las dimensiones de la matriz y después se
deben llamar a los métodos Llenado_Aleatorio, Despliega_Matrices y Divisiones_Matrices



package Parte_Final;

import java.util.Random;

public class Excepciones_Matriz {

   

    public int[][]a;
    public int[][] b ;
    public int [][]c;
    int filas;
    int columnas;
    int excepciones;

    public Excepciones_Matriz(int filas, int columnas) {
      this.filas = filas;
      this.columnas = columnas;
      a = new int [filas][columnas];
      b = new int [filas][columnas];
       
    }

    private void Llenado() {
   Random r = new Random ();

        for (int i = 0; i < filas; i++) {
            for (int j = 0; j < columnas; j++) { 
                        a[i][j] = r.nextInt(20)+ 1;
                         
            }
        }
                for (int k = 0; k < filas; k++) {
                    for (int l = 0; l <columnas; l++) { 
                       
                        b[k][l] = r.nextInt(10)+ 1;
                    }
                }

            }
       
   

    public void Desplegar() {
       
        Llenado ();
       
        System.out.println("Matriz A");
       
        for (int i = 0; i < filas; i++) {
             System.out.printf("\n");
            for (int j = 0; j < columnas; j++) {  // recorro la matriz
                System.out.print(a[i][j]+"\t");
               
           

            }
         
        }
                System.out.println("\n");
               
                System.out.println("Matriz B");

                for (int k = 0; k <filas; k++) {
                       System.out.printf("\n");
                    for (int l = 0; l < columnas; l++) {  // recorro la matriz
                        System.out.print(b[k][l]+"\t");
                       

                    }
                     
                }
               
               
            }
        }


package Parte_Final;

import java.util.Scanner;
import Parte_Final.Excepciones_Matriz;

public class Principal {
   
    public static void main(String[] args) {
       
        Scanner sc = new Scanner (System.in);
               
        System.out.println("Ingresa el valor de los renglones");
        int renglones = sc.nextInt ();
        System.out.println("Ingresa el valor de las 2columnas");
        int columnas = sc.nextInt ();
       
 Excepciones_Matriz m = new Excepciones_Matriz(renglones, columnas);
       
        m.Desplegar();
       
       
       
       
    }
   
}


Tengo que convertir una matriz de cadenas a la suma de sus letras en codigo ascii, por ejemplo tengo la palabra soleado, la suma de sus caracteres me daria 743, hasta este punto según yo ya lo tengo, pero despues de eso tengo que volver a sumar, pero esta ve serian los dígitos, entonces me quedaría 14, y nuevamente tengo que hacer el proceso y  me quedaría 5, alguien podría ayudarme a solucionar el problema.
Intente copiar y pegar parte del código una y ta vez, pero se que eso no se ve bien,les dejo mi código, espero alguien pueda ayudarme, de antemano gracias

package Parte_Final;

public class TBD__String {
   
     public static void main(String[] args) {

        String[][] BD = new String[14][5];
        int [][] BDSuma =new int[14][5];
        int [][] BDSuma2 =new int[14][5];
       
        BD [0][0] = "soleado"; BD[0][1] = "calor"; BD[0][2] = "alta"; BD[0][3] = "debil"; BD[0][4] ="no";
        BD [1][0] = "soleado"; BD[1][1] = "calor"; BD[1][2] = "alta"; BD[1][3] = "fuerte"; BD[1][4] ="no";
        BD [2][0] = "nublado"; BD[2][1] = "calor"; BD[2][2] = "alta"; BD[2][3] = "debil"; BD[2][4] ="si";
        BD [3][0] = "lluvia"; BD[3][1] = "templado"; BD[3][2] = "alta"; BD[3][3] = "debil"; BD[3][4] ="si";
        BD [4][0] = "lluvia"; BD[4][1] = "frio"; BD[4][2] = "normal"; BD[4][3] = "debil"; BD[4][4] ="si";
        BD [5][0] = "lluvia"; BD[5][1] = "frio"; BD[5][2] = "normal"; BD[5][3] = "fuerte"; BD[5][4] ="no";
        BD [6][0] = "nublado"; BD[6][1] = "frio"; BD[6][2] = "normal"; BD[6][3] = "fuerte"; BD[6][4] ="si";
        BD [7][0] = "soleado"; BD[7][1] = "templado"; BD[7][2] = "alta"; BD[7][3] = "debil"; BD[7][4] ="no";
        BD [8][0] = "soleado"; BD[8][1] = "frio"; BD[8][2] = "normal"; BD[8][3] = "debil"; BD[8][4] ="si";
        BD [9][0] = "lluvia"; BD[9][1] = "templado"; BD[9][2] = "normal"; BD[9][3] = "debil"; BD[9][4] ="si";
        BD [10][0] = "soleado"; BD[10][1] = "templado"; BD[10][2] = "normal"; BD[10][3] = "fuerte"; BD[10][4] ="si";
        BD [11][0] = "nublado"; BD[11][1] = "templado"; BD[11][2] = "alta"; BD[11][3] = "fuerte"; BD[11][4] ="si";
        BD [12][0] = "nublado"; BD[12][1] = "calor"; BD[12][2] = "normal"; BD[12][3] = "debil"; BD[12][4] ="si";
        BD [13][0] = "soleado"; BD[13][1] = "templado"; BD[13][2] = "alta"; BD[13][3] = "fuerte"; BD[13][4] ="no";
       
        int suma, n = 14, m = 5;
        System.out.printf("Matriz 1\n");
        for (int i = 0; i < n; i++) {
            System.out.printf("\n");
            for (int j = 0; j < m; j++) {

                System.out.printf("%s\t", BD[i][j]);

            }
        }

        System.out.printf("\n\n");

        System.out.printf("Matriz 2\n");

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

            System.out.printf("\n");

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

                int x = BD[i][j].length();

                suma = 0;

                for (int k = 0; k < x; k++) {

                    char aux1 = BD[i][j].charAt(k);

                    int aux2 = aux1;
                    suma = suma + aux2;

                }

                BDSuma[i][j] = suma;
                System.out.printf("%d\t", suma);

            }
        }
        System.out.printf("\n");

        System.out.printf("\nMatriz 3\n");

        for (int i = 0; i < n; i++) {
            System.out.printf("\n");
            for (int j = 0; j < m; j++) {

                int suma2 = 0;

                while (BDSuma[i][j] > 0) {

                    int x = BDSuma[i][j] % 10;

                    suma2 = suma2 + x;

                    BDSuma[i][j] = BDSuma[i][j] / 10;
                    //  System.out.printf("%d\t", BDSuma[i][j]);
                }
                 BDSuma2[i][j] = suma2;
                System.out.printf("%d\t", suma2);
            }
        }

           
       
        System.out.printf("\n");

        System.out.printf("\nMatriz 4\n");

        for (int i = 0; i < n; i++) {
            System.out.printf("\n");
            for (int j = 0; j < m; j++) {

                int suma3 = 0;

                while (BDSuma2[i][j] > 0) {

                    int x = BDSuma2[i][j] % 10;

                    suma3 = suma3 + x;

                    BDSuma2[i][j] = BDSuma2[i][j] / 10;
                    //  System.out.printf("%d\t", BDSuma[i][j]);
                }
                System.out.printf("%d\t", suma3);
            }
        }
    }
}⁠⁠⁠⁠

ASI LO IMPRIME Matriz 1

soleado   calor   alta   debil   no   
soleado   calor   alta   fuerte   no   
nublado   calor   alta   debil   si   
lluvia   templado   alta   debil   si   
lluvia   frio   normal   debil   si   
lluvia   frio   normal   fuerte   no   
nublado   frio   normal   fuerte   si   
soleado   templado   alta   debil   no   
soleado   frio   normal   debil   si   
lluvia   templado   normal   debil   si   
soleado   templado   normal   fuerte   si   
nublado   templado   alta   fuerte   si   
nublado   calor   normal   debil   si   
soleado   templado   alta   fuerte   no   

Matriz 2

743   529   418   512   221   
743   529   418   651   221   
741   529   418   512   220   
653   854   418   512   220   
653   432   649   512   220   
653   432   649   651   221   
741   432   649   651   220   
743   854   418   512   221   
743   432   649   512   220   
653   854   649   512   220   
743   854   649   651   220   
741   854   418   651   220   
741   529   649   512   220   
743   854   418   651   221   

Matriz 3

14   16   13   8   5   
14   16   13   12   5   
12   16   13   8   4   
14   17   13   8   4   
14   9   19   8   4   
14   9   19   12   5   
12   9   19   12   4   
14   17   13   8   5   
14   9   19   8   4   
14   17   19   8   4   
14   17   19   12   4   
12   17   13   12   4   
12   16   19   8   4   
14   17   13   12   5   

Matriz 4

5   7   4   8   5   
5   7   4   3   5   
3   7   4   8   4   
5   8   4   8   4   
5   9   10   8   4   
5   9   10   3   5   
3   9   10   3   4   
5   8   4   8   5   
5   9   10   8   4   
5   8   10   8   4   
5   8   10   3   4   
3   8   4   3   4   
3   7   10   8   4   
5   8   4   3   5   BUILD SUCCESSFUL (total time: 1 second)