DEV Community: Piyush Baraskar

Vocab deck

Piyush Baraskar — Wed, 14 Oct 2026 22:26:25 +0000

Vocab Deck

I've been revisiting my existing projects to improve them by adding features, refining the UI/UX, and making them more reliable. Vocab Deck is one of them.

It's a vocabulary practice app that helps users learn words through different study modes and track their progress.

Vocab Deck lets users choose a built-in or custom vocabulary deck and practice through flashcards, quizzes, typing exercises, or a matching game. The frontend validates vocabulary data and uses a pure-function game engine to generate randomized sessions, with features like answer checking, distractor generation, and real-time feedback. Built-in decks are served by the FastAPI backend, while custom decks and theme preferences are stored in the browser. Study progress stays in memory and resets when the page reloads.

FEATURES -

Four Study Modes
• 3D Flashcards - Review words and meanings.
• Multiple-Choice Quizzes - Test your understanding.
• Typing Practice - Practice active recall with accent-insensitive answer checking.
• Matching Game - Match words with their meanings

Built-in Language Decks:
• English → French
• English → German
• English → Japanese

Custom Decks:
Create and edit decks, with JSON and CSV import/export to manage and reuse vocabulary lists.

Progress Tracking:
Track study statistics, streaks, and time spent across different study modes.

TECH STACK
Backend -
Python 3.11
FastAPI 0.110+
Uvicorn
Pydantic 2

Frontend -
Node.js 18+
React 18 + TypeScript
Vite

Testing -
Vitest + Testing Library
Playwright

The project is live, and contributions are welcome! You can contribute to the codebase or open an issue to report bugs, suggest improvements, or propose new features.

Live Demo: https://vocab-deck.vercel.app/

PIYUSH-NEXTGEN / Vocab-Deck

Vocab Deck

Vocab Deck is a vocabulary practice application that helps language learners memorize words through four interactive study modes. It provides a modern React frontend backed by a FastAPI vocabulary service. Built-in decks cover English→French, English→German, and English→Japanese; users can also create, edit, import, and export custom decks entirely in the browser.

Features

Four study modes: Flashcards (with 3D flip), Multiple-choice Quiz, Typing (accent-insensitive option), Matching
Three built-in language pairs: English→French, English→German, English→Japanese (50 entries each, directly comparable)
Custom decks: Create, edit, import (JSON/CSV), export; validated client-side with same rules as built-in decks
Session tracking: Per-mode stats (correct/incorrect, streaks, time) preserved across mode switches; reset on demand
Theme support: Light/dark with prefers-color-scheme detection and localStorage persistence, no flash on load
Accessibility: prefers-reduced-motion swaps flip for instant face swap; focus-visible outlines; semantic HTML
Offline-capable custom decks: Stored in localStorage, portable via JSON/CSV…

View on GitHub

Feel free to explore the project and share your feedback.

Outdoor Nudge: One Small Mission to Get You Outside

Piyush Baraskar — Sun, 11 Oct 2026 11:33:01 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

There is a particular kind of afternoon I wanted to build this for.

You've been sitting at your desk for hours. Your brain feels a little fried, you're restless, and you know you probably need a break. You open another tab, check your phone, scroll for a while, and somehow another 20 minutes disappear.

You know you should step outside. You just can't think of what to do once you get there.

A walk sounds boring. The weather might be terrible. You don't have the energy for anything ambitious. And generic advice like "touch grass" isn't exactly helpful when you're already trying to figure out how.

That small moment is what led me to build Outdoor Nudge.

The idea is simple: tell it how you feel, and it gives you one small outdoor mission to do for roughly 20 minutes. Something concrete enough that you can stop thinking about taking a break and actually take one.

No endless recommendations. No motivational lecture. Just one nudge.

What I Built

Outdoor Nudge is a local-first AI app that turns your mood and the current weather into one practical outdoor activity.

You might type:

restless and stuck at my desk

Outdoor Nudge considers your mood, local weather, and the time of day, then generates a mission that fits the situation.

Instead of getting "go for a walk," you might get something like Shadow Sprint Intervals: head outside, move briskly along the sunny side of your building, use nearby landmarks for a few short intervals, and finish with some shoulder rolls.

The suggestion includes:

A mission title that gives the activity a little personality.
Step-by-step instructions so you know exactly what to do.
Why it fits your mood and the current conditions.
What to bring, if anything.
Duration, energy level, and activity category to help you decide whether it feels manageable.

The goal isn't to turn a break into another productivity task. It's to make getting outside easier to start.

Why not just ask a chatbot?

Because generating an idea is the easy part. Making it useful in the real world is harder.

