viernes, 20 de julio de 2007

MATERIA

===================================================
MATERIA ANTERIOR:


http://tics-ic-ucentral-07.blogspot.com/


===================================================
MATERIA DEL SEMESTRE:

===================================================
Ju.02/08/07
CONFIGURACION DE UN MICROCOMPUTADOR:

Memorias + CPU + Unidades de E/ y S/




===================================================
ALGORITMOS:

Etapas en la solución de un problema:

1.- Definición y delimitación del problema
2.- Diagrama de flujo
3.- Prueba de escritorio (verificación manual)
4.- Codificación
5.- Digitación
6.- Compilación
7.- Ejecutar prgm
8.- Evaluar prgm


Tipos de Algoritmos:

1.- Cualitativos

Ej:

- Uso del celular
- Elaboración de una receta de cocina
- Fabricación de un auto
- Arado de la Tierra
- Manejo de un tractor


2.- Cuantitativos


Ej:
- Factorial de un nº
- Sol de ecuac de 2 grado
- Tx de base 10 a base 2
- Estadísticas
- Sumar 10 nºs
- Restar 5 nºs
- Multiplicar 2 nºs
- Dividir 2 nºs


CONCEPTOS BASICOS:

1.- VARIABLE


Variable = Dato
que puede o no cambiar
Nombre+valor

Tipos de Variables:
- Simples
- Suscritas (arreglos)

Nombre de una variable:
caracteres, letras y/o números
a
b
c
d
x
y
z
n
V
F
Dcto
VAN
TIR


2.- CONSTANTES
Valores que no cambian
Pi
e
i


3.- EXPRESIONES ARITMETICAS

Operadores aritméticos:
Exponente =
**
Multiplicación =
*
División =
/
Menos =
-
Más =
+
Factorial =
!

Expresiones Relacionales
Operador
Notación
Complemento

Mayor que
>
<=

Menor que
<
>=

Diferente
<>
=

Igual
=
<>

Menor o igual
<=
>

Mayor o igual
>=
<


===================================================

MA.07/08/07

REPRESENTACION ALGORITMO

Diagrama

Seudocódigo


1.- ENUNCIADO ASIGNACION

Composición ; (Ejemplo)

Var vs Variable ;
(Pam = Casa)

Var vs Expresión ;
(Pam = k+p*2)

Var vs Constante;
(Pam = 0)


2.- COMPOSICION de las CONDICIONES

Variable vs. Variable ; (Z=X)

Variable vs. Expresión ; (Z = A+B)

Variable vs. Constante ; (Z = 80)

Expresión vs. Variable ; (X + Y = Z)

Expresión vs. Expresión ; (X + Y = A + B)

Expresión vs. Constante ; (X + Y = 80)

Constante vs. Variable ; (80=Z)

Constante vs. Expresión ; (80 = A + B)


===================================================
3.- ENUNCIADO de DECISION (SI = if)

SI (variable vs variable)

ENTONCES
enunciado1

SINO
enunciado 2

FIN SI



Ej. Opción1:

S=40?

Si es menor
S= S*5

Si es mayor o igual
S= S*10


Ej. Opción 2:

S<40?

Si
S= S*5
No
S= S*10


COMPOSICIÓN del ENUNCIADO:

EJEMPLO:
Inicio
I = 0
A = 10

Si (A>20)

Entonces
I = I + 1

Sino
I = I + 2

Fin
Si

A = A + I
Fin


===================================================
4.- ENUNCIADO de REPETICION

a.-
HAGA MIENTRAS (A seamenor 10)
enunciado
FIN MIENTRAS

b.-
HAGA PARA INT= J hasta N, con INCREMENTOS DE X
Enunciado a repetir
FIN PARA


5.- ENUNCIADO DE LECTURA

LEA X, Y, Z


6.- ENUNCIADO DE ESCRITURA

ESCRIBA PAN, LECHUGA


7.- ENUNCIADO DE TERMINACIÓN

INICIO

FIN


===================================================
Resumen ALGORITMO:

Enunciado de Inicio
Enunciado de Lectura (E/)
Enunciado de Decisión
Enunciado de Repetición
Enunciado de Escritura (S/)
Enunciado de Término

