practica.tar

Makefile000600 001750 000144 00000000777 13301566360 014113 0ustar00weijie.chenusers000000 000000 OPCIONS = -D_JUDGE_ -D_GLIBCXX_DEBUG -O2 -Wall -Wextra -Werror -Wno-sign-compare -std=c++11

program.exe: program.o warehouse.o Sala.o inventory.o
	g++ -o program.exe *.o 

warehouse.o: warehouse.cc Warehouse.hh Sala.hh Inventory.hh
	g++ -c warehouse.cc $(OPCIONS) 

Sala.o: Sala.cc Sala.hh Inventory.hh
	g++ -c Sala.cc $(OPCIONS) 

inventory.o: inventory.cc Inventory.hh
	g++ -c inventory.cc $(OPCIONS) 

program.o: program.cc Warehouse.hh Inventory.hh
	g++ -c program.cc $(OPCIONS) 

clean:
	rm *.o
	rm *.exe
warehouse.cc000600 001750 000144 00000004242 13302100051 014731 0ustar00weijie.chenusers000000 000000 #include "Warehouse.hh"

void warehouse::BinTreeIO(BinTree<int>& T){
	int a;
	cin>>a;
	if(a!=0){
	BinTree<int> aux_left;
	BinTreeIO(aux_left);
	BinTree<int> aux_right;
	BinTreeIO(aux_right);
	T=BinTree<int> (a, aux_left, aux_right);
	}
}

void warehouse::specify(int n){
	this -> alm_size=n;
	BinTreeIO(index);
	alm.resize(alm_size);
	int a, b;
	for(int i=0; i<alm_size; ++i){
		cin>>a>>b;
		sala s(a,b);
		alm[i]=s;
	}
}

int warehouse::poner_items(int sala, string& p, int quantity, inventory& inv){
	int afegits=alm[sala].poner_items(p, quantity);
	inv.update_quantity(p, afegits);
	return quantity-afegits;
}

int warehouse::quitar_items(int sala, string& p, int quantity, inventory& inv){
	int sustrets=alm[sala].quitar_items(p, quantity);
	inv.update_quantity(p, -sustrets);
	return quantity-sustrets;
}

int warehouse::i_distribuir(string& p, int& quantity, inventory& inv, warehouse& w, const BinTree<int>& t){
	if(t.empty() or quantity==0) return quantity;
	else{
		quantity=w.poner_items(t.value()-1, p, quantity, inv);
		BinTree<int> esq=t.left();
		BinTree<int> dre=t.right();
			int a, b;
			b=quantity/2;
			a=quantity-b;
			return i_distribuir(p, a, inv, w, esq)+i_distribuir(p, b, inv, w, dre);
	}
}

int warehouse::distribuir(string& p, int& quantity, inventory& inv, warehouse& w){
	return i_distribuir(p, quantity, inv, w, w.index);
}

void warehouse::compactar(int sala){
	alm[sala].compactar();
}

void warehouse::redimensionar(int sala, int files, int columnes){
	alm[sala].redimensionar(files, columnes);
}

void warehouse::reorganizar(int sala){
	alm[sala].reorganizar();
}
//Consultores

void warehouse::escribir(int sala) const
{
	alm[sala].escribir();
}

string warehouse::consultar_pos(int sala, int fila, int columna) const
{
	return alm[sala].consultar_pos(fila, columna);
}

bool warehouse::exists(int sala) const
{
	return 0<=sala and sala<alm_size;
}

bool warehouse::sala_redimensionable(int sala, int files, int columnes) const
{
	return alm[sala].redimensionable(files, columnes);
}

bool warehouse::pos_valid(int sala, int fila, int columna) const
{
	return alm[sala].pos_valida(fila, columna);
}


//-D_JUDGE_ -D_GLIBCXX_DEBUG -O2 -Wall -Wextra -Werror -Wno-sign-compare 
Sala.cc000600 001750 000144 00000004245 13302105702 013622 0ustar00weijie.chenusers000000 000000 #include "Sala.hh"
#include <map>
using namespace std;

typedef map<string, int>::const_iterator const_it;
typedef map<string, int>::iterator it;

