Mensajes

¡Buenas!

Tu idea es correcta, pero es lógico que no te salgan los caracteres, ya que la clase que en la clase se guardan solo los punteros que apuntan a la memoria que has reservado.

Es decir. Lo punteros están dentro de la clase, pero la memoria no lo está. No se si con un string te pasara lo mismo o no. Nunca lo he probado. Otra opción es declarar vectores char con un tamaño concreto. Así esa memoria si que pertenecerá a la clase, y cuando uses strcpy sobre un vector de char, aparecerá su contenido.

¡Saludos!

¡Buenas!

Aquí te dejo otras dos formas de resolverlo:

Código (cpp) [Seleccionar] Expandir


bool circulares(char *s1, char *s2)
{
    int i = 0;
    bool ret = false;

    if(strlen(s1) != strlen(s2))
        return false;

    if(!s1[0])
        return true;

    while(s1[i++])
    {
        if(!strcmp(s1,s2))
            ret = true;

        char aux = s2[strlen(s2) - 1];
        memmove(s2 + 1, s2, strlen(s2) - 1);
        s2[0] = aux;
    }

    return ret;
}

bool circulares(char *s1, char *s2)
{
    char *aux = NULL;
    bool ret;

    if(strlen(s1) != strlen(s2))
        return false;

    if(!s1[0])
        return true;

    if(!(aux = new char[2 * strlen(s2) + 1]))
        return false;

    sprintf(aux,"%s%s",s2,s2);

    ret = strstr(aux,s1);

    delete [] aux;

    return ret;
}


¡Saludos!

Asi de hi jos de pu ta son.

En mi pueblo pocas casas tienen conexión a internet.

Ah, y una de las razones por las que deje movistar fue porque empezaron a cobrarme 2€ mas por pagar la factura en ventanilla en lugar de tenerla domiciliada...

Unos malnacidos, eso es lo que son.

[sha1.h]

¡Buenas!

Aun arriesgándome a un tirón de orejas por el doble post, os deho aqui el SHA1.

La última vez que me juntaron dos posts con códigos relativamente largos, se perdio parte del código por exceder el límite de caracteres del post... por favor, EI, Littlehorse, no me unáis los posts.

sha1.h

Código (c) [Seleccionar] Expandir


#ifndef SHA1_H
#define SHA1_H

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#ifndef ULL_MAX
   #define ULL_MAX 0xFFFFFFFFFFFFFFFFULL
#endif

typedef unsigned long (*_funciones)(unsigned long, unsigned long, unsigned long);

char* sha1(char *input, unsigned long long len);

unsigned long long sha1_ajustar_datos(char **datos, unsigned long  long len);

unsigned long sha1_extraer_submensaje(char *m , unsigned long sub , unsigned long bloque);

#endif /* SHA1_H */


sha1.c

Código (c) [Seleccionar] Expandir


#include "sha1.h"

#define sha1F(X,Y,Z) (((X) & (Y)) | ((~(X)) & (Z)))
#define sha1G(X,Y,Z) ((X) ^ (Y) ^ (Z))
#define sha1H(X,Y,Z) (((X) & (Y)) | ((X) & (Z)) | ((Y) & (Z)))

