Mostrando entradas con la etiqueta Teoria. Mostrar todas las entradas
Mostrando entradas con la etiqueta Teoria. Mostrar todas las entradas

jueves, 23 de julio de 2015

■ Estructura de una función C#

Una función es un método que contiene un conjunto de instrucciones que puede o no devolver un valor según se requiera.

Cuando la función no devuelve valor se dice que no tiene tipo, mientras que cuando si regresa un valor se dice que es una función con tipo. El tipo de la función dependerá del valor que esta regresa.

■ Estructura de la función

<ámbito> <tipo> Nombre(argumentos) {
    //Bloque de instrucciones
    //return Variable; //Únicamente cuando devuelve un valor
}

Donde:
Ámbito: Puede ser público o privado dependiendo de si queremos pueda ser accedida desde cualquier parte del programa o solo localmente en la clase a la que pertenezca.
Tipo: Tipo de valor que devolverá la función al ser invocada, puede ser int, bool, string, double, etc., o bien "void" si no regresará nada.
Nombre: Identificador o nombre que se le da a la función.
Argumentos: Datos de entrada con los que trabajará la función, puede no llevar.
Return: Solo cuando la función es con tipo, cuando es sin tipo no lleva return.


■ Ejemplo

• Sin parámetros ni tipo.
Función que solo muestra un mensaje.

public void Mensaje() {
    Console.WriteLine("Mensaje"); //En consola
    MiLabel.Text = "Mensaje"; //En un form
}

• Con tipo
Función que recibe dos números enteros y devuelve la suma

public int Suma(int n1, int n2) {
    return n1 + n2;
}

• De tipo boleano
Función que recibe un número y devuelve verdadero si es positivo o falso si no

public bool Positivo(int num) {
    if (num > 0) {
        return true;
    } else {
        return false;
    }
}


■ Llamada a la función

Consideremos la función "Suma" de tipo entero que regresa la suma de dos números pasados como parámetros.

• Si la función es local, es decir, se llama desde la misma clase:

1) Asignar su resultado a una variable y luego mostrar la variable
int resultado = Suma(num1, num2);
Console.Write(resultado);

2) Mostrar directamente su resultado:
Console.Write(Suma(num1, num2));


• Si la función pertenece a otra clase, pero es pública:

Primero debemos declarar un objeto del tipo de dicha clase:
NombreClase MiObjeto = new NombreClase();

Luego mediante este objeto invocamos la función:

1) Guardando el resultado en una variable
int resultado = MiObjeto.Suma(num1, num2);
Console.Write(resultado);

2) Mostrando resultado directamente
Console.Write(MiObjeto.Suma(num1, num2));


Nota: Cuando la función se asigna a una variable, ésta debe ser del mismo tipo que el valor que regresa la función.

Registros (record - struct)

Un registro es un tipo de dato estructurado que contiene un conjunto de campos cada uno de los cuales puede ser de igual o diferente tipo.

En Turbo Pascal / Delphi se conoce como "record" mientras que en C++ se denomina "struct".

Los registros o estructuras son útiles cuando se necesita manejar información de una entidad la cual contiene varios datos que bien pueden ser de diferentes tipos.

Por ejemplo pensemos en un alumno con datos como nombre, edad, peso, dirección, grado, etc.

Esto bien se puede manejar con variables individuales:

nombre : string;
edad : integer;
peso : real;
dirección : string;
grado : integer;


Los registros nos permiten manejar estos mismos datos de una manera más cómoda y clara, los datos anteriores usando un registro quedarían de la siguiente forma:

• Pascal

alumno = record
    nombre : string[40];
    edad : integer;
    peso : real;
    direccion : string[50];
    grado : integer;
end;

• C++

struct {
    char nombre[40];
    int edad;
    float edad;
    char direccion[50];
    int grado;
} alumno;


Aparentemente podría parecer lo mismo, pero la ventaja está al momento de usarlo, el llenado del registro con datos se haría de la siguiente forma (Pascal):

WriteLn('Ingreso de datos');
Write('Nombre: ');
ReadLn(alumno.nombre);
Write('Edad: ')
ReadLn(alumno.edad);
Write('Peso: ');
ReadLn(alumno.peso);
Write('Dirección: ');
ReadLn(alumno.direccion);
Write('Grado: ');
ReadLn(alumno.grado);

