Índice

Contenido
Atajos: ...................................................................................................................................................................................... 2
1 Introducción .................................................................................................................................................. 4
2 Conceptos básicos de algoritmia .................................................................................................................. 4
3 Estructura de control..................................................................................................................................... 5
4 Funciones ..................................................................................................................................................... 6
5 Arreglos ........................................................................................................................................................ 8
6 Punteros ..................................................................................................................................................... 11
Funciones con Punteros ................................................................................................................................ 13
7 Tipos abstractos de datos ........................................................................................................................... 16
Funciones con Estructuras ............................................................................................................................ 19
Funciones con Vectores ................................................................................................................................ 23
Funciones con Matrices .......................................................................................................................................................... 27
Funciones con Vector String ................................................................................................................................................... 29
String con Matriz (guarda cadenas de string, ej: nombres) ............................................................................ 34

Atajos CodeBlocks
Ctrol+D Duplicar fila
F2 y Shift-F2 ocultar los mensajes y el panel del administrador respectivamente
Guías entre corchetes Settings --> editor --> ident options --> tildá: show idention guides

DEFINICIÓN
INT DOUBLE CHAR STRING CHAR Vector y matriz
int a; double a; char a='a'; char a [100]; int num[5];
int a=1; double a=1,0; char a [N]; int num[5][5];
char a [10]="hola"; int num[F][C];
char a [N]="hola"; Int num[2][3];
char a []={'a'}; double a[2][3]={1,2,3,
char a [N]={'a','b','c'}; 4,5,6};
char a [3][2];

1
 Atajos:
LIBRERIAS #include
math.h <stdio.h> <stdlib.h> <conio.h> <time.h> <string.h>
sqrt (raíz) Printf Srand getche time Strcmp(comp)
pow (num, exp) Scanf Malloc get
Free
sizeof

ESPECIFICADORES DE FORMATO
ENTERO REAL CARACTER
%d int %lf double %c char (-128 a 127)
%u unsigned int %.2lf double (2dec) %c unsigned char (0 a 255)
%o octal %g double (hasta 0) %s string
%x hexadecimal
%p hexa 16bits

MULTIPLO DE 4, FUNCION VALIDAR N° N° DIVISIBLE

INTERCAMBIO SABER SI ES REAL MCD
8, 16: BOOLEANA ENTERO POS POR OTRO
Ej: a,b,aux if(real!=entero) num%4==0 0=Falso If (num>0) num%div==0 Ej: a,b,resto
aux=a num%8==0 N°!=0=Verd a=b
a=b num%16==0 b=resto
b=aux Resto=a%b

DE MAY A MIN DE MIN A MAY RANGO VOCALES

let-('A'-'a') let-('a'-'A') (let=='a' || let=='e' || let=='i' || let=='o' || let=='u' ||
let=='A' || let=='E' || let=='I' || let=='O' || let=='U')

TIEMPO LONGITUD EN MTS CIFRAS

Seg= %60 mm=num*1000 u=num%10 = (Asignación)
Min= /60 %60 Cm=num*100 d=num/10%10 == (Comparación)
Hs= /3600 %24 Km=num/1000 c=num/100%10 suma+=num (suma = suma + num)
Días=/86400 %10 um=num/1000%10
dm=num/10000%10

Ingresar texto hasta Ingresar num hasta

PROMEDIO N° ALEATORIOS SEMILLA
ingresar ‘.’ ingresar 0
While(texto!=’.’) While(num!=0) suma/cant min+rand()%(max-min+1)=min/max Srand(time(NULL))

PAR IMPAR PRIMO OBTEN N° REAL

num%2==0 num%2!=0 If(num%div==0)-> resto 0 (*1.0) // (/1.0)
num%==1 If (cont==2)-> 2 divisor (double)

OPERADORES DE OPERADORES OPERADORES OPERADORES DE

COMPARACIÓN LOGICOS ARITMETICOS ASIGNACIÓN
< Menor que && Y(AND) ++ Incremento = ahora es este
> Mayor que || O(OR) -- Decremento += sumar acumular
<= Menor igual ! NO(NOT) % Módulo (Resto) -=
>= Mayor igual + Suma *=
== Igual a - Resta /=

2
!= Distinto a * Multiplicación %=
/ División EJ: suma+=num

3
1 Introducción
Definición de algoritmo. Partes principales de un algoritmo. Arquitectura de Von Neumann,
descripción de componentes básicos. Representación de los datos en la memoria:
Introducción al sistema de numeración binario. Estructura general de una computadora.

EXPRESION
Cualquier cosa que genera un valor (un numero)
ej: 12, 12+3, a cuando a=12, a+1 etc.
Existen 3 formas: constantes, variables y
operaciones entre expresiones.
La 4 forma seria: una función.

2 Conceptos básicos de algoritmia

Introducción al lenguaje C. Relación con la arquitectura de Von Neumann. Instrucciones de entrada
y salida estándar. Primer programa: “Hola Mundo”. Variables y constantes: conceptos. Tipos de
variable predefinidos. Operadores matemáticos. Indentación de programas.

VARIABLE CONSTANTE
Espacio de valor reservado para almacenar un Defino que N vale 100, siempre va arriba del main
valor según un tipo de dato Ej: Ej:
int a=1 #DEFINE N 100
int suma=a+b #DEFINE PI 3.14
double a=1.5
char= ‘a’

BUCLES ARREGLOS
En los bucles anidados siempre se mueve Funcion modificando Funcion sin modificar el
primero el de adentro y una vez que termina arreglo original: Se arreglo original: Se
avanza el de afuera(primero j después i) utiliza el mismo arreglo agrega un arreglo aux
Ej: tablas de multiplicar Se copia en un for todos
int main() los elementos del
{ arreglo original al
int i,j; auxiliar y se trabaja
for(i=1; i<=9; i++) con el auxiliar.
{
printf("Tabla del %d\n",i);
for(j=1; j<=10; j++)
{
printf("%d x %d =%d\n",i,j,i*j);
}
printf("\n");
}
return 0;
}

4
 3 Estructura de control
Lógica proposicional: definición, concepto, operadores, propiedades. Tablas de verdad.
Estructuras de decisión: i f - else. Estructuras de decisión múltiple: switch. Estructuras de
repetición: do-while , while , for . Anidamiento.

ESTRUCTURA DE DECISIÓN
IF (SI) IF ELSE (SINO) ELSE IF (ES ESTE) SWITCH (MENU)
Sentencia si es V o F Sentencia si es V o F Sentencia si es V o F CASE
(Verdadero o Falso) (Verdadero o Falso) (Verdadero o Falso) BREACK
Condición simple: if(condición) if(condición) switch(variable)
if(condición) { { { case valor1:
{ (Acciones a realizar (Acciones a realizar (acciones a realizar)
(Acciones a realizar si la condición es V) si esta condicion es V) Break;
si la condición es V) } } case valor2:
} else else if (condición) (acciones a realizar)
Condición múltiple: { { Break;
if(cond &&/|| cond) (Acciones a realizar (Acciones a realizar default:
{ si la condición es F) si esta condicion es V) (acciones por defecto)
(Acciones a realizar } }
si la condición es V)
}

ESTRUCTURA DE REPETICIÓN (BUCLES)

WHILE (MIENTRAS QUE) FOR (MIENTRAS QUE) DO-WHILE (MIENTRAS QUE)
VALIDACION
(inicialización) for(inicializa;condición;increment) do
while(condición) EJ: for (i=0; i<100; i++) {
{ { (Mientras que la condición sea
(Acciones a realizar mientras la (Acciones a realizar mientras la v que se mantenga en el bucle,
condición es Verdadera) condición es Verdadera) hasta que la condición sea F)
(incremento) } }while (condición);
} “Siempre se ejecutara una vez”
int main() int main()
{ {
int cont=0,nota,suma=0; int cont,nota,suma=0;
double prom; double prom;
while(cont<5) for(cont=0;cont<5;cont++)
{ {
printf("Ingres nota: "); printf("Ingrese nota: ");
scanf("%d",&nota); scanf("%d",&nota);
if(nota>=1 && nota<=10) if(nota>=1 && nota<=10)
{ {
suma+=nota; suma+=nota;
cont++; }
} }
} prom=(double)suma/cont;
prom=(double)suma/cont; printf("Prom: %.2lf",prom);
printf("Prom: %.2lf",prom); return 0;
return 0; }
}
A tener en cuenta:
Iniciar Contador: cont=1 (variable cuenta de a 1 en 1) // Condicion contador: (cont<=5) (Cuenta hasta 5 veces, después de
la 6º termina)// Acumulador: suma=0 (variable que suma)// Sumar acumulado: suma+=nota (Suma=suma+nota)//
Incremento al contador: cont++