int sala::poner_items(string& product, int quantity){
	int cont=quantity;
	for(int i=0; cont>0 and i<files*columnes; ++i){
		if(stan[i]=="NULL"){
			 stan[i]=product;
			 --cont;
		 }
	}
	int afegits=quantity-cont;
	if(afegits!=0){
	inv.inv_sala_update(product, afegits);
	n_prods+=afegits;
	}
	return afegits;
}


int sala::quitar_items(string& product, int quantity){
	int cont=quantity;
	for(int i=0; cont>0 and i<files*columnes; ++i){
		if(stan[i]==product){
				stan[i]="NULL";
				--cont;
		}
	}
	int sustrets=quantity-cont;
	inv.inv_sala_update(product, -sustrets);
	n_prods-=sustrets;
	return sustrets;
}


void sala::compactar(){
	int i_1=0, i_2=0;
	while(i_1<int(stan.size()) and int(i_2<stan.size())){
		if(stan[i_1]!="NULL") ++i_1;
		if(stan[i_2]=="NULL" or i_2<=i_1) ++i_2;
		if(i_2<int(stan.size()) and stan[i_2]!="NULL" and stan[i_1]=="NULL") swap(stan[i_2], stan[i_1]);
	}
}

/*
void sala::reorganizar(){
	inv.llista(files, columnes).swap(stan);
}
*/

void sala::reorganizar(){
	const_it iterator=inv.const_it_inv();
	vector<string> s(files*columnes, "NULL");
	int i=0;
	while(iterator!=inv.const_it_end()){
		for(int j=0; j<iterator->second; ++j){
			s[i]=iterator->first;
			++i;
		}
		inv.next_const_it(iterator);
	}
	s.swap(stan);
}

void sala::redimensionar(int files, int columnes){
	this -> compactar();
	this -> files=files;
	this -> columnes=columnes;
	stan.resize(files*columnes, "NULL");
}

//Consultores

void sala::escribir() const
{
	if(files*columnes>0){
	for(int i=files-1; i>=0; --i){
		cout<<"  ";
		for(int j=0; j<columnes; ++j){
			if(j!=0) cout<<' ';
			cout<<stan[j+i*columnes];
		}
		cout<<endl;
	}
}
	cout<<"  "<<n_prods<<endl;
	inv.inventario();
}


string sala::consultar_pos(int fila ,int columna) const
{
	fila=files-1-fila;
	return stan[fila*columnes+columna];
}

bool sala::redimensionable(int fila, int columna) const
{
	return 0<=n_prods and n_prods<=fila*columna;
}

bool sala::pos_valida(int fila, int columna) const
{
	return 0<=fila and fila < this -> files and 0<=columna and columna < this -> columnes;
}







program.cc000600 001750 000144 00000007302 13301566360 014420 0ustar00weijie.chenusers000000 000000 #include "Warehouse.hh"
#include "Inventory.hh"
using namespace std;


void poner_prod(inventory& inv){
	string product;
	cin>>product;
	cout<<"poner_prod "<<product<<endl;
	if(inv.exists(product)) cout<<"  error"<<endl;
	else inv.poner_prod(product);
}

void quitar_prod(inventory& inv){
	string product;
	cin>>product;
	cout<<"quitar_prod "<<product<<endl; //producto tiene que ser cero cantidad
	if(inv.exists(product) and inv.consultar_prod(product)==0) inv.quitar_prod(product);
	else cout<<"  error"<<endl;
}

void poner_items(warehouse& a, inventory& i){
	int sala;
	string product;
	int quantity;
	cin>>sala>>product>>quantity;
	cout<<"poner_items "<<sala<<' '<<product<<' '<<quantity<<endl;	
	--sala;
	if(i.exists(product) and a.exists(sala)) cout<<"  "<<a.poner_items(sala, product, quantity, i)<<endl;
	else cout<<"  error"<<endl;
}

void quitar_items(warehouse& a, inventory& i){
	int sala;
	string product;
	int quantity;
	cin>>sala>>product>>quantity;
	cout<<"quitar_items "<<sala<<' '<<product<<' '<<quantity<<endl;	
	--sala;
	if(i.exists(product) and a.exists(sala)) cout<<"  "<<a.quitar_items(sala, product, quantity, i)<<endl;
	else cout<<"  error"<<endl;
}

