DEV Community: Rohith V

Track My Cash: Building a Secure, Decoupled Ledger with Spring Boot, Vanilla JS, and Gemini

Rohith V — Sat, 28 Feb 2026 12:55:41 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

Reusing the side project that I had worked on recently for this Challenge

What I Built with Google Gemini

I built BookKeeping, a full-stack financial ledger application designed to solve a very specific problem: keeping track of money I lend to friends without needing a bloated, complex accounting tool.

The application is a stateless, decoupled Single Page Application (SPA). The frontend is built entirely in Vanilla JavaScript, HTML, and CSS (zero framework dependencies!) and now deployed securely on Google Cloud Run. It communicates with a robust backend powered by Java, Spring Boot 3, Spring Security 6, and a PostgreSQL database hosted on Render.

Google Gemini was my pair-programming partner throughout the entire development cycle. Gemini played a massive role in helping me stitch together the tricky parts of a decoupled architecture. Specifically, we used Gemini to:

Architect the Security Flow: It helped me implement stateless JWT authentication using HttpOnly cookies and standard Bearer tokens.
Handle Browser Security Hurdles: Gemini and I worked through aggressive third-party cookie blocking (like Safari ITP) by engineering a strict CORS and JSON-payload strategy to neutralise CSRF attacks natively.
Build the Math Engine: We built a custom "Partial Repayment" algorithm together that dynamically decreases loan amounts and automatically triggers database row deletion when a balance hits zero.
Construct Cloud Run Docker Environments: When migrating the frontend to Google Cloud Run, we built a lean Alpine Nginx container. Gemini instantly flagged that Cloud Run overrides standard port bindings—so we implemented a dynamic nginx.conf.template that natively injects Cloud Run's $PORT environment variable during deployment.
Design Native Operating System Localisation: During my Multi-Currency expansion logic, my browser stubbornly refused to format Euros properly. Gemini analysed the frontend code and detected a hardcoded 'en-US' locale string overriding the dynamic ISO codes. By removing the strict binding and passing undefined into the JavaScript Intl.NumberFormat API, my interface immediately inherited my computer's dynamic OS localisation formatting.

Note on Authentication: You might notice the login system is intentionally very straightforward. Since this application is built to solve a highly focused, personal task (tracking our own money), a complex OAuth or multi-role hierarchy wasn't necessary. The simple stateless JWT login keeps the app lightweight and entirely under control.

Demo

Github Link : https://rohithv07.github.io/BookKeeping/

Cloud Run URL Embedded :

Rohithv07 / BookKeeping

Record the debts that we are lending to other people.

BookKeeping

Record the debts that we are lending to other people.

What was implemented

Spring Boot App: A robust REST API running on Java 21, built using Gradle.
Database Models
- Borrower: Saves name, email, and phone.
- Loan: Tracks amount, date lent, exact 1-month (dueDate), and loan status (ACTIVE vs REPAID).
Core API Endpoints
- POST /api/borrowers and GET /api/borrowers
- POST /api/loans and GET /api/loans
- PUT /api/loans/{id}/repay
Notification Job: The NotificationService is scheduled to run every day at 8:00 AM. It queries the database for any active loans where the due date is today or earlier and dispatches an email exclusively to your personal Gmail account (as requested).
System Architecture Upgrades
- Interface-Driven Design: The Service layer employs interface contracts (BorrowerService, LoanService) for loose coupling and scalability.
- Data Transfer Objects (DTOs): API payloads exclusively use BorrowerDto and…

View on GitHub

What I Learned

Building this application taught me that security and distributed environments are not magic.

When you separate your frontend (Google Cloud Run) from your backend (Render), security suddenly becomes your biggest technical hurdle. Attempting to pass cookies across domains taught me deep, unexpected lessons about modern browser architecture, Preflight OPTIONS requests, and why major browsers actually intercept cross-domain cookies to protect privacy.

Additionally, I learned incredibly valuable lessons about Multi-Tenancy database migrations. When I upgraded the application to securely map existing financial records to authenticated user profiles, all of my old data completely "vanished"! By collaborating with Gemini, we built an automated DataMigrationRunner in Java that essentially scanned the PostgreSQL database for legacy, orphaned data during startup and flawlessly bound those records back to my isolated user profile using newly minted foreign keys.

Working with Gemini also taught me the value of interactive debugging. Instead of endlessly combing through StackOverflow threads when my frontend deployment returned an obscure gcloud run deploy port binding error, I could simply paste the logs directly to Gemini. It structurally unpacked how Nginx Alpine images process templates and provided the exact variable substitution fix instantaneously.

Google Gemini Feedback

What worked well: Gemini is incredibly strong at context retention across complex files. When I needed to refactor my Spring Security JwtAuthenticationFilter to accept both cookies and Bearer tokens, Gemini didn't just give me a generic code snippet; it understood the exact architecture of my Java files and provided surgical, drop-in code replacements. The same deep architectural awareness proved vital during our PostgreSQL schema migrations and Cloud Run Nginx optimisations.

Where I ran into friction: There were a few moments where Gemini would try to eagerly fix a bug before I had finished explaining the complete symptom. For example, when my frontend JavaScript was misfiring an onclick event, it occasionally suggested backend fixes before realising the bug was actually a simple string interpolation error in my Vanilla JS HTML template. Once we clarified the scope, however, the eventual fix was spot on. Additionally, I experienced a recurring loop where the agent would continuously execute superficial internal baseline scripts (like echo "do something") just to bypass strict system task-boundary protocols before finally delivering a direct chat response to my question!

Building a Full-Stack Bookkeeping Ledger Using Antigravity

Rohith V — Mon, 23 Feb 2026 13:29:48 +0000

I recently built a full-stack bookkeeping application to help track borrowed money and loan repayments. My goal for this side project was to build a secure, practical tool from scratch while gaining hands-on experience with modern, decoupled application architecture. I usually lend money, and most of the time, I get lost in tracking the records.

Since we have modern AI agents and tools, I use Google Antigravity IDE, where my primary focus was to provide the requirements, review the plan put forward by Antigravity, review the code, and provide suggestions.

Here is an overview of the project, the tech stack I used, and some of the technical challenges I solved along the way.

The Tech Stack

I chose to separate the frontend from the backend to mirror how production applications are often built. The project is hosted entirely on cloud-free tiers.

