• Jueves 2 de Mayo de 2024, 21:50

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - fachamix

Páginas: 1 [2] 3 4 ... 9
26
C/C++ / Re: buenas
« en: Martes 12 de Mayo de 2009, 08:44 »
no hermano , no molestas.


te recomiendo esa pagina, ya que para mi tiene el mejor manual para empesar con C++.

hace un esfuerzo y pasateun dia entero sentado , leelo, y te asegur oque terminas haciendo solo el problema.

aparte ya tienes una base de pascal, no es poco.

saludos

27
C/C++ / Re: declaracion y uso de matrices dinamicas en c++
« en: Martes 12 de Mayo de 2009, 08:41 »
de nada hermano

28
C/C++ / Re: buenas
« en: Lunes 11 de Mayo de 2009, 17:44 »
este .. mmmm... http:///www.conclase.net

29
C/C++ / Re: C : ELIMINAR ESPACIOS EN BLANCO DE UNA CADENA
« en: Lunes 11 de Mayo de 2009, 17:42 »
Cita de: "haevan"
en 3 lineas:

char*tmp;
while((tmp=strchr(cadena,32))!=NULL)
             sprintf(tmp,"%s",tmp+1);

32 es el codigo de el caracter de espaciado

ademas asi no necesitas el string.h
¿?¿?¿?¿?¿?¿?¿?¿¿?

si la necesita a string.h , donde crees que esta strchr() ???????

y dudo de la funcionalidad del codigo que has escrito, si alguien lo puede probar, buenisimo, ya que aqui no tengo ningun compilador para probar.

saludos amigo

30
C/C++ / Re: declaracion y uso de matrices dinamicas en c++
« en: Lunes 11 de Mayo de 2009, 17:33 »
Cita de: "m0skit0"
Cita de: "mabama"
He visto en otros temas como hacerlo, pero con la funcion de malloc de c, yo prefiero no hacerlo asi.
No se trata de preferir o no, se trata de que sólo se puede hacer así si quieres memoria dinámica. Lo de int matriz[a]; es lo que está mal, no se puede definir el tamaño de un vector con variables porque se debe reservar el espacio en compilación. Si lo que quieres es que la matriz pueda tener diferentes tamaños, sólo te queda usar memoria dinámica, que por cierto, tratándose de C++, mejor clases y new/delete, y no malloc()/free().

Saludos

moskio tiene razon, SE DEBE USAR SI O SI malloc, new, etc, peroi siempre terminas haciendo lo mismo, MEMORI DINAMICA DEL HEAP.

otra cosa moskito, si se puede hacer por ejemplo:
vector[variable]
es codeblocks con MINGW, yo lo hice, mira este post donde posteo el codigo de los subconjuntos:
viewtopic.php?f=18&t=39235

