saber valores de base de piramide a partir de su resultado

[aguml]

Primer problema, estoy intentando crear una funcion a la cual se le da un valor y te devuelve una matriz con todos los divisores posibles. El caso es que no se como hacerlo para pasar un puntero de tipo int y que al retornar tenga en ese puntero la matriz.
Tengo este codigo:

Código PHP:

int *Divisores;

nDivisores = ObtenerListaDivisores(10,&Divisores);

//Retorna el numero de divisores posibles
int ObtenerListaDivisores(int valor, int* Divisores[])
{
   int i, j=0, nDivisores=0;

   for(i=1;i<valor;i++)
      if(valor%i==0){
         nDivisores++;
         printf("%i\n",i);
      }

   Divisores = malloc(sizeof(int) * nDivisores);

   for(i=1;i<valor;i++)
      if(valor%i==0){
         *Divisores[j]=i;
         j++;
      }
   return nDivisores;
} 


El caso es que me estoy equivocando y no se como solucionarlo ya que no se como rellenar el array y retornar el puntero y que no se pierdan esos valores al salir de la funcion, no se si me explico.
Edito: Ya lo solucione esta parte.

[ecfisa]

Hola aguml.

Yo tampoco entiendo bién lo que buscas, pero en una parte mencionas:

no se como rellenar el array ... y que no se pierdan esos valores al salir de la funcion

Una forma de hacerlo es pasar el arreglo por referencia:

Código PHP:

...
void foo(int*&, int);

int main()
{
  int *vec;
  
  foo(vec, 10);
  for (int i = 0; i < 10; i++) cout << vec[i] << endl; 
  ...
}

void foo(int*& v, int n) {
  v = new int[n];
  for(int i = 0; i < n; i++) v[i] = i;
} 


Pero como te digo arriba, no entiendo bién el objetivo de obtener el apuntador al arreglo y tal vez me esté perdiendo algo...

Saludos

[aguml]

En C no se puede pasar el apuntador por referencia de ese modo. Lo hice de otro modo y a ver si me dices si es correcto o es una locura lo que hago.
El caso es que ya tengo solucionado el nivel 2 y 3 de la piramide y solo me falta la parte de los 4 valores de la base que ahi si que ya me pierdo. A ver si podeis ayudarme. Ya digo que esta aplicacion no sirve para nada ya que lo normal es que tengas los 4 valores de la base y te pidan resolver la piramide para saber cuanto vale el valor del pico y no al reves. Lo hago por aprender un poco y divertirme simplemente.
Lo que comentais de prueba/error parece mas encontrar un serial por fuerza bruta jejeje.
A ver si podeis orientarme aunque sea con un seudocodigo para ver como sería y de paso decirme si hago algo mal en el codigo o todo jejeje.
Hacerlo con recursividad... no se me da nada bien la recursividad y si así me está costando sudor y lagrimas... no quiero ni imaginarme con recursividad jajaja.
Aquí lo que tengo de codigo hasta ahora (espero comentarios):

Código PHP:

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

int MCD(int a, int b);
int ObtenerListaDivisores(int valor, int** Divisores);
void LiberarListaDivisores(int** Divisores);
int ObtenerPareja(int dividendo, int** Divisores, int nDivisores, int* valor1, int* valor2, int posX, int posY);
void shuffle(int *Divisores, int nDivisores);