Como puede observarse a cada variable se antepone el nombre del registro al que pertenece, esto es muy útil cuando se manejan datos personales de diferentes tipos de personas, por ejemplo alumnos, maestros, administrativos, clientes, etc., ya que con el uso de registros el código de vuelve más claro y fácil de manejar, puesto que aunque se pidan los mismos datos para cada entidad, siempre estaremos especificando a que registro pertenece cada uno, ejemplo:

maestro.nombre;
alumno.nombre;
cliente.nombre;

Tenemos una variable llamada "nombre" pero que a su vez puede pertenecer a diferentes registros.

martes, 21 de julio de 2015

13.1 ► Determinar si un número es primo

Se dice que un número es primo cuando solo tiene dos divisores enteros que son entre 1 y entre si mismo.

Es decir, si "n" tiene más de dos divisores enteros "n" no es primo, si solo tiene dos divisores enteros entonces si es primo.

El 0 y 1 no se consideran, por lo que el primer número primo es el 2 porque solo tiene dos divisores enteros:

► 2
2 / 1 = 2 → Entre 1, el resultado es 2, 2 es entero
2 / 2 = 1 → Entre 2, el resultado es 1, 1 es entero
Tiene dos divisores enteros: 1 y 2, por lo tanto es primo

► 3
El 3 también es primo:
3 / 1 = 3 → Entre 1, el resultado es 3, 3 es entero
3 / 2 = 1.5 → El resultado es 1.5, 1.5 no es entero
3 / 3 = 1 → Entre 3, el resultado es 1, 1 es entero
Tiene dos divisores enteros: 1 y 3, por lo tanto es primo.

► 4
4 / 1 = 4 → Entre 1, el resultado es 4, 4 es entero
4 / 2 = 2 → Entre 2, el resultado es 2, 2 es entero
4 / 3 = 1.33 → El resultado es 1.33, 1.33 no es entero
4 / 4 = 1 → Entre 4, el resultado es 1, 1 es entero
Tiene 3 divisores enteros: 1, 2 y 4, por lo tanto no es primo

► 5
5 / 1 = 5 → Entre 1, el resultado es 5, 5 es entero
5 / 2 = 2.5 → Entre 2, el resultado es 2.5, 2.5 no es entero
5 / 3 = 1.66 → Entre 3, el resultado es 1.66, 1.66 no es entero
5 / 4 = 1.25 →  Entre 4, el resultado es 1.25, 1.25 no es entero
5 / 5 = 1 → Entre 5, el resultado es 1, 1 es entero
Tiene 2 divisores enteros: 1 y 5, por lo tanto es primo


■ Ejercicio 13.1: Determinar si un número es primo.

Para saber si un número es primo debemos contar cuantos divisores enteros tiene, para ello lo dividiremos tantas veces como el valor del propio número, es decir, si el número es "n", lo dividiremos entre 1, 2, 3, hasta "n" y contaremos los divisores enteros.

Si al final del ciclo contamos más de 2 divisores enteros quiere decir que el número no es primo.

¿Cómo sabemos si al dividir un número "n" entre "x" el resultado es un número entero?
Hacemos la división y si el residuo es 0, entonces el resultado de la división será entero, como se muestra en la siguiente imagen:



► Basándonos en esto, el algoritmo quedaría de la siguiente forma:

Variables
    numero, i, divisores tipo entero
Empieza
    divisores <- 0;
    Escribe "Ingresa número"
    Leer numero
    Para i<-1 hasta numero Hacer
        Si numero MOD i = 0 Entonces
            divisores <- divisores + 1
        Fin_si
    Fin_para
    Si divisores = 2 Entonces
        Escribe "El número es primo"
    Fin_si
Fin


*En pseudocódigo el MOD devuelve el residuo de la división, es como utilizar el %% en C# o Java.

viernes, 12 de septiembre de 2014

Sintaxis Básica CSharp

Sintaxis Básica de C#

• Algunas palabras reservadas

