README.md

---
license: llama2
language:
- en
tags:
- Python
- Leetcode
- Problem Solving
- CP
---

# LeetCodeWizard: A LLM for mastering programming interviews and solving programming problems.

<p align="center">
<img src="https://raw.githubusercontent.com/Nan-Do/LeetCodeContestsDataset/main/LeetCodeWizardLogo.png" width="350"/>
</p>

**What is LeetCodeWizard?**
- LeetCodeWizard is a general large language model specifically trained solve and explain Leetcode problems

**How was the model developed?**
 - 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 problems](https://github.com/Nan-Do/LeetCodeContestsDataset)


**Model capabilities:**
- It should be able to solve most of the problems found at [Leetcode](https://leetcode.com/) and even pass the sample interviews they offer on the site. 

- It can write both the code and the explanations for the solutions.

| Model              | Checkpoint                                                                                  | Base Model |
|--------------------|---------------------------------------------------------------------------------------------|------------|
| LeetCodeWizard-13B-V1.0 | 🤗 <a href="https://huggingface.co/Nan-Do/LeetCodeWizard_13B_v1.0/tree/main" target="_blank">HF Link</a> |  WizardCoder-Python-13B-V1.0  | 
| LeetCodeWizard-7B-V1.0  | 🤗 <a href="https://huggingface.co/Nan-Do/LeetCodeWizard_7B_V1.0/tree/main" target="_blank">HF Link</a>  |  WizardCoder-Python-7B-V1.0   |

**Examples:**.  
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.


Examples
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.

### Instruction:
Solve the problem using Python.

### Input:
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.



Example 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: boxes = "001011"
Output: [11,8,5,4,3,4]



Constraints:

    n == boxes.length
    1 <= n <= 2000
    boxes[i] is either '0' or '1'.



### Response:
Of course, here is an example of a solution using Python that provides a solution to the problem.
'''python
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)]
'''
```

[<img src="https://raw.githubusercontent.com/OpenAccess-AI-Collective/axolotl/main/image/axolotl-badge-web.png" alt="Built with Axolotl" width="200" height="32"/>](https://github.com/OpenAccess-AI-Collective/axolotl)