Ayuda con Pascal ^_^u

[Lux]

Bueg, negrada de la UADE de usar pilas y cosads.

En fin.
El ejercicio pide que cargue datos en dos pilas, A y B, independientemente.
Luego, evaluar si los elementos de B están incluidos entre los elementos de A.

Sin importar su orden.

Es decir, si tengo una pila A:

A|1 0 4 6 7 3 2 5

y otra pila B|2 5 0

tengo que decir si B está incluído en A...
O no [b|2 5 8 por ej]

No tengo que evaluar si justo 2 5 0 estan magicamente dentro de a [a|1 0 2 5 0, por ej]


En fin.
Solamente puedo usar operaciones de pilas:
inicializarpila(PILA): la limpia de cualquier basura
tope(PILA): el tope
apilar(PILA,variable): mete como tope de la pila esa variable.
desapilar(PILA): saca el tope de esa pila
Pilavacía(PILA): determina si está vacía

whiles [sin contadores ni cosas rarasd] o ifs


hasta el momento tengo esto:

program tp1;
uses pilacola;
var
  e: integer;
  PilaA: pila;
  PilaB: pila;
  PilaAux: pila;
begin
  InicializarPila(PilaA);
  InicializarPila(PilaB);
  InicializarPila(PilaAux);
  writeln('Ingrese elementos para pila A. -1 para detener el programa');
  Read(e);
  While e<>-1 do
  begin
    Apilar(PilaA,e);
    Read(e);
  end;
  writeln('ingrese elementos para pila B. -1 para detener el programa');
  Read(e);
  While e<>-1 do
  begin
    Apilar(PilaB,e);
    Read(e);
  end;

  while NOT(Pilavacia(PilaA)) AND NOT(pilavacia(pilaB)) do
  begin
    while NOT(Pilavacia(PilaA)) AND NOT(Pilavacia(PilaB)) do
    begin
      if Tope(PilaA)=Tope(PilaB) then
        begin
          apilar(pilaaux,tope(pilaA));
          Desapilar(PilaA);
          Desapilar(PilaB);
        end
      else
        begin
          Apilar(PilaAux,Tope(PilaA));
          Desapilar(PilaA);
        end;
      end;
    end;

    while NOT(Pilavacia(PilaAux)) do
    begin
      apilar(PilaA,Tope(PilaAux));
      Desapilar(PilaAux)
    end;


  if Pilavacia(pilaB) then
    begin
    WriteLn('B esta incluida en A');
    end
  else
    begin
    WriteLn('B no esta incluida en A');
    end
  end.

El coso funciona de maravillas. El problema es que solo me anda si están ordenados. O sea, si por ejemplo, tengo una pila

A|5 6 7 0 2 1* (1 es tope)
y
B|5 0 2

Funciona joya. No le importa que haya elementos en el medio ni nada por el estilo. Lo que si le importa es que el 5 0 2 este en orden. Si fuera 5 2 0, cagué. El programa no vuelve a analizar para atrás. Es obvio que el 5 el 2 y el 0 están dentro de A, pero buep...

Ese es el problema y no sé como lograr que analice para atrasdsd =(

No seg, kpoyo? diablo? [ngds]

[Lux]

Ah, para no complicarme mucho la vida [?], imaginense que en la pila hay elementos unicos. O sea, ningun elemento se repite.

[MoaLaiSkirulais]

no entendi lo del orden:

B|5 0 2 pila ordenada ???

[Lux]

me refiero a que analiza secuencialmente [?]
primero el 2, despues el 0 y por ultimo el 5
si en A, la secuencia de elementos cambia, no funca

[creo q no me expliqué muy biends]

[MoaLaiSkirulais]

ah orden relativo entre A y B...

y ordena las pilas antes.. hacete una rutina con las primitivas tb ordenaPila(A)

??

[Lux]

O sea, está ordenada si la contrastas con A.

en b:
tope 2
segundo 0
base 5

en a
tope 2
segundo no importa
tercero tampoco
cuarto 0
quinto no importa
base 5

el programa funciona bien.

Pero, si A:
tope 5
segundo no importa
tercero tampoco
cuarto 0
quinto 2

no funciona =*

[MoaLaiSkirulais]

ordenando las pilas funciona bien independientemente del contraste..

y sino mientras vas descargando A para comparar la vas rearmando en C

estaB=false
mientras (~vacia(B) y ~estaB){
mientras (~vacia(A) y y ~estaB){
  estaB=(tope(B)=tope(A))
  push(C,pop(A))
}
}

//desagota A
mientras (~vacia(A) y estaB)
  push(A,pop(C))

//recarga A
mientras (~vacia(C) y estaB){
  push(A,pop(C))
}

pop(B)
} 