bool: Variable de tipo lógico
class: Clase
double: Variable de tipo flotante
float: Del tipo flotante
for: Ciclo repetitivo "para"
if: Estructura selectiva o condicional
int: De tipo entero
long: Entero largo
private: De tipo privado
public: De tipo público
static: Estático
string: Variable de tipo cadena de texto
System: Invocación al sistema
using: Librerías a utilizar
while: Estructura repetitiva "mientras"Write: Muestra un mensaje en pantalla (Consola)
WriteLine: Muestra un mensaje en pantalla con salto de línea
: (dos puntos) : Indica herencia (equivalente a "extends" en Java)


• Operadores

= : Asignación
+ : Suma
- : Sustracción
* : Multiplicación
/ : División
% : Módulo
== : Igualdar
< : Menor que
<= : Menor o igual a
> : Mayor que
>= : Mayor o igual a
!= : Diferente


• Operadores lógicos
&& : and
|| : or
! : not

• Tipos de datos primitivos
♦ Enteros
byte
int
long

♦ Reales
float
double

♦ Caracter
char

♦ Cadena
string

♦ Lógico
bool

domingo, 13 de julio de 2014

Diagrama de Flujo

El Diagrama de Flujo es un esquema con diversos componentes que nos permite representar gráficamente un algoritmo.

Cada componente del diagrama de flujo simboliza una instrucción del algoritmo y está conectado con los demás componentes mediante flechas que indican la línea de ejecución de las instrucciones de principio a fin. El diagrama de flujo viene siendo otra forma de ver el algoritmo.


■ Ejemplo



La imagen de arriba ejemplifica un Diagrama de Flujo muy simple, como puede observarse cada instrucción se encuentra dentro de una figura, ya sea una elipse, rombo, rectángulo, etc., éstas figuras son los componentes del diagrama y dependen del tipo de instrucción a la que representen.


■ Componentes

► El diagrama de flujo involucra diversos componentes gráficos, entre los más comunes están:

• Óvalo > Inicio o final del algoritmo

• Romboide > Mensaje en pantalla

• Rectángulo > Instrucción

• Rombo > Condición Si/No

• Flecha > Flujo de instrucciones



■ Generación del Diagrama de Flujo con PSeInt

PSeInt es un programa que nos permite escribir nuestros algoritmos en pseudocódigo y probarlos, al mismo tiempo el programa nos proporciona de forma automática el diagrama de flujo de nuestro algoritmo. (Para más detalles véase PSeInt)



viernes, 11 de julio de 2014

■ Ejemplo de Estructuras Anidadas

■ Estructuras Anidadas


El hecho de 'anidar' estructuras se refiere a colocar unas dentro de otras según se requiera, anidar estructuras o sentencias es unas práctica muy común en la programación ya que en algunas ocasiones es forzosamente necesaria y en otras ayuda a reducir y optimizar al mismo tiempo nuestro código.


► Ejemplo:
Para a <- 1 hasta 10 hacer
     Si a < 6 entonces
          Escribe "a es menor que 6"
     Si_No
          Escribe "a es mayor o igual que 6


En el ejemplo anterior se anidaron dos estructuras: un "si" (if) dentro de un "para" (for), por lo que la sentencia "si" se ejecutará tantas veces como se repita el "para".


Para que quede un poco más claro pensemos en otro ejemplo; supongamos que necesitamos leer las calificaciones finales de un grupo de 5 alumnos, del cual debemos contar y mostrar cuantos de ellos aprobaron y cuantos no lo hicieron.


Lo haremos de dos maneras, una sin recurrir a las estructuras anidadas y la segunda anidando las estructuras necesarias.

► 1) Sin anidar

Empieza
calif[5] tipo arreglo de reales
aprobados, reprobados tipo entero

Para i <-1 hasta 5 hacer
     Escribe "Ingresa calificación"
     Leer calif[i]
Fin_Para

Si calif[1] > 5.9 entonces
     aprobados <- aprobados + 1
Si_No
     reprobados <- reprobados + 1

Si calif[2] > 5.9 entonces
     aprobados <- aprobados + 1
Si_No
     reprobados <- reprobados + 1

Si calif[3] > 5.9 entonces
     aprobados <- aprobados + 1