A language model might suggest sitting on a park bench when there is no bench nearby, recommend an energetic activity when you're exhausted, or suggest something that makes no sense in the current weather.

Outdoor Nudge is designed around that gap between a plausible-sounding answer and an activity someone can actually do.

It checks the model's output against rules for safety, realism, energy level, activity category, and repetitive suggestions. If a suggestion fails those checks, the backend asks the model to try again rather than displaying the rejected result.

The model comes up with the idea. The application has the final say on whether that idea passes its checks.

That's an important distinction for an app whose suggestions are meant to be followed outside, not just read on a screen.

Demo

Try it yourself: Start Outdoor Nudge locally using the instructions in the repository.

Repository: github.com/PIYUSH-NEXTGEN/Outdoor-Nudge

The project currently runs locally, so I haven't included a public demo URL here. A short screen recording would be a good way to demonstrate the full experience, including mood input, weather, the generated mission, and the option to request an easier or different activity.

A useful demo scenario:

Enter restless and stuck at my desk.
Let the app fetch the weather, or enter weather conditions manually.
Generate a mission and inspect the steps, energy level, and explanation.
Click Give me another to get a different suggestion.
Click Make it easier to request a lower-energy activity.
Open the history panel to see previous nudges.

I'd especially show the last two interactions because they demonstrate that this is more than a single prompt sent to an LLM.

Code

PIYUSH-NEXTGEN / Outdoor-Nudge

Outdoor Nudge

Tell it how you feel, get one small outdoor mission back. Built for those afternoons when you know you should step outside but can't think of what to actually do.

Report a Bug

Overview

Outdoor Nudge is a tiny local first web app. You type your mood in plain words ("restless and stuck at my desk"), it looks up the live weather for your spot using Open-Meteo, and a local LLM (Ollama, gemma3:4b by default) comes up with exactly one concrete outdoor task of about 20 minutes.

