DEV Community: Abhinav Yadav

Building a Personalised AI Chatbot with GPT and Gradio

Abhinav Yadav — Sat, 12 Oct 2024 14:53:58 +0000

Have you ever thought about building your own chatbot? One that can respond to whatever you say like Siri or Alexa? Well, today we are going to see how to create a cool AI chatbot using GPT and Gradio and believe me you don't need to be a tech expert to do it!

By the end of this blog you will have your own chatbot up and running . Let's get started!

What’s GPT?

Before we directly dive in building our chatbot we need to know first what is GPT. GPT stands for Generative Pre-trained Transformer. It's a type of AI that can understand human language and respond to it accordingly. Just like a smart robot.

What is Gradio?

Gradio is an amazing tool that allows you to create interactive web apps easily. With Gradio, you can easily build apps where you can input texts, images or audio. You can learn more about it in my previous blog, where I have explained it's detailed explanation.

Step 1: Install the Required Libraries

Now going to our initial step, we will install the libraries that will help us to build our first chatbot. Use these commands to install the libraries:

pip install openai gradio

openai: This is the library that connects to the GPT models.
gradio: This creates a web interface for your chatbot.

Step 2: Set Up Your OpenAI API Key

You will need an API from OpenAI to use GPT. Go to OpenAI API and sign up if you have not already. Once you are done with this step use the following code:

import openai

openai.api_key = "your-openai-api-key"

Replace "your-openai-api-key" with your actual key.

Step 3: Create the Chatbot Logic

Now, the most important part let's create the logic for the chatbot. The bot will take user input and use GPT to generate responses.

def gpt_chatbot(user_input):
    response = openai.Completion.create(
        engine="text-davinci-003",  # You can use other engines like "gpt-3.5-turbo"
        prompt=user_input,
        max_tokens=150,
        temperature=0.7
    )
    return response.choices[0].text.strip()

engine="text-davinci-003": This tells GPT which version to use.
prompt=user_input: The user’s message is sent to GPT as the prompt.
max_tokens=150: Limits the response length.
temperature=0.7: Controls how creative or random the responses are (higher values mean more creative).

Step 4: Build the Gradio Interface

Now time to make the interface of our chatbot. Let's make it interactive by using Gradio. This part is what makes it fun!

import gradio as gr

# Create Gradio interface
def chatbot_interface(user_input):
    return gpt_chatbot(user_input)

iface = gr.Interface(
    fn=chatbot_interface,  # The function that handles user input
    inputs="text",  # User types text
    outputs="text",  # GPT responds with text
    title="GPT Chatbot",
    description="Ask me anything! I'm your AI assistant."
)

iface.launch()

inputs="text": Users will input text.
outputs="text": The chatbot will output text.
title and description: Customize the interface with a friendly title and description.

Step 5: Run Your Chatbot

Now, run the Python script. Your Gradio app will launch in a new window, and you’ll have your very own personalized chatbot! You can ask it questions, and it will respond intelligently.

Step 6: Make It Your Own

Once you have the basics set up, you can customize your chatbot to make it more unique:

Adjust the temperature: Want the bot to be more creative? Increase the temperature setting to make it more playful.
Add additional prompts: Guide the chatbot’s behavior by giving it specific instructions like “You are a helpful assistant” before each conversation.

Conclusion

Building an AI-powered chatbot is easier than ever, thanks to tools like GPT and Gradio. With just a few lines of code, you can create a fully interactive chatbot that’s ready to talk to the world. So go ahead, give it a try, and see how fun it can be!

Thank You for being till the end of the blog I hope you have learnt something valueable. Do like and share the blog and keep coding.

Thank You!

The Role of AI in Financial Services: Opportunities and Challenges

Abhinav Yadav — Thu, 03 Oct 2024 12:03:08 +0000

Hey coders, how you all doing? Today's blog is one of the interesting topics I like to talk on, I am a lot invested into technology but I am also doing my minor degree in financial economics, so today I will write something different. Let's dive in.

Nowadays Artificial Intelligence is everywhere. From helping you shop online to suggesting your favourite music, AI has become a part of our daily lives. But do you know how AI is changing the banking and finance sector? Let's take a fun and simple look at how AI is shaping the world of finance.

What is AI?

Imagine you have a robot friend that can learn things from the internet, understand patterns and help you solve problem quickly! Basically it is a super smart assistant that can help you process huge amount of data and help in make decisions.

How AI is Helping Financial Services

AI is making its presence in real world by doing amazing things. Here's how:

1.Customer Service - Chatbots to the Rescue!

Ever chatted with a bank’s website? That’s not a human—it’s a chatbot powered by AI! These can answer your questions, help you with your account information and guide you through policies and help you in taking a loan. They work tirelessly and make customer service more convenient and faster.

2. Personalised Banking - Tailored Just for You!

AI has the power of studying your banking habits and recommend the products that suits you best. Let’s say you often save a bit of money every month. AI might suggest savings accounts or investment options based on your habits, making your banking experience personal and customised.