Backend: Java, Spring Boot 3, Spring Data JPA
Database: PostgreSQL (hosted on Neon.tech)
Frontend: Vanilla JavaScript, HTML, and CSS
Security: Spring Security 6 with stateless JWTs
Deployment: Render (Backend), GitHub Pages (Frontend), with GitHub Actions for CI/CD
IDE: Google Antigravity

Core Features

The application handles standard CRUD operations for managing borrowers and tracking active loans. However, I focused heavily on building out two specific areas: security and realistic repayment logic.

1.Partial Repayment Logic
Instead of just marking a loan as "paid" or "unpaid", I implemented an endpoint that allows for partial repayments.

When a user submits a repayment amount, the Spring Boot backend processes the math. If the remaining balance drops to zero or below, the program automatically deletes the loan record from the PostgreSQL database. If there is still a remaining balance, it securely updates the active record.

2.Stateless Security and JWTs
To secure the API, I implemented stateless authentication using JSON Web Tokens (JWT). Instead of storing the token in local storage, where it might be exposed to XSS attacks, the backend packages it in an HttpOnly cookie.

3.Handling Cross-Origin Requests
One of the main challenges of deploying a decoupled app is dealing with browser security policies. Because the frontend is hosted on GitHub Pages and the backend is on Render, the domains do not match.

By configuring the server only to accept JSON payloads and explicitly whitelisting the GitHub Pages domain, the browser's native preflight OPTIONS requests successfully neutralize CSRF threats without relying on third-party cookies.

4.Brute-Force Protection
To protect the database from automated login attacks, I integrated Bucket4j into the authentication flow. This acts as an API rate limiter, restricting users to a maximum of 5 login attempts per minute before temporarily blocking their IP.

Repository and Deployment

To ensure the project remains stable, I set up a GitHub Actions pipeline that automatically runs my JUnit and Mockito integration tests on every push.

You can view the source code and the live deployment here:

GitHub Repository:

Rohithv07 / BookKeeping

Record the debts that we are lending to other people.

BookKeeping

Record the debts that we are lending to other people.

What was implemented

Spring Boot App: A robust REST API running on Java 21, built using Gradle.
Database Models
- Borrower: Saves name, email, and phone.
- Loan: Tracks amount, date lent, exact 1-month (dueDate), and loan status (ACTIVE vs REPAID).
Core API Endpoints
- POST /api/borrowers and GET /api/borrowers
- POST /api/loans and GET /api/loans
- PUT /api/loans/{id}/repay
Notification Job: The NotificationService is scheduled to run every day at 8:00 AM. It queries the database for any active loans where the due date is today or earlier and dispatches an email exclusively to your personal Gmail account (as requested).
System Architecture Upgrades
- Interface-Driven Design: The Service layer employs interface contracts (BorrowerService, LoanService) for loose coupling and scalability.
- Data Transfer Objects (DTOs): API payloads exclusively use BorrowerDto and…

View on GitHub

Live Application: https://rohithv07.github.io/BookKeeping/

Please note that the app will be slow as all the deployments are with limited resources and a free tier.

Minimalism Defying Gravity: My Entry for the Google AI Portfolio Challenge 🚀

Rohith V — Sat, 17 Jan 2026 16:38:04 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

Senior Application Engineer @ Oracle | Java & Spring Boot Enthusiast

I am a Senior Application Engineer at Oracle with over 4 years of experience building scalable enterprise solutions and optimizing UI performance for thousands of customers. My work ranges from architecting Agentic AI tools to leading complex cloud migrations.

Beyond the corporate world, I am passionate about competitive programming and data structures. I love breaking down complex algorithmic challenges and sharing my learnings with the community. You might have seen my articles on Dev.to and Medium, where I help over 1,200 followers master Java and problem-solving.

Tech Stack: Java, Spring Boot, JavaScript, SQL Writing about: Data Structures, Algorithms, and System Design

Portfolio

How I Built It

Portfolio Minimal

A Minimal, Fresh, and Clean personal portfolio website built with React, Vite, Tailwind CSS, and Antigravity. It features a dual-interface design: a stunning standard scroll view and a geeky Terminal Mode for CLI enthusiasts.

✨ Features

Dual View Modes:
- Standard: Clean typography, smooth scrolling, and responsive layout.
- Terminal Mode: A simulated MacBook terminal environment. Type commands like /experience or /help to navigate.
Smart Navigation:
- ChatBot: An AI-style assistant that scrolls you to sections (e.g., "Show me your skills").
- Smooth Scroll: Polished scroll interactions.
Theming:
- Dark/Light Toggle: Seamless switching between light (fresh) and dark (sleek) themes.
Modern Tech Stack:
- React + Vite: Chosen for lightning-fast HMR and component-based architecture.
- Tailwind CSS: Utility-first styling for consistent design tokens and dark mode support.
- Framer Motion: Smooth, spring-physics based animations for entrance effects and interactions.
- Lucide React: Clean, lightweight SVG icons that match the minimal aesthetic.

? Design Philosophy

The goal was to build a portfolio that stands out by doing less.

Minimalism: We stripped away heavy backgrounds and complex layouts in favor of whitespace, typography, and content.
Freshness: The "Standard" view is designed to feel like a breath of fresh air—smooth scrolling, pill-shaped interactions, and subtle motion.
Geek Mode: For the developers and CLI lovers, we included a Terminal Mode and ChatBot. It's a nod to our roots—sometimes the command line is just faster (and cooler) than a GUI.

? Layout & Sections

Hero: Minimal introduction with resume download and social links.
Experience: Time-line style work history.
Highlights: "Most Proud Of" section with card layouts.
Skills: Technical stack showcase.

- Contact: Pill-shaped interactive contact links.

? Getting Started

Prerequisites

Node.js (v14 or higher)
npm or yarn

1. Fork & Clone

To make this project your own, fork the repository to your GitHub account:

Click the Fork button at the top right of this page.

Clone your forked repository:

git clone https://github.com/YOUR_USERNAME/portfolio-minimal.git
cd portfolio-minimal

2. Install Dependencies

Install the required packages:

npm install

3. Run Locally

Start the development server:

npm run dev

Open http://localhost:5173 (or the port shown in your terminal) to view it in the browser.

4. Build for Production

To create an optimized build for deployment:

npm run build

? Terminal Commands (MacBook View)

Switch to Terminal Mode by clicking the Laptop Icon in the navbar.

