algoritmo  BuscaDivisoresMultiplicadosIgualesNumero
            var
                        num, divisor1, divisor2, divisor3: entero;
            fvar


            num := leerEntero( ); 

            mientras  (num ≠ -1) hacer    
                        buscadivisor1(num, divisor1, divisor2,divisor3);  

                        si loEs(num, divisor1, divisor2,divisor3)  entonces
                                          printaExito(num, divisor1, divisor2,divisor3

                        sino
                                          printaFracaso(num);

                         fsi  


                         num := leerEntero( ); 

            fmientras


       falgoritmo
 

      accion printaExito( ent a: entero, ent b: entero, ent c: entero, ent d: entero )


                  escribirCadena(‘El número: ‘);
                  escribirEntero(a);

                  escribirCadena(‘ es igual a  ‘);

                  escribirEntero(b);

                  escribirCadena(‘ multiplicado por  ‘);

                  escribirEntero(c);   

                  escribirCadena(‘ y por ‘);

                  escribirEntero(d);   

            fsi         

      faccion 


      accion printaFracaso(ent a: entero)
            escribirCadena(‘El número: ‘);
            escribirEntero(a);
            escribirCadena(‘ no tiene divisores diferentes de 1 que multiplicados sean igual a el. ‘);
      faccion 


      funcion loEs(ent x: entero,ent y:entero,ent z: entero, ent w: entero): booleano;

                        retorna x = (y * z * w);             
      ffuncion 


      accion buscadivisor1(ent n: entero, sal d1: entero, sal d2: entero, sal d3: entero )
            var

                   encontrado: booleano; 
            fvar

            encontrado:=falso;

            d1:=2;

            d2:=2;

            d3:=2;

            mientras  d1<=(n div 2) y no encontrado  hacer
                  buscadivisor2 (n,d1,d2,d3);
                  encontrado:= loEs (n,d1,d2,d3);

                   si   no encontrado  entonces

                           d1:=d1+1;

                   fsi   
            fmientras
      faccion
 

      accion buscadivisor2( ent num: entero, ent d1: entero, sal d2: entero, sal d3: entero  )

            var

                   encontrado: booleano; 
            fvar

            encontrado:=falso;

            d2:=2;

            d3:=2;

            mientras  d2 <= (num div 2) y no encontrado  hacer
                  buscadivisor3(num,d1,d2,d3);  

                 encontrado:= loEs (num,d1,d2,d3);
                  si no encontrado  entonces
                        d2:=d2+1;
                  fsi       
            fmientras
      faccion 

 

      accion buscadivisor3( ent num: entero, ent d1: entero, sal d2: entero, sal d3: entero  )

            var

                   encontrado: booleano; 
            fvar

            encontrado:=falso;

            d3:=2;

            mientras  d3 <= (num div 2) y no encontrado  hacer

                 encontrado:= loEs (num,d1,d2,d3);
                  si no encontrado  entonces
                        d3:=d3+1;
                  fsi       
            fmientras
      faccion

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

int* findDivisors(int number, int* divisorCount) {
    int* divisors = NULL;
    *divisorCount = 0;

    // Store divisors in a dynamic array
    for (int i = 2; i <= number / 2; i++) {
        if (number % i == 0) {
            (*divisorCount)++;

            // Add the divisor to the dynamic array
            divisors = realloc(divisors, (*divisorCount) * sizeof(int));
            divisors[*divisorCount - 1] = i;
        }
    }

    return divisors;
}

int findProduct(int* divisors, int divisorCount, int* productIndices) {
    for (int i = 0; i < divisorCount - 2; i++) {
        for (int j = i + 1; j < divisorCount - 1; j++) {
            for (int k = j + 1; k < divisorCount; k++) {
                int product = divisors[i] * divisors[j] * divisors[k];
                if (product == divisors[i] || product == divisors[j] || product == divisors[k]) {
                    // Store indices of divisors forming the product
                    productIndices[0] = i;
                    productIndices[1] = j;
                    productIndices[2] = k;
                    return product;
                }
            }
        }
    }
    return -1; // Indicates no such product was found
}

int main() {
    int number, divisorCount;
    int* divisors;

    printf("Introduce un numero: ");
    scanf("%d", &number);

    divisors = findDivisors(number, &divisorCount);

    if (divisorCount > 0) {
        printf("Divisores de %d: ", number);
        for (int i = 0; i < divisorCount; i++) {
            printf("%d ", divisors[i]);
        }
        printf("\n");

        int productIndices[3];
        int product = findProduct(divisors, divisorCount, productIndices);

        if (product != -1) {
            printf("El producto de los divisores %d, %d, y %d es igual a %d.\n",
                   divisors[productIndices[0]], divisors[productIndices[1]], divisors[productIndices[2]], product);
        } else {
            printf("No hay algun producto de los divisores igual a uno de los divisores.\n");
        }
    } else {
        printf("El numero %d no tiene divisores mayores que 1.\n", number);
    }

    // Free the memory of the dynamic array
    free(divisors);

    return 0;
}