Each nudge has a title, step by step instructions, why it fits your mood and weather, what to bring, an energy level, and a category. The front end is a single page (…

View on GitHub

The repository includes the application, prompt and validation logic, weather integration, local history, tests, and setup instructions.

It's open source under the MIT license, so you're welcome to explore it, run it locally, report issues, or contribute improvements.

How I Built It

I wanted the application to be small enough to run without a complicated setup, but I didn't want to sacrifice the logic that makes its suggestions useful.

That led to a deliberately straightforward stack:

Layer	Technology	Purpose
Frontend	HTML, CSS, JavaScript	Responsive interface, mood input, mission cards, history, and model comparison
Backend	Python, FastAPI, Uvicorn	API endpoints, request handling, orchestration, and retry logic
AI	Ollama + Gemma 3 4B	Local generation of structured outdoor missions
Weather	Open-Meteo	Live weather conditions without an API key
Validation	Pydantic + custom Python rules	Validate the output structure, activity constraints, and safety checks
Storage	Local JSON file	Save previous nudges and completion status
Testing	Playwright + Python tests	Test the interface, quality checks, and validation rules

No React. No frontend build step. No hosted database. No paid AI API.

I kept the stack intentionally boring because I wanted the interesting engineering to live in how the app makes decisions, not in how many dependencies it uses.

The architecture

Here's how a request moves through the application:

                 USER
                   |
                   v
       +------------------------+
       |   Browser Interface    |
       |   static/index.html    |
       +------------------------+
                   |
          +--------+---------+
          |                  |
          v                  v
    GET /api/weather    POST /api/nudge
          |                  |
          v                  v
    +-------------+   +------------------+
    | Open-Meteo  |   | FastAPI Backend  |
    | Live Weather|   |                  |
    +-------------+   +------------------+
                             |
                             v
                  +----------------------+
                  | Mood + Weather +     |
                  | Time + Energy +       |
                  | Category + Exclusions|
                  +----------------------+
                             |
                             v
                  +----------------------+
                  | Prompt Construction  |
                  +----------------------+
                             |
                             v
                  +----------------------+
                  | Ollama + Gemma 3 4B  |
                  | Generate JSON        |
                  +----------------------+
                             |
                             v
                  +----------------------+
                  | Schema, Realism &    |
                  | Safety Validation   |
                  +----------------------+
                             |
                      +------+------+
                      |             |
                   Rejected      Accepted
                      |             |
                      v             v
                 Retry with     Save to local
                 feedback       history.json
                      |             |
                      +----->       v
                              Return JSON
                                   |
                                   v
                            Render Mission

The weather lookup is a separate part of the flow. The browser can request current conditions through the backend, which uses Open-Meteo. The nudge endpoint then uses the available weather information alongside the mood and other request settings.

Let's look at the parts that make the application work.

1. Turn an ordinary sentence into useful constraints

The user doesn't have to select a formal mood category or fill out a long questionnaire. They can write something natural, such as:

"I'm exhausted and don't want to do much."
"Feeling restless after sitting all day."
"I need a change of scenery."
"I'm feeling lonely and could use some human interaction."

The backend uses energy_pool() to estimate whether the person needs a low-, medium-, or high-energy activity. It then uses pick_category() to select an activity category, taking category limits and least-recently-used weighting into account.

The request can also include the user's location, selected model, a manual weather override, previously excluded titles, and an easier-mode flag.

This is useful because the model shouldn't have to infer every constraint from a sentence on its own. The application can make some decisions explicitly before generation begins.

2. Give the model the right context

The prompt builder in app/prompts.py combines the relevant information into a structured instruction for Gemma.

Conceptually, the input looks like this:

Mood: Restless and stuck at my desk
Weather: Clear sky, 22°C
Time of day: Evening
Energy: High
Category: Movement
Previously used titles: [excluded titles]

Task:
Generate one specific outdoor mission.
Return the required JSON structure.
Follow the activity and safety constraints.
Avoid generic suggestions and repeated ideas.

This is an illustrative representation of the context, not a literal dump of the application's complete system prompt.

The model receives more than just the mood. It has conditions to work within, which helps make the resulting mission more relevant to the situation.

3. Use Gemma locally

Outdoor Nudge uses Gemma 3 4B through Ollama by default.

Ollama provides the local model runtime. The backend sends the prompt to the configured Ollama server, receives the model's response, and extracts the JSON needed by the application.

The important design choice is that the model is not accessed through a hosted AI API. Mood text is processed locally, and the app doesn't require an OpenAI or Gemini API key.

Weather is the exception to the local-only approach: live weather requires an internet connection to Open-Meteo. If that service is unavailable, the user can enter the conditions manually.

Local inference also comes with a practical trade-off. Generation speed depends on the machine and the model being used. On a CPU-only machine, a request can take a minute or two.

4. Don't trust the first answer just because it came from an LLM

This is probably the part of the project I find most interesting.

A model can return perfectly valid JSON and still give a terrible recommendation.

For example, a response might be structurally correct but tell someone to climb somewhere, approach a road, touch unknown plants, or rely on an object that may not exist. A generic "go for a walk" answer can also satisfy a loose prompt while failing the actual purpose of the application.

So I separated generation from validation.

The validate_nudge() function checks the response structure, category and energy consistency, instruction count, and banned verbs or venues. The safety_violations() function applies additional checks to the proposed activity.

The checks cover cases such as:

Climbing, roads, and water-related risks.
Eating or tasting things found outside.
Touching plants or litter with bare hands.
Assuming a bench, bin, notebook, or other object is available.
Generic suggestions that don't describe a concrete activity.
Lonely-mood suggestions that fail to include meaningful human contact.
Inappropriate activities after dark.

If a response fails, the application retries generation, providing feedback about what went wrong. It tries up to four times before returning an error rather than showing an invalid suggestion.

Generate mission
      |
      v
Parse JSON
      |
      v
Validate structure and constraints
      |
      +---- Pass? ---- Yes ----> Save and display
      |
      No
      |
      v
Explain failure to model
      |
      v
Retry (up to 4 attempts)
      |
      +---- Still invalid? ----> Return an error

These checks are deterministic rules, not a guarantee that every suggestion is safe. The project is a small local application, and the user should still exercise common sense when following an outdoor activity.

Still, separating these rules from the model is valuable: I can add a new restriction, write a test for it, and change the application's behavior without relying entirely on a better prompt.

5. Make the next suggestion different

Another small problem: if you ask an AI for another idea, it can give you essentially the same answer with a different title.

Outdoor Nudge tracks recent titles and excludes previously used ideas. It also limits repeated categories and uses least-recently-used weighting to encourage variety.

The Give me another button carries those exclusions forward. Make it easier requests a lower-energy option.

There's also a model comparison mode, so you can select two locally available Ollama models and compare their suggestions side by side.

That gives the application a little more depth than generating one answer and stopping there.

6. Keep history simple

Accepted nudges are stored in data/history.json, which is gitignored. The interface has a collapsible history panel and a way to mark a mission as completed.

I chose a JSON file instead of introducing a database. This is a single-user, local-first application, so a database would add setup and maintenance without solving a problem I currently have.

The history is written atomically, with a duplicate-title guard. It stays local rather than requiring an account or remote service.

7. Test the rules, not just the happy path

For an application that recommends real-world activities, testing only whether the page loads isn't enough.

The repository includes several layers of tests:

Offline safety tests: Around 70 cases covering prohibited activities, assumed objects, nighttime restrictions, generic walks, and other edge cases.
Quality retests: A 15-case harness covering different moods, weather conditions, time contexts, response structure, plausibility, clichés, and duplicates.
Browser tests: Playwright tests covering 14 page flows, with screenshots for desktop, mobile, model comparison, history, and weather fallback.

The live quality and safety retests require the backend and Ollama to be running. The offline validator tests can run without a model.

I wanted the rules to be testable independently of the AI, because changing a model or prompt shouldn't silently remove a safety constraint.

Why Does Open Innovation Matter?

I could have built this around a hosted AI API. It might have been a simpler way to get started.

But I wanted Outdoor Nudge to be something you could run on your own machine without an account, a paid API key, or sending your mood to a third-party AI service.

Mood is personal information, even when someone is only typing that they're exhausted, lonely, or having a bad day. I didn't want getting a small outdoor suggestion to require sharing that information with a remote model provider.

Using Gemma 3 4B through Ollama made local inference practical. The model runs on the user's machine, and the application can work without a hosted AI service. Open-Meteo is still used for live weather, so the app needs internet access for that feature unless the user enters conditions manually.

Open models also give us flexibility. We can try another model already supported by Ollama, compare outputs, adjust the prompt, and build our own validation around the model instead of depending on a single proprietary endpoint.

That freedom is particularly useful for this project because the model isn't the whole product. The weather integration, category selection, safety rules, retry loop, and history all shape the final experience.

Open innovation gave me the freedom to build the AI around the experience I wanted, instead of building the experience around an AI provider's API.

And the end goal is deliberately small: help someone close their laptop for a little while and do something in the world around them.

Prize Categories

Gemma: Outdoor Nudge uses Gemma 3 4B as its default local model through Ollama. The model generates structured outdoor missions, while application-side validation checks each suggestion before it reaches the user.

Outdoor Nudge isn't trying to replace a therapist, a fitness app, or a human friend.

Sometimes you don't need another app telling you how to improve your life. You just need one good reason to step away from your screen.

So that's what I built: one mood, one look at the weather, one small mission.

Now close the tab and go try it.

[Boost]

Piyush Baraskar — Mon, 05 Oct 2026 17:01:03 +0000

Hacktoberfest Weekend Challenge: Build for a Friend Submission 🤝

Jesus Chetia

Oct 4

What if your journal could understand you? So I built DayBook

#devchallenge #weekendchallenge #hf26challenge #opensource

8 min read

LUMEN - Full stack image analysis tool

Piyush Baraskar — Sat, 29 Aug 2026 15:23:56 +0000

Lemme share a half-baked project of mine LUMEN, which I am currently working on.

LUMEN - Full Stack Image Data Analyzer
(will share the link after completing)

It's primarily a learning project, not a platform/SaaS or something.

The basic idea:
The basic idea is simple: give LUMEN an image, and it extracts different properties from it and stores the analysis as structured data.

Working:
The image is first loaded using PIL and converted into a NumPy array. LUMEN then performs different types of analysis, including:

Image dimensions
dtype, std
min/max, mean
RGB channel statistics
Histograms and intensity distribution
Perceptual brightness
Contrast, Sharpness / blur
Colorfulness, Dominant colors
Exposure, Entropy
Duplicate detection

For duplicate detection, I use SHA-256 hashing. The image is hashed and the resulting hash can be used to identify identical files and group duplicates.

Also using pytest to test the analysis functions.

Database side -
Made a persistence layer using PostgreSQL + SQLAlchemy.
The idea is to store the analyzed images and their results as structured records.

For example, an image can have information such as:

ID
filename
dimensions
file information
analysis timestamp

And the analysis can contain things like:

mean brightness
standard deviation
minimum / maximum values
RGB channel statistics
quality metrics

SQLAlchemy ORM is used to represent DB tables as Python models.

Backend — (Work in progress)
The backend is being built with FastAPI,

FastAPI receives the image/request, the analysis engine processes it and the results are validated and structured, and the relevant data is persisted in PostgreSQL.

And the frontend will be made later and then deployment......✌🏼

Still work in progress, but this is where LUMEN is currently at, rn making the backend part :)