/help - List all commands
/experience - View work history
/skill - List technical skills
/proud - View highlights
/contact - Show contact info
exit - Return to standard view ### ? License Distribute freely. Credit is appreciated! MIT License.

What I'm Most Proud Of

Building the portfolio was one thing; deploying it was an entirely different beast. My goal was ambitious: a single codebase deployed simultaneously to GitHub Pages (for visibility) and Google Cloud Run (for the challenge).

Here is the breakdown of how everything broke, and the specific engineering decisions I made to fix it.

The Authentication Wall
The Error: Error: Key is already in use.
What broke: I was confident I had SSH keys set up, but when I tried to add my existing key to my GitHub account, I hit a brick wall. It turned out the key on my machine was already linked to an old, forgotten GitHub account. Since GitHub treats SSH keys as unique fingerprints, it wouldn't allow me to reuse the same key for my new identity. The Fix: instead of trying to recover the old account, I generated a brand new Ed25519 key specifically for this profile. I then configured my local SSH agent to recognize this new identity, effectively separating my past "ghost" account from my current work. The Lesson: In the world of git, keys are strict identities, not just reusable passwords. You can't be two people at once with the same fingerprint.
The "Missing" Homepage
The Error: My live site rendered my README.md instead of my React app. What broke: My project wasn't at the root of the repository; it was nested inside a /portfolio-minimal folder. GitHub Pages defaults to serving the root directory. The Fix: I moved away from the standard "Deploy from Branch" method and wrote a custom GitHub Actions workflow. I configured the upload-pages-artifact step to target my specific subdirectory (path: './portfolio-minimal'), essentially telling the build server exactly where to look.
The "Raw Code" Trap
The Error: 404 Not Found: /src/main.jsx What broke: Once the folder was found, the browser tried to load my source code directly. Browsers can't read React (.jsx) or TypeScript; they need standard JavaScript. The Fix: I updated my CI/CD pipeline to include a Build Step. I added a job to install Node.js dependencies and run npm run build inside the action. This compiled my raw React code into a static dist folder, which is what actually gets shipped to the user.
The Path Mismatch (The 404 Nightmare)
The Error: The site loaded, but was a blank white screen. The console screamed 404 for every CSS and JS asset. What broke: My repository name was Tryouts, so GitHub hosted the site at username.github.io/Tryouts/. However, Vite (my bundler) assumed the site was at the root (/), so it looked for assets in the wrong place. The Fix: I reconfigured vite.config.js to set the base path to /Tryouts/. This aligned my asset requests with the actual URL structure.
The Cloud Build Context
The Error: Dockerfile: no such file or directory What broke: Moving to Google Cloud Run, the build failed immediately. The Cloud Build trigger runs from the repository root, but my Dockerfile was hidden inside the subdirectory. The Fix: I modified the cloudbuild.yaml to include dir: portfolio-minimal in the build step. This forced the builder to "change directory" into my project folder before attempting to read the Docker instructions.
The Port Collision
The Error: The user-provided container failed to start... PORT=8080 What broke: Cloud Run acts as a reverse proxy sending traffic to port 8080. My Nginx container was listening on the standard web port 80. The signals were crossing, and the container crashed. The Fix: I updated my Nginx configuration (nginx.conf) and Dockerfile to explicitly listen and EXPOSE port 8080, aligning my container's internal networking with Google's infrastructure requirements.
The Dual-Environment Dilemma (The Final Boss)
The Error: Fixing the path for GitHub Pages (/Tryouts/) broke the site on Cloud Run (which runs at the root /). I couldn't have hardcoded paths for both. What broke: One static configuration cannot serve two different deployment environments. The Fix: I implemented conditional logic in my build process.

In vite.config.js, I added a check for an environment variable called BASE_PATH.

In my Dockerfile, I injected ENV BASE_PATH=/.

Result: When building for GitHub, it defaults to /Tryouts/. When building for Docker/Cloud Run, it dynamically switches to /.

💡 The Big Takeaway
This project wasn't just about writing React components; it was a crash course in DevOps. I learned that code doesn't live in a vacuum—it lives in environments, and mastering those environments is just as important as mastering the syntax.

My Github Project Link : https://github.com/Rohithv07/Tryouts/tree/main/portfolio-minimal

Whats new

Latest Writing section in the portfolio that picks latest article publised in DEV.to

Here is the breakdown of the steps I took:

1. The Strategy (Why)

Source: Dev.to provides a free, public API (https://dev.to/api/articles) that requires no authentication for reading public posts, making it perfect for a lightweight frontend integration.

2. The Implementation (How)

I created a new component

src/components/LatestArticles.jsx
with the following logic:

Fetch Data:

I used a useEffect hook to call https://dev.to/api/articles?username=rohithv07&per_page=3.
This returns a JSON array of latest posts, sorted by date.

Handle States:

Loading: While fetching, I display 3 gray "skeleton" boxes so the layout doesn't jump around.

Error: If the API fails (e.g., rate limits), I fallback gracefully to a simple "Check out my profile" button instead of crashing the page.

Render the UI:

I mapped over the data to create cards.
Visuals: I used the cover_image for visual impact and added a hover zoom effect.
Metrics: I displayed public_reactions_count and comments_count to prove engagement (validating your "Highlights" claim).
Integration:

I placed the component in App.jsx directly after "Highlights" section. This creates a logical flow: Here is what I'm proud of (Highlights) -> Here is proof of my knowledge (Latest Writing).

Automating Java Builds with GitHub Actions

Rohith V — Sat, 17 Jan 2026 10:18:30 +0000

We've all been there. You write code, it runs perfectly on your laptop, you push it, and... the build breaks for everyone else. Or worse, a bug sneaks into production because someone forgot to run the tests.

This is where Continuous Integration (CI) comes in.

In this guide, we are going to break down a very simple GitHub Actions workflow that automatically builds and tests 2 Microservices application (Order Service & Product Service) every time you push code.

What Problem Does This Solve?

Before we look at the code, let's understand why we need it. This YAML file lives in your repository. It solves three massive problems:

Consistency: It builds your code in a clean, neutral environment (Ubuntu), not on your potentially messy laptop.
Early Bug Detection: It runs your tests automatically on every Pull Request. You can't merge broken code.
Monorepo Support: It handles multiple services (OrderService and ProductService) in a single repository, ensuring a change in one doesn't break the other.

The Workflow File

Here is the complete ci.yml file we will be analyzing:


name: Java CI with Maven

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Set up JDK 17
      uses: actions/setup-java@v4
      with:
        java-version: '17'
        distribution: 'temurin'
        cache: maven

    - name: Build and Test Order Service
      working-directory: ./OrderService
      run: |
        chmod +x mvnw
        ./mvnw clean verify

    - name: Build and Test Product Service
      working-directory: ./ProductService
      run: |
        chmod +x mvnw
        ./mvnw clean verify

The Code Breakdown

Let's dissect the configuration line by line.

1.The Setup & Triggers


name: Java CI with Maven

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]
  workflow_dispatch:

