DEV Community: keshav jha

[Boost]

keshav jha — Tue, 31 Dec 2024 13:52:01 +0000

Seeking Opportunities as a Software Engineer

keshav jha — Tue, 17 Sep 2024 12:50:56 +0000

Hello Dev.to community,

I hope this post finds you all in great spirits!

I'm excited to share that I’m currently on the lookout for new opportunities as a Software Engineer. Over the past 3+ years, I’ve had the chance to work on a variety of intriguing projects, and I’d love to take this opportunity to reflect on my journey and the skills I bring to the table.

A Journey Through Innovation

My career has taken me through a range of experiences:

Advanced Trading Solutions: I contributed to the development of an advanced trading solution for Kotak Securities, enhancing their FinTech offerings.
Travel Management Platform: At Sita.in, I helped build a modular UI that streamlined their travel management platform, driving operational efficiency.
Social Media Application: Most recently, I led the end-to-end development of a social media platform focused on vision boards, akin to Pinterest. This project allowed me to leverage my full stack skills, including integrating machine learning for NSFW moderation and text-to-image AI generation.

Skills and Expertise

Here’s a snapshot of the technologies and methodologies I’ve been working with:

HTML5, CSS3, Talwindcss, SCSS, JavaScript, Typescript, Node.Js, Prisma.JS, React, Zustand, Redux, Redux Saga, Next.JS, Svelte, Sveltekit, GIT, AWS, Azure, Go(Golang), SQL, RabbitMQ, REST APIs.

My experience spans creating scalable solutions, delving into cloud technologies, and building robust event-driven architectures. I’m passionate about crafting efficient, scalable solutions and continuously learning to stay at the cutting edge of technology.

What I’m Looking For

I am eager to connect with teams and projects that are driven by innovation and creativity. Whether you're looking for a full-time engineer or a contract-based role, I am open to exploring various opportunities where I can contribute my skills and grow further.

Let’s Connect

If you’re interested in discussing potential opportunities or just want to chat about technology and development, feel free to reach out to me directly here on Dev.to or drop me an email at keshavkumarjha890@gmail.com or connect with me on Linkedin

Resume: Linkedin link
Looking forward to connecting with you and exploring new horizons!

Best regards,

Keshav Jha

leetcode: Median of Two Sorted Arrays Problem in C++

keshav jha — Thu, 11 Apr 2024 14:08:03 +0000

Introduction:

Finding the median of two sorted arrays efficiently. In this blog post, we'll explore how to solve this problem in C++, achieving a runtime complexity of O(log(m+n)).

Problem Statement:

Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.

The overall run time complexity should be O(log (m+n)).

Example 1:

Input: nums1 = [1,3], nums2 = [2]
Output: 2.00000
Explanation: merged array = [1,2,3] and median is 2.

Example 2:
Input: nums1 = [1,2], nums2 = [3,4]
Output: 2.50000
Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.

Constraints:

nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106

Approach:

To solve this problem efficiently, we'll utilise the binary search algorithm. The key insight is to partition the arrays nums1 and nums2 into two parts such that the elements on the left side are smaller than or equal to the elements on the right side. This partition should be such that the length of the left partition is equal to or one element larger than the length of the right partition.

Algorithm:

Ensure nums1 is not larger than nums2. If it is, swap them.
Initialize low and high as 0 and the length of nums1, respectively.
Perform a binary search on nums1 to find the correct partition partN1.
Calculate the corresponding partition partN2 in nums2.
Determine the maximum elements (mxLN1 and mxLN2) on the left side and the minimum elements (minRN1 and minRN2) on the right side.
Check if the partitioning is correct, ensuring that mxLN1 <= minRN2 and mxLN2 <= minRN1.
If the partitioning is correct, calculate the median based on the lengths of nums1 and nums2.
Adjust low and high based on the comparison of mxLN1 and minRN2.
Repeat the binary search until the correct partition is found.

Code C++

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        unsigned int n = nums1.size(), m = nums2.size();

        if (n == 0 && m == 0)
            return double(0);

        if (n == 0) {
            if (m % 2 == 0) {
                return (nums2[m / 2 - 1] + nums2[m / 2]) / 2.0;
            } else {
                return nums2[m / 2];
            }
        }

        if (m == 0) {
            if (n % 2 == 0) {
                return (nums1[n / 2 - 1] + nums1[n / 2]) / 2.0;
            } else {
                return nums1[n / 2];
            }
        }

        if (n > m) {
            return findMedianSortedArrays(nums2, nums1);
        }

        int low = 0, high = n;

        while (low <= high) {
            int partN1 = (low + high) / 2;
            int partN2 = (n + m + 1) / 2 - partN1;

            int mxLN1 = (partN1 == 0) ? INT_MIN : nums1[partN1 - 1];
            int minRN1 = (partN1 == n) ? INT_MAX : nums1[partN1];

            int mxLN2 = (partN2 == 0) ? INT_MIN : nums2[partN2 - 1];
            int minRN2 = (partN2 == m) ? INT_MAX : nums2[partN2];

            if (mxLN1 <= minRN2 && mxLN2 <= minRN1) {
                if ((n + m) % 2 == 0) {
                    return (max(mxLN1, mxLN2) + min(minRN1, minRN2)) / 2.0;
                } else {
                    return max(mxLN1, mxLN2);
                }
            } else if (mxLN1 > minRN2) {
                high = partN1 - 1;
            } else {
                low = partN1 + 1;
            }
        }

        return 0.0;
    }
};