Si_No
     reprobados <- reprobados + 1

Si calif[4] > 5.9 entonces
     aprobados <- aprobados + 1
Si_No
     reprobados <- reprobados + 1

Si calif[5] > 5.9 entonces
     aprobados <- aprobados + 1
Si_No
     reprobados <- reprobados + 1
Fin


► 2) Empleando Estructuras Anidadas

Empieza
     calif tipo real
     aprobados, reprobados tipo entero
     Para i <- 1 hasta 5 hacer
          Escribe "Ingresa calificación "
          Leer calif
          Si calif > 5.9 entonces
               aprobados <- aprobados + 1
          Si_No
               reprobados <- reprobados + 1
          Fin_Si
     Fin_Para
     Escribe "Número de aprobados: ",aprobados
     Escribe "Número de no aprobados: ",reprobados
Fin

► Conclusión

Como puede observarse, el primer ejemplo requiere más líneas de código que el segundo (aún cuando ambos hacen lo mismo) puesto que las estructuras no están anidadas, es decir, en el primer ejemplo se piden las calificaciones en un ciclo pero se evalúan una por una fuera del mismo.

La ventaja de anidar estructuras radica en el hecho de que podemos pedir y evaluar las calificaciones en el mismo ciclo con solo colocar nuestra sentencia "si" dentro del mismo ciclo "para" como se observa en el segundo ejemplo.

martes, 26 de julio de 2011

Métodos, Procedimientos y Funciones

■ Métodos

Un método es un segmento o bloque de código en el que se describe una serie de instrucciones que ejecutan determinada acción, el método recibe una serie de parámetros de entrada con los que trabajará para obtener el resultado y en algunos casos devolver un valor.

Cuando el método no devuelve ningún valor se dece que no tiene tipo, mientras que cuando es necesario que regresé cierto valor el método será con tipo, al igual que las variables.

Sintaxis para C# y Java.

Método sin tipo (no devuelve valor):

void nombreDelMetodo(parámetros) {
   //Acciones
}

Metodo con tipo (devuelve valor):

tipo nombreDelMetodo(parámetros) {
   //Acciones
     return valor;
}


En la Programación Esctructurada, particularmente en Pascal,  el equivalente al método viene siendo el Procedimiento para cuando no regresa nada, es decir, no tiene tipo; y las Funciones para cuando regresan un valor, es decir cuando tiene tipo.


■ Llamada al Método

En C# y Java pueden llamarse de varias formas.

1) Si el método es de la propia clase

Cuando el método pertenece a la propia clase que lo va usar, basta con invocarlo mediante su nombre y pasaándole los parámetros si es que lleva:

Método sin tipo:
nombreMétodo(parámetros);

Método con tipo:
variable = nombreMétodo(parámetros);


2) Si el método pertenece a otra clase

En la clase en la que se va invocar al método se debe crear un objeto de la clase propietaria del método que se va llamar:

ClaseSecundaria objetoClaseSecundaria = new ClaseSecundaria();

Habiendo creado este objeto ya podemos mediante él invocar a los métodos de dicha clase de la siguiente manera:

Método sin tipo:
objetoClaseSecundaria.nombreMétodo(parámetros);

Método con tipo:
variable = objetoClaseSecundaria.nombreMétodo(parámetros);



■ Procedimientos y Funciones

En Pascal en lugar de métodos se utilizan los llamados procedimientos y las funciones, los procedimientos para cuando no se necesita que devuelvan un valor y la funciones que si devuelven valores. Éstos ayudan a estructurar el código y de la misma forma hacerlo más corto y entendible.


► Un Procedimiento es también un segmento de código que realiza una determinada acción pero que no regresa valor, su estructura varía ligeramente dependiendo de si lleva o no parámetros, por ejemplo:

Sin paso de parámetros:
   Procedure nombreDelProcedimiento;
   Begin
      //Acciones
   End;

Con paso de parámetros:
   Procedure nombreDelProcedimiento(parámetros);
   Begin
      //Acciones
   End;


          ► Ver Procedimientos en Pascal

