Elimine los duplicados de la matriz y guárdelos en otro [duplicado]

Question

Se me ha asignado la tarea de crear una matriz sin valores duplicados de otra matriz existente. Así que lo hice, pero quiero saber si hay alguna otra forma mejor de hacerlo.

Ejemplo de entrada / salida

Input: 1, 15, 1, 5, 1, 3

Output: 1, 15, 5, 3

Mi código

#include <stdio.h>

int main(void) {
  const int ARRAY_SIZE = 5;

  int m[ARRAY_SIZE], p[ARRAY_SIZE];


  for(int i = 0; i < ARRAY_SIZE; i++) {
    printf("Enter number: ");
    scanf("%d",&m[i]);
  }
  // k variable is used to be the new indexing of the array p;
  int k = 0;

  // if it has a duplication dup is changed to 1;
  int dup = 0;
  
  // Loops through the array.
  for(int i =0; i < ARRAY_SIZE; i++) {
    for(int j = i +1; j <ARRAY_SIZE ; j++) {
        if(m[i] == m[j]) {
            dup = 1;
            break;
        }
    }
    if(dup != 1) {
      p[k++] = m[i];
    }
    dup = 0;
  }

  printf("The array without repeated values\n");

  for(int i = 0; i < k; i++) {
    printf("%d\n",p[i]);
  }

  return 0;
}

Quiero algunas sugerencias.

Gracias por adelantado. :)

Answer 1

Si la entrada realmente tiene comas entre los números, entonces queremos permitir eso aquí:

scanf("%d",&m[i]);

En cualquier caso, es importante verificar el valor de retorno de scanf(), de lo contrario, podríamos estar usando valores que no se han inicializado correctamente.

Probablemente valga la pena escribir funciones separadas para la entrada, la salida y el procesamiento, y luego tener una simple main()que vincule las tres.

Answer 2

Se puede evitar un indicador "dup" reorganizando el bucle interior. Aquí hay una versión compacta, de alguna manera un poco al revés para que podamos hacer lo nuestro p[k++]=bien en el acto:

    for (int i = 0; i < ARRAY_SIZE; i++) {

        for (int j = i + 1; m[i] != m[j]; j++) { /*NO! m[i+1] will be illegal */

            if (j == ARRAY_SIZE) {
                p[k++] = m[i];        // copy this one, next "i" please
                break;
            }
        }
    }

Para mayor claridad, casi prefiero esto como el bucle interno:

     for (int j = i + 1;; j++) {

          if (j == ARRAY_SIZE) {
              p[k++] = m[i];        // copy this one, next please
              break;
          }
          if (m[i] == m[j])
              break;               // skip, next 
     }

Esto es más simétrico; puede comparar fácilmente las dos condiciones de salida para este ciclo eterno (sin expresión intermedia).

Es importante verificar primero si jha alcanzado ARRAY_SIZE, y solo luego usarlo en m[j].

---

Para una matriz como 120000000...000012, creo que sería más rápido buscar en la matriz nueva y única ... pero sí, es por eso que la clasificación es un primer paso útil (y principal).

---

La primera versión (compacta) es incluso incorrecta . m[j]ya será ilegal para el último elemento.

for (int j = i + 1; m[i] != m[j];...