C Un Putero y Mas

CONTENIDO TEMARIO (PROPUESTO)
I.- conceptos bsicos

a) Identificadores, variables, constantes y secuencias de escape.
b) Tipos de datos
c) Operadores y expresiones
d) Estructuras de un programa
II.-Estructuras de control
a) Estructuras de control selectivas: if-else, switch
b) Estructuras de control repetitivas: while, do-while, for
III.- Estructuras de datos estticas (Tipos de datos estructurados 1)
a) Arreglos
b) Estructuras
c) Uniones
IV.- Estructuras de datos dinmicas (Tipos de datos estructurados 2)
a) Apuntadores
b) Asignacin dinmica de memoria
c) Operaciones con apuntadores
V.- Funciones
a) Funciones estndar
b) Funciones definidas por usuario
c) Recursividad
VI.- Aplicaciones
a) Archivos
Conceptos Bsicos
Lenguaje C es un lenguaje de programacin de propsito general. Algunas
caractersticas son:
Programacin estructurada
Economa en las expresiones
Variedad de operadores y tipos de datos
Codificacin en alto y bajo nivel simultneamente
Uso natural de las funciones primitivas del sistema
Uso de cdigo objeto altamente optimizado
Sin embargo, la excesiva libertad en la escritura de los programas puede llevar a errores
en la programacin que, por ser correctos sintcticamente no s detectan a simple vista.
En la figura 1 se indica la secuencia de pasos que realizar al compilador de C para