3. Fraud Detection - Stopping the Bad Guys!

AI is like a superhero that detects suspicious activity on your bank account. It can track if someone tries to steal from your bank account. It identifies by tracking the unusual spending activities on your account. If it detects something unusual, it immediately alert your bank.

4. Better Decisions - Smarter Loans and Investments

AI is very smart bank uses AI to predict whether giving someone loan is good or not. It goes through the past data, AI can help banks figure out if customer is likely to repay a loan or if an investment will be profitable.

Challenges: What’s Stopping AI from Being Perfect?

AI is an amazing tool but it comes with some shortcomings. Let's explore the challenges:

1. Data Privacy - Keeping Your Information Safe

AI works on a large amount of data but in case of banks, they have to handle all the sensitive data. It’s super important for banks to ensure that this data is secure and not misused. Sometimes, there’s a fear that AI systems could be hacked or data could be leaked.

2. Bias in Decision-Making

AI learns from data, but if that data has any biases, the AI system might make unfair decisions. For example, if the data shows a particular group was denied loans more often in the past, the AI might continue that pattern even if it’s wrong or unfair. It’s essential to make AI as unbiased and fair as possible.

3. Complex Regulations - Rules, Rules, and More Rules!

The financial world is heavily regulated to protect consumers. AI systems need to follow these rules, and sometimes this can slow down progress. Financial institutions must ensure AI is compliant with all regulations, which can be a tricky balancing act.

The Future of AI in Finance

The future of AI in financial services is bright! We might see even smarter AI that helps us save money better, offers new investment opportunities, or even makes banking more accessible to everyone around the world.

But remember, we still have to solve challenges like privacy and fairness to make AI the best tool it can be. With responsible development and careful management, AI can transform financial services for the better, creating a more efficient and inclusive financial system.

Conclusion

AI is like a magic wand for financial services, making everything faster, smarter, and more personal. It helps banks detect fraud, give better financial advice, and provide awesome customer service. But to make the most of AI, banks and financial institutions need to ensure security, fairness, and compliance with rules.

The world of AI in finance is just beginning, and we’re all part of this exciting journey!

Feel free to share your thoughts! Would you trust AI to handle your banking needs? Let me know in the comments!

I hope you enjoyed this blog, if you did don't forget to follow me on Linkedin and Github. Come on I also deserve some fame and if you don't please criticise me in comments.

How to Make a Cool App with Gradio!

Abhinav Yadav — Sat, 28 Sep 2024 18:28:09 +0000

Hey there, my coders! I am back with something different from my usual content. Today we gonna learn about Gradio! It's like magic for making apps that help people to talk to computer.

Now you might be thinking what is this gradio?

What is Gradio?

Imagine gradio as a magic wand for making apps. Imagine having a pet robot, and you want to ask it questions or show it pictures, and it answers you back! Gradio helps you build an interface where you can type things or give pictures, and computer can respond to it.

You don't need to know a lot about coding to get started. It is very basic and easy to use. Let's see how you can use it!

Step 1: Setting Up Gradio

Before getting started, we need to tell the computer to install Gradio.

Open your terminal.
Type this in terminal:

pip install gradio

This command will help you to install gradio and set it up for you. Now you are all set to create apps!

Step 2: Creating a Super Simple App

Let's make our very first app! In this app computer will ask for your name, and the computer will says hello to you. Sounds fun, right?

Write This Code:

import gradio as gr

def greet(name):
return "Hello, " + name + "!"

iface = gr.Interface(fn=greet, inputs="text", outputs="text")
iface.launch()

Now you must be thinking what is happening in this code, Let's break it down:

import gradio as gr: This is like saying computer to use gradio to make app.
def greet(name): This is the function asking your name and will return you Hello with your name.
iface = gr.Interface(fn=greet, inputs="text", outputs="text"): This part tells gradio how to build the app. It will take some text as input and return text as output.
iface.launch(): This helps us starting the app.

Now run your code, you will see a box where you can write your name, and the computer will greet you. Isn't it cool, try typing your name.

Step 3: Making It More Fun with Pictures!

Let's make the app more cooler by adding pictures! In this, we will show computer some pictures and tell the computer to identify it.

We’ll use a machine learning model that already knows what many animals look like.

Write This code:

import gradio as gr
from tensorflow.keras.applications.resnet50 import ResNet50, decode_predictions, preprocess_input
from tensorflow.keras.preprocessing import image
import numpy as np

model = ResNet50(weights="imagenet")

def classify_image(img):
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
preds = model.predict(img)
return decode_predictions(preds, top=1)[0][0][1]

iface = gr.Interface(fn=classify_image, inputs="image", outputs="label")
iface.launch()

Let's break down this code, to understand its functionality better:

Loading the model: We are uploading ResNet50 as brain of our computer, this helps the computer to guess what's in your picture.
classify_image: This function takes the image and guess what it sees.
inputs="image": Now here instead of text our app is asking for picture as input.

