copier une valeur d'un fichier à une variable

[invite8b421ec7]

Bonjour,

Comment fait-on pour stocker des données, lues à partir d'un fichier text, vers une matrice. Supposons que j'ai un fichier donnes.txt de la forme suivante:
0 1 2 3
12 5 6
6 7 8
9
11 10

Comment lui demander de copier dans la première ligne à la première case 0, deuxième case 1,..., à la deuxième ligne première case 12 ,etc.

J'ai fais le programme ci-dessous. Pourriez-vous SVP y jetter un coup d'oeil et me le corriger?
Merci.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 10 //number of lines
int main(int argc, char *argv[])
{
	int **matrix;
	matrix=malloc(N * sizeof(int*));
	if(matrix==NULL)
	{
                 printf("Can't allocate memory for matrix\n have to exit!");
                 exit(1);
	}
            for(i=0;i<N;i++)
           {
               matrix[i]=malloc(N * sizeof(int));
 
              if(matrix[i]==NULL)
             {
               printf("Can't allocate memory for matrix\n have to exit!\n");
               exit(1);
            }
        }
       j=0; //compteur column
       int caractereActuel = 0;
       fichier = fopen("test.txt", "r");
       caractereActuel = fgetc(fichier);
       while (caractereActuel != EOF) // On continue tant que fgetc n'a pas     retourné EOF (fin de fichier)
	{
	   for(i=0;i<N;i++)//i : compteur ligne
	   {
 
 
                   matrix[i][j]= caractereActuel;
                   caractereActuel = fgetc(fichier);
                   j++;
	      }
	  }
 
	}
 
             for(i=0;i<N;i++)
	{
	     for(j=i+1;j<N;j++)
	     {
                      printf("%d",matrix[i][j]); // On affiche le caractère stocké dans caractereActuel
 
	      }
	 }
	fclose(fichier);
	for(i=0;i<N;i++)
           {
              free(matrix[i]);
           }
           free(matrix);
           return 0;
     }
}

-----

[invite4492c379]

Hello,

Je suppose que la matrice qui va contenir les données a une taille fixe et qu'elle n'est pas déterminée en fonction des données dans le fichier. Je suppose également que les cellules non renseignées dans le fichier seront des cellules qui vont contenir la valeur 0. Est-ce bien cela ?

Ou au contraire souhaites-tu implémenter une matrice creuse de taille dynamique s'adaptant automatiquement aux nombre de données dans le fichier ?

[invite8b421ec7]

Merci pour votre réponse.
Je suis plutôt dans le deuxième cas.
Voici mon fichier .text
Merci de votre aide.

 Cliquez pour afficher