int main()
{
   int i, n, z, multiplicando, multiplicador, divisorComun, nDivisores;
   int *Divisores;
   int Resultado[10];
   int dividendo = 1000;
   int salir = 0, repetido, retval=0, posibles=0;
   int dibujados[100]={0};

   //Inicializo la semilla para rand()
   srand (time(NULL));

   //Coloco el valor del pico de la piramide en el array que almacena el resultado
   Resultado[0]=dividendo;


   //Obtengo todos los divisores del valor del pico de la piramide
   nDivisores = ObtenerListaDivisores(dividendo, &Divisores);

   //Barajo la lista de divisores
   shuffle(Divisores,nDivisores);

   retval=0;

   //Con estos dos bucles puedo calcular todas las posibilidades del segundo nivel de la pirámide
   for(n=nDivisores-1;n>=0 && salir==0;n--)
   {
      for(z=nDivisores-2;z>=0 && salir==0;z--)
      {
         if(n!=z){
            //Obtengo los dos valores del segundo nivel
            retval = ObtenerPareja(dividendo, &Divisores, nDivisores, &multiplicando, &multiplicador, z, n);

            //Si no hubo error entramos
            if(retval != -1){
               //Busco el multiplicando y el multiplicador en la lista y si no están los añado
               for(i=0;i<nDivisores;i++)
               {
                  if(dibujados[i] == multiplicando || dibujados[i] == multiplicador){
                     repetido=1;
                     break;
                  }else if(dibujados[i] == 0){
                     dibujados[i]=multiplicando;
                     dibujados[i+1]=multiplicador;
                     repetido=0;
                     break;
                  }
               }
               //Si no están repetidos los valores del segundo nivel
               //Si está repetido nos saltamos esto para empezar de nuevo con la siguiente posibilidad
               if(repetido != 1){
                  //Coloco los dos valores del segundo nivel en el array del resultado
                  Resultado[1]=multiplicando;
                  Resultado[2]=multiplicador;

                  //Calculo el valor central del tercer nivel
                  divisorComun = MCD(multiplicando,multiplicador);

                  //Calculo los dos extremos del tercer nivel para este MCD
                  multiplicando= multiplicando/divisorComun;
                  multiplicador= multiplicador/divisorComun;

                  //Coloco los tres valores del tercer nivel en el array del resultado.
                  //El MCD va en el centro
                  Resultado[3]=multiplicando;
                  Resultado[4]=divisorComun;
                  Resultado[5]=multiplicador;

                  //Incremento el contador de posibles soluciones
                  posibles++;

                  //Muestro la pirámide
                  printf("         %i\n", Resultado[0]);
                  printf("      %i     %i\n", Resultado[1], Resultado[2]);
                  printf("   %i     %i     %i\n", Resultado[3], Resultado[4], Resultado[5]);
                  printf("%i     %i     %i     %i\n", 1, 1, 1, 1); //Me falta calcular esta fila
                  printf("\n---------------------------------\n");
               }
            }
         }
      }
   }
   printf("\nSe obtuvieron %i posibles soluciones.\n",posibles);

   //Libero la memoria reservada para almacenar los divisores para el segundo nivel
   LiberarListaDivisores(&Divisores);

   printf("\nPresiona INTRO para salir");
   getchar();
   return 0;
}
//---------------------------------------------------------------------------

//Máximo común divisor de dos números mediante el algoritmo de Euclides.
int MCD(int a, int b)
{
   int aux, c, r;

   if(a < b){
      aux=b;
      b=a;
      a=aux;
   }

   r=a%b;
   while(r>0)
   {
      if(a>b){
         a=b;
         b=r;
         r=a%b;
      }else{
         return 0;
      }
   }
   return b;
}
//---------------------------------------------------------------------------

//Retorna el numero de divisores posibles
int ObtenerListaDivisores(int valor, int** Divisores)
{
   int i, j=0, nDivisores=0;

   for(i=1;i<valor;i++)
      if(valor%i==0){
         nDivisores++;
      }

   *Divisores = (int*)malloc(sizeof(int) * nDivisores);

   for(i=1;i<valor;i++)
      if(valor%i==0){
         (*Divisores)[j]=i;
         j++;
      }
   return nDivisores;
}
//---------------------------------------------------------------------------

void LiberarListaDivisores(int** Divisores)
{
   if(*Divisores != NULL)
      free(*Divisores);
}
//---------------------------------------------------------------------------

//Funcion que obtiene la pareja de numeros para un MCD
int ObtenerPareja(int dividendo, int** Divisores, int nDivisores, int* valor1, int* valor2, int posX, int posY)
{
   int divisorComun=0;
   int n,z, salir=0;
   int retval=0;

   if(nDivisores>1){
      divisorComun = MCD((*Divisores)[posX],(*Divisores)[posY]);
      *valor1 = divisorComun;
      *valor2 = dividendo/divisorComun;
   }else{
      retval=-1;
   }
   return retval;
}
//---------------------------------------------------------------------------

//Funcion para barajar el array de los divisores
void shuffle(int *Divisores, int nDivisores)
{
   int i, j, t;

   if (nDivisores > 1)
   {
      for (i = 0; i < nDivisores - 1; i++)
      {
         j = i + rand() % (nDivisores - i);
         t = Divisores[j];
         Divisores[j] = Divisores[i];
         Divisores[i] = t;
      }
   }
}
//--------------------------------------------------------------------------- 


[ecfisa]

Empezado por aguml

En C no se puede pasar el apuntador por referencia de ese modo...

Mismo ejemplo en C:

Código PHP:

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

#define ELEM 10

void foo(int* v, int);

