• Jueves 14 de Noviembre de 2024, 23:01

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 - Minamimoto

Páginas: [1]
1
Diseño de Algoritmos / Re: Variacion de un arreglo
« en: Miércoles 2 de Diciembre de 2009, 05:42 »
Gracias por tu respuesta, ya resolvi el problema, aqui lo pongo por si alguien esta interesado

Código: C
  1.  
  2. #include "stdio.h"
  3. #include "math.h"
  4. #include "stdlib.h"
  5. #include "conio.h"
  6. #include <vector>
  7.  
  8. #define NOTOKENS 6
  9.  
  10. int contarUnos(int conjunto[]);
  11. unsigned long conversor(unsigned long n1,int base1,int base2);
  12. void binarioCharInt(char *binarioA, int *binario2,int unos);
  13. void imprimirBinarioInt(int *binarioI);
  14. void generarPotencia(int conjunto[],int unos);
  15. void inicializarPotencia(int conjunto[][NOTOKENS], int numeroConjuntos, int unos);
  16. void IntToBin(int valor, int digitos, char *binario);
  17. void crearConjuntoAux(int conjunto[], int conjuntoAux[], int unos);
  18. void cambiarNumeros(int conjunto[], int conjuntoP[][NOTOKENS], int conjuntoPAux[][NOTOKENS], int numeroConjuntos, int unos);
  19. void inicializarZeroes(int conjunto[][NOTOKENS], int numeroConjuntos);
  20. void cambiarFinal(int conjuntoPAux[][NOTOKENS], int conjuntoFinal[][NOTOKENS], int numeroConjuntos, int unos);
  21. void imprimirConjuntoInicial(int conjunto[]);
  22.  
  23. int main (void){
  24.     int conjunto[NOTOKENS]={0,1,1,1,1,0};
  25.     int unos = contarUnos(conjunto);
  26.     int conjuntoAux[unos];
  27.     imprimirConjuntoInicial(conjunto);
  28.     crearConjuntoAux(conjunto,conjuntoAux,unos);
  29.     generarPotencia(conjuntoAux,unos);
  30.     return 0;
  31. }
  32.  
  33. void imprimirConjuntoInicial(int conjunto[]){
  34.     printf("Conjunto Inicial = ");
  35.     for(int i = 0;i<NOTOKENS;i++){
  36.             printf("%d",conjunto[i]);
  37.     }
  38.     printf("nn");
  39. }
  40.  
  41. void crearConjuntoAux(int conjunto[], int conjuntoAux[], int unos){
  42.     int j=0;
  43.     printf("ConjuntoAux = {");
  44.     for(int i = 0;i<NOTOKENS;i++){
  45.         if(conjunto[i]==1){
  46.             conjuntoAux[j]=i+1;
  47.             printf("%d, ",conjuntoAux[j]);
  48.             j++;
  49.         }
  50.     }
  51.     printf("}n");
  52. }
  53.  
  54. void generarPotencia(int conjunto[],int unos){
  55.     int numeroConjuntos = (int)pow(2,unos);
  56.     int conjuntoPotenciaAux[numeroConjuntos][NOTOKENS];
  57.     int conjuntoPotencia[numeroConjuntos][NOTOKENS];
  58.     int conjuntoPotenciaFinal[numeroConjuntos][NOTOKENS];
  59.     inicializarZeroes(conjuntoPotencia,numeroConjuntos);
  60.     inicializarZeroes(conjuntoPotenciaAux,numeroConjuntos);
  61.     inicializarPotencia(conjuntoPotencia,numeroConjuntos,unos);
  62.     inicializarPotencia(conjuntoPotenciaAux,numeroConjuntos,unos);
  63.     cambiarNumeros(conjunto,conjuntoPotencia,conjuntoPotenciaAux,numeroConjuntos,unos);
  64.     inicializarZeroes(conjuntoPotenciaFinal,numeroConjuntos);
  65.     cambiarFinal(conjuntoPotenciaAux,conjuntoPotenciaFinal,numeroConjuntos,unos);
  66. }
  67.  
  68. void inicializarPotencia(int conjunto[][NOTOKENS], int numeroConjuntos, int unos){
  69.     unsigned long binario;
  70.     unsigned long decimal;
  71.     char binarioA[unos];
  72.     int binario2[unos];
  73.     binarioA[unos]='';
  74.     for(int i = 0;i<numeroConjuntos;i++){
  75.         binario=conversor(i,2,10);
  76.         IntToBin(i,unos,binarioA);
  77.         binarioCharInt(binarioA,binario2,unos);
  78.         for(int j = 0;j<unos;j++){
  79.             conjunto[i][j]=binario2[j];
  80.         }
  81.     }
  82. }
  83.  
  84. void cambiarNumeros(int conjunto[], int conjuntoP[][NOTOKENS], int conjuntoPAux[][NOTOKENS], int numeroConjuntos, int unos){
  85.     printf("nConjunto Potencia Auxnn");
  86.     for (int i=0;i<numeroConjuntos;i++){
  87.         printf("{ ");
  88.         for(int j=0;j<unos;j++){
  89.             if(conjuntoP[i][j]==1){
  90.                     conjuntoPAux[i][j]=conjunto[j];
  91.                     printf("%d ",conjuntoPAux[i][j]);
  92.             }
  93.         }
  94.         printf("}n");
  95.     }
  96. }
  97.  
  98. void inicializarZeroes(int conjunto[][NOTOKENS], int numeroConjuntos){
  99.     for(int i = 0;i<numeroConjuntos; i++){
  100.         for(int j=0;j<NOTOKENS;j++){
  101.             conjunto[i][j]=0;
  102.         }
  103.     }
  104. }
  105.  
  106. void cambiarFinal(int conjuntoPAux[][NOTOKENS], int conjuntoFinal[][NOTOKENS], int numeroConjuntos, int unos){
  107.     printf("nConjunto Potenciann");
  108.     int cambio=0;
  109.     for(int i = 0;i<numeroConjuntos;i++){
  110.         for(int j = 0;j<NOTOKENS;j++){
  111.             cambio=conjuntoPAux[i][j];
  112.             if(cambio!=0)conjuntoFinal[i][cambio-1]=1;
  113.         }
  114.     }
  115.     for(int i = 0;i<numeroConjuntos;i++){
  116.         for(int j = 0;j<NOTOKENS;j++){
  117.             printf("%d",conjuntoFinal[i][j]);
  118.         }
  119.         printf("n");
  120.     }
  121. }
  122.  
  123. int contarUnos(int conjunto[]){
  124.     int cont=0;
  125.     for(int i =0;i<NOTOKENS;++i){
  126.         if(conjunto[i]==1)cont++;
  127.     }
  128.     return cont;
  129.  
  130. }
  131.  
  132. void binarioCharInt(char *binarioA, int *binario2,int unos){
  133.     for(int i = 0;i<unos;i++){
  134.         if(binarioA[i]=='0')binario2[i]=0;
  135.         if(binarioA[i]=='1')binario2[i]=1;
  136.     }
  137. }
  138.  
  139. unsigned long conversor(unsigned long n1,int base1,int base2){
  140.    unsigned long alg,mult=1,n2=0;
  141.    while (n1 > 0){
  142.       alg = n1 % base1;
  143.       n1 /= base1;
  144.       n2 += (alg*mult);
  145.       mult *= base2;
  146.    }
  147.    return n2;
  148. }
  149.  
  150. void imprimirBinarioInt(int *binarioI){
  151.     for(int i = 0;i<NOTOKENS;i++){
  152.         printf("%d",binarioI[i]);
  153.     }
  154.     printf("n");
  155. }
  156.  
  157. void IntToBin(int valor, int digitos, char *binario){
  158.     for (int i = 0; i <= digitos; i++){
  159.         if (((1 << i) & valor) > 0)
  160.             binario[digitos-1-i]= '1';
  161.         else
  162.         binario[digitos-1-i]= '0';
  163.     }
  164. }
  165.  
  166.  
  167.  
  168.  
  169.  
  170.  

