DEV Community: seonglinchua

📊 From Crystal Reports to Modern Reporting: My Journey

seonglinchua — Mon, 07 Jul 2025 15:12:54 +0000

"What began as drag-and-drop reporting became a quest for reusable, developer-first designs."

🕰️ The Legacy: Crystal Reports

When I first started building enterprise apps, Crystal Reports was the default solution for generating structured reports.

It offered:

Drag-and-drop design
Easy integration with .xsd datasets
Simple binding for stored procedures
Visual formatting with subreports

But with time, the cracks showed:

❌ Difficult versioning and collaboration
🐌 Slow preview and rendering for large reports
🧱 Static, UI-bound design process
🧩 Too much friction for CI/CD and automation

💥 The Breaking Point

Once the system grew:

My stored procedures were returning 30+ tables
Every report revision required opening a UI designer
Binding logic was opaque and brittle

I needed a better solution — one that aligned with how modern software is built.

🔁 The Shift: Code-Driven Reporting

I explored multiple options. My goal was clear:

✅ Build reports as code

✅ Enable reuse, automation, and testability

✅ Avoid proprietary formats

I evaluated:

🧾 iText7 – PDF generation with full C# control
📊 EPPlus – Excel output with charts & formatting
📈 Telerik Reporting – clean UI + developer-friendly structure
⚙️ FastReport.NET – balance between designer + code integration

🧠 My New Approach

Here’s what reporting looks like for me now:

Define report layouts in JSON or config files
Use Dapper to fetch data from DB
Generate reports via C# services (console/web API)
Store output as PDF / XLSX
Log execution results using Serilog

Everything is version-controlled, headless, and CI-ready.

🧩 Report Flow Now Looks Like This:

No UI needed. No designer crashes. Just reproducible reports every time.

🚀 What I Gained

✅ Automation-friendly workflows
✅ Easy to plug into jobs or web APIs
✅ Code-first design = easier collaboration
✅ No more hidden data bindings
✅ Reusable across systems (dashboard, batch jobs, ad-hoc UI)

📎 Advice for Devs Still Using Crystal Reports

Crystal Reports still works — but if you want to scale or automate:

Start separating data retrieval from visual design
Use reporting as an output, not a tool
Explore iText7 or Telerik Reporting if you're C# based

And most importantly, think:

How would this report behave in a headless system?

🔮 What’s Next?

Building a web-based report viewer
Exploring Power BI / Tableau for advanced analytics
Considering report-as-code tools like ReportSharp
Eventually integrating AI-driven report summaries

💬 How About You?

Are you still using Crystal Reports?

Have you moved to something more modern?

Drop your experience below — or share a screenshot of your setup!

Let’s swap ideas.

🧾 How I Rebuilt My eAdvice System with C# Console Apps

seonglinchua — Sun, 06 Jul 2025 14:36:26 +0000

“I didn’t modernize my stack. I rethought my system.”

👋 Background

I was tasked with supporting and enhancing an eAdvice distribution system at my bank.

The problem? It was built on tight coupling, manual triggers, and legacy UI dependencies.

The workflow was error-prone, slow, and hard to scale.

So, I tore it down — and rebuilt it as a headless C# console application.

This is how I did it, and why you might want to do the same.

🧠 What Was Wrong with the Old System?

⚠️ UI tightly coupled with core logic
🐢 Manual click events to fetch data
🧷 Dependencies that made automation nearly impossible
❌ No logging or audit trail
📎 Painful to manage errors and retries

I knew this wasn’t sustainable — especially with daily deadlines and growing compliance needs.

🧱 The Headless Approach

I rebuilt everything around this principle:

"Let the logic run without needing to be seen."

Key Design Decisions:

Convert UI code behind into reusable services
Store configs in JSON files
Add Serilog for structured logging
Use Task Scheduler to automate execution
Isolate mailing list fetch, PDF mapping, and Infobip sending into separate components
Capture every success/failure in a reconciliation table

⚙️ Technologies Used

Purpose	Tool/Lib
Core app	C# .NET Console App
DB access	Dapper
Logging	Serilog
File parsing	EPPlus, iText7
Email sending	Infobip Email API
Scheduling	Windows Task Scheduler
Config	appsettings.json + ENV overrides

🧩 Modular Workflow

