{
    "excluded_shortcodes": [],
    "excluded_misc": [],
    "pytest_config": {
        "VENV_PATH": "/courses/TDDE44/venv_pytest",
        "HELP_URL": "https://www.ida.liu.se/~TDDE44/kurslogistik/inlamningar/"
    },
    "assignment_sets": {
        "intro": {
            "name": "Introduktion",
            "shortname": "Introduktion",
            "outcomes": [
                "Förstå vad funktioner är och hur de används.",
                "Förstå vad ett returvärde är.",
                "Känna till olika datatyper så som till exempel heltal, flyttal och strängar och veta hur man konverterar mellan dem.",
                "Kunna använda python som en miniräknare."
            ],
            "pass_score": 0.7,
            "distinction_score": 0.7,
            "point_rounding": 5,
            "assignments": [
                {
                    "type": "single",
                    "id": "basic/return_five",
                    "points": 5
                },
                {
                    "type": "single",
                    "id": "basic/five_twice",
                    "points": 5
                },
...

{
  "id": "TDDE44-DAT1-20260107",
  "version": "1.3",
  "config-type": "single",
  "instructions": "TDDE44_v10.md",
  "title": "TDDE44. DAT1. 2hp.",
  "date": "2026-01-07 kl. 14.00-18.00",
  "templates": {
    "exam": "exam_template.md",
    "part": "part_template.md",
    "single_question": "single_question_template_manual_points.md",
    "multi_question": "multi_question_template_manual_points.md",
    "subquestion": "subquestion_template_manual_points.md",
    "web_solution_exam": "hugo_web_solution_template.md",
    "web_solution_part": "part_template.md",
    "web_solution_single_question": "single_question_template_web_with_solution.md",
    "web_solution_multi_question": "multi_question_template_web_with_solution.md",
    "web_solution_subquestion": "subquestion_template_web_with_solution.md"
  },
  "pagebreak_after_question": true,
  "unittests": "question",
  "parts": [
    {
      "name": "Del 1",
      "id": "del1",
      "info": "För att bli godkänd på Del 1 måste alla uppgifter vara godkända.",
      "questions": [
        {
          "name": "Uppgift 1 - Loopar",
          "id": "uppg1",
          "type": "multi",
          "points": "",
          "info": "- För att få godkänt på denna uppgift skall __båda__ deluppgifterna lösas.\n- En av uppgifterna skall lösas med en `while`-loop och en skall lösas med `for`-loop.\n- Comprehensions, generatorer eller rekursion får *inte* användas för att lösa uppgifterna.\n- Spara lösningarna till båda deluppgifterna i Uppgift 1 i en fil med namnet `uppg1.py`.\n- Filen skickas in via Studentklienten som '*Assignment #1*'.",
          "required_score": 4,
          "global_tests": [
            {
              "name": "Uppgift 1 - en med for, en med while",
              "id": "test1",
              "points": "2",
              "file": "for_while"
            }
          ],
          "subquestions": [
            {
              "name": "Uppgift 1.1 - lös med lämplig loop",
              "id": "uppg11",
              "type": "single",
              "points": "",
              "folder": "listor",
              "file": "get_repeated"
            },
            {
              "type": "pagebreak"
            },
            {
              "name": "Uppgift 1.2 - lös med lämplig loop",
              "id": "uppg12",
              "type": "single",
              "points": "",
              "folder": "loopar",
              "file": "multiply_until_inc"
            }
          ]
        },
...

list_of_lists = [["Ada Lovelace", 1815], ["Joan Clarke", 1917]]
list_of_dicts = [ { "name": "Ada Lovelace", "birthyear": 1815 }, { "name": "Joan Clarke", "birthyear": 1917 } ]
dict_with_some_list_value = { "name": "ditto", "abilities": ["imposter", "limber"] }

print("lista1[0]:", lista1[0]) # första elementet i lista1
print("lista1[0][0]:", lista1[0][0]) # första elementet i första elementet i lista1
print("lista1[1][1]:", lista1[1][1]) # andra elementet i andra elementet i lista1

lista1 = [(1, 2, 3), ('a', 'b', 'c')]

lista1[1][1]

'b'

# värdet associerat med nyckeln "johsj47"
print("teachers['johsj47']:", teachers['johsj47']) 
# värdet associerat med nyckeln "courses" i värdet associerat med nyckeln "johsj47"
print("teachers['johsj47']['courses']:", teachers['johsj47']['courses'])
# andra elementet i listan associerad med nyckeln "courses" i värdet associerat med nyckeln "johsj47"
print("teachers['johsj47']['courses'][1]:", teachers['johsj47']['courses'][1])

teachers = { 
    "chasi94": { "name": "Charlie", "courses": ["729G46", "729G87", "TDDE44", "769A34", "729G40"] },
    "johsj47": { "name": "Johan", "courses": ["729G46", "729G87", "TDDE44", "TDDI18", "732G16"] }
}

def get_courses_for(liuid, staff):
    return staff[liuid]['courses']
    

teachers['johsj47']['courses'][2]

get_courses_for('chasi94', teachers)

['729G46', '729G87', 'TDDE44', '769A34', '729G40']

def print_nested_list(outer_list):
    for outer_element in outer_list:
        # kod som skriver ut varje element i inner_list
        for inner_element in outer_element:
            print(inner_element)

groceries = [ ["apple", "banana", "orange"], ["carrot", "onion", "potato", "garlic"] ]

def print_nested_list(outer_list):
    for inner_list in outer_list:
        for element in inner_list:
            print(element)


print_nested_list(groceries)

apple
banana
orange
carrot
onion
potato
garlic

def print_dictionaries(dict_of_dictionaries, separator):
    # gå igenom alla värden i dict:en med dict:ar
    for dictionary in dict_of_dictionaries.values():
        print(separator)
        # gå igenom alla nyckel-värde-par i aktuellt dictionary
        for key, value in dictionary.items():
            print(f"The key '{key}' has the value: {value}")

teachers = { 
    "chasi94": { "name": "Charlie", "courses": ["729G46", "729G87", "TDDE44", "769A34", "729G40"] },
    "johsj47": { "name": "Johan", "courses": ["729G46", "729G87", "TDDE44", "TDDI18", "732G16"] }
}

def print_dictionaries(dict_of_dictionaries, separator):
    for dictionary in dict_of_dictionaries.values():
        print(separator)
        for key, value in dictionary.items():
            print(f"The key '{key}' has the value: {value}")

print_dictionaries(teachers, "teacher:")

teacher:
The key 'name' has the value: Charlie
The key 'courses' has the value: ['729G46', '729G87', 'TDDE44', '769A34', '729G40']
teacher:
The key 'name' has the value: Johan
The key 'courses' has the value: ['729G46', '729G87', 'TDDE44', 'TDDI18', '732G16']

def print_dictionaries(dict_of_dictionaries, separator):
    # gå igenom alla värden i dict:en med dict:ar
    for dictionary in dict_of_dictionaries.values():
        print(separator)
        # gå igenom alla nycklar i varje dictionary
        for key, value in dictionary.items():
            print(f"| The key '{key}' has the value: {value}")

books = {
    "skansholm24": { 
        "title": "Python från början, 2a uppl.", 
        "pages": 310, 
        "author": "Jan Skansholm"
    },
    "lutz25": { 
        "title": "Learning Python, 6th Ed.",
        "author": "Mark Lutz",
        "pages": 1172 } }

print_dictionaries(books, "book:")

book:
The key 'title' has the value: 'Python från början, 2a uppl.'
The key 'pages' has the value: '310'
The key 'author' has the value: 'Jan Skansholm'
book:
The key 'title' has the value: 'Learning Python, 6th Ed.'
The key 'author' has the value: 'Mark Lutz'
The key 'pages' has the value: '1172'

def print_dictionaries2(dict_of_dictionaries, separator):
    # gå igenom alla värden i dict:en med dict:ar
    for dictionary in dict_of_dictionaries.values():
        print(separator)
        # gå igenom alla nycklar i varje dictionary
        for key, value in dictionary.items():
            # i de fall som värdet för en nyckel är en lista
            if type(value) == list:
                print(f"| The key '{key}' has a list value with the following elements:")
                # skriv ut varje värde i listan dictionary[key]
                for element in value:
                    print(f"| - {element}")
            # när värdet i dictionaryt inte är en lista
            else:
                print(f"| The key '{key}' has the value: {value}")

def print_dictionaries2(dict_of_dictionaries, separator):
    for dictionary in dict_of_dictionaries.values():
        print(separator)
        for key, value in dictionary.items():
            if type(value) == str:
                print(f"The key '{key}' has the value: {value}")
            elif type(value) == list:
                print(f"| The key '{key}' has a list value with the following elements:")
                for element in value:
                    print("|-", element)
            
print_dictionaries2(teachers, 'teacher:')
print_dictionaries2(books, 'book:')

teacher:
The key 'name' has the value: Charlie
| The key 'courses' has a list value with the following elements:
|- 729G46
|- 729G87
|- TDDE44
|- 769A34
|- 729G40
teacher:
The key 'name' has the value: Johan
| The key 'courses' has a list value with the following elements:
|- 729G46
|- 729G87
|- TDDE44
|- TDDI18
|- 732G16
book:
The key 'title' has the value: Python från början, 2a uppl.
The key 'author' has the value: Jan Skansholm
book:
The key 'title' has the value: Learning Python, 6th Ed.
The key 'author' has the value: Mark Lutz

def has_value(needle, haystack):
    # bearbeta yttre listan
    for value in haystack:
        # bearbetning av yttre värden som är listor
        if type(value) == list:
            for inner_value in value:
                if inner_value == needle:
                    return True
        # om yttre värde inte är en lista, kolla om det är det vi letar efter
        elif value == needle:
            return True
    # når vi slutet av funktionen utan att ha hittat värdet vi letar efter så
    return False

def has_value(needle, haystack):
    for value in haystack:
        if type(value) == list:
            for inner_value in value:
                if inner_value == needle:
                    return True
        elif value == needle:
            return True 
    return False

nested_list = [ "a", ["b", ["c"]], "d", "e", ["f", "g"] ]
has_value("c", nested_list)

False

if values == []:
    return 0
else:
    return values[0] + sum_list_rec(values[1:])

def sum_list_rec(values):
    # basfall
    if values == []:
        return 0
    # förenkla och returnera
    return values[0] + sum_list_rec(values[1:])

print("sum_list_rec([1, 2, 75, 6, 7]): ", sum_list_rec([1, 2, 75, 6, 7]))

sum_list_rec([1, 2, 75, 6, 7]):  91

def sum_list_rec(values):
    if values == []:
        return 0
    else:
        return values[0] + sum_list_rec(values[1:])
    
print("sum_list_rec([1, [2, 3], 4]): ", sum_list_rec([1, [2, 3], 4]))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[33], line 7
      4     else:
      5         return values[0] + sum_list_rec(values[1:])
----> 7 print("sum_list_rec([1, [2, 3], 4]): ", sum_list_rec([1, [2, 3], 4]))

Cell In[33], line 5, in sum_list_rec(values)
      3     return 0
      4 else:
----> 5     return values[0] + sum_list_rec(values[1:])

Cell In[33], line 5, in sum_list_rec(values)
      3     return 0
      4 else:
----> 5     return values[0] + sum_list_rec(values[1:])

TypeError: can only concatenate list (not "int") to list

def sum_nest(values):
    if values == []:
        ...
    if type(values[0]) == int:
        ... 
    elif type(values[0]) == list:  
        ...

def sum_nest(values):
    if values == []:
        return 0
    if type(values[0]) == int:
        ...
    elif type(values[0]) == list:
        ...

def sum_nest(values):
    if values == []:
        return 0
    if type(values[0]) == int:
        return values[0] + sum_nest(values[1:])
    elif type(values[0]) == list:
        ...

def sum_nest(values):
    if values == []:
        return 0
    if type(values[0]) == int:
        return values[0] + sum_nest(values[1:])
    elif type(values[0]) == list:
        return sum_nest(values[0]) + sum_nest(values[1:])

print("sum_nest([1, [2, [3, [4]]]]): ", sum_nest([1, [2, [3, [4]]]]))

sum_nest([1, [2, [3, [4]]]]):  10

def sum_nest2(list_or_int):
    if type(list_or_int) == list:
        if list_or_int == []:
            return 0
        return sum_nest2(list_or_int[0]) + sum_nest2(list_or_int[1:])
    else:
        return list_or_int

def sum_nest2(list_or_int):
    if type(list_or_int) == list:
        if list_or_int == []:
            return 0
        return sum_nest2(list_or_int[0]) + sum_nest2(list_or_int[1:])
    else:
        return list_or_int
    
print("sum_nest2([1, [2, 3], 4]): ", sum_nest2([1, [2, 3], 4]))

sum_nest2([1, [2, 3], 4]):  10

def sum_nest2(list_or_int):
    print(' '*depth*2, "Evaluating sum_nest2(", values, ")")
    if type(list_or_int) == list:
        if list_or_int == []:
            print(' '*depth*2, "Returning from current level")
            return 0
        print(' '*depth*2, "Stepping down into first first element")
        return sum_nest2(list_or_int[0], depth+1) + sum_nest2(list_or_int[1:], depth)
    else:
        print(' '*depth*2, "Returning from current level")
        return list_or_int

def sum_nest2(list_or_int, depth=0):
    print(' '*depth*2, "Evaluating sum_nest2(", list_or_int, ")")
    if type(list_or_int) == list:
        if list_or_int == []:
            print(' '*depth*2, "Returning from current level")
            return 0
        print(' '*depth*2, "Recursive call for first element")
        return sum_nest2(list_or_int[0], depth+1) + sum_nest2(list_or_int[1:], depth)
    else:
        print(' '*depth*2, "Returning from current level")
        return list_or_int
    
print("sum_nest2([1, [2, 3], 4]): ", sum_nest2([1, [2, 3], 4]))

 Evaluating sum_nest2( [1, [2, 3], 4] )
 Recursive call for first element
   Evaluating sum_nest2( 1 )
   Returning from current level
 Evaluating sum_nest2( [[2, 3], 4] )
 Recursive call for first element
   Evaluating sum_nest2( [2, 3] )
   Recursive call for first element
     Evaluating sum_nest2( 2 )
     Returning from current level
   Evaluating sum_nest2( [3] )
   Recursive call for first element
     Evaluating sum_nest2( 3 )
     Returning from current level
   Evaluating sum_nest2( [] )
   Returning from current level
 Evaluating sum_nest2( [4] )
 Recursive call for first element
   Evaluating sum_nest2( 4 )
   Returning from current level
 Evaluating sum_nest2( [] )
 Returning from current level
sum_nest2([1, [2, 3], 4]):  10

def sum_nest_for(values):
    result = 0
    for elem in values:
        ...
    return result

# Fungerar för tomma listan
print("sum_nest_for([]): ", sum_nest_for([]))

sum_nest_for([]):  0

def sum_nest_for(values):
    result = 0
    for elem in values:
        if type(elem) == int:
            result = result + elem
        ...
    return result

# Fungerar för listor av enbart heltal men inga nästlade listor
print("sum_nest_for([]): ", sum_nest_for([]))
print("sum_nest_for([1, 2, 3]): ", sum_nest_for([1, 2, 3]))

sum_nest_for([]):  0
sum_nest_for([1, 2, 3]):  6

def sum_nest_for(values):
    result = 0
    for elem in values:
        if type(elem) == int:
            result = result + elem
        elif type(elem) == list:
            result = result + sum_nest_for(elem)
    return result

# Fungerar för nästlade listor med heltal:
print("sum_nest_for([]): ", sum_nest_for([]))
print("sum_nest_for([1, 2, 3]): ", sum_nest_for([1, 2, 3]))
print("sum_nest_for([1, [2, 3], 4]): ", sum_nest_for([1, [2, 3], 4]))
print("sum_nest_for([1, [2, 3], [[4, 5], 6]]): ", sum_nest_for([1, [2, 3], [[4, 5], 6]]))
print("sum_nest_for([1, [2, 3], [[4, 5, [6, 7, [8]]], 9]]): ", sum_nest_for([1, [2, 3], [[4, 5, [6, 7, [8]]], 9]]))

sum_nest_for([]):  0
sum_nest_for([1, 2, 3]):  6
sum_nest_for([1, [2, 3], 4]):  10
sum_nest_for([1, [2, 3], [[4, 5], 6]]):  21
sum_nest_for([1, [2, 3], [[4, 5, [6, 7, [8]]], 9]]):  45

def exists_in(value, values):
    if not values:
        # Inget värde kan finnas i en tom tupel
        return False
    # Kolla om det första elementet är det värde
    # vi letar efter, returnera i så fall True
    elif values[0] == value:
        return True
    # Om första värdet är en tupel, returnera resultatet
    # av att leta i både den tupeln och resten av values
    elif type(values[0]) == tuple:
        return (exists_in(value, values[0]) or
                exists_in(value, values[1:]))
    # Om inte första värdet varken var en tupel eller det vi letade efter
    # returnera resultatet av att leta efter värdet i resten av tupeln
    else:
        return exists_in(value, values[1:])

def exists_in(value, values):
    if values == tuple():
        return False
    if values[0] == value:
        return True
    elif type(values[0]) == tuple:
        return exists_in(value, values[0]) or exists_in(value, values[1:])
    else:
        return exists_in(value, values[1:])
    
exists_in('h', ('b', ('a', (('d'), 'a'))))

False

def exists_in_for(value, values):
    for element in values:
        if element == value:
            return True
        elif type(element) == tuple:
            if exists_in_for(value, element):
                return True
    return False
    
    
exists_in_for('h', ('b', ('a', (('d'), 'a'))))

False

def exists(name, directory):
    for file_node in directory.keys():
        if file_node == name:
            # the name we are looking for has been found
            return True
        if type(directory[file_node]) == dict:
            # file is a directory, recursively check if the wanted name exists in that directory
            if exists(name, directory[file_node]):
                return True
    # the end of directory has been reached without finding name
    return False

# Samma filträd som ovan men komprimerat
filetree = {'fil1': "", 'fil2': "", 'fil3': "", 'katalog1' :{'fil5': "", 'katalog1_1': {'fil4': ""}}, 'katalog2': {'fil6': "", 'hejsan': {'hoppsan': {'fallerallera': ""}}}, 'katalog3': {'fil7': ""}}

def exists(name, directory):
    for file_node in directory.keys():
        if file_node == name:
            # the name we are looking for has been found
            return True
        if type(directory[file_node]) == dict:
            # file is a directory, recursively check if the wanted name exists in that directory
            if exists(name, directory[file_node]):
                return True
    # the end of directory has been reached without finding name
    return False

print("exists('fil1', filetree) ->", exists('fil1', filetree))
print("exists('fil9', filetree) ->", exists('fil9', filetree))
print("exists('hoppsan', filetree) ->", exists('hoppsan', filetree))

exists('fil1', filetree) -> True
exists('fil9', filetree) -> False
exists('hoppsan', filetree) -> True

def find(name, directory):
    for file_node in directory.keys:
        if file_node == name:
            # the name we are searching for has been found
            return name
        if type(directory[file_node]) == dict:
            # file is a directory, recursively check if the
            # name searched for exists in that directory
            relative_from_here = find(name, directory[file_node])
            if relative_from_here:
                # file was found in subdirectory, return current
                # subdirectory plus the relative path from here
                return file_node + "/" + relative_from_here
    # the end of directory has been reached without finding name
    return False

# Samma filträd som ovan men komprimerat
filetree = {'fil1': "", 'fil2': "", 'fil3': "", 'katalog1' :{'fil5': "", 'katalog1_1': {'fil4': ""}}, 'katalog2': {'fil6': "", 'hejsan': {'hoppsan': {'fallerallera': ""}}}, 'katalog3': {'fil7': ""}}

def find(name, directory):
    for file_node in directory.keys():
        if file_node == name:
            # the name we are searching for has been found
            return name
        if type(directory[file_node]) == dict:
            # file is a directory, recursively check if the
            # name searched for exists in that directory
            relative_from_here = find(name, directory[file_node])
            if relative_from_here:
                # file was found in subdirectory, return current
                # subdirectory plus the relative path from here
                return file_node + "/" + relative_from_here
    # the end of directory has been reached without finding name
    return False

print("find('fil1', filetree)->", find('fil1', filetree))
print("find('hejsan', filetree)->", find('hejsan', filetree))
print("find('fallerallera', filetree)->", find('fallerallera', filetree))

find('fil1', filetree)-> fil1
find('hejsan', filetree)-> katalog2/hejsan
find('fallerallera', filetree)-> katalog2/hejsan/hoppsan/fallerallera

def find_files_containing(search_str, directory):
    found_files = []
    for file_node, contents in directory.items():
        if type(contents) == str:
            # file_node är en fil så vi undersöker 
            # om search_str finns i den filen
            if search_str in contents:
                found_files.append(file_node)
        if type(contents) == dict:
            # file_node is a directory, recursively investigate
            # the contents of that directory
            found_in_subdir = find_files_containing(search_str, contents)
            if found_in_subdir:
                # some matching files were found in subdirectory, prepend
                # current subdirectory to the relative paths from here
                for relative_from_here in found_in_subdir:
                    found_files.append(file_node + "/" + relative_from_here)
    # the end of directory has been reached without finding name
    return found_files

# Samma filträd som ovan men komprimerat
filetree = {'fil1': "Berndt Frida Henning Mio Sven Jennie Hildegard Caroline", 'fil2': "Erland Kristine Catrine Agnes Oskar Vivian Tanja Mårten", 'fil3': "Aron Edit Urban Christian Uno Gösta Hjalmar Hasse", 'katalog1' : {'fil5': "Lelle Richard Rikard Hugo Siri Torsten Solvig", 'katalog1_1': {'fil4': "Inger Ella Tindra Laura Gunborg Ulla Hillevi Jörgen"}}, 'katalog2': {'fil6': "Malin Kim Teresa Halsten Vilma Didrik Robert Alex", 'hejsan': {'hoppsan': {'fallerallera': "My Ylva Thea Marie Martin Linus Göta Moa"}}}, 'katalog3': {'fil7': "Emmy Vilde Catharina Halsten Josefin Gunnar Beata Iris"}}

def find_files_containing(search_str, directory):
    found_files = []
    for file_node, contents in directory.items():
        if type(contents) == str:
            # file_node är en fil så vi undersöker 
            # om search_str finns i den filen
            if search_str in contents:
                found_files.append(file_node)
        if type(contents) == dict:
            # file_node is a directory, recursively investigate
            # the contents of that directory
            found_in_subdir = find_files_containing(search_str, contents)
            if found_in_subdir:
                # some matching files were found in subdirectory, prepend
                # current subdirectory to the relative paths from here
                for relative_from_here in found_in_subdir:
                    found_files.append(file_node + "/" + relative_from_here)
    # the end of directory has been reached without finding name
    return found_files

print("find_files_containing('Halsten', filetree)->", find_files_containing('Halsten', filetree))
print("find_files_containing('H', filetree)->", find_files_containing('H', filetree))
print("find_files_containing('v', filetree)->", find_files_containing('v', filetree))

find_files_containing('Halsten', filetree)-> ['katalog2/fil6', 'katalog3/fil7']
find_files_containing('H', filetree)-> ['fil1', 'fil3', 'katalog1/fil5', 'katalog1/katalog1_1/fil4', 'katalog2/fil6', 'katalog3/fil7']
find_files_containing('v', filetree)-> ['fil1', 'fil2', 'katalog1/fil5', 'katalog1/katalog1_1/fil4', 'katalog2/hejsan/hoppsan/fallerallera']

def get_path(s_node, e_node, a_map, visited):
    """Returnera en lista med vägen från s_node till e_node om sådan finns."""
    # är e_node direkt tillgänglig?
    if e_node in a_map[s_node]:
        return visited + [s_node, e_node]
    # kolla om vi kan ta oss till e_node från någon av grannarna till s_node
    return get_path_hlp(a_map[s_node], e_node, a_map, visited + [s_node])

def get_path_hlp(s_nodes, e_node, a_map, visited):
    """Returnera den första vägen från en nod i s_nodes till e_node om sådan finns."""
    # om s_nodes är tom så kan vi inte ta oss till e_node
    if not s_nodes:
        return []
    # om vi inte redan besökt s_nodes[0]
    elif s_nodes[0] not in visited:
        # kolla om vi kan ta oss till e_node därifrån eller någon av de övriga
        # nodern i s_nodes
        path = get_path(s_nodes[0], e_node, a_map, visited)
        if path:
            return path
        else:
            return get_path_hlp(s_nodes[1:], e_node, a_map, visited)
    # om vi redan besökt s_nodes[0]
    else:
        # kolla om vi kan ta oss till e_node från någon av de övriga noderna
        # i s_nodes
        return get_path_hlp(s_nodes[2:], e_node, a_map, visited)

print(get_path('c', 'b', map1, []))

['c', 'd', 'a', 'b']

def get_path_with_for(s_node, e_node, a_map, visited):
    """Returnera en lista med vägen från s_node till e_node om sådan finns."""
    # är e_node direkt tillgänglig?
    if e_node in a_map[s_node]:
        return visited + [s_node, e_node]
    # kolla om vi kan ta oss till e_node från någon av grannarna till s_node
    for next_node in a_map[s_node]:
        if next_node not in visited:
            path = get_path_with_for(next_node, e_node, a_map, visited + [s_node])
            if path:
                return path
    # om vi kommer hit kunde vi inte hitta någon väg
    return []

print(get_path_with_for('c', 'b', map1, []))

['c', 'd', 'a', 'b']

print(get_path_with_for('h', 'g', map2, []))

['h', 'e', 'd', 'g']

def pseudoquicksort(values):
    if len(values) < 2:
        return values
    pivot = values[0]
    left = []
    right = []
    for elem in values[1:]:
        if elem < pivot:
            left.append(elem)
        else:
            right.append(elem)
    return pseudoquicksort(left) + [pivot] + pseudoquicksort(right)


print("pseudoquicksort([8, 1, 2, 4, 0, 9])->", pseudoquicksort([8, 1, 2, 4, 0, 9]))
print("pseudoquicksort([3, 9, 1, 4, 6, 5, 2])->", pseudoquicksort([3, 9, 1, 4, 6, 5, 2]))

pseudoquicksort([8, 1, 2, 4, 0, 9])-> [0, 1, 2, 4, 8, 9]
pseudoquicksort([3, 9, 1, 4, 6, 5, 2])-> [1, 2, 3, 4, 5, 6, 9]

def pseudoquicksort(seq):
    if len(seq) < 2:
        return seq
    else:
        pivot = seq[0]
        left = []
        right = []
        for elem in seq[1:]:
            if elem < pivot:
                left.append(elem)
            else:
                right.append(elem)
        return pseudoquicksort(left) + [pivot] + pseudoquicksort(right)
    
pseudoquicksort([3, 9, 1, 4, 6, 5, 2])

[1, 2, 3, 4, 5, 6, 9]

namn = "Guido"
print("Hej " + namn + "!")
print("Jag vet att svaret är " + str(21*2) + ".")
resultat = sum([10, 41, 29, 74, 26, 20, 8])
print("resultat=" + str(resultat))

Hej Guido!
Jag vet att svaret är 42.
resultat=208

namn = "Guido"
print(f"Hej {namn}!")
print(f"Jag vet att svaret är {21*2}.")
resultat = sum([10, 41, 29, 74, 26, 20, 8])
print(f"resultat={resultat}")

Hej Guido!
Jag vet att svaret är 42.
resultat=208

resultat = sum([10, 41, 29, 74, 26, 20, 8])
print(f"{resultat=}")

resultat=208

print(f"{40+2=}")

40+2=42

my_value = 123
print(f"{my_value/2=}")

my_value/2=61.5

apple_price = 1.2
print(f"Three apples cost ${3*apple_price:.2f}.")

Three apples cost $3.60.

apple_price = 1.2
sweater_price = 29.99
tv_price = 379
print(f"apple:   {apple_price:>6.2f}")
print(f"sweater: {sweater_price:>6.2f}")
print(f"tv:      {tv_price:>6.2f}")

apple:     1.20
sweater:  29.99
tv:      379.00

TDDE44 Programmering, grundkurs¶

Föreläsning 3.1-3.2¶

Johan Falkenjack, johan.falkenjack@liu.se¶

Föreläsningsöversikt¶

JSON¶

JSON: Exempel¶

JSON: Exempel¶

Bearbetning av nästlade datastrukturer¶

Nästlade datastrukturer¶

Hur kommer vi åt nästlade värden?¶

Samma princip med dict¶

Skriv ut listor av listor av strängar¶

Nästlade strukturer med dict¶

Bearbeta lista av mappningar¶

Bearbeta lista av mappningar¶

Bearbeta lista av mappningar med möjliga listvärden¶

Leta efter värde i nästlad lista¶

Okej, men om vi inte vet exakt hur strukturen kommer se ut i förväg?¶

Om vi måste kunna hantera godtyckligt många nivåer av nästling?¶

Rekursion (igen)¶

Repetition: Enkelrekursion¶

Mönster för att skriva en rekursiv funktion¶

Rekursion för nästlade datastrukturer¶

Summera en nästlad lista av heltal¶

Fallanalys¶

Basfallet¶

Om första elementet är ett heltal¶

Om första elementet är en lista, då?¶

Dubbelrekursion¶

Nästlade strukturer kan tolkas som träd

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

Trädrekursion

En alternativ lösning¶

Vad händer egentligen i sum_nest2?¶

Kan vi använda iteration istället?¶

Basfall?¶

Rekursionssteg¶

Leta efter ett värde i en nästlad tupel¶

Leta efter ett värde i en nästlad tupel, med for¶

Söka i en "katalogstruktur"¶

Söka i en "katalogstruktur", fortsättning¶

Söka i en "katalogstruktur", ännu mer fortsättning¶

Inte bara för explicit nästling¶

Exempel: Grafsökning¶

Rekursiva funktioner kan "utforska" flera olika lösningsvägar med trädrekursion¶

Hitta vägen¶

Hitta vägen (med for-loop)¶

Större karta¶

Pseudo-Quicksort, sortering med rekursion¶

f-strängar¶

Enklare strängformattering i Python¶

Tidigare: Strängkonkatenering¶

Enklare generering av strängar¶

Smidig utskrift av variabler¶

Formatering i f-strängar¶

Samma princip med `dict`¶

Nästlade strukturer med `dict`¶

Vad händer egentligen i `sum_nest2`?¶

Leta efter ett värde i en nästlad tupel, med `for`¶

Hitta vägen (med `for`-loop)¶