Welcome to Playground project

Sample project flowtimer

see source:flowtimer@master for the master branch

see source:flowtimer@guix for the development branch

Error: Failed to load processor json

No macro or processor named 'json' found

from Phase import Phase
from RecurringPhaseSequence import RecurringPhaseSequence
from Schedule import Schedule

p1 = Phase('Huddle', 10)
p2 = Phase('Tasking', 5)
p3 = Phase('Work', 45)
p4 = Phase('Break', 15)

seq1 = RecurringPhaseSequence(phase_list = [p1, p2, p3, p4], repetitions=3)
unrolled = [[deepcopy(seq) for seq in [each for each in seq1.repetitions * seq1.phase_list]]]
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.