🐍 Kodeboken - Python Programmering

Dette programmet demonstrerer bruk av tilfeldigheter i Python ved hjelp av random-modulen. Det simulerer:

• Et kast med en terning (1-6)
• Trekking av et tilfeldig kort fra en kortstokk

• Bruk av random.randint for å generere tilfeldige tall
• Bruk av random.choice for å velge et tilfeldig element fra en liste

import random

def kast_terning():
    """Simulerer et kast med en terning (1-6)."""
    return random.randint(1, 6)

def trekk_kort():
    """Simulerer trekking av et tilfeldig kort fra en kortstokk."""
    farger = ['Hjerter', 'Ruter', 'Kløver', 'Spar']
    verdier = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'Knekt', 'Dame', 'Konge', 'Ess']
    farge = random.choice(farger)
    verdi = random.choice(verdier)
    return f"{verdi} av {farge}"

# Eksempel på bruk
if __name__ == "__main__":
    print("Kaster terning...")
    print(f"Du fikk: {kast_terning()}")
    
    print("\nTrekker et kort...")
    print(f"Du trakk: {trekk_kort()}")

En enkel GUI-applikasjon som simulerer et terningkast ved hjelp av tkinter. Resultatet vises i en popup-melding.

• Introduksjon til GUI-programmering med tkinter
• Bruk av knapper og meldingsbokser

import random
import tkinter as tk
from tkinter import messagebox

def roll_dice():
    result = random.randint(1, 6)
    messagebox.showinfo("Terningkast", f"Du rullet: {result}")

# Opprett hovedvinduet
root = tk.Tk()
root.title("Terning-Simulator")

# Lag en knapp for å rulle terningen
roll_button = tk.Button(root, text="Rull terningen", command=roll_dice)
roll_button.pack(pady=20)

# Lag en knapp for å avslutte programmet
exit_button = tk.Button(root, text="Avslutt", command=root.quit)
exit_button.pack(pady=10)

# Start hovedløkken
root.mainloop()

Dette programmet implementerer Caesar Cipher, en enkel krypteringsalgoritme for å kode og dekode meldinger.

• Forstå grunnleggende kryptering og dekryptering
• Bruk av løkker og strengmanipulasjon

def caesar_cipher_encode(message, shift):
    """Koder en melding ved å bruke Caesar Cipher."""
    encoded_message = ""
    for char in message:
        if char.isalpha():
            shift_base = ord('A') if char.isupper() else ord('a')
            encoded_message += chr((ord(char) - shift_base + shift) % 26 + shift_base)
        else:
            encoded_message += char
    return encoded_message

def caesar_cipher_decode(encoded_message, shift):
    """Dekoder en melding som er kodet med Caesar Cipher."""
    return caesar_cipher_encode(encoded_message, -shift)

# Eksempelbruk
if __name__ == "__main__":
    print("Velkommen til Caesar Cipher!")
    valg = input("Vil du (K)ode eller (D)ekode en melding? ").strip().upper()

    if valg in ['K', 'D']:
        melding = input("Skriv inn meldingen: ")
        forskyvning = int(input("Skriv inn forskyvningen (et tall): "))

        if valg == 'K':
            kodet_melding = caesar_cipher_encode(melding, forskyvning)
            print(f"Kodet melding: {kodet_melding}")
        elif valg == 'D':
            dekodet_melding = caesar_cipher_decode(melding, forskyvning)
            print(f"Dekodet melding: {dekodet_melding}")
    else:
        print("Ugyldig valg. Vennligst prøv igjen.")

En funksjon som roterer en 2D-tabell (matrise) 90 grader med klokken.

• Arbeid med 2D-lister
• Forstå algoritmer for matriserotasjon

def roter_tabell(tabell):
    """
    Pedagogisk algoritme for å rotere en 2D-tabell med 90 grader med klokken.
    """
    # Sjekk om tabellen er tom
    if not tabell or not tabell[0]:
        return []

    # Finn antall rader og kolonner
    antall_rader = len(tabell)
    antall_kolonner = len(tabell[0])

    # Opprett en ny tabell for den roterte versjonen
    rotert_tabell = [[0] * antall_rader for _ in range(antall_kolonner)]

    # Roter tabellen
    for i in range(antall_rader):
        for j in range(antall_kolonner):
            rotert_tabell[j][antall_rader - 1 - i] = tabell[i][j]

    return rotert_tabell

