saber valores de base de piramide a partir de su resultado

[engranaje]

Yo sigo en la línea de las respuestas que ya te han dado. Mi planteamiento es una función que dado un número devuelva todas los posibles productos de 2 números que den como resultado el número pasado. Se me ocurre que por defecto ya tenemos una tupla (1,numeroPasado) , y despues bastaría con un bucle incrementando i comparando cuando numeroPasado mod i = 0, para cada vez que se cumpla la condición añadir una tupla mas a la lista de posibles semillas del número pasado (i,numeropasado/i).

Asi tendras el vertice y todas las posibles 2º lineas de triangulo que daran como resultado ese vertice. Según cuantas lineas quieres que tenga el triangulo te tocara para todas esas tuplas buscar los divisores comunes de los dos elementos teniendo en cuenta solo las tuplas que tengan divisores comunes.

Tendremos una 3º linea por cada divisor común con 3 números: en medio el divisor común, a la izquierda el numero de la izuierda en la 2º linea dividido entre el divisor comun y a la derecha el número de la derecha de la 2º líneda dividida entre el divisor común.

La 3º línea se complica y para cada divisor común del número de la izquierda y del centro además el número del centro/divisor común debe de ser divisor común del número del centro y el número de la derecha...

En fín me he puesto a escribir mientras pensaba y me he liado, lo cierto es que si parece posible.
PD: Neftalí se me ha adelantado mientras escribía esto explicando como siempre todo con mucha mas claridad. (y en 2 lineas, nnf, nnnf)

[aguml]

pues la verdad es que yo me lio y no soy capaz de hacer lo que indicais. Lo que si que se me ha ocurrido leyendoos es que si hago lo que indicais pero en vez de dividir multiplico obtendria una piramide divertida para hacer divisiones y obtener el resultado de su cima. El caso es que en ninguno de los casos se me ocurre como hacerlo. El caso es mas complejo de lo que parece ya que, en lo que exponia al iniciar este tema, la linea de dos valores (la que esta justo debajo de la cima tiene que contener valores mas o menos grandes y, cuando decis de probar todos los divisores, me puedo encontrar que hay valores pequeños que pueden ser divisores como 1, 2, y 3 y el caso es que es muy dificil que se llegue a ese nivel de la pirámide con un producto tan pequeño. La verdad es que no lo veo. ¿Habeis probado alguno a ver si os sale o es mas complejo de lo que parece? Como es por curiosidad pues no hay requisitos, podria ser por ejemplo que muestre la primera solucion, o tambien que las calcule todas y luego mostrar una al azar, o por ejemplo mostrar las x primeras, o cualquier cosa por el estilo. La idea surgio porque a mi niña le mandaron en el cole un trabajo de matematicas divertidas y buscando por google di con algo llamado piramide divertida y que las hay para sumas y multiplicaciones. Ya hice que un codigo resuelva ambas y luego se me ocurrio hacer lo inverso pero ahi ya me atasqué. Por cierto, no vi ninguna piramide para divisiones asi que no estaria mal aplicar lo que indicais para crear piramides para que practique las divisiones tambien.

[engranaje]

A ver si no me lio... La cosa es que de todos esos posibles valores para la segunda línea vas a tener que descartarlos casi todos a no econtrar divisores comunes entre ambos. Es decir el número del medio de la tercera linea debe ser un divisor común a los dos números de la segunda, Si quieres puedes buscar directamente el máximo común divisor y pillar la tupla con el máximo comúm divisor mas alto, asi elminiarias esos números bajos que tanto molestan.
Lo que pasa es que como la tercera línea también debe tener divisores comunes igual llegas a un punto muerto en la tercera línea de la piramide.... De entrada y si es por jugar yo probaría lo que digo de escoger la tupla con el máximo común divisor mas alto a ver que sale.

[Neftali [Germán.Estévez]]

Empezado por aguml

... y cuando decis de probar todos los divisores, me puedo encontrar que hay valores pequeños que pueden ser divisores como 1, 2, y 3 y el caso es que es muy dificil que se llegue a ese nivel de la pirámide con un producto tan pequeño.

Correcto. Esos casos se consideran de ERROE. Por eso se llama "PRUEBA Y ERROR". Por que se evalúan todos los casos posibles que pueden ser miles. De todos esos tal vez unos cuantos, uno sólo o ninguno sean viables (CORRECTOS).

[Neftali [Germán.Estévez]]

Yo creo que la cosa no es tan difícil.
Te recomiendo dividir el problema en pasos pequeños.

Por ejemplo, primer paso:

(PASO 1) Dado un número (864) obtener todos sus divisores: 1-2-3-4-6-8-9-12-16-18-24-27-32-36-48-54-72-96-108-144-216-288-432

[Neftali [Germán.Estévez]]

(PASO 2): Utilizando esos divisores, buscar todas las parejas que son válidas para un nivel inferior.

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