Código: C++
  1.  
  2.  
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. /*
  8. variable N, es la cantidad de elementos del conjunto padre
  9. variable M, es la cantidad de elementos que deben tener los cubconjuntos generados de PADRE
  10. */
  11. int N,M;
  12.  
  13. void imprimir_memoria(int memoria[100][10]); //imprime los subconjuntos generados
  14.  
  15. /* funcion que devuelve true si ya se evaluaron todos los elementos del conjunto PADRE*/
  16. bool fin_vectorPunteros(int vectorPunteros[]);
  17.  
  18. /*funcion que nos dice si el vector punteros apunta elementos distintos, es necesario, porque no podemos generar un subconjunto de 3 elementos que sea {1,1,2} por ejemplo */
  19. bool apunta_elementos_distintos(int vectorPadre[],int vectorPunteros[]);
  20.  
  21. /*funcion para incrementar el vector de punteros y apuntar al elemento siguiente del conjunto PADRE*/
  22. void inc_vectorPunteros(int vectorPunteros[],int longitud);
  23.  
  24. /*cuando se encuentra un subconjunto , debo guardarlo, en este caso en una memoria de 100 x 10, es decir podre almacenar hasta 100 subconjuntos de como maximo 10 elementos c/u*/
  25. void guardar_subconjunto_en_memoria(int memoria[100][10],int vectorPunteros[],int vectorPadre[]);
  26.  
  27. /*cuando el vector punteros se actualiza, hay un posible subconjunto de PADRE (apuntado por este vector), por ese debemos averiguar si existe un subconjunto en memoria igualal encontrado, pues puede darse el caso de haber almacenado el subconjunto {1,2} y en algun momento del algoritmo hacer referencia a un subconjunto {2,1} que seria equivalente*/
  28. bool subconjunto_encontrado_en_memoria(int memoria[100][10],int vectorPadre[],int vectorPunteros[]);
  29.  
  30. /*imprime el contenido de vectorPunteros*/
  31. void imprimir_vectorPunteros(int vectorPunteros[]);
  32.  
  33. /*imprime los elementos (que formarian un posible subconjunto) de PADRE apuntados por vectorPunteros*/
  34. void imprimir_vectorPadreApuntado(int vectorPadre[],int vectorPunteros[]);
  35.  
  36.  
  37. int main()
  38. {
  39.     cout << "Programa que genera SubConjuntos" << endl;
  40.     /*digo cuantos elementos tendra PADRE*/
  41.     cout << "Ingrese el numero de elementos del conjunto PADRE:";
  42.     cin >> N; cout << endl;
  43.    
  44.     /*luego cargo el conjunto PADRE*/
  45.     cout << "Cargue los elementos del conjunto PADRE:" << endl;
  46.     int vectorPadre[N];
  47.     for (int i = 0;i<N;i++) {
  48.         cout << i << ">";
  49.         cin >> vectorPadre[i];
  50.         cout << endl;
  51.     }
  52.     /*imprimo su contenido para verificar*/
  53.     cout << "Imprimiendo conjunto PADRE:" << endl;
  54.     for (int i = 0; i<N ;i++) {
  55.         cout << vectorPadre[i] << "-";
  56.     }
  57.  
  58.     cout << endl << "----------------------------------------------" << endl;
  59.     /* digo cuantos elementos debera tener los subconjuntos generados */
  60.     cout << endl << "Ingrese el tamaño de los subconjuntos:";
  61.     cin >> M;
  62.  
  63.     cout << endl << "----------------------------------------------" << endl;
  64.  
  65.     /* inicio el vector punteros en 0 para asegurar su contenido */
  66.     cout << "iniciando vector punteros en 0" << endl;
  67.     int vectorPunteros[M];
  68.     for (int i = 0;i<M;i++){
  69.         vectorPunteros[i] = 0;
  70.     }
  71.  
  72.     cout << endl << "----------------------------------------------" << endl;
  73.  
  74.     /* genero e inicio una memeoria para almacenar los subconjuntos encontrados */
  75.     cout << "iniciando matriz de memoria en -1" << endl;
  76.     int memoria[100][10];
  77.     for (int i = 0;i<100;i++) {
  78.         for (int j = 0;j<M;j++){
  79.             memoria[i][j] = -1;
  80.         }
  81.     }
  82.    
  83.     /* Parte principal del programa */
  84.     while (!fin_vectorPunteros(vectorPunteros)){
  85.         if (apunta_elementos_distintos(vectorPadre,vectorPunteros)) {
  86.             if (!subconjunto_encontrado_en_memoria(memoria,vectorPadre,vectorPunteros)){
  87.                 cout << "Subconjunto nuevo {" << endl;
  88.                 cout << "t"; imprimir_vectorPunteros(vectorPunteros);
  89.                 cout << "t"; imprimir_vectorPadreApuntado(vectorPadre,vectorPunteros);
  90.                 cout << endl << "}" << endl;
  91.  
  92.                 guardar_subconjunto_en_memoria(memoria,vectorPunteros,vectorPadre);
  93.             }
  94.         }
  95.         inc_vectorPunteros(vectorPunteros,M);
  96.     }
  97.     system("pause");
  98.     imprimir_memoria(memoria);
  99.     return 0;
  100. }
  101.  
  102. bool subconjunto_encontrado_en_memoria(int memoria[100][10],int vectorPadre[],int vectorPunteros[]){
  103.     bool ban = false,temp;
  104.     int fila = 0,coincidencias;
  105.  
  106.     while (memoria[fila][0] != -1) {
  107.         coincidencias = 0;
  108.         for (int j = 0;j<M;j++){
  109.             for (int j2 = 0;j2<M;j2++){
  110.                 if (memoria[fila][j] == vectorPadre[vectorPunteros[j2]]) {
  111.                     coincidencias++;
  112.                 }
  113.             }
  114.         }
  115.         fila++;
  116.         if (coincidencias == M) {
  117.             return true;
  118.         }
  119.     }
  120.     return false;
  121. }
  122.  
  123. void guardar_subconjunto_en_memoria(int memoria[100][10],int vectorPunteros[],int vectorPadre[]) {
  124.     int fila;
  125.     for (fila = 0;((fila<100) && (memoria[fila][0] != -1));fila++);
  126.     for (int j = 0;j<M;j++){
  127.         memoria[fila][j] = vectorPadre[vectorPunteros[j]];
  128.     }
  129. }
  130.  
  131. void inc_vectorPunteros(int vectorPunteros[],int longitud) {
  132.     bool ban = true;
  133.     longitud--;
  134.     while (ban) {
  135.         if (vectorPunteros[longitud] == (N-1)) {
  136.             vectorPunteros[longitud] = 0;
  137.             longitud--;
  138.         }
  139.         else {
  140.             vectorPunteros[longitud] = vectorPunteros[longitud] + 1;
  141.             ban = false;
  142.         }
  143.     }
  144. }
  145.  
  146. bool apunta_elementos_distintos(int vectorPadre[],int vectorPunteros[]) {
  147.     for (int i = 0;i<M;i++){
  148.         for (int j = i+1;j<M;j++) {
  149.             if (vectorPadre[vectorPunteros[i]] == vectorPadre[vectorPunteros[j]]) {
  150.                     return false;
  151.             }
  152.         }
  153.     }
  154.  
  155.     return true;
  156. }
  157.  
  158. bool fin_vectorPunteros(int vectorPunteros[]) {
  159.     bool ban = true;
  160.     for (int i = 0;i<M;i++) {
  161.         if (vectorPunteros[i] != (N-1)) {
  162.             ban = false;
  163.         }
  164.     }
  165.     return ban;
  166. }
  167.  
  168. void imprimir_memoria(int memoria[100][10]) {
  169.     for (int i = 0;i<100;i++){
  170.         for (int j = 0;j<M;j++){
  171.             cout << memoria[i][j] << " ";
  172.         }
  173.         cout << endl;
  174.     }
  175. }
  176.  
  177. void imprimir_vectorPunteros(int vectorPunteros[]){
  178.     cout << " Vector Punteros: ";
  179.     for (int i = 0; i<M ; i++){
  180.         cout << vectorPunteros[i];
  181.     }
  182. }
  183.  
  184. void imprimir_vectorPadreApuntado(int vectorPadre[],int vectorPunteros[]){
  185.     cout << " Vector Padre Apuntado: ";
  186.     for (int i = 0; i<M ; i++){
  187.         cout << vectorPadre[vectorPunteros[i]];
  188.     }
  189. }
  190.  
  191.  