Code and approach to solve Subarray sum equals

Piyush Baraskar — Sat, 29 Aug 2026 09:49:44 +0000

class Solution:
    def subarraySum(self, nums: List[int], k: int) -> int:
        prefixsum = 0
        count = 0
        hashmap = {0: 1}

        for i in nums:
            prefixsum += i

            needed = prefixsum - k

            if needed in hashmap:
                count += hashmap[needed]

            if prefixsum in hashmap:
                hashmap[prefixsum] += 1
            else:
                hashmap[prefixsum] = 1

        return count

PROBLEM

so in the ques we have given an array nums and an integer k and we have to return the total number of subarrays whose sum is equal to k.

like here nums = [1,2,3] and k = 3.

the subarrays whose sum is 3 are [1,2] and [3], so the answer will be 2.

APPROACH

so here we use prefixsum and hashmap.

first we calculate the prefixsum while looping through the array.

then we use this formula:

needed = prefixsum - k

because if the current prefixsum is prefixsum and we want a subarray with sum k, then we need a previous prefixsum equal to prefixsum - k.

like nums = [1,2,3] and k = 3.

when we reach 2:

prefixsum = 1 + 2 = 3

so:

needed = 3 - 3 = 0

and 0 is already present in the hashmap, which means the subarray from the beginning [1,2] has sum 3.

