Anders Hesselbom

Microsoft Copilot vet vad ett rullande index är

2024-05-24

Jag behövde presentera data som skrivs uppifrån och ned i minnet i en lista sorterat efter ålder, där den äldsta kommer först. Men jag tänkte låta Microsoft Copilot jobbet. Här är replikskiftet:

Jag: Jag skulle vilja ha hjälp med en kod i C#. Tänk dig en array innehållande 10 element numrerade 0 till 9. Tänk dig även en pekare som pekar på ett av dessa element. Hänger du med?

Copilot: Absolut, jag hänger med! I C# kan vi inte direkt använda pekare som i C eller C++, men vi kan använda index för att referera till ett specifikt element i en array. Här är ett exempel på hur du kan skapa en array med 10 element och sedan referera till ett specifikt element:

int[] array = new int[10]; // Skapar en array med 10 element

for(int i = 0; i < array.Length; i++)
    array[i] = i; // Fyller arrayen med värden från 0 till 9

int index = 5; // "Pekare" till det sjätte elementet i arrayen (index 5)
Console.WriteLine("Elementet på position {0} är {1}", index, array[index]); // Skriver ut värdet på det sjätte elementet

I det här exemplet skapar vi en array och fyller den med värden från 0 till 9. Sedan definierar vi en variabel index som “pekare” till det sjätte elementet i arrayen (index 5). Slutligen skriver vi ut värdet på det sjätte elementet. Hoppas det hjälper!

Jag: Utmärkt. Men tänk dig nu att jag vill läsa ut ett element, relativt till indexet, så jag vill introducera en variabel till. Om någon vill läsa ut den första raden, så ska han tillhandahålla siffran 0, men den första raden är den raden som indexet pekar på. Om någon vill läsa ut den andra raden, ska han tillhandahålla siffran 1, men den andra raden är raden efter indexet, och så vidare.

Copilot: Jag förstår, du vill ha en slags “rullande” index, där indexet pekar på “första” raden, och sedan räknas alla andra rader relativt till det indexet. Här är ett exempel på hur du kan göra det i C#:

int[] array = new int[10]; // Skapar en array med 10 element

for(int i = 0; i < array.Length; i++)
    array[i] = i; // Fyller arrayen med värden från 0 till 9

int index = 5; // "Pekare" till det sjätte elementet i arrayen (index 5)
int relativeRow = 1; // Den relativa raden vi vill läsa ut
int actualIndex = (index + relativeRow) % array.Length; // Beräknar det faktiska indexet med hänsyn till arrayens längd
Console.WriteLine("Elementet på relativa rad {0} är {1}", relativeRow, array[actualIndex]); // Skriver ut värdet på den relativa raden

I det här exemplet använder vi modulusoperatorn (%) för att säkerställa att det faktiska indexet inte överstiger arrayens längd. Om det gör det, börjar det om från början av arrayen. Detta skapar en “rullande” effekt, där indexet alltid pekar på “första” raden, och alla andra rader räknas relativt till det indexet. Hoppas det hjälper!

Notera att Copilot först antog att en pekare var just en minnespekare, och påstår felaktigt att sådana inte finns i C#. Men förstår därefter att jag menade elementpekare, och anpassar sitt språkbruk till detta, samt skriver en fungerande algoritm! Koden klippte jag ut och klistrade in i HUD-loggen i Altair 8800-emulatorn jag arbetar med.

public class Log
{
    public int StartPointer { get; set; }
    public string[] LogRows { get; }

    public Log()
    {
        LogRows = new string[10];
        StartPointer = 0;
    }

    public void Clear()
    {
        for (var i = 0; i < LogRows.Length; i++)
            LogRows[i] = "";

        StartPointer = 0;
    }

    public void Write(string text)
    {
        LogRows[StartPointer] = text;
        StartPointer++;

        if (StartPointer >= LogRows.Length)
            StartPointer = 0;
    }

    public string GetStringNumber(int number)
    {
        var pointer = (StartPointer + number) % LogRows.Length;
        return LogRows[pointer];
    }
}

Avslutningsvis har jag tagit för vana att även artigt tacka intelligenta entiteter, även om deras intelligens är en produkt av skapelse istället för evolution.

Categories: C#