void distribuir(warehouse& w, inventory& i){
	string product;
	int quantity;
	cin>>product>>quantity;
	cout<<"distribuir "<<product<<' '<<quantity<<endl;
	if(i.exists(product)){
		cout<<"  "<<warehouse::distribuir(product, quantity, i, w)<<endl;
		//cout<<quantity<<endl;
	}
	else cout<<"  error"<<endl;
}

void compactar(warehouse& a){
	int sala;
	cin>>sala;
	cout<<"compactar "<<sala<<endl;
	--sala;
	if(a.exists(sala)) a.compactar(sala);
	else cout<<"  error"<<endl;
}

void reorganizar(warehouse& a){
	int sala;
	cin>>sala;
	cout<<"reorganizar "<<sala<<endl;
	--sala;
	if(a.exists(sala)) a.reorganizar(sala);
	else cout<<"  error"<<endl;
}

void redimensionar(warehouse& a){
	int sala, files, columnes;
	cin>>sala>>files>>columnes;
	cout<<"redimensionar "<<sala<<' '<<files<<' '<<columnes<<endl;
	--sala;
	if(a.exists(sala) and a.sala_redimensionable(sala, files, columnes)) a.redimensionar(sala, files, columnes);
	else cout<<"  error"<<endl;
}

void inventario(const inventory& i){
	cout<<"inventario"<<endl;
	i.inventario();
}

void escribir(const warehouse& a){
	int sala;
	cin>>sala;
	cout<<"escribir "<<sala<<endl;
	--sala;
	if(a.exists(sala)) a.escribir(sala);
	else cout<<"error"<<endl;
}

void consultar_pos(warehouse& a){
	int sala, fila, columna; //const MIRAR
	cin>>sala>>fila>>columna;
	cout<<"consultar_pos "<<sala<<' '<<fila<<' '<<columna<<endl;
	--sala;
	--fila; --columna;
	if(a.exists(sala) and a.pos_valid(sala, fila, columna)) cout<<"  "<<a.consultar_pos(sala, fila, columna)<<endl;
	else cout<<"  error"<<endl;
}

void consultar_prod(const inventory& inv){
	string product;
	cin>>product;
	cout<<"consultar_prod "<<product<<endl;
	if(inv.exists(product)) cout<<"  "<<inv.consultar_prod(product)<<endl;
	else cout<<"  error"<<endl;
}

int main(){
	warehouse almacen;
	int n_sales;
	cin>>n_sales;
	almacen.specify(n_sales);
	inventory inv;
	
	string option;
	
	while(cin>>option and option!="fin"){
		if(option=="poner_prod") poner_prod(inv);
		else if(option=="quitar_prod") quitar_prod(inv);
		else if(option=="poner_items") poner_items(almacen, inv);
		else if(option=="quitar_items") quitar_items(almacen, inv);
		else if(option=="distribuir") distribuir(almacen, inv);
		else if(option=="compactar") compactar(almacen);
		else if(option=="reorganizar") reorganizar(almacen);
		else if(option=="redimensionar") redimensionar(almacen);
		else if(option=="inventario") inventario(inv);
		else if(option=="escribir") escribir(almacen);
		else if(option=="consultar_pos") consultar_pos(almacen);
		else if(option=="consultar_prod") consultar_prod(inv);
	}
	cout<<"fin"<<endl;
}
inventory.cc000600 001750 000144 00000003027 13302105711 014774 0ustar00weijie.chenusers000000 000000 #include "Inventory.hh"

typedef map<string, int>::const_iterator const_it;
typedef map<string, int>::iterator it;

void inventory::poner_prod(string& name_product){
	products.insert(pair<string, int> (name_product, 0));
}

void inventory::quitar_prod(string& name_product){
	products.erase(name_product);
}

void inventory::update_quantity(string& product, int quantity){
	products[product]+=quantity;
}


void inventory::inv_sala_update(string& product, int quantity){
	products[product]+=quantity;
	if(products[product]==0) products.erase(product);
}


bool inventory::exists(string& product) const
{
	return products.find(product) != products.end();
}

