Learn Encapsulation by Building a Projectile Trajectory Calculator - Step 19

Python
1

Tell us what’s happening:

Is there anyone who can help me with that please:
I’m on step 19 and currently stuck. It seems like i don’t really understand what they are asking to do.
Is there someone who can provide some hints so, i can complete this step?

Your code so far

import math

GRAVITATIONAL_ACCELERATION = 9.81
PROJECTILE = "∙"
x_axis_tick = "T"
y_axis_tick = "⊣"

class Projectile:
    __slots__ = ('__speed', '__height', '__angle')

    def __init__(self, speed, height, angle):
        self.__speed = speed
        self.__height = height
        self.__angle = math.radians(angle)
        
    def __str__(self):
        return f'''
Projectile details:
speed: {self.speed} m/s
height: {self.height} m
angle: {self.angle}°
displacement: {round(self.__calculate_displacement(), 1)} m
'''

    def __calculate_displacement(self):
        horizontal_component = self.__speed * math.cos(self.__angle)
        vertical_component = self.__speed * math.sin(self.__angle)
        squared_component = vertical_component**2
        gh_component = 2 * GRAVITATIONAL_ACCELERATION * self.__height
        sqrt_component = math.sqrt(squared_component + gh_component)
        
        return horizontal_component * (vertical_component + sqrt_component) / GRAVITATIONAL_ACCELERATION
        
    def __calculate_y_coordinate(self, x):
        height_component = self.__height
        angle_component = math.tan(self.__angle) * x
        acceleration_component = GRAVITATIONAL_ACCELERATION * x ** 2 / (
                2 * self.__speed ** 2 * math.cos(self.__angle) ** 2)
        y_coordinate = height_component + angle_component - acceleration_component

        return y_coordinate
    
    def calculate_all_coordinates(self):
        return [
            (x, self.__calculate_y_coordinate(x))
            for x in range(math.ceil(self.__calculate_displacement()))
        ]

    @property
    def height(self):
        return self.__height

    @property
    def angle(self):
        return round(math.degrees(self.__angle))

    @property
    def speed(self):
        return self.__speed

    @height.setter
    def height(self, n):
        self.__height = n

    @angle.setter
    def angle(self, n):
        self.__angle = math.radians(n)

    @speed.setter
    def speed(self, s):
       self.__speed = s
    
    def __repr__(self):
        return f'{self.__class__}({self.speed}, {self.height}, {self.angle})'

class Graph:
    __slots__ = ('__coordinates')

    def __init__(self, coord):
        self.__coordinates = coord

    def __repr__(self):
        return f"Graph({self.__coordinates})"

    def create_coordinates_table(self):
        table = '\n  x      y\n'
        for x, y in self.__coordinates:
            table += f'{x:>3}{y:>7.2f}\n'

        return table


# User Editable Region

    def create_trajectory(self):
        
        rounded_coords = [(round(x), round(y)) for x,y in self.__coordinates]
        
        x_max = max(rounded_coords, key=lambda i: i[0])[0]
        y_max = max(rounded_coords, key=lambda j: j[1])[1]
        
        matrix_list = [[' ' for _ in range(x_max + 1)] for _ in range(y_max + 1)]
        for X, Y in rounded_coords:
            x, y= PROJECTILE
            matrix_list['']
        return matrix_list
        

# User Editable Region


ball = Projectile(10, 3, 45)
print(ball)
coordinates = ball.calculate_all_coordinates()
graph = Graph(coordinates)
for row in graph.create_trajectory():
    print(row)

Your browser information:

User Agent is: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Challenge Information:

Learn Encapsulation by Building a Projectile Trajectory Calculator - Step 19

2

your approach is not bad, each X,Y is the coordinate that should be changed
only, x,y = PROJECTILE is not making that change. Do you remember how you can change an element in a list of lists?

3

I think it is like that: list[1][0]?

4

So, you mean to try to access the element in the matrix_list and then change them to the projectile symbol?

5

I think, i might need to do something like that:
for x, y in rounded_coords:
matrix_list[0][0] = PROJECTILE?

6

you need to use the right values here, if you write [0][0] only the first element in the first list is changed

8

Do i need to write matrix_list[x][y] = PROJECTILE

9

I have tried the last line of code and now it gives me this:IndexError: list index out of range

10 
for x, y in rounded_coords:
            for i in range(len(matrix_list)):
                for j in range(len(matrix_list[i])):
                    matrix_list[i][j] = PROJECTILE
        return matrix_list
11

This is what i’ve got, but still not pass

image
image675×423 3.07 KB

12

you don’t need to change all the elements, only those that match the coordinates

also you need to consider that in a normal list of lists 0,0 is on the top left corner but a graph will have the 0,0 in the bottom left corner, so one of the two coordinates need to be changed slightly

13

I have tried but how can i do that. It seems like i don’t really understand this part

14

what is it that you don’t understand? have you managed to have the graph even if upside down?

15

Not really.
The part that is requested for the graph to be upside down, is the one i don’t understand the most