Iniciar sesiónCrear cuenta

# Dev - C++ - Apuntadores

Vista:

Publicado por Erick (1 intervención) el 13/08/2017 02:28:57
ALGUIEN PORFAVOR QUE ME PUEDA EXPLICAR LOS PASOS E ESTE CODIGO!? SE QUE USA APUNTADORES Y ES PARA SACAR EL MINIMO COMÚN MÚLTIPLO MÁS SIN EMBARGO NO ENTIENDO LA LOGICA QUE USA Y SU MATEMÁTICA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
`#include <stdio.h>`
`#include <stdlib.h>`
`#include <iostream>`
` `
`bool isPrimo(int numero);`
`int nextPrimo(int start);`
`int maxArr(int *arr, int n);`
`int dividirArr(int *arr, int n, int numero);`
`int printArr(int *arr, int n);`
`int mcm(int *arr, int n);`
`bool esDivisibleArr(int *arr, int n, int numero);`
` `
`int main(){`
`	std::cout << "MCM:";`
`	std::cout << "n = ";`
`	int n;`
`	std::cin >> n;`
`	int *enteros = new int[n];`
`	for(int i  = 0; i < n; i++){`
`		std::cin >> enteros[i];`
`	}`
`	std::cout << "mcm = " << mcm(enteros,n) << std::endl;`
`	return 0;`
`}`
` `
`int mcm(int *arr, int n){`
`	int primo = 1;`
`	int intMcm = 1;`
`	while( maxArr(arr,n) > 1){`
`		primo = nextPrimo(primo);`
`		while( esDivisibleArr(arr,n,primo)){`
`			dividirArr(arr,n,primo);`
`			intMcm *= primo;`
`		}`
`	}`
`	return intMcm;`
`}`
` `
`bool esDivisibleArr(int *arr, int n, int numero){`
`	bool divisible = false;`
`	for(int i = 0; i < n && !divisible; i++){`
`		if( arr[i]%numero == 0)`
`			divisible = true;`
`	}`
`	return divisible;`
`}`
` `
`int printArr(int *arr, int n){`
`	for(int i = 0; i < n; i++){`
`		std::cout << arr[i] <<" ,";`
`	}`
`}`
` `
`int dividirArr(int *arr, int n, int numero){`
`	for(int i = 0; i < n; i++){`
`		if( arr[i]%numero == 0)`
`			arr[i] = arr[i]/numero;`
`	}`
`}`
` `
`int maxArr(int *arr, int n){`
`	int max = -1;`
`	if( n > 1 ){`
`		max = arr[0];`
`		for(int i = 1; i < n; i++){`
`			if ( max < arr[i] )`
`				max = arr[i];`
`		}`
`	}`
`	return max;`
`}`
` `
`int nextPrimo(int start){`
`	start++;`
`	while( !isPrimo(start) ){`
`		start++;`
`	}`
` `
`	return start;`
`}`
` `
`bool isPrimo(int numero){`
`	int nveces = 0;`
`	for(int i = 2; i < numero && nveces == 0; i++){`
`		if( numero%i == 0){`
`			nveces++;`
`		}`
`	}`
`	return nveces==0;`
`}`
Valora esta pregunta
0
Val: 417

Publicado por Thanatos (192 intervenciones) el 13/08/2017 14:14:02
Función maxArr:
Si la cantidad de valores es mayor que 1, devuelve el mayor elemento. Si no, devuelve -1.

Función isPrimo:
Cuenta el número de divisores del número que recibe como entrada. Divide el número utilizando como divisores los números desde el 2 hasta el mismo número o hasta que el contador nveces sea diferente de cero. Finalmente, si el contador es igual a cero devuelve 1 (true), si no devuelve 0 (false).

Función nextPrimo:
Devuelve el siguiente número primo, mayor al número que recibe como entrada.

Función esDivisibleArr:
Verifica si todos los números de arr son divisibles entre el numero. Si todos son divisibles devuelve true, si no false.

Función dividirArr:
Modifica los elementos de arr. Divide el valor de cada elemento de arr entre el numero que recibe como parámetro y almacena el resultado en la posición que ocupaba el elemento.

El tipo de retorno de esta función debería estar declarado como void, porque no devuelve ningún valor,

Función printArr:
No es utilizada en ninguna parte del código. Esta función también tiene un error en el tipo de dato que devuelve.

Función mcm:
Líneas 27 y 28:
Inicializa, los valores de las variables primo e intMcm con el valor 1.

Línea 29:
Inicia un bucle while que se ejecuta mientras el máximo valor almacenado en arr sea mayor que 1.

Linea 30:
Se reemplaza el valor actual de primo por el siguiente número primo mayor al valor actual.

Línea 31:
Se inicia un bucle while que se ejecuta si todos los números de arr son divisibles entre primo.

Línea 32:
Se divide cada elemento de arr usando a primo como divisor y se almacena el resultado en la posición que antes ocupaba el elemento correspondiente.

Línea 33:
Se acumula el producto de la multiplicación de los números primos que son divisores de todos los elementos del array, con lo que se genera el mínimo común múltiplo.

Nota: En el código que publicaste no se liberó la memoria que fue reservada en la línea 18, después de terminar de utilizarla.

Otra manera de obtener el mcm sin utilizar las funciones estándar de C++:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
`#include <iostream>`
` `
`unsigned *leerNumeros(const size_t);`
`unsigned calcularMCM(const unsigned *, const size_t);`
`unsigned mcd(unsigned, unsigned);`
`unsigned mcm(unsigned, unsigned);`
` `
`int main() {`
`    size_t size;`
` `
`    std::cout << "MINIMO COMUN MULTIPLO\n"`
`              << "Ingrese la cantidad de numeros: ";`
` `
`    if (std::cin >> size) {`
`        unsigned *numeros = leerNumeros(size);`
`        if (numeros) {`
`            std::cout << "mcm = " << calcularMCM(numeros, size) << '\n';`
`            delete[] numeros;`
`        } else {`
`            std::cout << "\n* Error al reservar memoria *\n";`
`        }`
`    } else {`
`        std::cout << "\n* Se esperaba un entero positivo *\n";`
`    }`
` `
`    return 0;`
`}`
` `
`unsigned *leerNumeros(const size_t size) {`
`    unsigned *numeros = new unsigned[size];`
` `
`    for (size_t i = 0 ; i < size; ++i) {`
`        std::cout << "numeros[" << i + 1 << "] = ";`
`        std::cin >> numeros[i];`
`        if (std::cin.bad()) {`
`            std::cout << "\n* Se esperaba un entero positivo *\n";`
`            break;`
`        }`
`    }`
` `
`    return numeros;`
`}`
` `
`unsigned calcularMCM(const unsigned *numeros, const size_t size) {`
`    if (size < 2) {`
`        return 0;`
`    }`
` `
`    unsigned ultimoMCM = mcm(numeros[0], numeros[1]);`
`    for (size_t i = 2; i < size; ++i) {`
`        ultimoMCM = mcm(ultimoMCM, numeros[i]);`
`    }`
` `
`    return ultimoMCM;`
`}`
` `
`unsigned mcd(unsigned num1, unsigned num2) {`
`    unsigned aux;`
` `
`    while (num1 != 0) {`
`        aux = num1;`
`        num1 = num2 % num1;`
`        num2 = aux;`
`    }`
` `
`    return num2;`
`}`
` `
`unsigned mcm(unsigned num1, unsigned num2) {`
`    return (num2 / mcd(num1, num2)) * num1;`
`}`
Valora esta respuesta
1