Learn Encapsulation by Building a Projectile Trajectory Calculator - Step 21

Tell us what’s happening:

I have tried as much as possible to make the chart output same as that of the example but it’s still not passing the test. Please can anyone point me to what I’m missing out?

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):
        # Round the coordinates to nearest integer
        rounded_coords = [(round(x), round(y)) for x, y in self.__coordinates]

        # Find the maximum x and y coordinates for the grid size
        x_max = max(rounded_coords, key=lambda i: i[0])[0]
        y_max = max(rounded_coords, key=lambda j: j[1])[1]

        # Create an empty matrix (grid) filled with spaces
        matrix_list = [[" " for _ in range(x_max + 1)] for _ in range(y_max + 1)]

        # Place the projectiles ('∙') on the grid at the correct coordinates
        for x, y in rounded_coords:
            matrix_list[-1 - y][x] = PROJECTILE  # Invert the y-axis to align the grid with bottom-left

        # Add the y-axis ('⊣') as the leftmost symbol for each row
        for i in range(len(matrix_list)):
            matrix_list[i] = [y_axis_tick] + matrix_list[i]

        # Add the x-axis at the bottom of the grid.
        # The x-axis ticks ('T') should start one space after the left boundary (⊣) on a new line.
        x_axis_line = [" "] + [x_axis_tick] * (x_max + 1)  # Start with space for alignment
        matrix_list.append(x_axis_line)

        # Format the grid into the desired output format
        matrix_string = []
        for row in matrix_list:
            matrix_string.append('"' + "".join(row) + '",')

        # Return the formatted output without square brackets
        return matrix_string


# 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 21

Can you provide an example of your chart output?

Sorry for the late response. Below is the output as requested. Thank you for your help

Output should not have the quotes and commas.

The chart will be stored as an array of strings, but printed as a “graphical” chart. Just like the lines above are strings without quotes.

This worked! I’m sincerely grateful for your help.

1 Like