saber valores de base de piramide a partir de su resultado

[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;
      }
   }
}
//---------------------------------------------------------------------------