Fizz Buzz

Write a program that outputs the string representation of numbers from 1 to n.

But for multiples of three it should output “Fizz” instead of the number and for the multiples of five output “Buzz”. For numbers which are multiples of both three and five output “FizzBuzz”.

Example:

n = 15,

Return:
[
    "1",
    "2",
    "Fizz",
    "4",
    "Buzz",
    "Fizz",
    "7",
    "8",
    "Fizz",
    "Buzz",
    "11",
    "Fizz",
    "13",
    "14",
    "FizzBuzz"
]

"use strict";

/**
 * @param {number} n
 * @return {string[]}
 */
var fizzBuzz = function(n) {
  let ans = [];
  for (let i = 1; i <= n; i++) {
    let str = '';
    if (i % 3 === 0)
      str += 'Fizz';
    if (i % 5 === 0)
      str += 'Buzz';
    if (str === '')
      str += i;

    ans.push(str);
  }

  return ans;
};

Flatten Binary Tree to Linked List

Given a binary tree, flatten it to a linked list in-place.

For example, given the following tree:

    1
   / \
  2   5
 / \   \
3   4   6

The flattened tree should look like:

1
 \
  2
   \
    3
     \
      4
       \
        5
         \
          6

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {void} Do not return anything, modify root in-place instead.
 */
var flatten = function(root) {
  if (!root)
    return;

  var arr = [];

  dfs(root, arr);

  for (var i = 0, len = arr.length; i < len - 1; i++)
    arr[i].right = arr[i + 1];
};

function dfs(node) {
  var left = node.left;
  var right = node.right;

  node.left = node.right = null;

  window.arr.push(node);

  left && dfs(left);
  right && dfs(right);
}

Flatten Nested List Iterator

Given a nested list of integers, implement an iterator to flatten it.

Each element is either an integer, or a list – whose elements may also be integers or other lists.

Example 1:
Given the list [[1,1],2,[1,1]],

By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].

Example 2:

Given the list [1,[4,[6]]],

By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * function NestedInteger() {
 *
 *     Return true if this NestedInteger holds a single integer, rather than a nested list.
 *     @return {boolean}
 *     this.isInteger = function() {
 *         ...
 *     };
 *
 *     Return the single integer that this NestedInteger holds, if it holds a single integer
 *     Return null if this NestedInteger holds a nested list
 *     @return {integer}
 *     this.getInteger = function() {
 *         ...
 *     };
 *
 *     Return the nested list that this NestedInteger holds, if it holds a nested list
 *     Return null if this NestedInteger holds a single integer
 *     @return {NestedInteger[]}
 *     this.getList = function() {
 *         ...
 *     };
 * };
 */

/**
 * @constructor
 * @param {NestedInteger[]} nestedList
 */
var NestedIterator = function(nestedList) {
  this.a = nestedList;
};


/**
 * @this NestedIterator
 * @returns {boolean}
 */
NestedIterator.prototype.hasNext = function() {
  if (!this.a.length)
    return false;

  while (this.a.length) {
    if (this.a[0] instanceof NestedInteger) {
      var obj = this.a.shift();
      // if a[0] is List
      if (!obj.isInteger()) {
        var arr = obj.getList();
        if (arr.length) 
          Array.prototype.unshift.apply(this.a, arr);
      } else {
        var item = obj.getInteger();
        Array.prototype.unshift.apply(this.a, [item]);
        return true;
      }
    } else {
      return true;
    }
  }

  return false;
};


/**
 * @this NestedIterator
 * @returns {integer}
 */
NestedIterator.prototype.next = function() {
  return this.a.shift();
};