name: This is how the workflow appears in the "Actions" tab on GitHub.

on: These are the triggers. When does this robot wake up?

push: Runs whenever code is pushed to the main branch.

pull_request: Runs whenever someone tries to merge code into main (Crucial for code review!).

workflow_dispatch: A feature that lets you manually click a "Run Workflow" button in the GitHub UI (great for debugging).

2.The Environment (The Job)


jobs:
  build:
    runs-on: ubuntu-latest

jobs: A workflow is made of one or more jobs. Here, we just have one called build.

runs-on: ubuntu-latest: This tells GitHub to provision a fresh virtual machine running the latest version of Ubuntu Linux. This is where your code will be downloaded and tested.

3.The Steps (The Actual Work)

Step A: Get the Code


    steps:
    - name: Checkout code
      uses: actions/checkout@v4

uses: This keyword pulls in a pre-made script from the GitHub Marketplace. actions/checkout is the standard action that clones your repository onto the Ubuntu runner so the script can access your files.

Step B: Prepare Java


    - name: Set up JDK 17
      uses: actions/setup-java@v4
      with:
        java-version: '17'
        distribution: 'temurin'
        cache: maven

uses: actions/setup-java: Installs Java on the runner.

distribution: 'temurin': Specifies which vendor of Java to use (Eclipse Temurin is a popular choice).

cache: maven: This speeds up your build massively! It remembers your downloaded dependencies (JARs) so it doesn't have to re-download the internet every time the build runs.

Step C: Build the Microservices


    - name: Build and Test Order Service
      working-directory: ./OrderService
      run: |
        chmod +x mvnw
        ./mvnw clean verify

This is where the magic happens. Since you have a monorepo (multiple projects in one folder), we handle them separately.

working-directory: Tells the runner to cd (change directory) into ./OrderService before running commands.

chmod +x mvnw: Grants execution permission to the Maven Wrapper.

./mvnw clean verify: The command that actually builds your app.

Why mvnw and not mvn? The "Wrapper" ensures the build uses the exact Maven version defined in your project.

Why verify? In the Maven lifecycle, verify runs validation, compilation, unit tests, and integration tests. It is more robust than just install.

How to Set This Up in GitHub

Open your project locally or on GitHub.
Create the directory structure: Inside your project root, create a folder named .github and inside that, a folder named workflows.

Path: .github/workflows/

Create the file: Create a new file named ci.yml.
Paste the code: Copy the YAML code we analyzed above into this file.

Commit and Push:


git add .github/workflows/ci.yml
git commit -m "Add CI pipeline"
git push origin main

That's it!

Go to the "Actions" tab in your GitHub repository. You will see your workflow spinning up. If the circles turn Green, your code is safe. If they turn Red, you broke the build—and thankfully, you found out before your users did.

Sample Setup : https://github.com/Rohithv07/OnlineShopping/blob/main/.github/workflows/ci.yml

Java Solution: Redundant Parenthesis Detection O(N)

Rohith V — Sat, 17 Jan 2026 06:29:45 +0000

Problem

Given a string of balanced expression s, check if it contains a redundant parenthesis or not. A set of parenthesis are redundant if the same sub-expression is surrounded by unnecessary or multiple brackets.
Note: Expression may contain + , — , *, and / operators. Given expression is valid and there are no white spaces present.

Examples:

Input: s = "((a+b))"
Output: true
Explanation: ((a+b)) can reduced to (a+b).

Input: s = "(a+(b)/c)"
Output: true
Explanation: (a+(b)/c) can reduced to (a+b/c) because b is surrounded by () which is redundant.

Input: s = "(a+b+(c+d))"
Output: false
Explanation:(a+b+(c+d)) doesn't have any redundant or multiple brackets.

Constraints:

1 ≤ |s| ≤10^5

Approach

In a naive approach, we might treat the string as a sequence of sub-expressions. The goal is to isolate every pair of matching parentheses ( ... ) and check the contents inside them.

The Algorithm

Iterate through the string to find an opening bracket (.
Scan forward to find the matching closing bracket ).
Extract the substring between them. 4.Scan that substring:
- Does it contain an operator (+, -, *, /)?
- If No, the brackets are redundant (e.g., (a)).
- If Yes, checking isn’t done yet — we have to ensure we didn’t just capture a nested redundant pair like ((a+b)).

Why this is inefficient

Complexity: finding a matching bracket and extracting substrings repeatedly forces us to scan the string multiple times. In the worst case (deeply nested brackets), this approaches O(N²) time complexity.
Messy Logic: Handling nested structures like ((a+b)*(c-d)) without a stack requires complex index tracking to ensure you are looking at the correct matching bracket, not just the next one you see.

We need a way to process the expression in a single pass (O(N)). Since the problem involves nested structures (brackets inside brackets), the Last-In-First-Out (LIFO) property of a Stack is the perfect tool.

Instead of scanning forward to find the end of a bracket pair, we can process characters as they come and “resolve” them when we hit a closing bracket ).

The Optimal Stack Approach

We treat the Stack as a “holding area” for the parts of the expression we haven’t finished evaluating yet.

Iterate through the expression.
If we see an open bracket ( or an operator: Push it onto the stack. These are the components that might be part of a valid sub-expression.
If we see a closing bracket ): This is our trigger. It means a sub-expression has just ended. We need to check if that sub-expression was "useful."

