Technical Test Introduction

Front-End Test Repository LeetCode: Merge Intervals

Overview

This technical test is divided into two complementary parts:

  1. Front-End (Bug Fixing)
    You will find a front-end application with several small bugs to fix. The goal is to assess your ability to:
    • Identify and solve logic, UI, and usability issues
    • Write clean, readable code with best practices in React/TypeScript
    • Ensure a smooth and stable user experience
  2. Logic (Merge Intervals)
    The second part aims to test your algorithmic thinking with a common data visualization problem:
    Problem: Merge Intervals — LeetCode
    Implement a function that receives an array of intervals [start, end] and returns a merged version where overlapping intervals are combined.
    This is closely related to real-world front-end scenarios (schedules, timelines, price ranges, availability, etc.).

Objectives & Criteria

Front-End

  • Fix all bugs listed in the repository (rendering, state, forms, responsiveness, etc.)
  • Ensure the app is functional and provides a good experience in different scenarios
  • Use proper practices: safe typing, reusable components, error handling, tests (if applicable)

Merge Intervals

  • Create a pure function (e.g., mergeIntervals(...)) that:
    • Sorts intervals by start
    • Merges overlaps and contiguous intervals correctly
    • Returns the minimal list of correct intervals
  • Explain your reasoning and highlight trade-offs (immutability, complexity, edge cases, etc.)
  • Consider cases like empty, reversed, contained, and contiguous intervals

How to Submit

  1. Fork this repository and work freely.
  2. For the front-end part:
    • Create a new branch (fix/frontend)
    • Fix the bugs and, if you wish, add tests
  3. For the logic part:
    • Create a new branch (feat/merge-intervals)
    • Add your function file and a brief explanation (comments or auxiliary README)
  4. Open a pull request explaining your choices, challenges, and solutions.

What We Are Evaluating

Criteria What We Observe
Reasoning & Clarity Logical approach, handling of edge cases
Code Quality Readability, consistency, organization
Attention to Experience Functional UI, no visual or logic bugs
Testing & Reliability Minimum coverage of important scenarios
Understanding Trade-offs Well-founded justifications
— Good luck! —