DEV Community: vishal.codes

Day 43/366

vishal.codes — Mon, 27 May 2024 07:32:53 +0000

🚀 Today's Learning:

🌟 DSA

calculate the largest subarray sum
print the subarray with the largest sum

🌟 Dev

JWT Authorization

🔍 Some Key Highlights:

DSA

To calculate the largest subarray sum, we use Kadane's Algorithm. We initialize two variables, maxCurrent and maxGlobal, with the first element of the array. We then iterate through the array starting from the second element. For each element, we update maxCurrent to be the maximum of the current element and the sum of maxCurrent and the current element. This step ensures that we are either starting a new subarray at the current element or continuing the existing subarray. We then update maxGlobal to be the maximum of maxGlobal and maxCurrent. By the end of the iteration, maxGlobal holds the largest sum of any subarray within the given array.

To print the subarray with the largest sum, we use a similar approach with Kadane's Algorithm, but with additional tracking of the start and end indices of the subarray. We initialize variables for the current and global maximums, and for the start and end indices. As we iterate through the array, we update maxCurrent in the same way, but also track when we start a new subarray by recording the current index as the start. If maxCurrent exceeds maxGlobal, we update maxGlobal and set the start and end indices to the current tracked start and current index, respectively. After completing the iteration, we print the subarray that starts at the recorded start index and ends at the recorded end index, which represents the subarray with the largest sum.

#100daysofcode #1percentplusplus #coding #dsa

Day 42/366

vishal.codes — Sun, 12 May 2024 20:32:15 +0000

🚀 Today's Learning:

🌟 DSA

Print all subsequences/Power Set
Generate all binary strings

🌟 Dev

Use of postman for API testing

🔍 Some Key Highlights:

DSA

To print all subsequences or the power set of a given set, you'd typically use a recursive approach. Starting with an empty subsequence, you'd iterate through each element in the set. At each step, you have two choices: either include the current element in the subsequence or exclude it. You continue this process recursively, generating subsequences that include or exclude each subsequent element. The base case occurs when you've processed all elements, at which point you print or store the generated subsequence. By exploring all possible combinations, you effectively generate all subsequences or the power set of the original set.

For generating all binary strings of length n, you can employ a similar recursive strategy. Starting with an empty string of length n, you'd explore each position in the string. At each position, you can either append '0' or '1'. You continue this process recursively until you've filled all n positions in the string. Once you've reached the base case (when all positions are filled), you print or store the generated binary string. By systematically exploring all possible combinations of '0' and '1' at each position, you generate all binary strings of length n.

DEV

Using Postman for API testing simplifies the process by providing a user-friendly interface for sending requests to an API endpoint and analyzing the responses. Much like sending a request through a web browser, you can input the endpoint URL, select the HTTP method (such as GET, POST, PUT, DELETE, etc.), and include any required headers, parameters, or body content. Postman allows you to organize requests into collections, making it easy to manage and run tests for different APIs or endpoints. Additionally, you can set up and automate workflows by chaining requests together, defining variables, and writing tests to verify the correctness of the responses. Postman's features, including environment variables, pre-request scripts, and test scripts, streamline the testing process and facilitate collaboration among team members. Overall, Postman serves as a comprehensive tool for API testing, offering a range of functionalities to ensure the reliability and functionality of APIs.

#100daysofcode #1percentplusplus #coding #dsa

Day 41/366

vishal.codes — Sat, 11 May 2024 16:23:18 +0000

🚀 Today's Learning:

🌟 DSA

Check if an array represents a min-heap or not
Convert min Heap to max Heap

🌟 Dev

pymongo library

🔍 Some Key Highlights:

DSA

To check if an array represents a min-heap, iterate through each parent node starting from the last non-leaf node towards the root. At each step, compare the parent node with its children. If any child is smaller than the parent, it violates the min-heap property, indicating that the array doesn't represent a min-heap. If no violation is found, the array is a min-heap.

To convert a min heap to a max heap, begin by swapping the positions of the parent node and its largest child if any child is greater than the parent. Then, recursively perform this swap operation for each subtree until the entire heap satisfies the max-heap property. This process effectively transforms the min heap into a max heap.

DEV

The PyMongo library is a Python driver for MongoDB, enabling interaction with MongoDB databases from Python applications. It provides a simple and intuitive interface for performing various operations such as inserting, updating, querying, and deleting documents in MongoDB collections. With PyMongo, you can establish connections to MongoDB servers, access databases and collections, and execute commands and queries efficiently. Its design aligns with Python's philosophy, making it easy for developers to work with MongoDB databases seamlessly within their Python projects.

#100daysofcode #1percentplusplus #coding #dsa

Day 40/366