4.Start popping from the stack until we hit the matching (.
While popping, did we encounter an operator?
Yes: The brackets enclosed an operation (e.g., (a+b)), so they were necessary.
No: The brackets enclosed nothing of value (e.g., (a) or ()), so they are Redundant.

Time and Space Complexity

Time O(N): Single pass iteration, each element pushed/popped once.

Space O(N): Stack acts as a buffer; worst case stores all characters.

Code

class Solution {
    public static boolean checkRedundancy(String s) {
        // code here
        if (s == null || s.length() == 0) {
            return false;
        }
        Stack<Character> stack = new Stack<>();
        for (char ch : s.toCharArray()) {
            boolean isRedundant = true;
            if (ch == ')') {
                while (!stack.isEmpty() && stack.peek() != '(') {
                    char topChar = stack.pop();
                    if (isValidOperator(topChar)) {
                        isRedundant = false;
                    }
                }
                if (!stack.isEmpty()) {
                    stack.pop();
                }
                if (isRedundant) {
                    return true;
                }
            }
            else if (isValidChar(ch)) {
                stack.push(ch);
            }
        }
        return false;
    }

    private static boolean isValidOperator(char ch) {
        return ch == '+' || ch == '-' || ch == '/' || ch == '*';
    }

    private static boolean isValidChar(char ch) {
        return isValidOperator(ch) || ch == '(';
    }
}

Leetcode 3613. Minimize Maximum Component Cost

Rohith V — Sun, 13 Jul 2025 06:55:46 +0000

Problem Statement

You are given an undirected connected graph with n nodes labeled from 0 to n - 1 and a 2D integer array edges where edges[i] = [ui, vi, wi] denotes an undirected edge between node ui and node vi with weight wi, and an integer k.

You are allowed to remove any number of edges from the graph such that the resulting graph has at most k connected components.

The cost of a component is defined as the maximum edge weight in that component. If a component has no edges, its cost is 0.

Return the minimum possible value of the maximum cost among all components after such removals.

Test Cases

Example 1:

Input: n = 5, edges = [[0,1,4],[1,2,3],[1,3,2],[3,4,6]], k = 2

Output: 4

Explanation:

Remove the edge between nodes 3 and 4 (weight 6).
The resulting components have costs of 0 and 4, so the overall maximum cost is 4.
Example 2:

Input: n = 4, edges = [[0,1,5],[1,2,5],[2,3,5]], k = 1

Output: 5

Explanation:

No edge can be removed, since allowing only one component (k = 1) requires the graph to stay fully connected.
That single component’s cost equals its largest edge weight, which is 5.

Constraints:

1 <= n <= 5 * 10^4
0 <= edges.length <= 10^5
edges[i].length == 3
0 <= ui, vi < n
1 <= wi <= 10^6
1 <= k <= n
The input graph is connected.

Intuition

From the problem statement, we need to find the minimum possible value of the maximum edge weight such that, if we remove all edges with weight greater than this value, the graph splits into at most k connected components.

This hints at a binary search strategy on the edge weights, because we’re looking for the minimum value satisfying a condition.

The concept of connected components immediately suggests using Union Find (Disjoint Set Union - DSU) or DFS/BFS. Since DSU is more efficient for repeated connectivity queries, it's the preferred choice here.

So the idea is:

🔍 Use binary search on the edge weight — and for each weight W, check if the number of connected components formed using only edges ≤ W is ≤ k.

Approach

Identify the maximum edge weight in the graph — this is the upper bound for binary search.
Perform binary search in the range [0, maxWeight]:
- For each midpoint weight W, consider only edges with weight ≤ W.
- Use Union Find to connect nodes using only those edges.
- Count the number of connected components formed.
If the number of components is ≤ k, then W is a valid candidate, but try to find a smaller one (move right = mid - 1).
If more than k components are formed, then W is too small (move left = mid + 1).
Finally, return the smallest weight that satisfies the condition.

Complexity

Time Complexity:

O(log(maxWeight) * E * α(N))

Binary Search: O(log(maxWeight))
Each check: Union-Find over all E edges → O(E * α(N)), where α(N) is the inverse Ackermann function (nearly constant time).

Space Complexity:

O(N) for Union-Find structures

Code

class Solution {
    public int minCost(int n, int[][] edges, int k) {
        if (edges == null || n <= 0 || k < 0) {
            return 0;
        }
        int maxWeight = 0;
        for (int [] edge : edges) {
            maxWeight = Math.max(maxWeight, edge[2]);
        }
        return findMinCost(edges, k, n, maxWeight);
    }

    public int findMinCost(int [][] edges, int k, int n, int maxWeight) {
        int low = 0;
        int high = maxWeight;
        int answer = -1;
        while (low <= high) {
            int middle = low + (high - low) / 2;
            if (isGraphHaveKComponent(edges, k, middle, n)) {
                answer = middle;
                high = middle - 1;
            }
            else {
                low = middle + 1;
            }
        }
        return answer;
    }

    private boolean isGraphHaveKComponent(int [][] edges, int k, int currentMaxWeight, int n) {
        UnionFind unionFind = new UnionFind(n);
        for (int [] edge : edges) {
            int node1 = edge[0];
            int node2 = edge[1];
            int weight = edge[2];
            if (weight <= currentMaxWeight) {
                unionFind.union(node1, node2);
            }
        }
        return unionFind.getComponentCount() <= k;
    }
}

class UnionFind {
    int [] rank;
    int [] parent;
    int componentCount;

    public UnionFind(int n) {
        if (n <= 0) {
            throw new IllegalArgumentException("N cannot be less or equal to 0");
        }
        componentCount = n;
        rank = new int [n];
        parent = new int [n];
        for (int node = 0; node < n; node++) {
            rank[node] = 1;
            parent[node] = node;
        }
    }

    public int findParent(int node) {
        if (node != parent[node]) {
            parent[node] = findParent(parent[node]);
        }
        return parent[node];
    }

    public void union(int node1, int node2) {
        int parentNode1 = findParent(node1);
        int parentNode2 = findParent(node2);
        if (parentNode1 == parentNode2) {
            return;
        }
        if (rank[parentNode1] < rank[parentNode2]) {
            parent[parentNode1] = parentNode2;
            rank[parentNode2] += rank[parentNode1];
        }
        else {
            parent[parentNode2] = parentNode1;
            rank[parentNode1] += rank[parentNode2];
        }
        componentCount--;
    }

    public boolean isConnectedComponent(int node1, int node2) {
        return findParent(node1) == findParent(node2);
    }

    public int getComponentCount() {
        return componentCount;
    }

}

Leetcode 1751. Maximum Number of Events That Can Be Attended II

Rohith V — Tue, 08 Jul 2025 18:33:04 +0000

Problem Statement

You are given an array of events where events[i] = [startDayi, endDayi, valuei]. The ith event starts at startDayi and ends at endDayi, and if you attend this event, you will receive a value of valuei. You are also given an integer k which represents the maximum number of events you can attend.

You can only attend one event at a time. If you choose to attend an event, you must attend the entire event. Note that the end day is inclusive: that is, you cannot attend two events where one of them starts and the other ends on the same day.

Return the maximum sum of values that you can receive by attending events.

Test Cases

Example 1:

Input: events = [[1,2,4],[3,4,3],[2,3,1]], k = 2
Output: 7
Explanation: Choose the green events, 0 and 1 (0-indexed) for a total value of 4 + 3 = 7.

Example 2:

Input: events = [[1,2,4],[3,4,3],[2,3,10]], k = 2
Output: 10
Explanation: Choose event 2 for a total value of 10.

Notice that you cannot attend any other event as they overlap, and that you do not have to attend k events.

Example 3:

Input: events = [[1,1,1],[2,2,2],[3,3,3],[4,4,4]], k = 3
Output: 9
Explanation: Although the events do not overlap, you can only attend 3 events. Pick the highest valued three.

Intuition

The core idea is to evaluate, for each event, two possible decisions:

Skip the event: simply move to the next index.
Attend the event: add its value, and move to the next available event that starts after the current event’s end day.

Since we're constrained by a limit of k events, and decisions depend on both current index and remaining count k, this naturally leads to overlapping subproblems — perfect for memoization.

To efficiently find the next non-overlapping event, we use binary search, as the events are sorted by start time.

if we skip, then 0 + f(event, index + 1, k)
if we do not skip, then val + f(event, index + 1, k - 1)

Approach

Sort the events by their startDay to enable binary search.
Define a recursive function findMaxValue(events, k, index, dp):
- Base case: if k == 0 or index is out of bounds, return 0.
- Memoization: return cached value if already computed.
- Recursive logic:
  - Skip the current event → findMaxValue(events, k, index + 1)
  - Attend the event → add its value + recurse from the next non-overlapping event.
Use binary search to find the next non-overlapping event whose startDay > current.endDay.
Store results in dp[index][k] to avoid recomputation.

Complexity

Time Complexity

O(n log n + n * k)
- Sorting: O(n log n)
- Each state dp[i][k] is computed once.
- Binary search per state is O(log n) but efficient in practice.

Space Complexity

O(n * k) for the memoization table.
Recursion stack space: O(k) in the worst case.

Code

class Solution {
    public int maxValue(int[][] events, int k) {
        Arrays.sort(events, (a, b) -> a[0] - b[0]); 
        int n = events.length;
        int [][] dp = new int [n][k + 1];
        for (int [] d : dp) {
            Arrays.fill(d, -1);
        }
        return findMaxValue(events, k, 0, dp);
    }

    private int findMaxValue(int [][] events, int k, int index, int [][] dp) {
        if (k < 1) {
            return 0;
        }
        if (index >= events.length) {
            return 0;
        }
        if (dp[index][k] != -1) {
            return dp[index][k];
        }
        int skipEvent = findMaxValue(events, k, index + 1, dp);
        int nextIndex = findNextStart(events, index + 1, events[index][1]);
        int attendEvent = events[index][2];
        if (nextIndex != -1) {
            attendEvent += findMaxValue(events, k - 1, nextIndex, dp);
        }
        return dp[index][k] = Math.max(skipEvent, attendEvent);
    }

    private int findNextStart(int [][] events, int left, int key) {
        int right = events.length - 1;
        int answer = -1;
        while (left <= right) {
            int middle = left + (right - left) / 2;
            if (events[middle][0] > key) {
                answer = middle;
                right = middle - 1;
            }
            else {
                left = middle + 1;
            }
        }
        return answer;
    }
}

Next Greater Element in Circular Array

Rohith V — Mon, 07 Jul 2025 18:28:21 +0000

Problem Statement

Given a circular integer array arr[], the task is to determine the next greater element (NGE) for each element in the array.

The next greater element of an element arr[i] is the first element that is greater than arr[i] when traversing circularly. If no such element exists, return -1 for that position.

Circular Property:

Since the array is circular, after reaching the last element, the search continues from the beginning until we have looked at all elements once.

Examples:

Input: arr[] = [1, 3, 2, 4]
Output: [3, 4, 4, -1]
Explanation:
The next greater element for 1 is 3.
The next greater element for 3 is 4.
The next greater element for 2 is 4.
The next greater element for 4 does not exist, so return -1.

Input: arr[] = [0, 2, 3, 1, 1]
Output: [2, 3, -1, 2, 2]
Explanation:
The next greater element for 0 is 2.
The next greater element for 2 is 3.
The next greater element for 3 does not exist, so return -1.
The next greater element for 1 is 2 (from circular traversal).
The next greater element for 1 is 2 (from circular traversal).

Constraints:

1 ≤ arr.size() ≤ 10^5
0 ≤ arr[i] ≤ 10^6

Intuition

To find the next greater element for each value in a circular array, we need to determine, for each number, the next number in traversal order that is strictly greater than it.

We use a stack to keep track of the indices of elements for which we haven't yet found a next greater element. When we encounter a new number, we compare it with the elements indexed at the top of the stack:

If the current number is greater than the one at the stack's top, then it's the "next greater element" for that previous number — we pop and record the result.

We repeat this until we can't find more matches or the stack is empty.

Since the array is circular, we iterate from 0 to 2 * n - 1 and use index % n to simulate wrapping around.

Important note: We only push indices less than n into the stack to avoid redundant processing in the second half (which is just to simulate the circular nature).

Steps

Check for null or empty input and return an empty list if so.
Initialize a stack for indices and an integer array result of length n.
Loop i from 0 to 2*n – 1:

Let j = i % n.
While the stack is not empty and arr[stack.peek()] < arr[j], pop an index and set result[pop] = arr[j].
If i < n, push j onto the stack.

After the loop, any indices still in the stack have no next greater element; set their result entry to -1.
Convert result into an ArrayList and return it.

Complexity

Time: O(n) — each element is pushed and popped at most once over the 2n iterations.

Space: O(n) — for the stack and the result array/list.

Code

class Solution {
    public ArrayList<Integer> nextLargerElement(int[] arr) {
        // code here
        if (arr == null || arr.length == 0) {
            return new ArrayList<>();
        }
        int length = arr.length;
        Stack<Integer> stack = new Stack<>();
        int [] result = new int [length];
        for (int index = 0; index < length * 2; index++) {
            while (!stack.isEmpty() && arr[stack.peek() % length] < arr[index % length]) {
                int currentIndex = stack.pop();
                result[currentIndex % length] = arr[index % length];
            }
            if (index < length)
                stack.push(index);
        }
        while (!stack.isEmpty()) {
            result[stack.pop() % length] = -1;
        }
        ArrayList<Integer> resultList = new ArrayList<>();
        for (int num : result) {
            resultList.add(num);
        }
        return resultList;
    }
}

Maximum Score From Subarray Mins

Rohith V — Sat, 05 Jul 2025 06:39:25 +0000

Problem Statement

You are given an array arr[] of integers. Your task is to find the maximum sum of the smallest and second smallest elements across all subarrays (of size >= 2) of the given array.

Input cases

Examples :

Input: arr[] = [4, 3, 5, 1]
Output: 8
Explanation: All subarrays with at least 2 elements and find the two smallest numbers in each:
[4, 3] → 3 + 4 = 7
[4, 3, 5] → 3 + 4 = 7
[4, 3, 5, 1] → 1 + 3 = 4
[3, 5] → 3 + 5 = 8
[3, 5, 1] → 1 + 3 = 4
[5, 1] → 1 + 5 = 6
Maximum Score is 8.
Input: arr[] = [1, 2, 3]
Output: 5
Explanation: All subarray with at least 2 elements and find the two smallest numbers in each:
[1, 2] → 1 + 2 = 3
[1, 2, 3] → 1 + 2 = 3
[2, 3] → 2 + 3 = 5
Maximum Score is 5

Constraints:

2 ≤ arr.size() ≤ 10^5
1 ≤ arr[i] ≤ 10^6

Intuition

Instead of iterating through all possible subarrays and finding the smallest and second smallest elements (which is inefficient), we can simplify the problem using the following observation:

To maximize the sum of the two smallest elements in a subarray, both of them should be as large as possible.

This naturally leads us to a key insight:

Key Insight:

Among all subarrays of size ≥ 2, the ones with only 2 elements are sufficient to check.

Why? Because:

In a longer subarray (size ≥ 3), the two smallest elements tend to be smaller, hence their sum is also smaller.

With just 2 elements, we know the smallest and second smallest directly — it's just the two numbers themselves.

Steps

Initialize a variable maxSum to 0.
Loop through the array and for every adjacent pair, calculate their sum.
Update maxSum with the maximum of the current sum and the existing maxSum.
Return maxSum at the end.

Time and Space Complexity

Time Complexity: O(N) where N is the length of the array.
Space Complexity: O(1) as no extra space is used.

Code

class Solution {
    public int maxSum(int arr[]) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        int maxSum = 0;
        int length = arr.length;
        for (int index = 0; index < length - 1; index++) {
            maxSum = Math.max(maxSum, arr[index] + arr[index + 1]);
        }
        return maxSum;
    }
}