5
 4 Funciones
Funciones definidas por el usuario. Separación del problema en partes. Parámetros y valores de
retorno. Procedimientos. Funciones booleanas. Pasaje de parámetros por valor. Bibliotecas de
funciones. Números aleatorios y seudo aleatorios.
FUNCIONES
(Retorna cuando necesito hacer algo con esa expresión) Retorna
(En void el valor termina en la función) Imprime
RECIBE PARAMETROS NO RECIBE PARAMETROS RECIBE PARAMETROS NO RECIBE PARAMETROS
RETORNA VALOR RETORNA VALOR (MENU) NO RETORNA VALOR NO RETORNA VALOR
Tipo de retorno: Tipo de retorno: Tipo de retorno: Tipo de retorno:
Ej: Int,double,char Ej: Int,double,char Ej: Void (sin retorno) Ej: Void (sin retorno)
Identificador/Nombre: Identificador/Nombre: Identificador/Nombre: Identificador/Nombre:
Ej: suma Ej: suma Ej: suma Ej: suma
Parámetros: (valores) Sin Parámetros: Se Parámetros: (valores) Sin Parámetros: Se
Ej: (int, double, char) ingresa por teclado Ej: (int, double, ingresa por teclado
dentro de la función char) dentro de la función
PROTOTIPO PROTOTIPO PROTOTIPO PROTOTIPO
int suma(int, int); int suma(void); void suma(int, int); void suma ();
LLAMAR EN MAIN DECLARO Y LLAMO EN MAIN LLAMAR EN MAIN DECLARO Y LLAMO EN MAIN
int main() int main() int main () int main()
{ { { {
int a,b; printf("R:%d",suma()); int a,b; suma();
printf("Ingre n1: "); return 0; printf("Ingr n1: "); return 0;
scanf("%d",&a); } scanf("%d",&a); }
printf("Ingre n2: "); printf("Ingr n2: ");
scanf("%d",&b); scanf("%d",&b);
printf("R:%d",suma(a,b)); suma(a,b);
return 0; return 0;
} }
EJ FUNCION EJ FUNCION EJ FUNCION EJ FUNCION
int suma(int a, int b) int suma() void suma(int a,int b) void suma ()
{ { { {
int s; int a,b,s; int s; int a,b,s;
s=a+b; printf("ingres n1\n"); s=a+b; printf("ingresa n1\n");
return s; scanf("%d",&a); printf("R: %d",s); scanf("%d",&a);
} printf("ingres n2\n"); } printf("ingresa n2\n");
int suma(int a, int b) scanf("%d",&b); void suma(int a,int b) scanf("%d",&b);
{ s=a+b; { s=a+b;
return a+b; return s; printf("R: %d",a+b); printf("Result: %d",s);
} } } }
FUNCION CON ARREGLO FUNCION CON ARREGLO FUNCION CON ARREGLO FUNCION CON ARREGLO

*R=Resultado *s=suma
FUNCION BOOLEANA FUNCIONES CON NUMEROS ALEATORIOS
1=VERDADERO Ingresando por teclado
0=FALSO Formula: min+rand()%(max-min+1)=min/max
Sin ingresar por teclado
Ej 1,2: 0+rand()%6 = 6N°(0 al 5) // 1+rand()%6 = 6N°(1 al 6)
Ej 3,4: 13+rand()%29 = 29N°(13 al 41) // 10+rand()%7 = 7N°(10 al 16)

6
 PROTOTIPO PROTOTIPO
char es_par(unsigned int); unsigned int azar(unsigned int, unsigned int);
LLAMAR A MAIN LLAMAR A MAIN
int main() ASIGANANDO POR TECLADO
{ int main() /**validando cada numero*/
int a; {
printf("Ingrese num: "); int i,min,max,cant;
scanf("%d",&a); do
if(es_par(a)) {
{ printf("Ingrese minimo: ");
printf("es par"); scanf("%d",&min);
} }
else while(min<=0);
{ do
printf("es impar"); {
} printf ("Ingrese maximo: ");
} scanf("%d",&max);
}
while(min>max);
do
{
printf ("Ingrese cantidad de valores: ");
scanf("%d",&cant);
}
while (cant<0);
srand(time(NULL));
for(i=0; i<cant; i++)
{
printf ("Nro: %d\n", azar(min,max));
}
return 0;
}
FUNCION CON PARAMET Y RET FUNCION CON PARAMETRO Y RETORNO
char es_par(unsigned int n) unsigned int azar(unsigned int min,unsigned int max)
{ {
if(n%2==0) return min+rand()%(max-min+1);
{ }
return 1;
}
else
{
return 0;
}
}

Pasaje por valor Por referencia

Le pasa a la función, una variable Le pasa a la función la dirección donde se encuentra
ubicado el primer elemento del arreglo.

7
 5 Arreglos
Arreglos unidimensionales o vectores. Cadenas de caracteres. Tratamiento y propiedades.
Arreglos en funciones. Algoritmos de ordenamiento, apareo, inserción y eliminación. Arreglos
bidimensionales (matrices). Arreglos multidimensionales.

ARREGLOS o ARRAY (secuencia de variables)