int inventory::consultar_prod(string& p) const
{
	return products.find(p) -> second;
}

void inventory::inventario() const
{
	map<string , int>::const_iterator it=products.begin();
	while(it!=products.end()){
		cout<<"  ";
		cout<<it -> first<<' '<<it -> second<<endl;
		++it;
	}
}
/*
vector<string> inventory::llista(int files, int columnes) const
{
	map<string, int>::const_iterator it=products.begin();
	vector<string> s(files*columnes, "NULL");
	int i=0;
	while(it!=products.end()){
		for(int j=0; j<it->second; ++j){
			s[i]=it->first;
			++i;
		}
		++it;
	}
	return s;
}
*/
const_it inventory::const_it_inv() const
{
	return products.begin();
}

void inventory::next_const_it(const_it& iterador_const)
{
	if(iterador_const!=products.end()) ++iterador_const;
}

void inventory::reset_const_it()
{
	iterador=products.begin();
}

const_it inventory::const_it_end() const
{
	return products.end();
}
Warehouse.hh000600 001750 000144 00000007665 13301756213 014737 0ustar00weijie.chenusers000000 000000 /** @file Warehouse.hh
    @brief Especificació de la Classe warehouse.
*/
#ifndef _WAREHOUSE_
#define _WAREHOUSE_


#include "Sala.hh"
#include "Inventory.hh"

#ifndef NO_DIAGRAM

#include <vector>
#include <string>
#include "BinTree.hh"

#endif

using namespace std;
/** @class warehouse
    @brief Aquesta classe representa als magatzems.
*/

class warehouse{
    
private:
    BinTree<int> index;
    vector<sala> alm;
    int alm_size;

	static int i_distribuir(string& p, int& quantity, inventory& inv, warehouse& w, const BinTree<int>& t);
	static void BinTreeIO(BinTree<int>& T);

public:
    //Constructores
      /** @brief Constructora per defecte.

      Es crea un objecte de la classe warehouse buida.
      \pre <em>true</em>
      \post Es crea una 'warehouse' sense sales.
      \coste N/A
  */
    warehouse(){};
    
    /** @brief Constructora per còpia.
     
        Es crea una nova 'warehouse' idèntica a un altre.
        \pre <em>true</em>
        \post S'inicialitza una 'warehouse' idèntica a un altre.
     */
    warehouse(const warehouse& w);
    
    
    //Modificadores
    /** @brief Entrada per el canal iostream els identificadors de les sales.
        \pre <em>true</em>
        \post La warehouse tindrà la distribució de sales que s'ha entrat.
     */
    
    void specify(int n);
    
    /** @brief S'afegeix a la sala una quantitat de productes.
     \pre La sala 'sala' i el prodcute 'p' existeixen, 'quantity' és no negativa i l'inventory 'inv' existeix.
     \post Consultar el mètode homònim de la classe sala
    */
    int poner_items(int sala, string& p, int quantity, inventory& inv); 
    
    /** @brief Mètode que permet treure una quantitat de productes d'una sala.
     \pre La sala 'sala' i el prodcute 'p' existeixen, 'quantity' és no negativa i l'inventory 'inv' existeix.
     \post Consultar el mètode homònim de la classe sala
     */
    int quitar_items(int sala, string& p, int quantity, inventory& inv);
    
    /** @brief Mètode que distribueix, en tant que càpiga, un producte en sales consecutives del warehouse.
     \pre El prodcute 'p' existeix, la quantitat 'quantity' és no negativa i l'inventori 'inv' exiseix.
     \post Es col·loca sequancialement la quantitat de productes i es retorna el nombre de productes que no s'han pogut col·locar i s'actualitza l'inventari.
     */
    static int distribuir(string& p, int& quantity, inventory& inv, warehouse& w);
    
    /** @brief Mètode que compacta una sala.
     \pre La sala 'sala' exiseix
     \post Consultar el mètode homònim de la classe sala
     */
    void compactar(int sala);
    
    /** @brief Reorganitza la sala desitjada.
     \pre La sala 'sala' existeix
     \post Consultar el mètode homònim de la classe sala
     */
    void reorganizar(int sala);
    
