Changes between Version 8 and Version 9 of WikiStart

Timestamp:

08/14/24 14:21:01 (16 months ago)

Author:

Enrico Schwass

Comment:

--

WikiStart

@@ -51 +51 @@
 schedule = Schedule(unrolled)
 }}}
-
-Certainly! Let's break down the task with an example:
-
-### Given:
-- You have a list of lists.
-- You want to split each sublist at the point where the sublist starts with a given symbol.
-
-### Example:
-
-#### Input:
-```python
-list_of_lists = [
-    ['a', 1, 2, 3],
-    ['b', 4, 5, 6],
-    ['*', 7, 8, 9],
-    ['c', 10, 11],
-    ['*', 12, 13],
-    ['d', 14, 15, 16]
-]
-symbol = '*'
-```
-
-#### Expected Output:
-```python
-[
-    [['a', 1, 2, 3], ['b', 4, 5, 6]],
-    [['*', 7, 8, 9], ['c', 10, 11]],
-    [['*', 12, 13], ['d', 14, 15, 16]]
-]
-```
-
-### Steps:
-
-1. **Initialize an empty result list**: This will hold the final split sublists.
-2. **Iterate through each sublist**: Check if the first element of the sublist is the given symbol.
-3. **When the symbol is found**: Start a new group in the result list.
-4. **Continue grouping until the symbol is encountered again**.
-
-### Python Code Implementation:
-
-```python
-def split_list_of_lists(list_of_lists, symbol):
-    result = []
-    current_group = []
-    
-    for sublist in list_of_lists:
-        if sublist[0] == symbol and current_group:
-            result.append(current_group)
-            current_group = []
-        current_group.append(sublist)
-    
-    if current_group:
-        result.append(current_group)
-    
-    return result
-
-# Example usage
-list_of_lists = [
-    ['a', 1, 2, 3],
-    ['b', 4, 5, 6],
-    ['*', 7, 8, 9],
-    ['c', 10, 11],
-    ['*', 12, 13],
-    ['d', 14, 15, 16]
-]
-symbol = '*'
-output = split_list_of_lists(list_of_lists, symbol)
-print(output)
-```
-
-### Output:
-```python
-[
-    [['a', 1, 2, 3], ['b', 4, 5, 6]],
-    [['*', 7, 8, 9], ['c', 10, 11]],
-    [['*', 12, 13], ['d', 14, 15, 16]]
-]
-```
-
-This code takes a list of lists and splits it into separate groups whenever a sublist starts with the specified symbol. Each group is then added to the result. The result is a list of these grouped sublists.
-
-To solve this problem in Scheme recursively, let's define a recursive function that will process the list of lists and split them into groups whenever a sublist starts with the specified symbol.
-
-### Steps:
-
-1. **Base Case**: If the list of lists is empty, return an empty list.
-2. **Recursive Case**: 
-    - If the first sublist starts with the given symbol and the current group is not empty, start a new group.
-    - Otherwise, continue adding sublists to the current group.
-
-### Scheme Implementation:
-
-Here’s how you can implement this in Scheme:
-
-```scheme
-(define (split-list-of-lists list-of-lists symbol)
-  (define (split-helper lists current-group result)
-    (cond
-      ((null? lists) 
-       (if (null? current-group) 
-           result
-           (append result (list current-group))))
-      ((equal? (caar lists) symbol)
-       (if (null? current-group)
-           (split-helper (cdr lists) (list (car lists)) result)
-           (split-helper (cdr lists) (list (car lists)) (append result (list current-group)))))
-      (else
-       (split-helper (cdr lists) (append current-group (list (car lists))) result))))
-  (split-helper list-of-lists '() '()))
-
-;; Example usage:
-(define list-of-lists 
-  '((a 1 2 3)
-    (b 4 5 6)
-    (* 7 8 9)
-    (c 10 11)
-    (* 12 13)
-    (d 14 15 16)))
-
-(define symbol '*)
-
-(split-list-of-lists list-of-lists symbol)
-```
-
-### Explanation:
-
-1. **`split-list-of-lists`**: The main function that initializes the recursive process with an empty `current-group` and `result`.
-
-2. **`split-helper`**: 
-    - **Base Case**: When `lists` is empty, if `current-group` is also empty, return the `result`. Otherwise, append the `current-group` to the `result`.
-    - **When symbol is encountered**: If the current group is not empty, append it to the result and start a new group. If the current group is empty, simply start a new group with the current sublist.
-    - **Else case**: Append the current sublist to the `current-group` and continue the recursion.
-
-### Example Output:
-Running the above code with the example `list-of-lists` and `symbol`, you should get:
-
-```scheme
-'(((a 1 2 3) (b 4 5 6)) 
-  ((* 7 8 9) (c 10 11)) 
-  ((* 12 13) (d 14 15 16)))
-```
-
-This Scheme code recursively processes the list of lists and splits them into groups based on the given symbol.
-