# Eksempelbruk
if __name__ == "__main__":
    tabell = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]
    rotert_tabell = roter_tabell(tabell)
    for rad in rotert_tabell:
        print(rad)

En implementasjon av Conway's Game of Life med visualisering ved hjelp av matplotlib.

• Forstå grunnleggende simuleringer og celleautomata
• Bruk av matplotlib for visualisering

import numpy as np
import matplotlib.pyplot as plt

def create_grid(size, randomize=True):
    """Opprett et rutenett av gitt størrelse."""
    if randomize:
        return np.random.choice([0, 1], size=(size, size))
    return np.zeros((size, size), dtype=int)

def count_neighbors(grid, x, y):
    """Tell levende naboer rundt en celle."""
    neighbors = [
        (-1, -1), (-1, 0), (-1, 1),
        (0, -1),         (0, 1),
        (1, -1), (1, 0), (1, 1)
    ]
    count = 0
    for dx, dy in neighbors:
        nx, ny = x + dx, y + dy
        if 0 <= nx < grid.shape[0] and 0 <= ny < grid.shape[1]:
            count += grid[nx, ny]
    return count

def step(grid):
    """Utfør ett steg i Game of Life."""
    new_grid = grid.copy()
    for x in range(grid.shape[0]):
        for y in range(grid.shape[1]):
            live_neighbors = count_neighbors(grid, x, y)
            if grid[x, y] == 1:
                if live_neighbors < 2 or live_neighbors > 3:
                    new_grid[x, y] = 0
            else:
                if live_neighbors == 3:
                    new_grid[x, y] = 1
    return new_grid

def simulate(size=20, steps=50, interval=0.2):
    """Kjør simuleringen av Game of Life."""
    grid = create_grid(size)
    plt.ion()
    fig, ax = plt.subplots()
    for _ in range(steps):
        ax.clear()
        ax.imshow(grid, cmap='binary')
        plt.title("Conway's Game of Life")
        plt.pause(interval)
        grid = step(grid)
    plt.ioff()
    plt.show()

if __name__ == "__main__":
    simulate()

En visuell implementasjon av A*-algoritmen for å finne den korteste stien i et rutenett. Programmet bruker pygame for grafisk visualisering.

• Forstå A*-algoritmen
• Bruk av pygame for grafisk visualisering

import pygame
import heapq

pygame.init()

WIDTH, HEIGHT = 800, 800
ROWS, COLS = 20, 20
CELL_SIZE = WIDTH // COLS
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)

screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pathfinding med A*")

class Node:
    def __init__(self, row, col):
        self.row = row
        self.col = col
        self.x = col * CELL_SIZE
        self.y = row * CELL_SIZE
        self.color = WHITE
        self.neighbors = []
        self.g = float('inf')
        self.h = 0
        self.f = float('inf')
        self.previous = None

    def __lt__(self, other):
        return self.f < other.f

    def draw(self):
        pygame.draw.rect(screen, self.color, (self.x, self.y, CELL_SIZE, CELL_SIZE))

    def add_neighbors(self, grid):
        if self.row > 0 and grid[self.row - 1][self.col].color != BLACK:
            self.neighbors.append(grid[self.row - 1][self.col])
        if self.row < ROWS - 1 and grid[self.row + 1][self.col].color != BLACK:
            self.neighbors.append(grid[self.row + 1][self.col])
        if self.col > 0 and grid[self.row][self.col - 1].color != BLACK:
            self.neighbors.append(grid[self.row][self.col - 1])
        if self.col < COLS - 1 and grid[self.row][self.col + 1].color != BLACK:
            self.neighbors.append(grid[self.row][self.col + 1])

def heuristic(a, b):
    return abs(a.row - b.row) + abs(a.col - b.col)

def a_star(grid, start, end):
    open_set = []
    heapq.heappush(open_set, (0, start))
    start.g = 0
    start.f = heuristic(start, end)

    while open_set:
        current = heapq.heappop(open_set)[1]

        if current == end:
            path = []
            while current.previous:
                path.append(current)
                current = current.previous
            return path

        for neighbor in current.neighbors:
            temp_g = current.g + 1
            if temp_g < neighbor.g:
                neighbor.g = temp_g
                neighbor.h = heuristic(neighbor, end)
                neighbor.f = neighbor.g + neighbor.h
                neighbor.previous = current
                heapq.heappush(open_set, (neighbor.f, neighbor))

    return None