vishal.codes — Fri, 10 May 2024 15:07:41 +0000

🚀 Today's Learning:

🌟 DSA

Remove outermost parenthesis
Palindrome check

🌟 Dev

Asynchronous behaviour of NodeJS

🔍 Some Key Highlights:

DSA

In the "Remove outermost parenthesis" code, we iterate through each character of the input string, keeping track of the count of open and close parentheses. We only add characters to the result string if they are not the outermost parentheses. The outermost parentheses are identified by the count of open and close parentheses being equal and the count being zero at the end.

For the "Palindrome check" code, we compare characters from the beginning and end of the input string simultaneously, moving inward until we reach the middle. If at any point the characters don't match, we conclude that the string is not a palindrome. If all characters match, the string is a palindrome.

DEV

In Node.js, asynchronous behavior allows tasks to be executed concurrently without waiting for previous tasks to complete. This is achieved using non-blocking I/O operations and event-driven architecture. When a task requiring I/O operation is encountered, Node.js delegates it to the system, and meanwhile, continues executing other tasks. Once the I/O operation is completed, a callback function is triggered to handle the result. This asynchronous model ensures efficient utilization of system resources and enables Node.js to handle large numbers of concurrent connections effectively.

#100daysofcode #dsa #coding

Day 39/366

vishal.codes — Thu, 09 May 2024 19:15:40 +0000

🚀 Today's Learning:

🌟 DSA

Find an element in a sorted array
Find a peak element in an array

🌟 Dev

JWT (JsonWebToken)

🔍 Some Key Highlights:

DSA

To find the single element in a sorted array, you'd employ a binary search approach. You'd begin by examining the middle element and check if it's the single element. If it's not, you'd determine which half of the array to search based on whether the adjacent elements are equal or not. You continue this process until you find the single element, updating your search range accordingly.

For finding a peak element in an array, you'd also utilize a binary search strategy. You'd check the middle element and examine its neighboring elements to determine if it's a peak. If it's not, you'd move towards the direction of the higher adjacent element, as the array must have at least one peak. This process continues until a peak element is found.

DEV

JWT (JSON Web Token) authentication works by creating a token containing encoded information about the user, such as their identity and any relevant permissions. This token is signed with a secret key known only to the server. When a user logs in or performs an action that requires authentication, the server generates a JWT and sends it back to the client. The client then includes this token in subsequent requests, typically in the Authorization header. Upon receiving a request with a JWT, the server verifies the token's signature using the secret key. If the signature is valid, the server extracts the user information from the token and processes the request accordingly. This process allows for stateless authentication, as the server does not need to store user sessions.

#100daysofcode #1percentplusplus #coding #dsa

Day 38/366

vishal.codes — Wed, 08 May 2024 18:15:39 +0000

🚀 Today's Learning:

🌟 DSA

Insert a node in DLL
Delete a node in DLL

🌟 Dev

FastAPI

🔍 Some Key Highlights:

DSA

To insert a node in a Doubly Linked List (DLL), you typically start by creating a new node with the provided data. Then, if the DLL is empty, you make the new node both the head and tail of the list. Otherwise, you update the pointers of the new node to point to the current head as its next node and NULL as its previous node. You then update the previous pointer of the current head to point to the new node. Finally, you set the new node as the new head of the list. This way, the new node is inserted at the beginning of the DLL, maintaining its connectivity.

Deleting a node from a Doubly Linked List (DLL) involves several steps. First, you locate the node to be deleted by traversing the list until you find it. Once found, you adjust the pointers of the neighboring nodes to bypass the node to be deleted. Specifically, you make the previous node point to the next node of the node to be deleted, and you make the next node point to the previous node of the node to be deleted. Additionally, if the node to be deleted is the head or tail of the DLL, you update the head or tail pointers accordingly. Finally, you free the memory allocated to the node to be deleted. This process ensures the integrity of the DLL structure after the deletion operation.

DEV

FastAPI is a web framework for building APIs with Python, designed for speed, simplicity, and type safety. It leverages Python's type hints for automatic data validation and documentation generation. When using FastAPI, you typically define API endpoints by creating functions decorated with specific route decorators, such as @app.get() for GET requests or @app.post() for POST requests. These functions typically receive parameters representing data from the request, process it as needed, and return data to be sent as the response. FastAPI automatically handles serialization and deserialization of data to and from JSON, making it straightforward to work with JSON-based APIs. Additionally, FastAPI provides built-in support for features like dependency injection, middleware, and automatic generation of interactive API documentation using Swagger UI or ReDoc. Overall, FastAPI simplifies the process of building high-performance APIs in Python while ensuring type safety and robust documentation.

#100daysofcode #1percentplusplus #coding #dsa