Leetcode 2099. Find Subsequence of Length K With the Largest Sum

Rohith V — Sat, 28 Jun 2025 06:43:30 +0000

Problem

You are given an integer array nums and an integer k. You want to find a subsequence of nums of length k that has the largest sum.

Return any such subsequence as an integer array of length k.

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

Testcases

Example 1:

Input: nums = [2,1,3,3], k = 2
Output: [3,3]
Explanation:
The subsequence has the largest sum of 3 + 3 = 6.
Example 2:

Input: nums = [-1,-2,3,4], k = 3
Output: [-1,3,4]
Explanation:
The subsequence has the largest sum of -1 + 3 + 4 = 6.
Example 3:

Input: nums = [3,4,3,3], k = 2
Output: [3,4]
Explanation:
The subsequence has the largest sum of 3 + 4 = 7.
Another possible subsequence is [4, 3].

Constraints:

1 <= nums.length <= 1000
-10^5 <= nums[i] <= 10^5
1 <= k <= nums.length

Intuition

To achieve the largest possible sum of a subsequence of length k, it makes sense to select the k largest elements from the array. However, since a subsequence must preserve the original order of elements, we can't simply sort and pick — we must track both the value and the original index.

Approach

Use a min-heap (priority queue) to maintain the top k largest elements. Each element in the heap is a pair of [value, index].