char* sha1(char *input, unsigned long long len)
{
   char *aux = NULL;
   unsigned long long longitud, i,j;
   unsigned long reg[5], aux_reg[5], K[4], bloque = 0, sub[80];
   unsigned long tmp;


   if(!(aux = malloc(len * sizeof(char))))
       return NULL;

   memcpy(aux,input,len * sizeof(char));

   if(!(longitud = sha1_ajustar_datos(&aux,len)))
   {
       free(aux);
       return NULL;
   }

   reg[0] = 0x67452301;
   reg[1] = 0xEFCDAB89;
   reg[2] = 0x98BADCFE;
   reg[3] = 0x10325476;
   reg[4] = 0xC3D2E1F0;

   K[0] = 0x5A827999;
   K[1] = 0x6ED9EBA1;
   K[2] = 0x8F1BBCDC;
   K[3] = 0xCA62C1D6;

   while(longitud)
   {
       memcpy(aux_reg , reg , 5 * sizeof(unsigned long));

       for(j = 0 ; j < 16 ; j++)
           for(i = 0 ; i < 4 ; i++)
               memset(((char*)&sub[j]) + i, *(aux + bloque * 64 + j * 4 + 3 - i) , sizeof(char));

       for(i = 16 ; i < 80 ; i++)
       {
           sub[i] = sub[i - 3] ^ sub[i - 8] ^ sub[i - 14] ^ sub[i - 16];
           sub[i] = sub[i] << 1 | sub[i] >> 31;
       }

       for(i = 0 ; i < 20 ; i++)
       {
           tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1F(aux_reg[1],aux_reg[2],aux_reg[3]) +
                           aux_reg[4] + sub[i] + K[0];

           aux_reg[4] = aux_reg[3];
           aux_reg[3] = aux_reg[2];
           aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
           aux_reg[1] = aux_reg[0];
           aux_reg[0] = tmp;
       }

       for(i = 20 ; i < 40 ; i++)
       {
           tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1G(aux_reg[1],aux_reg[2],aux_reg[3]) +
                           aux_reg[4] + sub[i] + K[1];

           aux_reg[4] = aux_reg[3];
           aux_reg[3] = aux_reg[2];
           aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
           aux_reg[1] = aux_reg[0];
           aux_reg[0] = tmp;
       }

       for(i = 40 ; i < 60 ; i++)
       {
           tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1H(aux_reg[1],aux_reg[2],aux_reg[3]) +
                           aux_reg[4] + sub[i] + K[2];

           aux_reg[4] = aux_reg[3];
           aux_reg[3] = aux_reg[2];
           aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
           aux_reg[1] = aux_reg[0];
           aux_reg[0] = tmp;
       }

       for(i = 60 ; i < 80 ; i++)
       {
           tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1G(aux_reg[1],aux_reg[2],aux_reg[3]) +
                           aux_reg[4] + sub[i] + K[3];

           aux_reg[4] = aux_reg[3];
           aux_reg[3] = aux_reg[2];
           aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
           aux_reg[1] = aux_reg[0];
           aux_reg[0] = tmp;
       }

       for(i = 0 ; i < 5 ; i++)
           reg[i] += aux_reg[i];

       bloque++;
       longitud -= 64;
   }

   free(aux);

   if(!(aux = malloc(41 * sizeof(unsigned long))))
       return NULL;

   aux[0] = '\0';

   for(i = 0 ; i < 5 ; i++)
       sprintf(aux,"%s%08lX",aux,reg[i]);

   return aux;
}

unsigned long long sha1_ajustar_datos(char **datos, unsigned long  long len)
{
   unsigned long long new_len;
   char *aux;
   int c = 0,i;

   /* si longitud en bits es mayor que ULL_MAX */
   if(len > ULL_MAX / 8)
       return 0; /* devolvemos falso */

   if(64 - (len % 64) > 8)
   {
       if(ULL_MAX - (64 - (len % 64)) >= len)
           new_len = len + (64 - (len % 64));
       else
           return 0;
   }
   else
   {
       if(ULL_MAX - 64 - (64 - (len % 64)) >= len)
           new_len = len + 64 + (64 - (len % 64));
       else
           return 0;
   }

   if(!(aux = (char*) realloc(*datos , new_len * sizeof(char))))
       return 0;

   (*datos) = aux;

   c = 1 << 7;

   memset((*datos) + len , c , sizeof(char));
   memset((*datos) + len + 1 , 0 , (new_len - len - 1) * sizeof(char));

   /* pasamos la longitud de bytes a bits */
   len *= 8;

   for(i = 0 ; i < 8 ; i++)
       memset((*datos) + new_len - 8 + i , ((char*)&len)[7 - i] , sizeof(char));

   return new_len;
}


¡Saludos!

El enlace para la descarga

antitusivo para Imoen

Que Boris Izaguirre

una putilla cualquiera

como por ejemplo...

Rajoy creó empleo

[combinatoria.h]

¡Buenas!

