C++

Inversion lignes de .txt par blocs

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Inversion lignes de .txt par blocs

rattlesnake

Bonjour,
J'aimerais connaître une méthode pour inverser des blocs d'un fichier txt
par exemple :
6
1
1
2
2
3
5
4
4
deviendrait :
5
4
4
2
2
3
6
1
1

Merci d'avance !

Publicité

gilou

Modérateur
Modosaurus Rex

Bon, manifestement tu inverses les premiers et derniers tiers du fichier.
En supposant que ton fichier tienne en mémoire (bref qu'il ne soit pas énorme) j'ai pondu un truc vite fait qui te montre l'idée de base (mais ne marche que si les blocs a échanger sont de même taille):

Code :

#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <system_error>
int main()
{
std::string filename = "data.txt";
try {
// on ouvre le fichier
std::ifstream ifs( filename );
if (!ifs) {
throw std::system_error( ENOENT, std::system_category(), filename );
}
// on lit son contenu dans un vecteur
std::vector<std::string> lines;
lines.reserve(256); // pas de réallocation si moins de 256 lines
for (std::string line; std::getline( ifs, line ); /* */) {
lines.push_back( line );
}
// on calcule la taille des blocs de début et fin faisant 1/3 des lignes
unsigned int bloc_size = lines.size()/3;
// on échange les blocs dans le vecteur
std::swap_ranges( lines.begin(), lines.begin() + bloc_size, lines.end() - bloc_size );
// On affiche le résultat
for ( auto it = lines.begin(); it != lines.end(); ++it ) {
std::cout << *it << std::endl;
}
} catch ( const std::exception & e ) {
std::cerr << "Error : " << e.what() << "." << std::endl;
}
return 0;
}

A compiler en C++11 (utilisation du test (!ifs) par exemple).

Note: si tu dois permuter des blocs d'entiers dans ton code, il serait peut être plus simple de faire un std::vector<unsigned int> et de faire du swap_ranges directement dessus.

A+,

Message édité par gilou le 15-09-2014 à 14:24:17

---------------
There's more than what can be linked! -- Le capitaine qui ne veut pas obéir à la carte finira par obéir aux récifs. -- Il ne faut plus dire Sarkozy, mais Sarkozon -- (╯°□°)╯︵ ┻━┻

rattlesnake

Merci pour ta réponse.
L'entreprise chez qui je travaille en ce moment ne dispose pas de c++11, du coup j'ai essayé de coder l'ensemble de façon bête et méchante. J'arrive à isoler le dernier bloc, mais quand il s'agit de reparcourir le texte pour récupérer l'avant dernier ça ne marche pas, du coup je me retrouve avec des fichiers textes avec uniquement le dernier bloc...
ci dessous le code commenté :

Code :

#include <iostream>
#include <fstream>
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include <sstream>
using namespace std;
int main()
{
ifstream liste("/home/modis/Desktop/Traitement/liste_fichiers_txt.txt", ios::in);//ouverture de la liste de fichiers
if(liste)
{
string lisligne;
string filename0, filename1;
string ligne,of_ligne;
int n_ligne=40701, i=0,j;
double double1, double2, double3, double4, double5, double6;
string s1,s2,s3,s4,s5,s6;
for(j=0;j<185;j++) //185 blocs
{
while(getline(liste, lisligne))
{
liste >> filename0; //lecture du nom du fichier à ouvrir dans un fichier texte avec l'ensemble des noms
filename1 = "/home/modis/Desktop/Traitement/fichiers_invers/" + filename0;
filename0 = "/home/modis/Desktop/Traitement/données_modèles/données_modèles/2011/" + filename0;
ifstream fichier0(filename0.c_str(), ios::in);
ofstream fichier1(filename1.c_str(), ios::out | ios::binary);
if(fichier0 && fichier1)
{
while(getline(fichier0, ligne))
{
ostringstream oss1,oss2,oss3,oss4,oss5,oss6;
if(i==n_ligne-2-220*j) //220 lignes par bloc
{
fichier0 >> double1 >> double2 >> double3 >> double4 >> double5 >> double6;
oss1 << double1;
oss2 << double2;
oss3 << double3;
oss4 << double4;
oss5 << double5; oss6<<double6;
s1 = oss1.str();
s2 = oss2.str();
s3 = oss3.str();
s4 = oss4.str();
s5 = oss5.str();
s6 = oss6.str();
of_ligne= s1 + " " + s2 + " " + s3 + " " + s4 + " " + s5 + " " + s6 + "\n";
fichier1 << of_ligne;//ecriture de la ligne dans le fichier output
//vide les ostringstream
oss1.str("" );
oss2.str("" );
oss3.str("" );
oss4.str("" );
oss5.str("" );
oss6.str("" );
}
else i++;//si je ne suis toujours pas à la ligne voulue
}
}
else
cerr<<"Impossible d'ouvrir le fichier!1"<<endl;
i=0;//remise à zero pour reparcourir le fichier
}
}
}
else
cerr<<"Impossible d'ouvrir le fichier!2"<<endl;
return 0;
}

Je tourne en rond dessus depuis un bon petit moment, j'aimerais juste savoir ce qui empêche de reparcourir le fichier pour prendre un nouveau bloc...
Le but étant d'ouvrir un fichier, de parcourir ses lignes jusqu'à la premiere du bloc voulu, d'écrire ces lignes dans un nouveau fichier. Une fois arrivé à la dernière ligne, on reparcourt le fichier jusqu'à la premiere ligne du bloc au dessus puis on écris la suite etc.
Merci d'avance

Message édité par rattlesnake le 16-09-2014 à 10:52:06

gilou

Modérateur
Modosaurus Rex

Bon, il y a pas mal de problèmes avec ton code et j'aimerais comprendre un peu mieux ce que tu veux faire.
Tu as un fichier avec 185 blocs de 220 lignes (et une ou plusieurs lignes d'en-tête?)
Chaque ligne contient 6 entiers longs (écrits sous format lisible, non binaire).

0) Quelle est la taille de ton fichier de départ?
1) une ou plusieurs lignes d'en-tête à ton fichier?
2) quels blocs permutes tu entre eux?
le i-ième bloc avec le (i+1)-ième bloc [blocs successifs]?
le i-ième bloc avec le (220-i)-ième bloc [blocs symmétriques par rapport au milieu du fichier]?
autre?
3) dans le fichier résultat, les 6 entiers longs sont au même format que dans celui de départ (ie lignes inchangées) ou bien sont ils en binaire?
*) tu utilises quel compilo, avec quelle version, parce que de nos jours, en entreprise, ne pas disposer d'un compilo le supportant, euh... (ce serait C++14, je comprendrais, mais la)

