Engineer Bae-🍀

Love Babbar's C++ DSA Lecture's Solutions

Lecture: 1 Homework Solutions
Lecture: 2 Homework Solutions
Lecture: 3 Homework Solutions
Lecture: 4 Homework Solutions
Lecture: 5 Homework Solutions
Lecture: 6 Homework Solutions
Lecture: 7 Homework Solutions

Homework of Video 4 ( Solving Pattern Questions (Part-2) ) - Love babbar

1. Write a program to print this pattern:

2. Write a program to print this pattern:


3
4 5
5 6 7

3. Write a program to print this pattern:

A B C
A B C
A B C

4. Write a program to print this pattern:

A B C
D E F
G H I

5. Write a program to print this pattern:

A B C
B C D
C D E

6. Write a program to print this triangular pattern:

A
B B
C C C

7. Write a program to print this triangular pattern:

D
C D
B C D
A B C D

8. Write a program to print this square matrix pattern:

****
***
**
*

9. Write a program to print this square matrix pattern:

****
 ***
  **
   *

10. Write a program to print this square matrix pattern:

11. Write a program to print this square matrix pattern:

12. Write a program to print this square matrix pattern:

13. Write a program to print this square matrix pattern:

14. Write a program to print this square matrix pattern:

1234554321
1234**4321
123****321
12******21
1********1

Homework of Video 3 ( If-Else, While loop & Lots of Patterns (Part-1) ) - Love babbar

1. Why do we write namespace std & iostream as the program's header?

Ans. These are pre-built libraries where a code related to performing a certain task is placed So that, C++ can work effectively.

a. Using namespace std: There are a bunch of namespaces & out of them we are using std that makes the computer know that we are using cout. Basically, an identifier conflict resolver.

b. #include <iostream> : This header contains the programs of input & output functions like cout,cin etc. #include asks to include iostream

2. Guess the output :

Ans: NINEYPOSITIVE

Ans: 3

Ans: Love24

3. Write a code that accepts char ch.

Prints this is the lowercase or small case if lies in between 'a' - 'z'
Prints this is uppercase if lies in between 'A' - 'Z'
Prints this is numeric if lies in between '0' - '9'

4. Input N and print the sum of all the even numbers lying in 1 to N.

5. Write a program to convert the temperature into:

Fahrenheit to celsius
Celsius to Fahrenheit

Homework of Video 1(Intro to Programming & Flowcharts)- Love babbar

Python Mail Merge Project - Automating Recipient Writing in a Letter

Project Description:

Automates the recipient writing part in the same letter.
Recipient names are given in a separate file named invited_names.txt
A sample letter is given in a separate file named starting_letter.txt
Code is to be written inside main.py whose purpose is to fetch the sample letter, replace the [name] in a sample letter with recipient names & generate an individual letter following this naming convention: letter_for_{recipient_name}.txt
The number of names given in invited_names.txt file generates a similar number of letters. Suppose, 5 names are given in invited_names.txt then, 5 letters will be generated.

Folder Structure:

Output:

./Input/Letters/starting_letter.txt

 
Dear [name],

You are invited to my birthday this Saturday.

Hope you can make it!

Engineer Bae

./Input/Names/invited_names.txt

  
Aang
Zuko
Appa
Katara
Sokka
Momo
Uncle Iroh
Toph

./Output/ReadyToSend/example.txt

  Dear Aang,

You are invited to my birthday this Saturday.

Hope you can make it!

Engineer Bae

main.py

 with open("Input/Names/invited_names.txt") as name_file:
    names = name_file.readlines()  # for each name in invited_names.txt

with open("Input/Letters/starting_letter.txt", "r") as letter_file:
    letter_content = letter_file.read()
    print(type(letter_content))

    for name in names:
        recipient = name.strip()
        # name.strip("\n")
        letter_name = f'letter_for_{recipient}.txt'

        new_letter = letter_content.replace("[name]", recipient)  # Replace the [name] placeholder with the actual name.

        with open(f'Output/ReadyToSend/{letter_name}', "w") as file:  # Save the letters in the folder "ReadyToSend".
            file.write(new_letter)

Crossing the Turtle : Python Turtle Project for Beginners

Game Rules:

One turtle of unique color can only move forward.

Neither left nor right. Turtle cannot even move backward.

Turtle has to save itself from the collision with cars.
If crosses all the cars, its level increases & along with all the car's speed!
Random count cars & each car of random color are coming from the left & right.
The scoreboard is maintained for every level.

How the game looks like?

main.py

     
        
