Update README.md

Updated README.md with some examples generated by the model.

README.md

@@ -9,6 +9,89 @@ tags:
 - CP
 ---
 
+This model is a fine-tuned version of the [WizardCoder-Python-7B](https://huggingface.co/WizardLM/WizardCoder-Python-7B-V1.0) with a dataset of [Leetcode](https://leetcode.com/) problems. 
+It should be able to solve most of the problems at Leetcode and even pass the sample interviews they offer on the site. 
+
+It can write both code and explanations for the solutions. 
+
+This is the result of one of the Google's phone interviews.   
+Question 1:
+```
+Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
+
+### Instruction:
+Solve the problem using Python 3 and explain your solution.
+
+### Input:
+Given an array of integers arr, return true if the number of occurrences of each value in the array is unique or false otherwise.
+
+
+
+Example 1:
+
+Input: arr = [1,2,2,1,1,3]
+Output: true
+Explanation: The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences.
+
+Example 2:
+
+Input: arr = [1,2]
+Output: false
+
+Example 3:
+
+Input: arr = [-3,0,1,-3,1,1,1,-3,10,0]
+Output: true
+
+
+
+Constraints:
+
+    1 <= arr.length <= 1000
+    -1000 <= arr[i] <= 1000
+
+### Response:
+Sure, here you have an explanation for the problem.
+## Solution Article
+---
+#### Approach 1: Counting Sort
+
+**Intuition**
+
+If we knew the frequency of every element in `arr`, then we could check that they are all unique by checking that there was only one occurrence of each frequency.  However, this would be very expensive to do manually.
+
+Fortunately, we don't need to count the elements themselves; we just need to know how many times each *frequency* occurred.
+
+So let's count the frequencies.  We can use a simple linear scan for this.  After, we should check that there was only one occurrence of each frequency.
+
+**Algorithm**
+
+First, perform a linear scan to count the frequencies of each element.  Our result will be an array where `count[k]` is the number of occurrences of the $$k$$-th element.
+
+Afterwards, we should check that there was only one occurrence of each frequency.  If any two entries in `count` have the same value (representing the same frequency), then our answer is `False`.  Otherwise, our answer is `True`.
+
+
+
+'''python
+class Solution(object):
+    def uniqueOccurrences(self, A):
+        count = collections.Counter(A)
+        seen = set()
+        for k, v in count.iteritems():
+            if v in seen: return False
+            seen.add(v)
+        return True
+'''
+
+
+**Complexity Analysis**
+
+* Time Complexity:  $$O(N)$$, where $$N$$ is the length of `A`.
+
+* Space Complexity:  $$O(N)$$ in additional space complexity, to store the `count`.
+```
+
+Question 2:
 ```
 Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
 
@@ -16,58 +99,54 @@ Below is an instruction that describes a task, paired with an input that provide
 Solve the problem using Python.
 
 ### Input:
-Consider a matrix M with dimensions width * height, such that every cell has value 0 or 1, and any square sub-matrix of M of size sideLength * sideLength has at most maxOnes ones.
+You have n boxes. You are given a binary string boxes of length n, where boxes[i] is '0' if the ith box is empty, and '1' if it contains one ball.
+
+In one operation, you can move one ball from a box to an adjacent box. Box i is adjacent to box j if abs(i - j) == 1. Note that after doing so, there may be more than one ball in some boxes.
+
+Return an array answer of size n, where answer[i] is the minimum number of operations needed to move all the balls to the ith box.
+
+Each answer[i] is calculated considering the initial state of the boxes.
 
-Return the maximum possible number of ones that the matrix M can have.
 
- 
 
 Example 1:
 
-Input: width = 3, height = 3, sideLength = 2, maxOnes = 1
-Output: 4
-Explanation:
-In a 3*3 matrix, no 2*2 sub-matrix can have more than 1 one.
-The best solution that has 4 ones is:
-[1,0,1]
-[0,0,0]
-[1,0,1]
+Input: boxes = "110"
+Output: [1,1,3]
+Explanation: The answer for each box is as follows:
+1) First box: you will have to move one ball from the second box to the first box in one operation.
+2) Second box: you will have to move one ball from the first box to the second box in one operation.
+3) Third box: you will have to move one ball from the first box to the third box in two operations, and move one ball from the second box to the third box in one operation.
 
 Example 2:
 
-Input: width = 3, height = 3, sideLength = 2, maxOnes = 2
-Output: 6
-Explanation:
-[1,0,1]
-[1,0,1]
-[1,0,1]
+Input: boxes = "001011"
+Output: [11,8,5,4,3,4]
+
 
- 
 
 Constraints:
 
-    1 <= width, height <= 100
-    1 <= sideLength <= width, height
-    0 <= maxOnes <= sideLength * sideLength
+    n == boxes.length
+    1 <= n <= 2000
+    boxes[i] is either '0' or '1'.
 
 
 
 ### Response:
-Sure, here you have a possible implementation to solve the problem.
-
+Of course, here is an example of a solution using Python that provides a solution to the problem.
 '''python
-class Solution:
-    def maximumNumberOfOnes(self, C, R, K, maxOnes):
-        # every K*K square has at most maxOnes ones
-        count = [0] * (K*K)
-        for r in range(R):
-            for c in range(C):
-                code = (r%K) * K + c%K
-                count[code] += 1
-        count.sort()
-        ans = 0
-        for _ in range(maxOnes):
-            ans += count.pop()
-        return ans
+class Solution(object):
+    def minOperations(self, s):
+        """
+        :type boxes: str
+        :rtype: List[int]
+        """
+        n = len(s)
+        pos = []
+        for i, c in enumerate(s):
+            if c == '1':
+                pos.append(i)
+        return [sum(abs(j-i) for j in pos) for i in xrange(n)]
 '''
 ```