11 KiB
| title | localeTitle |
|---|---|
| Smallest Common Multiple | El múltiplo común más pequeño |
Recuerda usar Read-Search-Ask si te atascas. Tratar de emparejar el programa 
y escribe tu propio código 
Explicación del problema:
El mínimo común más pequeño entre dos números es el número más pequeño en el que ambos números pueden dividirse. Este concepto puede extenderse a más de dos números también.
Primero podemos comenzar con solo encontrar el múltiplo común más pequeño entre dos números. De manera ingenua, puedes comenzar a escribir múltiples de cada número hasta que escribas un múltiplo que exista de ambos números.
Un ejemplo serían los números 3 y 4 . Los múltiplos de 3 son 3, 6, 9, 12, 15, 18, ... y los múltiplos de 4 son 4, 8, 12, 16, 20, ... El primer número más pequeño con el que nos encontramos en ambas listas es 12 por lo que este es el múltiplo común más pequeño entre 3 y 4 .
Este problema puede ser confuso porque la mayoría de las personas buscan el mínimo común más pequeño de solo los dos números, pero se olvidan del rango de palabras clave. Sin embargo, esto significa que si le dan [1,5] , entonces debe verificar el mínimo común más pequeño para todos los números [1,2,3,4,5] que es divisible por todos ellos.
Enlaces relevantes
Sugerencia: 1
Cree una matriz con todos los números que faltan en la matriz original para facilitar la verificación cuando tenga que verificar la división uniforme.
intenta resolver el problema ahora
Sugerencia: 2
Puede usar el operador de resto ( % ) para verificar si el recordatorio de una división es 0, lo que significa que es equitativamente divisible.
intenta resolver el problema ahora
Sugerencia: 3
Si ordena la matriz de mayor a menor, entonces puede usar los dos primeros números como primera comprobación del mínimo común más pequeño. Esto se debe a que es más probable que sean el múltiplo común más pequeño que los números más bajos.
intenta resolver el problema ahora
¡Alerta de spoiler!
¡Solución por delante!
Solución de código básico:
function smallestCommons(arr) {
// Sort array from greater to lowest
// This line of code was from Adam Doyle (http://github.com/Adoyle2014)
arr.sort(function(a, b) {
return b - a;
});
// Create new array and add all values from greater to smaller from the
// original array.
var newArr = [];
for (var i = arr[0]; i >= arr[1]; i--) {
newArr.push(i);
}
// Variables needed declared outside the loops.
var quot = 0;
var loop = 1;
var n;
// Run code while n is not the same as the array length.
do {
quot = newArr[0] * loop * newArr[1];
for (n = 2; n < newArr.length; n++) {
if (quot % newArr[n] !== 0) {
break;
}
}
loop++;
} while (n !== newArr.length);
return quot;
}
// test here
smallestCommons([1,5]);
Explicación del código:
- Debido a la posibilidad de que el denominador común más pequeño se encuentre entre los dos números más grandes, tiene sentido verificarlos primero, así que ordene la matriz.
- Crea una nueva matriz para ordenar todos los números,
newArr. - Use un bucle descendente
for(var i = arr[0]; i >= arr[1]; i--) para sumar los números del mayor al más pequeño en la nueva matriz. - Declare las variables para el cociente para que podamos acceder a ellas fuera del bucle:
- el cociente que será nuestro múltiplo común más pequeño (
quot) - el número de lazo que estamos comprobando (
loop) - El índice de la matriz de números (
n).
- el cociente que será nuestro múltiplo común más pequeño (
- Use un
dowhilebucle para comprobar lo que necesitamos, mientras quenno es la misma longitud que la nueva matriz. - En la parte
do, vamos a multiplicar el primer número, multiplicado por el número de bucles, multiplicado por el segundo número (quot = newArr[0] * loop * newArr[1];). - La parte de
loopnos permitirá aumentar el número que estamos verificando más allá del número más grande que tenemos sin tener que cambiar el algoritmo. - Entramos en un bucle
forque irá densiendo 2 y subirá en uno (loop++) mientras que es más pequeño que la matriz con todos los números (n < newArr.length). - Si el cociente no se divide uniformemente (
quot % newArr[n] !== 0), detenga el bucle (break;). Si es par, entonces verifique los siguientes elementos (n++) en el arreglo hasta que no esté par o encontremos nuestra respuesta. - Fuera del bucle, aumentar el valor del bucle (
loop++). - Al final del bucle, devuelva el cociente (
return quot;).
Nota: si la matriz solo tiene dos elementos, entonces el bucle for nunca se usa y el valor de retorno es el producto de dichos números.
Enlaces relevantes
- JS Array Prototype Sort
- JS For Loops Explicado
- JS Array Prototype Push
- JS Do While Loop
- Longitud de la cuerda
Solución de código intermedio:
function smallestCommons(arr) {
var range = [];
for (var i = Math.max(arr[0], arr[1]); i >= Math.min(arr[0], arr[1]); i--) {
range.push(i);
}
// can use reduce() in place of this block
var lcm = range[0];
for (i = 1; i < range.length; i++) {
var GCD = gcd(lcm, range[i]);
lcm = (lcm * range[i]) / GCD;
}
return lcm;
function gcd(x, y) { // Implements the Euclidean Algorithm
if (y === 0)
return x;
else
return gcd(y, x%y);
}
}
// test here
smallestCommons([1,5]);
Explicación del código:
- La primera solución básica requiere más de 2,000 bucles para calcular el caso de prueba
smallestCommons([1,13]), y más de 4 millones de bucles para calcularsmallestCommons([1,25]). Esta solución evalúasmallestCommons([1,13])en alrededor de 20 bucles ysmallestCommons([1,25])en 40, mediante el uso de un algoritmo más eficiente. - Hacer un rango de matriz vacía.
- Todos los números entre el rango dado se empujan al rango usando un bucle
for. - El siguiente bloque de código implementa el algoritmo euclidiano, que se utiliza para encontrar los múltiplos comunes más pequeños.
Enlaces relevantes
Solución avanzada de código:
function smallestCommons(arr) {
// range
let min = Math.min.apply(null, arr);
let max = Math.max.apply(null, arr);
let smallestCommon = lcm(min, min + 1);
while(min < max) {
min++;
smallestCommon = lcm(smallestCommon, min);
}
return smallestCommon;
}
/**
* Calculates Greatest Common Divisor
* of two nubers using Euclidean algorithm
* https://en.wikipedia.org/wiki/Euclidean_algorithm
*/
function gcd(a, b) {
while (b > 0) {
let tmp = a;
a = b;
b = tmp % b;
}
return a;
}
/**
* Calculates Least Common Multiple
* for two numbers utilising GCD
*/
function lcm(a, b) {
return (a * b / gcd(a, b));
}
// test here
smallestCommons([1,5]);
Explicación del código:
- Extraer el mínimo y máximo del arr proporcionado.
- Inicialice smallestCommon con el MCM de los dos primeros números.
- Recorrer el rango a través del LCM de cálculo del LCM actual y el siguiente número en el rango de mcm (a, b, c) = mcm (mcm (a, b), c) .
Enlaces relevantes
NOTAS PARA LAS CONTRIBUCIONES:
NO agregue soluciones que sean similares a las soluciones existentes. Si cree que es similar pero mejor , intente fusionar (o reemplazar) la solución similar existente.- Agregue una explicación de su solución.
- Categorice la solución en una de las siguientes categorías: Básica , Intermedia y Avanzada .
- Agregue su nombre de usuario solo si ha agregado algún contenido principal relevante . ( NO elimine ningún nombre de usuario existente )
Ver
Wiki Challenge Solution Templatepara referencia.