Documentos de Académico
Documentos de Profesional
Documentos de Cultura
+-Algoritmo raíces
|
| Variables reales a,b,c,x,y
|
| Escribir "Introduzca los coeficientes de mayor a menor grado."
| Leer a,b,c
|
| +-Si sqr(b)>= 4*a*c entonces
| | x=(-b+sqrt(b^2-4*a*c))/2a
| +-Sino
| | Escribir "No existen raíces reales."
| +-Finsi
|
+-Final
0.4 Organigramas.
Símbolos generales:
+-Algoritmo Suma
|
| Variable entera a,b
|
| Escribir "Indique el primer sumando"
| Leer a
| Escribir "Indique el segundo sumando"
| Leer b
| c=a+b
| Escribir "El resultado es: ";c
|
+-Final
+----------------------------+
| T R A Z A |
+------------+---------------+
| Comentario | Valores |
+------------+---------------+
| Leemos a: | a <- 4 |
| Leemos b: | b <- 5 |
| Calcula c: | c <- a+b <- 9 |
| Escribe c: | c <- 9 |
+------------+---------------+
Ejemplo:
1.2.1 Tipos.
Ejemplo:
+-Algoritmo Circunferencia
|
| Constante real PI=3.1416
| Variable real r,c
|
| Escribir "Introduzca el radio de la circunferencia"
| Leer r
| c=2*Pi*r
| Escribir "Su longitud es: ",c
|
+-Final
+-Algoritmo Producto_Escalar
|
| Vector entero a[1..3], b[1..3]
| Variable entera c
|
| Escribir "Introduzca el vector A (x,y,z)"
| Leer a[1],a[2],a[3]
| Escribir "Introduzca el vector B (x,y,z)"
| Leer b[1],b[2],b[3]
|
| c=a[1]*b[1]+a[2]*b[2]+a[3]*b[3]
|
| Escribir "El producto escalar es: ",c
|
+-Final
+-Algoritmo Circunferencia
|
| Constante real PI=3.1416
| Variable real r,c
|
+---->Escribir "Introduzca el radio de la circunferencia"
Bloque | | Leer r
del | | c=2*Pi*r
Programa+---->Escribir "Su longitud es: ",c
|
+-Final
+-Algoritmo Factorial
|
| Variable real num,valor
|
| Escribir "Introduzca el número a factorizar:"
| Leer num
|
| Factor(num,valor) <- Llama al Procedimiento Factor
| | |
| +---+---> Parámetro Actuales.
|
| Escribir "El factorial es: ",valor
|
+-Final
Ejemplo:
+--------------------+------------------------+
| Variables Locales | Subalgoritmo propio |
| Variables Globales | Cualquier subalgoritmo |
+--------------------+------------------------+
TEMA 3: Sentencias
- Sentencias Simples.
- Sentencias Compuestas.
- Sentencias de control del flujo del algoritmo.
+-------------+-----------------------------------------------+
| + | Suma |
| - | Resta |
| * | Producto |
| / | División (devuelve un valor real) |
| div | División (devuelve un valor entero) |
| mod | Cálculo del módulo aritmético. |
| log | Logaritmo en base 10 |
| ln | Logaritmo neperiano |
| exp | Exponencial de un número |
| pow | Potencia de un número |
| random | Obtención de un número aleatorio |
| abs | Obtenemos el valor absoluto de un número |
| sqr | Obtención del cuadrado de un número |
| sqrt | Obtención de la raíz cuadrada |
| sin,cos,tan | Funciones trigonométricas |
| chr/toascii | Obtenemos un carácter a partir de un número |
| ord | Obtenemos el número correspondiente al código |
| | ASCII |
+-------------+-----------------------------------------------+
+----+-----------------+
| = | Igual a |
| < | menor que |
| > | mayor que |
| <= | menor o igual a |
| >= | mayor o igual a |
| <> | distinto de |
+----+-----------------+
Operadores booleanos:
+--------------------------+
| true AND true -> true |
| true AND false -> false |
| false AND true -> false |
| false AND false -> false |
+--------------------------+
+-------------------------+
| true OR true -> true |
| true OR false -> true |
| false OR true -> true |
| false OR false -> false |
+-------------------------+
Operador XOR: (se cumple cuando las dos condiciones son distintas)
+--------------------------+
| true XOR true -> false |
| true XOR false -> true |
| false XOR true -> true |
| false XOR false -> false |
+--------------------------+
+--------------------+
| NOT true -> false |
| NOT false -> true |
+--------------------+
- Cerrar (variable)
- Leer/Escribir/Reescribir (variable1,variable2)
- NO fin (variable)
Ejemplo: En este ejemplo se intenta dar aun visión general del uso
de ficheros secuenciales.
+-Algoritmo Copiar_fichero
|
| Fichero de enteros Origen,Destino
| Variable entera x
|
| Escribir ("Indique el nombre del fichero Origen:");
| Leer Origen
| Escribir ("Indique el nombre del fichero Destino:")
| Leer Destino
|
| Abrir secuencial (Origen)
| Iniciar lectura en (Origen)
| Abrir secuencial (Destino)
| Iniciar escritura en (Destino)
|
| +-Mientras (NO fin(Origen)) hacer
| | Leer (Origen,x)
| | Escribir (Destino,x)
| +-Finmientras
|
| Escribir ("Fichero Copiado:")
|
| Cerrar (Origen)
| Cerrar (Destino)
|
+-Final
Ejemplo:
+-Registro datos-alumno
| Cadena nombre
| Cadena apellido1
| Cadena apellido2
| Cadena NIF
| Cadena curso
| Cadena telefono
| Cadena fecha_nac
| ...
+-Finregistro
+-----+------------+
| Reg | D A T O |
+-----+------------| Fíjese que los datos están
| 1 | LUIS | almacenados en el orden en el
| 2 | CARLOS | que han sido introducidos por el
| 3 | TERESA | usuario.
| 4 | JOAQUIN |
| 5 | INMA | Accedemos a los datos por medio
| 6 | JOSE | del valor de la posición del
+-----+------------+ registro.
Ejemplo:
+-Algoritmo Contador_de_registros.
|
| Fichero de enteros F
| Variable entera x,contador
|
| Abrir directo (F)
| Iniciar lectura (F)
| contador = 0
| +-Mientras (NO fin(F)) hacer
| | Leer directo(F,x)
| | contador=contador+1
| +-Finmientras
| Cerrar(F)
|
| Escribir ("El fichero:";F;"posee:";contador;"reg.")
|
+-Final
+------------+-------------------------------------+
| Clave | Clave Clave Clave |
| Principal | Secundaria Secundaria Secundaria |
+--------------------------------------------------+
+---------+------------+------------+-------------+--------+
| (Direc) | (D.N.I.) | (Nombre) | (Provincia) | (Edad) |
+---------|------------|------------|-------------|--------+
| 1 | 55.366.546 | LUIS | Las Palmas | 16 |
| 2 | 42.386.225 | CARLOS | Salamanca | 17 |
| 3 | 32.387.203 | TERESA | Oviedo | 16 |
| 4 | 46.399.554 | INMA | Palencia | 20 |
| 5 | 60.643.434 | JOAQUIN | Salamanca | 17 |
| 6 | 22.543.986 | JOSE | Las Palmas | 23 |
+---------+------------+------------+-------------+--------+
Como podemos observar, esto sería un ejemplo de un fichero
indexado.
+------------+---------+ +------------+---------+
| (D.N.I.) | (Direc) | | (Nombre) | (Direc) |
+------------+---------| +------------+---------+
| 22.543.986 | 6 | | CARLOS | 2 |
| 32.387.203 | 3 | | INMA | 4 |
| 42.386.225 | 2 | | JOAQUIN | 5 |
| 46.399.554 | 4 | | JOSE | 6 |
| 55.366.546 | 1 | | LUIS | 1 |
| 60.643.434 | 6 | | TERESA | 3 |
+------------+---------+ +------------+---------+
+--------------------------+ +---------------------------+
| Tabla de Ac. Clave Princ.| | Tabla de Ac. Clave Secund.|
+--------------------------+ +---------------------------+
- Cerrar (variable)
- Leer/Escribir/Reescribir (variable1,KEY=,variable2)
- NO fin (variable)
Esta función devuelve el valor lógico 'true' si no se ha
encontrado el final del fichero; y devuelve el valor lógico 'false'
si se ha encontrado el final del fichero.
- Error (variable)
Ejemplo:
+-Algoritmo Buscar_Persona.
|
| +-Registro estructurado datos_personales
| | Variable cadena dni
| | Variable cadena nombre
| | Variable cadena tlf
| | Variable cadena provincia
| +-Finregistro
|
| Fichero de datos_personales F
| Variable cadena documento
| Variable de datos_personales dato
|
| Escribir "Indique el DNI de la persona a buscar"
| Leer documento
|
| Abrir indexado (F,KEY=dni,nombre)
| Iniciar lectura (F)
|
| Leer (F,KEY=documento,dato)
| +-Si error(F)<>0 entonces
| | Escribir "Ese registro no existe."
| +-Sino
| | Escribir " DNI: ";dato.dni
| | Escribir " Nombre: ";dato.nombre
| | Escribir " Tlf: ";dato.tlf
| | Escribir "Provincia: ";dato.provincia
| +-Finsi
|
| Cerrar (F)
+-Final
Veamos un ejemplo:
+-Algoritmo Orden_selección
|
| Constante entera n=...
| Vector entero a(1..n)
| Variable entera x,i,j,h,mayor
|
| Escribir "Introduzca el vector a ordenar"
| +-Para h desde 1 hasta n hacer
| | Leer a(h)
| +-Finpara
|
| +-Para k desde 1 hasta n-1 hacer
| | mayor <- k
| | +-Para j desde k+1 hasta n hacer
| | | +-Si a(j)<a(i) entonces mayor <-j
| | | +-Finsi
| | +-Finpara
| | x <- a(j)
| | a(j) <- a(i)
| | a(i) <- x
| +-Finpara
| Escribir a
+-Final
+-Algoritmo Busqueda_secuencial
|
| Constante entera n=...
| Vector entero a(1..n)
| Variable entera x,i,j,h,mayor
|
| Escribir "Introduzca el valor a buscar"
| Leer x
|
| k <- 0
| +-Repetir
| | k <- k+1
| | +-Si a(k)=x entonces
| | | Escribir "El dato: ";a;
| | | "esta en la posición: ";k
| | +-Finsi
| +-Hasta que (k=n) or (a(k)=x)
+-Final
+-Algoritmo Búsqueda_dicotómica
|
| Constante entera n= ...
| Vector de enteros a(1..n)
| Variable entera x,i,j,m,h
|
| Escribir "Introduzca el vector a ordenar"
| +-Para h desde 1 hasta n hacer
| | Leer a(h)
| +-Finpara
|
| Escribir "Introduzca el valor a buscar"
| Leer x
|
| i <- 1
| j <- n
|
| +-Repetir
| | m <-(i+j) div 2
| | +-Si x < a(m) entonces
| | | j <- m-1
| | +-Sino
| | | i <- m+1
| | +-Finsi
| +-Hasta que (a(m)=x or i>j)
|
| +-Si i>j entonces
| | Escribir "El dato a buscar no se encuentra."
| +-Finsi
|
+-Final
+-Algoritmo mezcla
|
| +-Registro estructurado r
| | variable cadena clave
| | ...
| +-Finregistro
|
| Ficheros de r A,B,C
| Variables enteras a,b
|
| Abrir secuencial A,B,C
| Iniciar lectura en A,B
| Iniciar escritura en C
|
| Leer (A,a)
| Leer (B,b)
|
| +-Mientras (NO fin(A) AND NO fin(B)) hacer
| | +-Si a.clave < b.clave entonces
| | | Escribir (C,a)
| | | Leer (A,a)
| | +ÄSino
| | | Escribir (C,b)
| | | Leer (B,b)
| | +-Finsi
| +-Finmientras
|
| +-Mientras (NO fin(A)) hacer
| | Escribir (C,a)
| | Leer (A,a)
| +-Finmientras
|
| +-Mientras (NO fin(B)) hacer
| | Escribir (C,b)
| | Leer (B,b)
| +-Finmientras
|
| Cerrar A,B,C
|
+-Final
TEMA 0: Introducción
Paso 1: ESCRIBIRLO
Paso 2: COMPILARLO
Paso 3: ENLAZARLO
Paso 4: EJECUTARLO
ESQUEMA
1.0 Introducción
En este segundo tema se describirá la estructura básica de
un programa en lenguaje C así como la forma de visualizar distintos
tipos de datos en pantalla. Se introducirán los conceptos de tipos
de datos básicos y su utilidad.
main()
{
printf ("\nHola mundo");
}
printf ("mensaje");
+-------------------------+------+
| Nueva línea | \n |
| Tabulador horizontal | \t |
| Tabulador vertical | \v |
| Backspace (<-) | \b |
| Retorno de carro | \r |
| Avance de página | \f |
| Pitido (alerta) | \a |
| Caracter \ | \\ |
| Caracter ? | \? |
| Caracter ' | \' |
| Caracter " | \" |
| Número Octal (ooo) | \ooo |
| Número Hexadecimal (hh) | \xhh |
+-------------------------+------+
+--------+---------------------------------------+
| int | Representa números enteros. |
| float | Representa números decimales. |
| double | Representa números decimales de mayor |
| | precisión. |
| char | Representa caracteres. |
+--------+---------------------------------------+
int numero1,numero2,numero3;
float coordenada_x,coordenada_y;
main()
{
int numero;
numero =20;
}
+---+---------------------------------------------+
| + | para indicar suma |
| - | para indicar resta |
| * | para indicar producto |
| / | para indicar división |
| % | para indicar módulo (resto división entera) |
+---+---------------------------------------------+
b=30;
a=(float)b;
#include <stdio.h>
main()
{
float e,v,t;
e = v*t;
printf ("\nVelocidad : %f\nTiempo : %f",v,t);
printf ("\nEspacio recorrido : %f",e);
}
+-----+------------------------------------------------+
| d,i | Entero en notación decimal con signo. |
| o | Entero notación octal sin signo. |
| x,X | Entero en notación hexadecimal sin signo. |
| u | Entero en notación decimal sin signo. |
| c | Entero como caracter simple. |
| s | Cadena de caracteres. |
| f | Tipo double (ó float) de la forma [-]mmmm.ddd. |
| e,E | Tipo double (ó float) en notación científica o |
| | exponencial [-]m.dddde+-xx ó [-]m.ddddE+-xx. |
| p | Tipo puntero. |
+-----+------------------------------------------------+
printf ("%f",numero);
Visualiza un número real en el formato normal, parte entera
y parte decimal separadas por un punto.
printf ("%5.2f",numero);
Visualiza un número entero en el mismo formato que la
anterior, pero sólo visualizando 5 cifras y siendo dos de ellas
reservadas para la parte decimal.
#include <stdio.h>
main()
{
int i;
float a,b;
i = 10;
a = 30.456;
b = 678.12;
main()
{
float v,t,e;
2.0 Introducción
== Representa igualdad.
!= Representa desigualdad
> Mayor que.
< Menor que.
>= Mayor o igual que.
<= Menor o igual que.
&& Y lógico.
|| O lógico.
(a==2)||((b>=0)&&(b<=20))
#include <stdio.h>
main()
{
float dividendo,divisor;
if (divisor==0)
printf ("\nNo podemos dividir un número por 0");
else
printf ("\nEl resultado es: %f",dividendo/divisor);
}
2.2.0 Introducción
#include <stdio.h>
main()
{
int i; /* Esta variable la utilizaremos como contador*/
#include <stdio.h>
main()
{
int i;
int tabla1,tabla2;
for (i=1;i<11;i++)
{
printf ("\n %2dx%2d=%3d",tabla1,i,tabla1*i);
printf (" %2dx%2d=%3d",tabla2,i,tabla2*i);
}
}
for (i=0;i<20;i++)
{
printf ("Jugador preferido %d",i);
for (j=0;j<3;j++)
{
leo característica j;
la almaceno donde sea;
}
}
exp1;
while (exp2)
{
instrucción;
exp3;
}
#include <stdio.h>
main()
{
int i;
i = 0;
while (i<10)
{
printf ("\n%d",i);
i++;
}
}
#include <stdio.h>
main()
{
int numero;
numero = 10;
while (numero!=0)
{
printf ("\nDime un número:");
scanf ("%d",&numero);
}
}
#include <stdio.h>
main()
{
int numero;
do
{
printf ("\nDime un numero :");
scanf ("%d",&numero);
} while (numero !=0);
#include <stdio.h>
main()
{
int numero;
int contador;
contador =0;
do
{
printf ("\nIntroduce el número %2d:",contador);
scanf ("%d",&numero);
if ((numero<0)||(numero>20)) continue;
contador++;
} while (contador<50);
}
Este programa lee números en una variable hasta un máximo de
50, alcanzado este máximo el programa termina. Además si el número
no está entre 0 y 20 (si es menor que 0 o mayor que 20) vuelve a
pedir que lo introduzcamos. El comando continue en la instrucción if
obliga al programa a saltar a la instrucción while donde se vuelve a
evaluar la condición, sin pasar por la línea en la que se incrementa
el contador. De esta forma se nos vuelve a pedir el mismo número y
la entrada incorrecta no es tenida en cuenta.
#include <stdio.h>
main()
{
int i;
for (i=0;i<20;i++)
{
if (i==5) break;
printf ("\n%d",i);
}
printf ("\n\n%d",i);
}
0
1
2
3
4
2.2.2.1 Introducción
#include <stdio.h>
main()
{
int opcion;
switch (opcion)
{
case 1:
/* Código para cargar fichero de datos*/
break;
case 2:
/* Código para almacenar datos */
break;
case 3:
/* Código para modificar datos */
break;
case 4:
/* Salir del programa */
exit (0);
default :
printf ("\nSu opción no está disponible");
printf ("\nInténtelo con otra");
}
switch (variable)
{
case valor1-variable:
código asociado;
case valor2-variable:
código asociado;
.
.
case valorN-variable:
código asociado;
default:
código asociado;
}
while (Opcion!=0)
{
/* Secuencia de printfs que muestran en pantalla
el menú. En este caso la opción 0 debería ser salir */
switch (opcion)
{
/* Secuencia de cases */
default :
/* Mostrar mensaje de error */
}
}
@N - Activa Negrita.
@n - Desactiva Negrita.
@C,@c - Activa/desactiva cursiva.
@S,@s - idem sibrayado
etc...
3.0 Introducción.
tipo_de_dato identificador[tamaño1][tamaño2]...;
Dónde :
a = matriz [2][1];
/* A toma el valor del elemeto (2,1) comenzando a contar
desde 0 o del (3,2) si consideramos que el primer valor de la matriz
es el (1,1) */
int matriz[2][3] = {
{ 1,2,3 },
{ 4,5,6 }
};
#include <stdio.h>
#include <math.h>
main()
{
float senos[360]; /* Almacenamos senos */
float cosenos[360];
int i;
3.2.0 Introducción
struct [Nombre_de_la_estructura]
{
tipo1 campo1;
tipo2 campo2;
.
.
tipoN campoN;
} [variable];
struct punto
{
float x;
float y;
int color;
} punto_de_fuga;
int
float
double
char
struct punto
punto_de_fuga.x = 0;
punto_de_fuga.y = 0;
punto_de_fuga.color = 10;
matriz_de_puntos[4].x = 6;
struct otra
{
float x[10];
} matriz_de_puntos;
struct vector
{
float x;
float y;
float z;
};
struct poligono_cuadrado
{
struct vector p1;
struct vector p2;
struct vector p3;
struct vecto p4;
};
struct cubo
{
struct poligono_cuadrado cara[6];
int color;
struct vector posicion;
};
mi_cubo.color = 0;
mi_cubo.posicion.x = 3;
mi_cubo.posicion.y = 2;
mi_cubo.posicion.z = 6;
mi_cubo.cara[0].p1.x = 5;
/* Ahora acedemos a la coordenada 0 del tercer polígono
de la cara 0 de mi_cubo*/
mi_cubo.cara[0].p3.z = 6;
....
union ejemplo
{
char caracter;
int entero;
} mi_var;
mi_var es una variable cuyo tipo es union ejemplo, y el
acceso a cada campo de los definidos se realiza igual que en las
struct mediante la utilización de un punto. Hasta aquí nada nuevo lo
que sucede es que carácter y entero (los dos campos) ocupan la misma
posición de memoria. Así:
63452 = 6*10^4+3*10^3+4*10^2+5*10^1+2*10^0=
= 60000+3000+400+50+2
b100101 = 1*2^5+0*2^4+0*2^3+1*2^2+0*2^1+1*2^0=
= 32 + 0 + 0 + 4 + 1 = 37
b11111111 = 255
b1111111111111111 = 65535
mi_var.entero = 0x00f10;
0 -> 0000
f -> 1111 -> 15 en decimal
1 -> 0001 -> 1 en decimal
BYTE var1,var2;
HEXAEDRO var3;
Sería equivalente a:
4.0 Introducción
4.1 Punteros
main()
{
página *punt_página;
informe1 i1[10],*punt1;
informe2 i3[5],*punt2;
informe3 i4[15],*punt3;
....
punt_página = punt_página + 5;
punt3 = punt3 + 5;
punt3 pasaría a apuntar a el quinto informe de tipo 3
(i4[5]), puesto que punt3 es un puntero a informes de tipo tres. Si
ahora realizásemos la operación:
char identificador[tamaño_de_la_cadena];
char *identificador;
4.2 Funciones
4.2.1 Introducción
Código de la función
for (i=0;i<longitud;i++)
if (vector[i] == valor) break;
return i;
}
main ()
{
int matriz1[20];
int matriz2[30];
int indice,dato;
.....
}
t = a;
a = b;
b = t;
}
main ()
{
int c,d;
c = 5;
d = 7;
swap (c,d);
}
Veamos que pasa en la memoria de nuestro ordenador.
-Función main()
-Espacio para la variable c (Posición de memoria x)
-Espacio para la variable d (Posición de memoria y)
-Inicialización de las variables
-swap(c,d)
-Fin de main()
-Función swap
-Código de la función swap
-Espacio privado para almacenar los parámetros (Posición
de memoria z)