2
Diseño de Algoritmos / Variacion de un arreglo
« en: Lunes 30 de Noviembre de 2009, 05:32 »
He pasado toda la tarde intentado hacer un algoritmo que dado un arreglo cualquiera, por ejemplo

[0 1 1 1 0] calcule todos los arreglos que se pueden hacer con la combinacion del numero 1 asi:

[0 0 0 0 0]
[0 1 0 0 0]
[0 0 1 0 0]
[0 0 0 1 0]
[0 1 1 0 0]
[0 1 0 1 0]
[0 0 1 1 0]
[0 1 1 1 0]

El numero total de arreglos tendría que ser 2^n, en donde n es e numero total de unos en el arreglo original (3)

Existe un algoritmo que haga esto?

PD de antemano me disculpo porque el tema tambien lo hice en otro subforo

3
C/C++ / Re: Combinacion de un arreglo
« en: Lunes 30 de Noviembre de 2009, 05:21 »
Gracias por tu respuesta, pero quiza no me explique bien, el algortimo tendria que trabajar para cualquier arreglo, si importar la longitud, estaba investigando y se supone que es un algortimos de variacion, pero no he podido solucionar el problema

4
C/C++ / Combinacion de un arreglo
« en: Lunes 30 de Noviembre de 2009, 04:24 »
He pasado toda la tarde intentado hacer un algoritmo que dado un arreglo cualquiera, por ejemplo

[0 1 1 1 0]  calcule todos los arreglos que se pueden hacer con la combinacion del numero 1 asi:

[0 0 0 0 0]
[0 1 0 0 0]
[0 0 1 0 0]
[0 0 0 1 0]
[0 1 1 0 0]
[0 1 0 1 0]
[0 0 1 1 0]
[0 1 1 1 0]

El numero total de arreglos tendría que ser 2^n, en donde n es e numero total de unos en el arreglo original (3)

Existe un algoritmo que haga esto?

Editado para exponer mejor el problema

Páginas: [1]