Now you can run the code, upload a picture and let computer guess it. You can upload anything in it.

Step 4: Sharing Your App with Friends!

Now that you have made a cool app, let's now share it with your network and friends. Gradio makes this super easy by giving you a special link you can share with anyone in the world!

Here's How You Do It:

Change the last part of your code to this:

iface.launch(share=True)

When you run this code, Gradio will give you a link that you can send to your friends. They can open the link in their browser and play with your app, just like you are!

Step 5: Adding More Fun Features

You can customise your gradio app the way you want, let's see some ways to make your app more fun:

Change the Title and Description

You can give your app a good title and description to make it more interactive.

iface = gr.Interface(
fn=classify_image,
inputs="image",
outputs="label",
title="Animal Classifier",
description="Upload an image, and I'll guess what animal it is!"
)
iface.launch()

Now your app looks way more cooler it has a name and a description now which makes it look more professional.

2.Use More Inputs and Outputs

What if you want to give computer more information? Maybe you want to show it both a picture and type some text, Gradio can handle that too!

Here’s how you can make an app with both an image and text as input:

iface = gr.Interface(
fn=classify_image,
inputs=["image", "text"],
outputs="label"
)
iface.launch()

Now your app will take both an image and some text. It’s like your computer just got smarter!

Conclusion

Wow! You have just learned how to make cool apps using Gradio! You can make a lot of apps using it and it makes coding really fun. You can explore more about it here.

I hope you enjoyed this blog, if you did don't forget to follow me on Linkedin and Github. Come on I also deserve some fame and if you don't please criticise me in comments.

Happy Coding!!

Leetcode Solution #8

Abhinav Yadav — Mon, 23 Sep 2024 21:04:16 +0000

1. Minimum Window Substring

Even after less views and no comments I am back coz can't let the culture and streak die hahahaha.....

Anyways today's question is leetcode hard and took some time to me too solve it but yea did it somehow.

The Problem

Let's try to understand it's description first,

Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If there is no such substring, return the empty string "".

The testcases will be generated such that the answer is unique.

Now I will call this description a very poor explanation of the question, basically the question is saying that we have given two strings s and t and length of these strings are m and n respectively, we are asked to return a minimum window substring of s such that every character present in t is included in the window we are returning.

See these examples to make sense of what I said,

Well question is kind of messed up but not that bad, have confidence you can do it. Let's move to approach.

The Approach

We will do the same thing which we do when we have two strings to compare, i.e.

Store occurrence of characters of string t.
Count occurrence of characters of string s.
If all characters matched, minimise the window.
Update window size.
Return substring.

Looks pretty easy isn't it but code looks a little bit scary. But I have tried my best to make it easy in steps.

The Solution

So, steps to achieve this crazy code are,

Check if length of t is longer than s if it is return empty string.
Declare two vectors of size 256 initialised to 0.
Populate hashT with counts of character in t using for loop.
Declare variable start as starting index of current window in s, start_index keeps track of the best starting index for minimum window found, min_len initialises to max possible integer value, count to count how many characters from t we have matched in current window.
Loop through each character in s.
Increment the count for character s[j] in hashS.
If s[j] is a character in t and the count in hashS for that character does not exceeds that in hashT, we found a match and we increment count.
Check if all characters are matched.
Inner loop shrinks the window from left until we can no longer maintain all characters in t.
Calculate current window length.
If this length is less, update the length and set start_index to current start.
Return result.

Damn such a complex question isn't it that's why only one for today hehe, if you will attempt this you will need time to digest this and don't quit.

And please please if you are liking this atleast react to it comment on it criticise it if you are not liking come on don't be like this.

Connect to me on Linkedin and Github.

Come on man I deserve some fame.

Thank you if you are following this blog till here, have some confidence you can do it.

KEEP CODING!!!

Leetcode Solution #7

Abhinav Yadav — Sun, 22 Sep 2024 19:56:26 +0000

1. Count Subarrays With Score Less Than K

The Problem

Always try making sense out of the description though most the time its just trash but still try, so the description is given as,

The score of an array is defined as the product of its sum and its length.

For example, the score of [1, 2, 3, 4, 5] is (1 + 2 + 3 + 4 + 5) * 5 = 75.

Given a positive integer array nums and an integer k, return the number of non-empty subarrays of nums whose score is strictly less than k.

A subarray is a contiguous sequence of elements within an array.

blah blah blah blah......

So, basically the question is saying that you have to find the score of an array, now the first question should be what is the meaning of score of an array, so well it is defined as the product of the sum of elements given in array and the size of array.
So, in question a positive integer array is given, we have to return the number of non-empty subarrays whose score is strictly less than k, k is a already given integer.

Look at the examples given below to make sense of the summary I gave above,

Now, here I am assuming that you have understood what I am trying to explain if not try youtube.

The Approach

Well though this marked as hard level problem on leetcode but the approach does not feels like it because it is pretty basic.

Traverse the array and calculate the cumulative sum (coz subarray duhh!).
Calculate the score of the array by calculating it's size and sum.
Count the valid subarrays.
Return count of subarray.