import time
import turtle
from turtle import Screen
from player import Player
from car_manager import CarManager
from scoreboard import Scoreboard

import random

#TODO 1. Move the turtle with keypress
#TODO 2. Create & move the cars
#TODO 3. Detect collision with car
#TODO 4. Detect when turtle reaches the other side
#TODO 5. Create a scoreboard

screen = Screen()
screen.setup(width=600, height=600)
screen.title("Crossing the Turtle")
screen.tracer(0)
screen.bgcolor("sky blue")

game_is_on = True

player=Player()
car=CarManager()
scoreboard=Scoreboard()


screen.listen()
screen.onkey(player.move_forward,'Up')


while game_is_on:
    time.sleep(0.1)
    screen.update()
    car.create_car()
    car.move_cars()

    # TODO 3. Detect collision with car
    for cars in car.all_cars:
        if cars.distance(player)<20:
            game_is_on=False
            scoreboard.write_game_over()
    for cars in car.all_forward_cars:
        if cars.distance(player)<20:
            game_is_on=False
            scoreboard.write_game_over()

    #TODO 4. Detect when sucessful crossing
    if player.is_at_finish_line():
        player.got_to_start()
        car.level_up()
        scoreboard.increase_level()


screen.exitonclick()

player.py

        

from turtle import Turtle

STARTING_POSITION = (0, -280)
MOVE_DISTANCE = 10
FINISH_LINE_Y = 280


class Player(Turtle):

    def __init__(self):
        super().__init__()
        self.shape('turtle')
        self.color("gray")
        self.penup()
        self.got_to_start()
        self.left(90) #or self.setheading(90)

    def move_forward(self):
        self.forward(MOVE_DISTANCE)

    def is_at_finish_line(self):
        if self.ycor() > FINISH_LINE_Y:
            return True
        else:
            return False

    def got_to_start(self):
        self.goto(STARTING_POSITION)

car_manager.py

        
from turtle import Turtle
import random

COLORS = ["red", "orange", "yellow", "green", "blue", "purple"]
STARTING_MOVE_DISTANCE = 5
MOVE_INCREMENT = 10


class CarManager:
    def __init__(self):
        self.all_cars=[]
        self.all_forward_cars=[]
        self.car_speed=STARTING_MOVE_DISTANCE

    def create_car(self):
        random_chance=random.randint(1,6)

        if random_chance==1:
            new_car=Turtle("square")
            new_car.penup()
            new_car.shapesize(stretch_len=2,stretch_wid=1)
            new_car.color(random.choice(COLORS))
            random_y=random.randint(-250,250)
            new_car.goto(300,random_y)
            self.all_cars.append(new_car)

            new_forward_car=Turtle("square")
            new_forward_car.penup()
            new_forward_car.shapesize(stretch_len=2,stretch_wid=1)
            new_forward_car.color(random.choice(COLORS))
            random_y=random.randint(-250,250)
            new_forward_car.goto(-300,random_y)
            self.all_forward_cars.append(new_forward_car)


    def move_cars(self):
        for car in self.all_cars:
            car.backward(self.car_speed)

        for car in self.all_forward_cars:
            car.forward(self.car_speed)


    def level_up(self):
        self.car_speed+=MOVE_INCREMENT

scoreboard.py

        
class Scoreboard(Turtle):
    def __init__(self):
        super().__init__()
        self.level=1
        self.hideturtle()
        self.penup()
        self.goto(-280,250)
        self.update_scoreboard()


    def update_scoreboard(self):
        self.clear()
        self.write(f"Level:{self.level}",align="left",font=FONT)

    def increase_level(self):
        self.level+=1
        self.update_scoreboard()

    def write_game_over(self):
        self.goto(0,0)
        self.write("Game Over",align="center",font=FONT)

Blind 75 Must Do Leetcode Python 3 Solutions

Hashing to Solutions:

Two Sum
Longest Substring Without Repeating Characters
Longest Palindromic Substring
Container With Most Water
3Sum
Remove Nth Node From End of List
Valid Parentheses
Merge Two Sorted Lists
Merge k Sorted Lists
Search in Rotated Sorted Array
Combination Sum
Rotate Image
Group Anagrams
Maximum Subarray
Spiral Matrix
Jump Game
Merge Intervals
Insert Interval
Unique Paths
Climbing Stairs
Set Matrix Zeroes
Minimum Window Substring
Word Search
Decode Ways
Validate Binary Search Tree
Same Tree
Binary Tree Level Order Traversal
Maximum Depth of Binary Tree
Construct Binary Tree from Preorder and Inorder Traversal
Best Time to Buy and Sell Stock
Binary Tree Maximum Path Sum
Valid Palindrome
Longest Consecutive Sequence
Clone Graph
Word Break
Linked List Cycle
Reorder List
Maximum Product Subarray
Find Minimum in Rotated Sorted Array
Reverse Bits
Number of 1 Bits
House Robber
Number of Islands
Reverse Linked List
Course Schedule
Implement Trie (Prefix Tree)
Design Add and Search Words Data Structure
Word Search II
House Robber II
Contains Duplicate
Invert Binary Tree
Kth Smallest Element in a BST
Lowest Common Ancestor of a Binary Search Tree
Lowest Common Ancestor of a Binary Tree
Product of Array Except Self
Valid Anagram
Meeting Rooms
Meeting Rooms II
Graph Valid Tree
Missing Number
Alien Dictionary
Encode and Decode Strings
Find Median from Data Stream
Longest Increasing Subsequence
Coin Change
Number of Connected Components in an Undirected Graph
Counting Bits
Top K Frequent Elements
Sum of Two Integers
Pacific Atlantic Water Flow
Longest Repeating Character Replacement
Non-overlapping Intervals
Serialize and Deserialize BST
Subtree of Another Tree
Palindromic Substrings
Longest Common Subsequence

1. Two Sum

This code looks through a list to find two different numbers that add up to a specific target number. It does this by using two loops. The first loop starts at the beginning of the list. For each number in the first loop, the second loop looks at the numbers that come after it in the list. If it finds two numbers that add up to the target, it gives back their positions in the list.

 
   
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        
        for num_first in range(len(nums)):
            for num_second in range(num_first+1,len(nums)):
                if nums[num_first]+nums[num_second] == target:
                    return [num_first,num_second]

Time Complexity: O(n^2)

This is because for each element in the list (and there are 'n' elements), we are potentially looking at every other element in the list to find a match (which in the worst case is 'n-1' other elements), resulting in 'n' times 'n-1' operations.

Space complexity: O(1)

This code only uses a fixed amount of extra space (for the indices), no matter how big the list gets.

2. Longest Substring Without Repeating Characters

 
   
 class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        
        last_idx = {}
        max_len = 0

        # starting index of current
        # window to calculate max_len
        start_idx = 0

        for i in range(0, len(s)):

            # Find the last index of str[i]
            # Update start_idx (starting index of current window)
            # as maximum of current value of start_idx and last
            # index plus 1
            if s[i] in last_idx:
                start_idx = max(start_idx, last_idx[s[i]] + 1)

            # Update result if we get a larger window
            max_len = max(max_len, i-start_idx + 1)

            # Update last index of current char.
            last_idx[s[i]] = i

        return max_len

Time Complexity: O(n + d) where n is the length of the input string and d is the number of characters in the input string alphabet.
Space Complexity: O(d)

Counting Valleys - Hackerrank Solution

Check out the counting valleys question here: Hackerrank question

The picturization of the problem:

Suppose the input is: UDDDUDUU

Then,

Answer: Valley level is 1. Because hiker stepped this way only.

To solve this problem:

Initially, assumed U = 1, D = -1 & altitude=0

Then, iterated till total steps-1. Whenever altitude(height) that is sea level is 0 & the last step is 'U" I have incremented the valley by 1 (because valley level is considered only when hiker's last step is 'U" & at the sea level).

When all the elements are traversed it returned the final valley's value that's our final result.

Solution:

def countingValleys(steps, path):
    # Write your code here
    
    altitude = 0
    valley = 0
    dict = {
        "U": 1,
        "D": -1
    }

    for eachstep in range(steps):
        altitude += dict[path[eachstep]] # calculating hiker's each step

        if altitude == 0 and path[eachstep] == "U":
            valley += 1

    return valley

Sales by Match -Hackerrank solution

Check out the question here - Sales by Match

def sockMerchant(n, ar):

    pairs = 0

    for element in set(ar):
        pairs += ar.count(element) // 2
    
    return pairs

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')

    n = int(input().strip())

    ar = list(map(int, input().rstrip().split()))

    result = sockMerchant(n, ar)

    fptr.write(str(result) + '\n')

    fptr.close()

How to show code on blogger / blogspot with a copy snippet button

To show copy code snippet button for any code. Do the following steps:

Go to HTML View of blog post's editor.
Paste the below lines inside HTML editor & replace the Your Actual Code with the desired code.