Each step was designed as an isolated module:

🪛 Dev-Friendly Features

Logs are written both to file and console with timestamps.
The app supports --dryrun mode for safe testing.
Failures are automatically retried in the next run.
Configs can be changed without recompiling the app.

✨ Results

✅ System now runs unattended every day
✅ Reconciliation and error handling became transparent
✅ No more relying on fragile UIs
✅ Easy to support multiple advice types (e.g., PWM, V8)

🔮 What’s Next?

Adding queue retry logic for failed emails
Creating a web dashboard for ad-hoc resend and report lookup
Exploring cloud-based job runners for scalability
Plugging in GenAI classification for incoming requests

🙌 Your Turn

Have you turned a legacy system into something lean and modern?

Ever tried headless console automation in production?

Drop your experience below — or ask me anything about this build.

I’ll be sharing more posts like this daily 👇

🧠 Headless Architecture – The Unknown Gem That Supercharged My Automation Projects

seonglinchua — Sat, 05 Jul 2025 03:29:50 +0000

"Sometimes, the most powerful tools aren't shiny frameworks, but silent design decisions."

👋 Introduction

If you're still tightly coupling your UI with your backend, you're probably wasting time and limiting reusability. I discovered this the hard way — until I stumbled upon headless architecture.

Not through a textbook.

Not from a YouTube guru.

But from trying to automate a stubborn legacy system.

This post is about that journey — and why headless design might be the underrated gem you're not using enough.

🧩 What Is Headless Architecture?

Headless architecture is a decoupled design where the backend logic is independent of the frontend UI. You can trigger services, logic, or workflows without needing a UI to exist or be loaded.

UI optional, logic unstoppable.

💡 Why I Shifted to Headless

I was building a financial statement distribution system using C# and Windows Forms. It worked — but everything was tightly coupled, which made:

💣 Automation impossible without UI hacks
🐢 Testing painfully slow
🔁 Reuse nearly zero

So I refactored the core logic into a headless service.

The result?

✅ Runs as a scheduled console app
✅ Logging became modular (Serilog FTW)
✅ Can trigger actions from CLI, Task Scheduler, or API

🔍 The "Unknown Gem" Part

Nobody talks about headless design when discussing .NET console apps or automation. It’s often overshadowed by:

Microservices
Serverless
Dockerized containers

But in truth, headless thinking is foundational to those.

It made me:

Think in services
Decouple logic from presentation
Automate without fear of UI breakage

⚙️ How I Designed It

Here's a simplified structure of my architecture:

💻 Stack Used:

C# .NET Console App
Serilog for logging
Dapper for database
JSON config files for environments
Windows Task Scheduler for automation

🚀 Benefits I Didn't Expect

🔁 Easier unit testing & mocking
💻 Platform-agnostic execution
⚡️ Fast iteration on logic
🧩 UI became optional plugin

✨ Final Thoughts

If you're a developer juggling automation, dashboards, or backend logic, consider designing headless-first.

You don’t need React, Docker, or Kubernetes to start.

Just decouple your logic and build with flexibility in mind.

💬 Over to You

Have you tried headless design in your projects?

Is there an “unknown gem” in your dev journey you'd recommend?

Drop a comment below. Let’s surface the underrated wins 🛠️

How I'm Prepping for Interview Assessments — Smarter and Faster

seonglinchua — Sun, 25 May 2025 01:11:56 +0000

As a developer juggling work and side projects, prepping for technical interviews can feel overwhelming. Instead of chasing perfection, I've built a workflow that combines brute force, learning patterns, and AI tools — and it's helping me learn faster and stay sharp.

Here’s how I’m doing it.

🧠 Step 1: Categorize Topics

I broke down all assessment questions into 6 core categories:

Algorithms & Data Structures
SQL & LINQ
C#/.NET Core concepts
DevOps & CI/CD
System Design (microservices, REST, queues)
AI Tools as Coding Accelerators

This helps me track what to focus on weekly.

🔁 Step 2: Start with Brute Force (Then Optimize)

Instead of panicking over efficiency, I:

Write a brute-force version first
Ensure it works for small cases
Then search or iterate into the optimized version

This makes patterns like sliding window, hashmap, and recursion much easier to understand.

⚙️ Step 3: Practice Common Patterns

