## DEV Community is a community of 866,220 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

Kevin Kim

Posted on • Updated on

# JS Solutions for CodeWars Katas

In this article I will be documenting the solutions for codewars challenge questions that I am able to solve:

1.Your task is to sum the differences between consecutive pairs in the array in descending order.

For example:

[2, 1, 10] -> 9
In descending order: [10, 2, 1]

Sum: (10 - 2) + (2 - 1) = 8 + 1 = 9

If the array is empty or the array has only one element the result should be 0 ( Nothing in Haskell ).

My solution:

``````function sumOfDifferences(arr) {
arr.sort(function(a, b){return b - a});
let diff = 0
for(let i=0;i<=arr.length - 2;i++){
diff = diff + (arr[i] - arr[i + 1])
}
return diff
}
``````

2.A square of squares
You like building blocks. You especially like building blocks that are squares. And what you even like more, is to arrange them into a square of square building blocks!

However, sometimes, you can't arrange them into a square. Instead, you end up with an ordinary rectangle! Those blasted things! If you just had a way to know, whether you're currently working in vain… Wait! That's it! You just have to check if your number of building blocks is a perfect square.

Given an integral number, determine if it's a square number:

In mathematics, a square number or perfect square is an integer that is the square of an integer; in other words, it is the product of some integer with itself.

The tests will always use some integral number, so don't worry about that in dynamic typed languages.

Examples
-1 => false
0 => true
3 => false
4 => true
25 => true
26 => false

My solution:

``````var isSquare = function(n){
if(n>-1){
if(JSON.stringify(Math.sqrt(n)).includes('.')){
return false
}
else{
return true
}
}
else{
return false
}
}
``````

Refactored solution:

``````var isSquare = n => Math.sqrt(n) % 1 === 0;
``````

3.Implement a function that adds two numbers together and returns their sum in binary. The conversion can be done before, or after the addition.

The binary number returned should be a string.

Examples:(Input1, Input2 --> Output (explanation)))

1, 1 --> "10" (1 + 1 = 2 in decimal or 10 in binary)
5, 9 --> "1110" (5 + 9 = 14 in decimal or 1110 in binary)

My solution:

``````function addBinary(a,b){
return (a+b).toString(2)
}
``````

4.Given an array of integers, find the one that appears an odd number of times.

There will always be only one integer that appears an odd number of times.

Examples
 should return 7, because it occurs 1 time (which is odd).
 should return 0, because it occurs 1 time (which is odd).
[1,1,2] should return 2, because it occurs 1 time (which is odd).
[0,1,0,1,0] should return 0, because it occurs 3 times (which is odd).
[1,2,2,3,3,3,4,3,3,3,2,2,1] should return 4, because it appears 1 time (which is odd).

My solution:

``````function findOdd(A) {
const count = {};

for (const element of A) {
if (count[element]) {
count[element] += 1;
} else {
count[element] = 1;
}
}

for (const property in count) {
if(count[property] % 2 !== 0){
return parseInt(property)
}
}
}
``````

5.Make a program that filters a list of strings and returns a list with only your friends name in it.

If a name has exactly 4 letters in it, you can be sure that it has to be a friend of yours! Otherwise, you can be sure he's not...

Ex: Input = ["Ryan", "Kieran", "Jason", "Yous"], Output = ["Ryan", "Yous"]

i.e.

friend ["Ryan", "Kieran", "Mark"] `shouldBe` ["Ryan", "Mark"]
Note: keep the original order of the names in the output.

My solution:

``````const friend = friends => friends.filter(friend => friend.length === 4)
``````