Fortnightly Programming Q&A Thread

Let's say I have a world where I can put rectangles in any arbitrary location. The rules are the following:

1. After inserting a new rectangle, no rectangle should be overlapping each others
2. If an overlap happens, rectangles should be split and / or resized such that their verticality is maximized and cover the full area that the rectangles covered (not sure how to explain it better than that but it should be easier to understand from the examples)
3. If two rectangles next to each others have the same verticality, they should be merged

Here are some examples of what I mean. The gray rectangles show the initial state. The transparent green rectangle shows the rectangle being inserted. The blue rectangles shows the newly inserted rectangles after running the algorithm.

Example 01:

1. Initial state 2 rectangles
2. Insertion
3. Final state 5 rectangles

Example 02:

1. Initial state 2 rectangles
2. Insertion
3. Final state 3 rectangles

Example 03:

1. Initial state 1 rectangle
2. Insertion
3. Final state 3 rectangles

Example 04:

1. Initial state 1 rectangle
2. Insertion
3. Final state 1 rectangle

Example 05:

1. Initial state 2 rectangles
2. Insertion
3. Final state 1 rectangle

Example 06:

1. Initial state 1 rectangle
2. Insertion
3. Final state 3 rectangles

Example 07:

1. Initial state 2 rectangles
2. Insertion
3. Final state 2 rectangles

Example 08:

1. Initial state 1 rectangle
2. Insertion
3. Final state 1 rectangle

Originally, I was using a brute force approach that stored every rectangle. Every time a new rectangle was added I'd discard these "vertical" rectangles and recompute the whole world. This time though I'm looking for a way to only update locally the rectangles that should change around where the new rectangle is added. Visually, the solution seems obvious, but I can't come up with the right algorithm that's as simple to implement as it looks.

(Eventually I'd also like to do rectangle removal or updating, but for now adding is enough.)

Edit: Fixed an issue with example 02. I had missed the rule 3 where I should merge vertically similar rectangles next to each others. snip

I'm working on a simple guess-style game in which I generate an array of letters, guess a sequence, test the sequence against the generated sequence, and display a message showing what is right/wrong.

I'm stuck at passing the array from one object to another, and am also unsure how to do it without regenerating the array each run.

I've got my code below.

import sys;
import random

CHOOSE_ARRAY = ["a","b","c","d"]

# Generate array for the game

class GameArray:
    def __init__(self):
        self.gameArray = []
    def genArray(self):
        i = 1
        while i <= 4:
            self.gameArray.append(random.choice(CHOOSE_ARRAY))
            i += 1
        return self.gameArray

# Get user input for test array

class ArrayInput:
    def __init__(self):
        self.testArray = []
    def getArray(self):
        print("Please input letters from a to b")
        self.testArray.append(input("Input the first letter:>> "))
        self.testArray.append(input("Input the second letter:>> "))
        self.testArray.append(input("Input the third letter:>> "))
        self.testArray.append(input("Input the fourth letter:>> "))
    def useArray(self):
        return self.testArray

#instantiate GameArray()
game = GameArray()

#instantiate ArrayInput, get input
user = ArrayInput()
user.getArray()

# ensure I'm generating arrays
print(game.genArray())
print(user.useArray())

When doing something like this, I like to print the output so I can actually determine that the data is what I expect it to be. Would the best way for me to get the data in GameArray.genARray from GameArray to ArrayInput be to design it so I call something like ArrayInput.(GameArray.genArray)? My comparison, AFAIK, will be done via for loops against the arrays (sort of fizzbuzz style lazy test), but I'm clueless on how to get the data where I need it to start doing testing like that.