<textarea style="border-style: solid; border-width: 1px 1px 1px 20px; border-color: #4072a1; width: 100%; height: 321px; line-height: 16px; resize: none;" id="html1" readonly> Your Actual Code</textarea><div style="font-size:13px; font-family: comic sans ms; color: blue;"><button onclick="copyThis1()">Copy code snippet</button></div>

function copyThis1() {

var copyText = document.getElementById("html1");

copyText.select();

copyText.setSelectionRange(0, 99999)

document.execCommand("copy");

alert("Code snippet copied to clipboard");

}

</script>

Turtle Race : Python Project for Beginners

Game Rules:

1. 5 turtles of unique colors compete against each other.

2. User gets a chance to guess which color turtle will win the race.

3. If the user's guess is right it says you've won otherwise you lose!

Few screenshots of the game:

CODE:

     
from turtle import Turtle,Screen, penup, xcor
import turtle
import random

colors=['yellow','blue','red','pink','orange']
all_turtles=[]
y_positions=[-60,-30,0,30,60]


screen=Screen()

screen.setup(width=500,height=300)

user_input=screen.textinput('Turtle Race','Make a bet. Which color will win win the race?').lower()

#Background Customizations
screen.bgcolor("grey")
Tim=Turtle()
Tim.color('green')
Tim.penup()
Tim.write('Turtle Race', move=False, align="left", font=("Arial", 25, "normal"))
Tim.goto(x=190,y=100)
Tim.color('Black')
Tim.write('END', move=False, align="left", font=("Arial", 10, "normal"))
Tim.goto(x=220,y=150)
Tim.right(90)

Tim.pendown()
Tim.color('Black')
#Background Customization Ends


Tim.forward(300)

for turtle_index in range(5):
    
    next_turtle=Turtle(shape='turtle')
    next_turtle.color(colors[turtle_index])
    next_turtle.penup()
    next_turtle.goto(x=-230,y=y_positions[turtle_index])
    
    

    all_turtles.append(next_turtle)

if user_input:
    is_race_on=True

while is_race_on:
    for move_turtle in all_turtles:
        if move_turtle.xcor() > 200:
            is_race_on=False
            winning_color=move_turtle.pencolor()

            if user_input==winning_color:
                print(f" You've won! The {winning_color} turtle wins the race.")
            else:
                print(f" You lose! The {winning_color} turtle wins the race.")
        
        move_turtle.forward(random.randint(0,10))
        move_turtle.speed(0)


screen.exitonclick()

Doodle it: Imagine, Draw, Erase and Repeat - Python Project for Beginners

Doodle it: Imagine, Draw, Erase and Repeat

In order to create this game first step is to know a way of being able to listen to things the user does, like when a user taps a specific key on the keyboard. And the code that allows us to do this are called Event Listeners.

Go to python documentation > listen method()

It has a whole bunch of section-on-screen events, including listening to key presses or listening to a click or other things that you can listen to. So the important thing is this listen method.

This allows turtle screen to start listening and waiting for the events that the user might trigger, like tapping on a key.

So for this first thing, we'll be going to do is we'll import the turtle class and the screen class from the turtle module. And then, we'll use them to create our Ted the turtle, and also create a screen object.

from turtle import Turtle,Screen

ted=Turtle()
screen=Screen()

This is basically going to control the window when we run our code.

Now in order to start listening for events, we have to get hold of the screen object and then tell it to start listening.

from turtle import Turtle,Screen

ted=Turtle()
screen=Screen()

screen.listen()

And once it starts listening, we have to bind a function that will be triggered when a particular key is pressed on the keyboard. Now, in order to bind a keystroke to an event in our code, we have to use an event listener.

So the one that we're going to be using is this onkey method. And you can see it expects a function with no arguments and also a key, like the 'a' key on your keyboard or a key symbol, so the space or up or down.

So I'm going to say screen.onkey and then I have to bind some sort of function to this method.

So let's create a function named ted_move_right and all that this function is going to do is it's going to get Ted to go forward by 10 paces.

from turtle import Turtle,Screen

ted=Turtle()
screen=Screen()

def ted_move_right():
    ted.forward(10)

screen.listen()
screen.onkey() 

Now, coming back to our onkey method, we are going to say when the 'w', is pressed, then trigger the function move_forward.

def move_forward():
    ted.forward(10)

screen.listen()
screen.onkey(key='w',fun=move_forward)

Next, added the concerning triggered function move_backward to move backward when the 's' key is pressed.

from turtle import Turtle,Screen

ted=Turtle()
screen=Screen()