Et sinon, mon source précédent n'était pas bien dur à récrire en C++ archaïque:

Code :

#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <stdexcept> // <system_error> seulement en C++11
int main()
{
const std::string filename("blocs.txt" );
try {
// on ouvre le fichier
std::ifstream ifs( filename.c_str() ); // argument du constructeur en string seulement en C++11
if (ifs.fail()) { // booleen sur stream seulement en C++11
throw std::runtime_error( "No such file or directory: " + filename ); // remplacement vu qu'il y a pas de system_error
}
// on lit son contenu dans un vecteur
std::vector<std::string> lines;
lines.reserve(256); // pas de réallocation si moins de 256 lines
for (std::string line; std::getline( ifs, line ); /* */) {
lines.push_back( line );
}
// on calcule la taille des blocs de début et fin faisant 1/3 des lignes
unsigned int bloc_size = lines.size()/3;
// on échange les blocs dans le vecteur
std::swap_ranges(lines.begin(), lines.begin() + bloc_size, lines.end() - bloc_size);
// On affiche le résultat
for ( std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it ) { // iterateur a type déduit avec auto seulement en C++11
std::cout << *it << std::endl;
}
} catch ( const std::exception & e ) {
std::cerr << "Error : " << e.what() << "." << std::endl;
}
return 0;
}

A+,

Message cité 1 fois
Message édité par gilou le 16-09-2014 à 12:14:43

gilou

Modérateur
Modosaurus Rex

Pour ton pb, si on est bien dans le cas d'une inversion de blocs par rapport au milieu du fichier, voici un point de départ (en supposant que ta machine a assez de mémoire pour lire le fichier dans un vector de string, ce qui devrait être je pense le cas).

Code :