generar un programa ejecutable (*.exe). El ejemplo indica que una vez editados los
programas fuente a.cpp y b.cpp, son compilados obtenindose los archivos objeto a.obj
y b.obj, los cuales son enlazados con la librera d.lib y con las libreras del sistema .lib
dando lugar a un nico archivo ejecutable a.exe y b.exe, respectivamente.
Figura 1
a) Identificadores, variables, constantes y secuencias de escape.
Un identificador es el nombre que se le da a una variable o constante, el cual
debe comenzar con una letra y puede contener dgitos y el carcter subrayado.
Una variable es un identificador que puede cambiar su valor durante la ejecucin
de un programa. Pueden ser de diferente tipo, de acuerdo a los datos que
almacene.
Una constante es un identificador que conserva su valor durante la ejecucin del
programa.
Los caracteres tambin pueden ser representados por secuencias de escape, las
cuales estn formadas por el carcter \ seguido de una letra o de una
combinacin de dgitos. Son utilizadas para acciones como salto de lnea, tabular
y para representar caracteres no imprimibles. Algunas secuencias son:
\n
\t
\v
\r
Salto de lnea
Tabulador Horizontal
Tabulador vertical
Retorno de carro
\a
\ddd
\xdd
Alerta, pitido
Carcter ASCII, Representacin Octal
Carcter ASCII, Representacin Hexadecimal
b) Tipos de Datos
Los tipos de datos se clasifican en simples y estructurados.
Los primeros se pueden clasificar en:
Tipos enteros: char, short, int, long y enum
Tipos Reales: float, doubl y long doubl
Otros: void (sin tipo)
Cada tipo de dato entero puede ser procedido por la palabra reservada signed o
unsigned, obteniendo los tipos de dato:
Signed char, unsigned char
Signed short, unsignedshort
Signed int, unsigned int
Signed long, unsigned long
Un entero precedido por signed es un entero con un signo, es decir un entero
positivo o negativo. Un numero entero precedido por unsigned es un numero
entro sin signo, el cual se manipula como un numero entero positivo. Los
calificadores signed y unsigned se utilizan sin un tipo especifico, se asume el
tipo int.
Char
El tipo char es utilizado para almacenar un valor entero en un rango -128 a 127,
correspondiente a un carcter del cdigo ASCII. Solo los valores 0 a 127, son
equivalentes a un carcter.
El tipo unsigned char puede almacenar valores en el rango de 0 a 255, valores
correspondientes a los nmeros ordinales de los 256 caracteres ASCII.
Short (Entero formato corto -2bytes)
El tipo short permite manejar enteros en el rango de -32768 a 32767. De Igual
forma, el tipo unsigned short puede almacenar valores en el rango de 0 a 65535.
Long (entero formato largo 4bytes)
Son nmeros sin punto decimal comprendidos en el rango de:
-2E31 a 2E31-1 para el tipo long
0 a eE32-1 para el tipo unsigned long
Enum
La declaracin del tipo de dato enumerado consiste en una lista de valores que
pueden ser tomados por una variable de ese tipo. Los valores del tipo enumerado
se representaran con identificadores, que son las constantes que corresponden a
dicho tipo.
(#include <stdlib.h>) es: fflush (stdin) por si hay saltos en las instrucciones.
Creacin de una enumeracin
Sintaxis
Enum tipo-comando {
Definicin variables enteros
};
Despus de definir un tipo enumerado, se puede declarar 1 o ms variable de ese
tipo de la forma:
enum colores{
azul, amarillo, rojo, verde};

enum clores color;
Este ejemplo declara una variable color del tipo enumerado colores la cual
puede tomar cualquier valor de las especificaciones en la lista por ejemplo:
color=azul;
Cada identificador de la lista de constantes enteras en una enumeracin tiene
asociado un valor por defecto, el primer identificador tienes asociado el valor
cero (0), el siguiente el valor 1, y as sucesivamente.
A cualquier identificador de la lista se le puede asignar un valor inicial por
medio de una expresin constante. Los identificadores sucesivos tomaran
valores correlativos a partir de este.
Los miembros de una enumeracin tienen las siguientes propiedades:
a) 2 o mas miembros pueden tener el mismo valor.
b) Un identificador no puede aparecer en mas de un tipo
c) No es posible leer o escribir directamente un valor de un tipo
enumerado.
#include <stdio.h>
#include <conio.h>
main(){
int a, b=2, c;
enum colores{
azul, blanco, rojo, verde,
negro}
color;
a=b*verde;
printf("%d",a);
getch();
}
#include <stdio.h>
#include <conio.h>
main(){
int a, b=2, c;
enum comida{
mole, pozole,
sopa}
com;
a=b*sopa;
printf("%d",a);
getch();}
frijoles,
#include <stdio.h>
#include <conio.h>
main(){
int a, b=2, c;
enum bebidas{
pulque, tequila, cerveza,
vodka}
alcohol;
a=b*pulque;
printf("%d",a);
getch();
Float (4 bytes)
Un real en simple precisin es un nmero que puede tener un punto decimal y que
puede estar comprendido en el rango de -3.402923E38 a -1.175494E y de 1.775494E38
a 3.402823E738, un nmero real en simple precisin tiene solo 7 dgitos significativos.
Float x; float a=3.1416; float b=2.2E-5;
Double (8 bytes)
Un nmero real en doble precisin es un nmero que puede tener un mismo nmero
decimal y puede estar comprendido en el rango de: -1.79769E308 a -2.22507E-308
2.22507E-308 a 1.79769E+308, un nmero en simple posicin posee 7 dgitos
significativos pero un real en doble precisin tiene 16, lo que da lugar a clculos mas
exactos.
Double x; double c=2.27; double d=3E5;

Long Double (10 bytes)
Los valores para este tipos de datos estn comprendidos entre -1.189731E+4932 a
1.189731E+4932 Este tipo de dato puede manejar hasta 19 dgitos significativos lo que
da lugar a clculos mas precisos.
Long double=x; long double n;
Void
El tipo de dato void se utiliza para declarar funciones que no retornan un valor o para
declarar un puntero aun tipo no especificado. Si void aparece entre parntesis a
continuacin del nombre de una funcin, no es interpretado como un tipo, en este caso
indica que la funcin acepta argumentos.
Double fx (void); void fy (void);
Tipos de datos derivados
Estos tipos de datos se construyen a partir de los tipos fundamentales algunos son:
a) Estructuras
b) Arreglos
c) Punteros
d) Uniones
e) Funciones
Estructuras
Es una variable que representa como registro, es decir un conjunto de uno o mas campos
de diferentes tipos.
Arreglo de
Registros
Nombre
Juan
Luis
Luigi
1.- struct objeto{

float tam;
char color[10];
double precio;
} caja;
//muchos objetos.
Ejercicios:
#include <stdio.h>
#include <conio.h>
struct direc{
char titulodetarea[10];
Campos
Edad
5
18
19
Direccin
Av. s/n
Calle s/n.
Av. Rev.
double numempleado;
int tarifapago;
}info_direc;
main(){
struct direc
info_direc={"ANALISTA",123456789,1
593};
clrscr();
printf("Titulo de Tarea:
%s",info_direc.titulodetarea);
printf("\nNumero de Empleado:
%1.0lf",info_direc.numempleado);
printf("\nTarifa de Pago:
%d",info_direc.tarifapago);
getch();
}
//ejercicio strcut figura 02
#include <stdio.h>
#include <conio.h>
struct nom{
char pat[4];
char nombre[10];
char mat[2];
};
struct dir{
char edif[5];
int cubiculo;
};
struct direc{
nom nombre;
dir direccionoficina;
double numempleado;
int tarifapago;
}info_direc;
main(){
struct direc
info_direc={"MUD","JOE","N","CSC",
403,"ANALISTA",123456789,1593};
clrscr();
printf("\nNombre/PAT:
%s",info_direc.nombre.pat);
printf("\nNombre/NOMBRE:
%s",info_direc.nombre.nombre);
printf("\nNombre/MAT:
%s",info_direc.nombre.mat);
printf("\nDireccion
Oficina/Edif:
%s",info_direc.direccionoficina.edif);
printf("\nDireccion
Oficina/Cubiculo:
%d",info_direc.direccionoficina.cubicul
o);
getch();
}
//Figura 03 struct
#include <stdio.h>
#include <conio.h>
struct nom{
char pat[4];
char nombre[10];
char mat[2];
};
struct dir{
char edif[5];
int cubiculo;
};
struct cod{
int a;
int b;
int c;
int d;
int e;
};
struct direc{
nom nombre;
cod codigoproyecto;
double numempleado;
int tarifapago;
}info_direc;
main(){
struct direc
403,18,40,41,50,53,"ANALISTA",12345
6789,1593};
clrscr();
printf("\nDireccion
Oficina/Edif:
printf("\nDireccion
Oficina/Cubiculo:
o);
printf("\nCodigos de proyectos:
%d|%d|%d|%d|%d
",info_direc.codigoproyecto.a,info_dire
c.codigoproyecto.b,info_direc.codigopr
oyecto.c,info_direc.codigoproyecto.d,inf
o_direc.codigoproyecto.e);
getch();
}
//ejercicio 04 figura 04 struct
#include <stdio.h>
#include <conio.h>
struct nom{
char pat[4];
char nombre[10];
char mat[2];
};
struct dir{
char edif[5];
int cubiculo;
};
struct cod{
int a;
int b;
int c;
int d;
int e;
};
struct numtel{
int lada;
double local;
int lada1;
double local1;
};
struct direc{
nom nombre;
cod codigoproyecto;
numtel numerotel;
double numempleado;
int tarifapago;
}info_direc;
main(){
struct direc
403,18,40,41,50,53,202,2991673,301,6
263116,"ANALISTA",123456789,1593};
clrscr();
printf("\nDireccion
Oficina/Edif:
printf("\nDireccion
Oficina/Cubiculo:
o);
printf("\nCodigos de proyectos:
%d|%d|%d|%d|%d
",info_direc.codigoproyecto.a,info_dire
c.codigoproyecto.b,info_direc.codigopr
oyecto.c,info_direc.codigoproyecto.d,inf
o_direc.codigoproyecto.e);
printf("\nNumero
Telefonico/Lada: %d|Local:
%1.0lf",info_direc.numerotel.lada,info_
direc.numerotel.local);
printf("\nNumero Telefonico/Lada:
%d|Local:
%1.0lf",info_direc.numerotel.lada1,info
_direc.numerotel.local1);
getch();
}
//tarea del 23 de enero de 2009.
//c) utilizando las expresiones
algebraicas modificar los ejercicios del
libro de baldor de tal manera que se
emplee struct.
//ejercicio 01
#include <stdio.h>
#include <conio.h>
struct direc{
int x, y, z, aux1;
}expre1;
main(){
//Pgina 101, Ejercicio 65, Problema
#1
printf("Introduce el valor de x: ");
scanf("%d",&expre1.x);
printf("Introduce el valor de y: ");
scanf("%d",&expre1.y);
printf("Introduce el valor de z: ");
scanf("%d",&expre1.z);
expre1.aux1=(expre1.x+expre1.y+expr
e1.z)*(expre1.x+expre1.y-expre1.z);
gotoxy (27,15);
printf("El resultado es:
%d",expre1.aux1);
getch();
}
//Ejercicio 02
#include <stdio.h>
#include <conio.h>
struct direc{
int x, y, z, aux1;
}expre2;
main(){
#2
expre2.aux1=(expre2.xexpre2.y+expre2.z)*(expre2.x+expre2.y
-expre2.z);
gotoxy (27,15);
%d",expre2.aux1);
getch();
}
//Ejercicio 03
#include <stdio.h>
#include <conio.h>
struct direc{
int x, y, z, aux1, aux2;
}expre3;
main(){
#3
expre3.aux1=(expre3.x+expre3.y+expr
e3.z)*(expre3.x-expre3.y-expre3.z);
gotoxy (27,15);
%d",expre3.aux1);
getch();
}
//Ejercicio 04
#include <stdio.h>
#include <conio.h>
struct direc{
int m, n, aux1;
}expre3;
main(){
#4
printf("Introduce el valor de m: ");
scanf("%d",&expre3.m);
printf("Introduce el valor de n: ");
scanf("%d",&expre3.n);
expre3.aux1=(expre3.m+expre3.n+1)*(
expre3.m+expre3.n-1);
gotoxy (27,15);
%d",expre3.aux1);
getch();
}
//Ejercicio 05
#include <stdio.h>
#include <conio.h>
struct direc{
int m, n, aux1;
}expre2;
main(){
#5
expre2.aux1=(expre2.m+expre2.n1)*(expre2.m+expre2.n+1);
gotoxy (27,15);
%d",expre2.aux1);
getch();
}
//Ejercicio 06
#include <stdio.h>
#include <conio.h>
struct direct{
int x, y, aux1;
}expre1;
main(){
#6
int x, y, aux1;
expre1.aux1=(expre1.x+expre1.y2)*(expre1.x-expre1.y+2);
gotoxy (27,15);
%d",expre1.aux1);
getch();
}
//Ejercicio 07
#include <stdio.h>
#include <conio.h>
struct direc{
int m, n, aux1;
}expre7;
main(){
#7
expre7.m=expre7.n*expre7.n;
expre7.aux1=(expre7.m+(2*expre7.n)
+1)*(expre7.m-(2*expre7.n)-1);
gotoxy (27,15);
%d",expre7.aux1);
getch();
}
//Ejercicio 08
#include <stdio.h>
#include <conio.h>
struct direc{
int aux1, a, res;

}expre8;
main(){
#8
printf("Introduce el valor de a: ");
scanf("%d",&expre8.a);
expre8.aux1=expre8.a*expre8.a;
expre8.res=(expre8.aux1-(2*expre8.a)
+3)*(expre8.aux1+(2*expre8.a)+3);
gotoxy (27,15);
%d",expre8.res);
getch();
}
//Ejercicio 09
#include <stdio.h>
#include <conio.h>
struct direc{
int m, aux1, res;
}expre9;
main(){
#9
expre9.aux1=expre9.m*expre9.m;
expre9.res=(expre9.aux1-expre9.m1)*(expre9.aux1+expre9.m-1);
gotoxy (27,15);
%d",expre9.res);
getch();
}
//Ejercicio 10
#include <stdio.h>
#include <conio.h>
struct direc{
int a,b,c, aux1;
}expre10;
main(){

#10
printf("Introduce el valor de b: ");
scanf("%d",&expre10.b);
printf("introduce c: ");
scanf("%d",&expre10.c);
expre10.aux1=(2*expre10.a-expre10.bexpre10.c)*(2*expre10.aexpre10.b+expre10.c);
gotoxy (27,15);
%d",expre10.aux1);
getch();
}
//Ejercicio 11
#include <stdio.h>
#include <conio.h>
struct direc{
int x, y, z, aux1;
}expre11;
main(){
#11
expre11.aux1=(2*expre11.x+expre11.yexpre11.z)*(2*expre11.xexpre11.y+expre11.z);
gotoxy (27,15);
%d",expre11.aux1);
getch();
}
//Ejercicio 12
#include <stdio.h>
#include <conio.h>
struct direc{
int x, dos, aux1;
}expre12;
main(){
#12
expre12.dos=expre12.x*expre12.x;
expre12.aux1=(expre12.dos(5*expre12.x)
+6)*(expre12.dos+(5*expre12.x)-6);
gotoxy (27,15);
%d",expre12.aux1);
getch();
}
//Ejercicio 13
#include <stdio.h>
#include <conio.h>
struct direc{
int a, a1, b, b1, aux1;
}expre13;
main(){
#13
printf("Introduce el valor de b: ");
scanf("%d",&expre13.b);
expre13.a1=expre13.a*expre13.a;
expre13.b1=expre13.b*expre13.b;
expre13.aux1=(expre13.a1expre13.a*expre13.b+expre13.b1)*(exp
re13.a1+expre13.b1+expre13.a*expre1
3.b);
gotoxy (27,15);
%d",expre13.aux1);
getch();
}
//Ejercicio 14
#include <stdio.h>
#include <conio.h>
struct direc{
int x, x2, x3, resultado;
}expre14;
main(){
printf ("Dame el valor de x \n");
expre14.x2=expre14.x*expre14.x;
expre14.x3=expre14.x*expre14.x*expre
14.x;
expre14.resultado=(expre14.x3expre14.x2expre14.x)*(expre14.x3+expre14.x2+ex
pre14.x);
gotoxy(35,20);
printf("El resultado es
%d",expre14.resultado);
getch();
}
TIPOS DE DATOS ESTRUCTURADOS

Los tipos de datos derivados se construyen a partir de los tipos fundamentales. Entre
ellos estn:
Estructuras
Arreglos
Uniones
Punteros
Funciones
Estructuras (registros)
Una estructura es una coleccin de datos de diferentes tipos, lgicamente relacionados,
que puede ser manipulado igual que los tipos de datos simples. Los miembros de una
estructura se denominan campos y un conjunto de campos forma un registro o
estructura.
Sintaxis:
Forma 1:
struct nom_tipo_estructura {
declaracin de los miembros de la estructura;
} struct nom_tipo_estructura var1[,var2,varN];
Forma 2:
struct nom_tipo_estructura {
} var1[,var2,varN];
Forma 3:
struct {
} var1[,var2,varN];
El acceso a un campo de una estructura es de la siguiente forma:
var1.nom_campo;
Las estructuras pueden ser preinicializadas en la declaracin. Por ejemplo:
Struct
direc
info_direc={Vicente
salas,
Fantasa
200,
Dorado,MMX,12345};
Para referenciar o accesar un miembro (o campo) de una estructura, se utiliza el
operador punto., por ejemplo para asignar a info_direc otro cdigo:
Info_direc.codigo=54321;
Los miembros de una estructura son almacenados secuencialmente, en el mismo orden
en que son declarados.
Titulo del rea
Nm. De empleado
Tarifa pago
Analista
123456789
15.93
Figura 2
Titulo
Nm.
Tarifa Nombre
Direccin Oficina
del rea empleado
pago
Analista 123456789 15.93 PAT NOMBRE MAT EDIF CUBICULO
MUD JOE
N
CSC 403
Figura 3
Titulo
Nm.
Tarifa
Nombre
Direccin
Cdigos de proyecto
del rea
Analista
empleado
123456789
pago
15.93
pat
MUD
nombre
JOE
mat
N
Oficina
edif cubculo
CSC 403
18
40
41
50
53
Figura 4
Titulo
del
rea
Analis
ta
Nm.
emplead
o
1234567
89
Tarif
a
pago
15.9
3
Nombre
pat
MU
D
Direccin
Oficina
nomb
re
JOE
ma
t
N
edi
f
CS
C
cubcu
lo
403
Cdigos de proyecto
1
8
4
0
Figura 5
ARREGLOS
Unidimensionales (Vectores o listas) fig. 6.
fig. 6
Bidimensionales (tabla o matriz) fig. 7.
fig. 7
Tridimensional (cubo) fig. 8.
fig. 8
Tipo nom_var [tam_filas][tam_columnas][tam_capas];
Cadena de caracteres
4
1
5
0
Numero telefonico
5
3
Lad
a
202
Loal
29916
73
Lad
a
301
local
62631
16
Una cadena de caracteres es un arreglo unidimensional, en el cual todos sus elementos

son de tipo char. Un arreglo de caracteres puede ser inicializado asignndole un literal.
Char cadena []=palabra;
Este Ejemplo inicializando el arreglo de cadena con 8 elementos (cadena [0] a cadena
[7]), el octavo elemento es el carcter nulo (\0); con el cual se finalizan todas las
cadenas de caracteres.
Si se especifica el tamao del arreglo de caracteres y la cadena asimilada es mas larga
que el tamao especificado se obtiene un error en el momento de compilar. Por
Ejemplo:
Char cadena [3]=abcd;
Este ejemplo dar lugar a un mensaje de error que indica que se ha excedido los limites
del arreglo.
Si la cadena asignada es mas corta que el tamao del arreglo de caracteres el resto de lso
elementos del arreglo son inicializados al valor nulo (\0).
Char apellidos [60];
Este ejemplo declara el arreglo apellidos como una cadena de caracteres de longitud
mxima de 60.
Char lista [80] [40];
Este ejemplo declara el arreglo llamado lista como un arreglo de caracteres es decir,
lista es un arreglo de 80 filas cada una de las cuales es una cadena de caracteres de
longitud mxima de 40.
Antes de leer una cadena de caracteres debe declararse el arreglo de tipo char que la va
a contener. La dimensin de este arreglo debe corresponder con el nmero mximo de
caracteres que puede contener la cadena, por ejemplo:
Si queremos leer un nombre de 20 caracteres, se debe declarar el arreglo de la siguiente
forma:
Char nombre [21];
Funciones para el Manejo de cadenas
1.-strcat
Aade una copia de la cadena apuntada por s2 (incluyendo el carcter nulo) al final de
la cadena apuntada por s1. El carcter inicial de s2 sobrescribe el carcter nulo al final
de s1.
Valor de retorno:
La funcin retorna el valor de s1. Si la copia hace que los objetos se superpongan,
entonces el comportamiento no est definido.
Ejemplo:
#include <stdio.h>
#include <string.h>
int main()
strcat( s1, s2 );
printf( "s1=%s\n", s1 );
char s1[11] = "Hola ";

char s2[6] = "amigos";
return 0;
printf( "s1=%s\t", s1 );
2.-strtchr
Localiza la primera aparicin de c (convertido a unsigned char) en la cadena apuntada
por s (incluyendo el carcter nulo).
Valor de retorno:
La funcin retorna un puntero a partir del carcter encontrado. Si no se ha encontrado el
carcter, c, entonces retorna un puntero null.
Ejemplo:
#include <stdio.h>
#include <string.h>
int main()
{
char s[11] = "Hola amigos";
char c = 'a';
printf( "s=%s\t", s );
printf( "c=%c\n", c );
printf( "strchr=%s\n", strchr( s, c ) );
return 0;
}
3.-strcmp
Compara la cadena apuntada por s1 con la cadena apuntada por s2.
Valor de retorno:
La funcin retorna un nmero entero mayor, igual, o menor que cero, apropiadamente
segn la cadena apuntada por s1 es mayor, igual, o menor que la cadena apuntada por
s2.
Ejemplo:
#include <stdio.h>
#include <string.h>
int main()
{
char s1[5] = "Abeja";
char s2[5] = "abeja";
int i;
printf( "s1=%s\t", s1 );
i = strcmp( s1, s2 );
printf( "s1 es " );
if( i < 0 ) printf( "menor que" );
else if( i > 0 ) printf( "mayor que" );
else printf( "igual a" );
printf( " s2\n" );
return 0;
}
4.-strcpy
Copia la cadena apuntada por s2 (incluyendo el carcter nulo) a la cadena apuntada por
s1.
Valor de retorno:
La funcin retorna el valor de s1. Si al copiar una cadena a la otra se superponen,
entonces el comportamiento no est definido.
Ejemplo:
#include <stdio.h>
#include <string.h>
int main()
{
char s2[8] = "abcdefg";
char s1[8];
strcpy( s1, s2 );
return 0;
}
5.-strlen
Calcula el nmero de caracteres de la cadena apuntada por s.
Valor de retorno:
La funcin retorna el nmero de caracteres hasta el carcter nulo, que no se incluye.
Ejemplo:
#include <stdio.h>
#include <string.h>
int main()
{
char s[13] = "Hola a todos";
printf( "s=%s\n", s );
printf( "strlen(s) = %d\n",
strlen( s ) );
return 0;
}
6.-strspn
Calcula el nmero de caracteres de una subcadena inicial apuntada por s1 que consiste
en todos los caracteres formados en la cadena apuntada por s2.
Valor de retorno:
La funcin retorna la longitud de esta subcadena.
Ejemplo:
#include <stdio.h>
#include <string.h>
int main()
{
char s1[13] = "Hola a todos";
char s2[5] = "Hola";
printf( "strspn(s1,s2) = %d\n", strspn(
s1, s2 ) );
return 0;
}
7.-strtok
Rompe la cadena s1 en segmentos o tkens. Esta ruptura destruye s1, en el proceso. La
forma de romper la cadena depende de la secuencia de caracteres de la cadena s2. Estos
caracteres se denominan [caracteres] delimitadores. La funcin recorrer la cadena en
busca de alguno de los delimitadores de la cadena s2. Cuando lo encuentre, el proceso
se detiene, ya que tiene un token. Posteriores llamadas a strtok rompern la cadena s1 en
otros tkens. Estas llamadas pueden tener otra secuencia de delimitadores.
Valor de retorno:
La primera llamada a strtok determina la cadena a romper, retornando el puntero al
comienzo del primer token. Si se recorri la cadena s1 sin haber encontrado un
delimitador, y an no se ha obtenido el primer token, entonces la funcin retornar un
puntero nulo.
Posteriores llamadas retornarn ms tkens. Si ya no encuentra ms delimitadores,
entonces retornar todos los caracteres desde el ltimo delimitador para ser el ltimo
token. Si ya se retorn el ltimo token, entonces retornar un puntero nulo con dems
llamadas a la funcin.
Ejemplo:
#include <stdio.h>
#include <string.h>
int main()
{
char s1[49] = "Esto es un ejemplo
para usar la funcion strtok()";
char s2[4] = " \n\t";
char *ptr;
ptr = strtok( s1, s2 ); // Primera

llamada => Primer token
printf( "%s\n", ptr );
while( (ptr = strtok( NULL, s2 )) !=
NULL ) // Posteriores llamadas
printf( "%s\n", ptr );
return 0;
}
8.-strlwr y 9.-strupr
Convierten una cadena a minsculas o maysculas respectivamente. Su formato es:
strlwr(Cadena); / strupr(Cadena);
Devuelve el valor en el argumento y como valor de la funcin.
Ejemplos
strlwr("Pepe") ==> "pepe"
strupr("Pepe") ==> "PEPE"
Supongamos que nombre es una cadena con valor "Pepe".
strupr(nombre) ==> "PEPE" /* Y adems ahora nombre vale "PEPE" */
10.-strset
Sustituye un valor o la cadena por un carcter en especifico
#include <stdio.h>
printf( "esto es una cadena: %s\n", str
#include <string.h>
);
printf( "strset(s) = %d\n", strset( s ) );
int main(void)
{
return 0;
char str = "Hola a todos";
}
//Programa Hospital
#include <stdio.h>
#include <conio.h>
struct a{
int a;
//clave
char b[20]; //nombre(s)
char c[20]; //apellido paterno
char d[20]; //apellido
materno
char e[20]; //sexo
int f;
//edad
float g;//peso
float h;//estatura
char i;
//alergias
char j[3];
//grupo
sanguineo
char k[3];
//factor Rh
int l;
//por si si hay
alergias
}info_a[15];
main(){
int m, n, o, p, q, r, s, opci, op,
com;
printf("Da el nmero de
pascientes que ingresaras sus datos: ");
scanf("%d",&m);
for(n=1; n<=m; n++){
printf("\n Introduce la
clave: ");
scanf("%d",&info_a[n].a);
printf("\n Da el nombre:
");
scanf("%s",&info_a[n].b);
printf("\n Da el apellido
paterno: ");
scanf("%s",&info_a[n].c);
printf("\n Da el apellido
materno: ");
scanf("%s",&info_a[n].d);
printf("\n
Que
sexo(genero) eres: ");
scanf("%s",&info_a[n].e);
printf("\n Cual es tu
edad: ");
scanf("%d",&info_a[n].f);
printf("\n Cuanto pesas:
");
scanf("%f",&info_a[n].g);
printf("\n Da tu estatura:
");
scanf("%f",&info_a[n].h);
printf("\n
tienes
alergias?; \n1.-SI \n2.-NO \n");
scanf("%d",&opci);
if(opci==1){
for(o=1; o<=m;
o++){
printf("%s\n",info_a[o].b);
}
printf("\nDeseas
ver los datos completos de los
pacientes?");
printf("\n1.-Si
2.-No");
scanf("%d",&com);
if(com==1){
for(s=1;
s<=m; s++){
scanf("%d",&info_a[n].l);
if(info_a[n].l==1){
printf("\nEscribe
que tienes:\n");
las alergias
scanf("%s",&info_a[m].i);
}
printf("\n Introduce tu
grupo sanguineo: ");
scanf("%s",&info_a[n].j);
printf("\n Da tu factor
Rh: ");
scanf("%s",&info_a[n].k);
}
do{
clrscr();
printf("\n\nOpciones:");
printf("\n1.-Nombre");
printf("\n2.-Alergias");
printf("\n3.-Sexo");
printf("\n4.-Factor Rh");
printf("\nTeclea
la
opcion que desees ejecutar: ");
printf("\n\n\n
Clave
paciente: %d ",info_a[s].a);
del
printf("\n
",info_a[s].b);
%s
Nombre:
printf("\n Apellido paterno: %s

",info_a[s].c);
printf("\n Apellido Materno: %s
",info_a[s].d);
printf("\n
",info_a[s].e);
Sexo:
%s
printf("\n
aos",info_a[s].f);
Edad:
%d
printf("\n
Kg.",info_a[s].g);
Peso:
%f
printf("\n
m",info_a[s].h);
Estatura:
%f
printf("\n
",info_a[s].i);
Alergias:
%d
printf("\n Grupo Sanguineo: %s

",info_a[s].j);
printf("\n
",info_a[s].k);
Factor
Rh:
printf("%s",info_a[q].e);
}
}
else if(opci==4){
for(r=1; r<=m;
%s
}
}
}
else if(opci==2){
for(p=1; p<=m;
p++){
printf("\n
%s tiene estas alergias: ",info_a[p].b);
printf("%s",info_a[p].i);
}
}
else if(opci==3){
for(q=1; q<=m;
q++){
printf("\n
%s su sexo es: ",info_a[q].b);
r++){
printf("\n
%s su factor Rh es: ",info_a[r].b);
printf("%s",info_a[r].k);
}
}
else{printf("\nError esta
opcion no esta disponible");}
printf("\nDeseas repetir el
programa?");
printf("\n1.-Si 2.-No");
scanf("%d",&op);
}while(op==1);
getch();
}
Atof
La funcin atof retorna el valor convertido.
Ejemplo:
#include <stdio.h>
#include <stdlib.h>
int main()
{
char numPtr[11] = "123.456789";
printf( "Convirtiendo la cadena \"%s\" en un numero: %f\n", numPtr,
atof(numPtr) );
return 0;
}
Atoi
La funcin atoi retorna el valor convertido.
Ejemplo:
#include <stdio.h>
#include <stdlib.h>
int main()
{
char numPtr[5] = "1234";
printf( "Convirtiendo la cadena \"%s\" en un numero: %d\n", numPtr,
atoi(numPtr) );
return 0;
}
Atol
La funcin atol retorna el valor convertido.
Ejemplo:
#include <stdio.h>
#include <stdlib.h>
int main()
{
char numPtr[11] = "1234567890";
printf( "Convirtiendo la cadena \"%s\" en un numero: %u\n", numPtr,
atol(numPtr) );
return 0;
}
Itoa
Convierte un valor entero a una cadena terminada en nulo usando la base especificada y
alamacena el resultado en la variable daa.
/* itoa example */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int i;
char buffer [33];
printf ("Enter a number: ");
scanf ("%d",&i);
itoa (i,buffer,10);
printf ("decimal: %s\n",buffer);
itoa (i,buffer,16);
printf ("hexadecimal: %s\n",buffer);
itoa (i,buffer,2);
printf ("binary: %s\n",buffer);
return 0;
Isalnum
El valor de retorno ser no nulo si c es una letra o un nmero, y cero en caso contrario.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0sR(h&R1/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %d\n", cadena[i], isalnum(cadena[i]));
return 0;
}
Isalpha
El valor de retorno ser no nulo si c es una letra y cero en caso contrario.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0sR(h&R1/";
int i;
printf("%c, %d\n", cadena[i], isalpha(cadena[i]));
}
return 0;
Isascii
El valor de retorno ser no nulo si c est en el rango entre 0 y 127, en hezadecimal entre
0x00 y 0x7f.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0sR(h&~?R1/";
int i;
printf("%c, %d\n", cadena[i], isascii(cadena[i]));
}
return 0;
Iscntrl
El valor de retorno ser no nulo si c es un carcter "delete" o un carcter de control.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0s\003R(h\177&~?\037R1/";
int i;
if(isprint(cadena[i]))
printf("%c, %d\n", cadena[i], iscntrl(cadena[i]));
else
printf("%d, %d\n", cadena[i], iscntrl(cadena[i]));
}
return 0;
Isdigit
El valor de retorno ser no nulo si c es un dgito decimal.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0fR(4h&~?R1/";
int i;
printf("%c, %d\n", cadena[i], isdigit(cadena[i]));
return 0;
}
Isgraph
El valor de retorno ser no nulo si c es un carcter grfico.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0 sR(h &~?R 1/";
int i;
printf("%c, %d\n", cadena[i], isgraph(cadena[i]));
}
return 0;
Islower
El valor de retorno ser no nulo si c es un carcter en minscula.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = "aAbBcCdD31&75$/";
int i;
printf("%c, %d\n", cadena[i], islower(cadena[i]));
return 0;
}
Ispunct
El valor de retorno ser no nulo si c es un signo e puntuacin.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = "aAb.Bc/Cd(D3:1&,75%$/";
int i;
printf("%c, %d\n", cadena[i], ispunct(cadena[i]));
return 0;
}
Isprint
El valor de retorno ser no nulo si c es un carcter imprimible.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0 \003sR(h &~?\177R 1/";
int i;
printf("%c, %d\n", cadena[i], isprint(cadena[i]));
}
return 0;
Isspace
El valor de retorno ser no nulo si c es un carcter de tipo espacio.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0 sR\n(h &~?\177R\t 1/";
int i;
printf("%c, %d\n", cadena[i], isspace(cadena[i]));
return 0;
}
Isupper
El valor de retorno ser no nulo si c es un carcter en mayscula.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = "aAbBcCdD31&75$/";

int i;
printf("%c, %d\n", cadena[i], isupper(cadena[i]));
return 0;
}
Isxdigit
El valor de retorno ser no nulo si c es un dgito hexadecimal.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0fR(4h&5d~?ER1/";
int i;
printf("%c, %d\n", cadena[i], isxdigit(cadena[i]));
}
return 0;
Tolower
Convierte un carcter, en un parmetro entero ch, a minscula.
Valor de retorno:
ch debe estar en el rango 0 a 255, y si est entre A y Z lo convierte a su equivalente en el
rango a a z, el resto de los valores no son modificados. El valor de retorno es el valor
convertido si ch era una mayscula, o el valor original en caso contrario.
Nota: los caracteres en acentuados, o con diresis, en mayscula y la no sufren
modificaciones.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = "ESTO ES UNA CADENA DE PRUEBA";
int i;
cadena[i] = tolower(cadena[i]);
printf("%s\n", cadena);
return 0;
}
Toupper
Convierte un carcter, en un parmetro entero ch, a minscula.
Valor de retorno:
ch debe estar en el rango 0 a 255, y si est entre A y Z lo convierte a su equivalente en el
rango a a z, el resto de los valores no son modificados. El valor de retorno es el valor
convertido si ch era una mayscula, o el valor original en caso contrario.
Nota: los caracteres en acentuados, o con diresis, en mayscula y la no sufren
modificaciones.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = "ESTO ES UNA CADENA DE PRUEBA";
int i;
cadena[i] = tolower(cadena[i]);
printf("%s\n", cadena);
return 0;
}
Acos
Calcula el valor principal del arco coseno de x. Puede producirse un error de dominio
para los argumentos que no estn en el intervalo [-1, +1].
Valor de retorno:
La funcin acos retorna el arco coseno en el intervalo [0, PI] radianes.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 0.2345;
printf( "acos( %f ) = %f\n", x, acos(x) );

return 0;
Ceil
Calcula el valor integral ms pequeo que no sea menor de x.
Valor de retorno:
La funcin ceil retorna el resultado de la funcin "techo" de x.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 6.54321;
printf( "ceil( %f ) = %f\n", x, ceil(x) );

return 0;
Fabs
Calcula el valor absoluto del nmero de coma flotante, x.
Valor de retorno:
La funcin fabs retorna el valor absoluto de x.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = -6.54321;
printf( "fabs( %f ) = %f\n", x, fabs(x) );

return 0;
Idexp
Multiplica un nmero de coma flotante y un entero con potencia a la 2. Puede
producirse un error de recorrido.
Valor de retorno:
La funcin ldexp retorna el valor de x multiplicado por 2 elevado a la potencia de exp,
es decir, x * 2 exp.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 1.00;
int exp = 2;
printf( "ldexp( %f, %d ) = %f\n", x, exp, ldexp(x,exp) );

return 0;
Pow
Calcula x elevado a la potencia de y. Puede producirse un error de dominio si x es
negativo e y no es un valor entero. Tambin se produce un error de dominio si el
resultado no se puede representar cuando x es cero e y es menor o igual que cero. Un
error de recorrido puede producirse.
Valor de retorno:
La funcin pow retorna el resultado de xy.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 6.54321, y = 0.56789;
printf( "pow( %f, %f ) = %f\n", x, y, pow(x,y) );

return 0;
Tan
Calcula la tangente de x (medido en radianes).
Valor de retorno:
La funcin tan retorna la tangente, en radianes.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 3.1416/3.0;
printf( "tan( %f ) = %f\n", x, tan(x) );
return 0;
}
Asin
Calcula el valor principal del arco seno de x. Puede producirse un error de dominio para
los argumentos que no estn en el intervalo [-1, +1].
Valor de retorno:
La funcin asin retorna el arco seno en el intervalo [-PI/2, +PI/2] radianes.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 0.2345;
printf( "asin( %f ) = %f\n", x, asin(x) );
return 0;
}
Atan
Calcula el valor principal del arco tangente de x.
Valor de retorno:
La funcin atan retorna el arco tangente en el intervalo [-PI/2, +PI/2] radianes.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 0.2345;
printf( "atan( %f ) = %f\n", x, atan(x) );

return 0;
Atan2
Calcula el valor principal del arco tangente de y/x, usando los signos de ambos
argumentos para determinar el cuadrante del valor de retorno. Puede producirse un error
de dominio si ambos argumentos son cero.
Valor de retorno:
La funcin atan2 retorna el arco tangente de y/x, en el intervalo [-PI, +PI] radianes.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 0.2345, y = -3.4567;
printf( "atan2( %f, %f ) = %f\n", y, x, atan2(y,x) );

return 0;
Cos
Calcula el coseno de x (medido en radianes).
Valor de retorno:
La funcin cos retorna el coseno, en radianes.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 3.1416/3.0;
printf( "cos( %f ) = %f\n", x, cos(x) );

return 0;
Cosh
Calcula el coseno hiperblico de x. Puede producirse un error de recorrido si la

magnitud de x es demasiada grande.
Valor de retorno:
La funcin cosh retorna el coseno hiperblico.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 3.0;
printf( "cosh( %f ) = %f\n", x, cosh(x) );
return 0;
}
Exp
Calcula la funcin exponencial de x.
Valor de retorno:
La funcin exp retorna el valor de ex.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = -5.567;
printf( "exp( %f ) = %f\n", x, exp(x) );
return 0;
}
Floor
Calcula el valor integral ms grande que no sea mayor de x.
Valor de retorno:
La funcin floor retorna el resultado de la funcin "suelo" de x.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 6.54321;
printf( "floor( %f ) = %f\n", x, floor(x) );
return 0;
}
Fmod
Calcula el resto de coma flotante de la divisin de x/y.
Valor de retorno:
La funcin fmod retorna el resto de x/y.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = -6.54321, y = 1.23456;
printf( "fmod( %f ) = %f\n", x, fmod(x) );
return 0;
}
Frexp
Parte en dos el nmero de coma flotante en una fraccin normalizada y un entero con
potencia a la 2. Guarda el entero en el objecto int apuntado por exp.
Valor de retorno:
La funcin frexp retorna el valor de x tal que x es un double con magnitud en el
intervalo [1/2, 1] o cero, y valor = x * 2*exp. Si valor es cero, ambas partes del resultado
son cero.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double valor = 1.00, resultado;
int *exp = 2;
resultado = frexp( valor, exp );

printf( "frexp( %f, %d ) = %f\n", valor, *exp, resultado );
return 0;
Log
Calcula el logaritmo natural (o neperiano). Puede producirse un error de dominio si el
argumento es negativo. Puede producirse un error de recorrido si el argumento es cero.
Valor de retorno:
La funcin retorna el logaritmo natural, es decir, ln x.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 6.54321;
printf( "log( %f ) = %f\n", x, log(x) );

return 0;
Log10
Calcula el logaritmo en base 10 de x. Puede producirse un error de dominio si el
argumento es negativo. Puede producirse un error de recorrido si el argumento es cero.
Valor de retorno:
La funcin retorna el logaritmo en base 10, es decir, log x.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 6.54321;
printf( "log10( %f ) = %f\n", x, log10(x) );

return 0;
Modf
Parte en dos el argumento valor en una parte entera y otra decimal, cada una de las
cuales tiene el mismo signo que el argumento. Guarda la parte entera como un double
en el objeto apuntado por iptr.
Valor de retorno:
La funcin modf retorna la parte decimal con signo de valor.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double valor = 6.54321, *iptr, resultado;
resultado = modf( valor, iptr );

printf( "modf( %f, %f ) = %f\n", valor, *iptr, resultado );
return 0;
Sin
Calcula el seno de x (medido en radianes).
Valor de retorno:
La funcin sin retorna el seno, en radianes.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 3.1416/3.0;
printf( "sin( %f ) = %f\n", x, sin(x) );

return 0;
Sinh
Calcula el seno hiperblico de x. Aparece un error de recorrido si la magnitud de x es
demasiada grande.
Valor de retorno:
La funcin sinh retorna el seno hiperblico.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 3.0;
printf( "sinh( %f ) = %f\n", x, sinh(x) );
return 0;
}
Sqrt
Calcula la raz cuadrada del valor no negativo de x. Puede producirse un error de
dominio si x es negativo.
Valor de retorno:
La funcin sqrt retorna el resultado de la raz cuadrada de x.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 6.54321;
printf( "sqrt( %f ) = %f\n", x, sqrt(x) );
return 0;
}
Tanh
Calcula la tangente hiperblica de x.
Valor de retorno:
La funcin tanh retorna la tangente hiperblica.
Ejemplo:
#include <stdio.h>
#include <math.h>
int main()
{
double x = 3.0;
printf( "tanh( %f ) = %f\n", x, tanh(x) );

return 0;
//programa que lee una frase y da el numero de palabras que tiene

#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <iostream.h>
#include <string.h>
main(){
char x[100];
int space=1, cont;
cout<<"Dame una cadena: \n"; gets (x);
for(cont=0; x[cont];cont++){
if(isspace(x[cont])) space+=1;
}
printf("Hay %d palabras",space);
getch();
}
//lee una palabra y la muestra en orden inverso
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
main(){
char x[100];
int space=1, cont, a;
printf("Dame una palabra: \n");
scanf("%s",&x);
a=strlen(x);
for(cont=a;cont>=0;cont--){
printf("\n%c",x[cont]);
}
getch();
}
//lee 3 palabras y las muestra en orden alfabtico
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
void main(void)
{
int i, n=0, elem;
char cad[4][51], temp[51];
clrscr();
printf("Introduce 3 palabras para que las ordenemos alfabeticamente\n");
do
{
printf("Palabra %d: ", n+1);
gets(cad[n]);
fflush(stdin);
n=n+1;
}while(n<3);
for(elem=0; elem<n-1; elem++){
for(i=elem+1; i<n; i++){
if(strcmpi(cad[elem], cad[i])>0)
{
strcpy(temp, cad[elem]);
strcpy(cad[elem], cad[i]);
strcpy(cad[i], temp);
}
}
}
printf("\nLAS PALABRAS ORDENADAS ALFABETICAMENTE SON:");
for(i=0; i<n; i++)
printf("\n%d: %s", i+1, cad[i]);
getch();
}
//Que lea 5 palabrasy las muestre en maysculas
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
main(){
char n[100];
printf("Da 5 palabras en minusculas:\n");
gets(n);
strupr(n);
printf("\nTodo en mayusculas es:\n");
printf("%s",n);
getch();
}
//Que lea 4 palabras y diga cuantas tienen mas de 7 letras
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
main(){
char w[20];
int a,
b=0, e;
for(e=0; e<=3;e++){
printf("\nDa una palabra: ");
scanf("%s",w);
a=strlen(w);
if(a>7){
b+=1;
}
}
printf("\n hay %d con mas de 7 letras",b);
getch();
}
//Que lea 3 palabras y las muestre de menor a mayor por el numero de caracteres.
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
main(){
char x[20], y[20],z[20];
int a, b, c;
printf("Da 3 palabras:\n");
scanf("%s %s %s",&x, &y, &z);
a=strlen(x);
b=strlen(y);
c=strlen(z);
if(a>b){
if(a>c){
if(b>c){
printf("\nLa palabra mas pequea es: %s",z);
printf("\nLa que esta en medio de las tres palabras es:
%s",y);
printf("\nLa que tine mas caracteres es: %s",x);
}
else{
printf("\nLa palabra mas pequea es: %s",y);
printf("\nLa que esta en medio de las tres palabras es: %s",z);
printf("\nLa que tine mas caracteres es: %s",x);
}
}
else{
printf("\nLa palabra mas pequea es: %s",y);
printf("\nLa que esta en medio de las tres palabras es: %s",x);
printf("\nLa que tine mas caracteres es: %s",z);
}
}
else if(b>c){
if(a>c){
printf("\nLa palabra mas pequea es: %s",z);
printf("\nLa que esta en medio de las tres palabras es: %s",x);
printf("\nLa que tine mas caracteres es: %s",y);
}
else{
printf("\nLa palabra mas pequea es: %s",x);
printf("\nLa que esta en medio de las tres palabras es: %s",z);
printf("\nLa que tine mas caracteres es: %s",y);
}
}
else if(b==a){
printf("\nLa palabra %s, y la palabra %s, tienen el mismo tamao",y,x);
if(c>a){
printf("\nLa palabra mayor es: %s",z);
}
else{printf("\nLa palabra menor es: %s",z);}
}
else if(a==c){
printf("\nTiene el mismo tamao las palabras: %s y %s",x,z);
if(b>a){
printf("\nLa palabra mayor es: %s",y);
}
else{printf("\nLa palabra menor es: %s",y);}
}
else if(c==b){
printf("\nLa palabra %s y la palabra %s tienen el mismo tamao: ",z,y);
if(a>b){
printf("\nLa palabra mayor es: %s",x);
}
else{printf("\nLa palabra menor es: %s",x);}
}
else{
printf("\nLa que tine mas caracteres es: %s",z);
printf("\nLa que esta en medio de las tres palabras es: %s",y);
printf("\nLa palabra mas pequea es: %s",x);
}
getch();
}
//Que lea dos palabras y diga si son iguales
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
void main ()
{
int i=0;
int tamano=0;
int contador=0;
char palabra1[20];
char palabra2[20];
printf("Escribe la primera palabra:\n");
scanf("%s",&palabra1);
printf("Escribe la otra palabra:\n");
scanf("%s",&palabra2);
tamano= strlen(palabra1);
strlwr(palabra1);
strlwr(palabra2);
//para el de hoy a las 11.30
for (i=0; i<tamano; i++){
if(palabra1[i]==palabra2[i]){
contador++;
}
}
if(contador==tamano){
printf("La palabra %s es la misma",palabra2);
}
else{
printf("La palabra %s NO ES %s",palabra2,palabra1);
}
getch();
}
//que lea una frase y la muestre sin espacios
#include <stdio.h>
#include <conio.h>
#include <string.h>
int main(){
char s1[100];
char s2[4]=" \n\t";
char *ptr;
printf("Introduce una cadena o una frase:\n");
gets(s1);
printf("s1=%s",s1);
ptr=strtok(s1,s2);
printf("\nCadena sin espacios...\n");
printf("\n%s",ptr);
while((ptr=strtok(NULL,s2))!=NULL)
printf("%s",ptr);
return 0;
}
File
El tipo FILE es una estructura (misma que estudiaremos en la siguiente leccin) que
est definida en el archivo de cabecera stdio.h, se usa para definir un puntero que
se utilizar en operaciones con archivos. Por definicin, C requiere para accesar a un
archivo de un puntero de tipo FILE, como es normal, se puede utilizar cualquier
nombre para representar dicho puntero, es comn utilizar fp, as que ste nombre
utilizamos en el primer cdigo.
#include <stdio.h>
#include <string.h>
int main()
{
FILE *fp;
fp = fopen("prueba.htm", "w");
/* Abrir archivo para escritura */
fprintf(fp, "<HTML> \n");
fprintf(fp, "<BODY> \n");
fprintf(fp, "Esta es la primera linea de texto. \n");
fprintf(fp, "<CENTER>Esta es la segunda"
"linea</CENTER> \n");
fprintf(fp, "Y esta es la <B>tercera linea"
"de texto.</B> \n");

*/
fclose(fp);
/* Cerrar el archivo antes de terminar el programa
printf("Se ha creado el archivo: prueba.htm \n");

}
return 0;
Fopen
Abre un fichero cuyo nombre es la cadena apuntada por nombre, y adjudica un stream a
ello. El argumento modo apunta a una cadena empezando con una serie de caracteres de
la siguiente secuencia:
r
w
a
rb
wb
ab
r+
w+
a+
r+b
rb+
w+b
wb+
a+b
ab+
Abre un fichero de texto para lectura

Trunca, a longitud cero o crea un fichero de texto
para escribir
Aade; abre o crea un fichero de texto para escribir
al final del fichero (EOF)
Abre un fichero en modo binario para lectura
Trunca, a longitud cero o crea un fichero en modo
binario para escribir
Aade; abre o crea un fichero en modo binario para
escribir al final del fichero (EOF)
Abre un fichero de texto para actualizacin (lectura
y escritura)
Trunca, a longitud cero o crea un fichero de texto
para actualizacin
Aade; abre o crea un fichero de texto para
actualizacin, escribiendo al final del fichero (EOF)
Abre un fichero en modo binario para actualizacin
(lectura y escritura)
Trunca, a longitud cero o crea un fichero en modo
binario para actualizacin
Aade; abre o crea un fichero en modo binario para
actualizacin, escribiendo al final del fichero (EOF)
Abriendo un fichero con el modo de lectura ('r' como el primer carcter del argumento
modo) fallar si el fichero no existe o no puede ser ledo. Abriendo el fichero con el
modo de aadidura ('a' como el primer carcter del argumento modo) ocasiona todas las
escrituras posteriores al fichero a ser forzadas al final de fichero (EOF) actual, sin
considerar llamadas interventivas a la funcin fseek. En algunas implementaciones,
abriendo un fichero en modo binario con el modo de aadidura ('b'como el segundo o
tercer carcter del argumento modo) puede colocar, inicialmente, el indicador de
posicin de ficheros para el stream ms all de los ltimos datos escritos, debido al
relleno de caracteres nulos.
Cuando un fichero es abierto con el modo de actualizacin ('+' como el segundo o tercer
carcter del argumento modo), la entrada y salida pueden ser manipuladas en el stream
asociado. Sin embargo, la salida no puede estar seguida directamente de una entrada sin
tener una llamada interventiva a la funcin fflush o a una funcin de manipulacin del
fichero de posicin (fseek, fsetpos, o rewind), y la entrada no puede estar seguida
directamente de una salida sin tener una llamada interventiva a una funcin de
manipulacin del fichero de posicin, al menos que el proceso de entrada encuentre un
final de fichero (EOF). Abriendo (o creando) un fichero de texto con el modo de
actualizacin puede en su lugar abrir (o crear) un stream binario en algunas
implementaciones.
Cuando es abierto, un stream es almacenado completamente si, y slo si, puede ser
determinado que no hace referencia a un dispositivo interactivo. Los indicadores de
error y final de fichero (EOF) para el stream son borrados.
Valor de retorno:
La funcin fopen retorna un puntero al objeto controlando el stream. Si el proceso de
abertura no es realizado acabo, entonces retorna un puntero nulo.
Ejemplo:
#include <stdio.h>
int main()
{
FILE *fichero;
char nombre[10] = "datos.dat";
fichero = fopen( nombre, "w" );
printf( "Fichero: %s -> ", nombre );
if( fichero )
printf( "creado (ABIERTO)\n" );
else
{
printf( "Error (NO ABIERTO)\n" );
return 1;
}
if( !fclose(fichero) )
printf( "Fichero cerrado\n" );
else
{
printf( "Error: fichero NO CERRADO\n" );
return 1;
}
}
return 0;
Fprintf
Esta funcin enva datos al stream apuntado por stream, bajo el control de la cadena
apuntada por formato que especifica cmo los argumentos posteriores son convertidos
para la salida. Si hay argumentos insuficientes para el formato, el comportamiento no
est definido. Si el formato termina mientras quedan argumentos, los argumentos
restantes son evaluados (como siempre) pero ignorados. La funcin retorna control
cuando el final de la cadena de formato es encontrado.
Valor de retorno:
La funcin fprintf retorna el nmero de caracteres transmitidos, o un valor negativo si
un error de salida se ha producido.
Ejemplo:
#include <stdio.h>
int main()
{
FILE *fichero;
char nombre[10] = "datos.dat";
unsigned int i;
fichero = fopen( nombre, "w" );
printf( "Fichero: %s (para escritura) -> ", nombre );
if( fichero )
else
{
return 1;
}
fprintf( fichero, "Esto es un ejemplo de usar la
funcion \'fprintf\'\n" );
fprintf( fichero, "\t 2\t 3\t 4\n" );
fprintf( fichero, "x\tx\tx\tx\n\n" );
for( i=1; i<=10; i++ )
fprintf( fichero, "%d\t%d\t%d\t%d\n", i, i*i, i*i*i, i*i*i*i );
fprintf( stdout, "Datos guardados en el fichero: %s\n", nombre );
printf( "Fichero cerrado\n" );
else
{
printf( "Error: fichero NO CERRADO\n" );
return 1;
}
return 0;
}
Feof
La funcin feof comprueba el indicador de final de fichero para el stream apuntado por
stream.
Valor de retorno:
La funcin feof retorna un valor distinto a cero si y slo si el indicador de final de

fichero est activado para stream.
Ejemplo:
#include <stdio.h>
int main( void )
{
int tamanyo=0;
FILE *ficheroEntrada, *ficheroSaliada;
char nombreEntrada[11]="datos2.dat", nombreSalida[11]="datos3.dat";
ficheroEntrada = fopen( nombreEntrada, "r" );
printf( "Fichero de Lectura: %s -> ", nombreEntrada );
if( ficheroEntrada )
printf( "existe (ABIERTO)\n" );
else
{
return 1;
}
ficheroSalida = fopen( nombreSalida, "w" );
printf( "Fichero de Lectura: %s -> ", nombreSalida );
if( ficheroSalida )
else
{
return 1;
}
while( !feof(ficheroEntrada) )
{
fputc( fgetc(ficheroEntrada)+3, ficheroSalida );
/* Desplazar
cada carcter 3 caracteres: a -> d, b -> e, ... */
tamanyo++;
}
printf( "El fichero \'%s\' contiene %d caracteres.\n",
nombreEntrada, tamanyo );
if( !fclose(ficheroSalida) )
printf( "Fichero: %s cerrado\n", nombreSalida );
else
{
printf( "Error: fichero: %s NO CERRADO\n", nombreSalida );
return 1;
}
if( !fclose(ficheroEntrada) )
printf( "Fichero: %s cerrado\n", nombreEntrada );
else
{
printf( "Error: fichero: %s NO CERRADO\n", nombreEntrada );
return 1;
}
}
return 0;
Fgets
Esta funcin lee como mximo uno menos que el nmero de caracteres indicado por n
desde el stream apuntado por stream al array apuntado por cadena. Ningn carcter
adicional es ledo despus del carcter de nueva lnea (el cual es retenido) o despus de
un final de fichero (EOF). Un carcter nulo es escrito inmediatamente despus del
ltimo carcter ledo en el array.
Valor de retorno:
La funcin fgets retorna cadena si es realizada con xito. Si un final de fichero (EOF)
es encontrado y ningn carcter ha sido ledo en el array, entonces el contenido del array
permanece invariable y un puntero nulo es retornado. Si ocurre un error de lectura
durante el proceso, el contenido del array es indeterminado y un puntero nulo es
retornado.
Ejemplo:
#include <stdio.h>
int main()
{
char nombre[10]="datos.dat", linea[81];
FILE *fichero;
fichero = fopen( nombre, "r" );
if( fichero )
printf( "existe (ABIERTO)\n" );
else
{
return 1;
}
printf( "La primera linea del fichero: %s\n\n", nombre );
printf( "%s\n", fgets(linea, 81, fichero) );
printf( "\nFichero cerrado\n" );
else
{
printf( "\nError: fichero NO CERRADO\n" );
return 1;
}
}
return 0;
Fputc
Esta funcin escribe el carcter indicado por c (convertido a un unsigned char) al
stream de salida apuntado por stream, en la posicin indicada por el indicador de
posicin de ficheros asociado al stream (si est definido), y avanza el indicador
apropiadamente. Si el fichero no soporta peticiones de posicin, o si el stream fue

abierto con el modo de aado, el carcter es aadido al stream de salida.
Valor de retorno:
La funcin fputc retorna el carcter escrito. Si ocurre un error de escritura, el indicador
de error para el stream es activado y fputc retorna EOF.
Ejemplo:
#include <stdio.h>
int main()
{
char nombre[10]="datos.dat";
FILE *fichero;
int i;
fichero = fopen( nombre, "a" );
if( fichero )
printf( "existe o ha sido creado (ABIERTO)\n" );
else
{
return 1;
}
printf( "Escribimos las 18 primeras letras del abecedario ingles en
el fichero: %s\n\n", nombre );
for( i=0; i<18; i++)
printf( "%c", fputc('a'+i, fichero) );
else
{
return 1;
}
return 0;
}
Fwrite
La funcin fwrite enva, desde el array apuntado por puntero, hasta nmemb de
elementos cuyo tamao es especificado por tamanyo, al stream apuntado por stream.
El indicador de posicin de ficheros para el stream (si est definido) es avanzado por el
nmero de caracteres escritos correctamente. Si existe un error, el valor resultante del
indicador de posicin de ficheros para el stream es indeterminado.
Valor de retorno:
La funcin fwrite retorna el nmero de caracteres escritos correctamente, el cual puede

ser menor que nmemb, pero slo si se produce un error de escritura.
Ejemplo:
#include <stdio.h>
int main()
{
FILE *fichero;
char nombre[11] = "datos5.dat";
unsigned int dinero[10] = ;
unsigned int leer[10], i;
fichero = fopen( nombre, "w+" );
if( fichero )
else
{
return 1;
}
printf( "Escribiendo cantidades:\n\n" );
for( i=0; i<10; i++ )
printf( "%d\t", dinero[i] );
fwrite( dinero, sizeof(unsigned int), 10, fichero );
printf( "\nLeyendo los datos del fichero \"%s\":\n", nombre );
rewind( fichero );
fread( leer, sizeof(unsigned int), 10, fichero );
for( i=0; i<10; i++ )
printf( "%d\t", leer[i] );
else
{
return 1;
}
}
return 0;
//validacin de registros
#include <stdio.h>//libreria estandar
#include <conio.h>//libreria para utilizar el getch();
#include <string.h>//por si se utilizaba algunaa funcion de "str..."
#include <stdlib.h>//para pdoer emplear "fflush(stdin)"
#include <iostream.h>//para utlizar el cout, que al final y no lo utilizamos pero por si las
dudas
#include <ctype.h>//para convertir a minusculas la cadena.

//structura del progrma con las variables de pos, nombre, cantidad, precio Sin I.V.A.,
precio con I.V.A.
struct direc{
int pos;
char nombre[30];
int cant;
int si;
float ci;
}info_direc[5];
void main(void){
int k, l, m;
clrscr();//limpiamos pantalla
//ciclo para pedir registros
for(l=0;l<=3;l++){
printf("\nposicion: ");//pedimos la posicion
scanf("%d",&info_direc[l].pos);//almacenamos
en
la
variable
"info_direc[0].pos"
if( (isalpha(info_direc[l].pos))!=0||info_direc[l].pos<1){//validamos que no sea
un caracter ni un numero negativo
fflush(stdin);//para evitar el salto incomodo
printf("\nintroduciste un caracter, da un numero valido porfavor!!!: ");
scanf("%d",&info_direc[l].pos);
}
for(m=0;m<l;m++){//checamos por medio de este ciclo que la posicion no se
encuentre ya ocupada
if(info_direc[m].pos==info_direc[l].pos){
printf("\nDa otra posicion que esta posicion ya se encuentra
ocupada: ");
scanf("%d",&info_direc[l].pos);
}
}
fflush(stdin);//utilizamos esta funcion por que habia un salto al momento de compilar
y no pedia el nombre
printf("\n Da el nombre: ");gets(info_direc[l].nombre);//utilizamos gets por que es
mas confiable al momentoo de leer cadenas con espacios
strlwr(info_direc[l].nombre);//pasamos el nombre todo a minusculas para evitar
problemas de reconocimiento
printf("\ncantidad: ");//pedimos la cantidad
scanf("%d",&info_direc[l].cant);//la almacenamos
if(
(isalpha(info_direc[l].cant))!=0||info_direc[l].cant<1){//hacemos
la
validacion
fflush(stdin);
scanf("%d",&info_direc[l].cant);
}
printf("\nPrecio Sin Iva: ");//pedimos el precio sin iva
scanf("%d",&info_direc[l].si);
if( (isalpha(info_direc[l].si))!=0||info_direc[l].si<1){//validamos que no sea una
caracter o un numero negativo o cero.
fflush(stdin);
scanf("%d",&info_direc[l].si);
}
info_direc[l].ci=info_direc[l].si*1.15;//con esto sacamos el precio con iva
automaticamente, calculando el precio original e incrementandole el 15%.
}//se ciera ciclo del for, el primero
int opci, op,a,b, i,j, contador, x, y,b1,b2;//pedimos mas variables las cuales
emplearemos
char n[20];//la variable n del tipo char para cuando busquen el nombre en la
consulta
printf("\n\nOpciones:\n");//damos opciones para mostrar todo
printf("1.-Datos Generales\n");//o poder especificar y hacer la busqueda
printf("2.-Especific\n");
printf("Teclea la opcion que deseas: ");
scanf("%d",&opci);
if(opci==1) {//si opcion 1 haz
gotoxy(1,1);
printf("Posicion");
gotoxy(15,1);
printf("Nombre");
gotoxy(35,1);
printf("Cantidad");
gotoxy(50,1);
printf("Precio");
gotoxy(45,3);
printf("sin I.V.A.|");
gotoxy(60,1);
printf("Precio");
gotoxy(60,3);
printf("con I.V.A.");
for(a=0;a<=3;a++){//desde que a sea igual a a cero hasta que a sea menor a 3
hacer
//la imprecion de todos los datos de todos los registros pues se solicito la muestra
de datos generales
gotoxy(1,(a*4)+4);//aplicamos en y: 6*(b+1), para que se vayan separando

cuando sea otro registro el que se pide.
printf("%d",info_direc[a].pos);
gotoxy(15,(a*4)+4);
printf("%s",info_direc[a].nombre);
gotoxy(35,(a*4)+4);
printf("%d",info_direc[a].cant);
gotoxy(50,(a*4)+4);
printf("%d",info_direc[a].si);
gotoxy(60,(a*4)+4);
printf("%1.2f",info_direc[a].ci);
}//cierre ciclo for
}//cierre del if de la opcion uno.
else if(opci==2){//si opcion dos entonces
printf("\nDa el Nombre de la monografia:\n");//pedir el nombre que buscan en
las monografias
scanf("%s",&n);//leerlo en la variable n.
clrscr();//borramos pantalla
//ahora por medio de la funcion gotoxy, colocamos obligatoriamente los titulos
en x y y coordenadas
gotoxy(1,1);
printf("Posicion");
gotoxy(15,1);
printf("Nombre");
gotoxy(35,1);
printf("Cantidad");
gotoxy(50,1);
printf("Precio");
gotoxy(45,3);
printf("sin I.V.A.|");
gotoxy(60,1);
printf("Precio");
gotoxy(60,3);
printf("con I.V.A.");
for(b=0;b<=3;b++){//desde que b es igual a cero hasta que bea sea menor a 3,
hacer, se pone solo hasta tres por ser 4 el numero de registros nada mas
x=strlen(info_direc[b].nombre); //contamos los caracteres del nombre
oiginal
y=strlen(n); //contamos los caracteres de la palabra que buscan
//ciclo que recorrera el nombre original buscando al palabra que
menciona el usuario
for(j=0;j<x-y+1;j++){ //para no recorrer toda el nombre original y un
espacio de mas por el caracter nulo
b2=0; //a b se le asigna 0.
for(i=0;i<y;i++){ //desde 0 hasta el numero de caracteres de y

hacer
if(n[i]!=info_direc[b].nombre[j+i]){ //si la el caracter que
se busca en la posicion "i", es diferente al
//caracter que se busca en la posicion j+1, por que va
atrasado
b2++;//b igual a b+b.
break;
}
}//se cierra ciclo for.
if(b2==0){ //si b es igual a cero entonces la palabra no es
diferent y si se encuentra en el nombre original
//prueba
gotoxy(1,6*(b+1));//aplicamos en y: 6*(b+1), para que se vayan separando
cuando sea otro registro el que se pide.
printf("%d",info_direc[b].pos);
gotoxy(15,6*(b+1));
printf("%s",info_direc[b].nombre);
gotoxy(35,6*(b+1));
printf("%d",info_direc[b].cant);
gotoxy(50,6*(b+1));
printf("%d",info_direc[b].si);
gotoxy(60,6*(b+1));
printf("%1.2f",info_direc[b].ci);
break;}//se rompe el ciclo y se cierra el if
}//se cierra ciclo for; j=0;j<x-y+1
}//se cierra ciclo for; b=0; b<=3
}//se cierra sentencia else if, de la opcion dos
else {printf("\nLa opcin que escogiste no existe");}//en caso de que den otra
opcion que no sea 1 ni 2.
getch();//congelamos pantalla
}//cerramos programa
//leer archivo
#include <conio.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
void main(void){
FILE *ent;
char linea[80];
if ((ent=fopen("\\prueba.cpp","r"))==NULL)
{ fprintf(stderr,"NO SE PUEDE LEER EL ARCHIVO");
getch();
//return 1;
}
clrscr();
while(!feof(ent))
{ fgets(linea,strlen(linea)+1,ent);
printf("%s",linea);
}
fclose(ent);
getch();
}
Estrcuturas de control de programa
If
La palabra if significa si (condicional), pero supongo que esto ya lo sabas. Su formato
es el siguiente:
if ( condicin )
{
instrucciones a ejecutar
}
Cuando se cumple la condicin entre parntesis se ejecuta el bloque inmediatamente

siguiente al if (bloque instrucciones a ejecutar).
En el siguiente ejemplo tenemos un programa que nos pide un nmero, si ese nmero es
10 se muestra un mensaje. Si no es 10 no se muestra ningn mensaje:
#include <stdio.h>
int main()
{
int num;
printf( "Introduce un nmero " );
scanf( "%i", &num );
if (num==10)
{
printf( "El nmero es correcto\n" );
}
}
Como siempre, la condicin es falsa si es igual a cero. Si es distinta de cero ser

verdadera.
If - Else
El formato es el siguiente:
if ( condicin )
{
bloque que se ejecuta si se cumple la condicin
}
else
{
bloque que se ejecuta si no se cumple la condicin
}
En el if si no se cumpla la condicin no se ejecutaba el bloque siguiente y el programa

segua su curso normal. Con el if else tenemos un bloque adicional que slo se ejecuta si
no se cumple la condicin. Veamos un ejemplo:
#include <stdio.h>
);
int main()
{
int a;
scanf( "%i", &a );
if ( a==8 )
{
printf ( "El nmero introducido era un ocho.\n"
else
}
{
printf ( "Pero si no has escrito un ocho!!!"\n"
);
}
}
Al ejecutar el programa si introducimos un 8 se ejecuta el bloque siguiente al if y se

muestra el mensaje:
El nmero introducido era un ocho.
Si escribimos cualquier otro nmero se ejecuta el bloque siguiente al else mostrndose

el mensaje:
Pero si no has escrito un ocho!!!
Switch
El formato de la sentencia switch es:
switch ( variable )
{
case opcin 1:
cdigo a ejecutar si la variable tiene el
valor de la opcin 1
break;
case opcin 2:
cdigo a ejecutar si la variable tiene el

valor de la opcin 2
break;
default:
cdigo que se ejecuta si la variable tiene
un valor distinto a los anteriores
break;
}
Vamos a ver cmo funciona. La sentencia switch sirve par elegir una opcin entre varias
disponibles. Aqu no tenemos una condicin que se debe cumplir sino el valor de una
variable. Dependiendo del valor se cumplir un caso u otro.
Vamos a ver un ejemplo de mltiples casos con if-else y luego con switch:
#include <stdio.h>
int main()
{
int num;
if ( num==1 )
printf ( "Es un 1\n" );
else if ( num==2 )
else if ( num==3 )
else
printf ( "No era ni 1, ni 2, ni 3\n" );
}
Ahora con switch:

#include <stdio.h>
int main()
{
int num;
switch( num )
{
case 1:
printf( "Es un 1\n" );
break;
case 2:
break;
case 3:
break;
default:
printf( "No es ni 1, ni 2, ni 3\n" );
}
}
Como vemos el cdigo con switch es ms cmodo de leer.

Vamos a ver qu pasa si nos olvidamos algn break:
#include <stdio.h>
int main()
{
int num;
switch( num )
{
case 1:
/* Nos olvidamos el break que debera
haber aqu */
case 2:

break;
default:
printf( "No es ni 1, ni 2, ni 3\n" );
}
Si al ejecutar el programa escribimos un dos tenemos el mensaje Es un dos. Todo

correcto. Pero si escribimos un uno lo que nos sale en pantalla es:
Es un 1
Es un 2
Por qu? Pues porque cada caso empieza con un case y acaba donde hay un break. Si
no ponemos break aunque haya un case el programa sigue hacia adelante. Por eso se
ejecuta el cdigo del case 1 y del case 2.
Puede parecer una desventaja pero a veces es conveniente. Por ejemplo cuando dos case
deben tener el mismo cdigo. Si no tuviramos esta posibilidad tendramos que escribir
dos veces el mismo cdigo. (Vale, vale, tambin podramos usar funciones, pero si el
cdigo es corto puede ser ms conveniente no usar funciones. Ya hablaremos de eso ms
tarde.).
Sin embargo switch tiene algunas limitaciones, por ejemplo no podemos usar
condiciones en los case. El ejemplo que hemos visto en el apartado if-else-if no
podramos hacerlo con switch.
El bucle For
El formato del bucle for es el siguiente:
for( dar valores iniciales ; condiciones ; incrementos )
{
conjunto de intrucciones a ejecutar en el bucle

}
Vamos a verlo con el ejemplo anterior:

...
for ( i=0 ; i<100 ; i++ )
...
En este caso asignamos un valor inicial a la variable i. Ese valor es cero. Esa es la parte
de dar valores iniciales. Luego tenemos i<100. Esa es la parte condiciones. En ella
ponemos la condicin es que i sea menor que 100, de modo que el bucle se ejecutar
mientras i sea menor que 100. Es decir, mientras se cumpla la condicin. Luego
tenemos la parte de incrementos, donde indicamos cunto se incrementa la variable.
Como vemos, el for va delante del grupo de instrucciones a ejecutar, de manera que si la
condicin es falsa, esas instrucciones no se ejecutan ni una sola vez.
Cuidado: No se debe poner un ";" justo despus de la sentencia for, pues entonces sera
un bucle vaco y las instrucciones siguientes slo se ejecutaran una vez. Veamoslo con
un ejemplo:
#include <stdio.h>
int main()
{
int i;
for ( i=0 ; i<100 ; i++ );
este punto y coma */
{
printf( "Hola\n" );
}
}
/* Cuidado con
Este programa slo escribir en pantalla

Hola
una sola vez.

Tamben puede suceder que quieras ejecutar un cierto nmero de veces una sla
instruccin (como sucede en nuestro ejemplo). Entonces no necesitas las llaves "{}":
#include <stdio.h>
int main()
{
int i;
for ( i=0 ; i<100 ; i++ ) printf( "Hola\n" );
}
o tambin:
for ( i=0 ; i<100 ; i++ )
printf( "Hola\n" );
Sin embargo, yo me he encontrado muchas veces que es mejor poner las llaves aunque
slo haya una instruccin; a veces al aadir una segunda instruccin ms tarde se te
olvidan las comillas y no te das cuenta. Parece una tontera, pero muchas veces, cuando
programas, son estos los pequeos fallos los que te vuelven loco.
En otros lenguajes, como Basic, la sentencia for es muy rgida. En cambio en C es muy
flexible. Se puede omitir cualquiera de las secciones (inicializacin, condiciones o
incrementos). Tambin se pueden poner ms de una variable a inicializar, ms de una
condicin y ms de un incremento. Por ejemplo, el siguiente programa sera
perfectamente correcto:
#include <stdio.h>
int main()
{
int i, j;
for( i=0, j=5 ;
{
printf(
printf(
printf(
}
}
i<10 ; i++, j=j+5 )

"Hola " );
"Esta es la lnea %i", i );
"j vale = %i\n", j );
Como vemos en el ejemplo tenemos ms de una variable en la seccin de inicializacin

y en la de incrementos. Tambin podamos haber puesto ms de una condicin. Los
elementos de cada seccin se separan por comas. Cada seccin se separa por punto y
coma.
Ms tarde veremos cmo usar el for con cadenas.
While
El formato del bucle while es es siguiente:
while ( condicin )
{
bloque de instrucciones a ejecutar
}
While quiere decir mientras. Aqu se ejecuta el bloque de intrucciones mientras se

cumpla la condicin impuesta en while.
Vamos a ver un ejemplo:
#include <stdio.h>
int main()
{
int contador = 0;
while ( contador<100 )
{
contador++;
printf( "Ya voy por el %i, parar
enseguida.\n", contador );
}
}
Este programa imprime en pantalla los valores del 1 al 100. Cuando i=100 ya no se
cumple la condicin. Una cosa importante, si hubesemos cambiado el orden de las
instrucciones a ejecutar:
...
printf( "Ya voy por el %i, parar enseguida.\n", contador );
contador++;
...
En esta ocasin se imprimen los valores del 0 al 99. Cuidado con esto, que a veces
produce errores difciles de encontrar.
Do While
El formato del bucle do-while es:
do
{
instrucciones a ejecutar
} while ( condicin );
La diferencia entre while y do-while es que en este ltimo, la condicin va despues del
conjunto de instrucciones a ejecutar. De esta forma, esas instrucciones se ejecutan al
menos una vez.
Su uso es similar al de while.
La sentencia break
Finaliza la ejecucin de una proposicin switch, for, while, do-while, en la que aparece,
saltndose la condicin normal del ciclo de repeticin.
For(i=0;i<110;i++){
Contador=1;
Do{
Printf(%d,contador);
Contadro++;
If(contador==10)break;
While();
}
Exit()
Otra forma de terminar un cliclo de repeticin desde dentro es utilizar la funcin exit().
A diferencia con el break, la funcin exit() terminara con la ejecucin del programa y
regresara el control al sistema operativo.
For(i=0;i<=100;i++){
Printf(El valor de I es %d,i);
If(i>10)exit();
}
Continue
Actua alreves que la sentencia break; obliga a quwe tenga lugar la siguiente iteracin,
saltndose cualquier intermedio.
Do{
Printf(Da un numero);
Scanf(%d,&x);
If(x<10)continue;
Printf(El numero es: %d, x);
} While (x!=100)
Aqu solo se imrimen los nmeros positivos, indroducir un numero negativo provocara
que el control del programa se salte a a evaluar la expresion x!=100.
Moda
Corresponde al valor que mas se repite, sta sirve para describir una distribucin si slo
se desea tener una idea aproximada y rpida de donde est la mayor concentracin de
observaciones. Tambin se la utiliza para describir la forma de algunas distribuciones.
Puede ocurrir que en un conjunto de datos no haya moda, como en: 3; 4; 7; 9; 10; 11;
13. O tambin que haya varios valores con la mayor frecuencia, en estos casos la moda
queda indeterminado.
//Calcula la moda
#include <stdio.h>
#include <conio.h>
#include <math.h>
void main (void){
int i, aux, lon, j, moda, c, b[100], veces=1, ban=1, a[100], mul;
printf("Cuentos numeros usaras");
scanf("%d",&lon);
a[lon];
b[lon];
for(c=0;c<lon;c++)
{
printf("Da un numero: ");
scanf("%d",&a[c]);
}
//ordena
for(i=0,aux=0; i<lon-1;i++)
{
for (j=lon-1;j>=1;j--)
{
if (a[j-1]>a[j])
{
aux=a[j];
a[j]=a[j-1];
a[j-1]=aux;
}
}
}
if(lon==1)
moda=a[0];
if(lon>1)
for(c=1,i=0;i<lon;i++,c=1)
{
for(j=i+1;j<lon;j++)
{
if(a[i]==a[j])
{
c++;
b[i]=c;
}
}
if(c>veces)
{
moda=a[i];
veces=c;
}
}
if(lon>1)
for(c=1,j=0;j<lon-1;j++)
{
if(a[j]==a[j+1])
ban=0;
}
for(c=0,i=0;i<lon;i++)
{
if(b[i]==veces)
{
mul=a[i];
c++;
}
if(c>1)
ban=2;
}
if(ban==0)
printf("La moda es: %d por que aparece: %d veces.", moda, veces);
if(ban==1)
printf("No hay Moda TODOS los numeros son diferentes");
if(ban==2)
printf("Es multimodal por: %d que aparecen: %d veces",mul,
veces);
getch();
}
Mediana
La mediana es aquel valor que ocupa el lugar central, de modo que la mitad
de los casos queda por debajo de ese valor y la otra mitad por encima. Por
ejemplo si consideramos: 2; 3; 5; 7; 11; 13; 16; 18; 25. La mediana es M =
11. Si el conjunto de valores es un nmero par, entonces se calcula la media
aritmtica a los dos valores del centro.
//calcula la media aritmtica
#include <stdio.h>
int main()
{
int i, indice, MAX;
float n[100], mediana;
printf("Cuantos numeros manejaras??\n");
scanf("%d",&MAX);
for (i=0; i<MAX; i++) {
printf("Ingrese el valor de n%d: ", i);
scanf("%f", &n[i]);
}
indice = ((MAX + 1) / 2)-1;
if (MAX % 2 == 0) {
mediana = ( n[indice] + n[indice+1] ) / 2.00;
} else {
mediana = n[indice];
}
printf("La mediana es: %.1f ", mediana);
while (getchar() != '\n'); getchar();
return 0;
}
Media
Corresponde a la suma de todos los datos dividido por el numero total de
ellos. Es lo que se conoce como "promedio". La media aritmtica es uno de
los estadgrafos ms usados, por el hecho de ser de muy fcil clculo.
//Calcula la media aritmtica
#include <conio.h>
#include <stdio.h>
Void main (void){
Int a, b, c=0, f=0, e=0, g;
Printf(Da el numero de elementos: \n);
Scanf(%d, &a);
While(e<a){
Printf(\nDa un numero: );
Scanf(%d, &b);
C=c+b;
F=f+1;
E++;
}
G=c/f;
Printf(\n\t la media es: %d,g);
Getch();
}
Estructura de datos dinmicas
Son aquellas cuyo tamao, longitud, numero de elementos, varia en tiempo de
ejecucin. Por ejemplo listas simplemente enlazadas, listas doblemente enlazadas, pilas,
colas, arboles y grafos.
Struct nodo{
Int dato;
Struct nodo *otronodo;
};
Formas de clasificar los mtodos de ordenamiento

Algoritmos de ordenamiento:
Internos:
1. Insercin directa.
1. Insercin directa.
2. Insercin binaria.
2. Seleccin directa.
1. Seleccin directa.
3. Intercambio directo.
1. Burbuja.
2. Shake.
4. Insercin disminucin incremental.
1. Shell.
5. Ordenamiento de rbol.
1. Heap.
2. Tournament.
6. Sort particionado.
1. Quick sort.
7. Merge sort.
8. Radix sort.
9. Clculo de direccin.
Externos:
1. Straight merging.
2. Natural merging.
3. Balanced multiway merging.
4. Polyphase sort.
5. Distribution of initial runs.
Clasificacin de los algoritmos de ordenamiento de informacin:
El hecho de que la informacin est ordenada, nos sirve para poder encontrarla y
accesarla de manera ms eficiente ya que de lo contrario se tendra que hacer de manera
secuencial.
A continuacin se describirn 4 grupos de algoritmos para ordenar informacin:
Algoritmos de insercin:
En este tipo de algoritmo los elementos que van a ser ordenados son considerados uno a
la vez. Cada elemento es INSERTADO en la posicin apropiada con respecto al resto de
los elementos ya ordenados.
Entre estos algoritmos se encuentran el de INSERCION DIRECTA, SHELL SORT,
INSERCION BINARIA y HASHING.
Algoritmos de intercambio:
En este tipo de algoritmos se toman los elementos de dos en dos, se comparan y se
INTERCAMBIAN si no estn en el orden adecuado. Este proceso se repite hasta que se
ha analizado todo el conjunto de elementos y ya no hay intercambios.
Entre estos algoritmos se encuentran el BURBUJA y QUICK SORT.
Algoritmos de seleccin:
En este tipo de algoritmos se SELECCIONA o se busca el elemento ms pequeo (o
ms grande) de todo el conjunto de elementos y se coloca en su posicin adecuada. Este
proceso se repite para el resto de los elementos hasta que todos son analizados.
Entre estos algoritmos se encuentra el de SELECCION DIRECTA.
Algoritmos de enumeracin:
En este tipo de algoritmos cada elemento es comparado contra los dems. En la
comparacin se cuenta cuntos elementos son ms pequeos que el elemento que se est
analizando, generando as una ENUMERACION. El nmero generado para cada
elemento indicar su posicin.
Los mtodos simples son: Insercin (o por insercin directa), seleccin, burbuja y shell,
en dnde el ltimo es una extensin al mtodo de insercin, siendo ms rpido. Los
mtodos ms complejos son el quick-sort (ordenacin rpida) y el heap sort.
A continuacin se mostrarn los mtodos de ordenamiento ms simples.
METODO DE INSERCIN.
Este mtodo toma cada elemento del arreglo para ser ordenado y lo compara con los que
se encuentran en posiciones anteriores a la de l dentro del arreglo. Si resulta que el
elemento con el que se est comparando es mayor que el elemento a ordenar, se recorre
hacia la siguiente posicin superior. Si por el contrario, resulta que el elemento con el
que se est comparando es menor que el elemento a ordenar, se detiene el proceso de
comparacin pues se encontr que el elemento ya est ordenado y se coloca en su

posicin (que es la siguiente a la del ltimo nmero con el que se compar).
Procedimiento Insertion Sort
Este procedimiento recibe el arreglo de datos a ordenar a[] y altera las posiciones de sus
elementos hasta dejarlos ordenados de menor a mayor. N representa el nmero de
elementos que contiene a[].
paso 1: [Para cada pos. del arreglo] For i <- 2 to N do
paso 2: [Inicializa v y j] v <- a[i]
j <- i.
paso 3: [Compara v con los anteriores] While a[j-1] > v AND j>1 do
paso 4: [Recorre los datos mayores] Set a[j] <- a[j-1],
paso 5: [Decrementa j] set j <- j-1.
paso 5: [Inserta v en su posicin] Set a[j] <- v.
paso 6: [Fin] End.
Ejemplo:
Si el arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'], el algoritmo va a
recorrer el arreglo de izquierda a derecha. Primero toma el segundo dato 's' y lo asigna a
v y i toma el valor de la posicin actual de v.
Luego compara esta 's' con lo que hay en la posicin j-1, es decir, con 'a'. Debido a que
's' no es menor que 'a' no sucede nada y avanza i.
Ahora v toma el valor 'o' y lo compara con 's', como es menor recorre a la 's' a la
posicin de la 'o'; decrementa j, la cual ahora tiene la posicin en dnde estaba la 's';
compara a 'o' con a[j-1] , es decir, con 'a'. Como no es menor que la 'a' sale del for y
pone la 'o' en la posicin a[j]. El resultado hasta este punto es el arreglo siguiente: a =
['a','o','s','r',....]
As se contina y el resultado final es el arreglo ordenado :
a = ['a','a','e','e','g','i','l','m','n','o','p','r','s','t','x']
MTODO DE SELECCIN.
El mtodo de ordenamiento por seleccin consiste en encontrar el menor de todos los
elementos del arreglo e intercambiarlo con el que est en la primera posicin. Luego el
segundo mas pequeo, y as sucesivamente hasta ordenar todo el arreglo.
Procedimiento Selection Sort
paso 1: [Para cada pos. del arreglo] For i <- 1 to N do
paso 2: [Inicializa la pos. del menor] menor <- i

paso 3: [Recorre todo el arreglo] For j <- i+1 to N do
paso 4: [Si a[j] es menor] If a[j] < a[menor] then
paso 5: [Reasigna el apuntador al menor] min = j
paso 6: [Intercambia los datos de la pos.
min y posicin i] Swap(a, min, j).
paso 7: [Fin] End.
Ejemplo:
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el
menor elemento es la primera 'a'. De manera que no ocurre ningn cambio. Luego se
procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que est en la segunda posicin, la 's', quedando el
arreglo as despus de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se
intercambia con lo que est en la tercera posicin, o sea, la 'o'. Le sigue la segunda 's', la
cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a =
['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posicin hasta
ordenar todo el arreglo.
El nmero de comparaciones que realiza este algoritmo es :
Para el primer elemento se comparan n-1 datos, en general para el elemento i-simo se
hacen n-i comparaciones, por lo tanto, el total de comparaciones es:
la sumatoria para i de 1 a n-1 (n-i) = 1/2 n (n-1).
MTODO BURBUJA.
El bubble sort, tambin conocido como ordenamiento burbuja, funciona de la siguiente
manera: Se recorre el arreglo intercambiando los elementos adyacentes que estn
desordenados. Se recorre el arreglo tantas veces hasta que ya no haya cambios.
Prcticamente lo que hace es tomar el elemento mayor y lo va recorriendo de posicin
en posicin hasta ponerlo en su lugar.
Procedimiento Bubble Sort
paso 1: [Inicializa i al final de arreglo] For i <- N down to 1 do
paso 2: [Inicia desde la segunda pos.] For j <- 2 to i do

paso 4: [Si a[j-1] es mayor que el que le sigue] If a[j-1] < a[j] then
paso 5: [Los intercambia] Swap(a, j-1, j).
paso 7: [Fin] End.
Tiempo de ejecucin del algoritmo burbuja:

1. Para el mejor caso (un paso) O(n)
2. Peor caso n(n-1)/2
3. Promedio O(n2)
MTODO DE SHELL.
Ordenamiento de disminucin incremental.
Nombrado as debido a su inventor Donald Shell.
Ordena subgrupos de elementos separados K unidades (respecto de su posicin en el
arreglo) del arreglo original. El valor K es llamado incremento.
Despus de que los primeros K subgrupos han sido ordenados (generalmente utilizando
INSERCION DIRECTA), se escoge un nuevo valor de K ms pequeo, y el arreglo es
de nuevo partido entre el nuevo conjunto de subgrupos. Cada uno de los subgrupos
mayores es ordenado y el proceso se repite de nuevo con un valor ms pequeo de K.
Eventualmente el valor de K llega a ser 1, de tal manera que el subgrupo consiste de
todo el arreglo ya casi ordenado.
Al principio del proceso se escoge la secuencia de decrecimiento de incrementos; el
ltimo valor debe ser 1.
"Es como hacer un ordenamiento de burbuja pero comparando e intercambiando
elementos."
Cuando el incremento toma un valor de 1, todos los elementos pasan a formar parte del
subgrupo y se aplica insercin directa.
El mtodo se basa en tomar como salto N/2 (siendo N el nmero de elementos) y luego
se va reduciendo a la mitad en cada repeticin hasta que el salto o distancia vale 1.
Procedimiento Shell Sort;
const
MAXINC = _____;
incrementos = array[1..MAXINC] of integer;
var
j,p,num,incre,k:integer;
begin
for incre := 1 to MAXINC do begin /* para cada uno de los incrementos */
k := inc[incre]; /* k recibe un tipo de incremento */
for p := k+1 to MAXREG do begin /* insercin directa para el grupo que se encuentra cada K posiciones */
num := reg[p];
j := p-k;
while (j>0) AND (num < reg[j]) begin
reg[j+k] := reg[j];
j := j - k;
end;
reg[j+k] := num;
end
end
end;
Ejemplo:
Para el arreglo a = [6, 1, 5, 2, 3, 4, 0]
Tenemos el siguiente recorrido:
Recorrido
Salto
Lista Ordenada
Intercambio
2,1,4,0,3,5,6
(6,2), (5,4), (6,0)
0,1,4,2,3,5,6
(2,0)
0,1,4,2,3,5,6
Ninguno
0,1,2,3,4,5,6
(4,2), (4,3)
0,1,2,3,4,5,6
Ninguno
// unir A y C en un arreglo tridimensional

//Calcular: la suma de A y B, y el promedio de los elementos de C.
#include <stdio.h>
#include <conio.h>
void main(void){
int suma=0, de, fg, sumb, d, g, hi, jk, sumc=0, sumab;
float prom;
int a[4][4]={
{1,-1,-1,-1},
{-1,2,-1,-1},
{-1,-1,3,-1},
{-1,-1,-1,4}};
int b[4][4]={
{5,3,3,3},
{3,6,3,3},
{3,3,7,3},
{3,3,3,8}};
int c[4][4]={
{9,7,7,7},
{7,0,7,7},
{7,7,1,7},
{7,7,7,2}};
//inciso numero 3
int D[4][4][2]=
{1,-1,-1,-1,-1,2,-1,-1,-1,-1,3,-1,-1,-1,-1,4,9,7,7,7,7,0,7,7,7,7,1,7,7,7,7,2};
//numero 4 inciso a.
for(de=0;de<4;de++){
for(fg=1;fg<=4;fg++){
suma=suma+a[de][fg];
}
}
for(d=0;d<4;d++){
for(g=1;g<=4;g++){
sumb=sumb+b[d][g];
}
}
sumab=suma+sumb;
printf("\nLa suma de las capas A y B es: %d",sumab);
//numero 4 inciso b.
for(hi=0;hi<4;hi++){
for(jk=0;jk<4;jk++){
sumc=sumc+c[hi][jk];
}
}
prom=sumc/16;
printf("\n\nEl promedio de la capa C es: %f",prom);
getch();
}
//Que lea 27 letras del alfabeto y almacene cada una en una localidad de un arreglo
tridimensional
Mostral al final el alfabeto en mayusculasy minsculas.
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main(void){
int cont, a, b, c;
char letra, let;
letra='A';
let='a';
int letras[3][3][3];
for(a=0;a<=2;a++){
for(b=0;b<=2;b++){
for(c=0;c<=2;c++){
if(letra<='Z'){
letras[a][b][c]=letra;
printf("%c ",letra);
letra=letra+1;
}
}
printf("\n");
}
printf("\n");
}
printf("\n");
for(a=0;a<=2;a++){
for(b=0;b<=2;b++){
for(c=0;c<=2;c++){
if(let<='z'){
letras[a][b][c]=let;
printf("%c ",let);
let=let+1;
}
}
printf("\n");
}
printf("\n");
}
getch();
}
Mtodo de Ordenamiento
Descripci
n
C
a
r
a
c
t
e
r
s
t
i
c
a
s
Ventajas
Burbuja
QuickSort
Insercin
Funciona
revisando
cada
elemento de
la lista que va
a ser
ordenada con
el siguiente,
intercambindolos de
posicin si
estn en el
orden
equivocado.
Es un
algoritmo
basado en la
tcnica de
divide y
vencers, que
permite, en
promedio,
ordenar n
elementos en
un tiempo
proporcional a
n log n. Esta
es la tcnica
de
ordenamiento
ms rpida
conocida.
Muy rpido.
No requiere
memoria
adicional.
Este mtodo
toma cada
elemento del
arreglo para
ser ordenado
y lo compara
con los que
se
encuentran
en
posiciones
anteriores a
la de l
dentro del
arreglo.
Es bastante
sencillo
En un cdigo
reducido se
realiza el
ordenamiento
Eficaz
Fcil
implementac
in.
Requerimient
Bsqueda
Binaria
La bsqueda
binaria
consiste en
dividir el
array por su
elemento
medio en
dos
subarrays
ms
pequeos, y
comparar el
elemento
con el del
centro.
Factible para
vectores con
grandes
cantidades
de
elementos
os mnimos
de memoria.
Desventaj
as
Ejemplos
Consume
bastante
tiempo de
computadora
Requiere
muchas
lecturas/escrit
uras en
memoria
Implementaci
n un poco
ms
complicada.
Recursividad
(utiliza
muchos
recursos).
Mucha
diferencia
entre el peor y
el mejor caso.
Lento.
Realiza
numerosas
comparacion
es
Es necesario
que el vector
este
ordenado
#include<stdio.h>
Burbuja
void ordenar(int *,int,int);
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define TAM 10
int main(){
int a[TAM], temp, i, j;
clrscr();
randomize(); //Inicializa el
generador de nmeros aleatorios
printf ("Llenando arreglo con
nmeros aleatorios\n");
for (i=0; i< TAM; i++)
a[i]=random(100);
//Implementacion
de Ordenamiento por burbuja de
mayor a menor
for (j=1; j <= TAM;
j++)
for (i=0; i< TAM-1;

i++)
if (a[i] >
a[i+1]){
temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
}
printf ("\nArreglo
ordenado\n");
printf ("a[%d] =
%d\n", i, a[i]);
getch();
}
QuickSort
void main()
{
// Dar valores al array
ordenar(array,0,N-1); // Para llamar a
la funcin
}
void ordenar(int *array,int desde,int
hasta)
{
int i,d,aux; // i realiza la bsqueda de
izquierda a derecha
// y j realiza la bsqueda de derecha a
izquierda.
if(desde>=hasta)
return;
for(i=desde+1,d=hasta;;) // Valores
iniciales de la bsqueda.
{
for(;i<=hasta &&
array<=array[desde];i++); // Primera
bsqueda
for(;d>=0 &&
array[d]>=array[desde];d--); //
segunda bsqueda
if(i<d) // si no se han cruzado:
{
aux=array; // Intercambiar.
array=array[d];
array[d]=aux;
}
else // si se han cruzado:
break; // salir del bucle.
}
if(d==desde-1) // Si la segunda
bsqueda se sale del array
d=desde; // es que el pivote es el
elemento
// ms pequeo: se cambia con l
mismo.
aux=array[d]; // Colocar el pivote
array[d]=array[desde]; // en su
posicin.
array[desde]=aux;
ordenar(array, desde,d-1); // Ordenar

el primer array.
ordenar (array, d+1,hasta); // Ordenar
el segundo array.
}
if (a[i] >
a[i+1]){
temp = a[i];
a[i] = a[i+1];
Insercin
for (i=1; i
temp = lista[ i ];
j=i-1;
while ( (lista[ j ] > temp) && (j >= 0) )
{
lista[ j+1] = lista[ j ] ;
j-- ;
} //Fin while
lista [ j+1] = temp;
}//Fin for
a[i+1] = temp;
}
//Implementacion de busqueda
binaria
printf ("\nIntroduce un numero a
buscar: ");
scanf ("%d", &busca);
bajo = 0;
alto = TAM-1;
central = (bajo+alto)/2;
while (bajo < alto && busca !=
a[central]){
Bsqueda Binaria
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define TAM 15
if(busca > a[central])

bajo =
central+1;
else
alto = central1;
void main(){
central=(bajo+alto)/2;
}
int a[TAM], busca, temp, bajo, alto,

central;
printf("Llenando el arreglo con
nmeros aleatorios\n");
randomize(); //Inicializa el
generador de aleatorios
for (int i=0; i< TAM; i++)
a[i]=random(100);
//Implementacion de Ordenamiento
por burbuja de menor a mayor
printf ("Ordenando arreglo...\n");
for (int j=1; j <= TAM; j++)
for (i=0; i< TAM-1; i++)
if (busca == a[central])
printf("\n%d encontrado
en posicion %d", busca, central);
else
printf("\n%d no existe",
busca);
printf ("\n\nEl arreglo ordenado
era\n\n");
printf ("%d ", a[i]);
getch();
}

C Un Putero y Mas

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

C Un Putero y Mas

Hochgeladen von

Copyright:

Verfügbare Formate

CONTENIDO TEMARIO (PROPUESTO)

I.- conceptos bsicos

En la figura 1 se indica la secuencia de pasos que realizar al compilador de C para

azul, amarillo, rojo, verde};

Double x; double c=2.27; double d=3E5;

1.- struct objeto{

int aux1, a, res;

//Pgina 101, Ejercicio 65, Problema

TIPOS DE DATOS ESTRUCTURADOS

Una cadena de caracteres es un arreglo unidimensional, en el cual todos sus elementos

char s1[11] = "Hola ";

ptr = strtok( s1, s2 ); // Primera

printf("\n Apellido paterno: %s

printf("\n Grupo Sanguineo: %s

La funcin atoi retorna el valor convertido.

El valor de retorno ser no nulo si c es un carcter grfico.

char cadena[] = "aAbBcCdD31&75$/";

printf( "acos( %f ) = %f\n", x, acos(x) );

printf( "ceil( %f ) = %f\n", x, ceil(x) );

printf( "fabs( %f ) = %f\n", x, fabs(x) );

printf( "ldexp( %f, %d ) = %f\n", x, exp, ldexp(x,exp) );

printf( "pow( %f, %f ) = %f\n", x, y, pow(x,y) );

printf( "atan( %f ) = %f\n", x, atan(x) );

printf( "atan2( %f, %f ) = %f\n", y, x, atan2(y,x) );

printf( "cos( %f ) = %f\n", x, cos(x) );

Calcula el coseno hiperblico de x. Puede producirse un error de recorrido si la

resultado = frexp( valor, exp );

printf( "log( %f ) = %f\n", x, log(x) );

printf( "log10( %f ) = %f\n", x, log10(x) );

resultado = modf( valor, iptr );

printf( "sin( %f ) = %f\n", x, sin(x) );

printf( "tanh( %f ) = %f\n", x, tanh(x) );

//programa que lee una frase y da el numero de palabras que tiene

"de texto.</B> \n");

/* Cerrar el archivo antes de terminar el programa

printf("Se ha creado el archivo: prueba.htm \n");

Abre un fichero de texto para lectura

La funcin feof retorna un valor distinto a cero si y slo si el indicador de final de

apropiadamente. Si el fichero no soporta peticiones de posicin, o si el stream fue

La funcin fwrite retorna el nmero de caracteres escritos correctamente, el cual puede

#include <ctype.h>//para convertir a minusculas la cadena.

gotoxy(1,(a*4)+4);//aplicamos en y: 6*(b+1), para que se vayan separando

for(i=0;i<y;i++){ //desde 0 hasta el numero de caracteres de y

Cuando se cumple la condicin entre parntesis se ejecuta el bloque inmediatamente

Como siempre, la condicin es falsa si es igual a cero. Si es distinta de cero ser

En el if si no se cumpla la condicin no se ejecutaba el bloque siguiente y el programa

Al ejecutar el programa si introducimos un 8 se ejecuta el bloque siguiente al if y se

Si escribimos cualquier otro nmero se ejecuta el bloque siguiente al else mostrndose

cdigo a ejecutar si la variable tiene el

Ahora con switch:

Como vemos el cdigo con switch es ms cmodo de leer.

printf( "Es un 2\n" );

Si al ejecutar el programa escribimos un dos tenemos el mensaje Es un dos. Todo

conjunto de intrucciones a ejecutar en el bucle

Vamos a verlo con el ejemplo anterior:

Este programa slo escribir en pantalla

una sola vez.

i<10 ; i++, j=j+5 )

Como vemos en el ejemplo tenemos ms de una variable en la seccin de inicializacin

While quiere decir mientras. Aqu se ejecuta el bloque de intrucciones mientras se

Formas de clasificar los mtodos de ordenamiento

comparacin pues se encontr que el elemento ya est ordenado y se coloca en su

paso 2: [Inicializa la pos. del menor] menor <- i

gotoxy(1,(a4)+4);//aplicamos en y: 6(b+1), para que se vayan separando