UNIDIMENCIONALES (VECTOR)
i=subíndice fila (marca la posici)
(siempre inicia en la posición 0)
El arreglo solo puede mostrarse
completo recorriendo con un FOR
for=para recorrer los arreglos
(inicio ar, final ar, recorre ar)
Ej: for(i=0,i<N;i++)
DECLARAR/INICIALIZAR VECTOR
Tipo nombre [tamaño/indice]
Ej: int num[N]
int num[5]; (pos del 0 al 4)
double a[]={1,2,3,4,5};
char
letra[]={'a','e','i','o','u'};
*si o si debe tener un tamaño o
cantidad de valores
LLAMAR EN MAIN VECTOR
a[i]
Llamo al índice y este me dirá
que valor hay en esa posición.
Muestro al arreglo con un FOR
EJ MAIN ASIGNANDO UN N°
#define N 50
int main ()
{ (PROTOTIPO DE LA FUNCION)
int num [N],i;
for(i=0;i<N;i++)
{ int m[F][C]
num[i]=1;
printf("%d-",num[i]);
} }
return 0;
}
EJ MAIN INGRESANDO POR TECLADO
#define N 5
Int main()
{
int num[N],i;
for(i=0;i<N;i++)
{
printf ("Ingrese un num: ");
scanf ("%d",&num[i]);
}
for(i=0;i<N;i++)
{
printf("%d-",num[i]);
BIDIMENSIONALES(MATRIZ o TABLA)
i=subíndice fila
j=subíndice columna
ultimo elemento matriz:
Finaliza: fila n-1//columna n-1
for=para recorrer los arreglos
Ej: for(i=0,i<f;i++)->fila
for(j=0,j<c;j++)->columna
DECLARAR/INICIALIZAR MATRIZ
Tipo nombre [nfilas][ncolumnas]
Ej: int num[F][C];
Int num[2][3];
double a[2][3]={1,2,3,
4,5,6};
int
a[2][3]={{1,2,3,},{1,2,3,}};
char letra[3][2];
LLAMAR EN MAIN LA MATRIZ
Ej: int a[2][3]={1,2,3,4,5,6};
0 1 2
Filas=2 0 1 2 3
Columnas=3 1 4 5 6
Llamo n°2: a[0][1]=2 (F0,C1)
El ultimo[]determina la
cantidad de num por F
EJ MAIN ASIGNANDO UN N°
#define F 5
#define C 3
int main()
{ cargar_texto(texto,100);
(FUNCION)
Return 0;
EJ MAIN INGRESANDO POR TECLADO
STRING
-Finaliza con '\0'(cuando lo
ingreso por teclado, es necesario
ponerlo, sino no).
-Es necesario crear una función
“cargar” para poder ingresar
string por teclado.
DECLARAR/INICIAR ARREGLO STRING
Tipo nombre [tamaño]
char texto [N];
char texto [100];
char texto [N]="abc";
char texto [N]={'a','b','c'};
LLAMAR EN MAIN ARREGLO STRING
Cargar_texto(texto,100)
printf ("%s", texto);
EJ MAIN ASIGNANDO UN STRING
int main()
{
char texto[100];
printf("Ingrese el texto: ");
printf("Text ingres: %s",texto);
return 0;
}
EJ MAIN INGRESANDO POR TECLADO

8
 }
return 0;

EJ MAIN INGRESANDO EL TAMAÑO DEL EJ MAIN INGRESANDO EL TAMAÑO EJ MAIN INGRESANDO EL TAMAÑO DEL
ARREGLO (CUANTOS VALORES QUIERE DEL ARREGLO (CUANTOS VALORES ARREGLO (CUANTOS VALORES QUIERE
CARGAR)POR TECLADO QUIERE CARGAR)POR TECLADO CARGAR)POR TECLADO
#define N 100
int main()
{
int num[N],i,tam;
do
{
printf("Ingres tamaño: ");
scanf("%d",&tam);
if(tam<1 || tam>100)
{
printf("incorrecto\n");
}
}
while(tam<1 || tam>100);
for(i=0; i<tam; i++)
{
printf("Ingrese un num: ");
scanf("%d",&num[i]);
}
printf("Datos cargados\n");
for(i=0; i<tam; i++)
{
printf("%d-",num[i]);
}
return 0;
}

EJ MAIN HASTA INGRESAR 0 EJ MAIN HASTA INGRESAR 0 EJ MAIN HASTA INGRESAR 0

#define N 100
Int main()
{
int num[N],i=0;
do
{
printf("Ingr un n, (fiN 0):");
scanf("%d",&num[i]);
i++;
}while(i<N-1 && num[i-1]!=0);
if(i==N-1)
{
num[i]=0;
}
printf("Datos cargados");
for(i=0;num[i]!=0;i++)
{
printf("%d-",num[i]);
}
return 0;
}

9
 EJ LLAMAR FUNCION EN MAIN EJ LLAMAR FUNCION EN MAIN EJ LLAMAR FUNCION EN MAIN
cargar(a) #define F 4 int main()
llenar_azar(a) #define C 3 {
int main() char texto[100];
{ printf("Ingrese el texto: ");
int mat[F][C]; cargar_texto(texto,100);
cargar(mat); printf("Text ingres: %s",texto);
mostrar(mat); return 0;
return 0; }
}
PROTOTIPO VECTOR PROTOTIPO MATRIZ PROTOTIPO STRING
No retorna (arreglo,tamaño) No retorna (matriz) No retorna (string, tamaño)
Void cargar (int [], int) void cargar(int [F][C]); void cargar_texto (char [],int);
No retorna (arreglo)
void llenar_azar(int []);
EN FUNCION (no se puede retornar EN FUNCION EN FUNCION
un arreglo, solo un valor)
void llenar_azar(int a[]); void cargar (int m[F][C]) void cargar_texto (char t[],int N)
{ {
int i,j; char l;
for(i=0;i<F;i++) int i=0;
{ do
for(j=0;j<C;j++) {
{ l=getche();
m[i][j]=rand()%10+1; t[i]=l;
} i++;
} }
} while(l!='\r' && i<N-1);
if(l=='\r')
{
t[i-1]='\0';
}
else
{
t[i]='\0';
}
}
/**Se puede dejar vacío y recibir /**hay que agregar el tamaño en
como parametro un arreglo de este caso F y C*/
cualquier tamaño*/

10
6 Punteros
Definición, operadores, propiedades. Aritmética de punteros. Relación con arreglos. Paso de
parámetros por referencia. Puntero a puntero. Memoria dinámica.

PUNTEROS (es como un arreglo)

Puntero: tipo de dato que sirve para guardar * Declarar puntero ej: *a
direcciones de memoria. * Ver el contenido del puntero ej: *a
Desreferencia: decime donde esta y que hay ahí & Ver la dirección del puntero ej: &a
Por referencia: con puntero %p Imprime un puntero
PASAJE POR VALOR PASAJE POR REFERENCIA
En la función, le paso el valor por la En la función, le paso la dirección por
variable y trabajo con una variable distinta. la variable ósea que trabajo y modifico
la variable original.
DECLARAR Y LLAMAR FUNCION EJ EJERCICIO FUNCION INTERCAMBIAR VARIABLE
PUNTERO EN MAIN REDONDEAR
void f(int *); void redondear(double *pn) void intercambiar(int *,int *);
int main () { int main ()
{ int entero; {
int a=5; double dec; int n=5,x=20;
f(&a); entero=*pn; intercambiar(&n,&x);
dec=*pn-entero; printf("n=%d\n",n);
printf("a=%d\n",a); if(dec>0) printf("x=%d\n",x);
} { }
if(dec>=0.5) void intercambiar(int *a,int *b)
EN FUNCION { {
void f(int *p) *pn=entero+1; int aux;
{ } aux=*a; //a=n
(*p)++; else *a=*b; //b=x
} { *b=aux;
*pn=entero; }
}
}
else
{
*pn=entero;
}
}
Sumo un numero en la función con el puntero. Intercambio el valor de las variables con una
función

11
 MEMORIA DINAMICA
Malloc Asigna/Reserva memoria en tiempo de ejecución
Free Libera memoria que asigno de forma dinámica
sizeof Cantidad de memoria que ocupa un tipo de dato
DECLARAR/INICIALIZAR MEMORIA DINAMICA (UNO A UNO) INICIALIZAR MEMORIA DINAMICA (POR BLOQUE)

LLAMAR MEMORIA DINAMICA EN MAIN

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
char *cargar();
int main()
{
char *texto;
printf("Ingrese un texto: ");
texto=cargar();
printf("\nTexto ingresar: %s\n",texto);
free(texto); (liberar memoria)
return 0;
}
EN FUNCION CARGAR
char *cargar()
{
char *s;
int tam=10,i=0;
s=malloc(sizeof(char)*tam);(asignar memoria)
do
{
s[i]=getche();
i++;
if(i==tam)
{
tam+=10;
s=realloc(s,sizeof(char)*tam);(reasignar memoria)
}
}
while (s[i-1]!='\r');
s[i-1]='\0';
s=realloc(s,sizeof(char)*i);(Achicar memoria)
}

12
 Funciones con Punteros
MAIN FUNCION MOSTRAR
int main() void mostrar (int *a)
{ {
int a[]= {1,2,3,3,2,5,7,9,0},*p; int i;
int b[]= {2,4,4,6,7,8,8,10,10,1,0}; for(i=0; a[i]!=0; i++)
p=repetidos(a,b); {
mostrar(p); printf("%d", a[i]);
free(p); }
return 0; }
}
CARGAR FUNCION REPETIDOS
char *cargar() int *repetidos(int *pa,int *pb)
{ {
char *s; int i,*pc,tam,j=0;
int tam=10,i=0; for(i=0; pa[i]!=0; i++);
s=malloc(sizeof(char)*tam tam=i+1;
do pc=malloc(sizeof(int)*tam);
{ pc[0]=0;
s[i]=getche(); for(i=0; pa[i]!=0; i++)
i++; {
if(i==tam) if(esta(pb,pa[i])&& !esta(pc,pa[i]))
{ {
tam+=10; pc[j]=pa[i];
s=realloc(s,sizeof(char)*tam j++;
} pc[j]=0;
} }
while (s[i-1]!='\r'); }
s[i-1]='\0'; pc=realloc(pc,sizeof(int)*(j+1));
s=realloc(s,sizeof(char)*i return pc;
} }
Busca los numero que se repiten en dos arreglos
CREAR ARREGLO AZAR ESTA
int *crear_arreglo(int tam,int min,int max) int esta(int *c, int n)
{ {
unsigned int i; int i;
int * p = (int *) for(i=0; c[i]!=0; i++)
malloc(sizeof(int)*tam); {
for(i=0;i<tam-1;i++) if(c[i]==n)
{ {
p[i] = rand()%(max-min+1)+min; return 1;
} }
p[i]=0; }
return p; return 0;
} }
INSERTAR AL INICIO CREAR ARREGLO
int *insertar_inicio (int num,int*a) int *crear_arreglo()
{ {
int i,tam; int num,*p,tam=10,i=0;
for(i=0;a[i]!=0;i++); p=malloc(sizeof(int)*tam);
tam=i+2; do
a=realloc(a,sizeof(int)*tam); {
for(i=tam-2;i>=0;i--) printf("Ingrese entero: ");
{ scanf("%d",&num);
a[i+1]=a[i]; p[i]=num;
} i++;
a[0]=num; if(i==tam)
return a; {
} tam+=10;
p=realloc(p,sizeof(int)*tam);
}
}while(num!=0);
p=realloc(p,sizeof(int)*i);
return p;
}

13
 CONCATENAR ELIMINAR REPETIDOS
char * concatenar(char * a, char * b) void eliminar_repetidos(int * p)
{ {
unsigned int i, j, t; unsigned int i, j=0, k;
char * s; char aparece;
for(i=0;a[i]!='\0';i++); int temp;
for(j=0;b[j]!='\0';j++); for(i=0;p[i]!=0;i++)
t = i+j; {
s = malloc(sizeof(char)* (t+1)); aparece = 0;
for(k=0;k<i && !aparece;k++)
for(i=0;a[i]!='\0';i++) {
{ if(p[i] == p[k])
s[i] = a[i]; {
} aparece=1;
for(j=0;b[j]!='\0';j++) }
{ }
s[i] = b[j]; if(!aparece)
i++; {
} p[j] = p[i];
s[i]='\0'; j++;
}
return s; }
} p[j]=0;
p = realloc(p, sizeof(int)*(j+1));
}
/** Copia el contenido de un arreglo y a // busco si el valor p[i] aparece antes en el
continuación el otro */ arreglo
/** Calcula cuántos char se necesitarán para // si no aparece antes, lo traslado a la
concatenar ambos arreglos */ posición j

INSERTAR AL INICIO CREAR ARREGLO

int *insertar_inicio (int num,int*a) int *crear_arreglo()
{ {
int i,tam; int num,*p,tam=10,i=0;
for(i=0;a[i]!=0;i++); p=malloc(sizeof(int)*tam);
tam=i+2; do
a=realloc(a,sizeof(int)*tam); {
for(i=tam-2;i>=0;i--) printf("Ingrese entero: ");
{ scanf("%d",&num);
a[i+1]=a[i]; p[i]=num;
} i++;
a[0]=num; if(i==tam)
return a; {
} tam+=10;
p=realloc(p,sizeof(int)*tam);
}
}while(num!=0);
p=realloc(p,sizeof(int)*i);
return p;
}

INTERCALAR ELIMINAR NUMERO

int *intercalar (int *pa,int *pb) int eliminar (int *a)
{ {
int i,*pc,tam,j; int n,i;
for(i=0;pa[i]!=0;i++); if(a[0]==0)
for(j=0;pb[j]!=0;j++); {
tam=i+j+1; return 0;
pc=malloc(sizeof(int)*tam); }
i=0; else
j=0; {
while(pa[i]!=0 && pb[i]!=0) n=a[0];
{ for(i=0; a[i]!=0; i++)
pc[j]=pa[i]; {
j++; a[i]=a[i+1];

14
 pc[j]=pb[i]; }
j++; a=realloc(a,sizeof(int)*i);
i++; }
} return n;
while (pa[i]!=0) }
{
pc[j]=pa[i];
j++;
i++;
}
while (pb[i]!=0)
{
pc[j]=pb[i];
j++;
i++;
}
pc[j]=0;
return pc;
}
Depende el numero que ingrese en [i+?] de
función eliminar a[i]=a[i+1]; eliminare tantos
lugares.
Ej:[i+1] elimino el 1er lugar
Ej:[i+2] elimino los 2 primeros lugares

3 LETRAS SEGUIDAS BOOLEANA REPETIDOS BOOLEANA

unsigned char sonseguidas(char * s) int repetidos (char *p)
{ {
int i; int i,cont,j;
unsigned char escontinua = 0; char aux;

for(i=0; s[i]!='\0'; i++) for(i=0;p[i]!='\0';i++)

{ {
if(s[i]+1 == s[i+1] && s[i]+2 == s[i+2]) cont=0;
{ aux=p[i];
return 1; for(j=0;p[j]!='\0';j++)
} {
} if(aux==p[j])
return escontinua; {
} cont++;
}
if(cont>=5)
{
return 1;
}
}
}
return 0;
}
Funcion booleana que indica si 3 letras del
abecedario son consecutivas

15
7 Tipos abstractos de datos
Definición, operadores, propiedades. Estructuras y renombramiento de tipos. Arreglos de
estructuras. Estructuras anidadas. Punteros a estructuras. Operadores punto (.) y flecha (->),
diferencias.
ESTRUCTURAS
typedef struct La estructura es un tipo de dato creado, se cera
{ arriba fuera del mail, agrupa muchas variables de
campos(tipo nombre) muchos tipos.
campos(tipo nombre) Para ingresarlo en main el “.” me marca el campo
} Ej: .dia, .nombre, .dni.
(nombre de la estructura/tipo de dato); Los nombres llevan t_ (tipo) Ej: t_empleado
EJEMPLO ESTRUCTURA (CAMPOS)
Ej: variable Ej: arreglo (vector)
t_persona a; t_persona a[3];
nombre|dni|sueldo nombre|dni|sueldo
nombre|dni|sueldo
nombre|dni|sueldo

EJEMPLO ESTRUCTURA EJEMPLO ESTRUCTURA ANIDADA

typedef struct typedef struct
{ {
unsigned int edad; int dia,mes,anio;
char nombre[100]; }
} t_fecha;
t_persona; typedef struct
{
Char nombre[30];
int dni;
double sueldo;
t_fecha fnac; (t_fecha es el tipo de dato)
}
t_persona;
EJEMPLO MAIN
int main()
{
t_empleado a={"Tomas",32456778,54000.0};
printf("Nombre: %s DNI: %d Sueldo: %.2lf",a.nombre,a.dni,a.sueldo);
return 0;
}
EJEMPLO MAIN (INGRESO POR TECLADO)
void carg_text(char [],int);
int main()
{
t_empleado a;
printf("Ingrese el nombre: ");
carg_text(a.nombre,30);
printf("\nIngrese el dni: ");
scanf("%d",&a.dni);
printf("Ingrese el sueldo: ");
scanf("%lf",&a.sueldo);
printf("Nombre: %s DNI: %d Sueldo: %.2lf",a.nombre,a.dni,a.sueldo);
return 0;
}
Se hace un ingreso por cada campo. Lo mismo sucede cuando se imprime por pantalla

16
 COMPARAR CAMPOS ESTRUCTURA IF (Solo se pueden comparar campos)
void carg_text(char [],int);
int main()
{
t_empleado a,a2;
printf("Ingrese el nombre: ");
carg_text(a.nombre,30);
printf("\nIngrese el dni: ");
scanf("%d",&a.dni);
printf("Ingrese el sueldo: ");
scanf("%lf",&a.sueldo);
printf("Nombre: %s DNI: %d Sueldo: %.2lf",a.nombre,a.dni,a.sueldo);
a2=a;
printf("\nDatos Empelado 2:\n");
printf("Nombre: %s DNI: %d Sueldo: %.2lf",a2.nombre,a2.dni,a2.sueldo);
if(a.dni==a2.dni)
{
printf("\nIguales");
}
else
{
printf("\nDistintos");
}
return 0;
}
EN FUNCION CON PUNTERO
ESTRUCTURA Y PROTOTIPO EN MAIN
#include <stdio.h> void carg_text(char [],int);
#include <stdlib.h> void ingresar (t_empleado*);
#include <conio.h> int main()
typedef struct {
{ t_empleado a;
char nombre[30]; ingresar(&a);
int dni; printf("Nombre: %s DNI: %d Sueldo: %.2lf",a.nombre,a.dni,a.sueldo);
double sueldo; return 0;
}t_empleado; }
INGRESAR EMPLEADO POR REFERENCIA INGRESAR EMPLEADO POR DESREFERENCIA/VALOR
void ingresar (t_empleado* p) void ingresar (t_empleado* p)
{ {
printf("Ingrese el nombre: "); printf("Ingrese el nombre: ");
carg_text(p->nombre,30); carg_text((*p).nombre,30);
printf("\nIngrese el dni: "); printf("\nIngrese el dni: ");
scanf("%d",&p->dni); scanf("%d",&(*p).dni);
printf("Ingrese el sueldo: "); printf("Ingrese el sueldo: ");
scanf("%lf",&p->sueldo); scanf("%lf",&(*p).sueldo);
} }
Ingresa el nombre, dni y sueldo de la persona. Necesita la función aux cargar_texto
EN FUNCION CON ARREGLOS
ESTRUCTURA Y PROTOTIPO EN MAIN
#include <stdio.h> void carg_text(char [],int);
#include <stdlib.h> void ingresar (t_empleado[]);
#include <conio.h> void mostrar (t_empleado[]);
typedef struct int main()
{ }int main()
int dia,mes,anio; {
} t_fecha; t_empleado a[5];
typedef struct ingresar(a);
{ mostrar(a);
char nombre[30]; return 0;
int dni; }
double sueldo;
t_fecha fnac;
} t_empleado;

17
18
 Funciones con Estructuras
Estructura: Main:
#include <stdio.h> void ordenar(t_persona *);
#include <stdlib.h> void imprimir(t_persona *);
#include <string.h> t_persona * crear_arreglo(void);
#include <conio.h> t_persona ingresar(void);
void ingresar_texto(char [], unsigned int);
typedef struct int main()
{ {
unsigned int edad; t_persona * personas;
char nombre[100]; personas = crear_arreglo();
} printf("Sin ordenar: \n\n");
t_persona; imprimir(personas);
ordenar(personas);
printf("\n\nOrdenado: \n\n");
imprimir(personas);
return 0;
}
ORDENAR PERSONA puntero STRCMPI CREAR ARREGLO puntero
void ordenar(t_persona * a) t_persona * crear_arreglo(void)
{ {
unsigned int i,j; unsigned int i=0;
t_persona aux; t_persona * a = malloc(sizeof(t_persona));
for(i=0;a[i].nombre[0]!='\0';i++) do
{ {
for(j=i+1;a[j].nombre[0]!='\0';j++) a[i]=ingresar();
{ i++;
a = realloc(a,sizeof(t_persona)*(i+1));
if(strcmpi(a[i].nombre,a[j].nombre)==1) }
{ while(a[i-1].nombre[0]!='\0');
aux = a[i]; a = realloc(a,sizeof(t_persona)*(i));
a[i] = a[j]; return a;
a[j] = aux; }
}
}
}
}
INGRESAR EMPLEADO POR DESREFERENCIA puntero MOSTRAR/IMPRIMIR PERSONA puntero
void ingresar (t_empleado* p) void imprimir(t_persona * a)
{ {
printf("Ingrese el nombre: "); unsigned int i;
carg_text((*p).nombre,30); for(i=0;a[i].nombre[0]!='\0';i++)
printf("\nIngrese el dni: "); {
scanf("%d",&(*p).dni); printf("%s (%u)\n", a[i].nombre,
printf("Ingrese el sueldo: "); a[i].edad);
scanf("%lf",&(*p).sueldo); }
} }
Ingresa el nombre, dni y sueldo de la persona.
Necesita la función aux cargar_texto
PERSONA MAS JOVEN
t_persona mas_joven(t_persona * p)
{
unsigned int i;
t_persona joven;
joven = p[0]; //inicializa con el primer valor del arreglo (cualquiera).
for(i=0; p[i].fechaNacimiento!=0; i++)
{
if(p[i].fechaNacimiento > joven.fechaNacimiento)
{
joven = p[i];
}
}
return joven;
}

19
 FUNCION ESTRUCTURAS CON ARREGLOS
CARGAR TEXTO arreglo INGRESAR TEXTO arreglo
void carg_text(char t[],int n) void ingresar_texto(char txt[], unsigned int tam)
{ {
char l; unsigned int i=0;
int i=0; do
do {
{ txt[i]=getche();
l=getche(); i++;
t[i]=l; }
i++; while(txt[i-1]!='\r' && i<tam-1);
}while(l!='\r' && i<n-1); if(txt[i-1]=='\r')
if(l=='\r') {
{ txt[i-1]='\0';
t[i-1]='\0'; }
} else
else {
{ txt[i]='\0';
t[i]='\0'; }
} printf("\n");
} }
ORDENAR puntero o arreglo MOSTRAR/IMPRIMIR
void ordenar(t_persona *a) void mostrar(t_persona *a)
{
int tam,i,j; {
t_persona aux; int i;
for(i=0;a[i].fechaNacimiento!=0;i++); for(i=0;a[i].fechaNacimiento!=0;i++)
tam=i;
for(i=0;i<tam-1;i++)
{
{ printf("Fecha:%u Nombre:
for(j=i+1;j<tam;j++) %s\n",a[i].fechaNacimiento,a[i].apellidoNombre);
{
}
if(a[i].fechaNacimiento>a[j].fechaNacimiento) }
{
aux=a[i];
a[i]=a[j];
a[j]=aux;
}
}
}
}
Ordena por fecha de nacimiento.
ESTRUCTURA Y PROTOTIPO arreglo EN MAIN arreglo
#include <stdio.h> void carg_text(char [],int);
#include <stdlib.h> void ingresar (t_empleado[]);
#include <conio.h> void mostrar (t_empleado[]);
typedef struct int main()
{ }int main()
int dia,mes,anio; {
} t_fecha; t_empleado a[5];
typedef struct ingresar(a);
{ mostrar(a);
char nombre[30]; return 0;
int dni; }
double sueldo;
t_fecha fnac;
} t_empleado;

20
 INGRESAR EMPLEADO arreglo CARGAR TEXTO
void ingresar (t_empleado a[]) void carg_text(char t[],int n)
{ {
int i; char l;
for(i=0; i<5; i++) int i=0;
{ do
printf("Ingrese el nombre: "); {
carg_text(a[i].nombre,30); l=getche();
printf("\nIngrese el dni: "); t[i]=l;
scanf("%d",&a[i].dni); i++;
printf("Ingrese el sueldo: "); }while(l!='\r' && i<n-1);
scanf("%lf",&a[i].sueldo); if(l=='\r')
printf("Ingrese el fecha de {
nacimiento: "); t[i-1]='\0';
scanf("%d %d }
%d",&a[i].fnac.dia,&a[i].fnac.mes,&a[i].fnac. else
anio); {
} t[i]='\0';
} }
}
MOSTRAR EMPLEADO arreglo
void mostrar (t_empleado a[])
{
int i;
for(i=0;i<5;i++)
{
printf("Nombre: %s Dni: %d Sueldo: %.2lf\n",a[i].nombre,a[i].dni,a[i].sueldo);
printf("%d/%d/%d\n",a[i].fnac.dia,a[i].fnac.mes,a[i].fnac.anio);
}
}

21
 FUNCION ESTRUCTURAS CON PUNTEROS DINAMICA
ESTRUCTURA Y PROTOTIPO MAIN
#include <stdio.h> int main()
#include <stdlib.h> {
#include <conio.h> t_empleado *p;
typedef struct int cant;
{ do
int dia,mes,anio; {
} t_fecha; printf("Ingrese cantidad de empleados: ");
typedef struct scanf("%d",&cant);
{ if(cant<=0)
char nombre[30]; {
int dni; printf("Dato Incorrecto");
double sueldo; }
t_fecha fnac; }while(cant<=0);
} t_empleado; p=malloc(sizeof (t_empleado)*cant);
void carg_text(char [],int); ingresar(p,cant);
void ingresar (t_empleado*,int); mostrar(p,cant);
void mostrar (t_empleado*,int); free(p);
int main() return 0;
}
INGRESAR MOSTRAR
void ingresar (t_empleado *p, int cant) void mostrar (t_empleado *p,int cant)
{ {
int i; int i;
for(i=0; i<cant; i++) for(i=0;i<cant;i++)
{ {
printf("Ingrese el nombre: "); printf("Nombre: %s Dni: %d Sueldo:
carg_text(p[i].nombre,30); %.2lf\n",p[i].nombre,p[i].dni,p[i].sueldo);
printf("\nIngrese el dni: ");
scanf("%d",&p[i].dni); printf("%d/%d/%d\n",p[i].fnac.dia,p[i].fnac.m
printf("Ingrese el sueldo: "); es,p[i].fnac.anio);
scanf("%lf",&p[i].sueldo); }
printf("Ingrese el fecha de nacimiento: "); }
scanf("%d %d
%d",&p[i].fnac.dia,&p[i].fnac.mes,&p[i].fnac.anio);
}
}
AGREGAR AL FINAL PERSONA CREAR VECTOR DINAMICO
t_persona * agregar (t_persona * a, t_persona p) t_persona *crear()
{ {
t_persona *p;
unsigned int t; int i=0,tam=10;
for(t=0;a[t].fechaNacimiento!=0;t++); p=malloc(sizeof(t_persona)*tam);
a = realloc(a, sizeof(t_persona)* (t+2)); do
a[t+1] = a[t]; //copia la marca de finalización a la última {
posición. También sirve a[t+1].fechaNacimiento=0; . printf ("Ingrese la fecha de nacimiento: ");
scanf("%u",&p[i].fechaNacimiento);
a[t] = p; //copia el valor agregado printf("Ingrese el apellido y nombre: ");
return a; cargar_texto(p[i].apellidoNombre,200);
} i++;
t_persona * agregar (t_persona *a, t_persona v) if(i==tam)
{ {
tam+=10;
int i,tam; p=realloc(p,sizeof(t_persona)*tam);
for(i=0;a[i].fechaNacimiento!=0;i++); }
tam=i+2;//uno para el 0 y otro para el nuevo elemento }while(p[i-1].fechaNacimiento!=0);
a=realloc(a,sizeof(t_persona)*tam); p=realloc(p,sizeof(t_persona)*i);
a[tam-1]=a[tam-2];//paso el 0 a la ultima posicion return p;
}
[tam-1]
a[tam-2]=v;//anteultima posicion[tam-2] le agrego la
nueva variable
return a;
}
AGREGA LA PERSONA AL FINAL DEL ARREGLO CREA UNA NUEVA PERSONA

22
 Funciones con Vectores
IMPRIMIR / MOSTRAR MAIN CARGAR (FINALIZA EN 0)
void mostrar (int a[]) #define N 5 void cargar (int [])
{ (PROTOTIPO FUNCION) {
int i; int i=0;
int main
for(i=0;a[i]!=0;i++) do
{ { {
printf("%d ",a[i]); int a[N]; do
} (FUNCION) ej: mostrar(a); {
printf("\n"); Return 0; printf("Ingr un ent : ");
} } scanf("%d",&v[i]);
if(v[i]<0)
{
MOSTRAR (FINALIZA EN 0) CARGAR printf("Dato Incor\n");
void mostrar(int v[]) void cargar (int v[],int c) }
{ { }
int i; int i; while (v[i]<0);
for(i=0;v[i]!=0;i++) for (i=0;i<c;i++) i++;
{ { }
printf("%d",v[i]); do while(i<N-1 && v[i-1]!=0); /
} { if(i==N-1)
printf("\n"); printf("Ingr el nota: "); {
} scanf("%d",&v[i]); v[i]=0;
if(v[i]<=0 || v[i]>10) }
{ }
printf("Nota Incorrecto\n");
}
}
while(v[i]<=0 || v[i]>10);
}
}

Muestra por pantalla el Cargo los valores en el arreglo Mientras el n° sea <0 repite
arreglo Mientras no se pase o termina en 0

ORDENAR (M BURBUJA)-FINALIZA EN 0 ORDENAR (METODO BURBUJA) EXISTE VALOR

void ordenar (int v[]) void ordenar(int v[]) int existe_valor(int v[], int
{ { valor)
int i,j,aux,tam; int i,j,aux,tam; {
for(i=0;v[i]!=0;i++); for(i=0;i<tam-1;i++) unsigned int i;
tam=i { for(i=0;v[i]!=0;i++)
{ for(j=i+1;j<tam;j++) {
for(i=0;i<tam-1;i++) { if(v[i]==valor)
{ if(v[i]>v[j]) {
for(j=i+1;j<tam;j++) { return 1;
{ aux=v[i]; }
if(v[i]>v[j]) v[i]=v[j]; }
{ v[j]=aux; return 0;
aux=v[i]; } }
v[i]=v[j]; }
v[j]=aux; }
} }
}
}
}
}
for(i=0;v[i]!=0;i++);/*Busco el 0*/ Ordeno el arreglo de mayor a menor, Busco si ese valor existe dentro
tam=i;/*i marca el final de arreg*/ cambiando if(v[i]<v[j]) ordenare de del arreglo
menor a mayor

23
 INVERTIR MESCLAR FACTORIAL PRIMOS
void invertir (int a[]) int factorial (int a) int primo (int a)
{ { {
int i,j,aux; int i,aux; int i,j,aux;
for(j=0;a[j]!=0;j++); aux=1; j=0;
j--; for(i=1;i<=a;i++) for(i=2; i<a && j==0; i++)
for(i=0;i<j;i++) { {
{ aux*=i; aux=a%i;
aux=a[j]; } if (aux==0)
a[j]=a[i]; return aux; {
a[i]=aux; } j=1;
j--; }
} }
} return j;
}
Invierte los números del Mezclo los valores
arreglo del arreglo

UNION INTERSECCION DIFERENCIA(1-2)

INICIALIZAR INICIALIZAR AZAR

AGREGAR AL INICIO AGREGAR AL FINAL

void agregar_al_inicio(int a[], int valor) Void agregar_al_final(int a[], int valor)
{ {
unsigned int i, aux; unsigned int i;
for(i=0;a[i]!=0;i++) for(i=0;a[i]!=0;i++);
{ a[i] = valor;
aux = a[i]; a[i+1] = 0;
a[i] = valor; }
valor = aux;
}
a[i] = valor;
a[i+1] = 0;
}
Lo que hago con esta función es correr un lugar For recorre todas las posiciones hasta llegar a la
todos los números y colocar otro número delante de última casilla, ahí asigna valor y en la que sigue
todos estos, sustituyendo con aux. asigna el 0.

AGREGAR ORDENADO INSERTAR SIN REPETIR

void agregar_ordenado(unsigned int a[], int valor) void insert_sin_repetir(unsigned int a[], int v)
{ {
unsigned int i, aux; if(!(existe_valor(a,v)))
for(i=0;a[i]!=0;i++) {
{ agregar_al_final(a, v);
if(valor < a[i]) }
{
aux = a[i]; }
a[i] = valor;
valor = aux;
}
}
a[i] = valor;
a[i+1] = 0;
}
Agrega un numero ordenado de menor a mayor

24
 ELIMINAR VALOR MODIFICANDO ARREGLO ELIMINAR VALOR SIN MODIFICAR ARREGLO
void eliminar_valor(unsigned int v[], int valor) void eliminar_valor(unsigned int v[], int valor)
{ {
unsigned int i, aux; unsigned int i,otro[]= {1,2,3,4,5,0};
for(i=0; v[i]!=0; i++)
for(i=0;v[i]!=valor && v[i]!=0;i++); {
if(valor == v[i]) // Encontró el valor a otro[i]=v[i];
eliminar }
{ for(i=0; otro[i]!=valor && otro[i]!=0; i++);
for(/* sigo en el subíndice dejado por el if(valor == otro[i])
for de arriba*/;v[i]!=0;i++) {
{ for(; otro[i]!=0; i++)
v[i] = v[i+1]; {
} otro[i] = otro[i+1];
} }
}
} mostrar(otro);
}

POSICION VALOR
int posicion_valor(unsigned int v[], int valor)
{
unsigned int i;

for(i=0;v[i]!=0;i++)
{
if(v[i]==valor)
{
return i;
}
}

return -1; //Si no lo encotró

}

MAXIMO MINIMO POSICION MAXIMO POSICION MINIMO

int maximo (int a[],int t) int minimo (int a[],int t)
{ {
unsigned int i; unsigned int i;
double minimo=a[0]; double minimo=a[0];
for(i=0; i<t; i++) for(i=0; i<t; i++)
{ {
if(a[i]>minimo) if(a[i]<minimo)
{ {
maximo=a[i]; minimo=a[i];
} }
} }
return maximo; return minimo;
} }
Retorna valor máximo de [] Retorna valor minimo de []

BIT AND BIT ON BIT OR

25
 SUMATORIA PROMEDIO DESVIO
double promedio (int v[], int c)
{
int suma=0,i;
for (i=0;i<c;i++)
{
suma+=v[i];
}
return (double) suma/c;
}

MENOR(finaliza 0) MAYOR(finaliza 0) LLENAR AZAR (MATRIZ)

int menor (int v[]) int mayor (int v[]) void llenar_azar(int a[F][C]);
{ { {
int mini,i; int may,i; unsigned int f, c;
mini=v[0]; may=v[0]; for(f=0;f<F;f++)
for(i=0;v[i]!=0;i++) for(i=0;v[i]!=0;i++) {
{ { for(c=0;c<C;c++)
if(v[i]<mini) if(v[i]>may) {
{ { a[f][c]=rand()%100;
mini=v[i]; may=v[i]; }
} } }
} } }
return mini; return may;
} }

LARGO VECTOR EXISTE VALOR

unsigned int largoVector(unsigned int v[]) unsigned int existe_valor(unsigned int v[], int valor)
{ {
unsigned int i=0; unsigned int i;
do
{ for(i=0;v[i]!=0;i++)
i++; {
} if(v[i]==valor)
while(v[i-1]!=0 && i<1000); {
return i-1; return 1;
} }
}
return 0;
}

26
 Funciones con Matrices
MAIN CARGAR VALORES POR FILA POR TECLADO MOSTRAR
#define F 3 void cargar (int m[F][C]) void mostrar (int m[F][C])
#define C 2 { {
(PROTOTIPO FUNCION[][]) int i,j; int i,j;
int main()
{
for(i=0;i<F;i++) for(i=0;i<F;i++)
int mat[F][C]; { {
(FUNCION ();) for(j=0;j<C;j++) for(j=0;j<C;j++)
return 0; { {
} printf("Ingrese el elemento [%d][%d]:",i,j); printf("%-7d",m[i][j]);
scanf("%d",&m[i][j]); }
} printf("\n");
} }
} }
Cargo los valores de la matriz por fila Muestra el resultado en pantalla
Main: cargar(m) Main: mostrar (m)

CARGAR AZAR/ALEATORIO CARGAR VALOR POR COLUM POR TECLADO SUMAR MATRICES
void cargar_azar(int void cargar (int m[F][C]) int sumar (int m[F][C])
m[F][C]) { {
{ int i,j; int i,j,s=0;
int i,j; for(j=0;j<C;j++) for(i=0;i<F;i++)
for(i=0;i<F;i++) { {
{ for(i=0;i<F;i++) for(j=0;j<C;j++)
for(j=0;j<C;j++) { {
{ printf("Ingr elem[%d][%d]:",i,j); s+=m[i][j];
scanf("%d",&m[i][j]); }
m[i][j]=rand()%10+1; } printf("\n");
} } }
} } return s;
} }

Carga números al azar Se invierte los for de i por j Suma todos los valores
Main: cargar(m); Main: cargar(nombre matriz); de la matriz
Main: printf ("suma:
"%d",suma(m))";

SUMATORIA SUMAR UNA FILA VECTOR SUMAR TOTAL POR FILA

int sumarfila(int v[C]) void sumar_fila (int m[F][C]) {
{ int i,j,s;
int j,s=0; for (i=0;i<F;i++)
for(j=0;J<C;j++) {
{ s=0;
s+=v[j]; for(j=0;j<C;j++)
} {
return s; s+=m[i][j];
} }
printf("Tot Fil %d es %d\n",i,s);
}
}
Suma una fila de una matriz Suma total de cada fila

27
 INGRESO FILA Y COL TECLADO(MAIN) CARGAR INGRESANDO F Y C TECLADO MOSTRAR INGRESANDO F Y C
do void cargar (int m[100][100],int void mostrar (int
{ F, int C) m[100][100],int F, int C)
printf("Ingr cant de F: "); { {
scanf("%d",&fila); int i,j; int i,j;
if(fila<=0 || fila>100) for(j=0; j<C; j++) for(i=0; i<F; i++)
{ { {
printf("Dato incorr"); for(i=0; i<F; i++) for(j=0; j<C; j++)
} { {
} printf("Ingr [%d][%d]: ",i,j);
while(fila<=0 || fila>100); scanf("%d",&m[i][j]); printf("%7d",m[i][j]);
do } }
{ } printf("\n");
printf("Ingr cant de C: "); } }
scanf("%d",&col); }
if(col<=0 || col>100)
{
printf("Dato incorr");
}
}
while(col<=0 || col>100);
int mat [100][100],fila,col; Main: cargar(mat,fila,col); Main: mostrar (mat,fila,col);

CARGAR LISTA IMPRIMIR LISTA MOSTRAR LISTA

ES SIMETRICA BOOLEANA COMPARAR MATRIZ

int es_simetrica (int a[F][C])
{
int i,j;
for(i=0; i<F; i++)
{
for(j=0; j<C;j++)
{
if(a[i][j] != a[j][i])
{
return 0;
}
}
}
return 1;
}

28
 Funciones con Vector String
CARGAR TEXTO (FINAL ENTER) MAIN MODIFICAR/CAMBIAR LETRA
void carg_text(char t[],int n) int main() void modif(char t[],char l1,char
{ { l2)
char l; char texto[100]; {
int i=0; printf("Ingr text: "); int i;
do cargar_texto(texto,100); for (i=0;t[i]!='\0';i++)
{ printf("\nText ingr: {
l=getche(); %s",texto); if(t[i]==l1)
t[i]=l; return 0; {
i++; } t[i]=l2;
}while(l!='\r' && i<n-1); }
if(l=='\r') }
{ }
t[i-1]='\0';
}
else
{
t[i]='\0';
}
}
Ingreso un texto hasta enter Cambia una letra por otra
ES MONOVOCALICA (UNA SOLA VOCAL) BOOL MOSTRAR DIBUJOS COSTADOS STRING
int es_monovocalica(char p[]) void mostrar (char t[])
{ {
int i,prim=0,band=1; int espacios,longitud,cont,i;
char vocal; for(i=0;t[i]!='\0';i++);/** Longitud*/
for(i=0;p[i]!='\0';i++) longitud=i; /** Guardo i en longitud*/
{ espacios=80-longitud;
if(es_vocal(p[i])) for(cont=0;cont<espacios/2;cont++)
{ {
if(prim==0) printf("<");
{ }
prim=1; printf("%s",t);
vocal=p[i]; for(cont=0;cont<espacios/2;cont++)
} {
else printf(">");
{ }
if(p[i]!=vocal) if(espacios%2==1)
{ {
band=0; printf(">");
} }
} }
}
}
if(prim==0)
{
return 0;
}
return band;
}
Utiliza la función auxiliar es_vocal Ej: <<<<<<<<hola>>>>>>>
ES VOCAL? BOOLEANA ES CONSONANTE? BOOLEANA
int es_vocal (char l) char es_consonante (char c)
{ {
return (l=='a' || l=='e' || l=='i' || l=='o' if
|| l=='u'); ((c>='A'&&c<='Z'||c>='a'&&c<='z')&&!es_vocal(c))
} {
return 1;
Función auxiliar utilizada pasa saber si es una }
vocal. return 0;
Se le puede sumar la Mayúscula }
||v=='A'||v=='E'||v=='I'||v=='O'||v=='U' Función auxiliar , necesita de la función es_vocal
para funcionar

29
 ES_SEPARADOR BOOLEANA MAYUSCULA
char es_separador(char x) char a_mayuscula(char x)
{ {
return x==' '||x=='.'||x==','||x==';'||x=='?'||x=='!'||x==':'; if(x>='a' && x<='z')
} {
return x - ('a' - 'A');
}
return x;
}

COPIAR STRING COMPARAR STRING

void copiar (char c1[],char c2[]) int comparar(char c1[],char c2[])
{ {
int i; int i=0;
for(i=0;c2[i]!='\0';i++) while(c1[i]==c2[i] && c1[i]!='\0' && c2[i]!='\0')
{ {
c1[i]=c2[i]; i++;
} }
c1[i]='\0'; if(c1[i]>c2[i])
} {
return 1;
}
else if (c1[i]<c2[i])
{
return -1;
}
else
{
return 0;
}
}
Lo utilizo en la función ordenar_lista Lo utilizo en la función ordenar_lista (matriz)
(matriz) Compara los carácter de cada matriz

ELIMINAR CARACTER
void eliminar (char t[])
{
int i,j,k,l=0;
for(i=0; t[i]!='\0'&& !(t[i]>='a' && t[i]<='z' || t[i]>='A' && t[i]<='Z'); i++);
for(j=0; t[j]!='\0'; j++);
for(j; j>=0 && !(t[j]>='a' && t[j]<='z' || t[j]>='A' && t[j]<='Z'); j--);
for(k=i; k<=j; k++)
{
t[l]=t[k];
l++;
}
t[l]='\0';
}
Elimina todo carácter que no sea una letra

30
 CONTAR_APARICIONES REEMPLAZAR STRING
unsigned int contar_aparic(char s1[], char s2[]) void reempl(char s1[],char s2[],char s3[],char s4[])
{ {
unsigned int i=0, j=0, cantidad=0; unsigned int i1=0, i4=0, j=0;
char aux[200]; char aux[200];
while(s1[i1]!='\0') {
while(s1[i]!='\0') while(s1[i1]!='\0' && es_separador(s1[i1]))
{ {
while(s1[i]!='\0'&&es_separador(s1[i])) s4[i4]=s1[i1];
{ i1++;
i++; i4++; }
} j=0;
j=0; while(s1[i1]!='\0' && !es_separador(s1[i1]))
while(s1[i]!='\0'&&!es_separador(s1[i])) {
{ aux[j]=s1[i1];
aux[j]=s1[i]; j++;
j++; i1++; }
i++; aux[j]='\0';
} if(comparar_i(aux,s2)==0)
aux[j]='\0'; {
for(j=0; s3[j]!='\0';j++)
if(comparar_i(aux,s2)==0) {
{ s4[i4] = s3[j];
cantidad++; i4++;
} }
} }
return cantidad; else
} {
for(j=0; aux[j]!='\0';j++)
{
s4[i4] = aux[j];
i4++;
}
}
}
s4[i4] ='\0';
}
//guardo cada palabra del string en un arreglo
auxiliar para luego determinar si debe copiarse o
reemplazarse
// si esta palabra es la que tengo que reemplazar, la
reemplazo por s4
//copia los separadores literalmente
// si no es la palabra que busco, copio la original

INGRESAR STRING SUMAR STRING

ORDENAR ALFABETICAMENTE BOOLEANA ES_LETRA

int ord_alfab(char v[]) char es_letra (char l)
{ {
unsigned int i,j=1; if(l>='a'&&l<='z'||l>='A'&&l<='Z')
for (i=0;v[j]!='\0';i++,j++) {
{ return 1;
if(v[i] > v[j]) }
{ return 0;
return 0; }
}
}
return 1;
}
Verifica si lo que se ingresa es una letra

31
 COMPARAR STRING CONCATENAR STRING
char comparar (char s1[], char s2[]) void concatenar (char s1[], char s2[], char s3[])
{ {
unsigned int i; unsigned int i,j=0;
for(i=0;s1[i]!='\0' && s1[i]==s2[i];i++); for(i=0;s1[i]!='\0';i++)
{
if(s1[i]==s2[i]) s3[j] = s1[i];
{ j++;
return 0; }
} for(i=0;s2[i]!='\0';i++)
else if(s1[i]=='\0' || s1[i]<s2[i]) {
{ s3[j] = s2[i];
return -1; j++;
} }
else s3[j]='\0';
{ }
return 1;
}
}
Une dos o más cadenas de texto

LETRAS ALTERNADAS BOOLEANA DIVIDIR STRING

char alternado (char a[])
{
unsigned int i,j=1;
for(i=0; a[j]!='\0'; i++,j++)
{
if((es_vocal(a[i])&&es_vocal(a[j]))||(es_consonante(a[i])&&es_consonante(a[j])))
{
return 0;
}
}
return 1;
}
Identifica si una palabra tiene una consonante y una vocal alternada ej: abeja. Lleva
la fun aux vocal y consonante
CONTAR_PALABRAS COMPARAR_I
unsigned int contar_palabras(char s[]) char comparar_i (char s1[], char s2[])
{ {
unsigned int i=0, dentro, cantidad=0; unsigned int i;
while(s[i]!='\0') for(i=0;s1[i]!='\0' &&
{ a_mayuscula(s1[i])==a_mayuscula(s2[i]);i++);
while(s[i]!='\0' && es_separador(s[i]))
{ if(s1[i]==s2[i]) //en este caso, salió del
i++; for porque ambos son iguales
dentro=0; {
} return 0;
while(s[i]!='\0' && !es_separador(s[i])) }
{ else if(s1[i]=='\0' ||
i++; a_mayuscula(s1[i])<a_mayuscula(s2[i]))
dentro=1; {
} return -1;
if(dentro) }
{ else
cantidad++; {
} return 1;
} }
return cantidad; }
}

32
 RESTAR STRING CAMBIAR LETRA CON MAIN Y STRING.H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void cambiar_c (char []);

int main()
{
char c1[]="hola";
cambiar_c(c1);
printf("%s\n",c1);
return 0;
}
void cambiar_c (char c1[])
{
int limite,i;
limite=strlen(c1);
for(i=0;i<limite;i++)
{
if(c1[i]=='a')
{
c1[i]='e';
}
}
}
Cambia un carácter por otro

33
 String con Matriz (guarda cadenas de string, ej: nombres)
MAIN
#define N 5 (cantidad de strig) F
#define M 30 (tamaño del string)C
{ int i;
int nombres[N][M];
cargar_lista(nombres);
printf("Nombres ingresados\n");
imprimir_lista(nombres);
ordenar_lista(nombres);
printf("Nombres ordenados\n");
imprimir_lista(nombres);
return 0;
}
CARGAR LISTA MATRIZ STRING IMPRIMIR LISTA MATRIZ STRING
void cargar_lista(char nom[N][M]) void imprimir_lista(char nom[N][M])
{ {
int i;
for(i=0; i<N; i++) for(i=0; i<N; i++)
{ {
printf("Ingrese nombre: "); printf("%s\n",nom[i]);
carg_texto(nom[i]); }
} }
printf("\n");
}
Se requiere de la función auxiliar
(vector) carg_texto
(función vector string)
Main: cargar_lista(nombres); Main: imprimir_lista(nombres);

ORDENAR LISTA MATRIZ STRING CARGAR TEXTO VECTOR MOSTRAR STRING

void ordenar_lista(char nom[N][M]) void carg_texto(char t[])
{ {
int i,j; char l;
char aux[M]; int i=0;
for(i=0; i<N-1; i++) do
{ {
for(j=i+1; j<N; j++) l=getche();
{ t[i]=l;
if(comparar(nom[i],nom[j])>0) i++;
{ }
copiar(aux,nom[i]); while(l!='\r' && i<M-
copiar(nom[i],nom[j]); 1);
copiar(nom[j],aux); if(l=='\r')
} {
} t[i-1]='\0';
} }
} else
{
t[i]='\0';
}
printf("\n");
}
Requiere las funcione auxiliares (vector)
comparar y copiar
Main: ordenar_lista(nombres);

34
Función: strcmp(Compara dos cadenas de texto)
Include: string.h.
Esta función devuelve un número entero, que será:
 0 si ambas cadenas son iguales.
 Un número negativo, si cadena1 < cadena2.
 Un número positivo, si cad1 > cad2.
Parámetros: Las dos cadenas a comparar
Declaración: int strcmp(const char *cadena1, const char *cadena2);
Ejemplo de uso: if (strcmp(orden, "fin") == 0) { ... };

int main()
{
char texto1[40], texto2[40];
int comparacion;
printf("Introduce una palabra: ");
gets(texto1);
printf("Introduce otra palabra: ");
gets(texto2);
comparacion = strcmp(texto1, texto2);
if (comparacion==0)
printf("Son iguales\n");
else if (comparacion>0)
printf("La primera palabra es mayor\n");
else
printf("La segunda palabra es mayor\n");
return 0;
}

35
 MENU 1

36
 MENU 2

37
 MENU 3 Letras

MENU 4 (CON FUNCIONES)

38
 DIBUJAR FIGURAS

Horizontal Horizontal Horizontal Vertical Vertical Vertical Diagonal Diagonal cuadrante inferior

39
superior inferior medio izquierda derecha medio izq. a der der. a izq derecho
f==0 f==t-1 f==t/2 c==0 c==t-1 c==t/2 f==c f+c==t-1 f>=t/2 && c>=t/2

40