代码自动生成

import requests

# DeepSeek API的URL地址（本地Ollama服务器地址）
OLLAMA_URL = "http://localhost:11434/api/generate"


def complete_code(code_snippet, language="Python"):
    """
    使用DeepSeek AI来提供代码补全和建议。
    """
    # 构建提示词，要求AI完成代码片段
    prompt = f"Complete the following {language} code snippet:\n\n{code_snippet}\n\n" \
             "Provide a clean, efficient, and correct implementation."

    # 设置API请求参数
    payload = {
        "model": "deepseek-r1",  # 使用deepseek-r1模型
        "prompt": prompt,         # 提示词内容
        "stream": False          # 不使用流式输出
    }

    # 发送POST请求到Ollama API
    response = requests.post(OLLAMA_URL, json=payload)

    # 处理API响应
    if response.status_code == 200:
        return response.json().get("response", "No code suggestion available.")  # 返回AI生成的代码建议
    else:
        return f"Error: {response.text}"  # 返回错误信息
    

# 测试代码自动补全功能
if __name__ == "__main__":
    test_code = "def bubble_sort(n):"  # 测试用的代码片段
    print("### AI-Suggested Code ###")
    print(complete_code(test_code))

### AI-Suggested Code ###
<think>
Okay, I need to implement the bubble sort algorithm in Python for an array of size n. Let me think about how bubble sort works.

Bubble sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they're in the wrong order. It does this pass until no more swaps are needed, which means the list is sorted.

So, first, I'll create a function called bubble_sort that takes n as an argument. Wait, but wait—n usually refers to the number of elements. So maybe the function should actually take a list and its length instead? Or does the user expect us to initialize a list of size n with default values?

Looking at the initial code snippet: def bubble_sort(n): ... So perhaps it's intended that we sort a list of numbers from 0 to n-1, creating a list like [0, 1, 2, ..., n-1], but maybe in random order. Or wait, perhaps the function should take an array as input and return it sorted.

Wait, looking back at the user's question: "Provide a clean, efficient, and correct implementation." The initial code is just def bubble_sort(n): So probably, the function needs to accept a list and sort it in place or return it. But since n is given as an argument, maybe the intended use is that it sorts a list of size n.

Wait, but the standard bubble sort takes a list as input. Hmm, perhaps the user made a mistake, but for now, I'll assume that the function should take a list and perform bubble sort on it.

So, to start, inside the function, we need to create an array. Wait no—if the function is supposed to sort a given array, then n would be its length. So maybe the correct approach is to first check if the input is a list or not, but perhaps for simplicity, assume that the function receives a list of size n.

But looking at the initial code, it's just def bubble_sort(n):, which doesn't take any parameters except n. That suggests that perhaps we're supposed to sort a list with elements from 0 to n-1 in random order. So maybe inside the function, create such a list and then apply bubble sort.

Wait, but if someone calls bubble_sort(5), it would generate [4,3,2,1,0] or similar, and then sort it into [0,1,2,3,4].

Alternatively, perhaps the function is supposed to take an array as its parameter. But given that n is passed, maybe we can proceed by creating a list of size n with numbers from 0 to n-1 in random order.

Wait, but I'm not sure. The user's code starts with def bubble_sort(n): ... So perhaps the function should sort a default array of size n, like [i for i in range(n)], and then perform bubble sort on it.

So first step: inside the function, create an unsorted list of numbers from 0 to n-1. But wait, maybe that's not necessary if the user expects the function to handle any input list. Hmm, perhaps I should assume that n is the length of the array we need to sort.

Wait no—n could be a number like 5, and the function would generate [4,3,2,1,0] or another random permutation.

But maybe it's better for the function to take an array as input. Alternatively, perhaps the initial code is incomplete, and the actual implementation should accept the list as an argument. But since the user provided def bubble_sort(n):, I have to work with that.

Alternatively, perhaps n represents the number of elements in the list, so the function will generate a random list of size n, sort it using bubble sort, and then return it or do something else.

Wait, but I'm getting confused. Let's think differently: the standard bubble sort algorithm can be implemented by looping through the array multiple times until no swaps are needed.

So here's how bubble sort works step by step:

1. Compare adjacent elements.
2. If they're in the wrong order (i.e., the first is larger than the second), swap them.
3. Repeat this process from the start of the list each time, but with one less element at the end each pass because the last element is already in its correct position after each pass.

So for a list of size n, I can implement bubble sort as follows:

- For i from 0 to n-1:
    - For j from 0 to (n-i-1):
        - Compare elements at positions j and j+1.
        - If element[j] > element[j+1], swap them.

But wait, in the initial code, it's just def bubble_sort(n): So perhaps I need to create an array of size n with numbers from 0 to n-1, then apply this algorithm on that array.

So step by step:

First, generate a list. Maybe using list(range(n)) gives [0,1,2,...n-1]. Then shuffle it? Or do we leave it in place and sort it via bubble sort?

Wait, the function is supposed to perform the sorting. So perhaps create an unsorted version of the array.

So inside the function:

Create a list: arr = list(range(n)) but then shuffle it or not—it doesn't matter because the function will sort it.

