# [JavaScript Quiz #15] All possible compositions of a number

Today’s JavaScript quiz is about finding all the possible compositions of a number. For example if we have a number 4, we would like to find all the possible compositions that sums up to 4 as follows.

```1111
112
121
13
211
22
31
4
```

.
.
.
.
.
.
.
.
.
.
.
.
.
In order to develop this utility, it is important to understand its nature. For a number n, it has the following possible compositions:
n (for a composition length of 1)
1 n-1 (for a composition length of 2)
1 1 n-2 (for a composition of length 3)

1 1 1 … 1 (for a composition of length n)

This can be handled using recursive function as follows.

```function compositions(n, temp, output) {
var i, newTemp;

if (n == 0) {
output.push(temp);
} else {
for (i = 1; i <= n; ++i) {
newTemp = temp + i;

compositions(n - i, newTemp, output);
}
}
}
```

As shown, the base is if n is equal to 0 then we add the temp string (which is initialized to `""`) to the output list, else we subtract i from n and adds i to the temp string. The following function `getAllCompositions` calls `compositions` with the initial values.

```function getAllCompositions(n) {
var out = [];

compositions(n, "", out);

return out;
}
```

Finally, we can test `getAllCompositions` as follows.

```// Test ...
var num = 4;
var out = getAllCompositions(num), i;

console.log("Compositions number for (" + num + ") = " + out.length);
for (i = 0; i < out.length; ++i) {
console.log(out[i]);
}
```

The output will be:

```Compositions number for (4) = 8

1111
112
121
13
211
22
31
4
```

If you have a better solution, feel free to put in the comments below. The current solution complexity is `n!`.

# JavaScript Quiz #7

Assume that we have the following short JavaScript code:

```<script>
var str = new String("Hello");

var result = typeof(str instanceof String);

result = typeof typeof(str instanceof String);

result = typeof typeof typeof(str instanceof String);
</script>
```

What is the output of each alert?
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
The result will be as follows boolean then string then string. Let’s understand why we have these results. In the first expression (which is a very straightforward):

```var result = typeof(str instanceof String);
```

Will executed as follows:
1. `str instanceof String` will return true.
2. `typeof (true)` will return `"boolean"`.

In the second expression:

```var result = typeof typeof(str instanceof String);
```

Why does result will be string, this is because the expression will be executed as follows:
1. `str instanceof String` will return true.
2. `typeof (true)` will return `"boolean"` as you notice here typeof(true) returns a String that contains “boolean” value. It is important to know that JavaScript typeof operator always returns String.
3. Finally, it is now clear that `typeof ("boolean")` will return `"string"`.

In the third expression:

```var result = typeof typeof typeof(str instanceof String);
```

It is much similar to the second expression, `result` will return “string” because the third expression will be executed as follows:
1. `str instanceof String` will return true.
2. `typeof (true)` will return `"boolean"`.
3. `typeof ("boolean")` will return `"string"`.
3. Finally, `typeof ("string")` will return `"string"`.

So now you can guess what is the result of ;):

```alert(typeof typeof typeof typeof typeof typeof typeof(str instanceof String));
```

# JavaScript Quiz #6

Assume that we have the following short JavaScript code:

```<script>
var result = [12 + 21]['valueOf']()['length'];

result = [12 + 21]['valueOf']['length'];
</script>
```

What is the output of each alert?
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
The result will be as follows 1 then 0. The first expression (the easy one) will be executed as follows:

```var result = [12 + 21]['valueOf']()['length'];
```

The expression can be read as `[33].valueOf().length` which means that `.length` property will print the length of the `valueOf()` call to array `[33]` which is `1`. Note that the `[33].valueOf` will return `[33]`.

The second expression is the tricky part:

```var result = [12 + 21]['valueOf']['length'];
```

The expression can be read as follows `[33].valueOf.length`. This is really completely different from the first expression because in this case the `.length` property will print the number of arguments of the `valueOf` method which is zero. This is because if the `.length` property is attached to a method then it will print the number of arguments of the method.