grid = [[Node(row, col) for col in range(COLS)] for row in range(ROWS)]

running = True
start = None
end = None

while running:
    screen.fill(WHITE)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

        if pygame.mouse.get_pressed()[0]:
            pos = pygame.mouse.get_pos()
            row, col = pos[1] // CELL_SIZE, pos[0] // CELL_SIZE
            node = grid[row][col]
            if not start and node != end:
                start = node
                start.color = GREEN
            elif not end and node != start:
                end = node
                end.color = RED
            elif node != start and node != end:
                node.color = BLACK

        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE and start and end:
                for row in grid:
                    for node in row:
                        node.add_neighbors(grid)

                path = a_star(grid, start, end)
                if path:
                    for node in path:
                        node.color = BLUE

    for row in grid:
        for node in row:
            node.draw()

    for x in range(0, WIDTH, CELL_SIZE):
        pygame.draw.line(screen, BLACK, (x, 0), (x, HEIGHT))
    for y in range(0, HEIGHT, CELL_SIZE):
        pygame.draw.line(screen, BLACK, (0, y), (WIDTH, y))

    pygame.display.flip()

pygame.quit()

En implementasjon av Selection Sort-algoritmen for å sortere en liste.

• Forstå hvordan Selection Sort fungerer
• Arbeid med løkker og indekser

def selectionSort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i+1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j

        arr[i], arr[min_idx] = arr[min_idx], arr[i]

def printArray(arr):
    for i in range(len(arr)):
        print("%d" % arr[i], end=" ")
    print()

if __name__ == "__main__":
    arr = [64, 25, 12, 22, 11]
    selectionSort(arr)
    print("Sortert array")
    printArray(arr)

En enkel kalkulator som utfører grunnleggende matematiske operasjoner basert på brukerens valg.

• Bruk av if-elif-else-strukturer
• Håndtering av brukerinput

tall1 = int(input("Gi meg tall 1? "))
tall2 = int(input("Gi meg tall 2? "))
tall3 = int(input("Hva vil du regne ut? Trykk 1 for addisjon  2 for subtraksjon 3 for multiplikasjon 4 for divisjon: "))

if tall3 == 1:
    print(f"Tallet {tall1} pluss tallet {tall2} er lik {tall1 + tall2}")
elif tall3 == 2:
    print(f"Tallet {tall1} minus tallet {tall2} er lik {tall1 - tall2}")
elif tall3 == 3:
    print(f"Tallet {tall1} gange tallet {tall2} er lik {tall1 * tall2}")
elif tall3 == 4:
    if tall2 == 0:
        print("Det går ikke")
    else:
        print(f"Tallet {tall1} delt på tallet {tall2} er lik {tall1 / tall2}")
else:
    print("Jeg forstår ikke hva du mener")

En tekstbasert implementasjon av A*-algoritmen for å finne den korteste stien i et rutenett.

• Forstå A*-algoritmen uten grafisk visualisering
• Arbeid med prioritetskøer (heapq)

import heapq

class Node:
    def __init__(self, x, y, cost=0, heuristic=0, parent=None):
        self.x = x
        self.y = y
        self.cost = cost
        self.heuristic = heuristic
        self.parent = parent

    def __lt__(self, other):
        return (self.cost + self.heuristic) < (other.cost + other.heuristic)

def heuristic(a, b):
    """Beregner Manhattan-avstanden mellom to punkter."""
    return abs(a[0] - b[0]) + abs(a[1] - b[1])

def a_star(grid, start, goal):
    """Implementerer A*-algoritmen for å finne den korteste stien i et rutenett."""
    rows, cols = len(grid), len(grid[0])
    open_set = []
    heapq.heappush(open_set, Node(start[0], start[1], heuristic=heuristic(start, goal)))
    closed_set = set()

    while open_set:
        current = heapq.heappop(open_set)

        if (current.x, current.y) == goal:
            path = []
            while current:
                path.append((current.x, current.y))
                current = current.parent
            return path[::-1]

        closed_set.add((current.x, current.y))

        for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
            nx, ny = current.x + dx, current.y + dy

            if 0 <= nx < rows and 0 <= ny < cols and grid[nx][ny] == 0 and (nx, ny) not in closed_set:
                neighbor = Node(nx, ny, current.cost + 1, heuristic((nx, ny), goal), current)
                heapq.heappush(open_set, neighbor)

    return None

