Como determinar el nuevo largo de un arreglo luego de filtrar (TP5 - Ejercicio 2 - Punto 4)

[curambar]

El punto 4 pide "Implementar una función que reciba un arreglo y cree uno nuevo removiendo un determinado número."
Hay dos maneras de interpretar esto. Supongamos que el arreglo en cuestión tiene un tamaño N. Sea, por ejemplo, el arreglo {4, 5, 0, 1, 5, 9} con N = 6, y que queremos filtrar el número 5.

La primera interpretación es que elimine solo la primera instancia de ese valor, quedando el arreglo {4, 0, 1, 5, 9}. En este caso, el tamaño del nuevo arreglo es simplemente 5, N - 1, uno menos que el original.
En esta primera interpretación, también puede ocurrir que no encuentre el valor a filtrar, en cuyo caso devolvería el arreglo original sin modificar, con tamaño 6, N.

La segunda forma de interpretar la consigna es eliminar todas las instancias del valor en cuestión. En el ejemplo dado, el nuevo arreglo quedaría {4, 0, 1, 9}. Como halló dos instancias del valor dado, el nuevo tamaño es 4, N - 2.

Como vemos, el tamaño del nuevo arreglo depende del resultado de la operación. En un caso de prueba como en este ejemplo, podemos ver que el nuevo arreglo puede tener tamaño 4, 5, o 6. Esto presenta un problema. porque si no sabemos de antemano el el nuevo tamaño con certeza, no podremos usar el arreglo resultante como argumento de alguna función.

¿Hay alguna forma implementar adecuadamente la segunda interpretación a este enunciado, o de tener la opción de devolver la cadena intacta si no hay nada que filtrar?

Una solución que se me ocurre es limitar el resultado: Usar exclusivamente la primera interpretación del enunciado (solo eliminar un elemento), y devolver NULL en caso de que no encuentre el valor a filtrar. De este modo, el tamaño resultante es exclusivamente N - 1, o bien el resultado es nulo.

Esta solución me resulta limitada, por lo que seguí intentando hasta descubrir otra opción. Lo que me funcionó fue abandonar la necesidad de que la función devuelva un puntero al nuevo arreglo, y que en su lugar devuelva un entero. A esta función se le pasa como argumento un puntero a un arreglo que usaremos como resultante (como en el ejercicio que calcula simultáneamente cociente y resto). Este arreglo debe ser no nulo, intenté inicializarlo como NULL y todo explotó. Para aprovechar las funciones que ya tengo, inicialicé el arreglo resultante como un duplicado del arreglo a filtrar. El arreglo resultante es manipulado dentro de la función, asignándole el tamaño adecuado con realloc. El retorno de la función es el nuevo largo del arreglo.

Empecé a escribir esta discusión como una pregunta, pero a medida que la escribía se me iban ocurriendo ideas, así que la voy a dejar como un análisis de cómo lograr el resultado que estaba buscando. De todas maneras me queda la duda. ¿Existe alguna manera de determinar el tamaño de un arreglo cuyo puntero es devuelto por una función? ¿O de un arreglo arbitrario?

Aquí dejo el código que terminó funcionando, quedando abierto a sus sugerencias y a cualquier error que encuentren (Falta, por ejemplo, devolver valores negativos adecuados a los errores que pueda encontrar).

int filtrar_2(int num_elementos, int* arreglo, int* arreglo_filtrado, int valor)
{
	int num_final = num_elementos;
	if(num_elementos > 0)
	{
		int* filtro = crear_arreglo_cero(num_elementos);
		for(int i = 0; i < num_elementos; i++)
		{
			if(arreglo[i] == valor)
			{
				filtro[i] = 1;
				num_final--;
			}
		}
		arreglo_filtrado = my_realloc(arreglo_filtrado, num_final * sizeof(int));
		int i = 0;
		int j = 0;
		while(i < num_elementos)
		{
			if(filtro[i] == 0)
			{
				arreglo_filtrado[j] = arreglo[i];
				j++;
			}
			i++;
		}
		my_free(filtro);
	}
	return num_final;
}

El código que usé para probarlo es

int main()
{
    printf("Probando ...\n");
	int arr_1[] = {4, 5, 0, 1, 5, 9};
	int* arr_2 = duplica(6, arr_1);
	int test = filtrar_2(6, arr_1, arr_2, 5);
	muestra_arreglo(test, arr_2);
	return 0;
}

Es en esta parte donde me explotó cuando intenté inicializar arr_2 = NULL.

[Tilation]

Y si le sacas un solo 5, pero lo haces muchas veces hasta que no queda ninguno?

[curambar]

Es buena, y se me ocurre una variante a mi implementacion con tu sugerencia. Primero tenes que tener alguna funcion auxiliar (o escribirlo sin funcion, pero con funcion es mas bonito) que devuelva la cantidad de veces que aparece el valor a filtrar. El tamaño resultante es simplemente el tamaño original menos el valor devuelto por esa función. (suponiendo que nada cambie ni explote entre la llamda a la funcion auxiliar y la llamda a la funcion de filtrado)

[martinvilu]

La segunda forma de interpretar la consigna es eliminar todas las instancias del valor en cuestión. En el ejemplo dado, el nuevo arreglo quedaría {4, 0, 1, 9}. Como halló dos instancias del valor dado, el nuevo tamaño es 4, N - 2.

1. Esta es la que hay que implementar, una forma de implementarlo es duplicar el arreglo, e ir desplazando los elementos a la izquierda en cada valor encontrado a borrar.
2. O, con un arreglo del mismo tamaño, vas copiando lo que no coincide con lo que se pide filtrar.

Antes de finalizar, haces un realloc para dejar el arreglo del tamaño correcto.

Igual necesitas un puntero para poder indicar el tamaño del nuevo arreglo.