PSeInt - Guía 02

Les recomiendo realizar la guía, pero considerando el tiempo restante...
Si no entienden como realizar un problema, véanlo.

Problema 01 - Mostrar listado de numeros del 1 al 100 y su respectiva potencia al cuadrado
Problema 02 - Mostrar listado de numeros pares e impares del 1 al 100
Problema 03 - Mostrar listado de numeros pares desde N hasta 2
Problema 04 - Mostrar listado de factoriales hasta N numero
Problema 05 - Calcular factorial de un numero
Problema 06 - Calcular el factorial de 10 numeros
Problema 07 - Identificar numero mayor y menor entre 10 numeros generados
Problema 08 - Elevar una potencia con exponente variable
Problema 09 - Calcular una potencia ingresando la base y el exponente
Problema 10 - Calcular valor total respecto a la cantidad y precio de fotocopias
Problema 11 - Determinar cuándo A supera a B (cuando B supere a A)
Problema 12 - Determinar cantidad de iteraciones

Hay problemas mal desarrollados, hay formas de hacerlos más eficientes (Problema 12 y 8, creo).

PSeInt - Variables como lógico

 Un lógico es la asignacion de valores verdadero o falso a una variable. Con estas podemos definir límites, entradas de acceso, puntos de referencia, etc.

 Simplificando
 Tenemos una variable y la definimos como lógico.
 Al definir una variable "como lógico" esta solo podrá tomar dos valores: verdadero o falso.
 (Imaginemos que si el valor fuera falso, procesos se podrían detener, eliminar, cambiar, etc. Siendo posible que esta variable lógica sea utilizada de varias formas.)
  Teniendo esta variable lógica, podemos usarla como punto de referencia o acceso para datos.
//(Es decir, podemos usarlo como una condición para proseguir con una determinada acción, función, o  sección de código, por ejemplo: Un juego. Si tu nivel es superior a 9000 entonces a "misionesSecretas" se le asignara el valor "Verdadero" (*) y podrás realizar las misiones secretas. Mientras seas nivel inferior a 9000 (~(OVER 9000)) "misionesSecretas" se mantendra en "falso" y no podras realizarlas).

Ejemplo en PSeInt de un programa con uso de variables lógicos.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Proceso Respirando
    Definir respirar Como Logico;
    Definir condicionalRespirar Como Caracter;
    //
    respirar<-Verdadero;
    condicionalRespirar<-"";
    //
    Repetir
        Escribir "Inhalando";
        Esperar Tecla;
        Escribir "Exhalando";
        Esperar Tecla;
        Escribir "Desea parar de respirar? Para parar de respirar, ingrese cualquier caracter a excepción de 0.";
        Leer condicionalRespirar;
        Si condicionalRespirar <> "" Entonces
            respirar<-falso;
        FinSi
    Hasta que respirar = Falso;
  
    Repetir
        Escribir "Me ahogo...";
        Esperar Tecla;
        Escribir "Desea respirar? Para respirar, ingrese cualquier caracter a excepción de 0.";
        Leer condicionalRespirar;
        Si condicionalRespirar <> "" Entonces
            respirar<-verdadero;
            Escribir "respirando";
        FinSi
    Hasta que respirar = verdadero
  
FinProceso
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 A pesar de que el ejemplo no tenga un ciclo para seguir preguntando ssi deseamos parar o no de respirar, se puede apreciar la función de las variables lógicas.
 Al ejecutar el programa, este nos mostrará:

*** Ejecucion Iniciada. ***
Inhalando
Exhalando
Desea parar de respirar? Para parar de respirar, ingrese cualquier caracter a ex
cepción de 0.
>
Inhalando
Exhalando
Desea parar de respirar? Para parar de respirar, ingrese cualquier caracter a ex
cepción de 0.
> a
Me ahogo...
Desea respirar? Para respirar, ingrese cualquier caracter a excepción de 0.
>
Me ahogo...
Desea respirar? Para respirar, ingrese cualquier caracter a excepción de 0.
> a
Respirando

*** Ejecucion Finalizada. ***


