Løsningsforslag 7

def random_series(a):
    n = len(a)
    series_sum = 0
    for i in range(n):
        series_sum += a[i] / (i + 1)
    return series_sum

def sum_of_column(a, col):
    total = 0
    for row in a:
        total += row[col]
    return total

# eller, med list comprehension
def sum_of_column(a, col):
    return sum([ row[col] for row in a ])

def median(a):
    sorted_a = sorted(a)
    n = len(a)
    # finner indeks i midten
    mid = n // 2
    if n % 2 == 0:
        return (sorted_a[mid - 1] + sorted_a[mid]) / 2
    else:
        return sorted_a[mid]

def smallest_absolute_difference(a, b):
    min_diff = abs(a[0] - b[0])
    for num_a in a:
        for num_b in b:
            diff = abs(num_a - num_b)
            if diff < min_diff:
                min_diff = diff
    return min_diff

# eller, med list comprehension
def smallest_absolute_difference(a, b):
    return min([ abs(num_a - num_b) for num_a in a for num_b in b ])

# Oppgave A
def compress(seq):
    output = []
    count = 1
    
    if seq[0] == "1":
        output.append("0")

    for i in range(len(seq) - 1):
        if seq[i] == seq[i + 1]:
            count += 1
        else:
            output.append(str(count))
            count = 1

    output.append(str(count))
    return ' '.join(output)

# eller, uten range(len())

def compress(seq):
    output = []
    previous = seq[0]
    
    if previous == "1":
        output.append("0")

    count = 1
    for bit in seq[1:]:
        if bit == previous:
            count += 1
        else:
            output.append(str(count))
            count = 1
        previous = bit

    output.append(str(count))
    return ' '.join(output)


# Oppgave B
def decompress(seq):
    output = []
    bit = 0
    for num in seq.split(" "):
        bits = str(bit) * int(num)
        output.append(bits)
        bit = int(not bit)     # bytter ut 0 med 1 eller 1 med 0
        # bit = (bit + 1) % 2  # bytter ut 0 med 1 eller 1 med 0
        # bit = (0 if bit == 1 else 1) # bytter ut 0 med 1 eller 1 med 0
    return ''.join(output)

#Skrevet av Viljar Gjerde H22

def find_words_in_character_grid(char_grid, words):
    found_words = []
    for word in words:
        if find_word_in_grid(char_grid,word):
            found_words.append(word)
    return found_words


def find_word_in_grid(grid,word):
    for row in grid:
        if find_word_in_lst(row,word):
            return True
    cols = get_columns(grid)
    for col in cols:
        if find_word_in_lst(col,word):
            return True
    return False


def find_word_in_lst(char_lst,word):
    return word in "".join(char_lst)


def get_columns(grid):
    cols= []
    for i in range(len(grid[0])):
        col = [row[i] for row in grid]
        cols.append(col)
    return cols

# Unngå å gjøre .join hver gang i løkken
# ved å lage strengene bare en gang

def find_words_in_character_grid(char_grid, words):
    rows = get_rows(char_grid)
    cols = get_cols(char_grid)

    found_words = []
    for word in words:
        for line in rows + cols:
            if word in line:
                found_words.append(word)
                # trenger ikke se på de andre linjene etter vi finner ordet
                break

    return found_words


def get_rows(grid):
    return [ "".join(row) for row in grid ]


def get_cols(grid):
    N_cols = len(grid[0])
    cols= []
    for i in range(N_cols):
        col = [row[i] for row in grid]
        cols.append("".join(col))
    return cols