compila perfecto y funciona mejor, en serio probalo. estoy seguro que el compilador lo permite pero termina manejando estructura dinamica luego por su cuenta para resolver tal linea de codigo, pero lo permite.

31
C/C++ / Re: buenas
« en: Lunes 11 de Mayo de 2009, 02:20 »
escribi en google:

C con clase.


creo que tu problema cae en que no sabes programar, te lo digo con la mejor de las ondas.

32
C/C++ / Re: declaracion y uso de matrices dinamicas en c++
« en: Lunes 11 de Mayo de 2009, 02:17 »
pone en google


C con clase

33
C/C++ / Re: buenas
« en: Domingo 10 de Mayo de 2009, 04:14 »
empesificame mejor a que te refieres con intercalar, .... a "UNIR" los valores de los 2 vectores ????

34
C/C++ / Re: Promedio de diez estudiantes Usando While
« en: Domingo 10 de Mayo de 2009, 04:13 »
jajajajaja esta bien amigo, iva de onda lo mio.

35
C/C++ / Re: Promedio de diez estudiantes Usando While
« en: Domingo 10 de Mayo de 2009, 01:59 »
no puedo creer el laburo que te has tomado para contestar.

como e dicho antes .... FUIRA!

36
Publicaciones y e-books / Re: E-books C,PHP,Linux,Java y mas
« en: Domingo 10 de Mayo de 2009, 00:31 »
exelente!

37
C/C++ / Re: Promedio de diez estudiantes Usando While
« en: Domingo 10 de Mayo de 2009, 00:27 »
fuira!

38
Publicaciones y e-books / Re: E-books C,PHP,Linux,Java y mas
« en: Sábado 9 de Mayo de 2009, 16:45 »
bien muchachos.

si encuentran ebooks de vision artificial posteen

39
C/C++ / Re: Generar Subconjuntos de tamaño m de un conjutno
« en: Viernes 8 de Mayo de 2009, 22:50 »
y ??? desaparecio este chango che, como boludo yo haciendo el codigo para el niño.

en fin, por las dudas, te digo que es lo que e hecho:

_me e dado cuenta que si queria subconjuntos de 2 elementos por ejemplo, esos subconjuntos ivan a estar "incluidos" en la totalidad de pares que se puedan formar con los elementos del conjutno PADRE.
_Si queria subconjuntos de 3 elementos, me di cuenta que esos subconjuntos ivan a estar "incluidos" en todas las ternas posibles a armar con los elemtnos del conjunto padre


asi llegas a la conclusion de que el problema lo puedes dividir en 2:
1) encontrar todos los pares, ternas, cuaternas .... etc (dependiendo del tamaño del subconjunto deseado) posibles a armar con los elementos del conjunto PADRE

2) del resultado de 1), excluir a aquellos que tengan elementos similares, es decir, si tenemos los pares ordenados (1,2) y (2,1) , hablando dentro del marco de pares ordenados, SERIAN DIFERENTES, pero si hablamos de conjuntos {1,2} y {2,1}, SON IGUALES!!!!!!