Now, I know you have understood nothing till here or even if you have and don't know how to write the code don't worry, I got you and if everything is making sense for you then damn I am getting good at this.

The Solution

If you have understood nothing till here, try to look at the code and I am writing the steps below try to make sense of it.

Declare variable sum, result and start, initialise them with 0, use sum for storing the cumulative sum of array and result to store the valid subarrays and start for pointing beginning of window.
Traverse the array, add current elements to sum to take cumulative sum.
Calculate size which is i-start+1 i.e. from start to i.
Calculate score by multiplying size with sum.
We will use while loop to ensure that k is less than score, if it exceeds we will shrink the window by incrementing start.
Each time we shrink window, reduce sum by the element at start.
Recalculate the size and score for new window.
After adjusting window add the count of valid subarrays.
Return result.

Hope you have understood till here if yes thank you, you people are making this labour worth and if you don't once again try youtube.

2. Daily Temperatures

The Problem

Well repeat the drill here read the description first.

Given an array of integers temperatures represents the daily temperatures, return an array answer such that answer[i] is the number of days you have to wait after the i th day to get a warmer temperature. If there is no future day for which this is possible, keep answer[i] == 0 instead.

Well if you are able to make sense out of this description well congrats you are better at english than me and if you don't I got you covered again homie.

Description is basically saying that an array is given and which represents the daily temperatures and we have to return an array answer which will have the number of days we have to wait after the i th day to get a warmer temperature. If there is no future day for this just return 0 on that index.

Refer to below given examples for a better understanding,

Hope this made sense for you and you are understanding it, if not try youtube.

The Approach

Like every other question approach is basic for this one too and try to think hard and understand by yourself everything will make sense, so the approach goes like:

Use stack (well it is the most optimised approach for this) to store indices of the temperatures array.
When a warmer day is found, it pops the stack and calculates number of days until that warmer temperature.
Remaining indices in stack will have 0 in result because no warmer day exists for them.

I hope till here you are getting me, if not lets move towards the solution look at the code and try to form a basic understanding from the steps given below.

The Solution

Is this making sense? No? Try to figure it from the below given steps.

Declare a stack st to store indices of the temperatures array.
Declare vector answer with size n and all elements set to 0.
Traverse the array temperatures.
Use while loop to check whether stack is non empty and current day temperature is greater than temperature at top of stack.
Declare a integer variable index to store top index from stack.
Remove top element when we found warmer temperature for that day.
Calculate number of days between.
Push i into stack because we have not found a warmer day yet.
Return answer.

Was this question easy? Was this approach easy to understand, if yes thank you.

So, this was it for today, I hope both the questions were easy to understand if yes do not keep this thought to yourself please comment down below, it can motivate me a lot. If you were not able to understand and have a better approach for this comment it down below too. I ain't no celeb I will reply. But do comment it helps.

Connect to me on Linkedin and Github

Come on I deserve some fame.

Thank you, if you are genuinely reading till here.

KEEP CODING!!!

Leetcode Solution #6

Abhinav Yadav — Mon, 16 Sep 2024 17:06:29 +0000

1. Min Stack

The Problem

Start by reading the description of the problem,

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.

Implement the MinStack class:

MinStack() initializes the stack object.
void push(int val) pushes the element val onto the stack.
void pop() removes the element on the top of the stack.
int top() gets the top element of the stack.
int getMin() retrieves the minimum element in the stack.

You must implement a solution with O(1) time complexity for each function.

It is a leetcode medium question but very easy to attempt.

Refer the example for better understanding,

Approach

Our approach for this question is going to be pretty straightforward, we don't need to do anything special in this question we will just apply our basic knowledge of stack and complete the given functions.

Solution

We have implemented the solution in following ways:

Initialise two stacks s1 and min, s1 will store all values and min stack will have the minimum value.
MinStack will be empty as it will not do anything specific here.
In push function, push the value in main stack(s1), check if min stack is empty or value is less than or equal to current minimum value. If condition is true, it means value is new minimum, so it should be added to min stack.
For pop function ensure that s1 is not empty, check if top value of s1 is equal to top value of min. If so, means that we have to pop top value of min stack.
Pop top value from s1.
For top function, return top value of s1 stack.
For getMin function, return top value of min stack.

2. Evaluate Reverse Polish Notation

The Problem

You are given an array of strings tokens that represents an arithmetic expression in a Reverse Polish Notation.

Evaluate the expression. Return an integer that represents the value of the expression.

Note that:

The valid operators are '+', '-', '*', and '/'.
Each operand may be an integer or another expression.
The division between two integers always truncates toward zero.
There will not be any division by zero.
The input represents a valid arithmetic expression in a reverse
polish notation.
The answer and all the intermediate calculations can be
represented in a 32-bit integer.

This question is also very basic and is rated medium on leetcode, It is very basic question we just have to evaluate postfix notation.

Refer the examples given below for better understanding

Approaches