Each day I choose a pattern like:

🔁 Sliding Window → Longest substring without repeat
🧠 HashMap → Two Sum, Group Anagrams
📦 Stack → Valid Parentheses
📈 Binary Search → Search in rotated array

And I solve 1–2 problems using brute first, then refactor.

🧪 Step 4: Weekly Mock Tests

Once a week, I do a 25-minute simulation:

1 algorithm problem (LeetCode or Coderbyte)
1 real-world backend question (design API or SQL query)
Use Copilot + ChatGPT only for hints, not answers

This gives me realistic pressure and makes me confident before the real test.

🤖 Step 5: AI Tools that Help

Here’s how I use AI ethically:

🔹 GitHub Copilot to autocomplete loops, LINQ
🔹 ChatGPT to explain logic or debug
🔹 Ollama as a local GPT during offline prep
🔹 Build a Notion doc of best prompts for reuse

🗂️ Tools I Keep Open

LeetCode Patterns
C# Docs
Visualgo.net
My own GitHub repo with reusable snippets

🎯 Final Thoughts

By working smarter (not longer), I’ve found myself:

Writing faster and cleaner code
Explaining my solutions with more confidence
Actually enjoying the interview prep process

If you're prepping too — how do you learn best?

Let’s share strategies and improve together. 👇

How I Use Google (Ethically) During Coding Assessments

seonglinchua — Sun, 25 May 2025 00:53:30 +0000

As a software developer, I recently sat for a few technical assessments where I was allowed to use Google during the test. At first, it felt like a cheat code — but I quickly realized that using Google effectively and ethically is a skill of its own.

Here’s how I’ve learned to maximize Google like an AI-powered co-pilot while staying fully accountable for my work.

🔍 1. Google Is Not a Solution Engine — It's a Clarifier

I don’t use Google to find entire answers. Instead, I use it to:

