# Daily Archives: January 18, 2016

## Find Celebrity

This one is from leetcode. http://www.cnblogs.com/easonliu/p/4785253.html

Suppose you are at a party with n people (labeled from 0 to n – 1) and among them, there may exist one celebrity. The definition of a celebrity is that all the other n – 1people know him/her but he/she does not know any of them.

Now you want to find out who the celebrity is or verify that there is not one. The only thing you are allowed to do is to ask questions like: “Hi, A. Do you know B?” to get information of whether A knows B. You need to find out the celebrity (or verify there is not one) by asking as few questions as possible (in the asymptotic sense).

You are given a helper function bool knows(a, b) which tells you whether A knows B. Implement a function int findCelebrity(n), your function should minimize the number of calls to knows.

Note: There will be exactly one celebrity if he/she is in the party. Return the celebrity’s label if there is a celebrity in the party. If there is no celebrity, return -1.

Solution. As is depicted in the question, celebrity doesn’t know anyone, but anyone knows the celebrity. And we have a know(A, B) function to find if A knows B. If we define that [A knows B] equals to [A > B], and [A doesn’t know B] equals to [A < B]. In this way, the problem transformed to find the lowest value in an array. In this way, we just compare n times.

## Zigzag Iterator

This question is from leetcode zigzag iterator.

Given two 1d vectors, implement an iterator to return their elements alternately.

For example, given two 1d vectors:

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

First solution I gave out only work for 2 lists. I use currItr to indicate the current work iterator.

Second solution is used by a queue or linkedlist for iterators. It works for Zigzag for k iterators. It should guarantee that each iterator in queue’s hasNext() returns true. Then it pop the next value from the tail iterator, and return the value. Add the tail iterator to head if it still hasNext() is true.

check my code on github: solution1, solution2

## Move Zero

This one is from leetcode which I think is very useful. https://leetcode.com/problems/move-zeroes/

Given an array `nums`, write a function to move all `0`‘s to the end of it while maintaining the relative order of the non-zero elements.

For example, given `nums = [0, 1, 0, 3, 12]`, after calling your function, `nums` should be `[1, 3, 12, 0, 0]`.

A straight-forward solution is similar to insertion sort, which come up O(N^2) time complexity. However, here is a O(N) solution. The solution is that we make the non-zero elements to the left half. Then we put 0 to the rest.

The code is pretty neat, only with several lines.

Check my code on github: link

## Peeking Iterator

https://leetcode.com/problems/peeking-iterator/

Given an Iterator class interface with methods: `next()` and `hasNext()`, design and implement a PeekingIterator that support the `peek()` operation — it essentially peek() at the element that will be returned by the next call to next().

Here is an example. Assume that the iterator is initialized to the beginning of the list: `[1, 2, 3]`.

Call `next()` gets you 1, the first element in the list.

Now you call `peek()` and it returns 2, the next element. Calling `next()` after that still return 2.

You call `next()` the final time and it returns 3, the last element. Calling `hasNext()` after that should return false.

Solution
The solution is that we still use normal iterator. But we define a peek variable. Before next() is called, we already got the iterator.next() in peek. When peek() function is called, we just return peek. For hasNext() function, we return true if peek is not null;

check my code on github: link