Code Explanation:

We handle edge cases where one of the arrays is empty or both arrays are empty.
We ensure that the length of nums1 is smaller or equal to the length of nums2.
We perform a binary search to find the correct partition in nums1.
We calculate the corresponding partition in nums2.
We check if the partitioning is correct and calculate the median accordingly.
We adjust the search space based on the comparison of elements.

Complexity Analysis:

Time Complexity: O(log(min(m, n))) - The binary search is performed on the smaller array.
Space Complexity: O(1) - Only a constant amount of extra space is used.

Conclusion:

We discussed how to efficiently solve the median of two sorted arrays problem in C++ using a binary search approach. By partitioning the arrays intelligently, we were able to achieve a runtime complexity of O(log(m+n)).

Change Themes in Next.js 14 without Wrapping Children in Context .

keshav jha — Wed, 10 Apr 2024 11:51:15 +0000

Introduction

In Web applications, theming plays a crucial role in providing a personalised and visually appealing user experience. One common approach is to use a ThemeProvider Context to manage themes across the application. There is no problem with application's which is completely client side. This blog is specific to developer who is looking for a solution where there application is combination of client and server components and theming depends on color-schema or className.

With the release of Next.js 14+, wrapping children in a Context will make children a client component. In this blog post, we'll explore how to implement a ThemeProvider which will help us to avoid wrapping complete application into a Context provider.

Implementing Theme Provider in Next.js 14+

To implement the Theme Provider without wrapping children in Context, we'll follow these steps:

Install Dependencies: Ensure you have the necessary dependencies installed, including next-themes for theme management and cookies-next for cookies management.
Create Theme Provider Component: Develop a custom ThemeProvider component that handles theme switching and cookie management.
Integrate Theme Provider: Integrate the ThemeProvider component into your application layout to make sure client theming is synced with server on hydration.
Use Theme Switcher : Integrate the ThemeProvider component into your application to switch theme.

Let's dive deeper into each step.

Step 1: Install Dependencies

First, make sure you have next-themes installed in your Next.js project. If not, you can install it using npm or yarn:

npm install next-themes cookies-next
# or
yarn add next-themes cookies-next

Step 2: Create Theme Provider Component

In your project, create a custom ThemeProvider component that leverages next-themes for theme management. This component will handle theme switching and cookie management for server-side rendering.

// components/context/theme.tsx
import { setCookie } from "cookies-next";
import { ThemeProvider, useTheme } from "next-themes";
import type { ThemeProviderProps } from "next-themes/dist/types";
import { useEffect } from "react";

// Application theme provider
function AppThemeProvider({ children, ...props }: ThemeProviderProps) {
  return (
    <ThemeProvider enableColorScheme {...props}>
      <AppThemeProviderHelper />
      {children}
    </ThemeProvider>
  );
}

// Helper component to set theme in cookie
function AppThemeProviderHelper() {
  const { theme } = useTheme();

  useEffect(() => {
    setCookie("__theme__", theme, {
      expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
      path: "/",
    });
  }, [theme]);

  return null;
}

export default AppThemeProvider;

Step 3: Integrate Theme Provider

Now, integrate the ThemeProvider component into your application layout in your app/layout.tsx file or any child layout as per requirement:

import { MonaSans_Font } from "@/assets/fonts/MonaSans";
import dynamic from "next/dynamic";

const AppThemeProvider = dynamic(() => import("@/components/context/theme"), {
  ssr: false,
});

export default async function AppLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  const theme = cookies().get("__theme__")?.value || "system";

  return (
    <html
      className={theme}
      lang="en"
      style={theme !== "system" ? { colorScheme: theme } : {}}
    >
      <body className={`${MonaSans_Font.className} flex flex-col h-full w-full overflow-hidden`}>
        {children}

        <AppThemeProvider 
           attribute="class" 
           defaultTheme={theme} 
           enableSystem 
        />
      </body>
    </html>
  );
}

Step 4: Integrate Theme Provider in Theme Switching

A Tab's based switcher can be created as below to switch theme Using AppThemeProvider.

"use client";

import AppThemeProvider from "@/components/context/theme";
import { Tabs, TabsList, TabsTrigger } from "ui/components/tabs";
import { useTheme } from "next-themes";

function Tab() {
  const { setTheme, theme } = useTheme();
  return (
    <Tabs className="w-full" onValueChange={setTheme} value={theme}>
      <TabsList className="grid w-full grid-cols-3">
        <TabsTrigger value="light">Light</TabsTrigger>
        <TabsTrigger value="dark">Dark</TabsTrigger>
        <TabsTrigger value="system">System</TabsTrigger>
      </TabsList>
    </Tabs>
  );
}