def move_forward():
    ted.forward(10)

def move_backward():
    ted.backward(10)
    
screen.listen()
screen.onkey(key='w',fun=move_forward)
screen.onkey(key='s',fun=move_backward)

screen.exitonclick()

Such that, functions to move counter-clockwise(left), clockwise(right) and to clear screen(reset screen) are written and binded them with the following keys 'a','d', & 'c' respectively.

from turtle import Turtle,Screen

ted=Turtle()
screen=Screen()

def move_forward():
    ted.forward(10)

def move_backward():
    ted.backward(10)
    

def move_left():
    new_heading= ted.heading()+10
    ted.setheading(new_heading)

def move_right():
    new_heading= ted.heading()-10
    ted.setheading(new_heading)


def clear_screen():
    ted.clear()
    ted.penup()
    ted.home()
    ted.pendown()

screen.listen()

screen.onkey(key='w',fun=move_forward)
screen.onkey(key='s',fun=move_backward)

screen.onkey(key='a',fun=move_left)
screen.onkey(key='d',fun=move_right)
screen.onkey(key='c',fun=clear_screen)

screen.exitonclick()

And now what I'm going to try is when I hit the 'w' key on the keyboard, you should see my turtle move forwards by 10 paces each time. And, when 's' key is pressed it moves backward. So we're now controlling our turtle using a keystroke. That's pretty much in Doodle it: just imagine,draw & repeat.

Full key list for python's turtle- screen events ( Event Listeners )

Screen events

turtle.onkey(fun=function_name, key='Backspace')

turtle.onkeyrelease(fun=function_name, key='Left')

Parameters

fun – a function with no arguments or None
key – a string: key (e.g. “a”) or key-symbol (e.g. “space”)

`.keysym`	`.keycode`	`.keysym_num`	Key

`Alt_L`	`64`	`65513`	The left-hand alt key
`Alt_R`	`113`	`65514`	The right-hand alt key
`BackSpace`	`22`	`65288`	backspace

`Caps_Lock`	`66`	`65549`	CapsLock
`Control_L`	`37`	`65507`	The left-hand control key
`Control_R`	`109`	`65508`	The right-hand control key
`Delete`	`107`	`65535`	Delete
`Down`	`104`	`65364`	↓
`End`	`103`	`65367`	end
`Escape`	`9`	`65307`	esc

`F1`	`67`	`65470`	Function key F1
`F2`	`68`	`65471`	Function key F2
`F_i`	`66+i`	`65469+i`	Function key F_i
`F12`	`96`	`65481`	Function key F12
`Home`	`97`	`65360`	home
`Insert`	`106`	`65379`	insert ( ins)
`Left`	`100`	`65361`	←

`K0`	`90`	`65438`	0 on the keypad
`1`	`87`	`65436`	1 on the keypad
`2`	`88`	`65433`	2 on the keypad
`3`	`89`	`65435`	3 on the keypad
`4`	`83`	`65430`	4 on the keypad
`5`	`84`	`65437`	5 on the keypad
`6`	`85`	`65432`	6 on the keypad
`7`	`79`	`65429`	7 on the keypad
`8`	`80`	`65431`	8 on the keypad
`9`	`81`	`65434`	9 on the keypad
`+`	`86`	`65451`	+ on the keypad

.	`91`	`65439`	Decimal (`.`) on the keypad
`Delete`	`91`	`65439`	delete on the keypad
/	`112`	`65455`	`/` on the keypad
`Down`	`88`	`65433`	↓ on the keypad

`Enter`	`108`	`65421`	enter on the keypad
`Home`	`79`	`65429`	home on the keypad

`Left`	`83`	`65430`	← on the keypad
`*`	`63`	`65450`	× on the keypad

`Prior`	`81`	`65434`	PageUp on the keypad
`Right`	`85`	`65432`	→ on the keypad
`-`	`82`	`65453`	`-` on the keypad
`Up`	`80`	`65431`	↑ on the keypad
`Next`	`105`	`65366`	PageDown / pg dn
`Num_Lock`	`77`	`65407`	NumLock
`Pause`	`110`	`65299`	pause
`Print`	`111`	`65377`	PrintScrn / prt sc

`Right`	`102`	`65363`	→
`Scroll_Lock`	`78`	`65300`	ScrollLock
`Shift_L`	`50`	`65505`	The left-hand shift key
`Shift_R`	`62`	`65506`	The right-hand shift key
`Tab`	`23`	`65289`	The tab key

Search This Blog

1. Two Sum

2. Longest Substring Without Repeating Characters