0 1
0 2
0 3
0 4
0 5
0 6
0 7
0 8
0 9
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
2 3
2 4
2 5
2 6
2 7
2 8
2 9
3 4
3 5
3 6
3 7
3 8
3 9
4 5
4 6
4 7
4 8
4 9
5 6
5 7
5 8
5 9
6 7
6 8
6 9
7 8
7 9
8 9
0 1 2
0 1 3
0 1 4
0 1 5
0 1 6
0 1 7
0 1 8
0 1 9
0 2 3
0 2 4
0 2 5
0 2 6
0 2 7
0 2 8
0 2 9
0 3 4
0 3 5
0 3 6
0 3 7
0 3 8
0 3 9
0 4 5
0 4 6
0 4 7
0 4 8
0 4 9
0 5 6
0 5 7
0 5 8
0 5 9
0 6 7
0 6 8
0 6 9
0 7 8
0 7 9
0 8 9
1 2 3
1 2 4
1 2 5
1 2 6
1 2 7
1 2 8
1 2 9
1 3 4
1 3 5
1 3 6
1 3 7
1 3 8
1 3 9
1 4 5
1 4 6
1 4 7
1 4 8
1 4 9
1 5 6
1 5 7
1 5 8
1 5 9
1 6 7
1 6 8
1 6 9
1 7 8
1 7 9
1 8 9
2 3 4
2 3 5
2 3 6
2 3 7
2 3 8
2 3 9
2 4 5
2 4 6
2 4 7
2 4 8
2 4 9
2 5 6
2 5 7
2 5 8
2 5 9
2 6 7
2 6 8
2 6 9
2 7 8
2 7 9
2 8 9
3 4 5
3 4 6
3 4 7
3 4 8
3 4 9
3 5 6
3 5 7
3 5 8
3 5 9
3 6 7
3 6 8
3 6 9
3 7 8
3 7 9
3 8 9
4 5 6
4 5 7
4 5 8
4 5 9
4 6 7
4 6 8
4 6 9
4 7 8
4 7 9
4 8 9
5 6 7
5 6 8
5 6 9
5 7 8
5 7 9
5 8 9
6 7 8
6 7 9
6 8 9
7 8 9
0 1 2 3
0 1 2 4
0 1 2 5
0 1 2 6
0 1 2 7
0 1 2 8
0 1 2 9
0 1 3 4
0 1 3 5
0 1 3 6
0 1 3 7
0 1 3 8
0 1 3 9
0 1 4 5
0 1 4 6
0 1 4 7
0 1 4 8
0 1 4 9
0 1 5 6
0 1 5 7
0 1 5 8
0 1 5 9
0 1 6 7
0 1 6 8
0 1 6 9
0 1 7 8
0 1 7 9
0 1 8 9
0 2 3 4
0 2 3 5
0 2 3 6
0 2 3 7
0 2 3 8
0 2 3 9
0 2 4 5
0 2 4 6
0 2 4 7
0 2 4 8
0 2 4 9
0 2 5 6
0 2 5 7
0 2 5 8
0 2 5 9
0 2 6 7
0 2 6 8
0 2 6 9
0 2 7 8
0 2 7 9
0 2 8 9
0 3 4 5
0 3 4 6
0 3 4 7
0 3 4 8
0 3 4 9
0 3 5 6
0 3 5 7
0 3 5 8
0 3 5 9
0 3 6 7
0 3 6 8
0 3 6 9
0 3 7 8
0 3 7 9
0 3 8 9
0 4 5 6
0 4 5 7
0 4 5 8
0 4 5 9
0 4 6 7
0 4 6 8
0 4 6 9
0 4 7 8
0 4 7 9
0 4 8 9
0 5 6 7
0 5 6 8
0 5 6 9
0 5 7 8
0 5 7 9
0 5 8 9
0 6 7 8
0 6 7 9
0 6 8 9
0 7 8 9
1 2 3 4
1 2 3 5
1 2 3 6
1 2 3 7
1 2 3 8
1 2 3 9
1 2 4 5
1 2 4 6
1 2 4 7
1 2 4 8
1 2 4 9
1 2 5 6
1 2 5 7
1 2 5 8
1 2 5 9
1 2 6 7
1 2 6 8
1 2 6 9
1 2 7 8
1 2 7 9
1 2 8 9
1 3 4 5
1 3 4 6
1 3 4 7
1 3 4 8
1 3 4 9
1 3 5 6
1 3 5 7
1 3 5 8
1 3 5 9
1 3 6 7
1 3 6 8
1 3 6 9
1 3 7 8
1 3 7 9
1 3 8 9
1 4 5 6
1 4 5 7
1 4 5 8
1 4 5 9
1 4 6 7
1 4 6 8
1 4 6 9
1 4 7 8
1 4 7 9
1 4 8 9
1 5 6 7
1 5 6 8
1 5 6 9
1 5 7 8
1 5 7 9
1 5 8 9
1 6 7 8
1 6 7 9
1 6 8 9
1 7 8 9
2 3 4 5
2 3 4 6
2 3 4 7
2 3 4 8
2 3 4 9
2 3 5 6
2 3 5 7
2 3 5 8
2 3 5 9
2 3 6 7
2 3 6 8
2 3 6 9
2 3 7 8
2 3 7 9
2 3 8 9
2 4 5 6
2 4 5 7
2 4 5 8
2 4 5 9
2 4 6 7
2 4 6 8
2 4 6 9
2 4 7 8
2 4 7 9
2 4 8 9
2 5 6 7
2 5 6 8
2 5 6 9
2 5 7 8
2 5 7 9
2 5 8 9
2 6 7 8
2 6 7 9
2 6 8 9
2 7 8 9
3 4 5 6
3 4 5 7
3 4 5 8
3 4 5 9
3 4 6 7
3 4 6 8
3 4 6 9
3 4 7 8
3 4 7 9
3 4 8 9
3 5 6 7
3 5 6 8
3 5 6 9
3 5 7 8
3 5 7 9
3 5 8 9
3 6 7 8
3 6 7 9
3 6 8 9
3 7 8 9
4 5 6 7
4 5 6 8
4 5 6 9
4 5 7 8
4 5 7 9
4 5 8 9
4 6 7 8
4 6 7 9
4 6 8 9
4 7 8 9
5 6 7 8
5 6 7 9
5 6 8 9
5 7 8 9
6 7 8 9
0 1 2 3 4
0 1 2 3 5
0 1 2 3 6
0 1 2 3 7
0 1 2 3 8
0 1 2 3 9
0 1 2 4 5
0 1 2 4 6
0 1 2 4 7
0 1 2 4 8
0 1 2 4 9
0 1 2 5 6
0 1 2 5 7
0 1 2 5 8
0 1 2 5 9
0 1 2 6 7
0 1 2 6 8
0 1 2 6 9