► La función es similar al procedimiento, su estructura es casi la misma, la única diferencia es que ésta debe tener un tipo específico debido a que regresa un valor, ese tipo debe especificarse en su declaración y aunque no es obligatorio que devuelva un valor si es forzoso indicar su tipo, es decir, puede usarse como si fuera un simple procedimiento pero ésta debe tener tipo.

Ejemplo de su estructura:

Sin paso de parámetros:
   Function nombreDeLaFuncion : tipo;
   Begin
      //Acciones
        nombreDeLaFuncion := valorDevuelto;
   End;

Con paso de parámetros:
   Function nombreDeLaFuncion(parámetros) : tipo;
   Begin
      //Acciones
        nombreDeLaFuncion := valorDevuelto;
   End;

Ejemplo de función que no devuelver valor:
   Function nombreDeLaFunción : tipo;
   Begin
      Write('Hola mundo');
   End;


Como vez ésta función no regresa ningún valor, es decir, se comporta como un simple procedimiento. A diferencia de C# y Java en donde los métodos que regresan valores deben llevar forzosamente el "return" indicando el valor devuelto.


■ Parámetros.

Los parámetros son variables con las que trabajarán los métodos, sea procedimiento o función, estos se pasan dentro de los paréntesis del método y deben ser del mismo tipo que las variables originales, ¿a qué me refiero con ésto?, cuando se declara el método deben especificarse las variables que éste recibirá como parámetros y al momento de llamar al método se le deben pasar valores del mismo tipo de los que éste recibe y en el mismo orden.

Ejemplo para C# o Java: Declarar un método que sume dos números que recibe como parámetros y que regrese el resultado.

Declaración:
   int Sumar(int n1, int n2) {
      return n1 + n2;
   }

Llamada:
   int numero1 = 1, numero2 = 2;

   int resultado = Sumar(numero1, numero2);

Al momento de llamar al método "Sumar" se le pasan como parámetros las variables "numero1" y "numero2" y éste recibe sus valores almacenándolos en sus propias variables "n1" y "n2", las cuales toman el valor de la variable que esté en su misma posición, o sea, n1 toma el valor de numero1 y n2 toma el valor de numero2.

Internamente el método trabaja con sus propias variables, es decir, con n1 y n2 y al final regresa el resultado de las instrucciones que tenga programadas. Este resultado es el que regresa en sí la función Sumar y se almacena en la variable "resultado".

domingo, 24 de julio de 2011

Arreglos Bidimensionales

Generalmente conocidos como Matrices, podría decirse que es un vector de vectores, es decir, un conjunto de datos del mismo tipo, cuya agrupación se representa mediante una tabla de tamaño m por n (m x n), donde m son las filas y n las columnas, por lo que en su declaración se debe especificar el tamaño mediante sus parámetros.

El primer elemento puede estar posicionado ya sea en el registro 0 o 1 dependiendo el lenguaje de programación empleado, por ejemplo en C# y Java sería 0 mientras que en Pascal es el 1.


• Declaración.

Su declaración dede tener la siguiente estructura:

<tipo> <nombre> <[filas][columnas]>

Ejemplo: Una matriz llamada calificaciones que almacene las calificaciones del primer y segundo parcial de un grupo de alumnos y además el promedio de las dos, es decir, se necesita un arreglo de m filas por 3 columnas. (Donde "m" sería el número de alumnos).

real calificaciones [m , 3]


Declarado en Pascal, Java y C#, quedaría así:

Pascal: calificaciones : array[1..m, 1..30] of real;
Java: double calificaciones[][] = new double[m][30];
C#: double[,] calificaciones = new double[m,30];


• Recorrido de la matriz.

Debido a que ésta almacena m filas por n columnas (m x n), forzosamente es necesario anidar dos ciclos para recorrerla, pueden ser "para" o "mientras" (for o while), aunque lo recomendable es usar el "para", la estructura con éste ciclo sería de la siguiente forma:

para <fila_inicial> hasta <fila_final> hacer
   para <columna_inicial> hasta <columna_final> hacer
      //Instrucciones
   fin_para
fin_para

viernes, 22 de julio de 2011

Arreglos Unidimensionales

