# Coding Problems Part 1

This week I made it a focus to go through LeetCode and do practice problems to prepare for interviews. LeetCode is a great place to keep your problem-solving skills fresh and practice your coding languages of choice. I am focusing on Ruby and Javascript in the below problems. It was an interesting exercise to see the subtle differences in how to solve the same problems between the two languages.

**Two Sum**

Given an array of integers, return **indices** of the two numbers such that they add up to a specific target.

You may assume that each input would have ** exactly** one solution, and you may not use the

*same*element twice.

Given nums = [2, 7, 11, 15], target = 9,Because nums[0] + nums[1] = 2 + 7 = 9,

return [0,1].

**Ruby:**

`def two_sum(nums, target)`

hash = {}

nums.each_with_index do |num, index|

hash[num] = index

end

nums.each_with_index do |num, index|

diff = target - num

if hash.key?(diff) && hash[diff] != index

return [index, hash[diff]]

end

end

end

**Javascript:**

`var twoSum = function(nums, target) {`

let numObject = {};

for (var i = 0; i < nums.length; i++) {

let thisNum = nums[i];

numObject[thisNum] = i;

}

for (var i = 0; i < nums.length; i++) {

let diff = target - nums[i];

if (numObject.hasOwnProperty(diff) && numObject[diff] !== i) {

return [i, numObject[diff]];

}

}

};

**Analysis:**

I made a hash/object to keep track of the elements in the array and their index. I then check if the difference between the numbers exists in the numObjects hash and if it adds up to the target. I return the indices of the two that add up to the target.

**Reverse Integer**

Given a 32-bit signed integer, reverse digits of an integer.

**Example 1:**

**Input:** 123

**Output:** 321

**Example 2:**

**Input:** -123

**Output:** -321

**Example 3:**

**Input:** 120

**Output:** 21

**Note:**

Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231, 231 − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

**Ruby:**

`def reverse(x)`

limit = 2147483648

abs = 1

if x < 0

abs = -1

end

n = x.to_s.reverse!.to_i

if n > limit

return 0

else

return n * abs

end

end

**Javascript:**

`var reverse = function(x) {`

const limit = 2147483648

const k = x < 0 ? -1 : 1;

**// let n = x.toString().split("").reverse().join("")**

let n = Number(String(Math.abs(x)).split('').reverse().join(''))

if (n > limit) {

return 0

} else {

return n * k

}

};

**Analysis:**

This solution is pretty self explanatory, but the interesting thing here was that Javascript would return NaN when I tried to do the same Ruby solution where I set a variable to -1 or 1 and multiplied(it’s bold in the comments). I had to use Math.abs in order for it to return either positive or negative.

**First Unique Character in a String**

Given a string, find the first non-repeating character in it and return it’s index. If it doesn’t exist, return -1.

**Examples:**

s = "leetcode"

return 0.s = "loveleetcode",

return 2.

**Note:** You may assume the string contain only lowercase letters.

**Ruby:**

`def first_uniq_char(s)`

arr = s.split("")

arr.each_with_index do |ele, i|

if s.index(ele) == s.rindex(ele)

return i

end

end

return -1

end

**Javascript:**

`var firstUniqChar = function(s) {`

for(let i = 0; i < s.length; i++){

if (s.indexOf(s[i]) === s.lastIndexOf(s[i])){

return i;

}

}

return -1;

};

**Analysis:**

The interesting thing about this problem was learning that the index (Ruby) and indexOf (Javascript) method returns the first instance of an index and that rindex (Ruby) and lastIndexOf(Javascript) returns the last instance of an index.

**Check Palindrome**

This next one isn’t from LeetCode, but it is an interesting problem. Build a function that checks if a string is a palindrome.

**Example:**

`// bbaaa => baaab true`

// wkjqq => false

// ffeeaaf => feafaef true

**Javascript**

`function checkPalindrome(input) {`

counter = {}

for (let i = 0; i < input.length; i++) {

if (counter[input[i]]) {

counter[input[i]] += 1

} else {

counter[input[i]] = 1

}

}

let oddGuy = 0

Object.keys(counter).forEach( i => {

if (counter[i] % 2 === 1) {

oddGuy += 1

}

})

if (oddGuy > 1){

return false

} else {

return true

}

}

**Analysis:**

I made an object that was a counter for the number of times that a letter is in the input string. If there was more than one odd number of letters, then it wasn’t a palindrome.

**Conclusion**

This is a nice introduction to simple coding problems that are good building blocks for tackling more complex problems. The next part will be my attempts at more difficult problems.

Thanks for reading!