When the heap size exceeds k, remove the smallest element. This ensures the heap always contains the k largest elements.

Use a TreeMap to store the k elements with their original indices as keys. This automatically sorts them by index to preserve their relative order.

Build the result array by traversing the TreeMap in key order.

Time Complexity

O(n log k) — inserting into the heap for n elements with max size k

O(k log k) — for TreeMap insertion and sorting by index

O(k) — to construct the result array
Total: O(n log k + k log k)

Space Complexity

O(k) — for the heap and the TreeMap

Code

class Solution {
    public int[] maxSubsequence(int[] nums, int k) {
        if (nums == null || k < 0) {
            return new int []{};
        }
        int length = nums.length;
        int [] result = new int [k];
        PriorityQueue<int[]> minHeap = new PriorityQueue<>((p1, p2) -> Integer.compare(p1[0], p2[0]));
        TreeMap<Integer, Integer> kIndexNumber = new TreeMap<>();
        for (int index = 0; index < length; index++) {
            minHeap.offer(new int []{nums[index], index});
            if (minHeap.size() > k) {
                minHeap.poll();
            }
        }
        int resultIndex = 0;
        while (!minHeap.isEmpty()) {
            int [] top = minHeap.poll();
            kIndexNumber.put(top[1], top[0]);
        }
        for (Integer key : kIndexNumber.keySet()) {
            result[resultIndex++] = kIndexNumber.get(key);
        }
        return result;
    }
}

Leetcode 1432. Max Difference You Can Get From Changing an Integer

Rohith V — Sat, 28 Jun 2025 06:41:31 +0000

Problem Statement

You are given an integer num. You will apply the following steps to num two separate times:

Pick a digit x (0 <= x <= 9).
Pick another digit y (0 <= y <= 9). Note y can be equal to x.
Replace all the occurrences of x in the decimal representation of num by y.
Let a and b be the two results from applying the operation to num independently.

Return the max difference between a and b.