ya te e dicho todo lo que tenias que saber

40
C/C++ / Re: Parametros genericos....
« en: Viernes 8 de Mayo de 2009, 22:44 »
muy buen aporte, genial.

41
C/C++ / Re: Generar Subconjuntos de tamaño m de un conjutno
« en: Jueves 7 de Mayo de 2009, 20:34 »
tu estructura recursiva seria esta en mi codigo:

Código: C++
  1.  
  2. while (!fin_vectorPunteros(vectorPunteros)){
  3.         /*if (apunta_elementos_distintos(vectorPadre,vectorPunteros)) {
  4.             if (subconjunto_encontrado_en_memoria(memoria,vectorPadre,vectorPunteros)){
  5.                 cout << endl << "Encontrado:";
  6.                 for (int x = 0;x<M;x++){
  7.                     cout << vectorPadre[vectorPunteros[x]];
  8.                 }
  9.                 cout << endl;
  10.                 //guardar_subconjunto(matriz_memoria,vectorA,vectorPunt,M,N);
  11.             }
  12.         }
  13.         */
  14.         if (apunta_elementos_distintos(vectorPadre,vectorPunteros)) {
  15.             //imprimir_vectorPunteros(vectorPunteros);
  16.             //imprimir_vectorPadreApuntado(vectorPadre,vectorPunteros);
  17.             if (!subconjunto_encontrado_en_memoria(memoria,vectorPadre,vectorPunteros)){
  18.                 cout << "Subconjunto nuevo {" << endl;
  19.                 cout << "t"; imprimir_vectorPunteros(vectorPunteros);
  20.                 cout << "t"; imprimir_vectorPadreApuntado(vectorPadre,vectorPunteros);
  21.                 cout << endl << "}" << endl;
  22.  
  23.                 guardar_subconjunto_en_memoria(memoria,vectorPunteros,vectorPadre);
  24.             }
  25.         }
  26.         inc_vectorPunteros(vectorPunteros,M);
  27.         cout << endl;
  28.     }
  29.  
  30.  

desde mi logica, si tienes que almacenar los subconjuntos encontrados, porque SI es lo mismo decir subconjunto {1,2}  y {2,1} tienen los mismos elementos, es el mismo conjunto, entonces debes llevar una cuenta de los subconjuntos encontrados.

proba el programa que hice, porque lo e hecho por vos, bajate el codeblocks con mingw, compilalo, analizalo, testealo, y en todo caso depuralo.

vuelvo a repetir, sitienes que almacenar, aunque sea temporalmente como lo hago yo, todos los subconjuntos que vas encontrando para no repetirlos en la salida.

EI: juntando mensajes.

