[C++] Scomporre un unico file in 5 file distinti

[freetom]

Ho un unico file estrazioni.txt contentente righe del tipo:

40,63,18,5,27
30,19,33,28,52
57,64,54,32,6
81,83,7,9,67
39,90,21,12,89
66,47,29,78,89
55,57,78,66,50
3,1,17,85,8
84,68,70,5,71
5,27,73,75,85

vorrei per ogni elemento separato da virgola creare un rispettivo file txt in modo che ogni virgola "colonna" mi identifichi appunto un nuovo file...

es:

la prima virgola dovrebbe creare...
colonna1.txt contenente:

40
30
57
81
ecc...

colonna2.txt contenente:

63
19
64
83
ecc...

e così via fino a
colonna5.txt contenente:

27
52
6

ecc...

Per ulteriori eventuali chiarimenti son qua
grazie del vostro aiuto

[lolide]

Si ormai il tuo programma lo conosciamo a memoria

Come vuoi fare ... prima leggi ogni linea del file con getline, poi per ogni std::string contenente la riga del file, con una combinazione di std::string::find e std::string::substr splitti man mano la stringa e memorizzi i token nei file (anche se in quest'occasione secondo me sarebbe più comodo uno strtok(), ma se vuoi rimanere sul C++ ....).

[shodan]

Per ulteriori eventuali chiarimenti son qua

Ma questo file, che specifiche ha? Contiene sempre e solo cinquine? E' obbligatorio che sia un file di testo o può anche essere un file binario?

E soprattutto: hai mai azzeccato una combinazione?

[freetom]

Originariamente inviato da shodan
Ma questo file, che specifiche ha? Contiene sempre e solo cinquine? E' obbligatorio che sia un file di testo o può anche essere un file binario?

E soprattutto: hai mai azzeccato una combinazione?

Ma questo file, che specifiche ha?
[E' un semplicissimo file di testo .txt]

Contiene sempre e solo cinquine?
[si sono le estrazioni passate]

E' obbligatorio che sia un file di testo o può anche essere un file binario?
[e' obbligatorio che sia un file di testo]

E soprattutto: hai mai azzeccato una combinazione?
[per adesso... solo... estratti, ambi, ambi in terzina, in quartina e in lunghetta e 1 terno in quartina e uno in cinquina]

Ciao e grazie per il tuo aiuto! Se vuoi poi in cambio ti do qualche numero da provare...

[shodan]

Originariamente inviato da freetom
[e' obbligatorio che sia un file di testo]

Questo taglia la testa al toro.
Se poteva essere un file binario, ti risparmiavi tanti grattacapi sulla gestione del file e dei valori contenuti.

[freetom]

Originariamente inviato da shodan
Questo taglia la testa al toro.
Se poteva essere un file binario, ti risparmiavi tanti grattacapi sulla gestione del file e dei valori contenuti.

Non essere così sibillino...

Esattamente cosa intendi per binario?

se intendi stesso contenuto e diversa estensione...

si non è obbligatorio...

se intendi composto di 0 e 1... non saprei come trasformare il file di testo in quello binario...

Comunque se per ottenere quello che vorrei devi passare dalla forma binaria... fai pure

grazie

[shodan]

Un file di testo contiene qualcosa che per un essere umano è intelleggibile: di solito lettere e numeri; un file binario è tutto il resto (di cui il file di testo è un insieme di grosso modo 70 caratteri).

(*)Se hai l'obbligo (o necessità) che il file sia sempre intelleggibile (da te o da altri), non c'è molto da fare.

Se invece non è necessario (o si può eventualmente rimandare in altro momento), puoi usare un file binario per memorizzare i dati.
Le precondizioni sono (in sostanza):
1) avere sempre cinquine ( o anche inferiori tipo quaterne etc.)
2) che i numeri non superino il 90.
Dato che si parla di lotto, direi che sono verificate.

In soldoni la mia idea si basa nell'impacchettare i cinque dari in una struttura e scriverla in modo binario nel file. In questo modo ti eviti di parserizzare le varie linee, cercando vari "\n", virgole e in generale di perdere tempo nella ricerca nel file.
Essendo i numeri inferiori a 90 i dati si possono memorizzare tranquillamente in tipi char (per risparmiare spazio).

Un esempio molto grezzo che spero renda l'idea.

// Struttura di memorizzazione.
struct estrazione {
    char primo_estratto;
    char secondo_estratto;
    char terzo_estratto;
    char quarto_estratto;
    char quinto_estratto;
};

// calcoli vari delle combinazioni
vector<estrazione> combinazioni;
...
// N dev'essere un valore valido ovviamente.
combinazioni[N].primo_estratto = 10;
combinazioni[N].secondo_estratto = 20;
combinazioni[N].terzo_estratto = 30;
combinazioni[N].quarto_estratto = 40;
combinazioni[N].quinto_estratto = 50;

// scrittura di tutte le combinazioni in un file.
file.write(reinterpret_cast<const char*>(&combinazioni[0]),combinazioni.size()*sizeof(estrazione));

// scrittura di una singola combinazione in un file
file.write(reinterpret_cast<const char*>(combinazioni[N]),sizeof(estrazione));

// ricerca della N riga 
file.seekg( N*sizeof(estrazione), ios::beg);

// lettura della N riga.
estrazione estr.
file.read(reinterpret_cast<char*>(&estr),sizeof(estrazione));
// eventuali rielaborazioni.
...
// output. Il cast a int serve per mostrare il numero e non il carattere corrispondente.
cout << (int) estr.primo_estratto << endl;
cout << (int) estr.secondo_estratto << endl;
cout << (int) estr.terzo_estratto << endl;
cout << (int) estr.quarto_estratto << endl;
cout << (int) estr.quinto_estratto << endl;

(*) Ovviamente se non è vera la precondizione segnata.

[freetom]

non è necessario avere sempre in forma intellegibile i dati (o si può eventualmente rimandare in altro momento), si puo' dunque usare un file binario per memorizzare i dati.

Però il problema principale al momento e' semplicemente come ho scritto a inizio post quello di "scomporre" ogni riga in 5 file "colonna";

In sostanza se sai come basta "scomporre" questo piccolo esempio in 5 rispettivi file in base ai 5 valori che appaiono in ogni riga separati ognuno da virgole...


40,63,18,5,27
30,19,33,28,52
57,64,54,32,6
81,83,7,9,67
39,90,21,12,89
66,47,29,78,89
55,57,78,66,50
3,1,17,85,8
84,68,70,5,71
5,27,73,75,85

Non credo che per questo piccolo esempio o le 500 righe che mi servono si debba binarizzare il tutto ma se questo è necessario.. ben venga

a me per adesso basterebbe avere file1.txt con il seguente contenuto...

40
30
57
81
39
66
55
3
84
5

che corrisponde appunto a tutti i ptimi estratti...

file2.txt con tutti i secondi estratti...

ecc...

fino all'ultimo file5 .txt con tutti i quinti estratti...

[shodan]

Non credo che per questo piccolo esempio o le 500 righe che mi servono si debba binarizzare il tutto ma se questo è necessario.. ben venga

Tempo fa (se non ricordo male) dicevi di avere un file enorme di questi dati. Il mio era solo un suggerimento per gestitlo meglio.
Per il tuo problema specifico esistono almeno due modi in C++.
Il primo è usare uno stringstream:

stringstream little_parser(line_of_numbers);
int num1;
int num2;
int num3;
int num4;
int num5;
char c; // per estrarre la virgola.
little_parser >> num1 >> c >> num2 >> c >> num3 >> c >> num4 >> c >> num5;

Il secondo è usare (come è stato suggerito) le funzioni base di std::string (la find_last_of() in questo caso), estrarre la sottostringa e convertirla in numero.

[freetom]

Originariamente inviato da shodan
Tempo fa (se non ricordo male) dicevi di avere un file enorme di questi dati. Il mio era solo un suggerimento per gestitlo meglio.
Per il tuo problema specifico esistono almeno due modi in C++.
Il primo è usare uno stringstream:

stringstream little_parser(line_of_numbers);
int num1;
int num2;
int num3;
int num4;
int num5;
char c; // per estrarre la virgola.
little_parser >> num1 >> c >> num2 >> c >> num3 >> c >> num4 >> c >> num5;

Il secondo è usare (come è stato suggerito) le funzioni base di std::string (la find_last_of() in questo caso), estrarre la sottostringa e convertirla in numero.

Questo è il tentativo della sua implementazione nel mio cod ma...

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

#define LINEE 500

int main()
{

//APRI IL FILE E LEGGI SOLO LE PRIME 18 RIGHE...

string line;



ifstream testo;
ofstream fout;
fout.open("PRIME-500-RIGHE.txt", ios::app);

testo.open("ESTRAZIONI-BARI-ULTIME-515.txt");

if (testo.is_open())
{cout << "Le VOLUTE righe scelte:\n\n";
for (int i=0;i<500;i++)
{
getline (testo,line);
cout << line << endl;

  //scrivo su file...
  
    string datiscelti= line;
    
//stringstream little_parser(line_of_numbers);

stringstream little_parser(line);

int num1;
int num2;
int num3;
int num4;
int num5;

char c; // per estrarre la virgola.

little_parser >> num1 >> c >> num2 >> c >> num3 >> c >> num4 >> c >> num5;

    
fout << datiscelti;
	//fout << "";
	fout << "\n";

//----------------------------------------------------------
}

}

}

ma...

mi da sempre questo errore:

prova-split-5-files-1-ESTRAPOLA-PRIME-500-RIGHE-NO-STOP-OK.cpp In function `int main()':

e...

questo:

prova-split-5-files-1-ESTRAPOLA-PRIME-500-RIGHE-NO-STOP-OK.cpp variable `std::stringstream little_parser' has initializer but incomplete type