int
eliminaCeros(const int v[], int dim){
int i,j=0;
for(i=0;i<dim;i++){
if(arr[i] != 0){
arr[j++] = arr[i];
}
}
return j;
}
LIBRERÍA RANDOM:
#ifndef __RAND_H_
#define __RAND_H_
/*genera un nro aleatorio entre 0 y 1*/
double randNormalize (void);
/*genera nro aleatorio entrero entre a y b */
int randInt(int a, int b);
/*genera nro aleatorio double entre a y b */
double randReal (double a , double b );
/*resetea la semilla */
void randomize(void);
#endif
#include <stdlib.h>
#include <time.h>
double randNormalize(void) {
return rand() / ((double) RAND_MAX + 1);
}
// Double en el intervalo [0,1)
int randInt(int izq, int der) {
if ( izq > der) {
int aux = izq;
izq = der;
der = aux;
}
return randNormalize()*(der-izq+1) + izq;
// return rand() % (der - izq + 1) + izq;
}
// Entero en el intervalo [izq,der]
double randReal(double izq, double der) {
return randNormalize() * (der - izq) + izq;
}
void randomize(void){
srand(time(NULL));
}
// double en el intervalo [izq,der)
// Resetea la semilla.
int
union (int v1[], int dim1, int v2[], int dim2, int un[] ){
int i, j;
int dimUn=0;
int repetido;
for(i=0; i<dim1 ; dimUn++, i++)
un[dimUn++] = v1[i];
for(j=0 ; j<dim2 ; j++){
repetido = 0;
for(i=0; i<dim1 && !repetido; i++) {
if(v1[i] == v2[j])
repetido = 1;
}
if(!repetido)
un[dimUn++] = v2[j];
}
return dimUn;
Unión de arreglos:
- desordenados.
- sin repetidos
- la dimensión es dato
Primero pasa todos los elementos
del primer vector al vector union.
Luego, para cada elemento del
segundo vector, evalúa si sus
elementos están en el primero. Si
están, no los copia.
}
int
unionOrdenados (const int v1[], int dim1, const int v2[],
int dim2, int resp[] ){
int i=0,j=0;
int dimRes=0;
while(i<dim1 || j<dim2){
if (v1[i] == v2[j]){
resp[dimRes++] =
j++;
}
else if (v1[i]<v2[j]
resp[dimRes++] =
}
else if (v1[i]>v2[j]
resp[dimRes++] =
Unión de arreglos
-ordenados.
-sin repetidos
-la dimensión es dato
1) Si son iguales, ninguno terminó
(sino no hubiera entrado al while)
v1[i++];
&& i<dim1 || j==dim2){
v1[i++];
&& j<dim2 || i==dim1){
v2[j++];
}
return dimRes;
2) Incrementa y pasa el primero si
es menor al segundo y no termino,
o si el segundo ya terminó
3) Incrementa y pasa el segundo si
es menor al primero y no termino o
si el segundo ya terminó
}
int unirArreglos ( const int ar1[], const int ar2[],
int resultado[]){
int i=0,j=0;
int dimRes=0;
Unión de arreglos
-ordenados.
-sin repetidos
-terminan en -1
while(ar1[i]!=-1 || ar2[j]!=-1){
if(ar1[i]<ar2[j] && ar1[i]!=-1 || ar2[j]==-1){
resultado[dimrRes++]=ar1[i++];
}
Es lo mismo q el de arriba, solo que
<dim se reemplaza por !=-1
else if(ar1[i]>ar2[j] && ar1[j]!=-1 || ar1[i]==-1){
resultado[dimRes++]=ar2[j++];
}
else if(ar1[i]==ar2[j]){
resultado[dimRes++]=ar1[i++];
j++;
}
}
resultado[dimRes]=-1;
return dimRes;
}
Terminar el arreglo de la union con
-1, sin sumar en dimRes
GUIA 6 - Ejercicio 4: Escribir una función que reciba un vector desordenado de números enteros y su dimensión, y
construya otro vector eliminando los valores repetidos. La función deberá retornar en su nombre la dimensión del
nuevo vector
int
eliminaRepetidos( const int arr[],int dim, int sinRep[]){
int dimResp = 0;
int i, j;
int repetido;
for (i = 0; i<dim ; i++){
repetido = 0;
for (j=0 ; j<dimResp && !repetido ; j++){
if( sinRep[j] == arr[i])
repetido = 1;
}
Para cada elemento del vector
original, se recorre el nuevo
arreglo. Si el elemento no está, lo
agrega
Si encuentra q está repetido, deja
de buscar.
if (!repetido)
sinRep[dimResp++] = arr[i];
}
}
return dimResp;
GUIA 6 - Ejercicio 5: Lo mismo q el 4 pero para vectores ordenados.
int
eliminaRepetidos( const int arr[],int dim, int sinRep[]){
int dimResp = 0;
}
if (dim > 0){
sinRep[0] = arr[0];
dimResp++;
for (int i=1; i < dim ; i++){
if (arr[i] != arr[i-1])
sinRep[dimResp++] = arr[i];
}
}
return dimResp;
GUIA 6 - Ejercicio 11: Escribir una función que ordene las filas de una matriz de cualquier tamaño, según el valor de
una determinada columna. La función recibirá como parámetros la matriz, la cantidad de filas, la cantidad de
columnas y el número de columna a tomar como clave de ordenación, teniendo en cuenta que la primer columna es
la columna 1 (uno).
void
ordenaMatriz(int m[][MAXCOL], int f, int c, int cOrd){
cOrd--;
int min;
for(int i=1 ; i<f-1 ; i++){
min = i;
for(int j=min+1 ; j<f ; j++){
if (m[j][cOrd] < m[min][cOrd])
min = j;
}
if(min != i){
swapFil(m[i],m[min],c);
}
}
}
Buscar cual es la menor y
después hacer el cambio. Asi
se minimiza cantidad de
“swaps”
GUIA 6 - Ejercicio 12: Una imagen bmp se almacena en un archivo como una matriz de píxeles.
Si la imagen es de escala de grises, cada píxel ocupa un solo byte. Así, si la imagen tiene 20x30 píxeles, ocupa 600
bytes donde un byte con el valor 0x00 corresponde al negro y un byte con el valor 0xFF corresponde al blanco.
Cualquier valor entre 0x00 y 0xFF será una tonalidad de gris.
Realizar una función suavizar que, dada una imagen, la suavice aplicando un filtro de media de valor W, con W impar.
Esto significa que cada píxel (i, j) de la nueva imagen se obtiene a partir de la media aritmética de los píxeles que se
encuentran en la imagen original de la submatriz de tamaño WxW centrada en (i,j).
La función suavizar recibe como únicos parámetros la matriz y W. Si W es menor que 3 o no es impar, la función
no altera la imagen.
El ancho y alto de la imagen son las constantes simbólicas ANCHO y ALTO respectivamente.
#define MIN(a,b) ((a)<(b)?(a):(b))
#define MAX(a,b) ((a)>(b)?(a):(b))
void suavizar(int img[ALTO][ANCHO], int W);
int suavPixel(int img[ALTO][ANCHO], int f, int c, int W);
void copiaMat (int img[ALTO][ANCHO], int imgSuav[ALTO][ANCHO]);
void
suavizar(int img[ALTO][ANCHO], int W){
if(W>=3 && W%2){
int imgSuav[ALTO][ANCHO];
for(int i=0 ; i<ALTO ; i++){
for(int j=0 ; j<ANCHO ; j++){
imgSuav[i][j] = suavPixel(img, i, j, W);
}
}
copiaMat(img,imgSuav);
}
}
int
suavPixel(int img[ALTO][ANCHO], int f, int c, int W){
int suma=0;
int pixeles=0;
W=W/2;
for(int i = MAX(0,f-W) ; i <= MIN(ALTO-1,f+W) ; i++){
for(int j = MAX(0,c-W) ; j <= MIN(ANCHO-1,c+W) ; j++){
suma+= img[i][j];
pixeles++;
}
}
return (suma/pixeles);
}
void
copiaMat (int img[ALTO][ANCHO], int imgSuav[ALTO][ANCHO]){
for (int i=0 ; i<ALTO ; i++){
for(int j=0 ; j<ANCHO ; j++){
img[i][j]=imgSuav[i][j];
}
}
}
GUIA 6 - Ejercicio 20: Escribir la función elimVocales que reciba un string s y una matriz de 5 columnas y n filas,
donde cada columna representa una vocal y n es un parámetro de la función. La función deberá devolver el string s
sin las vocales (ya sean mayúsculas o minúsculas), y la matriz con las ubicaciones de las vocales eliminadas. Cada
columna de la matriz debe “cerrarse” con un -1. La función tiene que controlar el espacio disponible en la matriz
para seguir guardando ubicaciones. Si no hay espacio suficiente, devuelve ERROR, aunque haya quedado modificado
el string.
#include <string.h>
#include <ctype.h>
#define ERROR 0
#define EXITO 1
#define CANT_VOCAL 5
/* Devuelve 0 si no es vocal, 1 si es 'a', 2 si es 'e', etc. */
int esVocal(char c) {
static char * vMay = "AEIOU";
char * p = strchr(vMay, toupper(c));
if ( p == NULL)
return 0;
return p - vMay + 1;
}
int elimVocales(char * s, int m[][CANT_VOCAL], unsigned int n) {
unsigned int pos[CANT_VOCAL] = {0};
int ans = EXITO;
int i, j;
for(i=j=0; s[i]; i++)
{
int vocal = esVocal(s[i]);
if ( vocal && pos[vocal-1] < n-1) {
m[pos[vocal-1]++][vocal-1] = i;
} else {
if ( vocal )
ans = ERROR; // era vocal pero no habia mas lugar
s[j++] = s[i];
}
}
s[j] = 0;
// Completamos con -1 al final de cada columna
for(i=0; i < CANT_VOCAL; i++) {
m[pos[i]][i] = -1;
}
return ans;
}
int
ascendenteODescendente(const int (m[])[COLS]) {
int asc = 1, des = 1, anterior = m[0][0];
for(int i = 0; i < FILS && (asc || des); i++) {
for(int j = 0; j < COLS && (asc || des); j++) {
int actual = m[i][j];
if(asc && actual < anterior) {asc = 0;}
if(des && actual > anterior) {des = 0;}
anterior = actual;
}
}
}
if(asc) {
return 1;}
if(des) {
return -1;}
return 0;
Strings
void
insertaDesde(char * s1, const char * s2,
{
char c)
char * pos = strchr(s1, c);
if(pos != NULL)
strcpy(pos, s2);
}
char * strchr(const char * s, char c) localiza la primera
aparición de c en la cadena de caracteres s.
char * strcpy(char * d, const char * f) copia la cadena
apuntada por f (incluyendo el carácter nulo) a la
cadena apuntada por d.