int main()
{
  int i, *vec = (int*) malloc(sizeof(int) * ELEM);

  foo(vec, ELEM);
  for (i = 0; i < ELEM; i++) printf("%3d", vec[i]);
  free(vec);

  getchar();
}

void foo(int* v, int n) {
  int i;
  for(i = 0; i < n; i++) *(v+i) = i;
} 


Saludos

[aguml]

Ok, mañana lo miro que hoy ya es muy tarde. ¿Estas seguro que si lo hago así como indicas pero usando malloc dentro de la funcion funcionará? He corregido otros fallos que vi por el codigo:

Código PHP:

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

int MCD(int a, int b);
int ObtenerListaDivisores(int valor, int** Divisores);
void LiberarListaDivisores(int** Divisores);
int ObtenerPareja(int dividendo, int** Divisores, int nDivisores, int* valor1, int* valor2, int pos);
void shuffle(int *Divisores, int nDivisores);

int main()
{
   int i, n, z, multiplicando, multiplicador, divisorComun, nDivisores;
   int *Divisores;
   int Resultado[10]={0};
   int dividendo = 100;
   int salir = 0, repetido, retval=0, posibles=0;
   int dibujados[100]={0};

   //Inicializo la semilla para rand()
   srand (time(NULL));

   //Coloco el valor del pico de la piramide en el array que almacena el resultado
   Resultado[0]=dividendo;


   //Obtengo todos los divisores del valor del pico de la piramide
   nDivisores = ObtenerListaDivisores(dividendo, &Divisores);

   //Barajo la lista de divisores
   shuffle(Divisores,nDivisores);

   retval=0;

   //Con este bucle puedo calcular todas las posibilidades del segundo nivel de la pirámide
   for(z=0;z<nDivisores && salir==0;z++)
   {
      //Obtengo los dos valores del segundo nivel
      retval = ObtenerPareja(dividendo, &Divisores, nDivisores, &multiplicando, &multiplicador, z);

      //Si no hubo error entramos
      if(retval != -1){
         //Coloco los dos valores del segundo nivel en el array del resultado
         Resultado[1]=multiplicando;
         Resultado[2]=multiplicador;

         //Calculo el valor central del tercer nivel
         divisorComun = MCD(multiplicando,multiplicador);

         //Calculo los dos extremos del tercer nivel para este MCD
         if(multiplicando < divisorComun)
            multiplicando= divisorComun/multiplicando;
         else
            multiplicando= multiplicando/divisorComun;

         if(multiplicador < divisorComun)
            multiplicador = divisorComun/multiplicador;
         else
            multiplicador= multiplicador/divisorComun;

         //Coloco los tres valores del tercer nivel en el array del resultado.
         //El MCD va en el centro
         Resultado[3]=multiplicando;
         Resultado[4]=divisorComun;
         Resultado[5]=multiplicador;

         //Incremento el contador de posibles soluciones
         posibles++;

         //Muestro la pirámide
         printf("         %i\n", Resultado[0]);
         printf("      %i     %i\n", Resultado[1], Resultado[2]);
         printf("   %i     %i     %i\n", Resultado[3], Resultado[4], Resultado[5]);
         printf("%i     %i     %i     %i\n", 1, 1, 1, 1); //Me falta calcular esta fila
         printf("\n---------------------------------\n");
      }
   }
   printf("\nSe obtuvieron %i posibles soluciones.\n",posibles);

   //Libero la memoria reservada para almacenar los divisores para el segundo nivel
   LiberarListaDivisores(&Divisores);

   printf("\nPresiona INTRO para salir");
   getchar();
   return 0;
}
//---------------------------------------------------------------------------

//Máximo común divisor de dos números mediante el algoritmo de Euclides.
int MCD(int a, int b)
{
   int aux, c, r;

   if(a < b){
      aux=b;
      b=a;
      a=aux;
   }

   r=a%b;
   while(r>0)
   {
      if(a>b){
         a=b;
         b=r;
         r=a%b;
      }else{
         b=0;
         break;
      }
   }
   return b;
}
//---------------------------------------------------------------------------

//Retorna el numero de divisores posibles
int ObtenerListaDivisores(int valor, int** Divisores)
{
   int i, j=0, nDivisores=0;

   for(i=1;i<=valor;i++)
      if(valor%i==0){
         nDivisores++;
      }

   *Divisores = (int*)malloc(sizeof(int) * nDivisores);

   for(i=1;i<=valor;i++)
      if(valor%i==0){
         (*Divisores)[j]=i;
         j++;
      }
   return nDivisores;
}
//---------------------------------------------------------------------------

