コード例 #1
0
ファイル: campusSeguro.cpp プロジェクト: Jorjote/fucktpsh
//Posicion campusSeguro::proxPosicion(Posicion p,Conj<Posicion>::Iterador itPos)
Posicion campusSeguro::proxPosicion(Posicion p,DiccPalabra<Posicion>::itDiccP itPos)
{
    Posicion posMasCerca=itPos.SiguienteSignificado();
    Nat distActual = _campus.Distancia(p,posMasCerca);
    while( itPos.HaySiguiente() )
    {
        if( _campus.Distancia(p,itPos.SiguienteSignificado()) < distActual )
        {
            posMasCerca=itPos.SiguienteSignificado();
            distActual=_campus.Distancia(p,posMasCerca);
        }
    itPos.Avanzar();
    }
    Conj<Posicion> vecinos = _campus.Vecinos(p);
    Conj<Posicion>::Iterador itVecinos = vecinos.CrearIt();

    Posicion sigPos = p;
    while( itVecinos.HaySiguiente() )
    {
        Posicion vec = itVecinos.Siguiente();
        if( _campus.Distancia(vec,posMasCerca) < _campus.Distancia(p,posMasCerca) && (grilla.Obtener(vec)).id==4  ) // la grilla el campo id es de DatosPos
        {
            sigPos=vec;
        }
        itVecinos.Avanzar();
    }

    return sigPos;
}
コード例 #2
0
ファイル: test_catedra.cpp プロジェクト: lucasputer/algo2_tp3
void test_inspeccion_con_empate() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ca");

    Conj<Caracteristica> cs1;
    cs1.Agregar("cb");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Retiro");
    ASSERT_EQ(d.CantidadRobotsActivos(),4);
    d.Mover(0, "Retiro");
    d.Mover(1, "Retiro");
    d.Mover(2, "Retiro");
    d.Inspeccion("Retiro"); // debe volar un solo RUR del conj {0,1,2}

    ASSERT_EQ(d.CantidadRobotsActivos(),3);

    infoRobots info = getDatosRobotsActivos(d);
    // Chequeo que los que quedan están ok
    // Alguno de los primeros RURs tuvo que desaparecer
    ASSERT(!(info.estaciones.Definido(0) && info.estaciones.Definido(1) && info.estaciones.Definido(2)));
    ASSERT_EQ(info.estaciones.Significado(3),"Retiro");
    ASSERT_EQ(info.infracciones.Significado(3),0);
}
コード例 #3
0
ファイル: campus.cpp プロジェクト: Jorjote/fucktpsh
Conj<Posicion> campus::IngresosCercanos(Posicion p)
{
Conj<Posicion> res;
Posicion posIngresoFilaUno;//(p.x,0); // ACA LA PRIMER FILA ES LA 0 (CAPAZ HAY QUE MODIFICARLO)
posIngresoFilaUno.x = p.x;
posIngresoFilaUno.y = 0;

Posicion posIngresoUltimaFila;//(p.x,Filas()-1); // LA ULTIMA FILA ES LA CANTIDAD DE FILAS - 1 (CAPAZ HAY QUE MODIFICARLO)
posIngresoUltimaFila.x = p.x;
posIngresoUltimaFila.y = Filas()-1;
if( Distancia(p,posIngresoFilaUno) < Distancia(p,posIngresoUltimaFila) ) // caso <
{
    res.AgregarRapido(posIngresoFilaUno);
}
else
{
    if(  Distancia(p,posIngresoFilaUno) > Distancia(p,posIngresoUltimaFila)  ) // caso >
    {
       res.AgregarRapido(posIngresoUltimaFila);
    }
    else
    {//caso ==
        res.AgregarRapido(posIngresoFilaUno);
        res.AgregarRapido(posIngresoUltimaFila);
    }
}
return res;
}
コード例 #4
0
ファイル: campus.cpp プロジェクト: Jorjote/fucktpsh
Conj<Posicion> campus::Vecinos(Posicion p)
{// retorna vecinos validos dentro dela grilla,no importa si estan ocupados.
    Posicion posArriba;//( p.x ,p.y-1);
    posArriba.x = p.x;
    posArriba.y = p.y-1;

    Posicion posAbajo;//( p.x,p.y+1);
    posAbajo.x = p.x;
    posAbajo.y = p.y+1;

    Posicion posDer;//(p.x+1,p.y);
    posDer.x = p.x+1;
    posDer.y = p.y;

    Posicion posIzq;//(p.x-1,p.y);
    posIzq.x = p.x-1;
    posIzq.y = p.y;

    Conj<Posicion> res;
    // Agrego las posiciones validas:
    if (Valida(posArriba)){  res.AgregarRapido(posArriba); }
    if (Valida(posAbajo)) {  res.AgregarRapido(posAbajo);  }
    if (Valida(posDer))   {  res.AgregarRapido(posDer);    }
    if (Valida(posIzq))   {  res.AgregarRapido(posIzq);    }
    return res;
}
コード例 #5
0
ファイル: test.old.cpp プロジェクト: FerFrassia/algo2tp3
void test_restriccion() {
    Rest rojo("rojo");
    Rest amarillo("Amarillo");
    Rest verde("VERDE");
    
    Rest res1((rojo.OR(amarillo)).AND(verde.NOT()));
    
    
//    Rest res1("(rojo | Amarillo) & !VERDE");
    Conj<Caracteristica> carac;
    carac.Agregar("Amarillo");
    
//    ASSERT(res1 -> Verifica(carac));
    ASSERT(res1.Verifica(carac));
    
    Rest coso("Coso");
    Rest noCoso(coso.NOT());
    Rest res2 = res1.AND(noCoso);
    
    carac.Agregar("Coso");
    ASSERT(res1.Verifica(carac));
    ASSERT(!res2.Verifica(carac));
    
    Conj<Caracteristica> carac2;
    carac2.Agregar("Coso");
    Rest siCoso = noCoso.NOT();
    ASSERT(siCoso.Verifica(carac2));
}
コード例 #6
0
ファイル: BaseDeDatos.cpp プロジェクト: Asdolo/algo2-tp3
Conj<Registro_tp3> BaseDeDatos::combinarRegistros(string t1, string t2, string campo) const {
    assert( _nombreATabla.def(t1) && _nombreATabla.def(t2) );
    assert( _nombreATabla.obtener(t1).campos().Pertenece(campo) );
    assert( _nombreATabla.obtener(t2).campos().Pertenece(campo) );

    Tabla tabla1 = _nombreATabla.obtener(t1);
    Tabla tabla2 = _nombreATabla.obtener(t2);
    Conj<Registro_tp3>::const_Iterador it;

    Tabla tablaIt = (tabla1.indices().Pertenece(campo))? tabla2 : tabla1;
    Tabla tablaBusq = (tabla1.indices().Pertenece(campo))? tabla1 : tabla2;
    it = tablaIt.registros().CrearIt();

    Conj<Registro_tp3> res;

    while (it.HaySiguiente()) {
        Registro_tp3 regMergeado;
        Dato d = it.Siguiente().obtener(campo);
        Lista<Registro_tp3> coincis = tablaBusq.buscar(campo, d);
        if (!coincis.EsVacia()) {
            if (tablaBusq.nombre() == t1) {
                regMergeado = Merge(coincis.Primero(), it.Siguiente());
            } else {
                regMergeado = Merge(it.Siguiente(), coincis.Primero());
            }
        }
        Lista<struct tupString<Dato> >::const_Iterador ver_Vacio = regMergeado.vistaDicc();
        if (ver_Vacio.HaySiguiente()) res.AgregarRapido(regMergeado);
        it.Avanzar();
    }
    return res;
}
コード例 #7
0
ファイル: SistemaLaboral.cpp プロジェクト: ealmansi/algo2-tp3
Conj<Gremio> SistemaLaboral::obtenerGremios() const
{
    Conj<Gremio> result;
    for (Nat i = 0; i < sl.Longitud(); i++)
        result.AgregarRapido(sl[i]);

    return result;
}
コード例 #8
0
ファイル: registro.cpp プロジェクト: nippolito/Algo2
Conj<String> Registro::Campos() const{
	Conj<String> res;
	typename Dicc<String,Dato>::const_Iterador it = dic.CrearIt();
	while (it.HaySiguiente()){
		res.AgregarRapido(it.SiguienteClave());
		it.Avanzar();
	}
	return res;
}
コード例 #9
0
ファイル: planta.cpp プロジェクト: aaronson/AED2
Conj<unsigned int> Planta::verOrdenes() const{
	Conj<unsigned int> res;
	Secu<ordtars>::const_iterador it = this->terminadas.crearIt();
	while (it.hayMas()){
		res.agregar(it.actual().orden);
		it.avanzar();
	}
	return res;
}
コード例 #10
0
ファイル: Campus.cpp プロジェクト: FerFrassia/algo2-2015
Conj<Posicion> Campus::IngresosMasCercanos(Posicion pos) {
    Conj<Posicion> conjunto = Conj<Posicion>();
    Posicion superior = Posicion(pos.x, 0);
    Posicion inferior = Posicion(pos.x, Filas()-1);
    if (Distancia(pos, superior) <= Distancia(pos, inferior))
        conjunto.Agregar(superior);
    if (Distancia(pos, superior) >= Distancia(pos, inferior))
        conjunto.Agregar(inferior);
    return conjunto;
}
コード例 #11
0
ファイル: red.cpp プロジェクト: manucosta/algo2-tp3
Conj<Compu> Red::Computadoras(){
	vector<string> vec = vecinos.claves();
  
  Conj<Compu> con;
  for(unsigned int i = 0; i<vec.size(); i++){
    con.Agregar(vec[i]);
  }

	return con;
}
コード例 #12
0
ファイル: Driver.cpp プロジェクト: julifgo/tp3
const Interfaz Driver::IesimaInterfazDe(const Computadora& c, Nat i) const {
    assert(i < dameCompu(c).Interfaces().Cardinal());
    //cout<<"Interfaces de la compu: "<<dameCompu(c).Interfaces()<<endl;
    Conj<dcnet::Interfaz> conj = dameCompu(c).Interfaces();
    Conj<dcnet::Interfaz>::Iterador it = conj.CrearIt();
    while(i-- > 0) {
        it.Avanzar();
    }
    return it.Siguiente();
}
コード例 #13
0
ファイル: Temporada.cpp プロジェクト: svilerino/Algoritmos-II
Conj<Gremio> Temporada::gremiosNegociando() const{
	Conj<Gremio> res;
	Conj<Paritaria>::const_Iterador it = this->paritariasAbiertas.CrearIt();
	while(it.HaySiguiente()){
		Paritaria pa = it.Siguiente();
		res.AgregarRapido(pa.obtenerGremio());
		it.Avanzar();
	}
	return res;
}
コード例 #14
0
ファイル: Campus.cpp プロジェクト: FerFrassia/algo2-2015
Conj<Posicion> Campus::Vecinos(Posicion pos) {
    Conj<Posicion> conjPosiciones = Conj<Posicion>();

    if (PosValida(ProxPosicion(pos, abajo))) {
        conjPosiciones.AgregarRapido(ProxPosicion(pos, abajo));
    } else {
        conjPosiciones.AgregarRapido(Posicion(-1, -1));
    }

    if (PosValida(ProxPosicion(pos, arriba))) {
        conjPosiciones.AgregarRapido(ProxPosicion(pos, arriba));
    } else {
        conjPosiciones.AgregarRapido(Posicion(-1, -1));
    }

    if (PosValida(ProxPosicion(pos, der))) {
        conjPosiciones.AgregarRapido(ProxPosicion(pos, der));
    } else {
        conjPosiciones.AgregarRapido(Posicion(-1, -1));
    }

    if (PosValida(ProxPosicion(pos, izq))) {
        conjPosiciones.AgregarRapido(ProxPosicion(pos, izq));
    } else {
        conjPosiciones.AgregarRapido(Posicion(-1, -1));
    }

    return conjPosiciones;

}
コード例 #15
0
ファイル: campusSeguro.cpp プロジェクト: Jorjote/fucktpsh
void campusSeguro::actualizarDatosAgentes(Conj<Posicion> c)
{
    Posicion posActual;
    Conj<Posicion>::Iterador it = c.CrearIt();
    while( it.HaySiguiente() )
    {
        posActual=it.Siguiente();
        if( posCapturable(posActual,_campus) )
        {
            Conj<Posicion> vecinosDePosActual = _campus.Vecinos(posActual);
            Conj<Posicion>::Iterador itVec = vecinosDePosActual.CrearIt();
            while( itVec.HaySiguiente())
            {
                Posicion vecActual = itVec.Siguiente();
                if( esAgente(vecActual) && esHippie(posActual) )
                {
                    diccHash<Agente,Datos>::Iterador datosVec = grilla.Obtener(vecActual).datosAgente;
                    datosVec.SiguienteSignificado().hippiesAtrapados++;
                    Nat cantAtrapadosVec = datosVec.SiguienteSignificado().hippiesAtrapados;

                if(cantAtrapadosVec > _masVigilante.cantAtrapados  )
                {
                    (_masVigilante).agente = datosVec.SiguienteClave();
                    (_masVigilante).cantAtrapados = cantAtrapadosVec;
                }

                if( (cantAtrapadosVec == (_masVigilante).cantAtrapados) && ( datosVec.SiguienteClave()< (_masVigilante).agente) )
                {
                    (_masVigilante).agente = datosVec.SiguienteClave();
                    (_masVigilante).cantAtrapados = cantAtrapadosVec;
                }
                }

                if( esAgente(vecActual) && esEstudiante(posActual) )
                {
                    //diccHash<Agente,Datos>::Iterador datosVec = grilla.Obtener(vecActual).datosAgente;
                    //datosVec.SiguienteSignificado().Sanciones++;
                    //Nat vecSancionesActual = datosVec.SiguienteSignificado().Sanciones;

                    Agente ac = grilla.Obtener(posActual).placa;
                    datosAgentes.Obtener(ac).Sanciones ++;

                    //Nat vecSancionesActual = datosAgentes.Obtener(ac).Sanciones;
                    //datosAgentes.Obtener(ac).claseConMismasSanciones.ItActualizarElem(vecSancionesActual);

                    //datosVec.SiguienteSignificado().claseConMismasSanciones.ItActualizarElem(vecSancionesActual);  // CREOOO QUE ES DE CONJEQU
                    (KSanciones).buffer = false;
                }

            itVec.Avanzar();
            }
        }
        it.Avanzar();
    }
}
コード例 #16
0
ファイル: red.cpp プロジェクト: julifgo/tp3
	Conj<Lista<Compu> >& Red::CaminosQueEmpiezanConPcx(const Conj<Lista<Compu> >& caminos, const Compu& pcx) const {
		Conj<Lista<Compu> >* res = new Conj<Lista<Compu> >();
		Conj<Lista<Compu> >::const_Iterador it = caminos.CrearIt();
		while(it.HaySiguiente()) {
			if(it.Siguiente()[0] == pcx) {
				res->AgregarRapido(it.Siguiente());
			}
			it.Avanzar();
		}
		return *res;
	}