Tambien llamados Vectores o matrices, los arreglos unidimensionales como su nombre lo indica, sólo tienen una dimensión, es decir, son lineales, únicamente pueden guardar una columna de datos.

Un arreglo es un conjunto contínuo de espacios en memoria que almacena datos todos del mismo tipo, su tamaño comunmente es estático y se define cuando éste es creado, la estructura del arreglo es como lo muestra la siguiente imagen:


Como puede observarse, el elemento inicial se posiciona en el registro 0, aunque en algunos lenguajes se maneja como 1, en el caso de Pascal el primer elemento se encuentra en la casilla 1, mientras que en C# y Java en la casilla 0, ésto debe tenerse muy en cuenta a la hora de programarlo.


• Declaración.

La declaración del arreglo lleva la siguiente estructura:

<tipo> <nombre_del_arreglo> <[tamaño]>

Ejemplo: Un arreglo llamado calificaciones de tamaño 30.

real calificaciones [30]


Pero la declaración depende del lenguaje empleado, por ejemplo el arreglo anterior en Pascal, Java y C#:

Pascal: calificaciones : array[1..30] of real;
Java: double calificaciones[] = new double[30];
C#: double[] calificaciones = new double[30];


• Recorrido de un arreglo.

Debido a que el arreglo almacena n número de datos, su llenado o consulta debe hacerse mediante un ciclo que lo recorra de principio a fin y es dentro del ciclo donde se van guardando o leyendo los valores almacenados en él.

Dicho ciclo puede ser cualquier estructura repetitiva, pero lo más recomendable es utilizar el ciclo "para" (for), puesto que conocemos su tamaño exacto, ésto es de la siguiente forma.


   ♦ Llenado del arreglo:

   dato tipo entero
   para <posicion = 0> hasta <tamaño_del_arreglo> hacer
      escribe "Ingresa dato"
      leer dato
      mi_Arreglo[ posicion ] = dato
   fin_para


   ♦ Lectura del arreglo:

   dato tipo entero
   para <posicion = 0> hasta <tamaño_del_arreglo> hacer
      dato = mi_Arreglo[ posicion ]
      escribe dato
   fin_para

Donde dato es una variable del mismo tipo que el arreglo, es decir, si el arreglo es de enteros, dato deberá ser tipo entero también.

miércoles, 20 de julio de 2011

Arreglos

Un Arreglo es como una variable pero que almacena varios datos todos del mismo tipo, se define como un contenedor que almacena en memoria de forma consecutiva un conjunto determinado de datos del mismo tipo, se requiere un espacio en memoria por cada dato almacenado, los espacios se encuentran contiguos y son determinados por el programador al declarar el arreglo.

Los arreglos se dividen en:
  • Unidimensionales (vector)
  • Bidimensionales (matriz)
  • Multidimensionales (tres o más dimensiones)


Unidimensional 

• Una columna por m filas, donde m es el tamaño del arreglo.
 


Bidimensional 

 • m filas por n columnas (m x n), donde m y n definen el tamaño de la matriz.
► (Véase arreglos multidimensionales)



Multidimensional
 • m filas por n columnas por z dimensiones (m x n x z), donde m, n y z definen su tamaño.

Operadores Aritméticos y Relacionales

■ Aritméticos:

     *    →  Multiplicación
     /    →  División
     +    →  Suma
     -    →  Resta
     MOD  →  Módulo


Ejemplo:

Considerando que:  a = 1     b = 5     c = 10

     • a * b  =  5
     • c / b  =  2
     • a + c  =  11
     • c - b  =  5
     • a + b * c = 51

Nota: Para cualquier duda consultar → Priodidad de Operadores Aritméticos.



■ Relacionales:

     >   →   Mayor que
     <   →   Menor que
     >=  →   Mayor o igual que
     <=  →   Menor o igual que
     <>  →   Diferente
     =   →   Igual


Ejemplo:

Considerando que:  a = 3     b = 7     c =10

     • a > b       →  Falso
     • a < c       →  Verdadero
     • c >= b      →  Falso
     • a + b <= c  →  Verdadero
     • a <> c      →  Verdadero
     • a + b <> c  →  Falso
     • a = c       →  Falso

Prioridad de los Operadores Aritméticos

