Two Sums

                
Dos Sumas  (Java, Python, PHP, C++, Javascript).

Introducción
En este artículo, aprenderás cómo realizar el ejercicio más famoso de la plataforma de LeetCode.

En este artículo, cubriremos los siguientes temas:

✅ Una explicación del problema
✅ Una solución eficiente
✅ Implementaciones en Java, Python, PHP, C++ y JavaScript

Este ejercicio se encuentra en la plataforma de LeetCode como "Two Sums".

                       

Problema

Dado un array de números enteros y un objetivo entero, devuelva índices de los dos números de manera que sumen el objetivo.

Se asume que cada ejercicio tendría exactamente una solución y no se puede utilizar el mismo elemento dos veces.

Puede devolver la respuesta en cualquier orden.


Pasos para realizar el algoritmo:
1.- Se crea un array dinámico o hashmap para almacenar los índices de los dos números que se van a sumar. Este array se llama respuesta.

2.- Se recorre el array nums y se calcula el complemento del número evaluado. 
El complemento de un número es la diferencia entre el objetivo y el número evaluado.

3.-  Se verifica si el complemento calculado ya está presente en el array respuesta como clave.

3.1.- Si no está, se agrega en el array respuesta la posición actual como valor, y como índice el número evaluado.

3.2.- Si ya está, se devuelve un arreglo con el índice del número actual y el valor de la clave del complemento.	

Presentación

Código en Java

class Solution {
      public int[] twoSum(int[] nums, int target) {
 
        // Paso #1
        Map<Integer, Integer> respuesta = new HashMap<>();
 
        // Paso #2
        for (int i = 0; i < nums.length; i++) {
            int complemento = target - nums[i];
 
            //paso#3
            if (respuesta.containsKey(complemento)) 
                return new int[]{i, respuesta.get(complemento)};
            else 
                respuesta.put(nums[i], i);
        }
        return null;
    }
}

Código en php

class Solution {
 
    public function twoSum($nums, $target) {
 
        // Paso #1
        $respuesta = [];
 
        // Paso #2
        foreach ($nums as $i => $num) {
 
            $complemento = $target - $num;
 
            // Paso #3
            if (isset($respuesta[$complemento])) return [$i, $respuesta[$complemento]];
            else $respuesta[$num] = $i;
        }
    }
}

Código en Python

class Solution(object):
    def twoSum(self, nums, target):
 
        # Paso #1
        respuesta = {}
 
        # Paso #2
        for i, num in enumerate(nums):
            complemento = target - num
 
            # Paso #3
            if complemento in respuesta:
                return [i, respuesta[complemento]]
            respuesta[num] = i

Código en C++

class Solution {
public:
  std::vector<int> twoSum(const std::vector<int>& nums, int target) {
    // Paso #1
    std::unordered_map<int, int> respuesta;
 
    // Paso #2
    for (int i = 0; i < nums.size(); i++) {
      // Paso #3
      int complemento = target - nums[i];
      if (respuesta.count(complemento)) {
        return {i, respuesta[complemento]};
      } else {
        respuesta[nums[i]] = i;
      }
    }
    return {};
  }
};

Código en JavaScript

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
       // Paso #1
    const respuesta = new Map();
 
    // Paso #2
    for (let i = 0; i < nums.length; i++) {
      // Paso #3
      const complemento = target - nums[i];
      if (respuesta.has(complemento)) {
        return [i, respuesta.get(complemento)];
      } else {
        respuesta.set(nums[i], i);
      }
    }
    return null;
};

        
    
Conclusión
En este artículo, hemos aprendido a resolver el ejercicio Two Sums, uno de los ejercicios más famosos de la plataforma LeetCode. Este ejercicio es un buen punto de partida para aprender a resolver problemas de programación, ya que es relativamente sencillo pero requiere un pensamiento lógico y creativo.