Underrated step for logic building in programming.

-
Image
Logic building is a crucial and complex skill in programming. In essence, it is ability to come-up with solution of coding problem and write precise instructions ( or code) that a computer can execute autonomously. This skill requires aligning your thought process with computer and its capabilities. And running through code some-what abstractly to know and predict the behavior of code before it is executed. To be able to do this, one essential step that many beginner programmers overlook is performing dry runs. Understanding Dry Runs The concept of a dry run in programming is straightforward: can you mentally execute your code and predict its output without actually running it on a computer? While this seems simple, it is a challenging task. Typically, we are taught to write code, run it, and observe the output. This cycle is essential because code needs to run to be validated. However, if you rely solely on running your code to understand its behavior, you may struggle with building...
Post a Comment

Python Code for beginner's #3

-

 1.

# Get input from the user
num = int(input("Enter a number: "))

# Initialize variables for factorial calculation
factorial = 1
i = 1

# Calculate factorial using a while loop

while i <= num:
    factorial *= i  # Multiply the current factorial by the current value of i
    i += 1          # Increment i to move to the next number in the sequence

# Display the result
print("Factorial:", factorial)

**Summary:**

1. The program takes an integer input from the user.

2. It initializes variables `factorial` and `i` to 1.

3. It then uses a `while` loop to calculate the factorial of the entered number.

4. The loop multiplies the current value of `factorial` by the current value of `i` and increments `i` until it reaches the entered number.

5. The final factorial value is displayed.


2.

# Function to calculate the volume of a rectangular prism
def calculate_volume(length, breadth, height):
    # Formula for the volume of a rectangular prism: length * breadth * height
    volume = length * breadth * height
    return volume

# Taking user input for the dimensions of the rectangular prism

length = float(input("Enter the length: "))

breadth = float(input("Enter the breadth: "))

height = float(input("Enter the height: "))

# Calling the function to calculate the volume using user-provided dimensions

result = calculate_volume(length, breadth, height)

# Displaying the result to the user
print(f"The volume of the rectangular prism is: {result}")

Summary:

- The code defines a function `calculate_volume` that takes three parameters (length, breadth, and height) and calculates the volume of a rectangular prism using the formula `length * breadth * height`.

- User input is then taken for the length, breadth, and height of the rectangular prism using the `input` function and converted to float.

- The `calculate_volume` function is called with the user-provided dimensions, and the result is stored in the variable `result`.

- Finally, the calculated volume is displayed to the user using a formatted string in the `print` statement.


3.

# Get user input for the number to generate a multiplication table for
given_number = int(input("Enter a number: "))
# Define a function to print the multiplication table for the given number
def print_multiplication_table(number, up_to=10):
    # Loop through the range from 1 to the specified limit

    for i in range(1, up_to + 1):
        # Calculate the result of the multiplication
        result = number * i
        # Print the multiplication table entry
        print(f"{number} x {i} = {result}")

# Call the function to print the multiplication table for the given number up to 10
print_multiplication_table(given_number, up_to=10)

Summary:

- The script takes user input for a number.

- It defines a function `print_multiplication_table` that prints the multiplication table for the given number up to a specified limit (default is 10).

- The function uses a loop to iterate through the range of 1 to the specified limit and calculates the result of the multiplication for each iteration.

- The multiplication table entries are printed in the format "number x i = result".

- Finally, the function is called with the user-input number, and the multiplication table is printed up to 10.

4.

# Get user input for the number to generate a multiplication table
given_number = int(input("Enter a number: "))
# Function to print the multiplication table for a given number up to a specified limit
def print_multiplication_table(number, up_to=10):
    i = 1
    # Use a while loop to iterate through the table up to the specified limit
    while i <= up_to:
        # Calculate the result of the multiplication
        result = number * i

        # Print the multiplication table entry in a formatted way
        print(f"{number} x {i} = {result}")
        # Increment the iterator
        i += 1

# Call the function with the user-provided number and a default limit of 10
print_multiplication_table(given_number, up_to=10)

Summary:

1. The script takes user input for a number.

2. The `print_multiplication_table` function is defined to generate and print the multiplication table for the given number.

3. The function uses a `while` loop to iterate through the table up to a specified limit (default is 10).

4. Inside the loop, it calculates the result of the multiplication, prints the entry in a formatted manner, and increments the iterator.

5. Finally, the function is called with the user-provided number, and the multiplication table is printed up to 10 by default.

Comments

Post a Comment

Popular posts from this blog

Thinking in React: Relatable Scenarios for Building User Interfaces

-
Main post   Understanding the concept of "Thinking in React" can be easier when related to everyday scenarios. Let's explore this approach by comparing it to planning a road trip, organizing a party, and managing a kitchen. Each scenario will help illustrate the key principles of building efficient, maintainable user interfaces with React. Scenario 1: Planning a Road Trip Step 1: Mapping the Journey (Component Hierarchy) Imagine you're planning a road trip with friends. You don't just hop into the car and drive; you map out the journey, decide on destinations, and break the trip into manageable segments. The Road Trip : This is your entire application, the big picture. Destinations and Stops : These represent the major sections of your app, like the homepage, user profile, and settings. Activities and Rest Stops : These are smaller parts within those sections, like buttons, forms, and navigation links. By mapping out the journey, you create a clear plan f...
Read more

Understanding Closures in JS (with Examples and Analogies)

-
Image
  Today, I’ll be going talk about closures in js, my archnemesis 😒 The things that I will be covering in this post, are listed in content’s overview: Content’s Overview: Starting analogy What is a Closure? How Closures Work ? Examples 5 analogies to understand Why Are Closures Useful? Conclusion Let’s start with an analogy to understand Closures. Closures: Imagine you have a secret clubhouse that only you and your friends can access. Inside the clubhouse, you have a bunch of toys and games that you all share. Even if you leave the clubhouse, the toys and games are still there for you and your friends to use whenever you come back. That's kind of like a closure in JavaScript - a function that "remembers" the variables it had access to, even after it's done running. You might not understand it now, but just keep these lines in mind. You will get clearer picture later. Now that ,If you have ever encountered a situation in JavaScript where a function seems...
Read more

Python code # 15 'classes'

-
  class Student: def __init__ ( self , Roll: int , name: str , faculty: str ): self .__Roll = Roll self .__name = name self .__faculty = faculty def display ( self ): print ( f"Student( { self .__Roll } , ' { self .__name } ', ' { self .__faculty } ')" ) def set_Roll ( self ,Roll): self .__Roll=Roll def set_name ( self ,name): self .__name= name def set_faculty ( self ,faculty): self .__faculty = faculty def get_Roll ( self ): return self .__Roll def get_name ( self ): return self .__name def get_faculty ( self ): return self .__faculty c = Student( 2 , 'nn' , 'lk' ) c.display() # Output: Student(2, 'nn', 'lk') print (c.get_name()) c.set_Roll( 42 ) c.display() # Output: Student(42, 'John', 'lk') --------------------------------------------------------------------------------------------- class Studen...
Read more