function ThemeTabs() {
  return (
    <AppThemeProvider attribute="class" defaultTheme="system" enableSystem>
      <Tab />
    </AppThemeProvider>
  );
}

export default ThemeTabs;

Conclusion

Implementing a Theme Provider in Next.js 14+ without wrapping children in Context offers a cleaner and more efficient way to manage themes in your application without making complete application a client component.

Leetcode: Reveal Cards In Increasing Order

keshav jha — Wed, 10 Apr 2024 07:24:52 +0000

Revealing a Deck of Cards in Increasing Order

Description

You are given an integer array deck. There is a deck of cards where every card has a unique integer. The integer on the ith card is deck[i].

You can order the deck in any order you want. Initially, all the cards start face down (unrevealed) in one deck.

You will do the following steps repeatedly until all cards are revealed:

Take the top card of the deck, reveal it, and take it out of the deck.
If there are still cards in the deck then put the next top card of the deck at the bottom of the deck.
If there are still unrevealed cards, go back to step 1. Otherwise, stop.
Return an ordering of the deck that would reveal the cards in increasing order.

Note that the first entry in the answer is considered to be the top of the deck.

Example 1:

Input: deck = [17,13,11,2,3,5,7]
Output: [2,13,3,11,5,17,7]
Explanation:
We get the deck in the order 17,13,11,2,3,5,7, and reorder it.
After reordering, the deck starts as [2,13,3,11,5,17,7], where 2 is the top of the deck.
We reveal 2, and move 13 to the bottom. The deck is now [3,11,5,17,7,13].
We reveal 3, and move 11 to the bottom. The deck is now [5,17,7,13,11].
We reveal 5, and move 17 to the bottom. The deck is now [7,13,11,17].
We reveal 7, and move 13 to the bottom. The deck is now [11,17,13].
We reveal 11, and move 17 to the bottom. The deck is now [13,17].
We reveal 13, and move 17 to the bottom. The deck is now [17].
We reveal 17.
Since all the cards revealed are in increasing order, the answer is correct.
Example 2:

Input: deck = [1,1000]
Output: [1,1000]

Constraints:

1 <= deck.length <= 1000
1 <= deck[i] <= 106
All the values of deck are unique.

Revealing a deck of cards in increasing order can be a fascinating problem to solve efficiently. In this article, we'll explore an approach that utilises a specific pattern to reveal the cards in ascending order, considering a given initial ordering.

Approach

By observing the behaviour from the bottom to the top of the sorted deck, I notice a repetitive process: pop the last element, place it at the beginning, and insert the next element from the original deck also at the beginning. This pattern ensures that the revealed deck ends up in increasing order.

Complexity Analysis

Time Complexity: Sorting the deck initially dominates the time complexity. We use the sort() function, which typically employs an efficient sorting algorithm such as QuickSort. Therefore, the time complexity of sorting is O(n log n), where n is the size of the deck. However, if the deck is already sorted, the time complexity reduces to O(n) as there would be no need for sorting.
Space Complexity: The space complexity is O(n) since we use an additional vector to store the revealed deck.

Implementation

Here's a C++ implementation of the above approach:

class Solution {
public:
    vector<int> deckRevealedIncreasing(vector<int>& deck) {
        // Sort the deck in descending order
        sort(deck.begin(), deck.end(), greater<int>());

        // Initialize a vector to store the revealed deck
        std::vector<int> revealedDeck;

        // Iterate through the sorted deck to reveal cards in increasing order
        for (const int& card : deck) {
            if (revealedDeck.empty()) {
                revealedDeck.insert(revealedDeck.begin(), card);
            } else {
                // Pop the last card and place it at the beginning
                int lastCard = revealedDeck.back();
                revealedDeck.pop_back();
                revealedDeck.insert(revealedDeck.begin(), lastCard);
                // Insert the next card from the original deck at the beginning
                revealedDeck.insert(revealedDeck.begin(), card);
            }
        }

        return revealedDeck;
    }
};

By following this approach, we can efficiently reveal a deck of cards in increasing order based on a given initial ordering.

Stats

Can i get a review or tips for my portfolio website?

keshav jha — Mon, 04 May 2020 08:46:49 +0000

Hello everyone!

I'm graduating this year and got hired by a company through campus placement. But due to quarantine(coronavirus) joining is to be delayed.

So I decided to work as a freelancer developer and joined Upwork. But so far got one project only. Then due to lack of works, I decided to build a small personal website for myself. So i can get more projects but no luck.

LINK: https://keshavjha.me.

It's built using HTML,CSS(SCSS),JQuery(masonry) and hosted on netlify.

I want you guys to review my portfolio and tell me, where do i lack or can improve. Also any suggestion for self improvement to get better opportunities are welcome.

Thanks in advance.