// Dídac Comes Salas // Usuari u1988980 // Pràctica 2 #include "Solucio.h" #include…
- User
// Dídac Comes Salas // Usuari u1988980 // Pràctica 2 #include "Solucio.h" #include "Candidats.h" #include #include #include #include #include #include using namespace std;
Solucio::Solucio(){ niv = 0; linies = 0; suma = 0; sumaImport = 0; sumaLinies = 0; }
Solucio::Solucio(const vector &a_anys, const vector &a_ingresDespesa, const vector &a_codi, const vector &a_import, unsigned int a_any, long long a_imp, int a_aud, bool a_tipus, bool a_capitol){ assignacions.resize(50); sumaImp.resize(50); anys = a_anys; ingresDespesa = a_ingresDespesa; codi = a_codi; import = a_import; tipus = a_tipus; capitol = a_capitol; any = a_any; imp = a_imp; maxCan = a_aud; niv = 0; linies = 0; suma = 0; sumaImport = 0; sumaLinies = 0; while(any != anys[linies] and not acabada()){ linies++; } }
Candidats Solucio::inicialitzarCandidats() const{ return Candidats(maxCan + 1); }
bool Solucio::acceptable(const Candidats &iCan) const{ bool acceptable = false;
if(imp >= (sumaImp[iCan.actual()] + import[linies])/100 and any == anys[linies]) acceptable = true; if(sumaImp[iCan.actual()] != 0){ if(tipus){ char id = ingresDespesa[linies]; char ID = assignacions[iCan.actual()].begin()->first; if(id != ID) acceptable = false; } if(capitol){ char id = assignacions[iCan.actual()].begin()->first; int codiCap = stoi(codi[linies]) / 1000000; int codiCapitol = stoi(assignacions[iCan.actual()].at(id).front().first) / 1000000; if(codiCap != codiCapitol) acceptable = false; } } return acceptable;}
bool Solucio::importSuperior(const Candidats &iCan) const{ return imp < (sumaImp[iCan.actual()] + import[linies])/100; }
bool Solucio::anyDiferent() const{ return any != anys[linies]; }
bool Solucio::acabada() const{ return linies == codi.size(); }
void Solucio::anotar(const Candidats& iCan){ char id = ingresDespesa[linies]; string codiCap = codi[linies]; long long importCap = import[linies]; int pos = iCan.actual(); assignacions[pos][id].emplace_back(codiCap, importCap); sumaImp[iCan.actual()] += importCap; niv++; sumaImport += import[linies]; sumaLinies++; linies++; while(any != anys[linies] and not acabada()){ linies++; }
if(maxCan == iCan.actual() and codi.size() > (linies + 1)) maxCan++;}
void Solucio::desanotar(const Candidats& iCan) { if (not assignacions.empty() and iCan.actual() < assignacions.size()) { if (not assignacions[iCan.actual()].empty()) { niv--; linies--; char id = ingresDespesa[linies]; assignacions[iCan.actual()][id].pop_back(); sumaImp[iCan.actual()] -= import[linies]; sumaImport -= import[linies];
cout << maxCan << " - " << iCan.actual() << endl; if(maxCan == iCan.actual() and maxCan > 0){ maxCan--; } } }}
void Solucio::numAuditors(const Candidats &iCan){ if(iCan.actual() > maxCan) maxCan = iCan.actual(); }
bool Solucio::potSerMillor(const Solucio& opt, const Candidats &iCan) const{ if(not assignacions.empty() and opt.maxCan > 0){ if(maxCan == opt.maxCan){ long long carregaIdeal = 0.0; for(int i = 0; i < import.size(); i++) carregaIdeal += import[i]; carregaIdeal /= (maxCan + 1);
long long desv = 0.0; for(int i = 0; i < maxCan + 1; i++){ desv += max(0LL, sumaImp[i] - carregaIdeal); } desv = static_cast<double>(desv)/100; return desv < opt.desviacio(opt.sumaImp); } else{ return maxCan < opt.maxCan; } } else{ return true; }}
bool Solucio::esMillor(const Solucio& opt) const{ if(opt.assignacions.empty()) return true; else{ double desvAct = desviacio(sumaImp); double desvOpt = opt.desviacio(sumaImp);
return desvAct < desvOpt; }}
double Solucio::desviacio(vector sumaImp) const { double sumaTotal = 0.0; double sumaQuadrats = 0.0;
for (int i = 0; i < maxCan + 1; i++) { sumaTotal += sumaImp[i]; } sumaTotal = static_cast<double>(sumaTotal)/100; double impMitja = sumaTotal / (maxCan + 1); for (int i = 0; i < maxCan + 1; i++) { sumaQuadrats += pow((static_cast<double>(sumaImp[i])/100) - impMitja, 2); } double resultat = sqrt(sumaQuadrats / (maxCan + 1)); return resultat;}
void Solucio::primeraLinia() const{ long long total = 0; cout << endl;
if(niv != 0){ cout << niv << " linies (" << niv << ") llegides amb un import total de: "; for(int i = 0; i < sumaImp.size(); i++) total += sumaImp[i]; } else{ cout << sumaLinies << " linies (" << sumaLinies << ") llegides amb un import total de: "; total = sumaImport; } double impTotal = static_cast<double>(total)/100; cout << fixed << setprecision(2) << impTotal << " euros" << endl << endl;}
void Solucio::mostrar_solucio() const{ for(int i = 0; i < maxCan + 1; i++){ double impTotal = static_cast(sumaImp[i])/100; cout << "*********************************" << endl; cout << " Auditor " << i+1 << setw(15) << fixed << setprecision(2) << impTotal << " euros " << endl; cout << " ------------------------------ *" << endl;
for(auto it_imp = assignacions[i].begin(); it_imp != assignacions[i].end(); ++it_imp){ for (const auto &pair : it_imp->second) { double impAu = static_cast<double>(pair.second) / 100; cout << "* " << it_imp->first << pair.first << ":" << setw(15) << fixed << setprecision(2) << impAu << " euros *" << endl; } } cout << "**********************************" << endl; } cout << endl; long long total = 0; for(int i = 0; i < sumaImp.size(); i++) total += sumaImp[i]; double impTotal = static_cast<double>(total)/100; cout << "Total:" << setw(20) << impTotal << endl; cout << "Auditors: " << setw(6) << maxCan + 1 << endl; cout << "Desviacio: " << setw(13) << desviacio(sumaImp) << endl;}
void Solucio::mostrarLinies(const Candidats& iCan){ cout << linies << " - " << imp << " - " << sumaImp[iCan.actual()] << " - " << anys[linies] << " - " << ingresDespesa[linies] << " - " << codi[linies] << " - " << import[linies] << endl; }
- Assistant
This C++ code seems to be part of a larger project regarding a solution to a problem involving financial auditing assignments. Specifically, the code defines the
Solucio(which might mean "Solution" in Catalan or Spanish) class, which appears to manage a collection of financial transaction records, and distributes them among different auditors according to certain criteria. TheCandidatsclass appears to represent the candidates (possible assignments) for the solution, though details of that class are not provided in this snippet.Here's an overview of the
Solucioclass' functionality based on the code:- The class stores data related to financial transaction records, such as years (
anys), income or expense (ingresDespesa), transaction codes (codi), and the import amounts (import). - It also stores assignment-related information like the current level (
niv), number of lines processed (linies), sum of processed values (suma), sum of processed import amounts (sumaImport), and sum of processed lines (sumaLinies). - It holds configuration flags like
tipusandcapitolwhich presumably control certain aspects of the assignment logic. - There are methods to initialize candidates, check whether a candidate is acceptable, and if a candidate's import exceeds a threshold amount.
- The
acabadamethod checks if the solution is complete, determined by whether it has processed all input lines. anotarrecords the assigning of a transaction to a specific auditor, whiledesanotarundoes this assignment.numAuditorsmay update the number of auditors involved based on information in the candidates.potSerMillorandesMillorare used to compare solutions, likely to identify the best among alternatives.- The
desviaciomethod calculates a statistical deviation value that might be used to determine how evenly the financial load is spread among the auditors. - Finally, a few methods such as
primeraLinia,mostrar_solucio, andmostrarLiniesprovide output for user readability, potentially to display intermediate steps or the final solution.
It's worth noting to fully understand and utilize this code, you would need the related
Candidatsclass definition and possibly other parts of the project to see how it all integrates. - The class stores data related to financial transaction records, such as years (
- User
// Dídac Comes Salas // Usuari u1988980 // Pràctica 2 #include "Candidats.h" #include #include using namespace std;
Candidats::Candidats(int n){ iCan = 0; this->n = n; }
bool Candidats::esFi() const{ return iCan == n; }
int Candidats::actual() const{ if(esFi()) throw("S'ha acabat"); else return iCan; }
void Candidats::seguent(){ if(esFi()) throw("S'ha acabat"); else iCan++; }
void Candidats::afegirAuditor(){ n++; }
void Candidats::treureAuditor(){ n--; }
void Candidats::mostrarAuditors() const{ cout << iCan << " - " << n << endl; }
int Candidats::nAuditors() const{ return n; }
// Dídac Comes Salas // Usuari u1988980 // Pràctica 2 /**
- @class Candidats
- @brief Classe que representa els candidats d'una solució. */ #ifndef CANDIDATS_H #define CANDIDATS_H #include #include using namespace std;
class Candidats{ public: /** * @pre - * @post Crea una instància de Candidats. * @param n Nombre d'auditors. * @return - */ Candidats(int n);
/** * @pre - * @post Retorna la posició actual del candidat. * @return Posició actual del candidat. */ int actual() const; /** * @pre - * @post Indica si s'han acabat els candidats disponibles. * @return Cert si s'han acabat, fals altrament. */ bool esFi() const; /** * @pre - * @post Avança a la següent posició de candidat. * @return - */ void seguent(); /** * @pre - * @post Afegeix un auditor als candidats. * @return - */ void afegirAuditor(); /** * @pre - * @post Treu un auditor dels candidats. * @return - */ void treureAuditor(); /** * @pre - * @post Mostra el nombre d'auditors disponibles. * @return - */ void mostrarAuditors() const; /** * @pre - * @post Retorna el número total d'auditors. * @return Número total d'auditors. */ int nAuditors() const; private: int iCan; /// Posició actual del candidat. int n; /// Nombre d'auditors.};
#endif // CANDIDATS_H
// Dídac Comes Salas // Usuari u1988980 // Pràctica 2 #include #include "Solucionador.h" #include "Solucio.h" #include "Candidats.h" #include #include #include #include #include #include #include using namespace std; using namespace std::chrono;
/**
-
@brief Funció que divideix una cadena de caràcters en tokens usant un separador específic.
-
@param s La cadena de caràcters a dividir.
-
@param separador El caràcter que actuarà com a separador.
-
@param cometes Indica si les cometes han de ser tingudes en compte com a delimitadors.
-
@param primer Variable de sortida que indica la posició del primer caràcter del pròxim token.
-
@param ultim Variable de sortida que indica la posició del primer caràcter després del separador.
-
@return El token extret de la cadena de caràcters. */ string token(const string& s, char separador, bool cometes, size_t& primer, size_t& ultim) { string t;
if (!cometes || s[primer] != '"') { // No volem tenir en compte les " o no comença per " while (s[primer] == ' ' && primer < s.length()) { // ens mengem els espais inicials si no hi ha cometes primer++; } ultim = s.find(separador, primer); if (ultim == string::npos) { t = s.substr(primer); } else { t = s.substr(primer, ultim - primer); primer = ultim + 1; // ens mengem la , } } else { // comença per " i les volem tenir en compte com a delimitadors primer++; ultim = s.find('"', primer); while (s.length() > ultim + 1 && s[ultim + 1] == '"') { ultim = s.find('"', ultim + 2); // saltem "" (cometes dobles seguides) } if (ultim == string::npos) { throw ("cometes no tancades"); } else { t = s.substr(primer, ultim - primer); primer = ultim + 2; // ens mengem els ", if (primer > s.length()) { ultim = string::npos; //era l'últim token } } } return t; }
/**
- @brief Funció que divideix una cadena de caràcters en una llista de tokens usant un separador específic.
- @param s La cadena de caràcters a dividir.
- @param separador El caràcter que actuarà com a separador.
- @param cometes Indica si les cometes han de ser tingudes en compte com a delimitadors.
- @return Una llista de tokens extrets de la cadena de caràcters. */ vector tokens(const string& s, char separador, bool cometes) { vector resultat; if (!s.empty()) { size_t primer = 0, ultim = 0; while (ultim != string::npos) { resultat.push_back(token(s, separador, cometes, primer, ultim)); } } return resultat; }
/**
-
@brief Funció que llegeix les dades d'un fitxer i les emmagatzema en vectors.
-
@param fitxer El nom del fitxer a llegir.
-
@param a_anys Vector per emmagatzemar els anys.
-
@param a_ingresDespesa Vector per emmagatzemar els ingressos/despeses.
-
@param a_codi Vector per emmagatzemar els codis.
-
@param a_import Vector per emmagatzemar els imports. */ void llegirDades(const string& fitxer, vector &a_anys, vector &a_ingresDespesa, vector &a_codi, vector &a_import) { ifstream f_in(fitxer); string linia; vector items; getline(f_in, linia); while (getline(f_in, linia)) { items = tokens(linia, ',', true); unsigned int any = stoi(items[1]); char id = items[2][0]; string codi = items[21]; long long imp = stod(items[30])*100;
if(imp != 0){ a_anys.push_back(any); a_ingresDespesa.push_back(id); a_codi.push_back(codi); a_import.push_back(imp); }} }
/**
-
@brief Funció principal que gestiona les opcions i executa el solucionador.
-
@param argc El nombre d'arguments passats al programa.
-
@param argv Els arguments passats al programa.
-
@return 0 si s'executa correctament, un valor diferent si hi ha errors. / int main(int argc, char argv[]){ bool ajuda=false; bool sol=false; bool millorSol=false; bool a_tipus=false; bool a_capitol=false; bool desconeguda=false; bool anys=false; bool importMax=false; unsigned int a_any=0; long long a_imp=0; int a_aud=0; string fitxer=" ";
if(argc == 1){ cout << "Falten arguments ('./audita --help' per ajuda)" << endl; exit(EXIT_FAILURE); }
for(int i = 1; i < argc; i++){ string arg=argv[i]; size_t pos; int num = 0;
if(arg=="-h" or arg=="--help"){ cout << "Utilitzacio: ./audita opcio fitxer" << endl; exit(EXIT_FAILURE); } else if(arg=="-u") sol=true; else if(arg=="-m") millorSol=true; else if(arg=="-t") a_tipus=true; else if(arg=="-c") a_capitol=true; else if (arg == "-a") { anys = true; i++; arg = argv[i]; try { a_any = stoi(arg, &pos); } catch (const std::invalid_argument& e) { cout << "Error: L'argument -a no es un enter valid." << endl; exit(EXIT_FAILURE); } catch (const std::out_of_range& e) { cout << "Error: L'argument -a esta fora del rang d'enters valids." << endl; exit(EXIT_FAILURE); } if (pos != arg.size()) { cout << "Falta el valor associat a l'opcio: " << argv[i - 1] << endl; exit(EXIT_FAILURE); } } else if (arg == "-i") { importMax = true; i++; arg = argv[i]; try { a_imp = stoll(arg, &pos); } catch (const std::invalid_argument& e) { cout << "Error: L'argument -i no és un numero valid." << endl; exit(EXIT_FAILURE); } catch (const std::out_of_range& e) { cout << "Error: L'argument -i esta fora del rang de numeros valids." << endl; exit(EXIT_FAILURE); } if (pos != arg.size()) { cout << "Falta el valor associat a l'opcio: " << argv[i - 1] << endl; exit(EXIT_FAILURE); } } else if (arg == "-n") { i++; arg = argv[i]; try { a_aud = stoi(arg, &pos); } catch (const std::invalid_argument& e) { cout << "Error: L'argument -n no es un enter valid." << endl; exit(EXIT_FAILURE); } catch (const std::out_of_range& e) { cout << "Error: L'argument -n esta fora del rang d'enters valids." << endl; exit(EXIT_FAILURE); } if (pos != arg.size()) { cout << "Falta el valor associat a l'opcio: " << argv[i - 1] << endl; exit(EXIT_FAILURE); } } else{ if (arg.length() >= 4 and arg.substr(arg.length() - 3) == "csv") { fitxer = arg; break; } else{ cout << "Opcio desconeguda: " << arg << endl; exit(EXIT_FAILURE); } }} if(fitxer==" "){ cout << "Falta el nom del fitxer" << endl; exit(EXIT_FAILURE); } else{ if(not anys){ cout << "Cal indicar un valor correcte per l'any a auditar" << endl; exit(EXIT_FAILURE); } else{ if(a_any == 0){ cout << "Falta el valor associat a l'opcio: -a" << endl; exit(EXIT_FAILURE); } else{ if(a_imp <= 0){ cout << "Cal indicar un valor correcte per l'import maxim per auditor" << endl; exit(EXIT_FAILURE); } }
}}
high_resolution_clock::time_point time1 = high_resolution_clock::now();
ifstream f_in(fitxer); if(not f_in.is_open()){ cout << " El fitxer [" << fitxer << "] no es pot obrir. Repassa el nom o els permisos. " << endl; } else{
if(sol or millorSol){ vector<unsigned int> a_anys; vector<char> a_ingresDespesa; vector<string> a_codi; vector<long long> a_import; Solucionador solr; llegirDades(fitxer, a_anys, a_ingresDespesa, a_codi, a_import); Solucio ini(a_anys, a_ingresDespesa, a_codi, a_import, a_any, a_imp, a_aud, a_tipus, a_capitol); Solucio solu; if(sol) solu = solr.solucionar(ini); else if(millorSol) solu = solr.solucionarMillor(ini); solu.primeraLinia(); if(solr.acabat()) solu.mostrar_solucio(); else cout << "No hi ha solucio per la configuracio indicada" << endl; high_resolution_clock::time_point time2 = high_resolution_clock::now(); duration<double> temps_execucio = duration_cast<duration<double>>(time2 - time1); cout << "Temps: " << setw(12) << temps_execucio.count() << " segons" << endl; } else{ cout << "Cal indicar si es busca una solucio o la millor" << endl; }} return 0; }
// Dídac Comes Salas // Usuari u1988980 // Pràctica 2 #include "Solucio.h" #include "Candidats.h" #include #include #include #include #include #include using namespace std;
Solucio::Solucio(){ niv = 0; linies = 0; suma = 0; sumaImport = 0; sumaLinies = 0; }
Solucio::Solucio(const vector &a_anys, const vector &a_ingresDespesa, const vector &a_codi, const vector &a_import, unsigned int a_any, long long a_imp, int a_aud, bool a_tipus, bool a_capitol){ assignacions.resize(50); sumaImp.resize(50); anys = a_anys; ingresDespesa = a_ingresDespesa; codi = a_codi; import = a_import; tipus = a_tipus; capitol = a_capitol; any = a_any; imp = a_imp; maxCan = a_aud; niv = 0; linies = 0; suma = 0; sumaImport = 0; sumaLinies = 0; while(any != anys[linies] and not acabada()){ linies++; } }
Candidats Solucio::inicialitzarCandidats() const{ return Candidats(maxCan + 1); }
bool Solucio::acceptable(const Candidats &iCan) const{ bool acceptable = false;
if(imp >= (sumaImp[iCan.actual()] + import[linies])/100 and any == anys[linies]) acceptable = true; if(sumaImp[iCan.actual()] != 0){ if(tipus){ char id = ingresDespesa[linies]; char ID = assignacions[iCan.actual()].begin()->first; if(id != ID) acceptable = false; } if(capitol){ char id = assignacions[iCan.actual()].begin()->first; int codiCap = stoi(codi[linies]) / 1000000; int codiCapitol = stoi(assignacions[iCan.actual()].at(id).front().first) / 1000000; if(codiCap != codiCapitol) acceptable = false; } } return acceptable;}
bool Solucio::importSuperior(const Candidats &iCan) const{ return imp < (sumaImp[iCan.actual()] + import[linies])/100; }
bool Solucio::anyDiferent() const{ return any != anys[linies]; }
bool Solucio::acabada() const{ return linies == codi.size(); }
void Solucio::anotar(const Candidats& iCan){ char id = ingresDespesa[linies]; string codiCap = codi[linies]; long long importCap = import[linies]; int pos = iCan.actual(); assignacions[pos][id].emplace_back(codiCap, importCap); sumaImp[iCan.actual()] += importCap; niv++; sumaImport += import[linies]; sumaLinies++; linies++; while(any != anys[linies] and not acabada()){ linies++; }
if(maxCan == iCan.actual() and codi.size() > (linies + 1)) maxCan++;}
void Solucio::desanotar(const Candidats& iCan) { if (not assignacions.empty() and iCan.actual() < assignacions.size()) { if (not assignacions[iCan.actual()].empty()) { niv--; linies--; char id = ingresDespesa[linies]; assignacions[iCan.actual()][id].pop_back(); sumaImp[iCan.actual()] -= import[linies]; sumaImport -= import[linies];
cout << maxCan << " - " << iCan.actual() << endl; if(maxCan == iCan.actual() and maxCan > 0){ maxCan--; } } }}
void Solucio::numAuditors(const Candidats &iCan){ if(iCan.actual() > maxCan) maxCan = iCan.actual(); }
bool Solucio::potSerMillor(const Solucio& opt, const Candidats &iCan) const{ if(not assignacions.empty() and opt.maxCan > 0){ if(maxCan == opt.maxCan){ long long carregaIdeal = 0.0; for(int i = 0; i < import.size(); i++) carregaIdeal += import[i]; carregaIdeal /= (maxCan + 1);
long long desv = 0.0; for(int i = 0; i < maxCan + 1; i++){ desv += max(0LL, sumaImp[i] - carregaIdeal); } desv = static_cast<double>(desv)/100; return desv < opt.desviacio(opt.sumaImp); } else{ return maxCan < opt.maxCan; } } else{ return true; }}
bool Solucio::esMillor(const Solucio& opt) const{ if(opt.assignacions.empty()) return true; else{ double desvAct = desviacio(sumaImp); double desvOpt = opt.desviacio(sumaImp);
return desvAct < desvOpt; }}
double Solucio::desviacio(vector sumaImp) const { double sumaTotal = 0.0; double sumaQuadrats = 0.0;
for (int i = 0; i < maxCan + 1; i++) { sumaTotal += sumaImp[i]; } sumaTotal = static_cast<double>(sumaTotal)/100; double impMitja = sumaTotal / (maxCan + 1); for (int i = 0; i < maxCan + 1; i++) { sumaQuadrats += pow((static_cast<double>(sumaImp[i])/100) - impMitja, 2); } double resultat = sqrt(sumaQuadrats / (maxCan + 1)); return resultat;}
void Solucio::primeraLinia() const{ long long total = 0; cout << endl;
if(niv != 0){ cout << niv << " linies (" << niv << ") llegides amb un import total de: "; for(int i = 0; i < sumaImp.size(); i++) total += sumaImp[i]; } else{ cout << sumaLinies << " linies (" << sumaLinies << ") llegides amb un import total de: "; total = sumaImport; } double impTotal = static_cast<double>(total)/100; cout << fixed << setprecision(2) << impTotal << " euros" << endl << endl;}
void Solucio::mostrar_solucio() const{ for(int i = 0; i < maxCan + 1; i++){ double impTotal = static_cast(sumaImp[i])/100; cout << "*********************************" << endl; cout << " Auditor " << i+1 << setw(15) << fixed << setprecision(2) << impTotal << " euros " << endl; cout << " ------------------------------ *" << endl;
for(auto it_imp = assignacions[i].begin(); it_imp != assignacions[i].end(); ++it_imp){ for (const auto &pair : it_imp->second) { double impAu = static_cast<double>(pair.second) / 100; cout << "* " << it_imp->first << pair.first << ":" << setw(15) << fixed << setprecision(2) << impAu << " euros *" << endl; } } cout << "**********************************" << endl; } cout << endl; long long total = 0; for(int i = 0; i < sumaImp.size(); i++) total += sumaImp[i]; double impTotal = static_cast<double>(total)/100; cout << "Total:" << setw(20) << impTotal << endl; cout << "Auditors: " << setw(6) << maxCan + 1 << endl; cout << "Desviacio: " << setw(13) << desviacio(sumaImp) << endl;}
void Solucio::mostrarLinies(const Candidats& iCan){ cout << linies << " - " << imp << " - " << sumaImp[iCan.actual()] << " - " << anys[linies] << " - " << ingresDespesa[linies] << " - " << codi[linies] << " - " << import[linies] << endl; }
// Dídac Comes Salas // Usuari u1988980 // Pràctica 2 /**
- @class Solucio
- @brief Classe que representa una solució possible al problema. */ #ifndef SOLUCIO_H #define SOLUCIO_H #include #include #include #include "Candidats.h" using namespace std;
class Solucio{ public: /** * @pre - * @post Crea una solució sense assignacions inicials. * @return - */ Solucio();
/** * @pre - * @post Crea una solució amb les assignacions inicials especificades. * @brief Constructor amb paràmetres. * @param a_anys Vector d'anys. * @param a_ingresDespesa Vector de tipus d'ingrés/despesa. * @param a_codi Vector de codis. * @param a_import Vector d'imports. * @param a_any Any específic. * @param a_imp Import específic. * @param a_aud Número d'auditors. * @param a_tipus Tipus específic. * @param a_capitol Capitol específic. * @return - */ Solucio(const vector<unsigned int> &a_anys, const vector<char> &a_ingresDespesa, const vector<string> &a_codi, const vector<long long> &a_import, unsigned int a_any, long long a_imp, int a_aud, bool a_tipus, bool a_capitol); /** * @pre La solució ha d'estar inicialitzada. * @post Inicialitza els candidats per a la solució. * @return Candidats inicialitzats. */ Candidats inicialitzarCandidats() const; /** * @pre La solució ha d'estar inicialitzada. * @post Indica si una assignació és acceptable per als candidats actuals. * @param iCan Candidats actuals. * @return Cert si l'assignació és acceptable, fals altrament. */ bool acceptable(const Candidats &iCan) const; /** * @pre La solució ha d'estar inicialitzada. * @post Indica si l'import de la línia actual supera el límit permès. * @param iCan Candidats actuals. * @return Cert si l'import supera el límit, fals altrament. */ bool importSuperior(const Candidats &iCan) const; /** * @pre La solució ha d'estar inicialitzada. * @post Indica si l'any de la línia actual és diferent de l'any esperat. * @return Cert si l'any és diferent, fals altrament. */ bool anyDiferent() const; /** * @pre La solució ha d'estar inicialitzada. * @post Indica si la solució està completa (s'han processat totes les línies). * @return Cert si la solució està completa, fals altrament. */ bool acabada() const; /** * @pre La solució ha d'estar inicialitzada. * @post Anota l'assignació actual a la solució. * @param iCan Candidats actuals. * @return - */ void anotar(const Candidats &iCan); /** * @pre La solució ha d'estar inicialitzada. * @post Desanota l'última assignació a la solució. * @param iCan Candidats actuals. * @return - */ void desanotar(const Candidats &iCan); /** * @pre La solució ha d'estar inicialitzada. * @post Actualitza el número màxim d'auditors utilitzats. * @param iCan Candidats actuals. * @return - */ void numAuditors(const Candidats &iCan); /** * @pre La solució ha d'estar inicialitzada. * @post Indica si la solució pot ser millor que una altra opció. * @param opt Opció a comparar. * @param iCan Candidats actuals. * @return Cert si pot ser millor, fals altrament. */ bool potSerMillor(const Solucio& opt, const Candidats &iCan) const; /** * @pre La solució ha d'estar inicialitzada. * @post Indica si la solució és millor que una altra opció. * @param opt Opció a comparar. * @return Cert si és millor, fals altrament. */ bool esMillor(const Solucio& opt) const; /** * @pre La solució ha d'estar inicialitzada. * @post Calcula la desviació estàndard de les assignacions. * @param sumaImp Vector amb les sumes d'imports per auditor. * @return Desviació estàndard de les sumes d'imports. */ double desviacio(vector<long long> sumaImp) const; /** * @pre La solució ha d'estar inicialitzada. * @post Mostra un resum de la solució (número de línies, imports, etc.). * @return - */ void primeraLinia() const; /** * @pre La solució ha d'estar inicialitzada. * @post Mostra detalls de les assignacions per cada auditor. * @return - */ void mostrar_solucio() const; /** * @pre La solució ha d'estar inicialitzada. * @post Mostra detalls de les línies actuals i altres detalls rellevants. * @param iCan Candidats actuals. * @return - */ void mostrarLinies(const Candidats& iCan); private: vector<map<char, vector<pair<string, long long>>>> assignacions; /// Assignacions d'imports als auditors. vector<unsigned int> anys; /// Anys de les dades d'entrada. vector<char> ingresDespesa; /// Ingrés/despesa de les dades d'entrada. vector<string> codi; /// Codis de les dades d'entrada. vector<long long> import; /// Imports de les dades d'entrada. vector<long long> sumaImp; /// Suma d'imports per auditor. bool tipus; /// Indica si es considera el tipus. bool capitol; /// Indica si es considera el capítol. int any; /// Any a avaluar. int imp; /// Import a avaluar. long long suma; /// Suma total d'imports. long long sumaImport; /// Suma total d'imports en euros. int niv; /// Nivell actual. int linies; /// Línia actual. int sumaLinies; /// Suma total de línies. int maxCan; /// Nombre màxim d'auditors.};
#endif // SOLUCIO_H
// Dídac Comes Salas // Usuari u1988980 // Pràctica 2 #include "Solucionador.h" #include "Solucio.h" #include "Candidats.h" #include #include #include using namespace std;
Solucionador::Solucionador(){ encertat = false; }
Solucio Solucionador::solucionar(const Solucio &ini){ Solucio act = ini; trobar(act); return act; }
Solucio Solucionador::solucionarMillor(const Solucio &ini){ Solucio act = ini; opt = ini; trobarMillor(act); return opt; }
void Solucionador::trobar(Solucio& act){ Candidats iCan = act.inicialitzarCandidats(); while(not iCan.esFi() and not encertat){ if(act.acceptable(iCan)){ act.anotar(iCan); if(not act.acabada()) trobar(act); else encertat = true; } iCan.seguent(); } }
void Solucionador::trobarMillor(Solucio& act){ Candidats iCan = act.inicialitzarCandidats(); while(not iCan.esFi()){
if(act.acceptable(iCan) and act.potSerMillor(opt, iCan)){ act.anotar(iCan); if(not act.acabada()) trobarMillor(act); else { if(act.esMillor(opt)){ opt = act; } } act.desanotar(iCan); } iCan.seguent(); }if(iCan.esFi()) encertat = true;}
bool Solucionador::acabat(){ return encertat; }
// Dídac Comes Salas // Usuari u1988980 // Pràctica 2 /**
- @class Solucionador
- @brief Classe que s'encarrega de trobar solucions al problema. */ #ifndef SOLUCIONADOR_H #define SOLUCIONADOR_H #include #include #include "Solucio.h" #include "Candidats.h" using namespace std;
class Solucionador{ public: /** * @pre - * @post Crea una instància de Solucionador. * @return - */ Solucionador();
/** * @pre La solució inicial ha d'estar creada. * @post Troba una solució possible al problema. * @param ini Solució inicial. * @return Solució trobada. */ Solucio solucionar(const Solucio &ini); /** * @pre La solució inicial ha d'estar creada. * @post Troba la millor solució possible al problema. * @param ini Solució inicial. * @return Millor solució trobada. */ Solucio solucionarMillor(const Solucio &ini); /** * @pre - * @post Indica si s'ha acabat de trobar una solució. * @return Cert si s'ha acabat, fals altrament. */ bool acabat(); private: /** * @pre La solució ha d'estar inicialitzada. * @post Troba una solució possible al problema. * @param act Solució actual. * @return - */ void trobar(Solucio& act); /** * @pre La solució ha d'estar inicialitzada. * @post Troba la millor solució possible al problema. * @param act Solució actual. * @return - */ void trobarMillor(Solucio& act); Solucio opt; /// Millor solució trobada. bool encertat; /// Indica si s'ha acabat de trobar una solució.};
#endif // SOLUCIONADOR_H
Que em falla al programa perquè quan insereixo aquesta linia: ./audita -m -a 2022 -i 2600000 linies_0001.csv no em doni la millorSolucio? Jo crec que el problema està a l'acció desanotar. Podries corregir el que creguis necessaria perquè em doni bé.
- Assistant
El teu programa sembla ser una implementació d'un algorisme de cerca per a asignar linies de un fitxer CSV a diferents auditors basant-se en diferents criteris com l'any, el tipus d'operació (ingrés o despesa), import màxim asignable a cada auditor, entre d'altres.
He revisat la funció
desanotari hi ha un parell de coses que podrien causar problemes:-
Estàs fent servir
coutper imprimir la variablemaxCaniiCan.actual()a cada trucada dedesanotar, el que podria introduir soroll i dificultar seguir el flux lògic del programa. -
La lògica per a reduir
maxCanpodria no estar manejant correctament tots els casos, especialment simaxCanés igual aiCan.actual()i aquest candidat era l'únic assignat a l'auditor que està essent eliminat.
Revisem i ajustem el mètode
desanotar:void Solucio::desanotar(const Candidats& iCan) { if (not assignacions.empty() and iCan.actual() < assignacions.size()) { if (not assignacions[iCan.actual()].empty()) { niv--; linies--; char id = ingresDespesa[linies]; assignacions[iCan.actual()][id].pop_back(); sumaImp[iCan.actual()] -= import[linies]; sumaImport -= import[linies]; // Aquesta part sembla que podria ser una mica problemàtica. // Hem de revisar si després de desanotar, l'auditor actual té 0 càrregues, // i en aquest cas, actualitzar maxCan adequadament. if (assignacions[iCan.actual()][id].empty() && sumaImp[iCan.actual()] == 0) { // Es pot millorar aquesta comprovació per veure si realment ha de decrementar maxCan. bool esUltimAuditor = true; for (int i = 0; i <= maxCan; i++) { if (sumaImp[i] != 0) { esUltimAuditor = false; break; } } if (esUltimAuditor && maxCan > 0) { maxCan--; } } // Si estem desanotant i tornem enrere en les linies, hem d'assegurar-nos // que la propera trucada de `anotar` començarà a revisar des de la linia correcta. // Això és important perquè si tenim múltiples assignacions possibles en una linia, // podriem necessitar tornar enrere més d'una vegada. while(any != anys[linies] && linies > 0){ linies--; } } } }Una altra cosa que val la pena revisar és el maneig adequat de l'actualització de
maxCandins la funciónumAuditors:void Solucio::numAuditors(const Candidats &iCan){ // Si aquesta és una nova assignació que supera el nombre d'auditors actuals, // aleshores maxCan ha d'augmentar. if(iCan.actual() > maxCan) maxCan = iCan.actual(); // A més, hauries de considerar el cas quan treure una assignació disminueix maxCan. }A més, seria bo revisar les funcions
trobaritrobarMillorper asegurar-te que realitzen correctament els backtracking, especialment si el programar està fent servir recursivitat per explorar els candidats.Finalment, recomano revisar la lògica en
trobarMillori assegurar que quan trobis una millor solució, actualitzis correctament l'objecteopt. Si després de fer la recomanació encara teniu problemes, seria útil revisar el problema amb més detall per capçalera i entendre exactament quins casos no s'estan maneajnt correctament. -
- User
Ara he fet aixo: void Solucionador::trobarMillor(Solucio& act){ Candidats iCan = act.inicialitzarCandidats(); while(not iCan.esFi()){
if(act.acceptable(iCan) and act.potSerMillor(opt, iCan)){ act.anotar(iCan); if(not act.acabada()) trobarMillor(act); else { if(act.esMillor(opt)){ opt = act; } } act.desanotar(iCan); } iCan.seguent(); }if(iCan.esFi()){ encertat = true; cout << "hola" << endl; }} i em dona el hola molts cops i arriba un moment que para. No ho entenc ja que en teoria quan arriba a la linia if(iCan.esFi()){ l'ha de fer un cop ja que no està dins ni de cap while i entenc que no afecta a l'acció recursiva ja que per tornar al principi de l'acció trobarMillor està a la linia if(not act.acabada()) trobarMillor(act); que està dins del while.
- Assistant
Podem veure que el missatge "hola" s'imprimeix cada vegada que la funció
trobarMillorarriba al seu final i comprova la condicióif(iCan.esFi()). Això indicaria que cada trucada recursiva detrobarMillorestà arribant a aquesta condició.El teu enfocament per buscar la millor solució és correcte, utilitzant la recursivitat per recórrer tot l'espai de solucions possibles. La impressió del "hola" es pot repetir nombroses vegades perquè es tracta d'un procés recursiu profund i podria passar que s'arriba al final de la llista de candidats (la condició
iCan.esFi()) diverses vegades, ja que això ocorrerà en cada nivell de recurrència de la cerca.L'acció de
trobarMillores pot desglossar de la manera següent:- Amb cada nova crida recursiva, inicialitzem els candidats per a l'actual solució.
- Iterem a través de tots els possibles candidats, fins que no quedin més (
iCan.esFi()). - Si el candidat actual és acceptable i pot millorar la millor solució fins ara coneguda (
opt), l'anotem per veure si podria fer una solució completa o millorar una solució existent. - Si la solució arriba a ser completa, comprovem si és millor que la que tenim (
opt) i l'actualitzem si cal. - Desanotem el candidat actual per retrocedir i intentar altres possibles combinacions.
Respecte a la impressió repetida de "hola", això es pot donar per alguns motius diferents:
- La recursivitat de
trobarMillorestà arribant a la condició de fi (iCan.esFi()) múltiples vegades a través de diferents camins en l'arbre de cerca. Aquesta és una operació esperada en una recerca backtracking, ja que intentarem tots els possibles candidats en cada pas recursiu. - Hi ha prou nombroses combinacions possibles com per què la funció recursiva sigui cridada moltes vegades abans de trobar una solució.
Si el missatge "hola" s'imprimeix infinitament, és possible que la recursivitat no tingui una condició base correcta en alguna situació, o que es doni un cas infinit degut a la gestió incorrecta de l'estat de l'objecte
actooptdins de la cerca.Per resoldre el problema amb el bucle infinit, necessitaràs assegurar-te que el teu algorisme de cerca satisfà els següents punts:
- Cada candidat només es considera una vegada per cada trucada de funció recursiva.
- Reduint clarament el nombre de possibilitats en cada crida (
trobarMillor). - Que la condició de base està ben definida, així la cerca es detindrà quan ja no hi hagi més candidats o quan s'hagi trobat una millor solució.
Suggeriria afegir més opcions de depuració o utilitzar eines de depuració per seguir l'estat de les variables i comprendre millor el flux d'execució de la teva aplicació.
- User
El que fa és inserir-me molts "hola", però al final no insereix res més. Hauria d'inserir el que hi ha a assignacions i no insereix res. Ara et passo l'enunciat de tota la pràctica juntament amb alguns exemples. 1 Presentaci´o Ha arribat el dia en qu
e s’ha de fiscalitzar la feina de la Gencat i, entre d’altres, es realitzara una auditoria dels comptes d’acord amb els pressupostos. La nostra empresa, Empresa d’Auditories S.L. (EdA SL, en curt), ha rebut l’encarrec de fiscalitzar els comptes i la gerent de l’empresa ens ha demanat al servei informatic crear un programa per dimensionar l’equip d’auditors que participara en aquesta feina. L’objectiu ´es auditar totes les partides (Aplicacions) del pressupost d’un any donat amb un equip d’auditors adequat. Aix´ı, haurem d’assignar cada aplicaci´o pressupostaria a un auditor, pero aquesta assignaci´o no ´es trivial si es vol fer de la millor manera possible d’acord amb els criteris establerts. Per simplificar la feina als auditors, voldrem tenir la capacitat d’assignar nom´es aplicacions d’un mateix tipus a cada auditor, o d’un mateix cap´ıtol. A m´es, la gerent d’EdA SL ens indica que, per reduir costos, voldria poder trobar l’equip m´es petit possible pero sense sobresaturar cap dels nostres companys auditors. Es ´ a dir, en aquest cas buscar´ıem l’assignaci´o que necessiti el menor nombre d’auditors pero, donades dues solucions amb el mateix nombre, triar´ıem l’assignaci´o d’aplicacions que m´es b´e (balancejat) reparteix l’import total als auditors. 1.1 Dades d’entrada Tornarem a tractar amb el mateix tipus de dades sobre els pressupostos de la Gencat que d´ona el CTTI i que s’han fet servir abans en exercicis i practiques de l’assignatura. 1.2 Resum dels requeriments Si recopilem el m´es rellevant del que s’ha explicat abans: • Hem d’auditar totes les partides (aplicacions) del pressupost d’un any donat • Les aplicacions es repartiran entre auditors • A cada auditor se li poden assignar aplicacions per un import maxim donat. Tots els auditors tenen el mateix l´ımit. • Es pot demanar que cada auditor fiscalitzi nom´es (restriccions) aplicacions d’un mateix tipus (I/D) o d’un mateix cap´ıtol. • Es poden fer servir, en principi, tants auditors com calgui, pero... – es pot indicar el nombre d’auditors maxim a utilitzar, – o es pot demanar buscar la soluci´o amb el m´ınim nombre d’auditors. En aquest cas, entre dues solucions amb el mateix nombre, es prioritzara aquella que tingui l’import total m´es ben repartit entre auditors, ´es a dir, la que tingui la menor desviaci´o estandard (veure Equaci´o 1) de l’import assignat als auditors. σ = vuut 1 n Xn i=1 (pi − p) 2 F´ormula de la desviaci´o estandard σ, on n ´es el nombre d’auditors, pi ´es l’import agregat de les aplicacions assignades a l’i-esim auditor, i p ´es l’import mitja assignat als auditors. (1) EDA Practica 2: Algor ` ´ısmica, curs 2023/24 GDDV/GEINF 2 2 Feina a fer- Fent servir backtracking, trobar una assignaci´o d’aplicacions a auditors que no superi el nombre
m
axim donat (si s’indica) i que compleixi les restriccions establertes. Si no ´es possible trobar una assignaci´o amb aquestes condicions, s’informara que no hi ha soluci´o. - Fent servir backtracking, trobar la millor assignaci´o d’aplicacions a auditors complint les restriccions donades, ´es a dir, la que minimitza el nombre d’auditors, primer, i la desviaci´o est
andard de l’assignaci´o d’imports en segon lloc. Igualment, si no ´es possible trobar una assignaci´o amb aquestes condicions, s’informara que no hi ha soluci´o. 2.1 Instruccions • Cal codificar el backtracking utilitzant les classes vistes a teoria: Solucionador, Solucio i Candidats. • Les dades es llegiran d’un fitxer de tipus text que contindra les dades de pressupostos que ja coneixeu fent servir les funcions d’eines.h. • Ens quedarem amb les l´ınies del pressupost de l’any indicat per l’usuari amb un import consolidat m´es gran que 0. Recordeu que pot haver-hi m´es d’una l´ınia (o import) associada a la mateixa aplicaci´o. Nom´es cal guardar la informaci´o associada a l’aplicaci´o. • Un cop calculada la soluci´o, aquesta es mostrara per la sortida estandard en un format lliure, pero similar al que es mostra m´es endavant en aquest document. En tot cas, ha de mostrar l’assignaci´o de cada auditor (les aplicacions que auditara ordenades per codi), l’import agregat de les aplicacions assignades a cada auditor, el nombre total d’auditors, la desviaci´o estandard dels imports assignats als auditors, i el temps que ha trigat a trobar la soluci´o. • Si es creu oport´u, es poden preprocessar les dades abans d’iniciar el backtracking per obtenir estructures que ens puguin ser ´utils per podar branques de l’arbre de possibilitats. Aquest preprocessament s’incloura en el calcul del temps de comput de l’algorisme. • En una execuci´o normal, cal indicar obligatoriament si es busca una o la millor soluci´o, l’any a auditar, l’import maxim que pot assumir un auditor, i el nom del fitxer de dades. El nombre maxim d’auditors ´es un parametre opcional (si no s’indica, s´on il·limitats), al igual que les restriccions per tipus I/D i cap´ıtol. Per saber com indicar aquests parametres, es pot consultar l’ajuda del programa (veure exemple m´es avall). • Per fer les proves, cal comen¸car amb poques l´ınies amb imports ben dimensionats (pel que fa al maxim que se li podra assignar a un auditor), i anar-ho incrementant de mica en mica (el temps d’execuci´o es disparara!). • El programa principal s’ha d’anomenar audita i ha de funcionar a trav´es de l’interpret de comandes tal com es descriu a continuaci´o: – Si es crida sense parametres, ha d’emetre un missatge indicant com demanar ajuda. 1 $ ./audita 2 Falten arguments ("./audita --help" per ajuda) – Si es demana ajuda, ha de descriure el seu funcionament. 1 $ ./audita --help 2 Utilitzaci´o: ./audita opcio fitxer 3 4 opcio pot ser: 5 -h, --help mostra aquest missatge d'ajuda i surt 6 -u cerca una soluci´o qualsevol que compleixi les EDA Practica 2: Algor´ısmica, curs 2023/24 GDDV/GEINF 3 7 restriccions del problema 8 -m cerca la soluci´o que minimitza el nombre d'auditors 9 i el repartimentoptim d'aplicacions 10 -t indica que nom´es es poden assignar aplicacions del 11 mateix tipus (ingr´es/despesa) a un auditor 12 -c indica que nom´es es poden assignar aplicacions del 13 mateix cap´ıtol a un auditor 14 -a <any> indica que s'ha de fer l'assignaci´o per a 15 l'exercici pressupostari <any> 16 -i <imp> assigna <imp> com a import maxim que un 17 ´unic auditor pot fiscalitzar 18 -n assigna com a nombre maxim d'auditors 19 20 fitxer ha de ser un fitxer de text amb totes les l´ınies 21 dels pressupostos amb el format del CTTI. 22 – El programa s’ha d’aturar i mostrar un missatge d’error amb el primer problema detectat amb l’entrada de parametres (si falta un parametre o ´es incorrecte). Per exemple: 1 $ ./audita -j 2 Opci´o desconeguda: -j 1 $ ./audita fitxer.txt 2 Cal indicar si es busca una soluci´o o la millor 1 $ ./audita -u 2 Falta el nom del fitxer 1 $ ./audita -u fitxer.csv 2 Cal indicar un valor correcte per l'any a auditar 1 $ ./audita -a fitxer.csv 2 Falta el valor associat a l'opci´o: -a 1 $ ./audita -i 0 -a 2021 -u fitxer.csv 2 Cal indicar un valor correcte per l'import maxim per auditor – Si el fitxer no s’ha pogut obrir, s’ha d’avisar. 1 ./audita -u -a 2020 -i 200 linies_0002.csv 2 3 32 l´ınies (28 aplicacions) llegides amb un import total de: 15406545.67 € 4 ... 3 Exemples Podeu fer servir els fitxers de la Practica 1 per generar els vostres propis fitxers amb l´ınies d’un pressupost. Nosaltres proposem els dos fitxers seg¨uents: EDA Practica 2: Algor´ısmica, curs 2023/24 GDDV/GEINF 4 3.1 linies 0001.csv El fitxer linies 0001.csv t´e unes poques l´ınies per a 2 anys diferents (2020 i 2022). Hem de posar un import maxim per auditor raonable o... 1 ./audita -u -a 2022 -i 200 linies_0001.csv 2 3 14 l´ınies (14 aplicacions) llegides, amb un import total de: 12057492.78 € 4 5 No hi ha soluci´o per la configuraci´o indicada 6 Temps: 8.6191e-05 segons Ara, amb un import maxim raonable (opci´o -i), podem buscar una soluci´o (opci´o -u): 1 ./audita -u -a 2022 -i 2600000 linies_0001.csv 2 3 14 l´ınies (14 aplicacions) llegides amb un import total de: 12057492.78 € 4 5 ********************************** 6 * Auditor 1 2570927.06 € * 7 * ------------------------------ * 8 * D4800003: 2570927.06 € * 9 ********************************** 10 11 ********************************** 12 * Auditor 2 2593738.60 € * 13 * ------------------------------ * 14 * D2260002: 50000.00 € * 15 * D2270089: 2543738.60 € * 16 ********************************** 17 18 ********************************** 19 * Auditor 3 2574675.88 € * 20 * ------------------------------ * 21 * D2120003: 350000.00 € * 22 * D2210001: 146360.53 € * 23 * D6100001: 2078315.35 € * 24 ********************************** 25 26 ********************************** 27 * Auditor 4 2572232.03 € * 28 * ------------------------------ * 29 * D2210007: 1520708.47 € * 30 * D4820055: 145000.00 € * 31 * D6400001: 60000.00 € * 32 * I3110001: 846523.56 € * 33 ********************************** 34 35 ********************************** 36 * Auditor 5 1745919.21 € * 37 * ------------------------------ * 38 * D2260001: 30000.00 € * 39 * D2270013: 105000.00 € * 40 * D4480014: 235125.00 € * 41 * I1100002: 1375794.21 € * 42 ********************************** 43 44 Total: 12057492.78 45 Auditors: 5 46 Desviaci´o: 332892.42 EDA Practica 2: Algor´ısmica, curs 2023/24 GDDV/GEINF 5 47 Temps: 2.0834e-05 segons O podem buscar la millor soluci´o (opci´o -m): 1 ./audita -m -a 2022 -i 2600000 linies_0001.csv 2 3 14 l´ınies (14 aplicacions) llegides amb un import total de: 12057492.78 € 4 5 ********************************** 6 * Auditor 1 2570927.06 € * 7 * ------------------------------ * 8 * D4800003: 2570927.06 € * 9 ********************************** 10 11 ********************************** 12 * Auditor 2 2543738.60 € * 13 * ------------------------------ * 14 * D2270089: 2543738.60 € * 15 ********************************** 16 17 ********************************** 18 * Auditor 3 2313440.35 € * 19 * ------------------------------ * 20 * D4480014: 235125.00 € * 21 * D6100001: 2078315.35 € * 22 ********************************** 23 24 ********************************** 25 * Auditor 4 2317069.00 € * 26 * ------------------------------ * 27 * D2120003: 350000.00 € * 28 * D2210001: 146360.53 € * 29 * D2210007: 1520708.47 € * 30 * D2260002: 50000.00 € * 31 * D2270013: 105000.00 € * 32 * D4820055: 145000.00 € * 33 ********************************** 34 35 ********************************** 36 * Auditor 5 2312317.77 € * 37 * ------------------------------ * 38 * D2260001: 30000.00 € * 39 * D6400001: 60000.00 € * 40 * I1100002: 1375794.21 € * 41 * I3110001: 846523.56 € * 42 ********************************** 43 44 Total: 12057492.78 45 Auditors: 5 46 Desviaci´o: 119393.51 47 Temps: 0.000545787 segons Pero no volem que els auditors barregin ingressos i despeses, aix´ı que separem per tipus (opci´o -t): 1 2 ./audita -m -t -a 2022 -i 2600000 linies_0001.csv 3 4 14 l´ınies (14 aplicacions) llegides amb un import total de: 12057492.78 € 5 6 ********************************** EDA Practica 2: Algor ` ´ısmica, curs 2023/24 GDDV/GEINF 6 7 * Auditor 1 2570927.06 € * 8 * ------------------------------ * 9 * D4800003: 2570927.06 € * 10 ********************************** 11 12 ********************************** 13 * Auditor 2 2543738.60 € * 14 * ------------------------------ * 15 * D2270089: 2543738.60 € * 16 ********************************** 17 18 ********************************** 19 * Auditor 3 2359675.88 € * 20 * ------------------------------ * 21 * D2210001: 146360.53 € * 22 * D2260001: 30000.00 € * 23 * D2270013: 105000.00 € * 24 * D6100001: 2078315.35 € * 25 ********************************** 26 27 ********************************** 28 * Auditor 4 2360833.47 € * 29 * ------------------------------ * 30 * D2120003: 350000.00 € * 31 * D2210007: 1520708.47 € * 32 * D2260002: 50000.00 € * 33 * D4480014: 235125.00 € * 34 * D4820055: 145000.00 € * 35 * D6400001: 60000.00 € * 36 ********************************** 37 38 ********************************** 39 * Auditor 5 2222317.77 € * 40 * ------------------------------ * 41 * I1100002: 1375794.21 € * 42 * I3110001: 846523.56 € * 43 ********************************** 44 45 Total: 12057492.78 46 Auditors: 5 47 Desviaci´o: 129573.75 48 Temps: 5.3461e-05 segons
- Fent servir backtracking, trobar una assignaci´o d’aplicacions a auditors que no superi el nombre
m
- Assistant
Per a resoldre l'enunciat i els requeriments que has proporcionat, primer hem de garantir que l'estructura bàsica del nostre solucionador (backtracking) està correctament implementada. Això inclou les classes
Solucio,Candidats, iSolucionador, juntament amb la lògica de processament principal situada dins delmain. Volem assegurar-nos que el solucionador pugui:- Llegir dades del fitxer CSV proporcionat.
- Filtrar les dades segons l'any i altres criteris.
- Utilitzar backtracking per a trobar una assignació permesa d'aplicacions pressupostàries segons els límits d'import per auditor i altres restriccions.
- Comparar solucions per a determinar quina reparteix més equitativament l'import total entre els auditors, usant la desviació estàndard com a criteri de decisió.
En el teu cas, t'has trobat amb un problema on sembla que el solucionador s'executa, però no retorna cap solució. Hi ha alguns passos a seguir per a depurar el problema:
- Comprova que les dades es llegeixen correctament del fitxer CSV i es filtren adequadament basant-se en els criteris especificats (any i imports no nuls).
- Assegura't que la classe
Candidatspermet iterar adequadament a través de les opcions disponibles, i que l'estat es manté coherent a través de trucades recursives. - Verifica que les funcions
acceptable,anotar, idesanotardins de la classeSoluciogestionen correctament l'estat de la solució actual, inclòs l'assignació i la retirada d'aplicacions als auditors. - Revisa que la funció
trobarMillormaneja correctament la recursivitat, especialment quan es retorna de la recursió. Una vegada s'arriba a una fulla de l'arbre de cerca (és a dir, quaniCan.esFi()és cert), la solució actual s'ha de comparar amb la millor solució (opt) i actualitzar si és millor. Si no és millor, o no és una solució completa, la funció hauria de retornar a la trucada anterior per provar una altra branca de l'arbre.
Si després de fer les comprovacions anteriors encara no s'obté cap solució, seria útil incorporar missatges de depuració o utilitzar un depurador per seguir els valors de les variables i comprendre per què el programa està actuant d'aquesta manera.
Per a la depuració, pots inserir missatges addicionals de consola a punts clau de la teva implementació del backtracking que t'ajudin a entendre quins passos està seguint l'algorisme i per què podria estar fallant en trobar una solució. També podríeu considerar el cas que l'algorisme està trobant una solució, però per alguna raó no s'està mostrant correctament a la sortida.
A mode de recordatori, cal assegurar que no estàs imprimint "hola" dins la funció
trobarMillor, ja que aquest missatge s'imprimirà cada vegada que la funció s'execute i arribi a la condicióiCan.esFi(), i això pot provocar confusió durant la depuració. En lloc d'això, només haurien d'imprimir-se missatges que indiquin l'estat actual del backtracking i la raó per la qual no es troba solució, si és el cas.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.