Iterate over all characters one by one.
If character is operand push it in the stack.
If character is operator pop two elements from start and perform operation.

Solution

We have achieved this solution by following ways:

Initialise a stack to store the result.
Iterate over the tokens vector.
Check if first character of token is digit, then check if it has atleast 2 characters and negative and second character must be digit.
If any of above is true convert string to int and push it in stack.
Else if the character is an operator, There are two operands at top of stack value 1 and value 2.
Since token is an operator now based on operator check the case and push the value.
The final result is at top of the stack.

I hope the solutions I have provided are understandable and explanations are easy to understand.

Thank You

You can connect with me on Linkedin

Leetcode Solution #5

Abhinav Yadav — Sat, 14 Sep 2024 19:26:15 +0000

1. Unique Email Addresses

The Problem

Start by reading the description of the problem,

Every valid email consists of a local name and a domain name, separated by the '@' sign. Besides lowercase letters, the email may contain one or more '.' or '+'.

For example, in "alice@leetcode.com", "alice" is the local name, and "leetcode.com" is the domain name.
If you add periods '.' between some characters in the local name part of an email address, mail sent there will be forwarded to the same address without dots in the local name. Note that this rule does not apply to domain names.

For example, "alice.z@leetcode.com" and "alicez@leetcode.com" forward to the same email address.
If you add a plus '+' in the local name, everything after the first plus sign will be ignored. This allows certain emails to be filtered. Note that this rule does not apply to domain names.

For example, "m.y+name@email.com" will be forwarded to "my@email.com".
It is possible to use both of these rules at the same time.

Given an array of strings emails where we send one email to each emails[i], return the number of different addresses that actually receive mails.

The description might look big and scary but believe me question is
not that scary when it comes to the implementation, basically the question is saying

An email is divide into two parts the part before @ is called local name, the part after @ is called domain name.
In the question we have to handle following cases:

Dots (.) in the local name can be ignored.
Everything after the first plus sign (+) in the local name is discarded.
The domain name is not altered by dots or plus signs. It is used as is.

3.Two email addresses are considered the same if, after applying the above rules, they are identical.

4.You need to count how many unique addresses there are after applying these rules.

Looks easy isn't it.

Refer the example for better understanding,

Approach

Our approach for this question is going to be pretty straightforward,

Find @ symbol divide the email in local name and domain name.
Find '+' and '.' sign in local name and process it.
Merge the local and domain name together and give the answer.

Solution

We have achieved this solution by following ways,

Declare an unordered set unique to store the final answer.
Traverse the string and find the @ symbol.
When you find @ divide the part before @ as local name and part after that as domain name.
Declare a variable processedLocal as string datatype.
Traverse LocalName, if you find '+' symbol break because we have to ignore the values after + and if you find '.' symbol ignore it and add the rest of string in processedLocal variable.
Declare a string final where we give merged email of processedLocal, @ and domain Name.
Insert the final into the set unique.
Return the size of unique.

2. Remove Element

The Problem

Start by reading the description of problem

Given an integer array nums and an integer val, remove all occurrences of val in nums in-place. The order of the elements may be changed. Then return the number of elements in nums which are not equal to val.

Consider the number of elements in nums which are not equal to val be k, to get accepted, you need to do the following things:

Change the array nums such that the first k elements of nums contain the elements which are not equal to val. The remaining elements of nums are not important as well as the size of nums.
Return k.

Question is pretty straight forward and easy we just have to remove a given element from an array and return the size of the array after removing it, the only catch is that the positions will change.

Refer the examples for better understanding,

Approach

The approach to solve this question is short and pretty straight forward,

Iterate the array
Check and move valid elements

Solution

Steps to achieve this solution is as follows,

Initialise the variable index with 0 to keep track of position where next valid element should be placed.
Iterate through the vector.
Check if current element equal to value if not move it to position indicated by index and then increment the index to update next position.
Return index.

3.Group Anagrams

The Problem

Start by reading the description

Given an array of strings strs, group the anagrams together. You can return the answer in any order.

Well, I this time I guess question is understandable by description only.

Refer to example for better understanding.

Approach

Use hashmap to map each sorted string.
Sort the string.
Group by sorted string.
Add groups to result.
Return result.

Solution

Initialise a result vector this will store final grouped anagram.
Initialise a hash map to map sorted string to a vector of original strings that are anagrams of that key.
Loop through each string in input vector.
Sort the strings as it helps in identifying anagrams.
Add original string to vector associated with its sorted version in hashmap. This groups all anagrams together under same key.
Iterate through hashmap and add each group of anagrams to result vector.
Return result.

I hope the solutions I have provided are understandable and explanations are easy to understand.

Thank You

You can connect with me on Linkedin

Leetcode Solution #4

Abhinav Yadav — Fri, 13 Sep 2024 11:54:00 +0000

1. Replace Elements with Greatest Element on Right Side

The Problem

Start by reading the description of the problem,

Given an array arr, replace every element in that array with the greatest element among the elements to its right, and replace the last element with -1.