FIN ALGORITMOS

===================================================
PROGRAMANDO EN C++


Estructura del prgm

/* librerias de inicio */
#include

/* empezando */
int main()

{ /*inicio del prgm */

/* Cuerpo del Prgm */

} /* fin del prgm */

/* Funciones:
después de main() puedo crear funciones */


===================================================
Tipos de variables:

%d = decimales
%o = octal
%x = hexadecimal
%c = caracter
%e = notación científica
%f = not. decimal
%g = e ó f
%s = cadena de caracteres

===================================================
COMANDOS
Librerías:
Programas que se repiten por lo que están abreviados por comandos
#include stdio.h
(no olvidar poner las paréntisis respectivas)


Dar incio y fin al Prgm
int main()
{
}


Declara las variables:
Int a,b,c;
ó
Float x,y;


Solicita a tu Cliente que escriba info en pantalla:
printf ("Ingresa un valor para la variable x ");


Salta de línea
printf("\n");


Lee la info que se ingresa al teclado:
Lee la variable x desde el teclado:
Scanf ("%d", x) ;

Lee una cadena:
gets(variable_cadena);

Entrega el nº de bytes:
sizeof( ) ;

Detener el ciclo
break;

===================================================
COMANDOS de SELECCION:

/*sentencia if */

if (sentencia)
sentencia 1
else if
sentencia 2
else if
sentencia 3
else
sentencia n


/*sentencia switch */
switch (selector)
case etiqueta 1 : sentencia 1;
case etiqueta 2 : sentencia 2;
case ....
case etiqueta n : sentencia n;
default: sentencia n+1


===================================================
SENTENCIAS de BUCLES:

/*sentencia for */

for (a=0; a mayor 5; a++)
{
sentencia
}

/*sentencia while */
while (a>15)
{
sentencia1
}
{
alternativa 2
}

===================================================
FUNCIONES:
Conj. de sentencias == Bibliotecas

TipoDeRetorno NombreFuncion (ListaDeParametros)
Funcion (expresion)
{
CuerpoDeLaFuncion (prgm)

return expresion
}


Ex.:
float suma (float num1, float num2)
{
float resp;
resp = num1+num2;
return resp;
}

===================================================
24/09/07
RECURSIVIDAD:

Función recursiva es aquella que se llama a si misma.

DIRECTA:
Se invoca a sí misma.

Ej:

int f(int x)
{
int n;

if (x menor ó igual a 0)
a= 2;
else
a= n + 2 * f(n-2) ;
return (a);
}

INDIRECTA:
Llama a otra que luego llamará a la primera

Ej:

int f(int y);

int g(int y)
{
if (y "menor" 3)
return y;
else
return (y+ f(y-2);
}

int f( int y)
{
if (y menor 2)
return (y);
else
return (y+g(y-2));
}

RECURSION vs ITERACION

Ambas son de repetición, pero:
La iteración posee una estructura repetitiva
La recursión posee una estructura de selección.

Ej: Nºs Fibonacci
Con una función no recursiva generar los números “Fibonacci”.
(0, 1 , 1 , 2 , 3 , 5 ,8 ,13 , 21 ,...)
an= an-1+ an-2


#include

int main( )
{
int n, z, i ;
n=1;

printf ("ingresa num=\n");
scanf ("%d", n);

for (i "desde" 2; i "hasta menor q" n; i ++);
z= fibonacci(n)
printf (“%d” , fibonacci(n));
system("PAUSE");
}

long int fibonacci (int n)

{
static int x= 0;
static int y= 1;

y = y + x;
x = y - x;
return y
}

x - y
0 - 1
1 - 1
1 - 2
2 - 3
3 - 5
5 - 8
8 -13
12 - 21


Ej: Factorial

#include

int main(int n)
{
int num, z, aux;
num=1;

printf ("ingresa num=\n");
scanf ("%d", &num);

z = fact(num);

printf ("el factorial del %d es = %d\n\n", num, z);

system("PAUSE");
}



int fact(int n)
{
int aux;

if (n<=1)
aux= 1;
else
aux= n * fact(n-1);
return (aux);
}

===================================================