コード例 #17
0
ファイル: red.cpp プロジェクト: manucosta/algo2-tp3
Conj<Compu> Red::Vecinos(Compu c){
  DiccString<unsigned int> * x = vecinos.obtener(c);

	vector<string> vec = x->claves();
  
  Conj<Compu> con;
  for(unsigned int i = 0; i<vec.size(); i++){
    con.Agregar(vec[i]);
  }
  return con;
}
コード例 #18
0
ファイル: planta.cpp プロジェクト: aaronson/AED2
Conj<unsigned int> Planta::ordenesFinalizadas() const{
	Conj<unsigned int> res;
	Secu<ordtars>::const_iterador it = this->terminadas.crearIt();
	while (it.hayMas()){
		if (terminoOrden(it.actual().tareas, this->wkf.cantidadTareas())){
			res.agregar(it.actual().orden);
		}
		it.avanzar();
	}
	return res;
}
コード例 #19
0
ファイル: SistemaLaboral.cpp プロジェクト: ealmansi/algo2-tp3
Conj<Nat> SistemaLaboral::obtenerAliados(const Nat idGremio) const
{
    Nat idGrupoTarget = sl[idGremio].obtenerIdGrupo();

    Conj<Nat> result;
    for (Nat i = 0; i < sl.Longitud(); i++)
        if ((i != idGremio) && (sl[i].obtenerIdGrupo() == idGrupoTarget))
            result.AgregarRapido(i);

    return result;
}
コード例 #20
0
ファイル: Driver.cpp プロジェクト: nippolito/Algo2
bool Driver::tieneIndiceString(const NombreTabla& tabla) const
{
   const Conj<String> indices = b.DameTabla(tabla).Indices();
  typename Conj<String>::const_Iterador it = indices.CrearIt();
  bool res= false;
  while(it.HaySiguiente() && !res){
    res = !(b.DameTabla(tabla).TipoCampo(it.Siguiente()));
    it.Avanzar();
  }
  return res;
  //assert(false);
}
コード例 #21
0
ファイル: red.cpp プロジェクト: manucosta/algo2-tp3
Conj<Lista<Compu> > Red::CaminosMinimos(Compu c1, Compu c2){
  Nat k = 1;
  Nat n = Computadoras().Cardinal();
  Conj<Lista<Compu> > x = CaminosDeLargoN(c1, c2, k);
 
	while(k<n && x.EsVacio()){
    k++;	
		x = CaminosDeLargoN(c1,c2, k);
  }
  return x;
	
}
コード例 #22
0
ファイル: Temporada.cpp プロジェクト: svilerino/Algoritmos-II
Conj<nat> Temporada::obtenerGremiosConAcuerdos() const{
	Conj<nat> res;
	for(nat j=0;j<this->acuerdosPorGrupo.Longitud();j++){
		Lista<Acuerdo>::const_Iterador acuerdosDeGrupo = this->acuerdosPorGrupo[j].CrearIt();
		while(acuerdosDeGrupo.HaySiguiente()){
			Acuerdo ac = acuerdosDeGrupo.Siguiente();
			res.AgregarRapido(ac.obtenerGremio().obtenerIdGremio());
			acuerdosDeGrupo.Avanzar();
		}
	}
	return res;
}
コード例 #23
0
ファイル: red.cpp プロジェクト: julifgo/tp3
	Conj<Lista<Compu> >& Red::CaminosQueTerminanConPcx(const Conj<Lista<Compu> >& caminos, const Compu& pcx) const {
		Conj<Lista<Compu> >* res = new Conj<Lista<Compu> >();
		Conj<Lista<Compu> >::const_Iterador it = caminos.CrearIt();
		while(it.HaySiguiente()) {
			Lista<Compu>::const_Iterador itUlt = it.Siguiente().CrearItUlt();
			if(itUlt.Anterior() == pcx) {
				res->AgregarRapido(it.Siguiente());
			}
			it.Avanzar();
		}
		return *res;
	}
