Fundamentos de Informática

Ingeniería Técnica Industrial. E.U. Politécnica

EJERCICIOS RESUELTOS

Los ejercicios resueltos de la siguiente relación no están relacionados con la lista de ejercicios propuestos de cada tema (la cual puedes encontrar aquí).

Ejercicios sobre Datos Estructurados (arrays, cadenas, estructuras...)

Programar una función Calculos() cuyo primer argumento ser un array de elementos long double y el segundo argumento ser el tamaño de ese array. La función devolverá la media de ese array. Además, la función calculará los siguientes datos que serán pasados como argumentos por referencia: El valor más grande y más pequeño de todos los elementos del array, y el número de veces que se repiten esos dos valores, de forma independiente para cada uno de ellos. Por tanto, la función tendrá 6 argumentos (2 de entrada y 4 de salida).
Solución:
```
/***** ***** ***** ***** *****
Entrada: Array arr de tamaño tama.
Salida : Valor más grande y más pequeño del array y
     número de veces que se repiten ambos valores independientemente.
Devuelve: Media aritmética del array.
***** ***** ***** ***** *****/
long double Calculos (long double arr[],  unsigned tama,
              long double *Mayor, unsigned *NumMayor,
              long double *Menor, unsigned *NumMenor){
  unsigned i;
  long double suma=arr[0]; /* El primer elemento se usa fuera del bucle */

  *Mayor = *Menor = arr[0];  /* El primer elemento es el Mayor y el Menor */
  *NumMayor = *NumMenor = 1; /* Ambos valores se han repetido 1 vez */

  for (i=1;i < tama;i++){
    suma=suma+arr[i];

    if (arr[i] > *Mayor){
       *Mayor=arr[i];
       *NumMayor=1;
    }
    else if (arr[i] == *Mayor)
        (*NumMayor)++;

    if (*Menor > arr[i]){
       *Menor=arr[i];
       *NumMenor=1;
    }
    else if (arr[i] == *Menor)
        (*NumMenor)++;
  }

  return suma/tama;
}
```
Observaciones:
- En la expresión (*NumMenor)++ los paréntesis son necesarios, ya que el operador de incremento (++) tiene más prioridad que el operador de indirección (*). Por eso, si no se ponen los paréntesis, en vez de incrementar el valor apuntado por NumMenor se incrementará el puntero (la dirección de memoria).
- Si la función tiene muchos argumentos y se salen por la derecha de la pantalla, se puede partir la línea en varias, como se muestra en este ejemplo.
- Recuerde que para leer o escribir valores de tipo long double el modificador es "%Lf" (con la L mayúscula).
Hacer un subprograma para descubrir el número de veces que aparece cada dígito entre 0 y 9 en un determinado número natural. El subprograma tendrá dos argumentos. El primero será de tipo unsigned long int y el segundo será de tipo DIGITOS, siendo éste un tipo definido por el programador, como un array de 10 unsigned int.
El subprograma tomará el número del primer argumento, lo analizará y devolverá en el array del segundo argumento el número de veces que se repite cada dígito entre 0 y 9 en el número. Por ejemplo, para el número 248282, devolverá todo el array a cero, excepto la posición 2 que tendrá un 3, la posición 4 que tendrá un 1 y la posición 8 que tendrá un 2.
El programa principal leerá un número por teclado, llamará al subprograma anterior y mostrará en pantalla el número de veces que se repite cada dígito entre 0 y 9 en el número dado, evitando mostrar los dígitos que no existen en el número original. Al final, mostrará el número de dígitos total del número introducido.
Por ejemplo, para el ejemplo anterior del número 248282 el programa deberá mostrar las siguientes líneas:
```
Número de dígitos 2: 3
Número de dígitos 4: 1
Número de dígitos 8: 2
Número total de dígitos: 6
```
Solución:
```
/* Tema 6: Ejercicio 10 */
#include<stdio.h>

typedef unsigned int DIGITOS[10];

/***** ***** ***** ***** *****
Función para calcular el número de cada dígito distinto del número N.
El resultado es almacenado en el array DIG.
***** ***** ***** ***** *****/
void Num_Digitos (unsigned long N, DIGITOS DIG){
  int i;
  for(i=0;i < 10;i++) /* Inicializar el array */
    DIG[i]=0;

  if (N==0) { /* Caso particular del cero */
     DIG[0]=1;
  }
  else
     while (N!=0){
       DIG[N%10]++; /* Se incrementa la posición N%10 */
       N=N/10;      /* Se quita el último dígito de N */
     }
}

void main(){
  DIGITOS D;
  unsigned long numero;
  int i;
  unsigned total=0;

  printf("\n- Número: ");
  scanf("%lu",&numero);

  Num_Digitos(numero,D);

  for(i=0;i<10;i++){
    total=total+D[i];
    if (D[i]>0)
       printf("\nNúmero de dígitos %i es: %u.",i,D[i]);
  }
  printf("\nNúmero total de dígitos: %u.",total);
}
```

Programar una función en C de nombre InvierteCad() que tome un único argumento de tipo cadena de caracteres. La función debe invertir los caracteres de dicha cadena pero lo hará independientemente para cada frase. Supondremos que termina una frase cuando existe un punto (carácter '.') o si se llega al final de la cadena.

