@kenbitanga

const work = () => { return new Promise(resolve => { setTimeout(() => resolve('doing work'), 3000); }) }; const doWork = async () => { console.log(await work()); };

const work = () => { return new Promise(resolve => { setTimeout(() => resolve('doing work'), 3000); }) }; console.log('before'); work().then(e => { console.log(e);

function twoSumObj(nums, target) { const obj = {} for (const i in nums) { let diff = target - nums[i] if (diff in obj) { return [+obj[diff], +i] } obj[nums[i]] = i } return []

package main import "fmt" type Stack struct { data []string } func (s *Stack) Push(x string) { s.data = append(s.data, x) }

package main import "fmt" func twoSum(nums []int, target int) []int { memo := map[int]int{} for i := 0; i < len(nums); i++ { num := nums[i] diff := target - num if _, ok := memo[diff]; ok {

class Solution { fun twoSum(nums: IntArray, target: Int): IntArray { val prevMap = hashMapOf<Int, Int>() for ((i, num) in nums.withIndex()) { val diff = target - num if (prevMap.containsKey(diff))

#include <iostream> #include <vector> #include <unordered_map> class Solution { public: static std::vector<int> twoSum(const std::vector<int>& nums, const int target) { std::unordered_map<int, int> map {};

#include <iostream> #include <vector> #include <unordered_map> class Solution { std::vector<int> result {}; public:

package main import "fmt" func twoSum(nums []int, targ int) []int { prevMap := make(map[int]int) for i, v := range nums { diff := targ - v // same as: if (prevMap.containsKey(diff)) {}

class Solution { fun twoSum(nums: IntArray, target: Int): IntArray { val prevMap: HashMap<Int, Int> = HashMap() for (i in nums.indices) { val num = nums[i] val diff = target - num if (prevMap.c

#include <iostream> #include <vector> #include <unordered_map> class Solution { std::vector<int> result {}; public: void twoSum(std::vector<int>& nums, int target) { std::unordered_map<int, int> map {}; result = {};

#include <iostream> using namespace std; class Date { int mo, da, yr; public: Date(int m, int d, int y) { mo = m; da = d; yr = y;

using System; using System.Collections.Generic; namespace MyCompiler { class Program { public static void Main(string[] args) { var map = new Dictionary<int, int>(); // add entry to dictionary; throw

using System; namespace MyCompiler { class Program { public static void Main(string[] args) { int[] nums = {1,2,3}; // use string.Join(separator, array) Console.WriteLine("[" + string.Joi

<?php class Solution { /** * @param Integer[] $nums * @param Integer $target * @return Integer[] */ function twoSum($nums, $target) {

#include <iostream> #include <vector> #include <unordered_map> std::vector<int> twoSum(std::vector<int>& nums, int target) { std::unordered_map<int, int> map {}; std::vector<int> output {}; for (int i = 0; i < nums.size(); i++) {

import java.util.*; import java.lang.*; import java.io.*; // The main method must be in a class named "Main". class Main { private static int[] twoSum(int[] nums, int target) { HashMap<Integer, Integer> map = new HashMap<>(); f

function twoSum(nums, target) { const prevMap = new Map(); for (let i=0; i<nums.length; i++) { let diff = target - nums[i]; if (prevMap.has(diff)) { return [prevMap.get(diff), i]; } prevMap.set(num

using System; using System.Collections.Generic; namespace MyCompiler { class Program { public static void Main(string[] args) { var sol = new Solution(); int[] nums = new int[] {1,2,3,4,5};

class Solution: def twoSum(self, nums, target): prevMap = {} # val : index for i, n in enumerate(nums): diff = target - n if diff in prevMap: return [prevMap[diff], i]