LEGO 3D Coordinates
Tags: python, programming, tutorial, beginners
Published: 2024-03-01 16:38:06

### The Grid Dimensions
- **Length (X)**: The number of blocks you can place in a row.
- **Width (Y)**: The number of blocks you can place in a column, perpendicular to the row.
- **Height (Z)**: The number of layers of blocks you can stack on top of each other.

Imagine you have a LEGO base that's 1 block wide, 1 block long, and you're allowed to stack up to 1 block high. This gives you a tiny (2 X 2 X 2) space to work with, because you start counting from 0 (so you have positions 0 and 1 in each dimension).

### The Rule (N)
Now, let's say you have a rule: You can't place a LEGO block at any position where the sum of the coordinate's equals (N). For instance, if (N=2), you can't place a block at any spot where adding up the row number, column number, and stack height equals 2.

### Visualizing Coordinates
Each spot where you could place a LEGO block has coordinates (i, j, k):
- (i) is the position along the length of your base.
- (j) is the position along the width.
- (k) is the height or layer number.

### Real-World Example
Let's apply this with our (1 X 1 X 1) model and \(N=2\):
- You start placing blocks at (0, 0, 0), the very bottom corner.
- You can also place blocks at (0, 0, 1), moving up one layer without changing the row or column.
- However, you can't place a block at (0, 1, 1) because (0+1+1=2), and our rule forbids any spot where the coordinates add up to 2.

### The List of Allowed Coordinates
Using a list comprehension to apply these rules, we find the allowed spots to place our LEGO blocks without breaking the (N=2) rule. For our tiny LEGO base, the possible placements, avoiding spots where the sum equals 2, might look like this: [(0, 0, 0), (0, 1, 0), (1, 0, 0), (1, 1, 1)]. Each of these coordinates represents a spot where you can safely place a block according to the rules.

### Visualization
Imagine laying out a grid of possible block positions on your LEGO base and then marking which spots are allowed under the rule. Each allowed spot gets a LEGO block, building a unique structure that adheres to your constraints.

This visualization takes the abstract concept of 3D coordinates and the rule-based exclusion and turns it into a tangible LEGO building exercise, making it easier to grasp how list comprehensions can generate and filter complex collections based on specific conditions.

#### Here is the code in Python using a list comprehension.
```python
#!/usr/bin/python3
# lego_3d_coords.py

def lego_3d_coordinates(x, y, z, n):
    """
    This function will print all possible coordinates on the 3D grid within the
    specified dimensions, excluding those combinations where the sum of the dimenstions
    equals 'n'
    """
    coordinates = [[i, j, k] for i in range(x+1) for j in range(y+1) for k in range(z+1) if i + j + k != n]
    print(coordinates)

if __name__ == '__main__':
    x = int(input())
    y = int(input())
    z = int(input())
    n = int(input())
    lego_3d_coordinates(x, y, z, n)
```

> Once you have created this script be sure to make it executable using `chmod +x lego_3d_coords.py` then run it in the same directory using `./lego_3d_coords.py`

> Also remember to add the coordinates input values using your preferred CLI once you run your Python script.

Photo by <a href="https://unsplash.com/@xavi_cabrera?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Xavi Cabrera</a> on <a href="https://unsplash.com/photos/yellow-red-blue-and-green-lego-blocks-kn-UmDZQDjM?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Unsplash</a>