コード例 #24
0
ファイル: Driver.cpp プロジェクト: nippolito/Algo2
aed2::Conj<Driver::Registro> Driver::vistaJoin(const NombreTabla& tabla1, const NombreTabla& tabla2)
{
  Conj<Driver::Registro> res;
  Conj<modulos::Registro> cr = b.VistaJoin(tabla1,tabla2).Siguiente().Registros();
  typename Conj<modulos::Registro>::Iterador itr = cr.CrearIt();
  while(itr.HaySiguiente()){
    res.Agregar(RNRS(itr.Siguiente()));
    itr.Avanzar();
  }
  return res;
  //assert(false);
}
コード例 #25
0
ファイル: test.old.cpp プロジェクト: FerFrassia/algo2tp3
/**
 * Ejemplo de caso de test, con llamadas a las rutinas de aserción 
 * definidas en mini_test.h
 */
void test_ciudad_simple()
{
    Conj<Estacion> estaciones;
    estaciones.Agregar("Belgrano");
    estaciones.Agregar("Retiro");
    estaciones.Agregar("Martinez");

    Driver caba(estaciones);

    caba.AgregarSenda("Belgrano", "Retiro", "(trenDePasajeros | trenDeCarga) & !trenDeLaAlegria");
    caba.AgregarSenda("Martinez", "Retiro", "trenDeLaAlegria");
    caba.AgregarSenda("Martinez", "Belgrano", "trenDePasajeros");

    Conj<Caracteristica> r1, r2, r3;
    r1.Agregar("trenDePasajeros");
    r2.Agregar("trenDeCarga");
    r3.Agregar("trenDeLaAlegria");

    caba.Entrar(r1,"Belgrano"); // RUR 0
    caba.Entrar(r2,"Retiro");   // RUR 1
    caba.Entrar(r3,"Martinez"); // RUR 2

    ASSERT_EQ(caba.CantidadEstaciones(), 3);
    ASSERT_EQ(caba.CantidadRobotsActivos(), 3);
    ASSERT_EQ(caba.CantidadDeSendasParaEstacion("Belgrano"), 2);

    caba.Mover(0,"Retiro");    // RUR 0: 0 infracciones
    caba.Mover(0,"Martinez");  // RUR 0: 1 infracciones

    caba.Mover(1,"Belgrano");  // RUR 1: 0 infracciones
    caba.Mover(1,"Martinez");  // RUR 1: 1 infracciones

    caba.Mover(2,"Belgrano");  // RUR 2: 1 infracciones
    caba.Mover(2,"Retiro");    // RUR 2: 2 infracciones

    Dicc<RUR,Nat> infraccionesRobots;

    // Chequeo infracciones iterando los robots
    for (Nat i = 0;  i< caba.CantidadRobotsActivos(); ++i)
        infraccionesRobots.Definir(caba.IesimoRobotActivo(i),caba.CantInfraccionesIesimoRobotActivo(i));

    ASSERT_EQ(infraccionesRobots.Significado(0), 1);
    ASSERT_EQ(infraccionesRobots.Significado(1), 1);
    ASSERT_EQ(infraccionesRobots.Significado(2), 2);

    ASSERT_EQ(caba.ElMasInfractor(),2);

    // Vuela un robot
    caba.Inspeccion("Retiro");
    ASSERT_EQ(caba.CantidadRobotsActivos(),2);

}
コード例 #26
0
ファイル: red.cpp プロジェクト: julifgo/tp3
	Interfaz Red::Max(const Conj<Interfaz>& conj) const {
		assert(conj.Cardinal() > 0);

		Conj<Interfaz>::const_Iterador it = conj.CrearIt();
		Interfaz max = it.Siguiente();
		while (it.HaySiguiente()){
			if(max <= it.Siguiente()){
				max = it.Siguiente();
			}
			it.Avanzar();
		}
		return max;
	}