if __name__ == "__main__":
    grid = [
        [0, 1, 0, 0, 0],
        [0, 1, 0, 1, 0],
        [0, 0, 0, 1, 0],
        [0, 1, 1, 1, 0],
        [0, 0, 0, 0, 0]
    ]
    start = (0, 0)
    goal = (4, 4)

    path = a_star(grid, start, goal)
    if path:
        print("Funnet sti:", path)
    else:
        print("Ingen sti funnet.")

En animasjon som viser det norske flagget ved hjelp av matplotlib.

• Bruk av matplotlib for å lage animasjoner
• Arbeid med geometriske former

from matplotlib.animation import FuncAnimation
import matplotlib.pyplot as plt
import matplotlib.patches as patches

def draw_flag(ax, progress):
    ax.clear()
    ax.set_xlim(0, 22)
    ax.set_ylim(0, 16)
    ax.set_aspect('equal')
    ax.axis('off')

    ax.add_patch(patches.Rectangle((0, 0), 22, 16, color='red'))
    ax.add_patch(patches.Rectangle((6, 0), 4, 16, color='white'))
    ax.add_patch(patches.Rectangle((0, 6), 22, 4, color='white'))
    ax.add_patch(patches.Rectangle((6 + progress, 0), 2, 16, color='blue'))
    ax.add_patch(patches.Rectangle((0, 6 + progress), 22, 2, color='blue'))

def update(frame):
    progress = frame / 20
    draw_flag(ax, progress)

fig, ax = plt.subplots(figsize=(8, 6))
ani = FuncAnimation(fig, update, frames=21, interval=100, repeat=False)

plt.show()

Genererer og visualiserer Koch-snøfnugg-fraktalen ved hjelp av matplotlib.

• Forstå rekursive algoritmer
• Bruk av matplotlib for å tegne komplekse figurer

import matplotlib.pyplot as plt

def koch_snowflake(order, length):
    """Genererer koordinater for Koch-snøfnugget."""
    def koch_curve(order, p1, p2):
        if order == 0:
            return [p1, p2]
        else:
            x1, y1 = p1
            x2, y2 = p2

            dx = (x2 - x1) / 3
            dy = (y2 - y1) / 3

            pA = (x1 + dx, y1 + dy)
            pB = (x1 + 2 * dx, y1 + 2 * dy)
            pC = (x1 + dx - dy * (3**0.5) / 2, y1 + dy + dx * (3**0.5) / 2)

            return (
                koch_curve(order - 1, p1, pA)[:-1] +
                koch_curve(order - 1, pA, pC)[:-1] +
                koch_curve(order - 1, pC, pB)[:-1] +
                koch_curve(order - 1, pB, p2)
            )

    p1 = (0, 0)
    p2 = (length, 0)
    p3 = (length / 2, length * (3**0.5) / 2)

    points = (
        koch_curve(order, p1, p2)[:-1] +
        koch_curve(order, p2, p3)[:-1] +
        koch_curve(order, p3, p1)
    )
    return points

def plot_koch_snowflake(order, length):
    """Tegner Koch-snøfnugget ved hjelp av matplotlib."""
    points = koch_snowflake(order, length)
    x, y = zip(*points)

    plt.figure(figsize=(8, 8))
    plt.plot(x, y, color="blue")
    plt.axis("equal")
    plt.title(f"Koch-snøfnugg (Rekursjonsdybde: {order})")
    plt.show()

if __name__ == "__main__":
    plot_koch_snowflake(order=4, length=400)

En implementasjon av binærsøk for å finne et element i en sortert liste.

• Forstå binærsøk-algoritmen
• Effektiv søking i sorterte datastrukturer

def binary_search(sorted_list, target):
    """Utfører et binært søk på en sortert liste for å finne et mål."""
    low = 0
    high = len(sorted_list) - 1

    while low <= high:
        mid = (low + high) // 2
        guess = sorted_list[mid]

        if guess == target:
            return mid
        elif guess < target:
            low = mid + 1
        else:
            high = mid - 1

    return -1

if __name__ == "__main__":
    numbers = [1, 3, 5, 7, 9, 11, 13, 15]
    target = 7

    result = binary_search(numbers, target)
    if result != -1:
        print(f"Fant {target} på indeks {result}.")
    else:
        print(f"{target} finnes ikke i listen.")

En animasjon av grafen til funksjonen y = x² ved hjelp av manim.

• Bruk av manim for å lage matematiske animasjoner
• Visualisering av funksjoner

