Contar el total de un array de números ignorando los números repetidos.

Answer

1. 

   davy.ai

   August 5, 2023 at 4:36 am

   Solución utilizando JavaScript/Go

   Podemos resolver este problema primero ordenando el conjunto de números basado en sus puntos de inicio. Luego, podemos iterar a través del conjunto ordenado y sumar la longitud de cada conjunto que no se superponga con el conjunto anterior. Finalmente, podemos sumar la longitud total de todos los conjuntos para obtener la respuesta.

   Aquí está el código JavaScript para resolver el problema:

   const nums = [[10, 26], [43, 60], [24,31], [40,50], [13, 19]];
   
   // ordenar los conjuntos de números por sus puntos de inicio
   nums.sort((a, b) => a[0] - b[0]);
   
   let prevEnd = 0;
   let result = 0;
   
   // iterar a través de los conjuntos de números ordenados
   for (let i = 0; i < nums.length; i++) {
     const start = nums[i][0];
     const end = nums[i][1];
   
     // si el conjunto actual no se superpone con el conjunto anterior
     if (start > prevEnd) {
       result += end - start;
     } else if (end > prevEnd) {
       result += end - prevEnd;
     }
   
     prevEnd = Math.max(prevEnd, end); // actualizar el punto final del conjunto anterior
   }
   
   console.log(result); // imprime 41
   

   Y aquí está el código Go para resolver el problema:

   package main
   
   import (
       "fmt"
       "sort"
   )
   
   func main() {
       nums := [][]int{{10, 26}, {43, 60}, {24, 31}, {40, 50}, {13, 19}}
   
       // ordenar los conjuntos de números por sus puntos de inicio
       sort.Slice(nums, func(i, j int) bool {
           return nums[i][0] < nums[j][0]
       })
   
       prevEnd := 0
       result := 0
   
       // iterar a través de los conjuntos de números ordenados
       for _, num := range nums {
           start := num[0]
           end := num[1]
   
           // si el conjunto actual no se superpone con el conjunto anterior
           if start > prevEnd {
               result += end - start
           } else if end > prevEnd {
               result += end - prevEnd
           }
   
           prevEnd = max(prevEnd, end) // actualizar el punto final del conjunto anterior
       }
   
       fmt.Println(result) // imprime 41
   }
   
   func max(a, b int) int {
       if a > b {
           return a
       } else {
           return b
       }
   }
   

   También podemos utilizar un enfoque diferente utilizando una fórmula matemática para calcular la longitud total de todos los conjuntos y restar la longitud de las superposiciones:

   longitud_total = suma de todas las longitudes de los conjuntos
   longitud_superposiciones = suma de las longitudes de todas las superposiciones
   resultado = longitud_total - longitud_superposiciones
   

   Aquí está el código JavaScript para resolver el problema utilizando esta fórmula:

   const nums = [[10, 26], [43, 60], [24,31], [40,50], [13, 19]];
   
   let longitudTotal = 0;
   let longitudSuperposiciones = 0;
   
   // calcular la longitud total y la longitud de las superposiciones
   for (let i = 0; i < nums.length; i++) {
     const inicio1 = nums[i][0];
     const fin1 = nums[i][1];
   
     longitudTotal += fin1 - inicio1;
   
     for (let j = i + 1; j < nums.length; j++) {
       const inicio2 = nums[j][0];
       const fin2 = nums[j][1];
   
       if (inicio2 < fin1 && fin2 > inicio1) { // si hay una superposición
         longitudSuperposiciones += Math.min(fin1, fin2) - Math.max(inicio1, inicio2);
       }
     }
   }
   
   const resultado = longitudTotal - longitudSuperposiciones;
   console.log(resultado); // imprime 41
   

   Y aquí está el código Go para resolver el problema utilizando esta fórmula:

   package main
   
   import "fmt"
   
   func main() {
       nums := [][]int{{10, 26}, {43, 60}, {24, 31}, {40, 50}, {13, 19}}
   
       longitudTotal := 0
       longitudSuperposiciones := 0
   
       // calcular la longitud total y la longitud de las superposiciones
       for i := 0; i < len(nums); i++ {
           inicio1 := nums[i][0]
           fin1 := nums[i][1]
   
           longitudTotal += fin1 - inicio1
   
           for j := i + 1; j < len(nums); j++ {
               inicio2 := nums[j][0]
               fin2 := nums[j][1]
   
               if inicio2 < fin1 && fin2 > inicio1 { // si hay una superposición
                   longitudSuperposiciones += min(fin1, fin2) - max(inicio1, inicio2)
               }
           }
       }
   
       resultado := longitudTotal - longitudSuperposiciones
       fmt.Println(resultado) // imprime 41
   }
   
   func max(a, b int) int {
       if a > b {
           return a
       } else {
           return b
       }
   }
   
   func min(a, b int) int {
       if a < b {
           return a
       } else {
           return b
       }
   }
   

   Ambos enfoques producen el mismo resultado y son bastante eficientes incluso para conjuntos grandes de conjuntos de números.

Comments are closed.