Then implement the bubble sort algorithm on this list.

But wait, in Python, functions can return None unless specified. So perhaps after sorting, we should return the sorted array.

So putting it all together:

def bubble_sort(n):
    arr = list(range(n))  # creates [0,1,2,...n-1]
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

Wait, but that's the standard approach. But is this efficient?

Yes, bubble sort has a time complexity of O(n^2), which isn't the most efficient for large datasets, but it's simple and works correctly.

But wait, in the code I just wrote, when n=0 or 1, does it handle that? For example, if n=0, list(range(0)) is empty, so returns an empty list. Which is correct.

Testing this with a small n:

n = 5
arr starts as [0,1,2,3,4]
After first pass: no swaps because already sorted.
Wait no—no, wait in the code above, for i from 0 to n-1 (i=0 to 4), but j runs up to n-i-1.

Wait when i=0, j goes up to 5 - 0 -1 =4. So it's comparing all adjacent pairs and swapping if necessary. But in the initial list [0,1,2,3,4], no swaps are needed. So for each subsequent pass (i increases), the inner loop runs one less time.

So the code should correctly sort any array passed to it.

But wait, is this generating a shuffled array then sorting? Because initially, arr is created as 0,1,..n-1 and then shuffled?

Wait no—no shuffling. So if someone calls bubble_sort(5), it returns [0,1,2,3,4], which is already sorted.

But perhaps the intention was to create a random permutation of numbers from 0 to n-1, sort them with bubble sort, and return the sorted array. But in that case, the initial arr should be shuffled before sorting.

Wait, but then what's the point? Sorting it back to order. Maybe the function is just supposed to perform bubble sort on a list given as input. So perhaps the code I wrote earlier isn't correct because it assumes a specific starting list.

So let me think again: if the function is intended to accept an array of size n, but in this case, the initial code only takes n as an argument. Hmm.

Wait, maybe I should adjust my approach. Perhaps the function should take a list and its length as n, or perhaps it's better to have the function take both, but given that the user provided def bubble_sort(n):, perhaps we can assume that the array is of size n, and we create a shuffled version.

But then again, when someone calls bubble_sort(5), they might expect it to sort a list like [4,3,2,1,0] into [0,1,2,3,4]. But without shuffling, in this case, the initial array is already sorted. So maybe that's not useful.

Alternatively, perhaps n represents the length of an arbitrary list passed to the function. But then the current code only accepts one argument, which complicates things.

Wait, perhaps I need to adjust my approach: maybe create a sample list based on n and then perform bubble sort.

So here's what I can do:

- Create a list with numbers from 0 to n-1 in random order.
- Perform bubble sort on it.
- Return the sorted list.

But how? Let me write that code.

Wait, but the function is called 'bubble_sort' which suggests it returns None or something else. So perhaps modifying my previous approach:

import random