from manim import *

class QuadraticFunction(Scene):
    def construct(self):
        axes = Axes(
            x_range=[-3, 3, 1],
            y_range=[-1, 9, 1],
            axis_config={"include_numbers": True},
        )

        labels = axes.get_axis_labels(x_label="x", y_label="y")
        quadratic_graph = axes.plot(lambda x: x**2, color=BLUE)

        self.play(Create(axes), Write(labels))
        self.play(Create(quadratic_graph))

        self.wait(2)

if __name__ == "__main__":
    config.media_width = "75%"
    scene = QuadraticFunction()
    scene.render()
    print("Animasjonen er lagret som quadratic_function.mp4")

Genererer et magisk kvadrat for oddetallsstørrelser.

• Forstå algoritmer for å generere magiske kvadrater
• Arbeid med 2D-lister

def generateMagicSquare(n):
    if n % 2 == 0:
        raise ValueError("n må være et oddetall")

    magic_square = [[0] * n for _ in range(n)]
    i, j = 0, n // 2

    for num in range(1, n * n + 1):
        magic_square[i][j] = num
        i -= 1
        j += 1

        if num % n == 0:
            i += 2
            j -= 1
        elif j == n:
            j -= n
        elif i < 0:
            i += n

    print("Magisk kvadrat for n =", n)
    print("Summen av hver rad, kolonne eller diagonal er", n * (n * n + 1) // 2)
    for i in range(n):
        for j in range(n):
            print("%2d " % (magic_square[i][j]), end=" ")
        print()

    return magic_square

try:
    tall = int(input("Gi meg et odde-tall for å lage et magisk kvadrat: "))
    if tall % 2 == 0:
        raise ValueError("Tallet må være et oddetall!")
    magic_square = generateMagicSquare(tall)
except ValueError as e:
    print(e)

En enkel kalkulator som demonstrerer grunnleggende kontrollstrukturer som løkker og if-setninger.

• Bruk av løkker og betingelser
• Håndtering av brukerinput

def kalkulator():
    print("Velkommen til kalkulatoren!")
    print("Velg en operasjon:")
    print("1. Addisjon")
    print("2. Subtraksjon")
    print("3. Multiplikasjon")
    print("4. Divisjon")
    print("5. Avslutt")

    while True:
        try:
            valg = int(input("Skriv inn ditt valg (1-5): "))
            if valg == 5:
                print("Avslutter kalkulatoren. Ha en fin dag!")
                break

            if valg < 1 or valg > 5:
                print("Ugyldig valg. Prøv igjen.")
                continue

            tall1 = float(input("Skriv inn det første tallet: "))
            tall2 = float(input("Skriv inn det andre tallet: "))

            if valg == 1:
                print(f"Resultat: {tall1} + {tall2} = {tall1 + tall2}")
            elif valg == 2:
                print(f"Resultat: {tall1} - {tall2} = {tall1 - tall2}")
            elif valg == 3:
                print(f"Resultat: {tall1} * {tall2} = {tall1 * tall2}")
            elif valg == 4:
                if tall2 == 0:
                    print("Feil: Kan ikke dele på null.")
                else:
                    print(f"Resultat: {tall1} / {tall2} = {tall1 / tall2}")
        except ValueError:
            print("Ugyldig input. Vennligst skriv inn et tall.")

kalkulator()

En rekursiv implementasjon av Fibonacci-sekvensen. Funksjon som kaller opp seg selv.

• Forstå rekursjon
• Arbeid med matematiske sekvenser

def fibonacci(n):
    """
    Beregner Fibonacci-tall ved hjelp av rekursjon.
    
    Args:
        n (int): Indeksen til Fibonacci-tallet som skal beregnes.
        
    Returns:
        int: Fibonacci-tallet på indeks n.
    """
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

if __name__ == "__main__":
    print("Fibonacci-sekvens:")
    try:
        n = int(input("Skriv inn et tall for å beregne Fibonacci-sekvensen: "))
        if n < 0:
            print("Vennligst skriv inn et ikke-negativt tall.")
        else:
            print(f"F({n}) = {fibonacci(n)}")
    except ValueError:
        print("Vennligst skriv inn et gyldig heltall.")

Tegner Koch-snøfnugg-fraktalen ved hjelp av turtle.

• Bruk av rekursjon for å tegne fraktaler
• Introduksjon til turtle-modulen

import turtle

def draw_fractal_line(t, length, depth):
    """Tegner en rekursiv linje som en del av Koch-snøfnugg-fraktalen."""
    if depth == 0:
        t.forward(length)
    else:
        length /= 3.0
        draw_fractal_line(t, length, depth - 1)
        t.left(60)
        draw_fractal_line(t, length, depth - 1)
        t.right(120)
        draw_fractal_line(t, length, depth - 1)
        t.left(60)
        draw_fractal_line(t, length, depth - 1)

def draw_koch_snowflake(t, length, depth):
    """Tegner et Koch-snøfnugg ved å kombinere tre fraktallinjer."""
    for _ in range(3):
        draw_fractal_line(t, length, depth)
        t.right(120)

def main():
    """Hovedfunksjonen som setter opp skjermen og tegner Koch-snøfnugget."""
    screen = turtle.Screen()
    screen.setup(width=800, height=800)
    screen.title("Turtle Fractals - Koch Snowflake")

    t = turtle.Turtle()
    t.speed(0)
    t.penup()
    t.goto(-200, 100)
    t.pendown()

    draw_koch_snowflake(t, 400, 4)

    t.hideturtle()
    screen.mainloop()

if __name__ == "__main__":
    main()

En implementasjon av Conway's Game of Life med animasjon ved hjelp av matplotlib.

• Forstå celleautomata og Conway's Game of Life
• Bruk av matplotlib.animation for å lage animasjoner

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

def create_grid(size, random_seed):
    """Oppretter et rutenett (grid) med tilfeldige verdier (0 eller 1)."""
    np.random.seed(random_seed)
    return np.random.randint(2, size=(size, size))

def count_neighbors(grid, x, y):
    """Teller antall levende naboer (1) rundt en celle i rutenettet."""
    neighbors = [
        (-1, -1), (-1, 0), (-1, 1),
        (0, -1),         (0, 1),
        (1, -1), (1, 0), (1, 1)
    ]
    count = 0
    for dx, dy in neighbors:
        nx, ny = x + dx, y + dy
        if 0 <= nx < grid.shape[0] and 0 <= ny < grid.shape[1]:
            count += grid[nx, ny]
    return count

def next_generation(grid):
    """Beregner neste generasjon av rutenettet basert på Conway's Game of Life-regler."""
    new_grid = grid.copy()
    for x in range(grid.shape[0]):
        for y in range(grid.shape[1]):
            neighbors = count_neighbors(grid, x, y)
            if grid[x, y] == 1:
                if neighbors < 2 or neighbors > 3:
                    new_grid[x, y] = 0
            elif neighbors == 3:
                new_grid[x, y] = 1
    return new_grid

def update(frame, img, grid, history):
    """Oppdaterer rutenettet for hver generasjon og oppdaterer bildet."""
    new_grid = next_generation(grid[0])
    new_state = tuple(map(tuple, new_grid))
    if new_state in history:
        print("Syklus oppdaget. Simuleringen stopper.")
        plt.close()
        return img,
    history.add(new_state)
    img.set_data(new_grid)
    grid[0] = new_grid
    return img,

def run_game(size, random_seed, generations, interval):
    """Starter Conway's Game of Life med matplotlib-animasjon."""
    grid = create_grid(size, random_seed)
    fig, ax = plt.subplots()
    img = ax.imshow(grid, cmap="binary", interpolation="nearest")
    ax.axis("off")

    history = set()
    history.add(tuple(map(tuple, grid)))

    ani = animation.FuncAnimation(
        fig, update, fargs=(img, [grid], history), frames=generations, interval=interval, blit=True
    )
    plt.show()

# Parametere for spillet
size = 20
random_seed = 42
generations = 100
interval = 200

# Start spillet
run_game(size, random_seed, generations, interval)

Kode med logisk feil som kan brukes til å lære kodesporing. Finn feilen som gjør at resultatet ikke blir riktig.

• Bruk av IDE (programmeringsprogrammet) og kodesporing til å finne feil
• Forstå logiske feil i kode

# Denne koden har en logisk feil som kan brukes til å lære kodesporing
def finn_største_tall(tall_liste):
    største = 0  # Logisk feil: Hva om listen inneholder negative tall?
    for tall in tall_liste:
        if tall > største:
            største = tall
    return største

# Eksempelbruk
tall = [-5, -2, -8, -1]
print("Det største tallet er:", finn_største_tall(tall))

# Hva er feilen her? Prøv å finne den og rett den!