[invite4492c379]

Merci pour votre réponse.
Je suis dans le deuxième cas.
Voici mon fichier .text
Merci de votre aide.

Dans ce cas, au vu du fichier, le plus simple est d'implémenter une liste de liste, surtout si tu ne connais ni le nombre de lignes ni le nombre de colonnes.
La lecture dans le fichier peut-être un peut fastidieuse aussi :
stocker une ligne entière dans un buffer (char*)
en séparer les nombres avec des strtok/atoi successifs pour créer les noeuds successifs de tes listes

La liste de liste peut éventuellement être implémentée par un tableau dynamique (via malloc/realloc) de listes (il faudra penser à stocker la taille du tableau), voire un tableau dynamique de tableaux dynamiques (attention à bien stocker toutes les tailles de tous les tableaux).

Quel est ton niveau ? Est-ce dans le cadre d'un exercice ?

[A voir en vidéo sur Futura]

[invite4492c379]

Quoique au vu du fichier ... tu cherches toutes les r-combinaisons possibles de 10 éléments ?
Il serait plus simple de les générer lexicographiquement. Il y a des algo très performants pour ça.

[invite8b421ec7]

Merci pour ta réponse.
Je suis novice en C.
Pourrais-tu STP m'expliquer un peu plus les étapes de la méthode d'utilisation d'un tableau dynamique à 2D et comment allouer et reallouer de l'espace mémoire? Merci.

[invite4492c379]

Ton fichier c'est un exemple bidon ou le fichier que tu dois lire ?

[invite8b421ec7]

Quoique au vu du fichier ... tu cherches toutes les r-combinaisons possibles de 10 éléments ?
Il serait plus simple de les générer lexicographiquement. Il y a des algo très performants pour ça.

Exactement. J'ai énumérer toutes les combinaisons possibles de 10 éléments à l'aide d'un algorithme récursif et je les stocker dans un fichier. Maintenant je souhaite les cpier dans une matrice pour pouvoir effectuer quelques opérations.
Si vous auriez une idée meilleure, je suis preuneuse.
Merci

[invite4492c379]

Ça dépend des opérations, que veux-tu en faire ?

[invite8b421ec7]

Ton fichier c'est un exemple bidon ou le fichier que tu dois lire ?

C'est le bon fichier.

[invite8b421ec7]

Ça dépend des opérations, que veux-tu en faire ?

Des sommes des valeurs d'une ligne, comparaisons entre les valeurs etc

[invite4492c379]

Si je comprends bien, tu génères toutes les r-combinaisons possibles, tu les écris dans un fichier (au format texte) pour finalement remplir un tableau ?
Pourquoi passer par un fichier ? pourquoi ne pas remplir directement le tableau ?

[invite8b421ec7]

Si je comprends bien, tu génères toutes les r-combinaisons possibles, tu les écrits dans un fichier (au format texte) pour finalement remplir un tableau ?
Pourquoi passer par un fichier ? pourquoi ne pas remplir directement le tableau ?

Ceci dit je ne sais pas à quelle moment il faut le faire.
Voici mon algorithme qui calcule les k combinaisons.
Merci de votre aide.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 10 //number of elements
void combinaisons(FILE *fichier, int n, int p, int k, int *L, int *t, int r)
{
	int i, j, j1;
	int *t2 = malloc(n*sizeof(int)); 
	if(r<p-k) return;
	if(k==p)
	{
		for(i=0;i<p;i++)
		{
//			printf("%d ", L[i] );
			fprintf(fichier, "%d ",L[i]);
		}
//		printf("\n");
		fprintf(fichier, "\n"); 
		return;
	}

	for(i=0;i<r;i++)
	{
		L[k] = t[i];
		for(j=i+1, j1=0;j<r;j++, j1++)
		{
			t2[j1] = t[j];
		}
		combinaisons(fichier, n, p, k+1, L, t2, j1);
	}
	free(t2); 
}