Código: C++
  1.  
  2. #include <iostream>
  3.  
  4. using namespace std;
  5.  
  6. /*
  7. variable N, es la cantidad de elementos del conjunto padre
  8. variable M, es la cantidad de elementos que deben tener los cubconjuntos generados de PADRE
  9. */
  10. int N,M;
  11.  
  12. void imprimir_memoria(int memoria[100][10]); //imprime los subconjuntos generados
  13.  
  14. /* funcion que devuelve true si ya se evaluaron todos los elementos del conjunto PADRE*/
  15. bool fin_vectorPunteros(int vectorPunteros[]);
  16.  
  17. /*funcion que nos dice si el vector punteros apunta elementos distintos, es necesario, porque no podemos generar un subconjunto de 3 elementos que sea {1,1,2} por ejemplo */
  18. bool apunta_elementos_distintos(int vectorPadre[],int vectorPunteros[]);
  19.  
  20. /*funcion para incrementar el vector de punteros y apuntar al elemento siguiente del conjunto PADRE*/
  21. void inc_vectorPunteros(int vectorPunteros[],int longitud);
  22.  
  23. /*cuando se encuentra un subconjunto , debo guardarlo, en este caso en una memoria de 100 x 10, es decir podre almacenar hasta 100 subconjuntos de como maximo 10 elementos c/u*/
  24. void guardar_subconjunto_en_memoria(int memoria[100][10],int vectorPunteros[],int vectorPadre[]);
  25.  
  26. /*cuando el vector punteros se actualiza, hay un posible subconjunto de PADRE (apuntado por este vector), por ese debemos averiguar si existe un subconjunto en memoria igualal encontrado, pues puede darse el caso de haber almacenado el subconjunto {1,2} y en algun momento del algoritmo hacer referencia a un subconjunto {2,1} que seria equivalente*/
  27. bool subconjunto_encontrado_en_memoria(int memoria[100][10],int vectorPadre[],int vectorPunteros[]);
  28.  
  29. /*imprime el contenido de vectorPunteros*/
  30. void imprimir_vectorPunteros(int vectorPunteros[]);
  31.  
  32. /*imprime los elementos (que formarian un posible subconjunto) de PADRE apuntados por vectorPunteros*/
  33. void imprimir_vectorPadreApuntado(int vectorPadre[],int vectorPunteros[]);
  34.  
  35.  
  36. int main()
  37. {
  38.     cout << "Programa que genera SubConjuntos" << endl;
  39.     /*digo cuantos elementos tendra PADRE*/
  40.     cout << "Ingrese el numero de elementos del conjunto PADRE:";
  41.     cin >> N; cout << endl;
  42.    
  43.     /*luego cargo el conjunto PADRE*/
  44.     cout << "Cargue los elementos del conjunto PADRE:" << endl;
  45.     int vectorPadre[N];
  46.     for (int i = 0;i<N;i++) {
  47.         cout << i << ">";
  48.         cin >> vectorPadre[i];
  49.         cout << endl;
  50.     }
  51.     /*imprimo su contenido para verificar*/
  52.     cout << "Imprimiendo conjunto PADRE:" << endl;
  53.     for (int i = 0; i<N ;i++) {
  54.         cout << vectorPadre[i] << "-";
  55.     }
  56.  
  57.     cout << endl << "----------------------------------------------" << endl;
  58.     /* digo cuantos elementos debera tener los subconjuntos generados */
  59.     cout << endl << "Ingrese el tamaño de los subconjuntos:";
  60.     cin >> M;
  61.  
  62.     cout << endl << "----------------------------------------------" << endl;
  63.  
  64.     /* inicio el vector punteros en 0 para asegurar su contenido */
  65.     cout << "iniciando vector punteros en 0" << endl;
  66.     int vectorPunteros[M];
  67.     for (int i = 0;i<M;i++){
  68.         vectorPunteros[i] = 0;
  69.     }
  70.  
  71.     cout << endl << "----------------------------------------------" << endl;
  72.  
  73.     /* genero e inicio una memeoria para almacenar los subconjuntos encontrados */
  74.     cout << "iniciando matriz de memoria en -1" << endl;
  75.     int memoria[100][10];
  76.     for (int i = 0;i<100;i++) {
  77.         for (int j = 0;j<M;j++){
  78.             memoria[i][j] = -1;
  79.         }
  80.     }
  81.    
  82.     /* Parte principal del programa */
  83.     while (!fin_vectorPunteros(vectorPunteros)){
  84.         if (apunta_elementos_distintos(vectorPadre,vectorPunteros)) {
  85.             if (!subconjunto_encontrado_en_memoria(memoria,vectorPadre,vectorPunteros)){
  86.                 cout << "Subconjunto nuevo {" << endl;
  87.                 cout << "t"; imprimir_vectorPunteros(vectorPunteros);
  88.                 cout << "t"; imprimir_vectorPadreApuntado(vectorPadre,vectorPunteros);
  89.                 cout << endl << "}" << endl;
  90.  
  91.                 guardar_subconjunto_en_memoria(memoria,vectorPunteros,vectorPadre);
  92.             }
  93.         }
  94.         inc_vectorPunteros(vectorPunteros,M);
  95.         cout << endl;
  96.     }
  97.     system("pause");
  98.     imprimir_memoria(memoria);
  99.     return 0;
  100. }
  101.  
  102. bool subconjunto_encontrado_en_memoria(int memoria[100][10],int vectorPadre[],int vectorPunteros[]){
  103.     bool ban = false,temp;
  104.     int fila = 0,coincidencias;
  105.  
  106.     while (memoria[fila][0] != -1) {
  107.         coincidencias = 0;
  108.         for (int j = 0;j<M;j++){
  109.             for (int j2 = 0;j2<M;j2++){
  110.                 if (memoria[fila][j] == vectorPadre[vectorPunteros[j2]]) {
  111.                     coincidencias++;
  112.                 }
  113.             }
  114.         }
  115.         fila++;
  116.         if (coincidencias == M) {
  117.             return true;
  118.         }
  119.     }
  120.     return false;
  121. }
  122.  
  123. void guardar_subconjunto_en_memoria(int memoria[100][10],int vectorPunteros[],int vectorPadre[]) {
  124.     int fila;
  125.     for (fila = 0;((fila<100) && (memoria[fila][0] != -1));fila++);
  126.     for (int j = 0;j<M;j++){
  127.         memoria[fila][j] = vectorPadre[vectorPunteros[j]];
  128.     }
  129. }
  130.  
  131. void inc_vectorPunteros(int vectorPunteros[],int longitud) {
  132.     bool ban = true;
  133.     longitud--;
  134.     while (ban) {
  135.         if (vectorPunteros[longitud] == (N-1)) {
  136.             vectorPunteros[longitud] = 0;
  137.             longitud--;
  138.         }
  139.         else {
  140.             vectorPunteros[longitud] = vectorPunteros[longitud] + 1;
  141.             ban = false;
  142.         }
  143.     }
  144. }
  145.  
  146. bool apunta_elementos_distintos(int vectorPadre[],int vectorPunteros[]) {
  147.     for (int i = 0;i<M;i++){
  148.         for (int j = i+1;j<M;j++) {
  149.             if (vectorPadre[vectorPunteros[i]] == vectorPadre[vectorPunteros[j]]) {
  150.                     return false;
  151.             }
  152.         }
  153.     }
  154.  
  155.     return true;
  156. }
  157.  
  158. bool fin_vectorPunteros(int vectorPunteros[]) {
  159.     bool ban = true;
  160.     for (int i = 0;i<M;i++) {
  161.         if (vectorPunteros[i] != (N-1)) {
  162.             ban = false;
  163.         }
  164.     }
  165.     return ban;
  166. }
  167.  
  168. void imprimir_memoria(int memoria[100][10]) {
  169.     for (int i = 0;i<100;i++){
  170.         for (int j = 0;j<M;j++){
  171.             cout << memoria[i][j] << " ";
  172.         }
  173.         cout << endl;
  174.     }
  175. }
  176.  
  177. void imprimir_vectorPunteros(int vectorPunteros[]){
  178.     cout << " Vector Punteros: ";
  179.     for (int i = 0; i<M ; i++){
  180.         cout << vectorPunteros[i];
  181.     }
  182. }
  183.  
  184. void imprimir_vectorPadreApuntado(int vectorPadre[],int vectorPunteros[]){
  185.     cout << " Vector Padre Apuntado: ";
  186.     for (int i = 0; i<M ; i++){
  187.         cout << vectorPadre[vectorPunteros[i]];
  188.     }
  189. }
  190.  
  191.  