void LiberarListaDivisores(int** Divisores)
{
   if(*Divisores != NULL)
      free(*Divisores);
}
//---------------------------------------------------------------------------

//Funcion que obtiene la pareja de numeros para un MCD
int ObtenerPareja(int dividendo, int** Divisores, int nDivisores, int* valor1, int* valor2, int pos)
{
   int divisorComun=0;
   int n,z, salir=0;

   if(nDivisores>1){
      *valor1 = (*Divisores)[pos];
      *valor2 = (dividendo / *valor1);
      divisorComun = MCD(*valor1, *valor2);
   }else{
      divisorComun=-1;
   }
   return divisorComun;
}
//---------------------------------------------------------------------------

//Funcion para barajar el array de los divisores
void shuffle(int *Divisores, int nDivisores)
{
   int i, j, t;

   if (nDivisores > 1)
   {
      for (i = 0; i < nDivisores; i++)
      {
         j = i + rand() % (nDivisores-1 - i + 1);
         t = Divisores[i];
         Divisores[i] = Divisores[j];
         Divisores[j] = t;
      }
   }
}
//--------------------------------------------------------------------------- 


[ecfisa]

Hola aguml.

Para que sea un código mas claro y menos proclive a errores, yo creo que es mejor usar malloc/free fuera de la función, sobre todo si la llamas mas de una vez.

Saludos

[engranaje]

Acerca del nivel 4 y posteriores... a ver si te sirve de ayuda lo que pienso. La cosa es que ya no basta solo con un divisor común. El cociente de dividir el dividendo de la derecha en la linea superior entre el divisor tiene a su vez que ser divisor de ese mismo número y del siguiente número a la derecha... a ver si puedo aclararlo con un pseudográfico.

A B C
D dcAB dcBC F

siendo dcAB el divisor común de A y B, y siendo dcBC el divisor común de B y C hay que comprobar que:

B/dcAB es divisor de C para poder garantizar que es un dcBC. Esto tocará hacerlo para cada elemento no exterior del triangulo de mood que como ves puede incluso suceder que siguiendo un "camino" encuentres divisores comunes para los 2 primeros elementos pero te falle el tercero y debas abandonar este camino.

[aguml]

Lo he solucionado aunque creo que lo hago de una forma algo diferente a lo que explicas (o eso creo jejeje). Pongo el codigo a ver que os parece:

Código PHP:

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

int MCD(int a, int b);
int ObtenerNumeroDeDivisores(int valor);
void ObtenerListaDivisores(int valor, int* Divisores);
int ObtenerPareja(int dividendo, int* Divisores, int nDivisores, int* valor1, int* valor2, int pos);
void shuffle(int* Divisores, int nDivisores);