After doing so, return the array.

This is a leetcode easy and pretty basic question as it is written in the question we have to replace every element in the array with greatest element to the right side of those elements and we have to replace the last element with -1.

Refer the example for better understanding,

Approach

Our approach for this question is going to be pretty straightforward,

We will initialise last element as maximum.
Set the last element as -1, because there won't be anything in right of last element.
Traverse the array from right to left and return the maximum elements.

Solution

We have achieved the solution in following steps,

Initialise max variable to last element of array. This will track for the maximum element when we traverse from right to left.
Set last element as -1 as there are no elements right to it.
Traverse from second last element because last has already been set to -1.
Store max into a temporary variable temp because we need to update it.
If current element is greater than max update the value to current value.
Current element is replaced with temp, which held value of max element.
Return arr.

2. Is Subsequence

The Problem

Given two strings s and t, return true if s is a subsequence of t, or false otherwise.

A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).

This question is also pretty basic and straightforward you have to check if string s is subsequence of t. If it is return true else return false.

Refer to example for better understanding,

Approach

The approach for this question is also not that special, we just have to keep check of some base and recursive cases, lets jump to the solution its very easy to understand this question through solution.

Solution

We approached the solution by following steps,

Declare a helper function subsequence first with parameters string s and t (we have to compare between these strings) and variable m and n as length of these strings.
Check for base cases if s is traversed completely i.e. m==0, return true because it means we have matched all the characters of s.
If t is completely traversed return false because s still have unmatched characters.
If last characters of s and t are equal move both m and n to next character.
If current character mismatch skip current character in t by reducing n and keep m unchanged, checking if s can still be a subsequence of the remaining part of t.
Now in main function isSubsequence if length of m>n return false.
Otherwise, call the recursive Subsequence function to determine if s is a subsequence to t.

3. Length of Last Word

The Problem

Given a string s consisting of words and spaces, return the length of the last word in the string.

A word is a maximal substring consisting of non-space characters only.

This question is also leetcode easy and pretty basic, all we have to do is just to find the length of last word.

Refer the example for the better understanding,

Approach
We can approach this question in following way:

Traverse the string from last character.
Check if the last character is alphabetical or not.
Return the length.

Solution

We reached this solution by following steps,

Declare variable count that will hold length of last word.
Declare a bool flag to track when we start counting characters of last word. It will be initialised as false.
Iterate from right to left.
Use if condition to check if current character is alphabet or not.
When we encounter a letter flag turns to true indicating that we are counting.
Increment count.
If we encounter space after starting last word it means we have finished counting, return the count.
If no space encountered after last word, return count.

I hope the solutions I have provided are understandable and explanations are easy to understand.

Thank You

You can connect with me on Linkedin

Leetcode Solutions #3

Abhinav Yadav — Thu, 12 Sep 2024 18:44:53 +0000

1. Top K Frequent Elements

The Problem

First read the description of problem:

Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order.

Question is leetcode rating medium but is pretty basic when it comes to implementation.

Refer to the examples below

Approach

Approach is also very basic just like the question:

Use map to count the frequency of the elements.
Make a key value pair of elements.
Return the elements according to the question.

Solution

In the solution we have done the following things,

Use an unordered map to count and store frequency of each number.
Initialise a vector named bucket with n+1 empty vector. This will group elements with their frequency.
Iterate over the map and extract elements and their frequency.
Add elements to this bucket corresponding to its frequency. This groups elements by their frequency.
Declare a vector result to store final list.
Iterates backward to process bucket with higher frequency first.
Check for elements in bucket and iterate over each element in bucket.
Add current element in result vector and decrease remaining element.
Return result.

2. Product of Array Except Self

The Problem

Firstly read the description of problem:

Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i].

The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.

You must write an algorithm that runs in O(n) time and without using the division operation.

Question is pretty understandable from its statement only, we have to multiply the elements of the array except the element itself.
The only catch is we have to do this without doing division and in O(n) time complexity.

Here is the example for better understanding,

Approach

Approach is pretty basic here also we just have to make two passes over the array,

Left Pass: In first pass, it multiplies each element by product of all elements to the left of each index.
Right Pass: In second pass, it multiplies each element by product of all elements to right of the index.

Solution

In this solution we have,

Creates a vector result of size n to store final product.
Initialises first element of result to 1, because there are no elements to left of first element.
Start iterating through nums array.
For each index is this calculates the product of all elements to left of i and stores it in result[i] is product of result[i-1] and nums[i-1].
Initialise a variable right_product to store product of elements to right of each index. Set it to 1 because there are no elements to right of last element.
This loop iterates through nums in reverse order.
At each index i, it multiplies the current value of result[i] by right_product.
Update right_product by multiplying it with the current elements nums[i]. This allows right_product to hold the product of all elements to right of next elements.
Return result.

I hope the solutions I have provided are understandable and explanations are easy to understand.

Thank You

You can connect with me on Linkedin

Leetcode Solutions #2