    /** @brief Redimensionar l'estanteria de la sala desitjada.
     \pre La sala 'sala' existeix (consultar a la classe sala el mètode homònim).
     \post Consultar el mètode homònim de la classe sala
     */
    void redimensionar(int sala, int files, int columnes);
    
    
    //Consultores
    
    /** @brief S'escriu els productes de la sala desitjada.
     \pre La sala 'sala' existeix.
     \post Consultar mètode homònima de la classe sala
     */
    void escribir(int sala) const;
    
    /** @brief Consulta el producte (si n'hi ha) a la posició de la fila i columna de l'estanteria de la sala desitjada.
     \pre La 'sala' existeix (consultar a la classe sala el mètode homònim).
     \post Consultar el mètode homònim de la classe sala.
     */
    string consultar_pos(int sala, int fila, int columna) const;
    
    /** @brief Consultar si una sala existeix.
     \pre <em>true</em>
     \post Si la sala 'sala' existeix retorna <em>true</em> i <em>false</em> si no existeix.
     */
    bool exists(int sala) const;
    

	bool sala_redimensionable(int sala, int files, int columnes) const;
	
	
	bool pos_valid(int sala, int fila, int columna) const;
};
#endif
Sala.hh000600 001750 000144 00000010437 13302100747 013640 0ustar00weijie.chenusers000000 000000 /** @file Sala.hh
    @brief Descripció de la classe sala.
 */
#ifndef _SALA_
#define _SALA_
 
//#include "Inventory.hh"
 
#ifndef NO_DIAGRAM
#include <iostream>
#include <vector>
#include "Inventory.hh"
#endif
using namespace std;

/** @class sala
 @brief Aquesta classe representa una sala del magatzem.
 
 Dintre de les sales hi haurà una única estanteria i la prosició relativa dels productes vindrà donada per la següent definició:
 
 Direm que un prodcute 'a' està en una posició superior a un producte 'b' si la fila d''a' és menor que la fila de 'b' i en cas d'estar a la mateixa fila direm que 'a' està en una posició superior si està en una columna menor.
 */

class sala{

private:
    int n_prods;
    vector<string> stan;
    int files, columnes;
	bool compactada;
	bool full;
	inventory inv;
public:
    //Constructores
    
     /** @brief Constructa per decfecte.
     \pre <em>true</em>
     \post S'inicialitza una sala buida.
     */
    sala(){};
    
    sala(int a, int b){
		n_prods=0;
		files=a;
		columnes=b;
		compactada=true;
		if(a*b!=0) full=false;
		stan.resize(a*b, "NULL");
	}
    //Modificadores
    
    /** @brief Posar una quantitat 'quantity' de productes.
     \pre El 'product' és un producte vàlid i la quantitat és no negativa.
     \post A la sala s'afegirà una quantitat no superior a 'quantity' en funció de l'espai buit que té.
     */
    int poner_items(string& product, int quantity);
    
    
    //Si la sala nop està compactada i té espais buits però no consecutius, llavors es col·loquen productes en aquests espais?.
    
    /** @brief Treu una quantitat 'quantity' de productes.
     \pre El 'product' és un producte vàlid i la quantitat és no negativa.
     \post Es treuran de la sala una quantitat màxima 'quantity' de productes en funció de la quantitat disponible.
     */
    int quitar_items(string& product, int quantity);
    
    /** @brief Es compactarà la sala.
     \pre <em>true</em>
     \post El magatzem serà compatada de la següent manera: Si 'a,b' són prodcutes i sense pèrdua de generalitat suposem que 'a' està en una posició superior (abans de compactar) respecte 'b', llavors el compactat manté l'ordre relatiu entre els dos productes. Si entre dos productes hi havia espai buit aquesta serà omplerta seguint la norma anterior.
     */
    void compactar();
    
    /** @brief Es reorganitzarà el magatzem.
     \pre <em>true</em>
     \post Es reordenarà l'estanteria de la sala alfabèticament i la deixarà compactada.
     */
    void reorganizar();
    
