Trova il numero intero solitario in un array

Question

Per favore fai riferimento alla sfida di hackerrank this se puoi.

Il problema è trovare il numero intero solo in un array, dato che un array consiste di sole coppie tranne un solo numero intero.

Il problema è con questo test

9 
4 9 95 93 57 4 57 93 9 

9 è dimensione dell'array e sotto è la matrice

Vedere la parte di codice evidenziato da // ------

Se metto scanf ("% d", & n) sopra il codice arr arr nn funziona bene, ma dà risultati orribili al contrario. Si prega di darmi una mano

#include <stdio.h> 

int lonely_integer(int* a, int size); 

int main(){ 
    //n is size of array, i is counter variable 
    int n, i, result; 
    // --------------------- 
    int arr[n]; 
    scanf("%d", &n); 
    // --------------------- 
    printf("%d\n", n); 
    for(i = 0; i < n; i++){ 
     scanf("%d", &arr[i]); 
    } 
    result = lonely_integer(arr, n); 
    printf("%d", result); 
    return 0; 
} 


int lonely_integer(int* a, int size){ 
    int i; 
    int res = 0; 
    for(i = 0; i < size; i++){ 
     res = res^a[i]; 
    } 

    return res; 
} 

Answer 1

Che ci si vuole utilizzare:

#include <stdlib.h> 
/* ... */ 
int *arr; 
scanf("%d", &n); 
arr = malloc(sizeof(int) * n); 

In questo modo, arr ottiene allocata dinamicamente in fase di esecuzione, in modo che possa essere di qualsiasi dimensione a seconda dell'ingresso n.

Cosa si erano originariamente facendo (ad esempio dichiarando arr[n] dopo aver ricevuto n via scanf: scanf("%d", &n); int arr[n];) non è una buona idea perché si avvale di Array lunghezza variabile, una caratteristica di C che non è obbligatorio nel più recente C standard.

Vedete, arr viene creato al momento della compilazione, e si normalmente può solo inizializzare con un'espressione costante noto al momento della compilazione, che n, una variabile ricevuto come input dell'utente, ovviamente, non è. Gli array a lunghezza variabile sono una caratteristica del linguaggio che fondamentalmente consente di ignorare questa regola, cioè ti rendono in grado di inizializzare una matrice su una lunghezza non nota in fase di compilazione. Questo è stato standardizzato in C99, ma è stato elencato come "facoltativo" a partire da C11.

Cosa hai fatto dopo che (int arr[n]; scanf("%d", &n);) è del tutto illogica, perché, bene, si dichiara arr come un array di interi nprima si riceve il valore di n come input dell'utente, e, beh, conosco il suo valore. Stampa materiale privo di causa n è originariamente inizializzato ad un valore non specificato "spazzatura", e questo è ciò che la dimensione del VLA diventa quando si dichiara che:

int arr[n]; //n is garbage at this point, you have no idea how large arr will be! 
scanf("%d", &n); //you got the value of n that you needed, but too late, alas! 

Answer 2

gamma di n è dato in questione è 1 <= N < 100 che è piccolo e un variable length array può essere utilizzato.Ma si sta facendo male qui

int arr[n]; // n is uninitialized. Its value is indeterminate. 
scanf("%d", &n); 

È necessario inizializzare n prima di utilizzarla come dimensione della matrice

scanf("%d", &n); 
int arr[n]; 

Answer 3

Assegnazione di matrice con una variabile non inizializzata, porterà ad un comportamento indefinito e il compilatore lancerà un avvertimento "variabile utilizzata non inizializzata in questa funzione"

Se hai trovato la dimensione della matrice in fase di esecuzione, sarebbe saggio usare allocazione dinamica della memoria, come @ Mints97 postato

int data_size; 
int *data_array; 
scanf("%d", &data_size); 
data_array = (int*)calloc(data_size,sizeof(int)); 
/* 
. 
*/ 
// Free the memory at the end 
free(data_array); 
data_array = NULL; 

Se si desidera impostare dimensione della matrice al momento della compilazione, è possibile definire una macro

#define DATA_SIZE 9 

o impostare la macro durante la compilazione del codice

gcc test.c -o test -DDATA_SIZE=9 -Wall 

Answer 4

Valore della 'n' deve essere definito prima che sia utilizzato.come si utilizza

int arr [n];

prima di leggere il valore di "n". Quindi il compilatore non saprà, quanti numeri di elementi sono presenti nell'array 'n' può essere un valore spazzatura.quanta quantità di memoria dovrebbe allocare a un array.

quindi devi leggere il valore di 'n' prima di usarlo come definizione di array.