Note that neither a nor b may have any leading zeros, and must not be 0.

Test Cases

Example 1:

Input: num = 555
Output: 888
Explanation: The first time pick x = 5 and y = 9 and store the new integer in a.
The second time pick x = 5 and y = 1 and store the new integer in b.
We have now a = 999 and b = 111 and max difference = 888
Example 2:

Input: num = 9
Output: 8
Explanation: The first time pick x = 9 and y = 9 and store the new integer in a.
The second time pick x = 9 and y = 1 and store the new integer in b.
We have now a = 9 and b = 1 and max difference = 8

Constraints:

1 <= num <= 10^8

Intuition

We care about the maximum value that we can get by replacing some digit with x and minimum value that we can get by replacing some digit with y.
This will always gives a maximum different.
To get the maximum value, we can replace the first digit which is not 9 with 9. This will give us the max value as 9.
Eg :
92321 => replacing 2 with 9 => 99391

Similarly we need to get the minimum value. Incase of minimum value, there are two cases to consider.

If the first number is > 1, in that case, we can replace it with 1 and it will give us the minimum. Eg : 92321 => replace 9 by 1 => 12321. We can replace by 0, as no leading zero is allowed.
Another case if first number is already 1. If it is already 1, then we need to find the number > 1 and replace it with 0. Eg : 11112 => replace last 2 by 0 => 11110

Difference between them will give us the result.

Approach

Convert the number to string for easy processing.
Find the first digit which is not 9 and convert all its occurance to 9. This is our max.
Find the digit which is either > 1, replace it 1 or if its already 1, replace with 0.
Parse it to get the intervalue and take the different.

Complexity

Time complexity:

O(10) as we are going through the digit, as there can be only 10 digit max.
Space complexity:

O(10) as we are creating strings.

Code

class Solution {
    public int maxDiff(int num) {
        char [] forMax = Integer.toString(num).toCharArray();
        char [] forMin = Integer.toString(num).toCharArray();
        // for maximum value, replace the first non 9 digit to 9
        // for minimum, we have 2 case,
        // if first letter is 1, then first character which is not 1 should be replaced to 0
        // else first letter > 1 should be relaced with 1. This is because leading 0 is not allowed.
        int right = 0;
        int length = forMax.length;
        while (right < length && forMax[right] == '9') {
            right++;
        }
        int maxValue = 0;
        int minValue = 0;
        if (right == length) {
            maxValue = Integer.parseInt(new String(forMax));
        }
        else {
            char target = forMax[right];
            while (right < length) {
                if (forMax[right] == target)
                    forMax[right] = '9';
                right++;
            }
            maxValue = Integer.parseInt(new String(forMax));
        }
        // System.out.println(maxValue);
        if (forMin[0] - '0' > 1) {
            char target = forMin[0];
            for (int index = 0; index < length; index++) {
                if (forMin[index] == target) {
                    forMin[index] = '1';
                }
            }
            minValue = Integer.parseInt(new String(forMin));
        }
        else {
            right = 0;
            while (right < length && forMin[right] - '0' <= 1) {
                right++;
            }
            if (right == length) {
                minValue = Integer.parseInt(new String(forMin));
            }
            else {
                char target = forMin[right];
                while (right < length) {
                    if (forMin[right] == target)
                        forMin[right] = '0';
                    right++;
                }
                minValue = Integer.parseInt(new String(forMin));
            }
        }
        // System.out.println(minValue);
        return maxValue - minValue;
    }
}

Leetcode 1432. Max Difference You Can Get From Changing an Integer

Rohith V — Sun, 15 Jun 2025 12:09:57 +0000

Problem Statement

You are given an integer num. You will apply the following steps to num two separate times:

Return the max difference between a and b.

Note that neither a nor b may have any leading zeros, and must not be 0.

Test Cases

Example 1:

Constraints:

1 <= num <= 10^8

Intuition

Similarly we need to get the minimum value. Incase of minimum value, there are two cases to consider.

If the first number is > 1, in that case, we can replace it with 1 and it will give us the minimum. Eg : 92321 => replace 9 by 1 => 12321. We can replace by 0, as no leading zero is allowed.
Another case if first number is already 1. If it is already 1, then we need to find the number > 1 and replace it with 0. Eg : 11112 => replace last 2 by 0 => 11110

Difference between them will give us the result.

Approach

Convert the number to string for easy processing.
Find the first digit which is not 9 and convert all its occurance to 9. This is our max.
Find the digit which is either > 1, replace it 1 or if its already 1, replace with 0.
Parse it to get the intervalue and take the different.

Complexity

Time complexity:

O(10) as we are going through the digit, as there can be only 10 digit max.
Space complexity:

O(10) as we are creating strings.

Code

class Solution {
    public int maxDiff(int num) {
        char [] forMax = Integer.toString(num).toCharArray();
        char [] forMin = Integer.toString(num).toCharArray();
        // for maximum value, replace the first non 9 digit to 9
        // for minimum, we have 2 case,
        // if first letter is 1, then first character which is not 1 should be replaced to 0
        // else first letter > 1 should be relaced with 1. This is because leading 0 is not allowed.
        int right = 0;
        int length = forMax.length;
        while (right < length && forMax[right] == '9') {
            right++;
        }
        int maxValue = 0;
        int minValue = 0;
        if (right == length) {
            maxValue = Integer.parseInt(new String(forMax));
        }
        else {
            char target = forMax[right];
            while (right < length) {
                if (forMax[right] == target)
                    forMax[right] = '9';
                right++;
            }
            maxValue = Integer.parseInt(new String(forMax));
        }
        // System.out.println(maxValue);
        if (forMin[0] - '0' > 1) {
            char target = forMin[0];
            for (int index = 0; index < length; index++) {
                if (forMin[index] == target) {
                    forMin[index] = '1';
                }
            }
            minValue = Integer.parseInt(new String(forMin));
        }
        else {
            right = 0;
            while (right < length && forMin[right] - '0' <= 1) {
                right++;
            }
            if (right == length) {
                minValue = Integer.parseInt(new String(forMin));
            }
            else {
                char target = forMin[right];
                while (right < length) {
                    if (forMin[right] == target)
                        forMin[right] = '0';
                    right++;
                }
                minValue = Integer.parseInt(new String(forMin));
            }
        }
        // System.out.println(minValue);
        return maxValue - minValue;
    }
}