Ejemplo: Si como argumento de InvierteCad() se introduce la cadena de la izquierda, dicha cadena se modificaría tomando el valor de la cadena de la derecha:

"PAZ. PARA. KOSOVO" "ZAP.ARAP .OVOSOK "
"reconocer" "reconocer"
"HOLA TIO. Yo bien." "OIT ALOH.neib oY ."
"Lee entero. El examen!" "oretne eeL.!nemaxe lE "

Observe que los puntos quedan en la misma posición que en la cadena original.

Solución:

/****** Inversión de subcadenas separadas por un punto *****/
void InvierteCad(char cad[]){
  unsigned int fin, inicio=0, /* Inicio y Fin de cada subcadena */
               indice=0,      /* Indice para buscar el final de cada subcadena */
               longitud=strlen(cad); /* Longitud de la cadena */
  char aux; /* Carácter auxiliar para efectuar un intercambio */

  while (indice < longitud) {
    /* Bucle para buscar el final de cada subcadena: */
    while ((cad[indice]!='.') && (cad[indice]!='\0'))
      indice++;

    fin=indice-1; /* Resto 1 para eliminar el '.' o el '\0' */
    while (inicio < fin) {
      aux=cad[inicio]; /* Intercambio caracteres en posiciones inicio y fin */
      cad[inicio]=cad[fin];
      cad[fin]=aux;
      inicio++; /* Actualizo ambos índices */
      fin--;
    }

    inicio=++indice; /* El nuevo inicio será el caracter siguiente al '.' */
  }
} /* InvierteCad() */

Programar una función para ordenar un array de n enteros utilizando el algoritmo de ordenación por Burbuja.

Solución 1:

/**************************************************/
/* Ordena el vector de n enteros, utilizando el   */
/* Algoritmo de ordenación BURBUJA (simplificado) */
/**************************************************/
void burbuja (int vector[], int n){
  int i, w, aux;

  do {
       w = 0;

       for (i = 0; i < n - 1; i++)
           if (vector[i] > vector[i+1]) { /* intercambio */
              aux = vector[i];
              vector[i] = vector[i+1];
              vector[i+1] = aux;
              w = 1;
           }

     } while (w);  /* Es lo mismo que (w!=0) */
}

Solución 2:

/*************************************************/
/* Ordena el vector de n enteros.                */
/* Otra versión optimizada del algoritmo BURBUJA */
/* Esta versión es más eficiente. Comprúebelo    */
/* con un ejemplo suficientemente grande e       */
/* intente seguirlo, a mano, con un ejemplo de   */
/* 5 ó 6 elementos, para que vea las diferencias */
/*************************************************/
void burbuja (int vector[], int n){
  int i, w, aux,
      v=1; /* v indica el número de vuelta a realizar */

  do { w = i = 0;
       do {
          if (vector[i] > vector[i+1]) { /* intercambio */
              aux = vector[i];
              vector[i] = vector[i+1];
              vector[i+1] = aux;
              w = 1; /* Indica que el array NO está ordenado aún */
          } /*if*/
          i++;
       } while ( i < n-v ) /* Así, ahorramos comparaciones inútiles */
       v++;                /* Se incrementa el número de vueltas    */
  } while (w);
}

Implementar una función que devolverá un dato 1 (verdad) si una cadena de caracteres, que se le pasa como único argumento, es un palíndromo y 0 (falso) si no lo es. Una palabra o frase se dice que es un palíndromo si, ignorando los espacios, la lista de letras es idéntica hacia adelante o hacia atrás. Por ejemplo, si la frase de entrada es "Dabale arroz a la zorra el abad", el programa debe indicar que SÍ es un palíndromo.
Ejemplos de otras frases palindrómicas son: "se verla al revés", "ella te dará detalle", "A la Manuela dale una mala", "a la torre, derrótala", "ligar es ser ágil", "logré ver gol", "luz azul", "ojo rojo"...
Solución:
```
/*************************************************/
/* Devuelve 0 si NO es palíndromo y 1 si lo es   */
/*************************************************/
short palindromo (char *cadena){
  int largo=strlen(cadena),
      i=0,       /* Contador que empieza por el Inicio de cadena */
      f=largo-1; /* Contador que empieza por el Final  de cadena */

  while (i < f) {
    while (cadena[i]==' ' && i < f) /* Saltamos espacios iniciales */
          i++;
    while (cadena[f]==' ' && i < f) /* Saltamos espacios finales   */
          f--;
    if (i < f) { /* Si no se han cruzado los índices */
       if (cadena[i] != cadena[f])
          return 0;  /* Si llega hasta aquí NO es palíndromo */
       i++;
       f--;
    } /*if*/
  } /*while*/

  return 1; /* Si llega hasta aquí SI es palíndromo */
}
```
Modifique el anterior programa para que considere como iguales las letras acentuadas con las no acentuadas, y las letras mayúsculas de las minúsculas (incluida la ñ), así como que no considerase tampoco los signos de puntuación (comas, puntos...), además de los espacios como ya hace la función anterior.

`"PAZ. PARA. KOSOVO"`		`"ZAP.ARAP .OVOSOK "`
`"reconocer"`		`"reconocer"`
`"HOLA TIO. Yo bien."`		`"OIT ALOH.neib oY ."`
`"Lee entero. El examen!"`		`"oretne eeL.!nemaxe lE "`