Menu

Reporte errores menores en PseInt mayo 2023

Anonymous
2023-05-22
2023-05-30
  • Anonymous

    Anonymous - 2023-05-22

    Hola

    1. Al cerrar un archivo que no ha sido guardado o si el código ha tenido modificaciones muestra algunas veces la ruta completa en el título de la ventana emergente, el cual no permite identificar el nombre del archivo que se está guardando, otras veces muestra en el título "wxPseInt.exe"

    2: Al guardar un archivo no está colocando en el campo del nombre del algoritmo/proceso, en versiones anteriores lo efectuaba.

    2.1 para el control de versiones que realiza el estudiante al guardar como tomar como base el nombre actual del algoritmo/proceso

    3: El panel de 'Resultados' y 'ayuda de Acerca del error', deben actualizarse en cada corrida o ejecución nueva, muchas veces queda en estos paneles, los mensajes de corridas anteriores

    por ejemplo

    Proceso testPseint2023
        escribir "Bienvenidos a PseInt 2023";
        abc;
    FinProceso
    

    Muestra

    ERROR 106: Instrucción no válida.
    La instrucción de esta línea no se reconoce como una instrucción válida. Puede haber errores de tipeo.

    • Verifique que la palabra clave este escrita correctamente.
    • Si es una asignación recuerde utilizar el operador "<-" (o alternativamente el operador = si su perfil de lenguaje lo permite).

    Al eliminar la siguiente sentencia
    abc;

    el mensaje anterior prevalece, el cual no debe ser así.

     
    • Anonymous

      Anonymous - 2023-05-22

      Al definir un subproceso sin argumentos genera un error

      Proceso funcion_principal
          Escribir "Bienvenidos a PseInt " sin saltar;
          funcion_secundaria(  );
          Escribir "";
      FinProceso
      
      
      SubProceso funcion_secundaria(  )
          Escribir "2023";
      Fin SubProceso
      

      ERROR 247: Falta nombre de argumento.

      Si se elimina el paréntesis opera

      Proceso funcion_principal
          Escribir "Bienvenidos a PseInt " sin saltar;
          funcion_secundaria;
          Escribir "";
      Fin Proceso
      
      
      SubProceso funcion_secundaria
          Escribir "2023";
      Fin SubProceso
      

      RQ: para dar uniformidad a la definición de funciones, la función principal debería aceptar paréntesis, asi no tome argumentos. Los estudiantes, me preguntan siempre en cada curso, por que si un subproceso o función secundaria no requiere de argumentos se puede o no colocar un par de paréntesis de apertura y de cierre y porque no es igual en la función principal, esto les genera en su pensamiento una disrupción de conceptos y en la practica la función principal en algunos lenguajes si aceptan argumentos, el mismo C++ lo hace, otro lenguaje es Matlab, PASCAL, etc, además en pseint al predefinir una entrada debería hacerse por paso de argumentos y no por caja de dialogo

      Proceso funcion_principal(  )
          Escribir "Bienvenidos a PseInt " sin saltar;
          funcion_secundaria(  );
          Escribir "";
      FinProceso
      
      
      SubProceso funcion_secundaria(  )
          Escribir "2023";
      Fin SubProceso
      
       
  • Anonymous

    Anonymous - 2023-05-23

    nuevamente hay problemas al correr paso a paso un algoritmo en win10 64 bits

    Algoritmo pasar_arreglo
        definir v como entero;
        dimension v[3];
        v[0]=9; 
        v[1]=8;
        v[2]=7;
        f( v );
        escribir v[0];
        escribir v[1];
        escribir v[2];
    FinAlgoritmo
    
    
    Funcion f( v Por Referencia)
        v[0]=10; 
    FinFuncion
    

    aunque si cierro la app y la vuelvo abrir algunas veces funciona

    no entiendo muy bien como funciona Redimensionar un arreglo

    estoy probando lo siguiente

    Algoritmo pasar_arreglo
        definir v como entero;
        dimension v[3];
        v[0]=9; 
        v[1]=8;
        v[2]=7;
        f( v );
        escribir v[0];
        escribir v[1];
        escribir v[2];
    
        redimension v[4];
        escribir v[3];
    FinAlgoritmo
    
    
    Funcion f( v Por Referencia)
        v[0]=-9;    
    FinFuncion
    
    
    Funcion f1( v Por Referencia)
        v[3]=6;     
    FinFuncion
    

    Muestra: ERROR 288: Posición no inicializada (V(3)).

     
    • Anonymous

      Anonymous - 2023-05-23

      el código anterior si funciona, solo que me faltaba llamar a la segunda función =)

      Bueno se podría agregar este ejemplo a la lista de ejemplos predefinidas en Pseint

      Algoritmo pasar_arreglo
          definir v como entero;
          dimension v[3];
          v[0]=9; 
          v[1]=8;
          v[2]=7;
          f( v );
          escribir v[0];
          escribir v[1];
          escribir v[2];
      
          redimension v[4];
          f1( v );
          escribir v[3];
      FinAlgoritmo
      
      
      Funcion f( v Por Referencia)
          v[0]=-9;    
      FinFuncion
      
      
      Funcion f1( v Por Referencia)
          v[3]=6;     
      FinFuncion
      

      Lo que si veo es que aun no esta definido en la conversión a otros lenguajes, acá se necesitan colaboradores, esto es el código anterior como se porta a C, C++ C# etc, porque yo nunca he hecho en un lenguaje formal.

       
  • Anonymous

    Anonymous - 2023-05-24

    Hola

    Al abrir un archivo, y si luego se abre nuevamente el mismo archivo se coloca en una nueva pestaña, el cual no se debe hacer. Al ejecutar el algoritmo muestra el siguiente mensaje

    File 'C:\Users\user-name\pseint\temp_2.out' couldn't be removed (error 32: El proceso no tiene acceso al archivo porque está siendo utilizado por otro proceso.)

     
  • Anonymous

    Anonymous - 2023-05-24

    hola al convertir a C++, la función SubCadena en algunos casos al calcular el numero de elementos a subtraer llega a una expresión como --2 que en c++ es decremento

    Proceso substraer_str
        definir pos1, pos2 Como Entero;
        pos1 = 0; pos2 = 2;
        escribir SubCadena("hola",pos1,pos2);   
        escribir SubCadena("hola",0,2);
    FinProceso
    

    portado a c++

    # include<iostream>
    using namespace std;
    
    int main() {
        int pos1;
        int pos2;
        pos1 = 0;
        pos2 = 2;
        cout << string("hola").substr(pos1, pos2-pos1+1) << endl;
        cout << string("hola").substr(0, 2-(-1)) << endl; // aca esta el error
        return 0;
    }
    

    seria excelente si se portara como función

    ~~~
    # include<iostream>
    using namepace std;</iostream>

    string SubCadena( string s, int posicion1, int posicion2 );

    int main() {
    int pos1;
    int pos2;
    pos1 = 0;
    pos2 = 2;
    cout << string("hola").substr(pos1, pos2-pos1+1) << endl;
    cout << string("hola").substr(0, 2--1) << endl; // acá esta el problema cout << string("hola").substr(0, 2-(-1)) << endl;
    string s, s1;
    s = "hola";
    s1 = SubCadena( s, 0, 2 ); // INVOKA A LA FUNCION
    cout << s1 << endl;
    return 0;
    }

    // Por favor incluir en el port la siguiente función
    string SubCadena( string s, int posicion1, int posicion2 ){
    return string(s).substr(posicion1, (posicion2-posicion1)+1 );
    }
    ~~~

     
  • Anonymous

    Anonymous - 2023-05-28

    Hola
    A: Al pasar al panel grafico, algunas veces la instrucción SIN SALTAR, se une a una instrucción anterior, por ej.

    Escribir mensaje Sin Saltar;

    =>

    Escribir mensajeSin Saltar;

    B: Cuando se edita el diagrama de flujo, los comentarios se desfazan dos sentancias abajo.

     
  • Anonymous

    Anonymous - 2023-05-28

    Al ejecutar un algoritmo y luego pulsar ejecución paso a paso, se abre una segunda consola, pienso que se debe cerrar la actual y ejecutar una nueva consola pero paso a paso

     
  • Anonymous

    Anonymous - 2023-05-30

    Hola, algunos de los problemas detectados se presentan en códigos bastantes largos, en los cortos casi no

    por ejp.

    SubAlgoritmo modoBanco(flag_salir_menu_principal por referencia,arreglo_clientes_zonas por referencia,arreglo_zonas por referencia,arreglo_clientes por referencia,num_clientes_maximo,num_zonas_maximo,numCuenta por referencia)
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        Escribir ('');
        Definir mensaje Como Cadena;
        mensaje <- TABULACION3+'» ENTRANDO EN MODO BANCO';
        Escribir (mensaje);
        Esperar 1000 Milisegundos;
        Definir menu_zona_bancaria, menu_operaciones_banco, menu_seleccion_cliente Como Cadena;
        Definir menu_zona_bancaria_int, menu_operaciones_banco_int, menu_seleccion_cliente_int Como Entero;
        Definir test_menu Como Logico;
        Definir zona_actual, cliente_actual, num_clientes_zona Como Entero;
        Definir flag_salir_menu_operBanco, flag_salir_menu_zona Como Logico;
        Definir data_pag1_numCuenta, data_pag2_nombres, data_pag3_telefonos, data_pag4_email Como Entero;
        data_pag1_numCuenta <- 0;
        data_pag2_nombres <- 1;
        data_pag3_telefonos <- 2;
        data_pag4_email <- 3;
        flag_salir_menu_zona <- Falso;
        Mientras (flag_salir_menu_zona==Falso) Hacer
            test_menu <- Falso;
            Repetir
                Limpiar Pantalla;
                Esperar 200 Milisegundos;
                Si (test_menu==Verdadero) Entonces
                    Escribir ('Opción ['+(menu_zona_bancaria)+'] no disponible, vuelva a intentarlo');
                    Escribir ('');
                FinSi
                mensaje <- '+ MODO BANCO ¿En qué zona de Colombia desea registrar clientes?';
                Escribir (mensaje);
                mensaje <- TABULACION3+'Pulse [0]: Regresar menu Principal.';
                Para zona_actual<-0 Hasta num_zonas_maximo-1 Hacer
                    mensaje <- mensaje+' ['+ConvertirATexto(zona_actual+1)+']: '+arreglo_zonas[zona_actual]+'.  ';
                FinPara
                mensaje <- mensaje+" >";
                Escribir mensaje Sin Saltar;
                Leer menu_zona_bancaria;
                test_menu <- validar_numero_entero(menu_zona_bancaria);
                Si (test_menu==Verdadero) Entonces
                    menu_zona_bancaria_int <- ConvertirANumero(menu_zona_bancaria);
                    test_menu <- ((menu_zona_bancaria_int<0) O (menu_zona_bancaria_int>num_zonas_maximo));
                SiNo // almacena falso si es menú valido
                    test_menu <- Verdadero;
                FinSi
            Mientras Que (test_menu==Verdadero)
            Si (menu_zona_bancaria_int==0) Entonces
                Escribir TABULACION3+'Regresando a Menu Principal.';
                flag_salir_menu_zona <- Verdadero;
            SiNo
                Escribir ('');
                mensaje <- TABULACION3+'« CONSULTADO ZONA '+getZona(arreglo_zonas,menu_zona_bancaria_int);
                Escribir (mensaje);
                Esperar 1500 Milisegundos;
                flag_salir_menu_operBanco <- Falso;
                Mientras (flag_salir_menu_operBanco==Falso) Hacer
                    // MENU DE OPCIONES DEL BANCO
                    Limpiar Pantalla;
                    Esperar 200 Milisegundos;
                    test_menu <- Falso;
                    Repetir
                        Limpiar Pantalla;
                        Esperar 200 Milisegundos;
                        Si (test_menu==Verdadero) Entonces
                            Escribir ('Opción ['+(menu_operaciones_banco)+'] no disponible, vuelva a intentarlo');
                            Escribir ('');
                        FinSi
                        mensaje <- '+ MODO: BANCO. Zona: '+getZona(arreglo_zonas,menu_zona_bancaria_int)+' ¿Qué operación desea efectuar?';
                        Escribir (mensaje);
                        mensaje <- TABULACION3+'[0]: Regresar a Zonas Bancarias. Pulse [1]: Registrar Cliente.  [2]: Mostrar o cambiar información del Cliente. [3]: Mostrar información de Clientes entre zonas.>';
                        Escribir mensaje Sin Saltar;
                        Leer menu_operaciones_banco;
                        test_menu <- validar_numero_entero(menu_operaciones_banco);
                        Si (test_menu==Verdadero) Entonces
                            menu_operaciones_banco_int <- ConvertirANumero(menu_operaciones_banco);
                            test_menu <- ((menu_operaciones_banco_int<0) O (menu_operaciones_banco_int>3));
                        SiNo
                            test_menu <- Verdadero;
                        FinSi
                    Mientras Que (test_menu==Verdadero)
                    Segun (menu_operaciones_banco_int) Hacer
                        0:
                            flag_salir_menu_operBanco <- Verdadero;
                        1:
                            registroCliente(menu_zona_bancaria_int,arreglo_clientes_zonas,arreglo_zonas,arreglo_clientes,num_clientes_maximo,numCuenta);
                        2:
                            modificarCliente(menu_zona_bancaria_int,arreglo_clientes_zonas,arreglo_zonas,arreglo_clientes); // Registro de Clientes
                        3:
                            mostrarClientes(arreglo_clientes_zonas,arreglo_zonas,num_clientes_maximo,num_zonas_maximo);
                    FinSegun
                FinMientras
            FinSi
        FinMientras
    FinSubAlgoritmo
    
    SubAlgoritmo mostrarClientes(arreglo_clientes_zonas,arreglo_zonas,num_clientes_maximo,num_zonas_maximo)
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        Definir zona_actual Como Entero;
        Definir mensaje Como Cadena;
        Escribir '';
        mensaje <- '   » OPERACIÓN: CONSULTAR INFO CLIENTES POR ZONA';
        Escribir (mensaje);
        Esperar 1000 Milisegundos;
        mensaje <- '   » TOTAL CLIENTES POR ZONA:';
        Escribir (mensaje);
        Esperar 100 Milisegundos;
        Para zona_actual<-1 Hasta num_zonas_maximo Hacer
            mensaje <- '      Zona '+getZona(arreglo_zonas,zona_actual)+': '+ConvertirATexto(arreglo_clientes_zonas[zona_actual-1])+' cliente(s) encontrado(s).';
            Escribir (mensaje);
        FinPara
        Escribir (' ');
        Escribir TABULACION3+'« CONSULTA SATISFACTORIA.';
        Esperar 100 Milisegundos;
        Escribir TABULACION3+'» PULSE LA PANTALLA/[TECLA] PARA CONTINUAR. >';
        Esperar Tecla;
    FinSubAlgoritmo
    
    SubAlgoritmo modificarCliente(zona_actual,arreglo_clientes_zonas,arreglo_zonas,arreglo_clientes)
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        Definir cliente_actual, num_clientes_zona Como Entero;
        Definir test_menu Como Logico;
        Definir data_pag1_numCuenta, data_pag2_nombres, data_pag3_telefonos, data_pag4_email Como Entero;
        data_pag1_numCuenta <- 0;
        data_pag2_nombres <- 1;
        data_pag3_telefonos <- 2;
        data_pag4_email <- 3;
        Definir menu_zona_bancaria, menu_operaciones_banco, menu_seleccion_cliente Como Cadena;
        Definir menu_zona_bancaria_int, menu_operaciones_banco_int, menu_seleccion_cliente_int Como Entero;
        Definir mensaje Como Cadena;
        Escribir '';
        mensaje <- TABULACION3+'» OPERACIÓN: CONSULTAR INFO CLIENTE, ZONA '+getZona(arreglo_zonas,zona_actual);
        Escribir (mensaje);
        num_clientes_zona <- get_NumClientesZonas(arreglo_clientes_zonas,zona_actual);
        Esperar 100 Milisegundos;
        Si (num_clientes_zona==0) Entonces
            mensaje <- TABULACION3+'« En la Zona '+getZona(arreglo_zonas,zona_actual)+'. NO HAY CLIENTES REGISTRADOS.';
            Escribir (mensaje);
            Esperar 100 Milisegundos;
        SiNo
            Escribir ('');
            mensaje <- TABULACION3+'« En la  Zona '+getZona(arreglo_zonas,zona_actual)+'. Se encontró '+ConvertirATexto(num_clientes_zona)+' cliente(s).';
            Escribir (mensaje);
            test_menu <- Falso;
            Repetir
                Si (test_menu==Verdadero) Entonces
                    Escribir (TABULACION3+'« Opción ['+(menu_seleccion_cliente)+'] no disponible, vuelva a intentarlo');
                    Escribir ('');
                FinSi
                mensaje <- TABULACION3+'» SELECCIONE EL NUMERO DEL CLIENTE A CONSULTAR';
                Escribir (mensaje);
                Para cliente_actual<-0 Hasta num_clientes_zona-1 Hacer
                    mensaje <- TABULACION3+'» Cliente # ['+ConvertirATexto(cliente_actual+1)+']:  '+arreglo_clientes[zona_actual-1,cliente_actual,1];
                    Escribir (mensaje);
                FinPara
                Escribir TABULACION3+'» Salir: [0]';
                Escribir TABULACION3+'>'Sin Saltar;
                Leer menu_seleccion_cliente;
                test_menu <- validar_numero_entero(menu_seleccion_cliente);
                Si (test_menu==Verdadero) Entonces
                    menu_seleccion_cliente_int <- ConvertirANumero(menu_seleccion_cliente);
                    test_menu <- ((menu_seleccion_cliente_int<0) O (menu_seleccion_cliente_int>num_clientes_zona));
                SiNo
                    test_menu <- Verdadero;
                FinSi
            Mientras Que (test_menu==Verdadero)
            Si (menu_seleccion_cliente_int<>0) Entonces
                mensaje <- TABULACION3+'×××  Consultando en la BD, posicion'+' (Zona#'+ConvertirATexto(zona_actual)+', Cliente#'+ConvertirATexto(menu_seleccion_cliente_int)+', Cuenta: pag#1)';
                Escribir (mensaje);
                mensaje <- TABULACION3+'Cuenta del Cliente # '+arreglo_clientes[zona_actual-1,menu_seleccion_cliente_int-1,data_pag1_numCuenta];
                Escribir (mensaje);
                Escribir (' ');
                mensaje <- TABULACION3+'×××  Consultando en la BD, posicion'+' (Zona#'+ConvertirATexto(zona_actual)+', Cliente#'+ConvertirATexto(menu_seleccion_cliente_int)+', Nombre: pag#2)';
                Escribir (mensaje);
                mensaje <- TABULACION3+'Nombre del Cliente: '+arreglo_clientes[zona_actual-1,menu_seleccion_cliente_int-1,data_pag2_nombres];
                Escribir (mensaje);
                Escribir (' ');
                mensaje <- TABULACION3+'×××  Consultando en la BD, posicion'+' (Zona#'+ConvertirATexto(zona_actual)+', Cliente#'+ConvertirATexto(menu_seleccion_cliente_int)+', Telefonos: pag#3)';
                Escribir (mensaje);
                mensaje <- TABULACION3+'Telefonos del Cliente: '+arreglo_clientes[zona_actual-1,menu_seleccion_cliente_int-1,data_pag3_telefonos];
                Escribir (mensaje);
                Escribir (' ');
                mensaje <- TABULACION3+'×××  Consultando en la BD, posicion'+' (Zona#'+ConvertirATexto(zona_actual)+', Cliente#'+ConvertirATexto(menu_seleccion_cliente_int)+', Correo: pag#4)';
                Escribir (mensaje);
                mensaje <- TABULACION3+'Correo del Cliente: '+arreglo_clientes[zona_actual-1,menu_seleccion_cliente_int-1,data_pag4_email];
                Escribir (mensaje);
                Escribir (' ');
            FinSi
        FinSi
        Escribir (' ');
        Escribir TABULACION3+'« CONSULTA SATISFACTORIA.';
        Esperar 100 Milisegundos;
        Escribir TABULACION3+'» PULSE LA PANTALLA/[TECLA] PARA CONTINUAR. >';
        Esperar Tecla;
    FinSubAlgoritmo
    
    SubAlgoritmo cadena_texto_out <- f_eliminarEspacios(cadena_texto_in)
        Definir indice_cadena, long_cadena, pos_caracter Como Entero;
        Definir cadena_texto_out, car_consecutivo, parteLeft, parteRight Como Cadena;
        cadena_texto_out <- cadena_texto_in;
        long_cadena <- Longitud(cadena_texto_out);
        Para indice_cadena<-0 Hasta long_cadena-1 Hacer
            pos_caracter <- f_posicion_car(cadena_texto_out,' ');
            Si (pos_caracter>0) Entonces            
                car_consecutivo <- SubCadena(cadena_texto_out,pos_caracter,pos_caracter);
                // Escribir "-"+car_consecutivo+"-";
                Si (car_consecutivo=' ') Entonces
                    parteLeft <- SubCadena(cadena_texto_out,0,pos_caracter-2);
                    //Escribir "p-"+parteLeft+"-";              
                    parteRight <- SubCadena(cadena_texto_out,pos_caracter+1,Longitud(cadena_texto_out));
                    //Escribir "s-"+parteRight+"-";
                    cadena_texto_out <- parteLeft+parteRight;
                    long_cadena <- Longitud(cadena_texto_out);
                SiNo
                    parteLeft <- SubCadena(cadena_texto_out,0,pos_caracter-2);
                    //Escribir "p-"+parteLeft+"-";              
                    parteRight <- SubCadena(cadena_texto_out,pos_caracter,Longitud(cadena_texto_out));
                    //Escribir "s-"+parteRight+"-";
                    cadena_texto_out <- parteLeft+parteRight;
                    long_cadena <- Longitud(cadena_texto_out);
                FinSi
            SiNo
                indice_cadena <- long_cadena+10;
            FinSi
        FinPara
    FinSubAlgoritmo
    
    SubAlgoritmo zona_str <- getZona(arreglo_zonas,zona_num)
        Definir zona_str Como Cadena;
        zona_str <- arreglo_zonas[zona_num-1];
    FinSubAlgoritmo
    
    SubAlgoritmo num_clientes_zona <- get_NumClientesZonas(arreglo_clientes_zonas por referencia,zona_actual)
        Definir num_clientes_zona Como Entero;
        num_clientes_zona <- arreglo_clientes_zonas[zona_actual-1];
    FinSubAlgoritmo
    
    SubAlgoritmo incrementar_cliente_zona(arreglo_clientes_zonas por referencia,zona_actual,cliente_num)
        arreglo_clientes_zonas[zona_actual-1]<-cliente_num;
    FinSubAlgoritmo
    
    SubAlgoritmo suma_clientes_zonas <- get_SumaClientesZonas(arreglo_clientes_zonas por referencia,num_zonas_maximo)
        Definir suma_clientes_zonas, zona_actual, num_clientes_zona Como Entero;
        suma_clientes_zonas <- 0;
        Para zona_actual<-1 Hasta num_zonas_maximo Hacer
            num_clientes_zona <- arreglo_clientes_zonas[zona_actual-1];
            suma_clientes_zonas <- suma_clientes_zonas+num_clientes_zona;
        FinPara
    FinSubAlgoritmo
    
    SubAlgoritmo registroCliente(zona_actual,arreglo_clientes_zonas por referencia,arreglo_zonas por referencia,arreglo_clientes por referencia,num_clientes_maximo,numCuenta por referencia)
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        Definir mensaje, nombre_cliente, numero_telefono, correo Como Cadena;
        Escribir ('');
        Definir Fila1, Fila2, Columna1, Columna2, Columna3 Como Entero;
        Definir data_pag1_numCuenta, data_pag2_nombres, data_pag3_telefonos, data_pag4_email Como Entero;
        data_pag1_numCuenta <- 0;
        data_pag2_nombres <- 1;
        data_pag3_telefonos <- 2;
        data_pag4_email <- 3;
        Definir operador_telefonos_arr Como Cadena;
        Dimensionar operador_telefonos_arr(2,3);
        // Fila 1 para celulares, / Fila 2 para fijos
        Fila1 <- 0;
        Fila2 <- 1;
        Columna1 <- 0;
        Columna2 <- 1;
        Columna3 <- 2;
        operador_telefonos_arr[Fila1,Columna1]<-'300';
        operador_telefonos_arr[Fila1,Columna2]<-'310';
        operador_telefonos_arr[Fila1,Columna3]<-'320';
        operador_telefonos_arr[Fila2,Columna1]<-'250';
        operador_telefonos_arr[Fila2,Columna2]<-'260';
        operador_telefonos_arr[Fila2,Columna3]<-'-';
        Definir test_menu Como Logico;
        Definir menu_aux Como Entero;
        Definir menu_telefono, lista_telefonos Como Cadena;
        Definir menu_telefono_int, num_operadores, tipo_celular, num_digitos Como Entero;
        mensaje <- TABULACION3+'« OPERACIÓN: INSERTAR CLIENTE, ZONA '+getZona(arreglo_zonas,zona_actual);
        Escribir (mensaje);
        Definir num_clientes_zona Como Entero;
        num_clientes_zona <- get_NumClientesZonas(arreglo_clientes_zonas,zona_actual);
        // INCREMENTAR NUMERO DE CLIENTE
        Escribir (TABULACION3+'» El numero de clientes encontrados actualmente en la zona son: '+ConvertirATexto(num_clientes_zona)+' cliente(s)');
        Si (num_clientes_zona<num_clientes_maximo) Entonces
            num_clientes_zona <- num_clientes_zona+1;
            numCuenta <- numCuenta+1;
            incrementar_cliente_zona(arreglo_clientes_zonas,zona_actual,num_clientes_zona);
            mensaje <- TABULACION3+'×××  INSERCCION DE CLIENTE en la BD, posicion'+' ('+ConvertirATexto(zona_actual)+','+ConvertirATexto(num_clientes_zona)+')';
            Escribir (mensaje);
            mensaje <- TABULACION3+'» POR FAVOR REGISTRE LOS DATOS DEL CLIENTE';
            Escribir (mensaje);
    
            Escribir ('');
            Esperar 200 Milisegundos;
            mensaje <- TABULACION3+'» NOMBRE DE CLIENTE:';
            Escribir mensaje Sin Saltar;
            nombre_cliente <- f_validar_nombre('');
            arreglo_clientes[zona_actual-1,num_clientes_zona-1,data_pag2_nombres]<-nombre_cliente;
    
            Escribir ('');
            Esperar 200 Milisegundos;
            mensaje <- TABULACION3+'» CELULAR DEL CLIENTE:';
            Escribir (mensaje);
            lista_telefonos <- '';
            menu_aux <- 1;
            Repetir
                Segun (menu_aux) Hacer
                    0:
                        test_menu <- Falso;
                    1:
                        test_menu <- Falso;
                        Repetir
                            Si (test_menu==Verdadero) Entonces
                                Escribir ('Opción ['+(menu_telefono)+'] no disponible, vuelva a intentarlo');
                                Escribir ('');
                            FinSi
                            mensaje <- TABULACION3+'+ Seleccione el telefono a registrar';
                            Escribir (mensaje);
                            mensaje <- TABULACION3+'Pulse [0]: No Registar. [1]: Celular. [2]: Fijo Casa.   [3]: Fijo Oficina. >';
                            Escribir mensaje Sin Saltar;
                            Leer menu_telefono;
                            test_menu <- validar_numero_entero(menu_telefono);
                            Si (test_menu==Verdadero) Entonces
                                menu_telefono_int <- ConvertirANumero(menu_telefono);
                                test_menu <- ((menu_telefono_int<0) O (menu_telefono_int>3));
                            SiNo
                                test_menu <- Verdadero;
                            FinSi
                        Mientras Que (test_menu==Verdadero)
                        Segun (menu_telefono_int) Hacer
                            0:
                                arreglo_clientes[zona_actual-1,num_clientes_zona-1,data_pag3_telefonos]<-'NULO';
                            1:
                                num_operadores <- 3;
                                tipo_celular <- 1;
                                num_digitos <- 10;
    
                                numero_telefono <- f_validar_celular(operador_telefonos_arr,tipo_celular,num_digitos,num_operadores);
                                // Escribir "tel" + numero_telefono;
                                Si (lista_telefonos=='') Entonces
                                    lista_telefonos <- numero_telefono;
                                SiNo
                                    lista_telefonos <- lista_telefonos+', '+numero_telefono;
                                FinSi
                                arreglo_clientes[zona_actual-1,num_clientes_zona-1,data_pag3_telefonos]<-lista_telefonos;
                            2, 3:
                                num_operadores <- 2;
                                tipo_celular <- 2;
                                num_digitos <- 5;
    
                                numero_telefono <- f_validar_celular(operador_telefonos_arr,tipo_celular,num_digitos,num_operadores);
                                Si (lista_telefonos=='') Entonces
                                    lista_telefonos <- numero_telefono;
                                SiNo
                                    lista_telefonos <- lista_telefonos+', '+numero_telefono;
                                FinSi
                                arreglo_clientes[zona_actual-1,num_clientes_zona-1,data_pag3_telefonos]<-lista_telefonos;
                                // Escribir "tel" + numero_telefono;            
    
                        FinSegun
                        Si (menu_telefono_int<>0) Entonces
                            mensaje <- TABULACION3+'DESEA REGISTAR OTRO NUMERO TELEFÓNICO';
                            Escribir mensaje;
                            mensaje <- TABULACION3+'[0]: Salir [1]: Registrar otro telefono. >';
                            Escribir mensaje Sin Saltar;
                            Leer menu_telefono;
                            test_menu <- validar_numero_entero(menu_telefono);
                            Si (test_menu==Verdadero) Entonces
                                menu_telefono_int <- ConvertirANumero(menu_telefono);
                                test_menu <- ((menu_telefono_int==0) O (menu_telefono_int==1));
                                menu_aux <- menu_telefono_int;
                            SiNo
                                test_menu <- Verdadero;
                                menu_aux <- 0;
                            FinSi
                        FinSi
    
                FinSegun
            Mientras Que (test_menu==Verdadero)
    
            Escribir "";
            mensaje <- TABULACION3+'» E.MAIL DEL CLIENTE:';
            Escribir mensaje;
            mensaje <- TABULACION3+'» escriba el e.mail >';
            Escribir mensaje Sin Saltar;
            correo <- validar_correo("");
            arreglo_clientes[zona_actual-1,num_clientes_zona-1,data_pag4_email]<-correo;
    
    //      Escribir "";
    //      mensaje <- TABULACION3+'» DIRECCION DEL CLIENTE:';
    //      Escribir mensaje;
            arreglo_clientes[zona_actual-1,num_clientes_zona-1,data_pag1_numCuenta]<-ConvertirATexto(numCuenta);
        SiNo
            mensaje <- '   « NO SE PUEDE REGISTRAR EL CLIENTE, SUPERADO EL NUMERO DE CLIENTES EN ESTA ZONA: '+ConvertirATexto(num_clientes_maximo);
            Escribir (mensaje);
        FinSi
        Escribir (' ');
        Escribir TABULACION3+'« CONSULTA SATISFACTORIA.';
        Esperar 100 Milisegundos;
        Escribir TABULACION3+'» PULSE LA PANTALLA/[TECLA] PARA CONTINUAR. >';
        Esperar Tecla;
    FinSubAlgoritmo
    
    SubAlgoritmo modoCajero(flag_salir_menu_principal por referencia,arreglo_clientes_zonas por referencia,num_zonas_maximo)
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
    
        Escribir ('');
        Definir mensaje Como Cadena;
        Definir menu_operacion Como Cadena;
        Definir menu_operacion_int Como Entero;
        Definir test_menu como logico; 
        mensaje <- TABULACION3+'« ENTRANDO EN MODO CAJERO ...'; Escribir (mensaje);
        Limpiar Pantalla;
    
        Esperar 500 Milisegundos;
        Definir suma_clientes_zonas Como Entero;
        suma_clientes_zonas <- get_SumaClientesZonas(arreglo_clientes_zonas,num_zonas_maximo);
        Si (suma_clientes_zonas==0) Entonces
            mensaje <- TABULACION3+'« No hay clientes para realizar operaciones.';
            Escribir mensaje;
            Esperar 500 Milisegundos;
            //flag_salir_menu_principal <- Falso;
        SiNo        
            test_menu = Verdadero;
            Mientras (test_menu == Verdadero)
                mensaje = TABULACION3+"¿Qué transacción desea realizar?"; Escribir mensaje;
                mensaje = TABULACION3+"Pulse [0]: Regresar. [1]: Colsulta de Saldo. [2]: Abono. [3]: Retiro. [4]: Trasferencia. [5]: Cambio de clave. [6]: Pago de servicios. >";
                Escribir mensaje Sin Saltar;            
                Leer menu_operacion;
                test_menu <- validar_numero_entero(menu_operacion);
                Si (test_menu==Verdadero) Entonces
                    menu_operacion_int <- ConvertirANumero(menu_operacion);
                    test_menu <- ((menu_operacion_int<0) O (menu_operacion_int>6));
                SiNo
                    test_menu <- Verdadero;
                FinSi           
            FinMientras
            segun (menu_operacion_int)
                0:  // NOP
    
                1:
                    f_Colsulta_Saldo( "" ); 
                2: 
                    f_abono( "" );  
                3:
                    f_retiro( "" ); 
                4: 
                    f_transferencia( "" );  
                5:
                    f_cambio_clave( "" );   
                6: 
                    f_pago_servicios( "" ); 
    
            FinSegun
    
        FinSi   
    FinSubAlgoritmo
    
    SubAlgoritmo f_Colsulta_Saldo( null )
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        escribir TABULACION3;
    
        escribir TABULACION3+"funciones en construccion";
        Escribir TABULACION3+'» PULSE LA PANTALLA (TECLA) PARA CONTINUAR >';
        Esperar Tecla;
    FinSubAlgoritmo
    
    
    SubAlgoritmo f_abono( null )
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        escribir TABULACION3;
    
        escribir TABULACION3+"funciones en construccion";
        Escribir TABULACION3+'» PULSE LA PANTALLA (TECLA) PARA CONTINUAR >';
        Esperar Tecla;
    FinSubAlgoritmo
    
    SubAlgoritmo f_retiro( null )
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        escribir TABULACION3;
    
        escribir TABULACION3+"funciones en construccion";
        Escribir TABULACION3+'» PULSE LA PANTALLA (TECLA) PARA CONTINUAR >';
        Esperar Tecla;
    FinSubAlgoritmo
    
    SubAlgoritmo f_transferencia( null )
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        escribir TABULACION3;
    
        escribir TABULACION3+"funciones en construccion";
        Escribir TABULACION3+'» PULSE LA PANTALLA (TECLA) PARA CONTINUAR >';
        Esperar Tecla;
    FinSubAlgoritmo
    
    SubAlgoritmo f_cambio_clave( null )
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        escribir TABULACION3;
    
        escribir TABULACION3+"funciones en construccion";
        Escribir TABULACION3+'» PULSE LA PANTALLA (TECLA) PARA CONTINUAR >';
        Esperar Tecla;
    FinSubAlgoritmo
    
    SubAlgoritmo f_pago_servicios( null )
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        escribir TABULACION3;
    
        escribir TABULACION3+"funciones en construccion";
        Escribir TABULACION3+'» PULSE LA PANTALLA (TECLA) PARA CONTINUAR >';
        Esperar Tecla;
    FinSubAlgoritmo
    
    
    Proceso f_main_proyecto_final
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        Definir mensaje, animacion_banco Como Cadena;
        animacion_banco <- TABULACION3+'÷ Animacion BanColombia ÷';
        // MENU
        Definir flag_salir_menu_principal, test_menu Como Logico;
        flag_salir_menu_principal <- Falso;
        test_menu <- Falso;
        Definir menu_banco_o_cajero Como Cadena;
        Definir menu_banco_o_cajero_int Como Entero;
        // FIN de Menus
        // NÚMERO MÁXIMO DE CLIENTES Y ZONAS        
        Definir num_clientes_maximo, num_zonas_maximo Como Entero;
        num_clientes_maximo <- 3;
        num_zonas_maximo <- 4; // máxima población de cliente por zona, puede definirla variable por zona
        // FIN número máximo clientes y zonas
        // ARREGLOS
        // ARREGLO UNIDIMENSIONAL LISTA DE CLIENTES POR ZONA
        Definir arreglo_clientes_zonas Como Entero; // máximo número de zonas    
        Dimensionar arreglo_clientes_zonas(num_zonas_maximo);
        // Inicializar con 0 clientes
        Definir zona_actual Como Entero;
        // Para cada zona De arreglo_clientes_zonas Hacer
        // zona=0; // Cada zona con 0 clientes
        // FinPara    
        Para zona_actual<-0 Hasta num_zonas_maximo-1 Hacer
            arreglo_clientes_zonas[zona_actual] <- 0;
        FinPara // Cada zona con 0 clientes
        // FIN arreglo unidimensional lista de clientes por zona
        // ARREGLO UNI DE NOMBRES DE ZONA
        Definir arreglo_zonas Como Cadena;
        Dimensionar arreglo_zonas(num_zonas_maximo);
        arreglo_zonas[0] <- 'Central';
        arreglo_zonas[1] <- 'Cafetera';
        arreglo_zonas[2] <- 'Atlántica';
        arreglo_zonas[3] <- 'Pacifico';
        // arreglo_zonas[4]= "NUEVA ZONA DISPONIBLE";
        // arreglo_zonas[5]= "NUEVA ZONA DISPONIBLE";
        // FIN arreglo unidimensional  nombres zona
        num_zonas_maximo <- 4;
        Definir total_paginas Como Entero;
        total_paginas <- 4;
        // PAGINAS pagina#1: cliente_nombre, pagina#2: cliente_celular, pagina#3: cliente_cuenta, pagina#4: cliente_password ;
        Definir arreglo_clientes Como Cadena; // -> "Pacifico"
        Dimensionar arreglo_clientes(num_zonas_maximo,num_clientes_maximo,total_paginas);
        // FIN ARREGLOS
        Definir numCuenta Como Entero;
        numCuenta <- 1000;
        Escribir animacion_banco;
        Esperar 1500 Milisegundos;
        Mientras (flag_salir_menu_principal==Falso) Hacer
            // MENU PRINCIPAL
            Repetir
                Limpiar Pantalla;
                Esperar 200 Milisegundos;
                Si (test_menu==Verdadero) Entonces
                    Escribir ('Opción ['+(menu_banco_o_cajero)+'] no disponible, vuelva a intentarlo');
                    Escribir ('');
                FinSi
                mensaje <- '+  Seleccione Oficina Bancaria o Cajero Electrónico';
                Escribir (mensaje);
                mensaje <- TABULACION3+'Pulse [0]: Salir App. [1]: Banco.'+TABULACION3+'[2]: Cajero. >';
                Escribir mensaje Sin Saltar;
                Leer menu_banco_o_cajero;
                test_menu <- validar_numero_entero(menu_banco_o_cajero);
                Si (test_menu==Verdadero) Entonces
                    menu_banco_o_cajero_int <- ConvertirANumero(menu_banco_o_cajero);
                    test_menu <- ((menu_banco_o_cajero_int<0) O (menu_banco_o_cajero_int>2));
                SiNo
                    test_menu <- Verdadero;
                FinSi
            Mientras Que (test_menu==Verdadero)
            Si (menu_banco_o_cajero_int==0) Entonces
                    flag_salir_menu_principal <- Verdadero;
                    mensaje <- '+ Cerrando Aplicación de BanColombia';
                    Escribir (mensaje);
            Sino    
                Si (menu_banco_o_cajero_int==1) Entonces
                modoBanco(flag_salir_menu_principal,arreglo_clientes_zonas,arreglo_zonas,arreglo_clientes,num_clientes_maximo,num_zonas_maximo,numCuenta);
                SiNo // Repetir si es verdadero
                    Si (menu_banco_o_cajero_int==2) Entonces
                        modoCajero(flag_salir_menu_principal,arreglo_clientes_zonas,num_zonas_maximo);      
                    FinSi
                FinSi   
            FinSi
        FinMientras
    FinProceso
    
    SubAlgoritmo email <- validar_correo(NULO)
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        Definir mensaje Como Cadena;
        Definir cadena_valida_test Como Logico;
        Definir prefijo_cadena, sufijo_cadena, dominio, email Como Cadena;
        Definir posicion_caracter, posicion_caracter2, long_cadena Como Entero;
        // VALIDAR CORREO ELECTRÓNICO
        cadena_valida_test <- Verdadero;
        mensaje <- TABULACION3+'>';
        Repetir
            Si (cadena_valida_test==Falso) Entonces
                Escribir "";
                mensaje <- TABULACION3+'Escriba nuevamente el correo >';
                Escribir mensaje Sin Saltar;
            FinSi   
            Leer email;
            // email = "juan@gmail.com";
            posicion_caracter <- f_posicion_car(email,'@');
            //Escribir  posicion_caracter;
            cadena_valida_test = (posicion_caracter>0); //@
            Si (cadena_valida_test == Falso) Entonces       
                mensaje <- TABULACION3+'No se encontró ´@´';
                Escribir mensaje;
            SiNo                
                prefijo_cadena <- SubCadena(email,0,posicion_caracter-2); //pp@
                long_cadena <- Longitud(prefijo_cadena); // Extrae primera parte
    
                cadena_valida_test = (long_cadena>1); //pp@
                Si (cadena_valida_test == Falso) Entonces
                    mensaje <- TABULACION3+'El prefijo del correo debe contener mas de 1 caracter: ´'+prefijo_cadena+'´';
                    Escribir mensaje;
                SiNo
                    mensaje <- TABULACION3+'El prefijo del correo es ´'+prefijo_cadena+'´';
                    Escribir mensaje;
    
                    posicion_caracter2 <- f_posicion_car(email,'.');     //pp@. 
                    //Escribir "pos ." + ConvertirATexto(posicion_caracter2);
                    cadena_valida_test = (posicion_caracter2>0); 
                    Si (cadena_valida_test == Falso) Entonces               
                        mensaje <- TABULACION3+'No se encontró ´.´';
                        Escribir mensaje;   
                    SiNo                    
                        sufijo_cadena <- SubCadena(email,posicion_caracter,posicion_caracter2-2); //pp@ss.
                        // Escribir sufijo_cadena;
                        long_cadena <- Longitud(sufijo_cadena);                     
                        cadena_valida_test = (long_cadena>1);                   
                        Si (cadena_valida_test == Falso) Entonces
                            mensaje <- TABULACION3+'El sufijo del correo debe contener mas de 1 caracter: ´'+sufijo_cadena+'´'; // Extrae segunda parte
                            Escribir mensaje;
                        SiNo
                            mensaje <- TABULACION3+'El sufijo del correo es ´'+sufijo_cadena+'´';
                            Escribir mensaje;
                            long_cadena <- Longitud(email);
                            dominio <- SubCadena(email,posicion_caracter2,long_cadena); //.dd
                            long_cadena <- Longitud(dominio);                   
                            cadena_valida_test = (long_cadena>1);
                            Si (cadena_valida_test == Falso) Entonces
                                mensaje <- TABULACION3+'El dominio del correo debe contener mas de 1 caracter: ´'+dominio+'´'; // Extrae segunda parte
                                Escribir mensaje;
                            SiNo                            
                                mensaje <- TABULACION3+'El dominio del correo es: ´'+dominio+'´';
                                Escribir mensaje;
                                cadena_valida_test = (Minusculas(dominio)=='com' O Minusculas(dominio)=='co');
                                Si (cadena_valida_test == Verdadero) Entonces
                                    mensaje <- TABULACION3+'Dominio valido: ´'+dominio+'´. Correo valido ';
                                    Escribir mensaje; 
                                SiNo
                                    mensaje <- TABULACION3+'Dominio invalido: ´'+dominio+'´';
                                    Escribir mensaje;
                                FinSi
                            FinSi                       
                        FinSi
                    FinSi               
                FinSi
            FinSi
        Mientras Que (cadena_valida_test==Falso)
    FinSubAlgoritmo
    
    SubAlgoritmo num_telefono_str <- f_validar_celular(operador_arr por referencia,tipo_celular,num_digitos,num_operadores)
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        Definir mensaje, mensaje2 Como Cadena;
        Definir num_telefono_str, operador_tel, operador_tel2 Como Cadena;
        Definir indice_operador Como Entero;
        Definir posicion_caracter, posicion_caracter2, long_cadena Como Entero;
        Definir numerico_valido_test Como Logico;
        Definir test_valido_acumulado Como Logico;
        numerico_valido_test <- Verdadero;
        Repetir
            Si (numerico_valido_test==Falso) Entonces
                mensaje <- TABULACION3+'Numero de telefono invalido.';
                Escribir mensaje;
            FinSi
            Escribir '';
            mensaje2 <- '';
            Para indice_operador<-0 Hasta num_operadores-1 Hacer
                Si (mensaje2=='') Entonces
                    mensaje2 <- operador_arr[tipo_celular-1,indice_operador];
                SiNo
                    mensaje2 <- mensaje2+', '+operador_arr[tipo_celular-1,indice_operador];
                FinSi
            FinPara
            mensaje2 <- 'Operadores: '+mensaje2;
            Segun (tipo_celular) Hacer
                1:
                    mensaje <- TABULACION3+'Ingrese numero de celular de 10 digitos. '+mensaje2+' >';
                2:
                    mensaje <- TABULACION3+'Ingrese numero fijo hogar de 5 digitos. '+mensaje2+' >';
                3:
                    mensaje <- TABULACION3+'Ingrese numero fijo oficina de 5 digitos. '+mensaje2+' >';
            FinSegun
            Escribir mensaje Sin Saltar;
            Leer num_telefono_str;
            num_telefono_str = f_eliminarEspacios(num_telefono_str);    
    
            numerico_valido_test <- validar_numero_entero(num_telefono_str);
            Si (numerico_valido_test==Falso) Entonces
                mensaje <- TABULACION3+'Digitó un valor alfanumerico';
                Escribir mensaje;
            SiNo
                numerico_valido_test = (ConvertirANumero(num_telefono_str)>=0);
                Si (numerico_valido_test == Falso ) Entonces
                    mensaje <- TABULACION3+'Numero negativo';
                    Escribir mensaje;
                SiNo
                    long_cadena <- Longitud(num_telefono_str);
                    numerico_valido_test = (long_cadena==num_digitos);
    
                    Si (numerico_valido_test == Falso ) Entonces
                        mensaje <- TABULACION3+'Numero incorrecto de digitos';
                        Escribir mensaje;
                    SiNo
                        test_valido_acumulado = Falso;
                        Para indice_operador<-0 Hasta num_operadores-1 Hacer
                            operador_tel <- operador_arr[tipo_celular-1,indice_operador];
                            //Escribir operador_tel;
                            operador_tel2 <- SubCadena(num_telefono_str,0,2);
                            numerico_valido_test <- (operador_tel2==operador_tel);
                            test_valido_acumulado <- (test_valido_acumulado O numerico_valido_test);
                            // escribir test_valido_acumulado;                      
                        FinPara
                        numerico_valido_test = test_valido_acumulado;
                        Si (numerico_valido_test==Falso) Entonces                   
                            mensaje <- TABULACION3+'Operador '+operador_tel2+' invalido';
                            Escribir mensaje;   
                        SiNo    
                            mensaje <- TABULACION3+'Operador '+operador_tel2+' valido. Celular Valido: '+num_telefono_str;
                            Escribir mensaje;
                            Escribir "";
                        FinSi
                    FinSi
                FinSi
            FinSi
        Mientras Que (numerico_valido_test==Falso)
    FinSubAlgoritmo
    
    SubAlgoritmo nombre <- f_validar_nombre(NULO)
        Definir TABULACION3 Como Cadena;
        TABULACION3 <- '   ';
    
        Definir mensaje Como Cadena;
        Definir cadena_valida_test Como Logico;
        Definir nombre Como Cadena;
        Definir prefijo_cadena, sufijo_cadena Como Cadena;
        Definir posicion_caracter, posicion_caracter2, long_cadena Como Entero;
        cadena_valida_test <- Verdadero;
        // VALIDAR NOMBRE CLIENTE CON APELLIDO
        Repetir
            Si (cadena_valida_test==Falso) Entonces
                mensaje <- TABULACION3+'Nombre invalido.';
                Escribir mensaje;
            FinSi
            Escribir '';
            mensaje <- TABULACION3+'Ingrese primer nombre y primer apellido del cliente >';
            Escribir mensaje Sin Saltar;
            Leer nombre;
            cadena_valida_test <- validar_texto(nombre);
            Si (cadena_valida_test==Verdadero) Entonces
                posicion_caracter <- f_posicion_car(nombre,' ');
                Si (posicion_caracter>0) Entonces // Busca un espacio
                    prefijo_cadena <- SubCadena(nombre,0,posicion_caracter-2);
                    long_cadena <- Longitud(prefijo_cadena);
                    Si (long_cadena<=1) Entonces
                        mensaje <- TABULACION3+'El nombre debe contener más de un carácter: ´'+prefijo_cadena+'´';
                        Escribir mensaje;
                        cadena_valida_test <- Falso;
                    FinSi
                    long_cadena <- Longitud(nombre);
                    sufijo_cadena <- SubCadena(nombre,posicion_caracter,long_cadena);
                    long_cadena <- Longitud(sufijo_cadena); // Extrae el apellido
                    Si (long_cadena<=1) Entonces
                        mensaje <- TABULACION3+'El apellido debe contener más de un carácter: ´'+sufijo_cadena+'´';
                        Escribir mensaje;
                        cadena_valida_test <- Falso;
                    FinSi
                SiNo
                    cadena_valida_test <- Falso;
                FinSi // "el nombre no contiene un espacio para el apellido";
            FinSi
        Mientras Que (cadena_valida_test==Falso)
        posicion_caracter <- f_posicion_car(nombre,' ');
        prefijo_cadena <- SubCadena(nombre,0,posicion_caracter-2);
        Escribir TABULACION3+'El nombre del cliente es: ´'+prefijo_cadena+'´';
        long_cadena <- Longitud(nombre);
        sufijo_cadena <- SubCadena(nombre,posicion_caracter,long_cadena);
        Escribir TABULACION3+'El apellido del cliente es: ´'+sufijo_cadena+'´';
    FinSubAlgoritmo
    
    SubAlgoritmo cadena_valida_test <- validar_texto(dato_texto)
        Definir cadena_valida_test, test_valido_acumulado Como Logico;
        Definir pos_caracter, long_cadena Como Entero;
        Definir sub_caracter Como Cadena;
        test_valido_acumulado <- Verdadero;
        long_cadena <- Longitud(dato_texto);
        Para pos_caracter<-0 Hasta (long_cadena-1) Con Paso 1 Hacer
            sub_caracter <- SubCadena(dato_texto,pos_caracter,pos_caracter);
            // Escribir sub_caracter;
            // Forma alternativa
            Segun (sub_caracter) Hacer
                ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z':
                    cadena_valida_test <- Verdadero;
                    // "á", "é", "í", "ó", "ü", "Á", "É", "Í", "Ó", "Ü": // caracteres con acento
                De Otro Modo:
                    cadena_valida_test <- Falso; // debe estar deseleccionado: Limitar la estructura Según a variables de control numéricas     
            FinSegun
            test_valido_acumulado <- (test_valido_acumulado Y cadena_valida_test);
        FinPara
        cadena_valida_test <- test_valido_acumulado;
    FinSubAlgoritmo
    
    SubAlgoritmo numerico_valido_test <- validar_numero_entero(dato_texto)
        Definir numerico_valido_test, test_valido_acumulado Como Logico;
        Definir pos_caracter, long_cadena Como Entero;
        Definir sub_caracter Como Cadena;
        test_valido_acumulado <- Verdadero;
        long_cadena <- Longitud(dato_texto);
        Para pos_caracter<-0 Hasta (long_cadena-1) Con Paso 1 Hacer
            sub_caracter <- SubCadena(dato_texto,pos_caracter,pos_caracter);
            Segun (sub_caracter) Hacer
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-':
                    numerico_valido_test <- Verdadero;
                De Otro Modo:
                    numerico_valido_test <- Falso;
            FinSegun
            test_valido_acumulado <- (test_valido_acumulado Y numerico_valido_test);
        FinPara
        numerico_valido_test <- test_valido_acumulado;
    FinSubAlgoritmo
    
    SubAlgoritmo cadena_valida_test <- validar_alfaNumerico(dato_alfaNumerico)
        Definir cadena_valida_test, test_valido_acumulado Como Logico;
        Definir pos_caracter, long_cadena Como Entero;
        Definir sub_caracter Como Cadena;
        test_valido_acumulado <- Verdadero;
        long_cadena <- Longitud(dato_alfaNumerico);
        Para pos_caracter<-0 Hasta (long_cadena-1) Con Paso 1 Hacer
            sub_caracter <- SubCadena(dato_alfaNumerico,pos_caracter,pos_caracter);
            // Escribir sub_caracter;
            Segun (sub_caracter) Hacer
                ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z':
                    cadena_valida_test <- Verdadero;
                    // "á", "é", "í", "ó", "ü", "Á", "É", "Í", "Ó", "Ü": // caracteres con acento
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-':
                    cadena_valida_test <- Verdadero;
                De Otro Modo:
                    cadena_valida_test <- Falso;
            FinSegun
            test_valido_acumulado <- (test_valido_acumulado Y cadena_valida_test);
        FinPara
        cadena_valida_test <- test_valido_acumulado;
    FinSubAlgoritmo
    
    // Devuelve la posición entre 1 y 1000 del elemento buscado (primera ocurrencia), 
    // Si no encuentra devuelve 0, si hay error devuelve -1, devuelve -2 si se esta buscando la cadena vacia
    SubAlgoritmo posicion_caracter <- f_posicion_car(cadena_in,caracter_buscar)
        // Escribir "caracter a substraer. " + caracter_buscar + ":";
        Definir posicion_caracter Como Entero;
        Definir char_sub_i Como Cadena;
        Definir char_pos, char_maximo Como Entero; // caracter 'i' enesimo extraido
        Definir char_index Como Entero; // posicion del caracter a buscar y maximo num de chars
        Definir test Como Logico; // Indice de la extraccion de caracteres de la cadena ingresada
        Definir long_char_buscar Como Entero;
        long_char_buscar <- Longitud(caracter_buscar);
        char_maximo <- 1000;
        Si (long_char_buscar>1) Entonces // se asume que la cadena puede contener maximo 1000 chars
            char_pos <- -1; // Error: la cadena a buscar contiene mas de un caracter. devuelve -1
        SiNo
            Si (long_char_buscar==0) Entonces
                char_pos <- -2;
            SiNo
                Para char_index<-0 Hasta char_maximo Con Paso 1 Hacer
                    char_sub_i <- SubCadena(cadena_in,char_index,char_index); // se esta buscando la cadena vacia
                    // Escribir "caracter en indice" + ConvertirATexto(char_index+1) + " es " + char_sub_i;
                    test <- (char_sub_i<>'');
                    // Escribir "prueba1 " sin saltar ; Escribir test;
                    Si (test==Verdadero) Entonces
                        test <- (char_sub_i==caracter_buscar); // subtrae cada caracter, Mientras Que sea ""
                        // Escribir "prueba2 " sin saltar ; Escribir test;
                        Si (test==Verdadero) Entonces
                            char_pos <- char_index+1; // si el caracter es diferente de ""                    
                            char_index <- char_maximo+1; // posicion actual del indice+1 es la posicion del caracter a buscar
                        SiNo // Desborde para romper el bucle
                            char_pos <- 0;
                        FinSi // No se encontró el caracter 
                    SiNo
                        char_pos <- 0;
                        char_index <- char_maximo+1;
                    FinSi // Desborde para romper el bucle
                FinPara
            FinSi
        FinSi
        posicion_caracter <- char_pos;
    FinSubAlgoritmo
    
     

Anonymous
Anonymous

Add attachments
Cancel





MongoDB Logo MongoDB