comment stocker jusqu’à 1 000 000 000 d’éléments

#include #include #include int max_b(int,int); int max(int[],int); int main(){ int num_tests; scanf("%d",&num_tests); int array_n[num_tests]; int array_b[num_tests]; int i,j; for (i=0;i<num_tests;i++){ scanf("%d %d",&array_n[i],&array_b[i]); } for (j=0;j<num_tests;j++){ int A = 1; int N = array_n[j]; int B = array_b[j]; int max_num_b; max_num_b = max_b(N,B); int array2[max_num_b]; int k; for (k=0;k<max_num_b;k++){ int num_a,num_b; num_a = N-(k+1)*B; num_b = k+1; array2[k] = num_a*num_b; } printf("%d\n",max(array2,max_num_b)); } } int max(int array[],int a){ int max_num = 0,i; for (i=0;i max_num){ max_num = array[i]; } } return max_num; } int max_b(int n,int b){ return n/b; } 

Ma première entrée est num nombre de cas de test T (disons 1), et la deuxième entrée est 1 000 000 000 1. Alors, le code essaie de former un tableau de taille 10 ^ 9 et le programme finit par montrer une erreur de segmentation. Cependant, le code fonctionne bien jusqu’à 1.000.000 1. Comment puis-je stocker jusqu’à 10 ^ 9 éléments. Si ce n’est pas possible, comment puis-je stocker autant de nombres. Devrais-je utiliser malloc, si oui, alors comment. Toute aide serait appréciée.

    Vous n’avez pas besoin de stocker ces données du tout. Il suffit de le traiter à la volée.

    Autant que je sache, le code suivant produit les mêmes résultats que le code que vous avez publié, mais n’utilise aucun tableau.

     #include  int main() { int k, t, N, B, max, num_tests; scanf("%d", &num_tests); while (num_tests--) { scanf("%d %d", &N, &B); for (k=N/B,max=0; k>0; k--) { t = (Nk*B) * k; if (t > max) max = t; } printf("%d\n", max); } return 0; } 

    Pour un milliard d’ int dans deux baies, vous aurez besoin de près de 8 Go de stockage, en supposant que vous ayez des int 32 bits.

    C’est une quantité de mémoire vraiment énorme et votre meilleur pari avec la fonction standard C est de les demander via malloc() – si votre espace d’adressage est assez grand (sur i386 , il serait trop petit, mais sur amd64 , tout amd64 bien. ) et si le système peut fournir autant de mémoire, les éléments suivants devraient fonctionner:

     int main(){ unsigned long num_tests; scanf("%lu",&num_tests); int *array_n = malloc((size_t)num_tests * sizeof(*array)); if (!array_n) { fputs("couldn't allocate array_n\n", stderr); return 1; } int *array_b = malloc((size_t)num_tests * sizeof(*array)); if (!array_b) { fputs("couldn't allocate array_b\n", stderr); free(array_n); return 1; } size_t i,j; for (i=0;i 

    Remarque J'ai modifié le scanf() pour lire un unsigned long , juste pour être sûr. Ce n'est toujours pas à l'épreuve des balles, cependant.

    Vous ne devez PAS utiliser de déclarations de tableau de longueur variable lorsque la taille est déterminée au moment de l’exécution.

    Je vous suggère d’utiliser malloc() place. Remplace les lignes suivantes

     int num_tests; scanf("%d",&num_tests); int array_n[num_tests]; int array_b[num_tests]; 

    Avec

     int num_tests, *array_n, *array_b; scanf("%d", &num_tests); array_n = malloc(num_tests * sizeof(int)); if (array_n == NULL) { printf("Memory allocation error for array_n!\n"); return -1; } array_b = malloc(num_tests * sizeof(int)); if (array_b == NULL) { /* cleanup */ free(array_n); printf("Memory allocation error for array_b!\n"); return -1; } 

    Comme d’autres commentaires l’ont souligné, un million d’éléments ont besoin d’environ 4 Go de mémoire (le double étant donné que vous avez deux baies). Donc, vous risquez de manquer de mémoire en allouant autant d’entiers.

    Tout d’abord, lorsque vous initialisez un tableau, la taille doit être constante. Donc, utilisez #define NUM_TESTS 1000000000 place. Deuxièmement, comme une taille d’entiers est de 4 octets, 10 ^ 9 entiers auraient besoin de 4 000 000 000 B, ce qui équivaut à 4 Go. Et c’est assez “dur” à 4 Go sur la stack. Vous devez utiliser des fichiers ou, si toutes vos valeurs sont inférieures à 256, vous pouvez utiliser des caractères. C’est toujours 1 Go, mais c’est beaucoup plus facile à obtenir.