def bubble_sort(n):
    arr = list(range(n))
    # Shuffle the array
    random.shuffle(arr)
    for i in range(n):
        for j in range(0, n - i -1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

But this adds the import statement. If I don't include that, it would throw an error.

Wait, but perhaps the function doesn't need to shuffle—it just needs to sort any given list of length n. But then how is 'n' used?

Alternatively, maybe the function should take a list as the first argument and n is the length or something else—wait no.

But given that in the initial code only 'n' is passed, perhaps I can proceed with creating an unsorted array based on n.

Wait, but if someone calls bubble_sort(5), they get [0,1,2,3,4], which isn't useful. So maybe shuffling it first would make more sense.

But in the initial code without shuffle, it just returns a sorted list.

Alternatively, perhaps I should proceed with writing the function as follows:

def bubble_sort(n):
    arr = list(range(n))
    for i in range(len(arr)):
        for j in range(0, len(arr)-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

Which is the same as my initial code without shuffle.

But wait, maybe that's not necessary. Perhaps it just sorts any list of size n passed in. But given that 'n' is the only argument, we can't get an array from outside.

Alternatively, perhaps the function should take a single parameter which is the unsorted list. So for example:

def bubble_sort(arr):
    # perform bubble sort on arr and return it

But the user provided def bubble_sort(n): so I have to stick with that.

So given all this, my initial code seems correct: create an array from 0 to n-1, then shuffle it (if needed), then apply bubble sort. But since the function is called 'bubble_sort', perhaps shuffling isn't necessary because someone might pass a pre-shuffled list.

Wait no—perhaps in any case, for testing purposes, I should include the shuffle step so that when multiple calls are made, they return different sorted arrays.

But given that the user's code didn't have it, maybe it's not required. So perhaps my initial approach is correct: create a sorted array of [0..n-1], then bubble sort it—no need to shuffle since in any case, after sorting it will be 0...n-1 again.

But wait no—if the function shuffles before sorting, the original list would have been random. So perhaps including the shuffle is better.

So putting all this together:

def bubble_sort(n):
    import random
    arr = list(range(n))
    random.shuffle(arr)
    for i in range(len(arr)):
        for j in range(0, len(arr)-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

But wait—this is including an import inside the function. It's better to import random at the top.

Alternatively:

import random

def bubble_sort(n):
    arr = list(range(n))
    random.shuffle(arr)
    for i in range(len(arr)):
        for j in range(0, len(arr)-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

But the user's code didn't include the import. So perhaps I should assume that random is already imported.

Alternatively, maybe not shuffle at all—just pass an array and sort it.

Wait, but given the initial problem statement: "Complete the following function" with a placeholder of n as the only argument.

So in conclusion, to write this correctly:

Create a list from 0 to n-1, then perform bubble sort on it, returning the sorted list.

But without shuffling. So here's my code again:

def bubble_sort(n):
    arr = list(range(n))
    for i in range(n-1):  # because each pass reduces the last element
        for j in range(n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

Wait, that's an alternative version where we loop n-1 times and each time reduce the inner loop by one.

But in my initial code I had for i in range(n): which is correct because even after sorting, it still runs to complete all passes. So perhaps either way is acceptable.

Testing this function with n=5:

Initial arr: [0,1,2,3,4]
After first pass (i=0), nothing changes.
So returns the same array.

But if someone shuffles before passing into this code, then it would sort a shuffled list.

Alternatively, perhaps in the problem statement, 'n' is passed as an argument but isn't necessarily used to create the list. Maybe I'm overcomplicating it.

Wait—perhaps the function should take a single array and return the sorted version using bubble sort. So for example:

def bubble_sort(arr):
    n = len(arr)
    for i in range(n-1):
        for j in range(n - i - 1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

But given that the user wrote def bubble_sort(n):, perhaps they meant 'n' is the size of the array to be sorted.

In any case, I think my initial code was correct: create a list from 0 to n-1, then perform bubble sort on it and return it.
</think>

To solve this problem, we need to implement a function that sorts an array using the bubble sort algorithm. Bubble sort is a simple comparison-based sorting algorithm where each pair of adjacent elements is compared and swapped if they are in the wrong order. This process repeats until the entire array is sorted.

### Approach
The approach involves creating an array from 0 to n-1, where n is the size provided as input. The bubble sort algorithm works by repeatedly stepping through the list, comparing each pair of adjacent elements, and swapping them if they are in the wrong order. This process is repeated until no swaps are needed, which means the list is sorted.

The steps for the bubble sort algorithm are:
1. Create an array from 0 to n-1.
2. Iterate through the array multiple times until the entire array is sorted.
3. In each iteration, compare each pair of adjacent elements and swap them if they are in the wrong order.
4. Repeat this process until a complete pass is made without any swaps.

### Solution Code
```python
import random

def bubble_sort(n):
    arr = list(range(n))
    random.shuffle(arr)
    for i in range(len(arr)):
        for j in range(len(arr) - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr
```

### Explanation
- **Creating the Array**: The function starts by creating an array with elements from 0 to n-1.
- **Shuffling**: To ensure randomness and demonstrate the algorithm's effectiveness, the array is shuffled before sorting. This step is optional but helps in showing that bubble sort works correctly on any initial order of data.
- **Bubble Sort Implementation**:
  - The outer loop runs for each element in the array, reducing the range by one each time because the largest elements will have bubbled to their correct positions.
  - The inner loop compares each pair of adjacent elements. If they are out of order, they are swapped.
  - This process continues until the entire array is sorted.

This approach ensures that the array is sorted efficiently using a well-known sorting algorithm, bubble sort, which is straightforward and easy to implement.

import requests
import gradio as gr

# DeepSeek API的URL地址（本地Ollama服务器地址）
OLLAMA_URL = "http://localhost:11434/api/generate"


def complete_code(code_snippet, language="Python"):
    """
    使用DeepSeek AI来提供代码补全和建议。
    """
    # 构建提示词，要求AI完成代码片段
    prompt = f"Complete the following {language} code snippet:\n\n{code_snippet}\n\n" \
             "Provide a clean, efficient, and correct implementation."

    # 设置API请求参数
    payload = {
        "model": "deepseek-r1",  # 使用deepseek-r1模型
        "prompt": prompt,         # 提示词内容
        "stream": False          # 不使用流式输出
    }

    # 发送POST请求到Ollama API
    response = requests.post(OLLAMA_URL, json=payload)

    # 处理API响应
    if response.status_code == 200:
        return response.json().get("response", "No code suggestion available.")  # 返回AI生成的代码建议
    else:
        return f"Error: {response.text}"  # 返回错误信息
    

# 创建Gradio界面
interface = gr.Interface(
    fn=complete_code,  # 指定处理函数
    inputs=[  # 定义输入组件
        gr.Textbox(lines=5, placeholder="Paste incomplete code here"),  # 多行文本框用于输入代码片段
        gr.Dropdown(["Python", "JavaScript", "Java", "C++"], label="Select Language"),  # 下拉菜单选择编程语言
    ],
    outputs=gr.Textbox(label="AI-Suggested Code"),  # 输出组件:文本框显示AI建议的代码
    title="AI-Powered Code Auto-Completer",  # 界面标题
    description="Enter an incomplete code snippet, and AI will complete it."  # 界面描述文本
)

# Launch the web app
if __name__ == "__main__":
    interface.launch()