Abhinav Yadav — Wed, 11 Sep 2024 17:24:58 +0000

1. Sort List

The Problem

First read the description of problem:

Given the head of a linked list, return the list after sorting it in ascending order.

So here, basically we have to return the linked list after sorting it in ascending order.

Approach

There are a lot of ways to solve this question but one of the easiest and optimal way is to implement the merge sort in this problem. We will follow the following steps to implement the merge sort here:

Find the middle of the list
Split the list
Merge it
Sort and Return the list

Basically the same procedure which we follow for merge sort.

Solution

In the solution we have done the following things,

We have declared a function to find the middle value of the list, here we are using slow and fast pointer to find it, slow pointer will point to next of head and fast will be ahead of slow, so when fast will exit the list , slow will reach the middle of list.
Now declare a merge function to merge the list, create a dummy node to help easily build the merge list, tail is pointer to track end of merge list.
Compare l1 and l2 values, the smaller node append to next of tail and move pointer in that list. Move tail to its next.
If one list gets exhausted before the other, append remaining nodes from non empty list to next of tail.
Return merged list.
Now, in sortList function use findMiddle function to get the middle node of list, split the list into two by making next of middle null.
Recursively sort both the halves.
Merge the list and return it.

2. Add 1 to a Linked List Number

The Problem

Firstly read the description of problem:

You are given a linked list where each element in the list is a node and have an integer data. You need to add 1 to the number formed by concatinating all the list node numbers together and return the head of the modified linked list.

So, in this question we have to take the nodes of a linked list together as a number and add 1 to it.

Approach

For adding 1 to given number we have to keep in mind that we have to handle the carry also so for that:

Recursively traverse to the end of LL, accumulating carry.
Handle the carry recursively.
Add carry to current node value and update it.

Solution

In this solution we have,

Declare a function addWithCarry which handles the carry that results from addition.
Add data of current node to carry returned from recursive call on next node. This give total sum with carry.
Update current node data to last digit of result, handling the carry for current node.
Return carry for next node.
In addOne function call addWithCarry to add one to the number and handle any carry.
If there is a carry left after processing all nodes, create a new node with carry value.
Set this new node's next to current head and return new node.
If there is no carry left return original head.

I hope the solutions I have provided are understandable and explanations are easy to understand.

Thank You

You can connect with me on Linkedin

Leetcode Solutions #1

Abhinav Yadav — Tue, 10 Sep 2024 18:39:45 +0000

1. Longest Common Prefix

The Problem

Let's read the description first:

Write a function to find the longest common prefix string amongst an array of strings.
If there is no common prefix, return an empty string "".

Question is not that hard to understand from the description in this question you have to check for the longest common prefix among a given array of string. If there is no common prefix just simply return "".

Refer to the examples given below:

Approach

Basic approach here should be that when we have to find something common among a set of items, we compare the first item with others. Similarly here we will use the same kind of approach in following steps:

Set the first string as the prefix.
Compare the first string with all other given strings.
Keep reducing the length of string to find the common prefix.

Solution

In the solution,

Set the first string of the vector strs as the prefix.
Iterate through the remaining string using for loop.
While loop checks if the current string starts with the current prefix. If not the loop will run.
If prefix is not found prefix.substr(0, prefix.length()-1) this will trim one character from the end and creates a new string from starting to second last character of prefix.
If prefix not found even after trimming return "".
Else return prefix.

2. Sort Characters By Frequency

The Problem

Let's Read the description first:

Given a string s, sort it in decreasing order based on the frequency of the characters. The frequency of a character is the number of times it appears in the string.

Return the sorted string. If there are multiple answers, return any of them.

The description is pretty basic and understandable about what we need to achieve in this question.

Refer to the examples given below:

Approach

This question is pretty basic approach wise, we can do this in the following steps:

Create an unordered map to record the frequencies of characters.
Make character frequency pair of every character appearing in the string.
Sort the string and return the result.

Solution

In the solution,

I have declared an unordered map frq that will store characters as key and their frequencies as values.
Use for loop to iterate over each character in the given string and record their frequencies.
A vector of pairs freqpair is created using the elements from the frq map. Each element in the freqpair vector contains a character and its frequency as a pair. The map is transformed into a vector to allow sorting based on the frequency.
I have used basic bubble sort for the sorting purpose.
Declare a for loop that goes through the sorted freqpair vector. For each pair p, it appends the character to the result string, repeated p.second times.
Return result.

String to Integer (atoi)

The Problem

Let's Read the description first:

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer.

The algorithm for myAtoi(string s) is as follows:

Whitespace: Ignore any leading whitespace (" ").
Signedness: Determine the sign by checking if the next character is '-' or '+', assuming positivity is neither present.
Conversion: Read the integer by skipping leading zeros until a non-digit character is encountered or the end of the string is reached. If no digits were read, then the result is 0.
Rounding: If the integer is out of the 32-bit signed integer range [-231, 231 - 1], then round the integer to remain in the range. Specifically, integers less than -231 should be rounded to -231, and integers greater than 231 - 1 should be rounded to 231 - 1.