then we store the prefixsum in the hashmap and its frequency as the value.

we store frequency instead of just the index because the same prefixsum can appear multiple times, and every previous occurrence can create a different subarray whose sum is k.

also we start with hashmap = {0: 1} because prefixsum 0 exists once before the array starts. this helps us count subarrays that start from index 0.

finally count contains the total number of subarrays whose sum is equal to k.

CODE EXPLAINATION

nums = [1,2,3]

k = 3

prefixsum = 0    -> prefixsum is used to calculate the running prefix sum.
count = 0        -> count stores the total number of subarrays whose sum is equal to k.
hashmap = {0: 1} -> hashmap stores prefixsum as the key and its frequency as the value.


{0: 1} means prefixsum 0 has appeared once before the array started.

for i in nums:
    prefixsum += i

-> looping through every element of nums and adding it to prefixsum.

for nums = [1,2,3] the prefixsum will be:

1 -> 3 -> 6

needed = prefixsum - k

-> calculating which previous prefixsum we need to get a subarray whose sum is k.

the formula is:

previous prefixsum = current prefixsum - k

for example when prefixsum = 3 and k = 3:

needed = 3 - 3 = 0

so we check if prefixsum 0 was seen before.

if needed in hashmap:
    count += hashmap[needed]

-> if needed is present in the hashmap, it means there are previous prefix sums that can create a subarray with sum k.

then we add its frequency to count.

we add the frequency instead of just 1 because the same prefixsum might have appeared multiple times.

if prefixsum in hashmap:
    hashmap[prefixsum] += 1
else:
    hashmap[prefixsum] = 1

-> after checking the needed prefixsum, we store the current prefixsum in the hashmap.

if the prefixsum already exists, increase its frequency by 1.

otherwise create a new key with frequency 1.

return count

-> returns the total number of subarrays whose sum is equal to k.

Code and approach to solve Contiguous array problem

Piyush Baraskar — Sat, 29 Aug 2026 09:47:35 +0000

class Solution:
    def findMaxLength(self, nums: List[int]) -> int:
        arr2 = []
        for i in nums:
            if i == 0:
                arr2.append(-1)
            else :
                arr2.append(1)

        prefixsum = []
        total = 0

        for i in arr2:
            total += i
            prefixsum.append(total)

        hashmap = {0: -1}
        max_length = 0

        for i in range(len(prefixsum)):

            if prefixsum[i] in hashmap:
                length = i - hashmap[prefixsum[i]]
                max_length = max(max_length, length)

            else:
                hashmap[prefixsum[i]] = i

        return max_length

PROBLEM-
so in the ques we have given a binary array and we have to return longest subarray of equal number of 0,1
like here

nums = [0,1,1,1,1,1,0,0,0]

the


 is the longest subarray the numbers are repeating like three ones and then three zeroes and it will return 6 cuz the total number of elements are six 

APPROACH -
so here we are first converting the 0 into -1 because it helps us to calculate the balanced subarray, because when the sum becomes 0 it means there are equal numbers of 0 and 1. like

 ```0,1```

 convert ->

 ```-1,1```

 -> sum = -1 + 1 = 0 -> length = 2

then we calc the prefixsum so we can store the prefixsum according to key value pairs in the hashmap
after that uses the hashmap

then we calc loop through prefix sum index
and if the element is present in hashmap it calc length from i- previous index
and update the max length

else remember its current index

# CODE EXPLAINATION

`nums = [0,1,1,1,1,1,0,0,0]`



