saber valores de base de piramide a partir de su resultado

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


[aguml]

Y este para crear la piramide divertida pero de divisiones:

Código PHP:

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

#define MAXCOUNTBUCLES 10

int ObtenerPosibles(double* Resultado, int posToShow);
void ObtenerNivelDos( double* pResultado, double cociente, double divisor);
int ObtenerNivelTres(double* pResultado, double valor6);
int ObtenerNivelCuatro(double* pResultado, double valor9);

int main()
{
   double Resultado[10]={0.0};
   int posibles=0, posToShow;
   int salir=0;
   char caracter;

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

      posibles = ObtenerPosibles(Resultado,-1);
      printf("\nSe obtuvieron %i posibles soluciones para un contador maximo para los bucles de %i.\n", posibles, MAXCOUNTBUCLES);

      if(posibles > 0){
         printf("Introduce el indice de la piramide que deseas mostrar ('0' para mostrar todas): ");
         scanf("%i",&posToShow);

         posibles = ObtenerPosibles(Resultado,posToShow);
      }

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

int ObtenerPosibles(double* Resultado, int posToShow)
{
   int i, x, n, retval, posibles=0;

   for(i=1;i<MAXCOUNTBUCLES;i++)
   {
      ObtenerNivelDos(Resultado, Resultado[0], i);

      for(x=1;x<MAXCOUNTBUCLES;x++)
      {
         retval = ObtenerNivelTres(Resultado, x);

         if(retval == 0){
            for(n=1;n<MAXCOUNTBUCLES;n++)
            {
               retval = ObtenerNivelCuatro(Resultado, n);

               if(retval == 0){
                  posibles++;
                  if(posToShow == posibles || posToShow == 0){
                     //Muestro la pirámide
                     printf("\n---------------------------------\n");
                     printf("         %.0lf\n", Resultado[0]);
                     printf("      %.0lf     %.0lf\n", Resultado[1], Resultado[2]);
                     printf("   %.0lf     %.0lf     %.0lf\n", Resultado[3], Resultado[4], Resultado[5]);
                     printf("%.0lf     %.0lf     %.0lf     %.0lf\n", Resultado[6], Resultado[7], Resultado[8], Resultado[9]);
                  }
               }
            }
         }
      }
   }
   if(posToShow != -1)
      printf("\n---------------------------------\n");
   return posibles;
}
//---------------------------------------------------------------------------

void ObtenerNivelDos( double* pResultado, double cociente, double divisor)
{
   *(pResultado+1) = cociente * divisor;
   *(pResultado+2) = divisor;
}
//---------------------------------------------------------------------------

int ObtenerNivelTres(double* pResultado, double valor6)
{
   int retval=-1;

   *(pResultado+5) = valor6;
   *(pResultado+4) = *(pResultado+5) * *(pResultado+2);
   if(*(pResultado+4) <= *(pResultado+1)){
      *(pResultado+3) = *(pResultado+1) * *(pResultado+4);
      retval = 0;
   }
   return retval;
}
//---------------------------------------------------------------------------

int ObtenerNivelCuatro(double* pResultado, double valor9)
{
   int retval=-1;

   *(pResultado+9) = valor9;
   *(pResultado+8) = *(pResultado+9) * *(pResultado+5);
   if(*(pResultado+8) <= *(pResultado+4)){
      *(pResultado+7) = *(pResultado+4) * *(pResultado+8);
      if(*(pResultado+7) <= *(pResultado+3)){
         *(pResultado+6) = *(pResultado+3) * *(pResultado+7);
         retval = 0;
      }
   }
   return retval;
}
//--------------------------------------------------------------------------- 


¿que os parece? La verdad es que no soy programador profesional, todo lo que se lo he aprendido por libre porque siempre me ha apasionado la programacion y para mi plantearme hacer un codigo es como para otros hacer un sudoku, me divierte y me entretiene y hay veces (muchas) que tengo que pedir ayuda porque me atasco .

[aguml]

Esta es la idea con la que empezó todo, vi una imagen en internet donde aparecia una esfinge con 4 piramides de estas y se me ocurrio hacer una estrella y al final puedo poner tanto multiplicaciones como divisiones jejeje.