Aquí os dejo unos códigos que acabo de hacer. Han salido a raíz de una pregunta posteada y por fin me he decidido ha hacerlos.

Son funciones para el manejo de la combinatoria (combinaciones, variaciones y permutaciones, tanto con repeticiones como sin repeticiones).

Trabajan con indices de enteros, así que los resultados de las funciones son aplicables a cualquier vector o contenedor lineal al que se pueda acceder por subindices.

Primero os dejo tanto combinatoria.h como combinatoria.c y al final un codigo de ejemplo.

¡Saludos!

Si os resulta mas cómodo aquí os dejo un enlace de descarga.

combinatoria.h

Código (c) [Seleccionar] Expandir


#ifndef COMBINATORIA_H
#define COMBINATORIA_H

/*
* La esctructura t_combinatoria guarda una lista con todos los elementos
* que genera un tipo combinatorio... (lio)
*
* Por ejemplo. Si caltulamos las permutaciones de un conjunto, cada elemento
* de lista sera una de las permutaciones. (mas claro)
*
* n_elementos es el numero de listas. Si hemos calculado permutaciones de n
* elementos n_elementos sera n!...
*
* longitud_elemento es la longitud de cada elemento generado:
* en variaciones de n elementos tomados de k en k, longitud_elemento = k.
*
*/

struct t_combinatoria
{
    unsigned char **lista;
    unsigned long n_elementos;
    unsigned char longitud_elemento;
};
typedef struct t_combinatoria t_combinatoria;

/*
* IMPORTATISIMO UTILIZAR LA FUNCION PARA INICIALIZAR ANTES DE CUALQUIER
* LLAMADA A ALGUNA DE LAS SIGUIENTES FUNCIONES, Y FINALIZAR LOS DATOS
* DESPUES DE TERMINAR DE UTILIZARLOS
*
*/
void inicializar_combinatoria(t_combinatoria *comb);
void finalizar_combinatoria(t_combinatoria *comb);

/* CUALLQUIERA DE LAS SIGUIENTE FUNCIONES DEVUELVE 0 SI HAY ALGUN ERROR Y 1 SI TODO VA BIEN */

/* Combinaciones sin repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k <= n)*/
int combinaciones(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_combinacion);

/* Combinaciones con repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k cualquiera)*/
int combinaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjutnto, unsigned char elementos_combinacion);

/* variaciones sin repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k <= n) */
int variaciones(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion);

/* variaciones con repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k cualquiera) */
int variaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion);

/* permutaciones sin repeticion de n (elementos_conjunto) elementos */
int permutaciones(t_combinatoria *datos, unsigned char elementos_conjunto);

/*permutaciones con repeticion de un conjunto de elementos_conjunto elementos, y repeticiones es un vector
* en el que se nos indica cuantas veces se repite el elemento i de la lista
*/
int permutaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char *repeticiones);

#endif // COMBINATORIA_H


combinatoria.c

Código (c) [Seleccionar] Expandir


#include "combinatoria.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void inicializar_combinatoria(t_combinatoria *c)
{
    c->lista = NULL;
    c->n_elementos = 0;
    c->longitud_elemento = 0;
}

void finalizar_combinatoria(t_combinatoria *c)
{
    unsigned long i;

    for(i = 0 ; i < c->n_elementos ; i++)
        free(c->lista[i]);

    free(c->lista);

    c->lista = NULL;
    c->n_elementos = 0;
    c->longitud_elemento = 0;
}

unsigned long factorial(unsigned long n)
{
    unsigned long ret = 1;

    while(n)
        ret *= (n--);

    return ret;
}

unsigned long variaciones_n_k(unsigned long n, unsigned long k)
{
    unsigned long copia_n = n, ret = 1;

    while(n - (copia_n - k))
        ret *= (n--);

    return ret;
}

unsigned long exponencial(unsigned long base, unsigned long exponente)
{
    unsigned long ret = 1;

    if(exponente)
        while(exponente--)
            ret *= base;

    return ret;
}

unsigned long binomial(unsigned long n, unsigned long k)
{
    return variaciones_n_k(n,k) / factorial(k);
}

