Problem Setter Evaluation Assignment
Overview
You are required to design an original competitive programming problem along with its complete
implementation and test [Link] assignment evaluates problem design ability, constraint
understanding, edge case thinking, test case quality, multi-language implementation skill, and
professional competitive programming standards.
Please read all instructions carefully before starting.
Part 1: Problem Creation
You must create one original competitive programming problem satisfying all of the following
conditions.
1. Difficulty Level
The problem should match Codeforces 1400–1600 rating level.
It should be medium difficulty and require non-trivial thinking.
Pure implementation-only problems are not acceptable.
2. Storyline Requirement
The problem must contain a meaningful and natural storyline.
It should resemble a real competitive programming problem.
Avoid plain mathematical descriptions without context.
The story should not feel artificially forced.
3. Constraints and Complexity
Brute force solutions should result in TLE.
Constraints must justify the intended optimal time complexity.
Upper bounds should be meaningful, for example n up to 2 × 10^5 or similar.
Naive O(n²) or worse approaches should fail under maximum constraints.
4. Originality Requirement
The problem must not be a direct copy or obvious variation of a well-known problem.
Avoid classic templates such as basic Kadane, simple BFS shortest path, plain two-sum,
standard LRU, etc.
The idea should demonstrate independent thinking.
Part 2: Required Submission
You must submit all of the following components.
1. Problem Statement
Provide a professionally formatted problem statement including a clear description, proper
formatting, a natural storyline, and logical flow without ambiguity.
Structure should include:
Problem Description
Input
Output
Constraints
2. Input and Output Format
Clearly define the input structure and output format.
Define all variables precisely.
3. Constraints Section
Explicitly mention bounds for all variables.
Include any cumulative constraints if required.
Constraints must align properly with the intended time complexity.
4. Visible Sample Test Cases
Provide at least three sample test cases.
Each sample must include:
Input
Output
Explanation
The explanation should be concise and written in a typical competitive programming style. It
should clearly explain how the output is derived without turning into a full editorial.
5. Hidden Test Case File
Create one hidden test case file containing exactly ten test cases.
These must include:
Edge cases such as minimum values and boundary behavior
Random medium-sized cases
Logical tricky corner cases
Two maximum-constraint test cases at the upper bound of constraints, specifically designed to
detect TLE
This section is important and will be evaluated strictly.
6. Expected Complexity
Clearly state the intended time complexity and space complexity.
Provide a short justification explaining why this complexity is required.
7. Complete Reference Solution
You must provide a complete working solution in all five of the following languages:
C++
Java
C
Python
JavaScript ([Link])
Mandatory Implementation Structure for Each Language
For every language, your submission must include:
A full driver code
This should handle input reading, call the core logic function, print the output, and handle
multiple test cases if applicable.
A separate core logic function
This function should contain only the actual algorithm and must be clearly separated from input
and output handling.
The structure should resemble the following:
1. Main function reads input
2. Main function calls solve or equivalent
3. Solve function contains core logic
4. Main function prints result
This separation is mandatory in all five languages.
Additional Code Requirements
Code must compile and run without errors.
It must correctly handle large inputs, edge cases, and maximum constraints.
No hardcoded outputs are allowed.
Use clean variable naming.
Avoid unnecessary debug prints.
Incomplete language submissions will not be evaluated.
Part 3: Evaluation Criteria & Submission
Submissions will be evaluated based on:
1. Originality of the idea
2. Quality and correctness of constraints
3. Strength of hidden test cases
4. Edge case coverage
5. Clean multi-language implementation
6. Logical consistency
7. Correctness across all five languages
8. Please submit the solution on internshala before the deadline.
Important Notes
This assignment is designed to test real problem-setting ability, depth of algorithmic thinking,
constraint design skill, test case design capability, and multi-language implementation strength.
Incomplete, plagiarized, or poorly structured submissions will not be considered.