Fouten oplossen en uw code verbeteren

Voltooid

Ontwikkelaars kunnen soms code schrijven die voornamelijk werkt, maar kunnen worden verbeterd door fouten, syntaxis, prestaties of modulariteit op te lossen. Azure OpenAI-modellen kunnen helpen bij het identificeren van manieren om betere code te verbeteren en suggesties te geven.

Fouten in uw code oplossen

Azure OpenAI-modellen kunnen helpen bij het oplossen van fouten in code door de code te analyseren en wijzigingen voor te stellen die het probleem mogelijk kunnen oplossen. Dit kan ontwikkelaars helpen fouten sneller en efficiënter te identificeren en op te lossen.

Stel dat u de volgende functie hebt die niet voor u werkt.

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;
}

Geef deze functie op voor het model, samen met de prompt Fix the bugs in this function, en u krijgt een antwoord met de vaste code en een uitleg van wat er is opgelost.

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.

De prestaties verbeteren

Hoewel codeontwikkelaars mogelijk werken, is er mogelijk een efficiëntere manier om de taak uit te voeren. Hier volgt een voorbeeld van een functie waarmee de som van de eerste n positieve gehele getallen wordt berekend, mogelijk niet efficiënt:

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;  
}  

Deze versie werkt correct, maar de tijdcomplexiteit is O(n). Wanneer dit is opgegeven aan het model, is dit het antwoord:

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;  
}  

Deze versie retourneert nog steeds het juiste resultaat, maar de tijdcomplexiteit is nu O(1), waardoor het veel efficiënter wordt.

Inefficiënte code herstructureren

Betere code is minder gevoelig voor bugs en is eenvoudiger te onderhouden en de Azure OpenAI-modellen kunnen ontwikkelaars helpen bij het herstructureren van hun code.

Houd rekening met de volgende functie.

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;
    }
}

Met deze code wordt de totale prijs van een bepaald item berekend op basis van de naam en hoeveelheid. De code is echter niet modulair en kan moeilijk te onderhouden zijn. Wanneer het aan het model is verstrekt met de aanvraag om het te herstructureren, is dit het antwoord:

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;  
}  

Samen met de code biedt het model een uitleg van de herstructurering.

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.