(*) : Explicación de cómo"misionesSecretas<-verdadero" se podría aplicar en PSeInt.
(Si nivel>9000 Entonces misionesSecretas<-Verdadero. FinSi //// Si misionesSecretas=Verdadero Entonces <mostrar lista de misiones secretas> FinSi ( <mostrar lista de misiones secretas> = forma de explicar que hay más pseudocodigo dentro de este--> imaginese un codigo con muchos "Escribir", "Si" y más "Logico"/s incluidos)).



**********************************************************************************************************************
**********************************************************************************************************************

********************************************************************************************************************** **********************************************************************************************************************
 Si aún tienes dudas de "para qué" o "porqué" existe esta función, daremos un ejemplo mas amplio, pero no aplicable en PSeInt. En el siguiente ejemplo nos abstraeremos un poco, intenta relacionar :
Paradigma Orientado a Objetos, Soporte en Software y Programación de Algoritmos.
(intenta relacionarlos como sea, si no puedes razonar correctamente, solo sigue leyendo.)

**********************************************************************************************************************
**********************************************************************************************************************

 Sigamos con el ejemplo de respirar.

 Donde usamos esta clase? En el objeto cuerpo. // (Intenta distribuir los objetos del cuerpo en dominios, y éstos distribuirlos en distintas clases.)
 El objeto cuerpo necesita "recursos de sistema", como alimento, oxígeno y agua. // (Como organizaríamos el proceso cerebral de despertarnos? Intenta crear algo con byte, boolean, if, while, do while, go to, abstract, void, public, protected, ptivate, etc.)

 En el proceso de respirar, si es que este está funcionando, se activan y desactivan otros procesos, como inhalar y exhalar (que como ya sabemos, no podemos hacer al mismo tiempo). Y dentro de estos ocurren otros procesos, como por ejemplo en la sangre (distribución de oxigeno).

Intentemos escribir vágamente en pseudocódigo lo que creamos que debería pasar para cuando "respirar" esté asignado como "Verdadero".
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Proceso ejemploLogicos
//
//Para ahorrar tiempo, en vez de anteponer "proceso"/"rutaAbierta"/"rutaNoObstruída"/ //"funcionalidad" u otra función específica de los objetos, los encerramos en "<>", quedando como //"<objeto>".
//
Definir <víasNasales>, <faringe>, <traquea>,, <traquea>, <bronquio>, <pulónDerecho>, <pulónDerecho>, <pulónDerecho>, <pulónDerecho>, <pulmonIzquierdo>, <pulmonIzquierdo>, <pulmonIzquierdo>, <pulmonIzquierdo>, <respirar>, <inhalar>, <inhalar>, <inhalar>, <exhalar>, <exhalar>, <exhalar>, <distribuciónDeOxigeno>, <distribuciónDeNitrogeno>, <alveolo>, <alveolo>, <bronqueolo> como logico;

<víasNasales><-verdadero;
<faringe><-verdadero;
<traquea><-verdadero;
<traquea><-verdadero;
<bronquio><-verdadero;
<pulónDerecho><-verdadero;
<pulónDerecho><-verdadero;
<pulónDerecho><-verdadero;
<pulónDerecho><-verdadero;
<pulmonIzquierdo><-verdadero;
<pulmonIzquierdo><-verdadero;
<pulmonIzquierdo><-verdadero;
<pulmonIzquierdo><-falso;
<respirar><-verdadero;
<inhalar><-verdadero;
<inhalar><-verdadero;
<inhalar><-verdadero;
<exhalar><-verdadero;
<exhalar><-falso; 
<exhalar><-verdadero;
<distribuciónDeOxigeno><-verdadero;
<distribuciónDeNitrogeno><-verdadero;
<alveolo><-verdadero;
<alveolo><-verdadero;
<bronqueolo><-verdadero;
//
Mientras respirar = verdadero Hacer
        <inhalar> | <exhalar> ;
     Si inhalar = verdadero Entonces
          exhalar<-falso
     FinSi

(...)

FinProceso
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Si usted manejara directamente los impulsos eléctricos del cerebro:
 Cree que sería más recomendable, o incluso posible usar "Mientras"/s o "Si"/s para administrar estos procesos?
 Algunos de estos procesos (aunque no todos) no pueden ser realizados si otros fallan. Si tuviera un sistema que mostrara la condición actual de sus lógicos facilitaría bastante la busqueda para solucionar un problema, o aún mejor, un sistema para determinar qué procesos fallan.
  

PSeInt - Función Si

 La función "Si" nos sirve para crear una condición y decidir qué proceso realizará esta misma dependiendo si la variable cumple o no con la condición establecida.

Simplificando:
 La funcion "Si"  plantea una condición.
 Si la condición planteada se cumple, se realizará el proceso escrito dentro de la función.
 Si la condición no se cumple, el programa realizará otro proceso para el caso. Si no se ha establecido un proceso para el caso de tener un valor que no cumpla nuestra condición, el programa pasará de largo (seguirá corriendo).

Si punto = "macho" Entonces
//Escribir "deberia castrarlo";
Sino
//Escribir "debería operarla";
FinSi

 Si----------> Inicio de la función.
punto ------> Variable a la cual se le aplica una o varias (&/|) condiciones.
= ---------->  Simbolo igual.
"macho" --> Variable o constante (caracter, constante en este caso). Condición de la funcion.
Entonces -> Fin de los términos de la condición.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Proceso SeleccionDeProceso
    Definir respuesta Como Caracter;
    //
    respuesta<-"";
    //
    Escribir "Desea instalar el DirectX9c? ingrese [s] para continuar con la instalación o cualquier otra tecla para continuar.";
    Leer respuesta;
    Si respuesta = "s" Entonces
        Escribir "Espere un momento mientras Windows se prepara para la instalación.";
        Esperar Tecla;
    Sino
        Escribir "Fin de la instalación. EVE se ha instalado correctamente.";
    FinSi
FinProceso
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Al ejecutar el programa, este nos mostrará:

 *** Ejecucion Iniciada. ***
Desea instalar el DirectX9c? ingrese [s] para continuar con la instalación o cua
lquier otra tecla para continuar.
> s
Espere un momento mientras Windows se prepara para la instalación.
>

*** Ejecucion Finalizada. ***
o
*** Ejecucion Iniciada. ***
Desea instalar el DirectX9c? ingrese [s] para continuar con la instalación o cua
lquier otra tecla para continuar.
> si
Fin de la instalación. EVE se ha instalado correctamente.

*** Ejecucion Finalizada. ***

En caso de no cumplir con la condición de la función.


De esta forma, podemos crear condiciones que elijan un determinado proceso respecto a los valores ingresados.

PSeInt - Guía 01

Si aún no han intentado desarrollar el problema específico, se recomienda no revisarlas, ya que perderían la oportunidad de buscar una solución al problema y razonar el ejercicio.

Guía


Problema 01 - Sueldo respecto a tarifa y trabajo por hora
Problema 02 - Descuento al sueldo neto respecto al sueldo bruto
Problema 03 - Cálculo de descuento de un monto
Problema 04 - Cálculo de segundos restantes para el minuto exacto
Problema 05 - Conversión de minutos a días horas y minutos
Problema 06 - Determinación de Aprobacion Alumno segun notas - Funcion Segun
Problema 06 - Determinación de Aprobacion Alumno segun notas - Funcion Repetir
Problema 07 - Suma de los dígitos de un numero ingresado
Problema 08 - Calcular emisión de factura respecto a una condición
Problema 09 - Clasificar caracteristicas de numeros ingresados
Problema 10 - Muestra de factorial segun numero ingresado
Problema 11 - Promedio de numeros aleatorios
Problema 12 - Muestra de suma y producto de numeros pares

PSeInt - Función Mientras

La función "Mientras" nos sirve para repetir un proceso infinitas veces hasta que la condición expuesta para esto no se cumpla.

Simplificando
 Tenemos una condición, necesitamos que esta se repita hasta que el valor usado en la condición indique lo contrario.
 //(Necesitamos que un valor (guardado como String, int, boolean, double, entero, caracter, real, logico, piensenlo como quieran, pero dentro de un valor determinado) cumpla o no  ( ~ / no ) una condición.
 //(Respecto a la condición establecida, esta comenzará un proceso que se repetirá infinitas veces hasta que el valor que rige la condición indique lo contrario (para que la condición Mientras no se cumpla)).
//(Es decir que, en el caso de que la condición se cumpla, esta comenzara un loop infinito hasta que el valor que rige la condición sea modificado).

Mientras (~(variable = 0)) Hacer

Mientras (~(     variable    =        0)) Hacer
----------  (*)         (1)       (*)      (2)  -------


(*) ~ --> Negación para la condición. // (En este caso se lee:"Cuando variable no sea cero, hacer").

(1) Variable --> Valor ingresado a la condición // (Este valor regirá si los procesos de la condición "Mientras" se realizarán).
(*) = --> Simbolo igual. Parte de la condición // ( puede ser > ,<, =, <=, >= o <> en el caso de numeros).
(2) 0 -->  Valor numerico de la condición. // (En este caso es solo un valor numerico, pero podría ser otro tipo de variable; Ej:num00, una constante con valor de String; Ej:confirmacion00 o una palabra directamente escrita: "asadasa").


Dentro de la condición escribiremos los procesos a repetir. (Hasta que el valor que rija la condición no se cumpla). *Ingresaremos una lectura para no crear un loop infinito.*
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Proceso CondicionTerminosDeUso
    Definir respuesta Como Caracter;
    //
    Escribir "Esta de acuerdo con los terminos de uso?";
    Escribir "Si esta de acuerdo, ingrese: [ s ], si no, ingrese cualquier letra.";
    Leer respuesta;
    Mientras (respuesta <> "s") Hacer
        Escribir "Entonces no saldra de esta pantalla.";
        Escribir "Esta de acuerdo con los terminos de uso?";
        Escribir "Si esta de acuerdo, ingrese: [ s ], si no, ingrese cualquier letra.";      
        Leer respuesta;
    FinMientras
    Escribir "Gracias por aceptar nuestros terminos de uso.";
FinProceso
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Al ejecutar el programa, este nos mostrará:

*** Ejecucion Iniciada. ***
Esta de acuerdo con los terminos de uso?
Si esta de acuerdo, ingrese: [ s ], si no, ingrese cualquier letra.
> mm...no
Entonces no saldra de esta pantalla.
Esta de acuerdo con los terminos de uso?
Si esta de acuerdo, ingrese: [ s ], si no, ingrese cualquier letra.
> no
Entonces no saldra de esta pantalla.
Esta de acuerdo con los terminos de uso?
Si esta de acuerdo, ingrese: [ s ], si no, ingrese cualquier letra.
> m...
Entonces no saldra de esta pantalla.
Esta de acuerdo con los terminos de uso?
Si esta de acuerdo, ingrese: [ s ], si no, ingrese cualquier letra.
> ..
Entonces no saldra de esta pantalla.
Esta de acuerdo con los terminos de uso?
Si esta de acuerdo, ingrese: [ s ], si no, ingrese cualquier letra.
> no
Entonces no saldra de esta pantalla.
Esta de acuerdo con los terminos de uso?
Si esta de acuerdo, ingrese: [ s ], si no, ingrese cualquier letra.
> s
Gracias por aceptar nuestros terminos de uso.

*** Ejecucion Finalizada. ***

PSeInt - Función Para

La función "Para" nos sirve para repetir un proceso una determinada cantidad de veces hasta llegar a un número de referencia que determinará el fin del proceso.

Tenemos la función "Mientras", que repite un proceso mientras una condición se cumpla, es decir, mientras la condición que hayamos definido se cumpla, el programa validará internamente este proceso como "true", y comenzará su ejecución infinitas veces hasta que la condición que hayamos definido sea considerada como "false" (es decir, que no se cumpla). En el caso de la función "Para" esta se repetirá hasta que la variable definida llegue a su punto de referencia límite.

Para variable<-1 hasta numX Con Paso 1 Hacer

Para     variable  <-        1    hasta     numX   Con Paso    1    Hacer
                (*)      ----     (1)    ------      (2)      ---------   (3)   ------

(*) variable --> Asignación de un nombre para definir el proceso. // (Le doy un nombre al proceso).
(1) 1 --> Valor inicial asignado a la variable. // (El valor con el cual comenzará la variable).
(2) 2 --> Valor que la variable tomará como referencia de límite. // (Cuando "variable" llegue a numX, terminará de repetir el ciclo y el programa continuará).
(3) 1 --> Valor que se sumará a la variable cada vez que el ciclo se repita. // (Es decir, "variable" se modificará cada vez de termine un ciclo, sumándole a la variable en este caso "1" (Podría ser 2, 3, 3549, etc etc.) quedando el primer ciclo como "1", el segundo como "2" y así hasta que llegue a la condición de término).

Ahora que tenemos definidas las condiciones del proceso, tenemos que escribir qué occurrirá dentro de este, por ejemplo:

Para var01<- 1 Hasta 10 Con Paso 1 Hacer
Escribir "Hola", varEspacio, "por", varEspacio, var01, (... etc etc.) ;
FinPara

Nuestra variable creada para la función "Para" es "var01" y este proceso se repetirá hasta que esta variable (var01) tenga el valor "10".
En los procesos a realizar dentro de la función escribimos "Hola", varEspacio, var01 --> Incluimos la variable (recordemos que es una variable numérica, no un String o caracter) que se modificará cada vez que termine un ciclo.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Proceso RepeticionDeHolas
    Definir var01 Como Entero;
    Definir varEspacio Como Caracter;
    //
    varEspacio<-" ";
    //
    Para var01<-1 Hasta 10 Con Paso 1 Hacer
        Escribir "Hola", varEspacio, "por", varEspacio, var01, "°", varEspacio, "vez.";
    FinPara   
FinProceso
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Al ejecutar el programa, este nos mastrará:

*** Ejecucion Iniciada. ***
Hola por 1░ vez.
Hola por 2░ vez.
Hola por 3░ vez.
Hola por 4░ vez.
Hola por 5░ vez.
Hola por 6░ vez.
Hola por 7░ vez.
Hola por 8░ vez.
Hola por 9░ vez.
Hola por 10░ vez.

*** Ejecucion Finalizada. ***

De esta forma, podemos repetir un proceso una determinada cantidad de veces hasta que este llegue a el punto de término definido o predefinido.