Return the integer as the final result.

In my opinion, this question just looks scary but is very easy to deal with just ignore the description and focus on the part that you have to convert a string to integer with some conditions like:

There should not be any leading whitespaces.
Check for the signs that the character is '-' or '+'.
Check for the non digit characters, if you encounter non digit character you have to stop reading.
Handle the integer overflow.

Refer to the examples below:

Approach

There is nothing special going to be with the approach you just have to look out for the conditions mentioned in the description and convert the string to int. Let's go to the solution.

Solution

In the solution,

Declare and initialize three variable index(to traverse string s), num(to store the resultant integer), negative(to check whether number is negative or not).
Use while loop to check for any leading whitespace, the function isspace checks if the current character is whitespace. Loop will continue until a non whitespace character is found.
Now, we will check for the sign if the current character is '-' or '+' sign. If character is '-' sign the negative is set to be true and index is incremented to move past the sign.
Here, this while loop continues until it encounters a non-digit character. int digit = s[index] - '0' converts the character at a particular index from its ASCII value to numeric value.
This if statement checks for overflow. If adding the next digit would cause num to exceed the 32-bit signed integer limit (INT_MAX), the function returns the appropriate value.
If there is no overflow, current digit is added to num. The number is updated by multiplying num by 10 and adding the value of the current digit. The index is then incremented to move to the next character.
After processing all digits if negative is true, num is made negative by multiplying by -1.
Now return num.

I hope the solutions I have provided are understandable and explanations are easy to understand.

Thank You

You can connect with me on linkedin

Blockchain Beyond Crypto: Real-World Applications

Abhinav Yadav — Wed, 07 Aug 2024 15:27:58 +0000

Usually when people hear the term "blockchain", they usually get the thought of cryptocurrencies like Bitcoin and Ethereum. However, blockchain extends beyond digital currencies. Its unique features—decentralisation, transparency, and immutability—are driving innovation across various industries. In this blog, we'll explore some fascinating real-world applications of blockchain that might surprise you.

Table Of Content

What is Blockchain?
Supply Chain Management
Healthcare
Voting Systems
Real Estate

What is Blockchain?

Before going straight towards the application of blockchain, let's briefly explain what blockchain is. Imagine a digital ledger that records transactions across many computers in a way that ensures the data's integrity and security. Each "block" of data is linked to the previous one, forming a "chain"—hence the name blockchain. This technology eliminates the need for intermediaries, reduces fraud, and increases transparency.

Supply Chain Management

How Does It Work?

Blockchain is capable of tracking the journey of products from its origin to final destination. Each step in the supply chain is recorded on the blockchain, creating an immutable record.

Why Is It Important?

Transparency about the origin of product is the priority for consumer. Blockchain helps verify the authenticity of goods, such as organic food or luxury items, by providing an unalterable record of their journey.

Interactive Element: Imagine you're buying a diamond ring. With blockchain, you can scan a QR code to see the diamond's entire history—from the mine to your finger. Wouldn't that make your purchase feel more secure and trustworthy?

Healthcare

How Does It Work?

Blockchain can store patient records securely, ensuring that they are accessible only to authorised parties. Each update to a patient's record can be logged in the blockchain, providing a complete history.

Why Is It Important?

In emergencies, quick access to accurate medical records can save lives. Blockchain ensures that records are up-to-date and tamper-proof, reducing the risk of errors.

Interactive Element: Think about a world where you control your medical data. You could grant temporary access to your records to a new doctor with just a few clicks. How would this change your experience with healthcare?

Voting Systems

How Does It Work?

Blockchain-based voting systems allow citizens to cast their votes digitally. Each vote is recorded on the blockchain, making it nearly impossible to alter or delete.

Why Is It Important?

Election integrity is a global concern. Blockchain can make elections more secure, transparent, and accessible, increasing trust in democratic processes.

Interactive Element: Picture participating in an election where you can vote from the comfort of your home, and instantly verify that your vote has been counted correctly. How might this increase voter turnout and trust in the system?

Real Estate

How Does It Work?

Property transactions can be recorded on the blockchain, simplifying the process of buying and selling real estate. Smart contracts can automate and enforce the terms of agreements.

Why Is It Important?

Buying a house typically involves a lot of paperwork and intermediaries. Blockchain can streamline the process, reduce costs, and ensure that records are accurate and easily accessible.

Interactive Element: Imagine being able to buy or sell property without the need for endless paperwork and multiple intermediaries. How would this change your experience with real estate transactions?

Conclusion

Blockchain technology is revolutionizing various sectors by providing security, transparency, and efficiency. Its applications extend far beyond cryptocurrencies, offering solutions to some of the world's most pressing problems. From enhancing supply chain transparency to securing election integrity, blockchain is paving the way for a more reliable and efficient future.

Happy Learning !

Please do comment below if you like the content or not

Have any questions or ideas or want to collaborate on a project, here is my linkedin