Day 37/366

vishal.codes — Tue, 07 May 2024 18:16:32 +0000

🚀 Today's Learning:

🌟 DSA

Greedy algorithm to find minimum number of coins
Valid Paranthesis Checker

🌟 Dev

Benefits of NodeJS

🔍 Some Key Highlights:

DSA

The greedy algorithm for finding the minimum number of coins works by iteratively selecting the largest coin denomination that is less than or equal to the remaining amount needed to make change. It continues this process until the remaining amount becomes zero. At each step, it selects the largest possible coin denomination, ensuring the minimum number of coins is used to make the change.

A valid parenthesis checker algorithm works by iterating through each character in the given string representing parentheses. It utilizes a stack data structure to keep track of the opening parentheses encountered. When an opening parenthesis is encountered, it is pushed onto the stack. When a closing parenthesis is encountered, it checks if the stack is empty or if the top of the stack contains the corresponding opening parenthesis. If either condition is not met, the parentheses are not valid. After processing all characters, if the stack is empty, the parentheses are valid; otherwise, they are not.

DEV

Node.js offers several benefits for developers. Firstly, it allows for asynchronous, event-driven programming, which is particularly useful for handling I/O operations efficiently. This means Node.js can handle a large number of concurrent connections without blocking, making it ideal for building real-time applications like chat applications or streaming services. Secondly, Node.js utilizes JavaScript, a language familiar to many developers, both on the front end and the back end. This allows for code reuse and easier collaboration between front-end and back-end teams. Additionally, Node.js has a vast ecosystem of libraries and packages available through npm (Node Package Manager), which speeds up development by providing ready-to-use solutions for common tasks. Finally, Node.js is lightweight and scalable, making it suitable for building microservices architectures and deploying applications to cloud platforms. Overall, Node.js offers flexibility, performance, and a thriving community, making it a popular choice for building modern web applications.

#100daysofcode #1percentplusplus #coding #dsa

Day 36/366

vishal.codes — Mon, 06 May 2024 18:33:11 +0000

🚀 Today's Learning:

🌟 DSA

Implement queue using stack

Reverse a queue using recursion

🌟 Dev-
Tailwind css library

Some Key highlights:

DSA

To implement a queue using a stack, you can utilize two stacks. One stack will be used for enqueue operations, while the other will handle dequeue operations. For enqueue, simply push elements onto the first stack. When dequeuing, if the second stack is empty, transfer all elements from the first stack to the second. Then, pop from the second stack. This way, the oldest element in the queue will always be at the top of the second stack for dequeue operations.
To reverse a queue using recursion, you can recursively dequeue each element from the original queue until it's empty, storing each element. Then, recursively enqueue these elements back into the queue. This process effectively reverses the order of elements in the queue using recursion, maintaining its FIFO (First In, First Out) property.

DEV

Tailwind CSS is a utility-first CSS framework that streamlines web development by providing a comprehensive set of pre-designed utility classes. Instead of creating custom CSS rules for individual elements, Tailwind encourages developers to apply these utility classes directly in HTML markup. This approach promotes consistency and rapid prototyping by abstracting common styling patterns into reusable classes. With Tailwind, you can quickly style elements by applying classes like bg-blue-500 for background color, text-lg for text size, or p-4 for padding. This methodology facilitates responsive design, as classes can be easily modified with breakpoints (e.g., md:bg-red-500 for medium-sized screens). Overall, Tailwind CSS simplifies the styling process, allowing developers to focus on building robust and visually appealing user interfaces efficiently.

#100daysofcode

Day 35/366

vishal.codes — Sun, 05 May 2024 15:49:46 +0000

🚀 Today's Learning:

🌟 DSA

Longest increasing subsequence
Selecting stock

🌟 Dev

Styled components library

🔍 Some Key Highlights:

DSA

To find the longest increasing subsequence, the algorithm iterates through each element in the sequence, keeping track of the length of the longest increasing subsequence ending at that element. It does this by comparing the current element with all previous elements, updating the length if the current element is greater and has a longer subsequence. The overall longest increasing subsequence length is the maximum of these lengths across all elements.

For selecting stocks, the algorithm analyzes each stock's price and its potential for profit. It iterates through the prices, keeping track of the minimum price seen so far and the maximum profit that can be made by buying at that minimum price and selling at the current price. It updates these values as it progresses through the prices, ultimately returning the maximum profit possible.

DEV

Styled Components is a library for styling React components with JavaScript and CSS. It allows developers to write CSS in JavaScript files using tagged template literals. This approach enables scoped styles, where styles are encapsulated within the component, preventing them from affecting other components. Styled Components simplifies the process of creating reusable and maintainable UI components by allowing developers to define styles directly within their component code. Additionally, it supports dynamic styling based on props and theming, making it a powerful tool for building responsive and customizable user interfaces in React applications.