EI: juntando mensajes por ULTIMA VEZ (para algo esta el boton Editar), la proxima borro.

ya esta flaco, hasta e programado por vos, que mas ayuda quieres, por lo menos analiza lo que te paso

42
C++ Builder / Re: AnsiString en Función
« en: Jueves 7 de Mayo de 2009, 13:33 »
en donde los utilizes

43
La taberna del BIT / Re: Cuentame Un Chiste
« en: Jueves 7 de Mayo de 2009, 07:09 »
a ese chiste nadie lo cuenta mejor que este tipo:

http://www.youtube.com/watch?v=VpZ3rhuSEl4

44
C/C++ / Re: compilador c++
« en: Jueves 7 de Mayo de 2009, 07:07 »
Borland C++Builder amigo, usted vea y despues me cuenta.

tambien te recomiendo QT CREATOR, ya que vas a empesar de cero, es una gran pero gran eleccion e inversion a futuro

45
C/C++ / Re: Generar Subconjuntos de tamaño m de un conjutno
« en: Jueves 7 de Mayo de 2009, 07:00 »
lindo tu problema.

disculpa si mi codigo esta improlijo, le hice de apuradas, porque me parecia intrigante tu problema.

tambien te pido disculpas si es algo ineficiente o dificil de seguir.

tambien te pido disculpas, porque no hice pruebas necesarias para garantizar que el programa funcione para todos los casos.

pero probalo y decime ok ????

aqui va.... esta compilado en CODE BLOCKS con MINGW:

Código: C++
  1.  
  2. #include <iostream>
  3.  
  4. using namespace std;
  5.  
  6. int N,M;
  7. void imprimir_memoria(int memoria[100][10]);
  8. bool fin_vectorPunteros(int vectorPunteros[]);
  9. bool apunta_elementos_distintos(int vectorPadre[],int vectorPunteros[]);
  10. void inc_vectorPunteros(int vectorPunteros[],int longitud);
  11. void guardar_subconjunto_en_memoria(int memoria[100][10],int vectorPunteros[],int vectorPadre[]);
  12. bool subconjunto_encontrado_en_memoria(int memoria[100][10],int vectorPadre[],int vectorPunteros[]);
  13. void imprimir_vectorPunteros(int vectorPunteros[]);
  14. void imprimir_vectorPadreApuntado(int vectorPadre[],int vectorPunteros[]);
  15.  
  16.  
  17. int main()
  18. {
  19.     cout << "Programa que genera SubConjuntos" << endl;
  20.  
  21.     cout << "Ingrese el numero de elementos del conjunto PADRE:";
  22.     cin >> N; cout << endl;
  23.     cout << "Cargue los elementos del conjunto PADRE:" << endl;
  24.     int vectorPadre[N];
  25.     for (int i = 0;i<N;i++) {
  26.         cout << i << ">";
  27.         cin >> vectorPadre[i];
  28.         cout << endl;
  29.     }
  30.     cout << "Imprimiendo conjunto PADRE:" << endl;
  31.     for (int i = 0; i<N ;i++) {
  32.         cout << vectorPadre[i] << "-";
  33.     }
  34.  
  35.     cout << endl << "----------------------------------------------" << endl;
  36.     cout << endl << "Ingrese el tamaño de los subconjuntos:";
  37.     cin >> M;
  38.  
  39.     cout << endl << "----------------------------------------------" << endl;
  40.     cout << "iniciando vector punteros en 0" << endl;
  41.     int vectorPunteros[M];
  42.     for (int i = 0;i<M;i++){
  43.         vectorPunteros[i] = 0;
  44.     }
  45.  
  46.     cout << endl << "----------------------------------------------" << endl;
  47.     cout << "iniciando matriz de memoria en -1" << endl;
  48.     int memoria[100][10];
  49.     for (int i = 0;i<100;i++) {
  50.         for (int j = 0;j<M;j++){
  51.             memoria[i][j] = -1;
  52.         }
  53.     }
  54.  
  55.     while (!fin_vectorPunteros(vectorPunteros)){
  56.         /*if (apunta_elementos_distintos(vectorPadre,vectorPunteros)) {
  57.             if (subconjunto_encontrado_en_memoria(memoria,vectorPadre,vectorPunteros)){
  58.                 cout << endl << "Encontrado:";
  59.                 for (int x = 0;x<M;x++){
  60.                     cout << vectorPadre[vectorPunteros[x]];
  61.                 }
  62.                 cout << endl;
  63.                 //guardar_subconjunto(matriz_memoria,vectorA,vectorPunt,M,N);
  64.             }
  65.         }
  66.         */
  67.         if (apunta_elementos_distintos(vectorPadre,vectorPunteros)) {
  68.             //imprimir_vectorPunteros(vectorPunteros);
  69.             //imprimir_vectorPadreApuntado(vectorPadre,vectorPunteros);
  70.             if (!subconjunto_encontrado_en_memoria(memoria,vectorPadre,vectorPunteros)){
  71.                 cout << "Subconjunto nuevo {" << endl;
  72.                 cout << "t"; imprimir_vectorPunteros(vectorPunteros);
  73.                 cout << "t"; imprimir_vectorPadreApuntado(vectorPadre,vectorPunteros);
  74.                 cout << endl << "}" << endl;
  75.  
  76.                 guardar_subconjunto_en_memoria(memoria,vectorPunteros,vectorPadre);
  77.             }
  78.         }
  79.         inc_vectorPunteros(vectorPunteros,M);
  80.         cout << endl;
  81.     }
  82.     system("pause");
  83.     imprimir_memoria(memoria);
  84.     return 0;
  85. }
  86.  
  87. bool subconjunto_encontrado_en_memoria(int memoria[100][10],int vectorPadre[],int vectorPunteros[]){
  88.     bool ban = false,temp;
  89.     int fila = 0,coincidencias;
  90.  
  91.     while (memoria[fila][0] != -1) {
  92.         coincidencias = 0;
  93.         for (int j = 0;j<M;j++){
  94.             for (int j2 = 0;j2<M;j2++){
  95.                 if (memoria[fila][j] == vectorPadre[vectorPunteros[j2]]) {
  96.                     coincidencias++;
  97.                 }
  98.             }
  99.         }
  100.         fila++;
  101.         if (coincidencias == M) {
  102.             return true;
  103.         }
  104.     }
  105.     return false;
  106. }
  107.  
  108. void guardar_subconjunto_en_memoria(int memoria[100][10],int vectorPunteros[],int vectorPadre[]) {
  109.     int fila;
  110.     for (fila = 0;((fila<100) && (memoria[fila][0] != -1));fila++);
  111.     for (int j = 0;j<M;j++){
  112.         memoria[fila][j] = vectorPadre[vectorPunteros[j]];
  113.     }
  114. }
  115.  
  116. void inc_vectorPunteros(int vectorPunteros[],int longitud) {
  117.     bool ban = true;
  118.     longitud--;
  119.     while (ban) {
  120.         if (vectorPunteros[longitud] == (N-1)) {
  121.             vectorPunteros[longitud] = 0;
  122.             longitud--;
  123.         }
  124.         else {
  125.             vectorPunteros[longitud] = vectorPunteros[longitud] + 1;
  126.             ban = false;
  127.         }
  128.     }
  129. }
  130.  
  131. bool apunta_elementos_distintos(int vectorPadre[],int vectorPunteros[]) {
  132.     for (int i = 0;i<M;i++){
  133.         for (int j = i+1;j<M;j++) {
  134.             if (vectorPadre[vectorPunteros[i]] == vectorPadre[vectorPunteros[j]]) {
  135.                     return false;
  136.             }
  137.         }
  138.     }
  139.  
  140.     return true;
  141. }
  142.  
  143. bool fin_vectorPunteros(int vectorPunteros[]) {
  144.     bool ban = true;
  145.     for (int i = 0;i<M;i++) {
  146.         if (vectorPunteros[i] != (N-1)) {
  147.             ban = false;
  148.         }
  149.     }
  150.     return ban;
  151. }
  152.  
  153. void imprimir_memoria(int memoria[100][10]) {
  154.     for (int i = 0;i<100;i++){
  155.         for (int j = 0;j<M;j++){
  156.             cout << memoria[i][j] << " ";
  157.         }
  158.         cout << endl;
  159.     }
  160. }
  161.  
  162. void imprimir_vectorPunteros(int vectorPunteros[]){
  163.     cout << " Vector Punteros: ";
  164.     for (int i = 0; i<M ; i++){
  165.         cout << vectorPunteros[i];
  166.     }
  167. }
  168.  
  169. void imprimir_vectorPadreApuntado(int vectorPadre[],int vectorPunteros[]){
  170.     cout << " Vector Padre Apuntado: ";
  171.     for (int i = 0; i<M ; i++){
  172.         cout << vectorPadre[vectorPunteros[i]];
  173.     }
  174. }
  175.  
  176.  
  177.  


