Ejercicios de Punteros II - Programación 1

Acerca de¶

Estos ejercicios prácticos y aplicados complementan la teoría de punteros y aritmética básica de indirección de memoria en C.

Capítulos de Apunte Correspondientes¶

Introducción

Cuestiones de Estilo Aplicables¶

Uso de aserciones: Es mandatorio validar mediante assert de la cabecera <assert.h> que los punteros recibidos por parámetros en las funciones no sean NULL (ver Regla 0x2009h: Los ejercicios deben ser resueltos mediante funciones).
Aritmética de punteros: Recorré los arreglos operando de manera directa sobre los punteros de control y evitando índices lógicos temporales, incrementando o decrementando las direcciones físicas de memoria de forma explícita.

Ejercicio 9.1 - s ⭐⭐☆☆☆¶

Ejercicio 9.2 - b.1 - Intercambiar valores ⭐⭐☆☆☆¶

Solution to Exercise punteros-1

1
2
3
4
5
6
7
8
9
10
11
#include <assert.h>
#include <stddef.h>
#include <stdio.h>

void intercambiar(int *a, int *b) {
  assert(a != NULL);
  assert(b != NULL);
  int temporal = *a; // Guardamos el valor al que apunta 'a'
  *a = *b;           // Asignamos al lugar de 'a' el valor al que apunta 'b'
  *b = temporal;     // Asignamos al lugar de 'b' el valor guardado
}

Ejercicio 9.3 - b.2 - Encontrar máximo ⭐⭐☆☆☆¶

Solution to Exercise funciones-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <assert.h>
#include <stddef.h>
#include <stdio.h>

int encontrar_maximo(const int *arreglo, size_t n) {
  assert(arreglo != NULL);
  if (n == 0) {
    return 0; // O un valor de error apropiado
  }

  int maximo = *arreglo; // Suponemos que el primer elemento es el máximo

  // Avanzamos el puntero por el resto del arreglo
  for (size_t i = 1; i < n; i++) {
    // Usamos aritmética de punteros para acceder al siguiente elemento
    if (*(arreglo + i) > maximo) {
      maximo = *(arreglo + i);
    }
  }
  return maximo;
}

Ejercicio 9.4 - b.3 - Copiar cadena ⭐⭐⭐☆☆¶

Solution to Exercise funciones-2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <assert.h>
#include <stddef.h>
#include <stdio.h>

void copiar_cadena(char *destino, const char *origen) {
  assert(destino != NULL);
  assert(origen != NULL);
  // Mientras el valor al que apunta 'origen' no sea el carácter nulo...
  while (*origen != '\0') {
    *destino = *origen; // Copiamos el valor
    origen++;           // Avanzamos el puntero de origen
    destino++;          // Avanzamos el puntero de destino
  }
  *destino = '\0'; // Aseguramos que la cadena destino termine con el nulo
}

Ejercicio 9.5 - b.4 - Sumar arreglo con punteros ⭐⭐⭐☆☆¶

Solution to Exercise funciones-3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <assert.h>
#include <stddef.h>
#include <stdio.h>

int sumar_arreglo(const int *inicio, const int *fin) {
  assert(inicio != NULL);
  assert(fin != NULL);
  int suma = 0;
  // Iteramos mientras el puntero 'p' no haya llegado al puntero 'fin'
  for (const int *p = inicio; p < fin; p++) {
    suma += *p; // Sumamos el valor al que apunta 'p'
  }
  return suma;
}

Ejercicio 9.6 - b.5 - Invertir arreglo in-place ⭐⭐⭐☆☆¶

Solution to Exercise punteros-2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <assert.h>
#include <stddef.h>
#include <stdio.h>

void invertir_arreglo(int *arreglo, size_t n) {
  assert(arreglo != NULL);
  if (n < 2) {
    return; // No hay nada que invertir
  }
  int *inicio = arreglo;
  int *fin = arreglo + n - 1;

  while (inicio < fin) {
    // Intercambiamos los valores
    int temp = *inicio;
    *inicio = *fin;
    *fin = temp;

    // Movemos los punteros hacia el centro
    inicio++;
    fin--;
  }
}