unsigned long binomial_generalizado(unsigned char *repeticiones, unsigned long dim)
{
    unsigned long ret = 0,i;

    for(i = 0 ; i < dim ; i++)
        ret += repeticiones[i];

    ret = factorial(ret);

    for(i = 0 ; i < dim ; i++)
        ret /= factorial(repeticiones[i]);

    return ret;
}

int combinaciones(t_combinatoria *datos,unsigned char elementos_conjunto, unsigned char elementos_combinacion)
{
    static unsigned char indice = 0;
    static unsigned long elementos_fijados = 0;
    static unsigned char *aux = NULL;
    unsigned long i;

    if(!elementos_combinacion || !elementos_conjunto)
        return 0;

    if(indice == elementos_combinacion)
    {
        memcpy(*(datos->lista + elementos_fijados), aux, elementos_combinacion * sizeof(unsigned char));

        elementos_fijados++;

        return 1;
    }

    /* si es la primera vez que llamamos a la funcion, reservamos memoria para la tabla de combinaciones */
    if(!indice)
    {
        if(!(aux = (unsigned char *) malloc(elementos_combinacion * sizeof(unsigned char))))
            return 0;

        datos->n_elementos = binomial(elementos_conjunto,elementos_combinacion);
        datos->longitud_elemento = elementos_combinacion;

        if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
        {
            datos->n_elementos = 0;
            datos->longitud_elemento = 0;

            return 0;
        }

        for(i = 0 ; i < datos->n_elementos ; i++)
        {
            if(!(datos->lista[i] = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
            {
                unsigned long j;

                for(j = 0 ; j < i ; j++)
                    free(datos->lista[i]);

                free(datos->lista);
                datos->lista = NULL;

                datos->n_elementos = 0;
                datos->longitud_elemento = 0;

                return 0;
            }
        }

        for(i = 0 ; i < elementos_conjunto - elementos_combinacion + indice + 1; i++)
        {
            aux[indice] = i;

            indice++;

            combinaciones(datos, elementos_conjunto, elementos_combinacion);

            indice--;
        }

        free(aux);
        aux = NULL;
        elementos_fijados = 0;
        indice = 0;
    }
    else
    {
        for(i = aux[indice - 1] + 1 ; i < elementos_conjunto - elementos_combinacion + indice + 1; i++)
        {
            aux[indice] = i;

            indice++;

            combinaciones(datos, elementos_conjunto, elementos_combinacion);

            indice--;
        }
    }

    return 1;
}

int combinaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_combinacion)
{
    static unsigned char indice = 0;
    static unsigned long elementos_fijados = 0;
    static unsigned char *aux = NULL;
    unsigned long i;

    if(!elementos_combinacion || !elementos_conjunto)
        return 0;

    if(indice == elementos_combinacion)
    {
        memcpy(*(datos->lista + elementos_fijados), aux, elementos_combinacion * sizeof(unsigned char));

        elementos_fijados++;

        return 1;
    }

    /* si es la primera vez que llamamos a la funcion, reservamos memoria para la tabla de combinaciones */
    if(!indice)
    {
        if(!(aux = (unsigned char *) malloc(elementos_combinacion * sizeof(unsigned char))))
            return 0;

        datos->n_elementos = binomial(elementos_conjunto + elementos_combinacion - 1,elementos_combinacion);
        datos->longitud_elemento = elementos_combinacion;

        if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
        {
            datos->n_elementos = 0;
            datos->longitud_elemento = 0;

            return 0;
        }

        for(i = 0 ; i < datos->n_elementos ; i++)
        {
            if(!(datos->lista[i] = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
            {
                unsigned long j;

                for(j = 0 ; j < i ; j++)
                    free(datos->lista[i]);

                free(datos->lista);
                datos->lista = NULL;

                datos->n_elementos = 0;
                datos->longitud_elemento = 0;

                return 0;
            }
        }

        for(i = 0 ; i < elementos_conjunto; i++)
        {
            aux[indice] = i;

            indice++;

            combinaciones_repeticion(datos, elementos_conjunto, elementos_combinacion);

            indice--;
        }

        free(aux);
        aux = NULL;
        elementos_fijados = 0;
        indice = 0;
    }
    else
    {
        for(i = aux[indice - 1] ; i < elementos_conjunto ; i++)
        {
            aux[indice] = i;

            indice++;

            combinaciones_repeticion(datos, elementos_conjunto, elementos_combinacion);

            indice--;
        }
    }

    return 1;
}

int variaciones(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion)
{
    static unsigned char indice = 0;
    static unsigned long elementos_fijados = 0;
    static unsigned char *aux = NULL;
    static unsigned char *lista_indices = NULL;
    unsigned long i;

    if(!elementos_variacion || !elementos_conjunto)
        return 0;

    if(indice == elementos_variacion)
    {
        memcpy(*(datos->lista + elementos_fijados), aux, elementos_variacion * sizeof(unsigned char));

        elementos_fijados++;

        return 1;
    }

    if(!indice)
    {
        if(!(aux = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
            return 0;

        if(!(lista_indices = (unsigned char *) malloc(elementos_conjunto * sizeof(unsigned char))))
        {
            free(aux);
            aux = NULL;

            return 0;
        }

        for(i = 0 ; i < elementos_conjunto ; i++)
            lista_indices[i] = i;

        datos->n_elementos = variaciones_n_k(elementos_conjunto , elementos_variacion);
        datos->longitud_elemento = elementos_variacion;

        if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
        {
            free(aux);
            aux = NULL;

            free(lista_indices);
            lista_indices = NULL;

            datos->n_elementos = 0;
            datos->longitud_elemento = 0;

            return 0;
        }

        for(i = 0 ; i < datos->n_elementos ; i++)
        {
            if(!(datos->lista[i] = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
            {
                unsigned long j;

                for(j = 0 ; j < i ; j++)
                    free(datos->lista[j]);

                free(datos->lista);
                datos->lista = NULL;

                free(aux);
                aux = NULL;

                free(lista_indices);
                lista_indices = NULL;

                datos->n_elementos = 0;
                datos->longitud_elemento = 0;

                return 0;
            }
        }
    }

    aux[indice] = lista_indices[indice];

    indice++;
    variaciones(datos, elementos_conjunto, elementos_variacion);
    indice--;

    for(i = indice + 1; i < elementos_conjunto ; i++)
    {
        aux[indice] = lista_indices[i];

        lista_indices[indice] ^= lista_indices[i];
        lista_indices[i] ^= lista_indices[indice];
        lista_indices[indice] ^= lista_indices[i];

        indice++;

        variaciones(datos , elementos_conjunto , elementos_variacion);

        indice--;

        lista_indices[indice] ^= lista_indices[i];
        lista_indices[i] ^= lista_indices[indice];
        lista_indices[indice] ^= lista_indices[i];
    }

    if(!indice)
    {
        elementos_fijados = 0;
        indice = 0;

        free(aux);
        aux = NULL;

        free(lista_indices);
        lista_indices = NULL;
    }

    return 1;
}

int variaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion)
{
    static unsigned char indice = 0;
    static unsigned long elementos_fijados = 0;
    static unsigned char *aux = NULL;
    unsigned long i;

    if(!elementos_variacion || !elementos_conjunto)
        return 0;

    if(indice == elementos_variacion)
    {
        memcpy(*(datos->lista + elementos_fijados),aux,elementos_variacion * sizeof(unsigned char));

        elementos_fijados++;

        return 1;
    }

    if(!indice)
    {
        if(!(aux = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
            return 0;

        datos->n_elementos = exponencial(elementos_conjunto, elementos_variacion);
        datos->longitud_elemento = elementos_variacion;

        if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
        {
            datos->n_elementos = 0;
            datos->longitud_elemento = 0;

            return 0;
        }

        for(i = 0 ; i < datos->n_elementos ; i++)
        {
            if(!(datos->lista[i] = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
            {
                unsigned long j;

                for(j = 0 ; j < i ; j++)
                    free(datos->lista[j]);

                free(datos->lista);
                datos->lista = NULL;

                datos->n_elementos = 0;
                datos->longitud_elemento = 0;

                return 0;
            }
        }
    }

    for(i = 0 ; i < elementos_conjunto ; i++)
    {
        aux[indice] = i;

        indice++;
        variaciones_repeticion(datos, elementos_conjunto, elementos_variacion);
        indice--;
    }

    if(!indice)
    {
        free(aux);
        aux = NULL;

        elementos_fijados = 0;
    }

    return 1;
}

int permutaciones(t_combinatoria *datos, unsigned char elementos_conjunto)
{
    return variaciones(datos , elementos_conjunto , elementos_conjunto);
}

int permutaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char *repeticiones)
{
    static unsigned char indice = 0;
    static unsigned long elementos_fijados = 0;
    static unsigned char *aux = NULL;
    unsigned long i;

    if(!elementos_conjunto)
        return 0;

    if(!indice)
    {
        for(i = 0 ; i < elementos_conjunto ; i++)
            datos->longitud_elemento += repeticiones[i];

        if(!datos->longitud_elemento)
            return 0;

        if(!(aux = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
        {
            datos->longitud_elemento = 0;

            return 0;
        }

        datos->n_elementos = binomial_generalizado(repeticiones, elementos_conjunto);

        if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
        {
            free(aux);
            aux = NULL;

            datos->n_elementos = 0;
            datos->longitud_elemento = 0;

            return 0;
        }

        for(i = 0 ; i < datos->n_elementos ; i++)
        {
            if(!(datos->lista[i] = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
            {
                unsigned long j;

                for(j = 0 ; j < i ; j++)
                    free(datos->lista[j]);

                free(datos->lista);
                datos->lista = NULL;

                free(aux);
                aux = NULL;

                datos->n_elementos = 0;
                datos->longitud_elemento = 0;

                return 0;
            }
        }
    }

    if(indice == datos->longitud_elemento)
    {
        memcpy(*(datos->lista + elementos_fijados), aux, datos->longitud_elemento * sizeof(unsigned char));

        elementos_fijados++;

        return 1;
    }

    for(i = 0; i < elementos_conjunto ; i++)
    {
        if(repeticiones[i])
        {
            aux[indice] = i;
            repeticiones[i]--;

            indice++;
            permutaciones_repeticion(datos,elementos_conjunto,repeticiones);
            indice--;

            repeticiones[i]++;
        }
    }

    if(!indice)
    {
        free(aux);
        aux = NULL;

        elementos_fijados = 0;
    }

    return 1;
}


ejemplo

Código (c) [Seleccionar] Expandir


#include <stdio.h>

#include "combinatoria.h"

int main()
{
   t_combinatoria comb;
   int i, j;
   unsigned long repeticiones[] = {2,1,0,0,2};
   char vector1[] = "aeiou";
   char *vector2[] = {"que","dia","mas","tonto","llevo"};

   inicializar_combinatoria(&comb);

   /* combinaciones sin repeticion de 5 elementos, tomados de 3 en 3 */
   combinaciones(&comb,5,3);

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%c",vector1[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%s ",vector2[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   while(getchar() != '\n');

   finalizar_combinatoria(&comb);

   inicializar_combinatoria(&comb);

   permutaciones(&comb,3);

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%c",vector1[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%s ",vector2[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   while(getchar() != '\n');

   finalizar_combinatoria(&comb);

   inicializar_combinatoria(&comb);

   /*
    * permutaciones con repeticion de 5 elementos donde
    * el prinero se repite 2 veces, el segundo 1 vez y
    * el quinto 2 veces (repeticiones = {2,1,0,0,2})
    */
   permutaciones_repeticion(&comb,5,repeticiones);

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%c",vector1[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   for(i = 0 ; i < comb.n_elementos ; i++)
   {
       for(j = 0 ; j < comb.longitud_elemento ; j++)
           printf("%s ",vector2[comb.lista[i][j]]);

       printf("\n");
   }

   printf("\n");

   while(getchar() != '\n');

   finalizar_combinatoria(&comb);


   return 0;
}


¡Saludos!