#100daysofcode

Day 34/366

vishal.codes — Sat, 04 May 2024 18:20:42 +0000

🚀 Today's Learning:

🌟 DSA

Is Perfect square
Search in a rotated array

🌟 Dev

Redux for state management

🔍 Some Key Highlights:

DSA

To determine if a given number is a perfect square, the algorithm iteratively narrows down the search range by dividing the number by 2 and checking if the square of the midpoint is equal to the target number. This process continues until the search range is sufficiently small or until the square of the midpoint matches the target number. If a match is found, the algorithm returns true; otherwise, it returns false, indicating that the number is not a perfect square.

For searching in a rotated sorted array, the algorithm follows a binary search approach. It first identifies the pivot point where the array was rotated, dividing the array into two sorted halves. Then, it applies binary search separately on each half, adjusting the search range based on whether the target value falls within the sorted range of the current half. This process continues until the target value is found or until the search range becomes empty, indicating that the target value is not present in the array.

DEV

Redux is a predictable state container for JavaScript apps, commonly used with React. It provides a centralized store to manage the state of an application and facilitates predictable state mutations through actions. The Redux pattern involves defining actions to describe state changes, reducers to specify how those actions modify the state, and a store to hold the application state. When an action is dispatched, it flows through the reducers, which update the state accordingly. Components can subscribe to the store to receive updates when the state changes, ensuring a single source of truth for the application's data and enabling efficient management of complex state logic.

#100daysofcode #1percentplusplus #coding #dsa

Day 33/366

vishal.codes — Fri, 03 May 2024 15:38:43 +0000

🚀 Today's Learning:

🌟 DSA

Reverse words in a given string
Longest common prefix

🌟 Dev

SSR vs CSR

🔍 Some Key Highlights:

DSA

To reverse words in a given string, start by splitting the string into words. Then, iterate through the words in reverse order and append them to form the reversed string, ensuring to add spaces between words. Finally, return the reversed string. This process effectively flips the order of words while maintaining their individual characters' order within each word.

For finding the longest common prefix among an array of strings, first, set the prefix as the first string in the array. Then, iterate through the remaining strings and compare each character of the prefix with the corresponding character of the current string. If there's a mismatch or if the prefix length exceeds the length of the current string, trim the prefix accordingly. Repeat this process until the prefix is the longest common prefix among all strings in the array, then return the prefix.

DEV

Server-Side Rendering (SSR) involves rendering the web page on the server and sending a fully rendered page to the client. When a user requests a page, the server processes the request by executing the JavaScript code and generating the HTML content to be sent back to the browser. This approach provides faster initial load times and better SEO because search engine crawlers can easily parse the HTML content.

Client-Side Rendering (CSR), on the other hand, involves sending a minimal HTML document to the client, which includes links to JavaScript and CSS files. The browser then downloads these files and executes the JavaScript code to render the page dynamically. This approach provides a smoother and more interactive user experience, as the page can update without full page reloads. However, initial load times may be slower, and SEO can be more challenging since search engine crawlers may not execute JavaScript.

#100daysofcode #1percentplusplus #coding #dsa

Day 32/366

vishal.codes — Thu, 02 May 2024 17:34:43 +0000

🚀 Today's Learning:
🌟 DSA

Check whether two Strings are anagram of each other
Print all anagrams together

🌟 Dev

Redux Persist

🔍 Some Key Highlights:

DSA

To check whether two strings are anagrams of each other, iterate through each character of both strings, counting the frequency of each character in each string using a hashmap. Then, compare the frequency maps of both strings. If the maps are identical, the strings are anagrams; otherwise, they are not.

To print all anagrams together, create a hashmap where the keys are sorted versions of each word in the input list, and the values are lists of words that are anagrams of each other. Iterate through the input list of words, sorting each word and using the sorted word as a key to group anagrams together in the hashmap. Finally, iterate through the hashmap and print each list of anagrams together.

DEV

Redux Persist is a library used in Redux-based applications to persist the Redux state to storage, typically AsyncStorage in React Native or localStorage in web applications. It allows the state to be saved across browser or app restarts, ensuring a seamless user experience. Redux Persist works by integrating with the Redux store and providing middleware that automatically saves the state to storage whenever it changes. Upon app or browser restart, the persisted state is retrieved from storage and rehydrated into the Redux store, allowing the application to resume from where it left off. This library simplifies the process of implementing persistence in Redux applications, enhancing reliability and user satisfaction.

#100daysofcode #1percentplusplus #coding #dsa