    /** @brief Es redimensionarà l'estanteria de la sala.
     \pre files*columnes haurà de ser com a mínim la de la quantitat de productes.
     \post L'estanteria tindrà dimensions 'fila' x 'columna', la regla per compactar és que si 'a' i 'b' són productes qualsevols de l'estanteria i sense pèrdua de generalitat suposem que 'a' està en una posició superior respecte 'b' llavors es conservarà aquest ordre relatiu. Redimensionar també compacta l'estanteria.
     */
    void redimensionar(int files, int columnes);
    
    //Consultores
    
    /** @brief S'ecriurà el contingut de l'estanteria de la sala.
     \pre <em>true </em>
     \post S'escriurà a el contingut de les estanteries, si hi ha un producte s'escriurà l'identificador del producte, si no hi ha cap producte s'escriurà "NULL".
     */
    void escribir() const;
    
    /** @brief S'escriurà el contingut de l'estanteria continguda dintre de la posicó que es desitja.
     \pre 'fila' i 'columna' és una posició vàlida de l'estanteria.
     \post S'escriurà, si hi ha un producte, el seu identificador i si no hi ha cap producte s'escriurà "NULL".
     */
    string consultar_pos(int fila, int columna) const;
    
    /** @brief Consultar si és redimensionable amb les noves mesures.
     \pre <em>true</em>
     \post Retornarà <em>true</em> si el paràmetre implícits pot redimensionar-se amb les noves dimensions. En cas contrari retornarà <em>false</em>
     */
    bool redimensionable(int fila, int columna) const;
    
    /** @brief Consultar si una posició de l'estanteria és vàlida.
     \pre <em>true</em>
     \post Retorna <em>true</em> si la posició és vàlida. En cas contrari retornarà <em>false</em>
     */
    bool pos_valida(int fila, int columna) const;
    

    
};
#endif
Inventory.hh000600 001750 000144 00000004526 13302105713 014755 0ustar00weijie.chenusers000000 000000 /** @file Inventory.hh
    @brief Especificación de la classe inventory.
 */
#ifndef _INVENTORY_
#define _INVENTORY_

#ifndef NO_DIAGRAM
#include <map>
#include <iostream>
#include <vector>
using namespace std;
#endif
typedef map<string, int>::const_iterator const_it;
typedef map<string, int>::iterator it;
/**
 @class inventory
 @brief Aquesta classe representa l'inventari del magatzem.
 
 */

class inventory{
private:
    map<string, int> products;
    const_it iterador=products.begin();
public:
    //Constructoras
    
    /** @brief Constructa per decfecte.
     \pre <em>true</em>
     \post S'inicialitza un inventari buit.
     */
    
    inventory(){};
    
    //Modificadoras
    
    /** @brief Crear una entrada per un producte de codi 'product'.
     \pre El producte 'name_product' no estava registrat.
     \post El producte 'name_product' es registrarà.
     */
    void poner_prod(string& name_product);
    
    /** @brief Des-registrar un producte.
     \pre El producte 'name_product' existeix.
     \post El producte 'name_product' deixarà d'estar registrat. 
     */
    void quitar_prod(string& name_product);
    
    /** @brief Actualitza la quantitat d'un producte.
     \pre El producte 'product' existeix i la quantititat 'quantity' és la nova que hi ha al magatzem.
     \post La quantitat 'quantity' del producte 'product' serà actualitzada.
     */
    void update_quantity(string& product, int quantity);
    
    
    void inv_sala_update(string& product, int quantity);
    //Consultoras
    
    /** @brief Determinar si el producte 'product' està a l'inventari.
     \pre <em>true</em>
     \post Retorna 'true' si el producte existeix i 'false' si no existeix.
     */
    bool exists(string& product) const;
    
    /** @brief Consultar la quantitat de productes amb identificador 'p'.
     \pre El producte 'p' existeix.
     \post Retorna la quantitat de productes 'p'.
     */
    int consultar_prod(string& p) const;
    
     /** @brief Imprimeix l'inventari.
     \pre <em>true</em>
     \post S'imprimeix per ordre alfabètic els productes amb la quantitat que hi ha al magatzem.
     */
    void inventario() const;
	
	const_it const_it_inv() const;

	void next_const_it(const_it& iterador_const);
	
	void reset_const_it();
	
	const_it const_it_end() const;
	
    //vector<string> llista(int files, int columnes) const;
};

#endif