Corrigir bugs e aprimorar seu código

Concluído

Às vezes, os desenvolvedores podem escrever um código que funciona em grande parte, mas que pode ser aprimorado com a correção de bugs, sintaxe, desempenho ou modularidade. Os modelos do OpenAI do Azure podem ajudar a identificar maneiras de aprimorar e fornecer sugestões sobre como escrever um código melhor.

Corrigir bugs no código

Os modelos do OpenAI do Azure podem ajudar a corrigir bugs no código analisando o código e sugerindo alterações que podem corrigir o problema. Isso pode ajudar os desenvolvedores a identificar e resolve bugs de maneira mais rápida e eficiente.

Por exemplo, digamos que você tenha a função a seguir que não está funcionando.

def calculate_average(numbers):  
    total = 0  
    for i in range(len(numbers)):  
        number = numbers[i]  
        total += number  
    average = total  
    rerun averave  

public double CalculateAverage(int[] numbers)
{
    int total = 0;
    for (int i = 0; i < numbers.Length; i++)
    {
        int number = numbers[i];
        total += number;
    }
    double average = (double)total;
    rerun averave;
}

Forneça essa função ao modelo, acompanhado do prompt Fix the bugs in this function, e você obterá uma resposta com o código corrigido e uma explicação do que foi feito.

def calculate_average(numbers):  
    total = 0  
    for i in range(len(numbers)):  
        number = numbers[i]  
        total += number  
    average = total / len(numbers)  
    return average  

public double CalculateAverage(int[] numbers)
{
    int total = 0;
    for (int i = 0; i < numbers.Length; i++)
    {
        int number = numbers[i];
        total += number;
    }
    double average = (double)total / numbers.Length;
    return average;
}

There were a few issues with the original code:

1. The variable "average" was assigned the value of "total" instead of the actual average.
2. There was a typo in the last line - "rerun" should be "return".
3. The average was not actually calculated - the corrected code divides the total by the length of 
the "numbers" list to get the average.

Melhorar o desempenho

Embora a escrita dos desenvolvedores de código possa funcionar, pode haver uma forma mais eficiente de realizar a tarefa. Este é um exemplo de uma função que calcula a soma dos primeiros n números inteiros positivos, possivelmente ineficiente:

def sum_of_n(n):
    result = 0
    for i in range(1, n+1):
        result += i
    return result

public int SumOfN(int n)  
{  
    int result = 0;  
    for (int i = 1; i <= n; i++)  
    {  
        result += i;  
    }  
    return result;  
}  

Essa versão funciona corretamente, mas a complexidade temporal é O(n). Quando fornecida ao modelo, esta é a resposta:

We can improve this function it by using a mathematical formula instead.

Here's the more efficient version:

def sum_of_n(n):
    return n * (n + 1) // 2

public int SumOfN(int n)  
{  
    return n * (n + 1) / 2;  
}  

Essa versão ainda retorna o resultado correto, mas a complexidade temporal agora é O(1), o que a torna muito mais eficiente.

Refatorar um código ineficiente

Um código melhor é menos propenso a bugs e é mais fácil de ser mantido, e os modelos do OpenAI do Azure podem ajudar a orientar os desenvolvedores sobre como refatorar o código.

Considere a função a seguir.

def calculateTotalPrice(item, quantity):
    if item == 'apple':
        return quantity * 0.5
    elif item == 'banana':
        return quantity * 0.75
    elif item == 'orange':
        return quantity * 0.6
    else:
        return 0

public double CalculateTotalPrice(string item, int quantity)
{
    if (item == "apple")
    {
        return quantity * 0.5;
    }
    else if (item == "banana")
    {
        return quantity * 0.75;
    }
    else if (item == "orange")
    {
        return quantity * 0.6;
    }
    else
    {
        return 0;
    }
}

Esse código calcula o preço total de um item específico com base no nome e na quantidade. No entanto, o código não é modular e pode ser difícil de ser mantido. Quando fornecido ao modelo com a solicitação para refatorá-lo, esta é a resposta:

item_prices = {  
    'apple': 0.5,  
    'banana': 0.75,  
    'orange': 0.6  
}  

def calculate_total_price(item, quantity):  
    price = item_prices.get(item, 0)  
    return quantity * price  

static Dictionary<string, double> itemPrices = new Dictionary<string, double>()  
{  
    {"apple", 0.5},  
    {"banana", 0.75},  
    {"orange", 0.6}  
};  

static double CalculateTotalPrice(string item, int quantity)  
{  
    double price;  
    if (!itemPrices.TryGetValue(item, out price))  
    {  
        price = 0;  
    }  
    return quantity * price;  
}  

Acompanhado do código, o modelo fornece uma explicação da refatoração.

In this refactored code, we've created an object called itemPrices that maps item names to their 
prices. We've also simplified the calculateTotalPrice function by using the itemPrices object to look 
up the price of the item, rather than using a series of if/else statements. This makes the code more 
modular and easier to maintain, and also reduces the risk of introducing bugs in the future.