Ledger Nano X - The secure hardware wallet
SHARE
TWEET

EjercicioPilas1_pract

BarbaraE Apr 6th, 2020 (edited) 189 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "pila.h"
  4. #include <conio.h>
  5. #include <time.h>
  6. #include <windows.h>
  7.  
  8. /*
  9. 1)1. Cargar desde el teclado una pila DADA con 5 elementos.
  10. Pasar los tres primeros elementos a la pila AUX1 y los dos
  11. restantes a la pila AUX2, ambas pilas inicializadas en vacío.
  12.  
  13.     Pila DADA, AUX1, AUX2;
  14.     inicpila(&DADA);
  15.     inicpila(&AUX1);
  16.     inicpila(&AUX2);
  17.  
  18.     leer(&DADA);
  19.     leer(&DADA);
  20.     leer(&DADA);
  21.     leer(&DADA);
  22.     leer(&DADA);
  23.  
  24.     printf("Pila DADA\n");
  25.     mostrar(&DADA);
  26.  
  27.     apilar(&AUX1, desapilar(&DADA));
  28.     apilar(&AUX1, desapilar(&DADA));
  29.     apilar(&AUX1, desapilar(&DADA));
  30.  
  31.     printf("Pila AUX1\n");
  32.     mostrar(&AUX1);
  33.  
  34.  
  35.     while(!pilavacia(&DADA)){
  36.         apilar(&AUX2, desapilar(&DADA));
  37.  
  38.     }
  39.  
  40.     printf("Pila AUX2\n");
  41.     mostrar(&AUX2);
  42.  
  43. -------------------------------------------------------------
  44. -------------------------------------------------------------
  45. 2)2. Cargar desde el teclado la pila ORIGEN e inicializar en
  46. vacío la pila DESTINO. Pasar todos los elementos de la pila
  47. ORIGEN a la pila DESTINO.
  48.  
  49.     Pila ORIGEN, DESTINO;
  50.     inicpila(&ORIGEN);
  51.     inicpila(&DESTINO);
  52.     char stop='s';
  53.  
  54.     do{
  55.         leer(&ORIGEN);
  56.         printf("Si desea continuar presione s \n");
  57.         fflush(stdin);
  58.         scanf("%c", &stop);
  59.     }while (stop== 's');
  60.  
  61.     printf("Pila ORIGEN\n");
  62.     mostrar(&ORIGEN);
  63.  
  64.     while(!pilavacia(&ORIGEN)){
  65.         apilar(&DESTINO, desapilar(&ORIGEN));
  66.     }
  67.  
  68.     printf("Pila ORIGEN despues de desapilarla\n");
  69.     mostrar(&ORIGEN);
  70.     printf("Pila DESTINO\n");
  71.     mostrar(&DESTINO);
  72. -------------------------------------------------------------
  73. -------------------------------------------------------------
  74. 3. Cargar desde teclado una pila DADA y pasar a la pila
  75. DISTINTOS todos aquellos elementos distintos al valor 8.
  76.  
  77.     Pila DADA, DISTINTOS, AUX;
  78.     inicpila(&DADA);
  79.     inicpila(&DISTINTOS);
  80.     inicpila(&AUX);
  81.     char stop='s';
  82.  
  83.     do{
  84.         leer(&DADA);
  85.         printf("Si desea continuar presione s \n");
  86.         fflush(stdin);
  87.         scanf("%c", &stop);
  88.     }while (stop== 's');
  89.  
  90.     printf("Pila ORIGEN\n");
  91.     mostrar(&DADA);
  92.  
  93.     while(!pilavacia(&DADA)){
  94.  
  95.             if(tope(&DADA)!= 8){
  96.                 apilar(&DISTINTOS, desapilar(&DADA));
  97.             }else {
  98.                 apilar(&AUX, desapilar(&DADA));
  99.  
  100.             }
  101.     }
  102.     while(!pilavacia(&AUX)){
  103.         apilar(&DADA, desapilar(&AUX));
  104.     }
  105.     printf("Pila ORIGEN despues de desapilarla\n");
  106.     mostrar(&DADA);
  107.  
  108.     printf("Pila DISTINTOS A 8\n");
  109.     mostrar(&DISTINTOS);
  110.  
  111. -------------------------------------------------------------
  112. -------------------------------------------------------------
  113. 4. Cargar desde el teclado la pila ORIGEN e inicializar
  114. en vacío la pila DESTINO. Pasar los elementos de la pila
  115. ORIGEN a la pila DESTINO, pero dejándolos en el mismo orden.
  116.  
  117.     Pila ORIGEN, DESTINO, AUX;
  118.     inicpila(&ORIGEN);
  119.     inicpila(&DESTINO);
  120.     inicpila(&AUX);
  121.     char stop='s';
  122.  
  123.     do{
  124.         leer(&ORIGEN);
  125.         printf("Si desea continuar presione s \n");
  126.         fflush(stdin);
  127.         scanf("%c", &stop);
  128.     }while (stop== 's');
  129.  
  130.     printf("Pila ORIGEN\n");
  131.     mostrar(&ORIGEN);
  132.  
  133.     /////////////////////////////////////////////////////////
  134.     TENGO QUE DESAPILAR ORIGEN Y APILAR EN AUXILIAR: 1 2 3 4
  135.     CUANDO APILO EN AUXILIAR SE APILA: 4 3 2 1
  136.     DESAPILO AUXILIAR Y APILO EN DESTINO: 1 2 3 4
  137.     /////////////////////////////////////////////////////////
  138.  
  139.     while(!pilavacia(&ORIGEN)){
  140.  
  141.             apilar(&AUX, desapilar(&ORIGEN));
  142.         }
  143.  
  144.     while(!pilavacia(&AUX)){
  145.             apilar(&DESTINO, desapilar(&AUX));
  146.     }
  147.  
  148.     printf("Pila DESTINO: \n");
  149.     mostrar(&DESTINO);
  150. -------------------------------------------------------------
  151. -------------------------------------------------------------
  152. 5. Cargar desde el teclado la pila DADA. Invertir la pila
  153. de manera que DADA contenga los elementos cargados
  154. originalmente en ella, pero en orden inverso
  155.     Pila DADA, DESTINO, AUX;
  156.     inicpila(&DADA);
  157.     inicpila(&DESTINO);
  158.     inicpila(&AUX);
  159.     char stop='s';
  160.  
  161.     do{
  162.         leer(&DADA);
  163.         printf("Si desea continuar presione s \n");
  164.         fflush(stdin);
  165.         scanf("%c", &stop);
  166.     }while (stop== 's');
  167.  
  168.     printf("Pila DADA\n");
  169.     mostrar(&DADA);
  170.  
  171.     ////////////////////////////////////////////////////////
  172.     TENGO QUE DESAPILAR DADA Y APILAR EN AUXILIAR: 1 2 3 4
  173.     CUANDO APILO EN AUXILIAR SE APILA: 4 3 2 1
  174.     DESAPILO AUXILIAR Y APILO EN DESTINO: 1 2 3 4
  175.     DESAPILO DESTINO Y APILO EN DADA: 4 3 2 1
  176.     ///////////////////////////////////////////////////////
  177.  
  178.     while(!pilavacia(&DADA)){
  179.  
  180.             apilar(&AUX, desapilar(&DADA));
  181.         }
  182.  
  183.     while(!pilavacia(&AUX)){
  184.             apilar(&DESTINO, desapilar(&AUX));
  185.     }
  186.  
  187.     while(!pilavacia(&DESTINO)){
  188.             apilar(&DADA, desapilar(&DESTINO));
  189.     }
  190.  
  191.     printf("Pila DADA: \n");
  192.     mostrar(&DADA);
  193.  
  194. -------------------------------------------------------------
  195. -------------------------------------------------------------
  196.  
  197. 6. Pasar el primer elemento (tope) de la pila DADA a su última
  198. posición (base), dejando los restantes elementos en el mismo orden.
  199.     Pila DADA, DESTINO, AUX;
  200.     inicpila(&DADA);
  201.     inicpila(&DESTINO);
  202.     inicpila(&AUX);
  203.     char stop='s';
  204.  
  205.     do{
  206.         leer(&DADA);
  207.         printf("Si desea continuar presione s \n");
  208.         fflush(stdin);
  209.         scanf("%c", &stop);
  210.     }while (stop== 's');
  211.  
  212.     printf("Pila DADA\n");
  213.     mostrar(&DADA);
  214.  
  215. /////////////////////////////////////////////////////
  216.  
  217.     CARGO DADA: 1 2 3 4
  218.     TENGO QUE DESAPILAR DADA Y APILAR EN AUXILIAR: 4
  219.     CUANDO APILO EN AUXILIAR SE APILA: 4
  220.     DESAPILO DADA Y APILO EN DESTINO: 3 2 1
  221.     DESAPILO AUXILIAR EN DADA: 4
  222.     DESAPILO DESTINO Y APILO EN DADA: 4 3 2 1
  223.  
  224. /////////////////////////////////////////////////////
  225.  
  226.  
  227.     apilar(&AUX, desapilar(&DADA));
  228.  
  229.  
  230.     while(!pilavacia(&DADA)){
  231.             apilar(&DESTINO, desapilar(&DADA));
  232.     }
  233.  
  234.     while(!pilavacia(&AUX)){
  235.             apilar(&DADA, desapilar(&AUX));
  236.     }
  237.  
  238.     while(!pilavacia(&DESTINO)){
  239.             apilar(&DADA, desapilar(&DESTINO));
  240.     }
  241.  
  242.  
  243.     printf("Pila DADA: \n");
  244.     mostrar(&DADA);
  245.  
  246. OPCION2
  247.     Pila DADA, DESTINO, AUX;
  248.     inicpila(&DADA);
  249.     inicpila(&DESTINO);
  250.     inicpila(&AUX);
  251.     char stop='s';
  252.  
  253.     do{
  254.         leer(&DADA);
  255.         printf("Si desea continuar presione s \n");
  256.         fflush(stdin);
  257.         scanf("%c", &stop);
  258.     }while (stop== 's');
  259.  
  260.     printf("Pila DADA\n");
  261.     mostrar(&DADA);
  262.  
  263.     if(!pilavacia(&DADA)){
  264.         apilar(&AUX, desapilar(&DADA));
  265.         while(!pilavacia(&DADA)){
  266.             apilar(&DESTINO, desapilar(&DADA));
  267.         }
  268.         apilar(&DADA, desapilar(&AUX));
  269.         while(!pilavacia(&DESTINO)){
  270.             apilar(&DADA, desapilar(&DESTINO));
  271.         }
  272.     }
  273.     mostrar(&DADA);
  274.  
  275.  
  276. -------------------------------------------------------------
  277. -------------------------------------------------------------
  278. 7. Pasar el último elemento (base) de la pila DADA a su primera
  279. posición (tope), dejando los restantes elementos en el mismo orden.
  280.  
  281.     Pila DADA, DESTINO, AUX;
  282.     inicpila(&DADA);
  283.     inicpila(&DESTINO);
  284.     inicpila(&AUX);
  285.     char stop='s';
  286.  
  287.     do{
  288.         leer(&DADA);
  289.         printf("Si desea continuar presione s \n");
  290.         fflush(stdin);
  291.         scanf("%c", &stop);
  292.     }while (stop== 's');
  293.  
  294.     printf("Pila DADA\n");
  295.     mostrar(&DADA);
  296.  
  297. //////////////////////////////////////////////////
  298. DESAPILO LOS ELEMENTOS EN AUXILIAR
  299. EN AUXILIAR QUEDA LA BASE COMO TOPE: 4 3 2 1
  300. EN DESTINO APILO EL TOPE DE AUXILIAR: 1
  301. APILO EN DADA LOS ELEMENTOS DE AUXILIAR: 2 3 4
  302. DESDE DESTINO APILO EN DADA 2 3 4 1
  303. //////////////////////////////////////////////////
  304.  
  305.     while(!pilavacia(&DADA)){
  306.             apilar(&AUX, desapilar(&DADA));
  307.     }
  308.  
  309.     apilar(&DESTINO,desapilar(&AUX));
  310.  
  311.     while(!pilavacia(&AUX)){
  312.             apilar(&DADA, desapilar(&AUX));
  313.     }
  314.  
  315.     while(!pilavacia(&DESTINO)){
  316.         apilar(&DADA, desapilar(&DESTINO));
  317.     }
  318.     printf("Pila DADA: \n");
  319.     mostrar(&DADA);
  320. -------------------------------------------------------------
  321. OPCION2
  322.  
  323.     Pila DADA, DESTINO, AUX;
  324.     inicpila(&DADA);
  325.     inicpila(&DESTINO);
  326.     inicpila(&AUX);
  327.     char stop='s';
  328.  
  329.     do{
  330.         leer(&DADA);
  331.         printf("Si desea continuar presione s \n");
  332.         fflush(stdin);
  333.         scanf("%c", &stop);
  334.     }while (stop== 's');
  335.  
  336.     printf("Pila DADA\n");
  337.     mostrar(&DADA);
  338.  
  339.     if(!pilavacia(&DADA)){
  340.         while(!pilavacia(&DADA)){
  341.             apilar(&AUX, desapilar(&DADA));
  342.         }
  343.         apilar(&DESTINO,desapilar(&AUX));
  344.         while(!pilavacia(&AUX)){
  345.             apilar(&DADA, desapilar(&AUX))
  346.         }
  347.         apilar(&DADA,desapilar(&DESTINO));
  348.     }
  349.     printf("Pila DADA: \n");
  350.     mostrar(&DADA);
  351.  
  352. -------------------------------------------------------------
  353. -------------------------------------------------------------
  354.  
  355. 8. Repartir los elementos de la pila MAZO en las pilas
  356. JUGADOR1 y JUGADOR2 en forma alternativa.
  357. #define s 83 ////la letra s corresponde a la tecla 83
  358. int main()
  359. {
  360.     Pila MAZO, J1, J2;
  361.     inicpila(&MAZO);
  362.     inicpila(&J1);
  363.     inicpila(&J2);
  364.     int i;
  365.     srand(time(NULL));
  366.     int limite= 20; //CANTIDAD DE ELEMENTOS QUE VA A TENER LA PILA
  367.  
  368.     printf("Cargando mazo: \n");
  369.     Sleep(1500);
  370.     printf(".....................\n");
  371.     Sleep(1500);
  372.     printf(".....................\n");
  373.     Sleep(1500);
  374.     ///////LLENO LA PILA DE NUMEROS ALEATORIOS
  375.     for(i=0; i< limite ; i++){
  376.             apilar(&MAZO, rand()%15);
  377.     }
  378.  
  379.     printf("\nMAZO\n");
  380.     mostrar(&MAZO);
  381. //////////////////////////////////////////////
  382. DESAPILO EN J1 Y EN J2 LA PILA MAZO
  383. MIENTRAS MAZO NO ESTE VACIA DESAPILO EL TOPE AL J1
  384. SI SIGUE CON ELEMENTOS DESAPILO EL TOPE EN J2
  385. Y ASI SUCESIVAMENTE HASTA QUE NO TENGA MAS ELEMENTOS
  386. //////////////////////////////////////////////
  387.     while (!pilavacia(&MAZO)){
  388.         apilar(&J1, desapilar(&MAZO));
  389.         if(!pilavacia(&MAZO)){
  390.             apilar(&J2, desapilar(&MAZO));
  391.         }
  392.     }
  393.  
  394.     printf("Cartas J1\n");
  395.     mostrar(&J1);
  396.  
  397.     printf("Cartas J2\n");
  398.     mostrar(&J2);
  399.  
  400. -------------------------------------------------------------
  401. -------------------------------------------------------------
  402. 9. Comparar la cantidad de elementos de las pilas A y B.
  403. Mostrar por pantalla el resultado.
  404.  
  405. OPCION1:
  406.     Pila aux, A1, B1;
  407.     inicpila(&aux);
  408.     inicpila(&A1);
  409.     inicpila(&B1);
  410.     char stop='s';
  411.  
  412.      do{
  413.         leer(&A1);
  414.         printf("Si desea continuar cargando la pila A presione s\n");
  415.         fflush(stdin);
  416.         scanf("%c",&stop);
  417.     }while(stop=='s');
  418.  
  419.     mostrar(&A1);
  420.     do{
  421.         leer(&B1);
  422.         printf("Si desea continuar cargando la pila B presione s\n");
  423.         fflush(stdin);
  424.         scanf("%c",&stop);
  425.     }while(stop=='s');
  426.  
  427.     mostrar(&B1);
  428.  
  429.     while(!pilavacia(&A1)&& !pilavacia(&B1)){
  430.         apilar(&aux, desapilar(&A1));
  431.         apilar(&aux, desapilar(&B1));
  432.     }
  433.     if(pilavacia(&A1) && pilavacia(&B1)){
  434.         printf("Las Pilas A y B tienen la misma cantidad de elementos\n");
  435.     }else{
  436.         printf("Las Pilas A y B tienen diferente cantidad de elementos\n");
  437.         }
  438. --------------------------------------------------------------------------------------------------------------------------
  439. OPCION2:
  440.  
  441. int main()
  442. {
  443.     Pila aux, A1, B1;
  444.     inicpila(&aux);
  445.     inicpila(&A1);
  446.     inicpila(&B1);
  447.     srand(time(NULL));
  448.     int limite;
  449.     int i;
  450.  
  451.     printf("Ingrese la cantidad de elementos que quiera en la pila A\n");
  452.     fflush(stdin);
  453.     scanf("%i",&limite);
  454.  
  455.     for(i=0; i< limite ; i++){
  456.             apilar(&A1, rand()%15);
  457.     }
  458.     mostrar(&A1);
  459.  
  460.     system("cls");
  461.  
  462.     printf("Ingrese la cantidad de elementos que quiera en la pila B\n");
  463.     fflush(stdin);
  464.     scanf("%i",&limite);
  465.  
  466.     for(i=0; i< limite ; i++){
  467.             apilar(&B1, rand()%15);
  468.     }
  469.     mostrar(&B1);
  470.  
  471.     while(!pilavacia(&A1)&& !pilavacia(&B1)){
  472.         apilar(&aux, desapilar(&A1));
  473.         apilar(&aux, desapilar(&B1));
  474.     }
  475.     if(pilavacia(&A1) && pilavacia(&B1)){
  476.         printf("Las Pilas A y B tienen la misma cantidad de elementos\n");
  477.     }else{
  478.         printf("Las Pilas A y B tienen diferente cantidad de elementos\n");
  479.         }
  480. -------------------------------------------------------------
  481. -------------------------------------------------------------
  482.  
  483. 10. Comparar las pilas A y B, evaluando si son completamente iguales
  484.  (en cantidad de elementos, valores que contienen y posición de los
  485.   mismos). Mostrar por pantalla el resultado.
  486. OPCION1:
  487.     Pila aux, A1, B1;
  488.     inicpila(&aux);
  489.     inicpila(&A1);
  490.     inicpila(&B1);
  491.     srand(time(NULL));
  492.     int limite;
  493.     int i;
  494.  
  495.     printf("Ingrese la cantidad de elementos que quiera en la pila A\n");
  496.     fflush(stdin);
  497.     scanf("%i",&limite);
  498.  
  499.     for(i=0; i< limite ; i++){
  500.             apilar(&A1, rand()%15);
  501.     }
  502.     mostrar(&A1);
  503.  
  504.     printf("Ingrese la cantidad de elementos que quiera en la pila B\n");
  505.     fflush(stdin);
  506.     scanf("%i",&limite);
  507.  
  508.     for(i=0; i< limite ; i++){
  509.             apilar(&B1, rand()%15);
  510.     }
  511.     mostrar(&B1);
  512.  
  513.     while(!pilavacia(&A1)&& !pilavacia(&B1) && (tope(&A1)==tope(&B1))){
  514.         apilar(&aux, desapilar(&A1));
  515.         apilar(&aux, desapilar(&B1));
  516.     }
  517.     if(pilavacia(&A1) && pilavacia(&B1)){
  518.         printf("Las Pilas A y B son IGUALES \n");
  519.     }else{
  520.         printf("Las Pilas A y B son DIFERENTES \n");
  521.         }
  522. -------------------------------------------------------------
  523. OPCION2
  524.  
  525.     Pila aux, A1, B1;
  526.     inicpila(&aux);
  527.     inicpila(&A1);
  528.     inicpila(&B1);
  529.     char stop='s';
  530.  
  531.      do{
  532.         leer(&A1);
  533.         printf("Si desea continuar cargando la pila A presione s\n");
  534.         fflush(stdin);
  535.         scanf("%c",&stop);
  536.     }while(stop=='s');
  537.  
  538.     mostrar(&A1);
  539.  
  540.     do{
  541.         leer(&B1);
  542.         printf("Si desea continuar cargando la pila B presione s\n");
  543.         fflush(stdin);
  544.         scanf("%c",&stop);
  545.     }while(stop=='s');
  546.  
  547.     mostrar(&B1);
  548.  
  549.  
  550.     while(!pilavacia(&A1)&& !pilavacia(&B1) && (tope(&A1)==tope(&B1))){
  551.         apilar(&aux, desapilar(&A1));
  552.         apilar(&aux, desapilar(&B1));
  553.     }
  554.     if(pilavacia(&A1) && pilavacia(&B1)){
  555.         printf("Las Pilas A y B son IGUALES \n");
  556.     }else{
  557.         printf("Las Pilas A y B son DIFERENTES \n");
  558.         }
  559.  
  560. -------------------------------------------------------------
  561. -------------------------------------------------------------
  562.  
  563. 11. Suponiendo la existencia de una pila MODELO que no esté vacía,
  564. eliminar de la pila DADA todos los elementos que sean iguales al
  565. tope de la pila MODELO.
  566.  
  567.     Pila aux, MODELO, DADA, reserva;
  568.     inicpila(&aux);
  569.     inicpila(&MODELO);
  570.     inicpila(&DADA);
  571.     inicpila(&reserva);
  572.  
  573.  
  574.     srand(time(NULL));
  575.     int limite;
  576.     int i;
  577.     char stop= 's';
  578.  
  579.     printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
  580.     fflush(stdin);
  581.     scanf("%i",&limite);
  582.  
  583.     for(i=0; i< limite ; i++){
  584.             apilar(&DADA, rand()%15);
  585.     }
  586.     mostrar(&DADA);
  587.  
  588.     do{
  589.         leer(&MODELO);
  590.         printf("Si desea continuar cargando la pila MODELO presione s\n");
  591.         fflush(stdin);
  592.         scanf("%c",&stop);
  593.     }while(stop=='s');
  594.  
  595.     mostrar(&MODELO);
  596.  
  597.     while(!pilavacia(&DADA)){
  598.             if(tope(&DADA) == tope(&MODELO)){
  599.                 apilar(&aux, desapilar(&DADA));
  600.             }else{
  601.                 apilar(&reserva, desapilar(&DADA));
  602.             }
  603.         }
  604.         while(!pilavacia(&reserva)){
  605.             apilar(&DADA, desapilar(&reserva));
  606.         }
  607.     printf("Pila DADA\n");
  608.     mostrar(&DADA);
  609.  
  610.     printf("Elemento eliminado repetido \n");
  611.     mostrar(&aux);
  612.  
  613.     return 0;
  614.     }
  615.  
  616. -------------------------------------------------------------
  617. -------------------------------------------------------------
  618.  
  619. 12. Suponiendo la existencia de una pila MODELO (vacía o no),
  620.  eliminar de la pila DADA todos los elementos que existan en MODELO.
  621.  
  622.     Pila aux, MODELO, DADA, reserva, DESCARTE;
  623.     inicpila(&aux);
  624.     inicpila(&MODELO);
  625.     inicpila(&DADA);
  626.     inicpila(&reserva);
  627.     inicpila(&DESCARTE);
  628.  
  629.  
  630.     srand(time(NULL));
  631.     int limite;
  632.     int i=0;
  633.  
  634.     printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
  635.     fflush(stdin);
  636.     scanf("%i",&limite);
  637.  
  638.     for(i=0; i< limite ; i++){
  639.             apilar(&DADA, rand()%15);
  640.     }
  641.     mostrar(&DADA);
  642.  
  643.     printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
  644.     fflush(stdin);
  645.     scanf("%i",&limite);
  646.  
  647.     for(i=0; i< limite ; i++){
  648.             apilar(&MODELO, rand()%15);
  649.     }
  650.     mostrar(&MODELO);
  651.  
  652.     while(!pilavacia(&MODELO)) {
  653.         while(!pilavacia(&DADA)){
  654.                 if(tope(&DADA) == tope(&MODELO)){
  655.                     apilar(&aux, desapilar(&DADA));
  656.             }   else{
  657.                     apilar(&reserva, desapilar(&DADA));
  658.                     }
  659.         }
  660.  
  661.             while(!pilavacia(&reserva)){
  662.                 apilar(&DADA, desapilar(&reserva));
  663.         }
  664.         apilar(&DESCARTE, desapilar(&MODELO));
  665.     }
  666.  
  667.     printf("Pila DADA\n");
  668.     mostrar(&DADA);
  669.  
  670.     printf("Elementos eliminados repetidos en ambas pilas\n");
  671.     mostrar(&aux);
  672.  
  673.  
  674. -------------------------------------------------------------
  675. -------------------------------------------------------------
  676.  
  677. 13. Suponiendo la existencia de una pila LÍMITE, pasar los
  678. elementos de la pila DADA que sean mayores o iguales que el
  679. tope de LIMITE a la pila MAYORES, y los elementos que sean
  680. menores a la pila MENORES
  681.  
  682.     Pila DADA, DESCARTE, LIMITE, MAYORES,MENORES;
  683.  
  684.     inicpila(&DADA);
  685.     inicpila(&DESCARTE);
  686.     inicpila(&LIMITE);
  687.     inicpila(&MAYORES);
  688.     inicpila(&MENORES);
  689.     srand(time(NULL));
  690.     int limite;
  691.     int i=0;
  692.  
  693.     printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
  694.     fflush(stdin);
  695.     scanf("%i",&limite);
  696.  
  697.     for(i=0; i< limite ; i++){
  698.             apilar(&DADA, rand()%15);
  699.     }
  700.     mostrar(&DADA);
  701.  
  702.     printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
  703.     fflush(stdin);
  704.     scanf("%i",&limite);
  705.  
  706.     for(i=0; i< limite ; i++){
  707.             apilar(&LIMITE, rand()%15);
  708.     }
  709.     mostrar(&LIMITE);
  710.  
  711.     while(!pilavacia(&LIMITE)&& !pilavacia(&DADA)){
  712.                 if(tope(&DADA)>= tope(&LIMITE)){
  713.                     apilar(&MAYORES, desapilar(&DADA));
  714.             }   else{
  715.                     apilar(&MENORES, desapilar(&DADA));
  716.  
  717.                     }
  718.         apilar(&DESCARTE, desapilar(&LIMITE));
  719.     }
  720.  
  721.  
  722.  
  723.     printf("Pila MAYORES\n");
  724.     mostrar(&MAYORES);
  725.     printf("Pila MENORES\n");
  726.     mostrar(&MENORES);
  727. -------------------------------------------------------------
  728. -------------------------------------------------------------
  729.  
  730. 14. Determinar si la cantidad de elementos de la pila DADA es par.
  731. Si es par, pasar el elemento del tope de la pila AUX a la pila PAR
  732. y si es impar pasar el tope a la pila IMPAR (EN EL MAIN)
  733.  
  734. -------------------------------------------------------------
  735. -------------------------------------------------------------
  736.  
  737. 15. La condición es que mientras la pila PILA1 no esté vacía, se desapilen
  738. los elementos de la pila DESCARTE y se apilen en PILA2. El ciclo finaliza
  739. al vaciar P1.
  740. -------------------------------------------------------------
  741. -------------------------------------------------------------
  742. 16. Mientras que PILA1 no se vacíe, si el tope de Pila1 es igual a 5, se desapila y se apila en la pila
  743. aux, luego se desapila su tope y se apila en la pila result.
  744. -------------------------------------------------------------
  745. -------------------------------------------------------------
  746. 17. ERRORES:
  747. Solo se leerá un elemento a la hora de cargar la pila.
  748. Solo si carga el valor 5 funcionará el resto del programa.
  749. Falta incluir librerías
  750.  
  751. //librerias
  752. #include <stdio.h>     
  753. #include <stdlib.h>
  754. #include"pila.h"
  755. //main
  756. int main()
  757. {
  758. //Declaración de las Pilas a utilizar
  759.     Pila origen, distinto;
  760. //Inicialización de las Pilas
  761.     inicpila(&origen);
  762.     inicpila(&distinto);
  763. //Declaración de variable de tipo char
  764.     char stop='s';
  765. //Algoritmo de carga de elementos a Pila
  766.     do{
  767.         leer(&origen);
  768.         printf("Si desea continuar cargando elementos presionar s y enter\n");
  769.         fflush(stdin);
  770.         scanf("%c",&stop);
  771.     }while(stop=='s');
  772. //Algoritmo de manejo de Pila utilizando condicional (if) y bucle while
  773. //Utilización de funciones de Pilas: tope, pilavacia, desapilar, apilar
  774.     if(!pilavacia(&origen)){
  775.         while(tope(&origen)!= 5){
  776.             apilar(&distinto, desapilar(&origen));
  777.         }
  778.        
  779.     }
  780. //muestra por pantalla de las pilas
  781.     mostrar(&origen);
  782.     mostrar(&distinto);
  783.  
  784. }
  785. -------------------------------------------------------------
  786. -------------------------------------------------------------
  787.  
  788. 18. La condición es que la Pila1 y la Pila2 no estén vacías, en caso de que una
  789. esté vacía y la otra no,el programa dejará de ejecutar el ciclo while ya que es
  790. una condición excluyente que AMBAS no estén vacías.
  791. Puede que ambas queden vacías o que una de ellas quede con elementos y la otra vacía.
  792.  
  793. */
  794.  
  795. int main()
  796. {
  797.     Pila DADA, AUX, PAR,IMPAR;
  798.  
  799.     inicpila(&DADA);
  800.     inicpila(&AUX);
  801.     inicpila(&PAR);
  802.     inicpila(&IMPAR);
  803.     char stop ='s';
  804.  
  805.     do{
  806.        leer(&DADA);
  807.        printf("Si desea continuar cargando la PILA DADA presione s\n");
  808.        fflush(stdin);
  809.        scanf("%c", &stop);
  810.     }while(stop=='s');
  811.  
  812.     mostrar(&DADA);
  813. //////////////////////////////////////////////
  814. /*PASOS:
  815. MIENTRAS QUE LA PILA DADA NO ESTE VACIA ,DESAPILO SU TOPE
  816. Y LO PASO A LA PILA AUX
  817. SI SIGUE CON ELEMENTOS LA PILA DADA (1° IF) DESAPILO EL TOPE Y LO PASO
  818. A AUX DE NUEVO
  819. PREGUNTO SI LA PILA SE VACIÓ, SI ES AFIRMATIVO
  820. APILO EN PAR EL TOPE DE AUX (si no tiene mas elementos es porque tenia cantidad par
  821. : esto lo verificamos al hacer 2 pasadas )
  822. EN CASO DE QUE SE VACIE ANTES DE HACER LA 2DA REVISION
  823. PASAMOS EL TOPE DE AUX A LA PILA IMPAR
  824.  
  825. */
  826.  
  827. /////////////////////////////////////////////
  828.     while (!pilavacia(&DADA)){
  829.         apilar(&AUX, desapilar(&DADA));
  830.  
  831.         if(!pilavacia(&DADA))
  832.         {
  833.             apilar(&AUX, desapilar(&DADA));
  834.  
  835.             if(pilavacia(&DADA))
  836.             {
  837.                 apilar(&PAR, desapilar(&AUX));
  838.             }
  839.  
  840.         }
  841.         else
  842.             {
  843.             apilar(&IMPAR,desapilar(&AUX));
  844.             }
  845.     }
  846.  
  847.         if(!pilavacia(&IMPAR)){
  848.             printf("DADA tenia cantidad de elementos impares\n");
  849.     }
  850.  
  851.         else if (!pilavacia(&PAR)) {
  852.             printf("DADA tenia cantidad de elementos pares\n");
  853.     }
  854.         else{
  855.             printf("La pila DADA no tenia elementos en su pila\n");
  856.     }
  857.  
  858. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top