int main(int argc, char *argv[])
{
//	int n = 5, p = 2;
//	int L[5], t[5], i;
	int L[N], t[N], i,j,p;
	FILE *fichier;

	for(i=0;i<N;i++)
		t[i] = i;

	fichier=fopen("Combinations.txt","w");
	if(fichier==NULL)
	{
		printf("Failed to open  Combinations file, quitting!\n");
		exit(1);
	}
	for(p=2;p<N;p++)
	combinaisons(fichier, N, p, 0, L, t, N);

	fclose(fichier);
	
	return 0;
}

[invite4492c379]

Re-,

Bon, dans ton énumération tu commences avec les combinaisons de longueur 2, tu skippes celles de longueur 1 et 0. Ton tableau va donc contenir 2^N-N-1 lignes, la plus grandes de ces lignes va contenir N nombres. Dans un premier temps nous allons partir sur l'utilisation d'un tableau plein de 2^N-N-1 lignes et N+1 colonnes. Pourquoi N+1 colonnes ? Simplement car la première colonne va contenir le nombre de nombres utilisés par la combinaison.
Cette solution est inutilisable pour de grandes valeurs de N, en effet un entier étant généralement codé sur 4 octets le tableau prendra 4*(2^N-N-1)(N+1) octets en mémoire. Pour N=10 on obtient 44 kO (on va dire raisonnable), pour N=20 on obtient 84 MO (on va dire plutôt gros), pour N=30 124 GO (carrément impraticable).

Maintenant comment faire ? Ça reste simple, mais on ne va pas faire propre pour modifier ton code un minimum.
On commence par déclarer un tableau en variable globale :

int Comb[(1<<N)-N-1][N+1];

1<<N est un «raccourci» pour calculer 2^N en entier.

Au lieu d'écrire p entiers dans le fichier :

  for(i=0;i<p;i++)
  {
//   printf("%d ", L[i] );
   fprintf(fichier, "%d ",L[i]);
  }

on va écrire à la bonne ligne dans le tableau l'entier p dans la case 0, puis toujours avec un boucle les p entier dans les cases 1 à p+1. Mais comment savoir à quelle ligne écrire ? On va de nouveau faire sale. On va déclarer une variable globale i_Comb que l'on initialise directement à 0 :

int i_Comb=0;

ta boucle va se transformer en :

  // on écrit à la ligne i_Comb du tableau Comb
  // la première case contient le nombre d'éléments de la combinaison
  Comb[i_Comb][0]=p
  for(i=0;i<p;i++)
  {
  // Avant : 
  //printf("%d ", L[i] );
  //fprintf(fichier, "%d ",L[i]);
  // Après :
  // On écrit dans la case i+1 l'élément de la combinaison :
    Comb[i_Comb][i+1]=L[i];
  }
  // On a tout écrit, il ne faut pas oublier d'incrémenter i_Comb pour la prochaine écriture
  i_Comb=i_Comb+1;

à la fin i_Comb contiendra le nombre de lignes du tableau Comb.

Pour l'afficher tu pourras l'utiliser ainsi :

  for(i=0;i<i_Comb;i++) {
    for(j=1;j<=Comb[i][0];j++)
      printf("%d ", Comb[i][j]);
    printf("\n");
  }

ATTENTION : Ce code n'est pas propre (au sens usuel du terme), et je ne l'ai pas testé.

Si tu en as envie on pourra le rendre un peu plus propre, voire carrément l'améliorer surtout si tu peux m'expliquer ce que tu comptes en faire.


REMARQUE : Une technique de sioux (à n'employer que dans des circonstances exceptionnelles)

tu aurais pu commencer par écrire un header dans ton fichier :

int Comb[][]={

ensuite au lieu de faire un printf pour y écrire par exemple

0 1 2 3

plutôt y écrire

{4, 0, 1, 2, 3},

tout à la fin tu y écris

};

pour obtenir un fichier que tu aurais pu compiler ... tu aurais généré du code (un programme qui écrit un programme).