#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <stdexcept>
int main()
{
const std::string filename("blocs.txt" );
const unsigned int bloc_size = 220;
const unsigned int blocs_nb = 185;
try {
// on ouvre le fichier
std::ifstream ifs( filename.c_str() );
if (ifs.fail()) {
throw std::runtime_error( "No such file or directory: " + filename );
}
// on lit son contenu dans un vecteur
std::vector<std::string> lines;
lines.reserve(40701);
for (std::string line; std::getline( ifs, line ); /* */) {
lines.push_back( line );
}
for (unsigned int i = 0; i < (int)(blocs_nb/2); ++i) {
std::swap_ranges(lines.begin() + (i * bloc_size),
lines.begin() + ((i+1) * bloc_size),
lines.end() - ((i+1) * bloc_size));
}
// On affiche le résultat
for ( std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it ) {
std::cout << *it << std::endl;
}
} catch ( const std::exception & e ) {
std::cerr << "Error : " << e.what() << "." << std::endl;
}
return 0;
}

J'ai testé vite fait sur un fichier de 7 blocs de 3 lignes, et ça marchait sans pb.

A+,

Message cité 1 fois
Message édité par gilou le 16-09-2014 à 12:53:42

rattlesnake

gilou a écrit :

Code :

#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <stdexcept> // <system_error> seulement en C++11
int main()
{
const std::string filename("blocs.txt" );
try {
// on ouvre le fichier
std::ifstream ifs( filename.c_str() ); // argument du constructeur en string seulement en C++11
if (ifs.fail()) { // booleen sur stream seulement en C++11
throw std::runtime_error( "No such file or directory: " + filename ); // remplacement vu qu'il y a pas de system_error
}
// on lit son contenu dans un vecteur
std::vector<std::string> lines;
lines.reserve(256); // pas de réallocation si moins de 256 lines
for (std::string line; std::getline( ifs, line ); /* */) {
lines.push_back( line );
}
// on calcule la taille des blocs de début et fin faisant 1/3 des lignes
unsigned int bloc_size = lines.size()/3;
// on échange les blocs dans le vecteur
std::swap_ranges(lines.begin(), lines.begin() + bloc_size, lines.end() - bloc_size);
// On affiche le résultat
for ( std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it ) { // iterateur a type déduit avec auto seulement en C++11
std::cout << *it << std::endl;
}
} catch ( const std::exception & e ) {
std::cerr << "Error : " << e.what() << "." << std::endl;
}
return 0;
}

A+,

0) Mes fichiers font 1.3 Mo environ, 186 blocs de 220 lignes soit 40920 lignes en tout
1) Pas d'en-tête, uniquement des mesures sous formes de 6 doubles par ligne
2) Je ne cherche pas à permuter les blocs par rapport au central mais supposons que j'aie 6 blocs :
1
2
3
4
5
6
Je voudrais que ça devienne
6
5
4
3
2
1
3) Qu'ils soient en binaire serait encore mieux (étant donné que je compte utiliser le nouveau fichier pour le transformer en fichier binaire), mais déjà rien que la permutation serait un gros pas en avant

Merci beaucoup

rattlesnake

gilou a écrit :

Code :

#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <stdexcept>
int main()
{
const std::string filename("blocs.txt" );
const unsigned int bloc_size = 220;
const unsigned int blocs_nb = 185;
try {
// on ouvre le fichier
std::ifstream ifs( filename.c_str() );
if (ifs.fail()) {
throw std::runtime_error( "No such file or directory: " + filename );
}
// on lit son contenu dans un vecteur
std::vector<std::string> lines;
lines.reserve(40701);
for (std::string line; std::getline( ifs, line ); /* */) {
lines.push_back( line );
}
for (unsigned int i = 0; i < (int)(blocs_nb/2); ++i) {
std::swap_ranges(lines.begin() + (i * bloc_size),
lines.begin() + ((i+1) * bloc_size),
lines.end() - ((i+1) * bloc_size));
}
// On affiche le résultat
for ( std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it ) {
std::cout << *it << std::endl;
}
} catch ( const std::exception & e ) {
std::cerr << "Error : " << e.what() << "." << std::endl;
}
return 0;
}

J'ai testé vite fait sur un fichier de 7 blocs de 3 lignes, et ça marchait sans pb.