EI: juntando mensajes.

vi que andaba con un conjunto de 4 elementos, y generaba sobconjuntos de 2, tambien de 3, y lo postie.

es muy tarde, probalo, mañana lo explico bien cual fue la logica.

por favor, nadie me critique eficiencia y eso ... vuelvo a decir, lo hice a las apuradas (aun pueden ver mis comentarios en el codigo que muestran que estaba depurando y ni siquiera los borre)

saludos

la memoria para guardar los subconjuntos encontrados es de 100 por 10, es decir, puedes almacenar como maximo 100 subconjuntos de 10 elementos cada uno en esa memoria.

saludos, mañana lo explico

46
C++ Builder / Re: AnsiString en Función
« en: Miércoles 6 de Mayo de 2009, 17:58 »
la vredad que no se :D jajajajaja


pero depurar un programa tambien es un arte.

cambia sa funcion y en vez de AnsiString ponele int, etc etc etc.

parece que lo que esta pidiendo es el archivo .h - el Acerolam.h

quizas no lo tengas

47
C/C++ / Re: compilador c++
« en: Miércoles 6 de Mayo de 2009, 17:53 »
yo te recomiendo de corazon jajajajaja, C++Builder, impresionante

48
C/C++ / Re: Programa Help!!!!
« en: Miércoles 6 de Mayo de 2009, 00:33 »
mira, es un programa muy boludo el que teestan pidiendo, es mas me arriesgo a decir queestasen primer año.


area = base * altura
perimetro = base*2 + altura*2

supongo que tu profesor no te da los rectangulos, tu programa deberia permitirte cargarlos

con un while para cargarlos y otro while fuera del anterior para hacerlo que tepiden.

para almacenar los rectangulos quevas ingresando puedes hacer de muchas maneras, tecuento algunas:
1) en un vector de tipo struct rectangulo, donde struct rectangulo contenga los campos BASE y ALTURA (como minimo). El tamaño del vector lo tienes quedefinir de antemano.
2)  si no manejas tipos de datos struct, pero si manejas matrices, lo puedes hacer en una matriz. donde cada fila representaria un rectangulo. tu matriz seria de Nx2, es decir N filas por 2 columnas (como minimo por lo antes dicho), el tamaño N lo debes fijar deantemano.

3) pero lo mejor es usar estructurasde datos dinamicas, como listas por ejemplo.


en fin, pensa , tienes 2 partes muy importantes en tu programa, la 1era es la carga de los rectangulos, la 2da es lo que te piden

49
C++ Builder / Re: Colorear Celda en excel desde builder????
« en: Domingo 3 de Mayo de 2009, 16:42 »
valoro mucho que hayas vuelto y contestado la solucion.

realmente no entendia o que pedias por eso no postie.

50
C/C++ / Re: Generar Subconjuntos de tamaño m de un conjutno
« en: Sábado 2 de Mayo de 2009, 16:43 »
segui el consejo que te acaban de dar.
el programa es muy simple.

porque quieres utilizar listas???? necesitas tener en memoria (RAM) estos subconjuntos o simplemente los tienes que guardar en alguna parte, o simplemente los tienes que imprimir ???

si no necesitas tenerlos en memoria RAM, imprimelos simplemente, o guardalos en un archivo :D

Páginas: 1 [2] 3 4 ... 9