int main()
{
   int i, n, z, multiplicando, multiplicador, divisorComun, nDivisores;
   int *Divisores;
   int Resultado[10]={0};
   int repetido, retval=0, posibles=0;
   int salir;
   char caracter;

   //Inicializo la semilla para rand()
   srand (time(NULL));

   do{
      //Pido el valor del pico de la piramide
      printf("Introduce el valor de la cima de la piramide: ");
      scanf("%d",&Resultado[0]);
      printf("\n---------------------------------\n");

      nDivisores = ObtenerNumeroDeDivisores(Resultado[0]);

      Divisores = (int*)malloc(sizeof(int) * nDivisores);

      //Obtengo todos los divisores del valor del pico de la piramide
      ObtenerListaDivisores(Resultado[0], Divisores);

      //Barajo la lista de divisores
      shuffle(Divisores,nDivisores);

      retval=0;

      //Con este bucle puedo calcular todas las posibilidades del segundo nivel de la pirámide
      for(z=0;z<nDivisores;z++)
      {
         //Obtengo los dos valores del segundo nivel
         retval = ObtenerPareja(Resultado[0], Divisores, nDivisores, &multiplicando, &multiplicador, z);

         //Si no hubo error entramos
         if(retval != -1){
            //Coloco los dos valores del segundo nivel en el array del resultado
            Resultado[1]=multiplicando;
            Resultado[2]=multiplicador;

            //Calculo el valor central del tercer nivel
            divisorComun = MCD(multiplicando,multiplicador);

            //Calculo los dos extremos del tercer nivel para este MCD
            if(multiplicando < divisorComun)
               multiplicando= divisorComun/multiplicando;
            else
               multiplicando= multiplicando/divisorComun;

            if(multiplicador < divisorComun)
               multiplicador = divisorComun/multiplicador;
            else
               multiplicador= multiplicador/divisorComun;

            //Coloco los tres valores del tercer nivel en el array del resultado.
            //El MCD va en el centro
            Resultado[3]=multiplicando;
            Resultado[4]=divisorComun;
            Resultado[5]=multiplicador;

            multiplicador = divisorComun;
            divisorComun = MCD(multiplicando, multiplicador);

            //Calculo los dos extremos del tercer nivel para este MCD
            if(multiplicando < divisorComun)
               multiplicando= divisorComun/multiplicando;
            else
               multiplicando= multiplicando/divisorComun;

            if(multiplicador < divisorComun)
               multiplicador = divisorComun/multiplicador;
            else
               multiplicador= multiplicador/divisorComun;

            Resultado[6]=multiplicando;
            Resultado[7]=divisorComun;
            Resultado[8]=multiplicador;

            if(Resultado[8] <= Resultado[5] && Resultado[5] % Resultado[8] == 0)
            {
               Resultado[9]=Resultado[5] / Resultado[8];

               //Incremento el contador de posibles soluciones
               posibles++;

               //Muestro la pirámide
               printf("         %i\n", Resultado[0]);
               printf("      %i     %i\n", Resultado[1], Resultado[2]);
               printf("   %i     %i     %i\n", Resultado[3], Resultado[4], Resultado[5]);
               printf("%i     %i     %i     %i\n", Resultado[6], Resultado[7], Resultado[8], Resultado[9]); //Me falta calcular esta fila
               printf("\n---------------------------------\n");
            }
         }
      }

      if(nDivisores == 2)
         printf("\nEl valor introducido es primo. Solo se pueden obtener 2 posibilidades.\n");
      else
         printf("\nSe obtuvieron %i posibles soluciones.\n",posibles);

      //Libero la memoria reservada para almacenar los divisores para el segundo nivel
      if(Divisores != NULL)
         free(Divisores);

      //Pido que el usuario decida si repetir o salir
      do{
         fflush(stdin);
         printf("\nPresiona 'S' para salir o 'R' para repetir: ");
         caracter = getchar();
      }while(caracter != 'S' && caracter != 's' && caracter != 'R' && caracter != 'r');

      if(caracter == 'S' || caracter == 's')
         salir = 1;
      else
         system("CLS");
   }while(salir != 1);

   return 0;
}
//---------------------------------------------------------------------------

//Máximo común divisor de dos números mediante el algoritmo de Euclides.
int MCD(int a, int b)
{
   int aux, c, r;

   if(a < b){
      aux=b;
      b=a;
      a=aux;
   }

   r=a%b;
   while(r>0)
   {
      if(a>b){
         a=b;
         b=r;
         r=a%b;
      }else{
         b=0;
         break;
      }
   }
   return b;
}
//---------------------------------------------------------------------------

//Retorna el numero de divisores posibles
int ObtenerNumeroDeDivisores(int valor)
{
   int i, nDivisores=0;

   for(i=1;i<=valor;i++)
      if(valor%i==0){
         nDivisores++;
      }
   return nDivisores;
}
//---------------------------------------------------------------------------

//Rellena el array con divisores posibles
void ObtenerListaDivisores(int valor, int* Divisores)
{
   int i, j=0;

   for(i=1;i<=valor;i++)
      if(valor%i==0){
         *(Divisores+j)=i;
         j++;
      }
}
//---------------------------------------------------------------------------

//Funcion que obtiene la pareja de numeros para un MCD
int ObtenerPareja(int dividendo, int* Divisores, int nDivisores, int* valor1, int* valor2, int pos)
{
   int divisorComun=0;
   int n,z;

   if(nDivisores>0){
      *valor1 = *(Divisores+pos);
      *valor2 = (dividendo / *valor1);
      divisorComun = MCD(*valor1, *valor2);
   }else{
      divisorComun=-1;
   }
   return divisorComun;
}
//---------------------------------------------------------------------------

//Funcion para barajar el array de los divisores
void shuffle(int *Divisores, int nDivisores)
{
   int i, j, t;

   if (nDivisores > 1)
   {
      for (i = 0; i < nDivisores; i++)
      {
         j = i + rand() % (nDivisores-1 - i + 1);
         t = *(Divisores+i);
         *(Divisores+i) = *(Divisores+j);
         *(Divisores+j) = t;
      }
   }
}
//---------------------------------------------------------------------------