A+,

Tiens, j'ai bien l'impression que ça marche ça ! je fais quelques essais et je vous tiens tout de suite au jus !!

gilou

Modérateur
Modosaurus Rex

Dans ton cas, il faudrait faire:
const unsigned int blocs_nb = 186;

et ajouter une vérification (a laquelle j'ai pensé après coup)
// on vérifie la cohérence
if (bloc_size * blocs_nb != lines.size() ) {
throw std::logic_error( "Le parametrage par bloc est incoherent avec le nombre de lignes du fichier" );
}

après avoir fait la copie et avant de faire le swap.

A+,

gilou

Modérateur
Modosaurus Rex

Et tu m'as toujours pas dit quel compilo (et sa version) tu utilisais.
A+,

rattlesnake

En tapant g++ -v j'obtiens "gcc version 4.3.2 (Debian 4.3.2-1.1)"

J'ai une dernière petite question !
Les lignes sont de la forme :
12.5 158.3 12.0 15.1 159.2 0.0
Y a-t il moyen de les lire les double séparement (afin de pouvoir les stocker en binaire dans un autre fichier)
lecture façon :

Code :

fichier0 >> double1 >> double2 >> double3 >> double4 >> double5 >> double6;

Merci encore !

Publicité

gilou

Modérateur
Modosaurus Rex

Ah oui, le compilo date de 6 ans. Pour un truc gratuit comme gcc/g++ c'est un peu bête de ne pas avoir une version a jour, car C++11 corrige et améliore un très grand nombre de chose (le constructeur des fstream qui n'accepte pas les std::string comme argument par exemple, c'est horripilant).
A+,

gilou

Modérateur
Modosaurus Rex

Bon déjà, sans rentrer dans les histoires de binaires, ce que tu veux faire devrait ressembler à ceci
(pas testé a 100%, mais a 90%, vu que je n'ai ni tes sources ni tes paths sur ma machine).

Code :

#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <stdexcept>
std::vector<std::string> get_files(const std::string& file)
{
std::ifstream ifs( file.c_str() );
if (ifs.fail()) {
throw std::runtime_error( "Echec a l'ouverture du fichier " + file );
}
std::vector<std::string> filelist;
for (std::string line; std::getline( ifs, line ); ) {
filelist.push_back( line );
}
return filelist;
}
void swap_blocs(const std::string& infile, const std::string& outfile, unsigned int blocs_nb, unsigned int bloc_size)
{
// on ouvre le fichier en entree
std::ifstream ifs( infile.c_str() );
if (ifs.fail()) {
throw std::runtime_error( "No such file or directory: " + infile );
}
// on lit son contenu dans un vecteur
std::vector<std::string> lines;
lines.reserve(40921);
for (std::string line; std::getline( ifs, line ); /* */) {
lines.push_back( line );
}
for (unsigned int i = 0; i < (unsigned int)(blocs_nb/2); ++i) {
std::swap_ranges(lines.begin() + (i * bloc_size),
lines.begin() + ((i+1) * bloc_size),
lines.end() - ((i+1) * bloc_size));
}
// on ouvre le fichier en sortie
std::ofstream ofs( outfile.c_str() );
if (ofs.fail()) {
throw std::runtime_error( "No such file or directory: " + outfile );
}
// on écrit ligne à ligne dedans
for ( std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it ) {
ofs << *it << std::endl;
}
}
int main()
{
// données initiales
const std::string base_dir( "/home/modis/Desktop/Traitement/" );
const std::string in_dir("fichiers_invers/" );
const std::string out_dir("données_modèles/données_modèles/2011/" );
const std::string liste("liste_fichiers_txt.txt" );
const unsigned int bloc_size = 220;
const unsigned int blocs_nb = 186;
try {
std::vector<std::string> filelist = get_files(base_dir + liste);
for ( std::vector<std::string>::iterator it = filelist.begin(); it != filelist.end(); ++it ) {
swap_blocs( base_dir + in_dir + *it, base_dir + out_dir + *it, blocs_nb, bloc_size);
}
} catch ( const std::exception & e ) {
std::cerr << "Erreur : " << e.what() << "." << std::endl;
}
return 0;
}

Toute erreur détectée déclenchera l'arrêt du programme (tu peux coder un autre comportement, fichier de log...)
A+,

Message édité par gilou le 16-09-2014 à 16:16:37

gilou

Modérateur
Modosaurus Rex

Bon, le même modifié pour lire en interne comme des doubles et non du texte, et pour écrire en binaire.
Sans garanties, mais au vu de mes tests, ça devrait être bon.

Code :

#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include <vector>
#include <stdexcept>
std::vector<std::string> get_files(const std::string& file)
{
std::ifstream ifs( file.c_str() );
if (ifs.fail()) {
throw std::runtime_error( "Echec a l'ouverture du fichier " + file );
}
std::vector<std::string> filelist;
for (std::string line; std::getline( ifs, line ); ) {
filelist.push_back( line );
}
return filelist;
}
void swap_blocs(const std::string& infile, const std::string& outfile, unsigned int blocs_nb, unsigned int bloc_size)
{
// on ouvre le fichier en entree
std::ifstream ifs( infile.c_str() );
if (ifs.fail()) {
throw std::runtime_error( "Echec a l'ouverture du fichier " + infile );
}
// on lit son contenu dans un vecteur de vecteur de doubles
std::vector<std::vector<double> > lines;
lines.reserve(40921);
for (std::string line; std::getline( ifs, line ); /* */) {
std::istringstream iss( line );
std::vector<double> numbers;
numbers.reserve( 6 );
// on parse les doubles en input et on les range dans le vecteur
std::copy( std::istream_iterator<double>(iss), std::istream_iterator<double>(), std::back_inserter( numbers ) );
// on range le vecteur dans le vecteur
lines.push_back( numbers );
}
// On procède au swap des blocs
for (unsigned int i = 0; i < (unsigned int)(blocs_nb/2); ++i) {
std::swap_ranges( lines.begin() + (i * bloc_size),
lines.begin() + ((i+1) * bloc_size),
lines.end() - ((i+1) * bloc_size) );
}
// on ouvre le fichier en sortie
std::ofstream ofs;
ofs.open( outfile.c_str(), std::ios::binary );
if (ofs.fail()) {
throw std::runtime_error( "Echec a l'ouverture du fichier " + outfile );
}
for (std::vector<std::vector<double> >::iterator it = lines.begin(); it != lines.end(); ++it) {
for (std::vector<double>::iterator dt = (*it).begin(); dt != (*it).end(); ++dt) {
// on écrit un double en binaire. Note: l'endiannesss dépendra de l'OS
ofs.write( reinterpret_cast<char*>( &(*dt) ), sizeof( double ) );
}
// ?? je ne connais pas ton format cible
ofs << std::endl;
}
}
int main()
{
// données initiales
const std::string base_dir( "/home/modis/Desktop/Traitement/" );
const std::string in_dir("fichiers_invers/" );
const std::string out_dir("données_modèles/données_modèles/2011/" );
const std::string liste("liste_fichiers_txt.txt" );
const unsigned int bloc_size = 220;
const unsigned int blocs_nb = 186;
try {
std::vector<std::string> filelist = get_files(base_dir + liste);
for ( std::vector<std::string>::iterator it = filelist.begin(); it != filelist.end(); ++it ) {
swap_blocs( base_dir + in_dir + *it, base_dir + out_dir + *it, blocs_nb, bloc_size);
}
} catch ( const std::exception & e ) {
std::cerr << "Erreur : " << e.what() << "." << std::endl;
}
return 0;
}

A+,

Message édité par gilou le 16-09-2014 à 19:15:16

FORUM HardWare.fr

Programmation

C++

Inversion lignes de .txt par blocs

Sujets relatifs
[RESOLU] [POWERSHELL] Briser lignes de codes	updater n lignes : combler des trous
Récuperer des lignes dans un ordre précis avec une seule requête	Résumer plusieurs lignes en une seule
Quelle base pour 100 millions de lignes par jour	SQL et les Update multi lignes
supprimer des lignes contenant une valeur donnée	Disposition de blocs : comment faire ça ?
Copie de fichiers video selon lignes tableau Excel	Faire un tri dans un tableau avec un nombre de colonnes et lignes aléa
Plus de sujets relatifs à : Inversion lignes de .txt par blocs

Page générée en 0.224 secondes