コード例 #27
0
bool campusSeguro::posConvertibleAEstudiante(Posicion p,campus c)
{
    Conj<Posicion> vecinos = c.Vecinos(p);
    Conj<Posicion>::Iterador it = vecinos.CrearIt();
    Nat cantEstudiantes = 0;
    while(  it.HaySiguiente() )
    {
       Posicion posVec = it.Siguiente();
       if( (grilla.Obtener(posVec)).id==1  ) {cantEstudiantes=cantEstudiantes+1;}
       it.Avanzar();
    }
    return cantEstudiantes==4;
}
コード例 #28
0
ファイル: registro.cpp プロジェクト: nippolito/Algo2
Conj<String> Registro::DiferenciaSimetrica(const Registro r2) const{
	Conj<String> res;
	Conj<String> c2(r2.Campos());
	typename Conj<String>::Iterador it = c2.CrearIt();
	Conj<String> c1(Campos());
	while(it.HaySiguiente()){
		if(!(c1.Pertenece(it.Siguiente()))){
			res.AgregarRapido(it.Siguiente());
		}
		it.Avanzar();
	}
	return res;
}
コード例 #29
0
ファイル: Driver.cpp プロジェクト: nippolito/Algo2
aed2::Conj<Driver::Registro> Driver::buscar(const NombreTabla& tabla, const aed2::Driver::Registro& criterio) const
{
  Conj<Driver::Registro> res;
  modulos::Registro crit = RSRN(criterio);
  Conj<modulos::Registro> cr = b.DameTabla(tabla).BuscarT(crit);
  typename Conj<modulos::Registro>::Iterador itr = cr.CrearIt();
  while(itr.HaySiguiente()){
    res.Agregar(RNRS(itr.Siguiente()));
    itr.Avanzar();
  }
  return res;
  //assert(false);
}
コード例 #30
0
ファイル: Campus.cpp プロジェクト: FerFrassia/algo2-2015
Arreglo<Posicion> Campus::DeConjAArreglo(Conj<Posicion> c) {
    Arreglo<Posicion> arreglo = Arreglo<Posicion>(c.Cardinal());
    Conj<Posicion>::Iterador itConjunto = c.CrearIt();
    Nat i = 0;
    while (itConjunto.HaySiguiente()) {
        // Copiar lo siguiente..
        if (itConjunto.Siguiente() != Posicion(-1, -1)) {
            arreglo.Definir(i, itConjunto.Siguiente());
        }
        ++i;
        itConjunto.Avanzar();
    }
    return arreglo;
}