¡Hola a todos! El día de hoy les mostraré 5 ejercicios de Programación para practicar y conocer más sobre los métodos que ofrece el lenguaje Javascript. Éstos forman parte de unos retos que ofrecen plataformas como Scrimba o LeetCode. Así que por medio de este post les compartiré algunas soluciones a estos problemas de código, así descubrimos diferentes formas de resolver un problema.
Add Two Numbers - Sumar dos números
Parece sencillo y lo es, este problema consiste en crear una función que devuelva la suma de dos números. Sin embargo, también se pide que devuelva la suma de cualquier cantidades de números que le pases como parámetros.
Por ejemplo:
- sum(2,3) = 5
- sum(2,3,5,10) = 20
La primera parte sería tan fácil como escribir la siguiente función:
function addTwoNumbers(num1, num2){return num1 + num2;}
Sin embargo, ¿Qué pasaría si quisiéramos colocar tres números, cuatro o más? No vamos a colocar num3, num4, num5, etc, sería poco práctico.
Para resolver este problema utilizaremos el operador de propagación spread operator (...), que permitirá agregar indefinidamente todos los parámetros que necesitemos.
Además utilizaremos el método forEach(), que es un método que pueden utilizar todos los arreglos en Javascript. Donde a cada elemento del mismo se le aplica una función indicada. En este caso, a cada elemento en args se le irá acumulando en la variable sum (suma).
Sustituimos la función anterior con lo siguiente:
function addTwoNumbers(...args){var sum = 0;args.forEach(element => sum+=element);return sum;}
Y al ejecutar
function run(){const num1 = 1;const num2 = 2;const num3 = 3;const result = addTwoNumbers(num1, num2); //Resultado: 3console.log("Resultado: "+ result);const result2 = addTwoNumbers(num1, num2, num3); // Resultado: 6console.log("Resultado: "+ result2);}run();
Factorial
Este es un ejercicio muy común dentro de la Programación y saber implementarlo es muy beneficioso para resolver otras tareas.
El factorial de un número es la multiplicación de ese número por todos los números positivos que le preceden.
function factorial(n){var result = n;for(var i= 1; i < n; i++){console.log(n);console.log(n-i);result = result * (n-i); }return result;}
Aquí utilizamos un ciclo for y creamos la variable i, a la que se le irá sumando 1 por cada iteración, siempre que sea menor a ese número; en este caso 5. A medida de que i aumenta y se lo restamos a 5, garantizará que sean los números que le anteceden a ese número, es decir: 5 * 4 * 3 * 2 * 1 = 120
function run(){
const resultado = factorial(5);
console.log(resultado); // 120
}
run();
All Longest Strings - Todos las Cadenas más Largas
Este problema consiste es que si nos proveen un arreglo de Strings, y necesitamos una función que nos devuelva aquellos que sean los más largos. En primer lugar ¿Como definimos a los strings más largos? La solución elegida se basa en que tomemos la media o promedio, si es mayor a esta, es considerado un string largo.
Por ejemplo, si le paso este arreglo: ["abc", "aac", "ad", "aaaa", "aba", "b"], quiero que me devuelva ["aaaa"]
function allLongestStrings(array){var mean = 0;for(var i = 0; i < array.length; i++){mean += parseInt(array[i].length); }var output = array.filter((element) => element.length > mean);mean = mean / array.length; return output;}
Como se puede ver anteriormente, se utilizó un ciclo for, donde se inicialización la variable i a la que se le irá sumando 1 progresivamente. Dentro de este ciclo a la variable mean (media) se le van sumando 1 progresivamente. Dentro este ciclo a la variable mean (media) se le irán sumando las longitudes de cada palabras del arreglo. Luego calculamos el promedio.
function run(){
const array = ["aba", "aac", "ad", "aaaa", "aba", "b"];
const resultado = allLongestStrings(array);
console.log("Resultado: "+ resultado);
}
run();
Aquí estamos utilizando el método filter() que ofrecen los arreglos, que devuelve devolve otro arreglo que contenga elementos que cumplan cierta condición. Aquí lo que se pide es que cada elemento sea mayor que la media (mean) y se guardan en la variable output (salida).
var salida = array.filter((element) => element.length > mean);
Primer Dígito - First Digit
Consiste en que se nos provee una cadena de texto, un string, con varios números y letras, pero lo que se desea es una función que devuelva el primer dígito que aparezca, aunque se ubique al final del texto.
Para solucionar este problema utilizaremosn un recurso muy útil, conocido como las Expresiones Regulares. Que nos permiten manipular todo tipo de texto basándonos en patrones y reglas.
Estos son algunos de sus patrones:
- Letras: \w
- Números \d
- Espacios en blanco: \s
- Saltos de línea: \n
- Tabulaciones: \t
- Números del cero al nueve: [0-9]
- Cualquier letra de la A a la Z (mayúsculas y minúsculas): [a-zA-Z]
Las expresiones Regulares en Javascript se escriben dentro de dos barras invertidas /expresión/
- Primero dividiremos ese texto por caracteres usando el método split(), pasándole como parámetro una cadena vacía, y los guardamos en un arreglo (array).
- Se utilizará un ciclo for.
- Utilizaremos un condicional If y como condición colocaremos la expresión regular para buscar dígitos, /\d/ y su método test() que posee la siguiente estructura:
patron.test(en_donde)
En este caso nuestro patrón es /\d/ y el dónde aplicarlo es en el elemento específico del arreglo (array[i]). Con estas líneas de código, el primer número que se encuentre, lo devolverá y romperá el ciclo.
function firstDigit(str){array = str.split("");for (i in array){if(/\d/.test(array[i])){return array[i]; break;
} }return false;}
Por lo que al ejecutar el siguiente código, nos devolverá 3 como resultado, ya que es el primer dígito.
function run(){const str = "a_b_3_c_1";const resultado = firstDigit(str);console.log("First Digit: " + resultado); //First Digit: 3}run();
Sum All Primes - Sumar Todos los Números Primos
Este problema consiste en que se nos provee un número cualquiera, y se desea una función que devuelva la suma de todos los números Primos que le preceden.
Un número primo es aquel que posee sólo dos divisores conocidos, el 1 y él mismo. Los primeros números primos son 2, 3, 5, 7, etc.
El resto de ellos son números complejos, ya que poseen más divisores. Por consenso, el número 1 no se considera ni primo ni compuesto.
Existen muchas maneras de resolver este problema, pero en esta ocasión haremos uso de las ventajas que nos ofrecen las computadoras que es la iteración de una forma casi indefinida y en poco tiempo.
Este problema se resolverá utilizando dos ciclos for, uno con la variable i y uno con la variable j. Ambos comenzado cuyo valor inicial es 2 (ya que el 1 no lo consideramos como primo) la j, debe ser menor o igual a i para poder aumentar una unidad.
Si ocurre la condición de que i sea estrictamente igual a j a la variable sum (suma) se le sumará ese valor de i. La variable sum es nuestro acumulador donde se sumarán todos los números primos que consigamos.
La variable numbers es un arreglo que mediante el método push() le iremos agregando cada i (número primo). Para saber cuales eran antes de sumarlos.
Si ocurre que la división de i entre j tiene como residuo 0 (utilizando el operador de módulo %), es decir, es exacta, se rompe el ciclo.
function sumAllPrimes(num){
let numbers = [];
var sum = 0;
for(var i = 2; i < num; i++){
for(var j = 2; j<=i; j++){
if(i === j){
numbers.push(i); sum+=i;
}
if(i % j == 0){
break;
}
}
}
console.log(numbers);
return sum;
}Para explicar este ejercicio es más fácil visualizarlo con una tabla:
i j i === j i % j == 0
2 2 true true Es primo
3 2 false false —
3 3 true true Es primo
4 2 false true Es compuesto
5 2 false false —
5 3 false false —
5 4 false false —
5 5 true true Es primo
6 2 false true Es compuesto
7 2 false false —
7 3 false false —
7 4 false false —
7 5 false false —
7 7 true true Es primo
De la tabla anterior podemos sacar las siguientes conclusiones:
- Cuando las dos condiciones (i === j y i % j == 0) son verdaderas, se trata de un número primo.
- Cuando las dos condiciones son falsas se trata de un número decimal y no se toman en cuenta.
- Cuando la primera condición es falsa, pero (i % j == 0) resulta en una división exacta al dividir entre 2, se trata de un número compuesto.
Con esto obtendremos una solución bastante eficiente para obtener la suma de todos los números primos menores al número que le pasemos como parámetro en la función.
Si le colocamos como parámetros 10, los números Primos que le preceden son 2, 3, 5, 7, por lo tanto sumados dan como resultado 17.
function run(){const num = 10;const resultado = sumAllPrimes(num);console.log("Resultado: "+resultado); //Resultado: 17}run();
Éstos son ejercicios básicos, pero que resultan muy valiosos de aprender ya que te darán más conocimientos a la hora de presentar alguna entrevista de programación para entrar a alguna compañía.
¿Qué les ha parecido este post? Déjenmelo saber en los comentarios.
¡Saludos y espero verlos pronto!
0 Comentarios