Haciendo uso de los Operadores Aritméticos podemos realizar operaciones matemáticas con nuestras variables, éstos operadores sólo pueden aplicarse con valores numéricos, ya sean enteros o decimales, donde si ambos son enteros el resultado será entero, si uno de ellos es decimal el resultado será decimal.

entero <*,/,+,-> entero = entero
entero <*,/,+,-> decimal = decimal

Así mismo, los operadores aritméticos tienen cierta prioridad al evaluarse, es decir, unos se evaluan primero que otros, su prioridad es la siguiente:

1 - Exponentes (^)
2 - Multiplicación, División y Módulo (*, /, MOD)
3 - Suma y Resta (+, -)


De acuerdo a la prioridad, la evaluación se hace respetando lo siguiente:
  • Aquellos operadores de igual prioridad que estén en una misma expresión se evalúan de izquierda a derecha.
  • Todas las expresiones entre paréntises se evalúan primero.
  • Las expresiones con paréntesis anidados se evalúan de dentro hacía fuera, es decir, el paréntesis más interno se evalúa primero.


Ejemplos:

  • 5 + 3 * 2 = 11
  • 12 * 4 / 3 = 16
  • 8 + 2 * (11 - (2 + 3)) = 20
  • 1.5 * (2 + 5.3) = 10.95

martes, 19 de julio de 2011

Estructuras anidadas

Las estructuras anidadas no son más que las mismas estructuras, ya sean selectivas o repetitivas, pero colocadas unas dentro de otras, por ejemplo, podemos colocar un bloque "si" dentro de un ciclo "para" o dentro de un "mientras", y de la misma manera podemos colocar cualquiera de éstas estructuras dentro de cualquier otra.

Éstas pueden ser simples cuando se coloca únicamente una dentro de otra, o bien, compuestas cuando se colocan más de una dentro, como se ejemplifica a continuacuón.


■ Estructuras anidadas Simples:

• Bloque "si" dentro de ciclo "para":

para <valor_inicial> hasta <valor_final> hacer
   si <condición> entonces
      //Instrucciones
   fin_si
fin_para


• Bloque "si" dentro de ciclo "mientras":

mientras <condición> hacer
   si <condición> entonces
      //Instrucciones
   fin_si
fin_para


• Bloque "si" (1) dentro de otro bloque "si"; y bloque "si - si_no" (2) dentro de bloque "si":

1)                              2)
si <condición> entonces         si <condición> entonces
   si <condición> entonces         si <condición> entonces
      //Instrucciones                 //Instrucciones
   fin_si                          si_no
fin_si                                //Instrucciones
                                   fin_si
                                fin_si


• Ciclo "mientras" dentro de ciclo "para":

para <valor_inicial> hasta <valor_final> hacer
     mientras <condición> hacer
          //Instrucciones
     fin_mientras
fin_para



■ Estructuras anidadas Compuestas:

• Bloque "si" y bloque "si-si_no" dentro de ciclo "para":

para <valor_inicial> hasta <valor_final> hacer
   si <condición> entonces
      //Instrucciones
   fin_si
   si <condición> entonces
      //Instrucciones
   si_no
      //Instrucciones
   fin_si
fin_para



• Ciclo "para" y bloque "si" dentro de ciclo "mientras":

mientras <condición> hacer
   para <valor_inicial> hasta <valor_final> hacer
      //Instrucciones
   fin_para
   si <condición> entonces
      //Instrucciones
   fin_si
fin_mientras



■ Las estructuras anidadas anteriores vendrían siendo de dos niveles, puesto que sólo se anidarón una o varias dentro de la primera, también las puede haber de más niveles dependiendo de el número estructuras anidadas unas dentro de otras, por ejemplo:

• 3 niveles:

si <condición> entonces
   si <condición> entonces
      si <condición> entonces
         //Instrucciones
      fin_si
   fin_si
fin_si


• 4 niveles:

mientras <condición> hacer
   mientras <condición> hacer
      mientras <condición> hacer
         si <condición> entonces
            //Instrucciones
         fin_si
      fin_mientras
   fin_mientras
fin_mientras


Y así anidar de tantos niveles como sea necesario.