¿?

[Lux]

juajuj u.u

[emiii]

con esas funciones enfermisimas creo que es asi y me faltaba agregar el or bien pero en mi mente es asi recontra no optimizado.

while NOT (Pilavacia(PilaB) OR (pilavacia (PilaA) AND pilavacia (pilaaux)) do
begin
while NOT Pilavacia(PilaA) do
begin
if Tope(PilaA)=Tope(PilaB) then
begin
Desapilar(PilaA);
Desapilar(PilaB);
end
else
begin
Apilar(PilaAux,Tope(PilaA));
Desapilar(PilaA);
end;
end;
end;

while NOT Pilavacia(PilaAux) do
begin
if Tope(PilaB)=Tope(PilaAux) then
begin
Desapilar(PilaB);
Desapilar(PilaAux);
end
else
begin
Apilar(PilaA,Tope(PilaAux));
Desapilar(PilaAux);
end;
end;
end;
end;

despues te fijas si pilab esta vacia y adios marioneta-

[judío ginger daywalker petiso]

a vos te piden que tu programa lea dos conjuntos de numeros, A y B, y dps te diga si A esta contenido en B. eso significa que cada elemento de A esta en B. no importa que esten repetidos. si tenes cuatro "5" en A, con que haya uno en B, para mi, alcanza.

como te dijeron, tenes varias formas... la mas obvia es ordenar ambas pilas y dps desapilar elemento a elemento, teniendo cuidado de como operar con valores repetidos. esto es de complejidad n log n si sabes ordenar en n log n. si no sabes programar un mergesort o un heapsort, ni te gastes, pq ordenando por burbujeo o seleccion terminas denuevo en n^2.
la otra, rata, es ir desapilando A y por cada elemento que sacas, buscarlo en B. eso implica que tendrias q ir volcando B en otra pila temporal, y dps swapear identificadores. esto es n^2 en complejidad.

K

[Lux]

program tp1obligatorio;
uses pilacola;
var
  e: integer;
  PilaA: pila;
  PilaB: pila;
  PilaAux: pila;
begin
  InicializarPila(PilaA);
  InicializarPila(PilaB);
  InicializarPila(PilaAux);

  writeln('Ingrese valores para A. -1 para detener ingreso');
  Read(e);
  While e<>-1 do
  begin
    Apilar(PilaA,e);
    Read(e);
  end;

  writeln('Ingrese valores para B. -1 para detener ingreso');
  Read(e);
  While e<>-1 do
  begin
    Apilar(PilaB,e);
    Read(e);
  end;

  while NoT(PilaVacia(PilaA)) AND NoT(PilaVacia(PilaB)) do
  begin
    while NoT(PilaVacia(PilaA)) AND NoT(PilaVacia(PilaB)) do
    begin
      if Tope(PilaA)=Tope(PilaB) then
        begin
          Apilar(PilaAux,Tope(PilaA));
          Desapilar(PilaA);
          Desapilar(PilaB);
        end
      else
        begin
          Apilar(PilaAux,Tope(PilaA));
          Desapilar(PilaA);
        end;
    end;

    while NoT(PilaVacia(PilaAux)) AND NoT(PilaVacia(PilaB)) do
    begin
      apilar(PilaA,Tope(PilaAux));
      Desapilar(PilaAux)
    end;

  if PilaVacia(PilaB) then
    begin
      WriteLn('B esta incluida en A');
    end
  else
    begin
      WriteLn('B no esta incluida en A');
    end;
  end;
end.

Listop
Logré que no le importe si están ordenados o no.

El problema es que ahora, juAJuj, cuando pila B NO està incluido posta (un elemento descolgado), queda loopeando en el apilado y desapilado de B.

[Chuwacca]

Hola, estaria bueno que copies el enunciado del problema.
Los elementos de la pila estan ordenados?