```python
arr2 = []

-> creating a blank array to store -1 and 1.

for i in nums:
    if i == 0:
        arr2.append(-1)
    else:
        arr2.append(1)

-> loops through the nums. If element is 0, replace it with -1, otherwise keep it as 1. So arr2 becomes [-1,1,1,1,1,1,-1,-1,-1].

prefixsum = []
total = 0

for i in arr2:
    total += i
    prefixsum.append(total)

-> calculating the prefixsum by adding each element to total and storing the result in prefixsum.

hashmap = {0: -1}
max_length = 0

-> creating a hashmap where prefixsum is the key and its first index is the value. {0: -1} means prefixsum 0 was present before the array started.

for i in range(len(prefixsum)):

-> looping through the prefixsum using its index and calclating the length = current index i - previous index i which is stored in hashmap

if prefixsum[i] in hashmap:
    length = i - hashmap[prefixsum[i]]
    max_length = max(max_length, length)

-> if the current prefixsum is already in the hashmap, it means the sum between the previous index and current index is 0, so the number of 0s and 1s is equal. Then calculate the length and update the max_length.

else:
    hashmap[prefixsum[i]] = i

-> if the prefixsum is not already in the hashmap, store its current index. We store only the first index because it gives the longest possible subarray.

return max_length

-> returns the longest subarray length.

Code and approach to solve Range sum query - immutable problem of leetcode

Piyush Baraskar — Sat, 29 Aug 2026 09:44:20 +0000

class NumArray:

    def __init__(self, nums: List[int]):
        self.prefix = []
        total = 0
        for i in nums:
            total += i
            self.prefix.append(total)

    def sumRange(self, left: int, right: int) -> int:
        if left == 0:
            return self.prefix[right]
        else:
            return self.prefix[right] - self.prefix[left - 1]

So in this problem, we first make a prefix array from the given array. A prefix array stores the sum of all elements from the beginning up to the current index. For example, [1, 2, 3] becomes [1, 3, 6] because 1, 1+2 = 3, and 1+2+3 = 6.

Why prefix sum? Because we have to perform multiple range-sum queries. Instead of calculating the sum again and again for every query, we calculate the cumulative sums once and then use them to get each range sum in O(1) time.

self.prefix = []

→ Creates an empty array to store the prefix sums.

total = 0

→ Stores the running sum. We start with 0 because we haven't added anything yet.

for i in nums:

→ Loops through every element in nums.

total += i

→ Adds the current element to the previous running sum. For [-2, 0, 3, -5, 2, -1], the totals become -2, -2, 1, -4, -2, -3.

self.prefix.append(total)

→ Stores each running total in the prefix array, so we finally get [-2, -2, 1, -4, -2, -3].

if left == 0:

→ Checks if the requested range starts from index 0. For example, sumRange(0, 2).

return self.prefix[right]

→ If left is 0, we don't need to subtract anything. prefix[2] = 1, which is -2 + 0 + 3 = 1.

else:

→ If the range does not start from 0, we need to remove the elements before left.

return self.prefix[right] - self.prefix[left - 1]

→ prefix[right] gives the sum from the beginning up to right, while prefix[left - 1] gives the unwanted part before left. For sumRange(2, 5): prefix[5] - prefix[1] = -3 - (-2) = -1.

How does `self.prefix[right] - self.prefix[left - 1]` work?

Suppose:

nums = [-2, 0, 3, -5, 2, -1]

and the query is:

sumRange(2, 5)

So:

left = 2
right = 5

We want:

3 + (-5) + 2 + (-1) = -1

Our prefix array is:

prefix = [-2, -2, 1, -4, -2, -3]
index     0   1  2   3   4   5

self.prefix[right]

→ Since right = 5, self.prefix[5] = -3. This gives the sum of everything from index 0 to 5:

-2 + 0 + 3 - 5 + 2 - 1 = -3

But we only want the elements from index 2 to 5, so we need to remove the elements before index 2:

-2 + 0 = -2

self.prefix[left - 1]

→ Since left = 2, left - 1 = 1, so self.prefix[1] = -2. This gives the sum of everything before index 2.

Now subtract:

self.prefix[5] - self.prefix[1]

= -3 - (-2)

= -1

And -1 is exactly:

3 + (-5) + 2 + (-1) = -1

In simple words

prefix[right]     → everything up to right
prefix[left - 1]  → unwanted part before left

everything - unwanted part = required range sum

That's why we use:

return self.prefix[right] - self.prefix[left - 1]

Code and approach to solve Contains Duplicate problem of leetcode

Piyush Baraskar — Sat, 29 Aug 2026 09:41:51 +0000

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        seen = set()
        for i in nums:
            if i in seen:
                return True
            else :
                seen.add(i)

        return False

PROBLEM

so in the ques we have given an array nums and we have to check if there is any duplicate element in the array or not.

if any element appears more than one time then we have to return True, otherwise we return False.

like here nums = [1,2,3,1], 1 is present two times so it contains a duplicate and the answer will be True.

but if nums = [1,2,3,4], every element is unique so the answer will be False.

APPROACH

so here we use a set to keep track of the elements that we have already seen.

first we create an empty set called seen.

then we loop through every element of nums.

for every element we check if it is already present in seen.

if it is already present, it means that we have seen this element before, so it is a duplicate and we immediately return True.

otherwise we add that element into seen and continue the loop.

if the complete array is checked and we never find a duplicate, then we return False.

for example nums = [1,2,3,1]:

1 -> not in set -> add 1

2 -> not in set -> add 2

3 -> not in set -> add 3

1 -> already in set -> duplicate found -> return True

CODE EXPLAINATION


python
nums = [1,2,3,1]
seen = set()  -> creating an empty set called seen where we will store the elements that we have already seen.

for i in nums:  -> looping through every element of nums one by one.

if i in seen:
    return True  -> checking if the current element i is already present in seen.

if it is already present, it means the same element appeared before, so it is a duplicate and we return True.

else:
    seen.add(i) -> if the current element is not already present in seen, we add it to the set so we can check it against the upcoming elements.

return False    -> if the loop finishes without finding any duplicate element, it means every element is unique, so we return False.

Code and approach to solve Concatenation of array

Piyush Baraskar — Sat, 29 Aug 2026 09:40:27 +0000

class Solution:
    def getConcatenation(self, nums: List[int]) -> List[int]:
        ans = []

        for i in nums:
            ans.append(i)

        ans += nums

        return ans

PROBLEM

so in the ques we have given an array nums and we have to return the array with itself concatenated. like here nums = [1,2,3] so we have to return [1,2,3,1,2,3]. basically we have to put the same array two times one after another.

APPROACH

so here we first create a blank array ans where we will store the elements.

then we loop through nums and append every element into ans. after that ans already contains the original array.

then we use ans += nums which adds the complete nums array again at the end of ans.

so if nums = [1,2,3]:

ans = [1,2,3]

then ans += nums

ans = [1,2,3,1,2,3]

and finally we return ans.

CODE EXPLAINATION

nums = [1,2,3]

ans = []

creating a blank array to store the elements of nums.

for i in nums:
    ans.append(i)

-> looping through nums and adding every element into ans. So after this loop ans becomes [1,2,3].

ans += nums

-> adding the complete nums array again at the end of ans. So ans becomes [1,2,3,1,2,3].

return ans

-> returns the concatenated array [1,2,3,1,2,3].

Code and approach to so solve Longest common prefix

Piyush Baraskar — Wed, 26 Aug 2026 22:40:28 +0000

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        Longest_sum = ""

        for i in range(len(strs[0])):
            for j in strs:
                if i >= len(j) or j[i] != strs[0][i]:
                    return Longest_sum

            Longest_sum += strs[0][i]

        return Longest_sum

PROBLEM

so in the ques we have given an array of strings strs and we have to find the longest common prefix among all the strings.

prefix means the characters that come at the starting of the string.

like here strs = ["flower","flow","flight"].

the common starting characters are f, l, so the longest common prefix is "fl".

therefore the answer will be "fl".

APPROACH

so here we create an empty string Longest_sum where we will store the common prefix.

then we loop through the characters of the first string because we can use the first string as a reference and compare its characters with all the other strings.

then inside that loop, we loop through every string in strs.

for every string we check two conditions:

i >= len(j)

this checks if the current index i is outside the length of the current string. If it is, then there cannot be any common prefix at this position.

and:

j[i] != strs[0][i]

this checks if the current character of the string is different from the character at the same position in the first string.

if either condition is true, it means the common prefix has ended, so we return Longest_sum.

if the character is the same in every string, we add that character to Longest_sum and continue checking the next character.

for example:

strs = ["flower","flow","flight"]

first character:

f == f == f -> add f

second character:

l == l == l -> add l

third character:

o == o but o != i -> stop

so Longest_sum = "fl" and we return "fl".

CODE EXPLAINATION

strs = ["flower","flow","flight"]

Longest_sum = ""  -> creating an empty string Longest_sum where we will store the common prefix.

for i in range(len(strs[0])): -> looping through the indices of the first string.

we use the first string as a reference and check its characters against all the other strings.
for strs = ["flower","flow","flight"], the loop checks index 0, 1, 2, and so on.

for j in strs:  -> looping through every string in strs so we can compare the character at index i with the character from the first string.

if i >= len(j) or j[i] != strs[0][i]:
    return Longest_sum  -> checking if the current index is outside the length of the current string or if the characters are different.

i >= len(j) means the current string is shorter and does not have a character at index i.

j[i] != strs[0][i] means the current character is different from the character at the same position in the first string.

if either condition is true, the common prefix ends here, so we return Longest_sum.

Longest_sum += strs[0][i]  -> if the current character is the same in every string, we add that character to Longest_sum.

for example:

Longest_sum = ""

then f -> "f"

then l -> "fl"

then when the characters don't match, we return "fl".

return Longest_sum  -> if we finish checking the first string without finding a mismatch, we return the complete Longest_sum as the longest common prefix.

My Code and approach to solve the two sum problem of leetcode

Piyush Baraskar — Wed, 26 Aug 2026 22:36:40 +0000

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            for j in range(len(nums)):
                if i != j and nums[i] + nums[j] == target:
                    return [i, j]

PROBLEM

so in the ques we have given an array nums and an integer target and we have to find two different elements whose sum is equal to target.

we have to return the indices of those two elements.

like here nums = [2,7,11,15] and target = 9.

here 2 + 7 = 9, so the indices are 0 and 1, therefore the answer will be [0,1].

APPROACH

so here we use two loops to check every possible pair of elements in the array.

first loop takes one element using index i.

then second loop takes another element using index j.

we check two conditions:

i != j

this makes sure that we are not using the same element twice.

and:

nums[i] + nums[j] == target

this checks if the sum of the two elements is equal to the target.

if both conditions are true, we return their indices [i,j].

for example nums = [2,7,11,15] and target = 9:

2 + 2 -> not allowed because i == j

2 + 7 = 9 -> target found

so we return [0,1].

CODE EXPLAINATION

``
nums = [2,7,11,15]

target = 9

for i in range(len(nums)): -> first loop through the indices of nums.

for nums = [2,7,11,15], i will be 0, 1, 2, and 3.

for j in range(len(nums)): -> second loop also goes through all the indices of nums,this allows us to check every possible pair of elements.

if i != j and nums[i] + nums[j] == target: -> checking two conditions.

i != j means the two indices must be different, so we don't use the same element twice.

nums[i] + nums[j] == target checks if the sum of the two elements is equal to target.

return [i, j] -> if we find two elements whose sum is equal to the target, we return their indices.

for example:

nums[0] + nums[1]

2 + 7 = 9

so it returns [0,1].
``

WHAT'S HISTOGRAM ? A histogram shows how pixel intensity is distributed in image. I calculate it to understand how much of image is dark, mid-tone or bright Using NumPy to count pixel val into 256 bins then convert those regions into % for easier analysis

Piyush Baraskar — Thu, 20 Aug 2026 20:25:45 +0000

DEV Community: Piyush Baraskar

Vocab deck

PIYUSH-NEXTGEN / Vocab-Deck

Vocab Deck

Features

Outdoor Nudge: One Small Mission to Get You Outside

What I Built

Why not just ask a chatbot?

Demo

Code

PIYUSH-NEXTGEN / Outdoor-Nudge

Outdoor Nudge

Table of Contents

Overview

How I Built It

The architecture

1. Turn an ordinary sentence into useful constraints

2. Give the model the right context

3. Use Gemma locally

4. Don't trust the first answer just because it came from an LLM

5. Make the next suggestion different

6. Keep history simple

7. Test the rules, not just the happy path

Why Does Open Innovation Matter?

Prize Categories

[Boost]

What if your journal could understand you? So I built DayBook

LUMEN - Full stack image analysis tool

Code and approach to solve Subarray sum equals

PROBLEM

APPROACH

CODE EXPLAINATION

Code and approach to solve Contiguous array problem

Code and approach to solve Range sum query - immutable problem of leetcode

How does self.prefix[right] - self.prefix[left - 1] work?

In simple words

Code and approach to solve Contains Duplicate problem of leetcode

PROBLEM

APPROACH

CODE EXPLAINATION

Code and approach to solve Concatenation of array

PROBLEM

APPROACH

CODE EXPLAINATION

Code and approach to so solve Longest common prefix

PROBLEM

APPROACH

CODE EXPLAINATION

My Code and approach to solve the two sum problem of leetcode

PROBLEM

APPROACH

CODE EXPLAINATION

WHAT'S HISTOGRAM ? A histogram shows how pixel intensity is distributed in image. I calculate it to understand how much of image is dark, mid-tone or bright Using NumPy to count pixel val into 256 bins then convert those regions into % for easier analysis

How does `self.prefix[right] - self.prefix[left - 1]` work?