Recall C# syntax or built-in methods (Array.Find, Dictionary.TryGetValue)
Look up error messages or edge-case behaviors
Cross-check my logic pattern when stuck (e.g., “two pointer sliding window C#”)

🧠 2. I Start With Brute Force — Then Search to Improve

Every time I tackle a problem, I first:

Break it down manually
Sketch the brute-force logic
Code the basic loop

Then I Google:

“C# optimize dictionary lookup in loop”

or

“C# LINQ sum of group by value”

to improve my solution — not replace it.

🧰 3. I Keep a Google-Efficient Toolkit Open

When I know Google is allowed, I preload:

✅ C# Documentation
✅ LINQ Examples
✅ My GitHub snippets (like reusable TwoSum and GroupBy patterns)
✅ A Notion tab with common C# error fixes I’ve collected

This helps me reduce context switching and stay in my zone.

🚫 What I Avoid

❌ Copy-pasting from LeetCode without understanding
❌ Spending 5+ minutes reading deep discussions
❌ Searching for “the exact problem title” (easily detectable!)

✅ The Result

I use Google like I use Copilot or ChatGPT — as a thought extender, not a replacement for problem-solving.

In fact, showing how I reason and improve my own logic with tools like Google has helped me perform better in interviews — and start better tech conversations during debriefs.

🗣️ How About You?

Do you get access to Google during tests?

How do you make sure you're learning — not leaning?

Let’s discuss 👇

Beyond the Surface: Understanding Different Application Types

seonglinchua — Thu, 15 May 2025 08:27:06 +0000

Ever wondered about the different kinds of software that power our digital world? From the websites we browse to the tools running silently in the background, applications come in many forms, each designed for a specific purpose and environment.

If you've ever looked at a list of project templates in a development environment, you might have seen terms like "Console Application," "Windows Form," or "Web Application." But what do these really mean? Let's break down some of the common application types you might encounter.

We recently came across a list featuring several distinct application types. Let's take a closer look at what each one entails:

1. Web Application

This is likely the most familiar type for most people. A web application is a program that lives on a remote server and is accessed through a web browser (like Chrome, Firefox, or Edge).

What it is: Software that runs on a server and is delivered to users over the internet or an intranet via a web browser.
Key Characteristics:
- Accessed through a URL in a web browser.
- No installation required on the user's computer (beyond the browser itself).
- Updates are deployed centrally on the server.
- Accessible from various devices with a web connection.
Common Use Cases: E-commerce websites (like Amazon), social media platforms (like Facebook or X), online banking portals, web-based email services (like Gmail), online productivity suites (like Google Workspace).

2. Console Application

Step away from the graphical interfaces for a moment. A console application is a program that runs within a text-based environment, like the Command Prompt in Windows or the Terminal in macOS/Linux.

What it is: A program that interacts with the user through text input and output in a command-line interface.
Key Characteristics:
- Runs in a console window.
- Relies on text commands and displays text-based results.
- Typically lightweight and efficient.
- Often used for automation and scripting.
Common Use Cases: Command-line utilities (like ping or ipconfig), scripts for system administration tasks, simple tools for processing data, background automation jobs.

3. Windows Form (WinForms)

If you've used desktop applications on Windows, you've likely interacted with a Windows Forms application. This is a framework for building traditional desktop software with a graphical user interface.

What it is: A framework for creating desktop applications with a visual interface that runs directly on the Windows operating system.
Key Characteristics:
- Features windows, buttons, text boxes, and other graphical controls.
- Requires installation on a Windows machine.
- Provides a native Windows look and feel.
- Event-driven (responds to user actions like clicks and typing).
Common Use Cases: Desktop productivity software (like Microsoft Word), business applications, utility programs, custom internal tools for Windows environments.

4. Web (Legacy)

This term often pops up when dealing with older projects or technologies. "Web (Legacy)" typically refers to web applications built using older frameworks, structures, or coding practices that are no longer the current standard.

What it is: Refers to web applications built with older web development technologies or project patterns.
Key Characteristics:
- Based on technologies or structures that have been superseded by newer ones.
- May be maintained for compatibility with existing systems.
- Could potentially lack features or performance of modern web applications.
Common Use Cases: Maintaining and updating existing older web applications, integrating with legacy systems that cannot be easily modernized.

5. Windows Service

Working silently in the background, Windows Services are applications that perform tasks without a user interface. They are essential for operations that need to run continuously or on a schedule on a Windows system.

What it is: An application that runs in the background on a Windows operating system, typically without a user interface.
Key Characteristics:
- Runs independently of a user being logged in.
- Can be configured to start automatically with the system.
- Managed through the Windows Service Control Manager.
- Ideal for long-running tasks or background processes.
Common Use Cases: Background data synchronization, scheduling automated tasks, monitoring system events, hosting services that other applications use.

Understanding these different application types is crucial for developers, project managers, and anyone involved in software development. The choice of application type depends heavily on the project's requirements, target audience, deployment environment, and desired user experience.

Whether it's a website you visit daily, a script automating a task, a desktop program you use for work, or a silent service keeping things running smoothly, each application type plays a vital role in the digital landscape.

What other application types have you encountered? Share your thoughts in the comments below!

Common Use Cases for Button-Triggered Excel Macros

seonglinchua — Wed, 14 May 2025 03:18:59 +0000

Excel is a powerful tool for data management and analysis, but its capabilities can be significantly extended through the use of macros. By attaching these small programs to buttons on your worksheet, you can create interactive tools and automate repetitive tasks with a simple click. This transforms a static spreadsheet into a dynamic application.

Here are some common and effective use cases for button-triggered Excel macros:

1. Custom Calculators and Specialized Tools

Beyond standard formulas, macros allow you to build complex, multi-step calculators or tools tailored to specific needs. A button can initiate a series of calculations based on user inputs, potentially involving conditional logic, lookups across different sheets, or interactions with external data.

Financial Calculators: Develop tools for loan amortization, investment analysis, budget forecasting, or specific financial modeling (like the "Loan Pre-Break Calculator" we discussed).
Pricing and Quoting Tools: Create interactive forms where sales teams can input product details and quantities, and a macro calculates the final price, including discounts, taxes, or custom fees.
Engineering or Scientific Tools: Perform specialized calculations relevant to specific disciplines, displaying results in a user-friendly format.

2. Data Processing and Transformation

Repetitive data manipulation tasks that would be tedious to perform manually can be automated with a button click.

Data Cleaning and Formatting: A macro can quickly remove duplicate rows, standardize text formatting (e.g., capitalize names, remove extra spaces), split data from one column into multiple, or combine data from several columns.
Data Reorganization: Transform data layouts to meet specific requirements, such as pivoting data, unpivoting data, or rearranging columns and rows.
Merging and Splitting Data: Combine data from multiple spreadsheets into a master sheet or split a large dataset into smaller, separate files based on criteria.

3. Report Generation and Summarization

Automate the process of creating regular reports, saving significant time and reducing the risk of manual errors.

Automated Report Assembly: Gather data from various sheets or even external sources, perform necessary calculations or aggregations, and assemble the information into a predefined report template.
Creating Summaries and Dashboards: Update summary tables, pivot tables, and charts with the latest data at the push of a button, providing instant insights.
Generating Custom Reports: Allow users to select parameters (e.g., date range, department), and a macro generates a tailored report based on their selections.

4. Workflow Automation

Connect different steps of a process within Excel or interact with other applications.

Automated Email Sending: Generate personalized emails based on data in rows (e.g., sending invoices, reminders, or notifications) and send them directly from Excel using Outlook automation.
File Management: Automate saving the current workbook in different formats (PDF, CSV), creating dated backups, or organizing files into specific folders.
Task Sequencing: Execute a series of actions in a defined order, such as refreshing external data connections, performing calculations, updating a summary sheet, and then saving the workbook.

5. Data Import and Export

Streamline the process of getting data into or out of your Excel workbook.

Importing Data from Files: Read data from text files, CSV files, or other structured file types and import it into your worksheet, handling potential formatting issues.
Exporting Data to Files: Save specific ranges or entire sheets as new files in different formats for use in other applications or systems.

6. Interactive Forms and Guided Data Entry

Create a more user-friendly interface for data input compared to simply typing into cells.

Custom Input Forms: Design sections on your sheet with labels and controls (text boxes, dropdowns, checkboxes) to guide users on where and how to enter data. A button can then process this input.
Validation and Feedback: Use macros to perform complex data validation as users enter information and provide immediate feedback or error messages.

In Conclusion

Button-triggered Excel macros are a versatile tool for anyone who spends significant time working with data in spreadsheets. They empower users to automate repetitive tasks, build custom tools, and streamline workflows directly within the familiar Excel environment. While they may not offer the same scalability or collaborative features as full web applications, for targeted use cases and users comfortable with Excel, they provide a powerful and accessible way to enhance productivity.

GitHub Copilot Workflows for Modern Software Developers

seonglinchua — Tue, 13 May 2025 07:51:24 +0000

GitHub Copilot has rapidly become an integral AI companion for software developers building modern applications, transforming various stages of the development lifecycle. Moving beyond simple code completion, Copilot now offers a suite of features that streamline workflows, enhance productivity, and assist with complex tasks within and outside the integrated development environment (IDE).

At its core, GitHub Copilot acts as an AI pair programmer, providing real-time code suggestions as developers type. This capability, powered by large language models trained on a vast dataset of public code, significantly accelerates the writing of boilerplate code, repetitive patterns, and common functions. Developers can accept, modify, or ignore these suggestions, maintaining control while reducing the cognitive load of recalling syntax and structures.

However, Copilot's utility in modern application development extends far beyond basic code completion. Here are some key workflows developers are adopting:

1. Accelerated Coding and Prototyping:

Intelligent Code Completion and Generation: Copilot excels at suggesting lines, blocks, and even entire functions based on the surrounding code and comments. This speeds up the initial coding phase, allowing developers to translate ideas into code more rapidly.
Boilerplate Reduction: For modern applications often involving various frameworks, libraries, and configurations, Copilot can quickly generate repetitive code structures, setup code, and standard patterns, freeing developers to focus on unique application logic.
Learning New Technologies: When working with unfamiliar languages, frameworks, or APIs, Copilot can provide syntax suggestions, code examples, and usage patterns, lowering the barrier to entry and accelerating the learning process.

2. Enhanced Code Understanding and Documentation:

Code Explanation: Using features like Copilot Chat, developers can ask for explanations of existing code snippets, functions, or even larger code structures. This is particularly valuable when navigating legacy codebases or collaborating on code written by others.
Automated Documentation Generation: Copilot can assist in generating documentation, such as docstrings for functions and comments explaining complex logic, helping maintain code readability and making it easier for others to understand the codebase.

3. Streamlined Testing and Debugging:

Test Case Generation: Copilot can suggest and generate unit tests based on the code's functionality, helping developers achieve better test coverage and ensuring code quality.
Debugging Assistance: By analyzing error messages and code context, Copilot can offer suggestions for potential fixes and debugging steps, accelerating the process of identifying and resolving issues. Copilot's newer agent mode can even suggest terminal commands or tool executions to help with runtime errors.

4. Efficient Code Refactoring and Improvement:

Refactoring Suggestions: Copilot can identify opportunities for code refactoring to improve readability, efficiency, and maintainability, and suggest alternative code implementations.
Adhering to Best Practices: Based on its training data, Copilot can offer suggestions that align with common coding standards and design patterns.

5. Elevated Code Review and Collaboration:

Pull Request Summaries: Copilot can generate summaries of changes within a pull request, highlighting the key modifications and impacted files, which aids reviewers in quickly understanding the scope of the changes.
Code Review Assistance: AI-powered code review features can provide suggestions for improvements and potential issues directly within the pull request workflow, complementing human review efforts.

6. Advanced Capabilities with Copilot's Evolution:

Agent Mode: This newer feature allows Copilot to understand higher-level goals described in natural language and break them down into actionable steps, including suggesting and executing terminal commands and addressing errors autonomously within the development environment.
Multi-Model Support: The ability to utilize different large language models (like various versions of Claude, Gemini, and GPT) allows developers to leverage the strengths of different models for specific tasks, potentially leading to more accurate or nuanced suggestions.
Copilot Edits: This feature enables multi-file code changes based on a single Copilot Chat prompt, streamlining tasks that involve modifications across several files.
Copilot in the CLI: Extending Copilot's assistance to the command line allows developers to get help with terminal commands, further reducing context switching.

Integration and Customization:

GitHub Copilot integrates seamlessly with popular IDEs like VS Code, Visual Studio, and JetBrains IDEs, embedding its capabilities directly into the developer's workflow. Customization options, such as providing custom instructions in Copilot Chat, allow developers to tailor Copilot's responses to their specific preferences and project requirements.

Considerations and Best Practices:

While GitHub Copilot offers significant benefits, it's crucial to remember that it's a copilot, not an autopilot. Developers remain responsible for reviewing and validating all suggested code to ensure it meets requirements, is secure, and fits within the overall project architecture. Best practices include:

Treating suggestions as recommendations: Always review and understand the generated code before accepting it.
Providing clear and specific prompts: The quality of Copilot's output often depends on the clarity of the input, especially when using chat or agent modes.
Maintaining context: Keeping relevant files open in the IDE helps Copilot provide more accurate and context-aware suggestions.
Iterating and refining: Don't hesitate to rephrase prompts or request alternative suggestions if the initial output isn't suitable.

In conclusion, GitHub Copilot is a powerful tool that is reshaping modern software development workflows. By leveraging its capabilities for code generation, understanding, testing, and review, developers can enhance their productivity, focus on more complex problem-solving, and ultimately build modern applications more efficiently. As AI capabilities continue to evolve, the integration of tools like Copilot into the developer toolkit will only become more sophisticated and impactful.

Mastering Stack in C# for Coding Interviews

seonglinchua — Sun, 11 May 2025 14:13:48 +0000

🧱 Stack in C# — Solving Problems the LIFO Way

A Stack<T> is a Last-In-First-Out (LIFO) collection — the last element added is the first one removed. It's commonly used in parsing, expression evaluation, and backtracking.

✅ When to Use Stack

Use Case	Why Use Stack
Reversing elements	Natural LIFO behavior
Nested structures / matching	e.g., parentheses, XML, recursion stack
Backtracking	Push state, pop to revert
Undo features	Store previous states

✍️ Declaring and Using Stack

var stack = new Stack<int>();

stack.Push(10);        // Add to top
stack.Push(20);
int top = stack.Peek(); // Peek top (20)
stack.Pop();            // Remove top (20)

🔁 Iterating Through Stack

foreach (int item in stack)
{
    Console.WriteLine(item);
}

🧪 Interview Example 1: Valid Parentheses

public bool IsValid(string s)
{
    var stack = new Stack<char>();
    var map = new Dictionary<char, char> {
        {')', '('}, {']', '['}, {'}', '{'}
    };

    foreach (char c in s)
    {
        if (map.ContainsValue(c))
            stack.Push(c);
        else if (map.ContainsKey(c))
        {
            if (stack.Count == 0 || stack.Pop() != map[c])
                return false;
        }
    }

    return stack.Count == 0;
}

🧪 Interview Example 2: Evaluate Reverse Polish Notation

public int EvalRPN(string[] tokens)
{
    var stack = new Stack<int>();

    foreach (var token in tokens)
    {
        if (int.TryParse(token, out int num))
            stack.Push(num);
        else
        {
            int b = stack.Pop();
            int a = stack.Pop();
            switch (token)
            {
                case "+": stack.Push(a + b); break;
                case "-": stack.Push(a - b); break;
                case "*": stack.Push(a * b); break;
                case "/": stack.Push(a / b); break;
            }
        }
    }

    return stack.Pop();
}

📌 Summary

Feature	Syntax Example
Declare	`new Stack<T>()`
Push	`stack.Push(value)`
Pop	`stack.Pop()`
Peek	`stack.Peek()`
Count	`stack.Count`
Iterate	`foreach (var item in stack)`

Up next: Queue and Deque — perfect for BFS traversal and sliding window problems!

Mastering Dictionary in C# for Coding Interviews

seonglinchua — Sun, 11 May 2025 14:11:34 +0000

🔑 Dictionary in C# — The Ultimate Tool for Fast Lookup

A Dictionary<TKey, TValue> is a powerful data structure that maps unique keys to values, allowing fast O(1) lookups and efficient data grouping.

✅ When to Use Dictionary

Use Case	Why Use Dictionary
Map key to value	Quick access with known key
Frequency count	Count how many times items appear
Grouping elements	Categorize data using keys
Implement cache or memoization	Fast storage and retrieval

✍️ Declaring and Initializing

// Declare and initialize
Dictionary<string, int> ageMap = new Dictionary<string, int>();

// Adding entries
ageMap["Alice"] = 25;
ageMap["Bob"] = 30;

🔧 Common Operations

// Add or update
ageMap["Charlie"] = 28;

// Check key existence
if (ageMap.ContainsKey("Alice"))
    Console.WriteLine(ageMap["Alice"]);

// Remove entry
ageMap.Remove("Bob");

// Loop through dictionary
foreach (var kvp in ageMap)
{
    Console.WriteLine($"{kvp.Key} => {kvp.Value}");
}

🧪 Interview Example 1: Two Sum

public int[] TwoSum(int[] nums, int target)
{
    var map = new Dictionary<int, int>();
    for (int i = 0; i < nums.Length; i++)
    {
        int complement = target - nums[i];
        if (map.ContainsKey(complement))
            return new int[] { map[complement], i };
        map[nums[i]] = i;
    }
    return new int[] { -1, -1 };
}

🧪 Interview Example 2: Group Anagrams

public IList<IList<string>> GroupAnagrams(string[] strs)
{
    var map = new Dictionary<string, List<string>>();

    foreach (var word in strs)
    {
        char[] chars = word.ToCharArray();
        Array.Sort(chars);
        string key = new string(chars);

        if (!map.ContainsKey(key))
            map[key] = new List<string>();

        map[key].Add(word);
    }

    return new List<IList<string>>(map.Values);
}

📌 Summary

Feature	Syntax Example
Declare	`new Dictionary<TKey, TValue>()`
Add/Update	`dict[key] = value;`
Exists Check	`dict.ContainsKey(key)`
Remove	`dict.Remove(key)`
Iterate	`foreach (var kvp in dict)`

Next up: Stack — ideal for solving nested and reverse order problems like Valid Parentheses and backtracking tasks.

Mastering List in C# for Coding Interviews

seonglinchua — Sat, 10 May 2025 08:42:12 +0000

📘 List in C# — The Dynamic Array You Need to Know

List<T> is the most flexible and commonly used collection in C#. It’s a dynamic array that automatically resizes and provides indexed access.

✅ When to Use List

Use Case	Why Use List
Need dynamic resizing	Automatically expands as needed
Index-based access	Like arrays, but flexible
Frequent insert/remove	Especially at the end
Storing objects or models	Generic and powerful

✍️ Declaring & Initializing List

// Create an empty list
List<int> numbers = new List<int>();

// Initialize with values
List<string> names = new List<string> { "Alice", "Bob", "Charlie" };

🔁 Adding, Removing, and Accessing Elements

numbers.Add(10);       // Add to end
numbers.AddRange(new int[] { 20, 30 }); // Add multiple

numbers.Remove(20);    // Remove by value
numbers.RemoveAt(0);   // Remove by index

int first = numbers[0];         // Access
numbers[1] = 100;               // Update

🔁 Iterating Through List

for (int i = 0; i < names.Count; i++)
{
    Console.WriteLine(names[i]);
}

foreach (string name in names)
{
    Console.WriteLine(name);
}

🔍 Searching and Sorting

bool exists = names.Contains("Bob");     // true
int index = names.IndexOf("Charlie");    // 2

names.Sort();       // Sort alphabetically
names.Reverse();    // Reverse order

🧪 Interview Example: Merge Intervals (List of Lists)

public int[][] Merge(int[][] intervals)
{
    if (intervals.Length <= 1) return intervals;

    Array.Sort(intervals, (a, b) => a[0].CompareTo(b[0]));
    var merged = new List<int[]>();
    var current = intervals[0];

    foreach (var interval in intervals)
    {
        if (interval[0] <= current[1])
            current[1] = Math.Max(current[1], interval[1]);
        else
        {
            merged.Add(current);
            current = interval;
        }
    }
    merged.Add(current);

    return merged.ToArray();
}

📌 Summary

Feature	Syntax Example
Declare	`List<int> list = new List<int>();`
Add	`list.Add(value)`, `list.AddRange(...)`
Access/Update	`list[i]`, `list[i] = value`
Remove	`list.Remove(value)`, `list.RemoveAt(i)`
Sort/Reverse	`list.Sort()`, `list.Reverse()`

Up next: Dictionary — your go-to structure for frequency maps and lookup-based problems like Two Sum and Group Anagrams.

Mastering HashSet in C# for Coding Interviews

seonglinchua — Sat, 10 May 2025 08:39:15 +0000

🧠 HashSet in C# — A Must-Know Tool for Uniqueness and Fast Lookups

HashSet<T> is one of the most versatile and commonly used data structures in coding interviews. It allows constant-time lookup and guarantees unique elements only.

✅ When to Use HashSet

Use Case	Why Use HashSet
Check for duplicates	Fast `Contains()` check
Track seen items	O(1) add/lookup
Unique collections	Prevents duplicates automatically
Set operations (union/intersect)	Built-in set logic

✍️ Declaring and Using HashSet

var seen = new HashSet<int>();

seen.Add(5);        // true
seen.Add(5);        // false (duplicate)

bool exists = seen.Contains(5); // true
seen.Remove(5);     // removes 5

🔁 Looping Through HashSet

foreach (int num in seen)
{
    Console.WriteLine(num);
}

🧪 Interview Example 1: Detect Duplicates

public bool ContainsDuplicate(int[] nums)
{
    var set = new HashSet<int>();
    foreach (int num in nums)
    {
        if (!set.Add(num)) return true;
    }
    return false;
}

🧪 Interview Example 2: Longest Substring Without Repeating Characters

public int LengthOfLongestSubstring(string s)
{
    var set = new HashSet<char>();
    int left = 0, maxLen = 0;

    for (int right = 0; right < s.Length; right++)
    {
        while (set.Contains(s[right]))
        {
            set.Remove(s[left]);
            left++;
        }

        set.Add(s[right]);
        maxLen = Math.Max(maxLen, right - left + 1);
    }

    return maxLen;
}

⚙️ Set Operations

var a = new HashSet<int>() { 1, 2, 3 };
var b = new HashSet<int>() { 2, 3, 4 };

a.IntersectWith(b);  // a = {2, 3}
a.UnionWith(b);      // a = {1, 2, 3, 4}
a.ExceptWith(b);     // a = {1}

📌 Summary

Feature	Syntax Example
Declare	`new HashSet<int>()`
Add	`set.Add(value)`
Check Exists	`set.Contains(value)`
Remove	`set.Remove(value)`
Set Ops	`UnionWith()`, `IntersectWith()`

Next up: Dictionary — perfect for counting, mapping, and solving problems like Two Sum and Group Anagrams.