Edit Task

Advanced generated

Download Zip

Title

Coordinate Tuple Processor

Function

advanced_tuple_manipulation()

Task ID

task_v28a6be434_advanced_tuple_manipulation

Source

manual

Review & edit before approving

Each file below is editable. Read through the content, fix any issues, and click Save & Re-zip when you're happy. Saving automatically marks the task as "reviewed."

README — what the learner sees Starter code — skeleton with TODOs Solution — the answer key (hidden from learner) Tests — verify correctness Config — metadata and structure

README.md — The instructions the learner sees. Contains the problem overview, requirements, ...

# Coordinate Tuple Processor

## Overview
This task asks you to build a small data processor that works with coordinate pairs stored as tuples. You will read a sequence of 2D points and perform one of several operations, emphasizing immutable tuple usage and efficient data handling. The solution should handle typical edge cases and operate in linear time where possible.

## Technical Challenge
Create a function `advanced_tuple_manipulation()` that:
- Read input from stdin in a single function
- Parse lines into a list of 2-element integer tuples
- Handle three operation modes (1: deduplicate preserving order, 2: count occurrences, 3: compute bounding box)
- Print results in a deterministic format

---

## Project Structure

```
├── requirements.txt         # Python dependencies (pytest, etc.)
├── src/
│   ├── __init__.py          # Package initialization file
│   └── main.py              # YOUR CODE GOES HERE
└── tests/
    ├── __init__.py          # Test package initialization
    ├── test_main.py         # Public test cases
    └── test_eval.py         # Hidden evaluation tests for grading
```

---

## Input/Output Specifications

**Input:** The input consists of: first an integer n, followed by n lines each containing two integers representing a point (x y), followed by an integer op indicating the operation (1, 2, or 3).
**Output:** Depending on op: (1) print each unique point on its own line in order of first appearance; (2) print lines containing 'x y count' for each unique point in order of first appearance; (3) print a single line with 'min_x max_x min_y max_y'.

---

## Specification by Example (SBE)

| Scenario | Input | Expected Output | Notes |
|----------|-------|-----------------|-------|
| **DeduplicatePreserveOrder** | `4\n1 2\n3 4\n1 2\n5 6\n1` | `1 2\n3 4\n5 6\n` | Remove duplicates while preserving the order of first occurrences. |
| **CountOccurrences** | `5\n1 2\n3 4\n1 2\n3 4\n1 2\n2` | `1 2 3\n3 4 2\n` | Count each unique point in the order of first appearance. |
| **BoundingBox** | `4\n-1 0\n2 5\n-3 -2\n0 4\n3` | `-3 2 -2 5\n` | Compute min/max for x and y coordinates. |

---

## Points to Remember While Working on This
- Maintain order where required by using an ordered structure or a list to record first appearances.
- Tuples are immutable; store as (x, y) and use them as dictionary/set keys when counting or deduplicating.
- Ensure proper input parsing to handle potential extra spaces or empty lines.

starterFiles/src/main.py — The skeleton code given to the learner. Should only have a function signature, d...

def advanced_tuple_manipulation():
    """
    Process a list of 2D points (tuples) and perform one of three operations:
    1) Deduplicate while preserving the first occurrence order
    2) Count occurrences of each unique point in appearance order
    3) Compute the bounding box (min/max for x and y) of all points

    This function:
    1. Reads input from stdin
    2. Parses into a list of (x, y) tuples
    3. Executes the requested operation based on a final operation code
    4. Prints results to stdout in a deterministic format
    """

    # TODO: Implement the function according to the above specification
    # 1. Read n
    # 2. Read n lines of coordinates -> list of tuples
    # 3. Read operation code (1/2/3)
    # 4. Perform operation and print results

    pass


if __name__ == "__main__":
    advanced_tuple_manipulation()

starterFiles/tests/test_main.py — Public test cases visible to the learner. 3-5 tests that help them verify their ...

import unittest
from unittest.mock import patch
from io import StringIO
from src.main import advanced_tuple_manipulation


class TestAdvancedTupleManipulation(unittest.TestCase):

    @patch('builtins.input', side_effect=[
        '4',
        '1 2',
        '3 4',
        '1 2',
        '5 6',
        '1'
    ])
    @patch('sys.stdout', new_callable=StringIO)
    def test_deduplicate_preserve_order(self, mock_stdout, mock_input):
        advanced_tuple_manipulation()
        self.assertEqual(mock_stdout.getvalue(), '1 2\n3 4\n5 6\n')

    @patch('builtins.input', side_effect=[
        '5',
        '1 2',
        '3 4',
        '1 2',
        '3 4',
        '1 2',
        '2'
    ])
    @patch('sys.stdout', new_callable=StringIO)
    def test_count_occurrences(self, mock_stdout, mock_input):
        advanced_tuple_manipulation()
        self.assertEqual(mock_stdout.getvalue(), '1 2 3\n3 4 2\n')

    @patch('builtins.input', side_effect=[
        '4',
        '-1 0',
        '2 5',
        '-3 -2',
        '0 4',
        '3'
    ])
    @patch('sys.stdout', new_callable=StringIO)
    def test_bounding_box(self, mock_stdout, mock_input):
        advanced_tuple_manipulation()
        self.assertEqual(mock_stdout.getvalue(), '-3 2 -2 5\n')


if __name__ == '__main__':
    unittest.main()

starterFiles/tests/test_eval.py — Hidden evaluation tests used for grading. 8-12 tests covering edge cases. Learne...

import unittest
from unittest.mock import patch
from io import StringIO
from src.main import advanced_tuple_manipulation


class TestAdvancedTupleManipulationHidden(unittest.TestCase):

    def run_input(self, inputs):
        with patch('builtins.input', side_effect=inputs):
            with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
                advanced_tuple_manipulation()
                return mock_stdout.getvalue()

    def test_single_point_dedup(self):
        out = self.run_input(['1', '10 20', '1'])
        self.assertEqual(out, '10 20\n')

    def test_op2_counts_negative(self):
        out = self.run_input(['4', '-5 -5', '0 0', '-5 -5', '0 0', '2'])
        # order: (-5,-5) first, then (0,0)
        self.assertEqual(out, '-5 -5 2\n0 0 2\n')

    def test_op3_large_values(self):
        out = self.run_input(['3', '1000000 2000000', '-1000000 -2000000', '3'])
        self.assertEqual(out, '-1000000 1000000 -2000000 2000000\n')

    def test_invalid_op(self):
        out = self.run_input(['2', '1 1', '2 2', '9'])
        self.assertEqual(out, 'Invalid operation\n')

    def test_mixed_signs_and_points(self):
        out = self.run_input(['5', '0 0', '0 1', '1 0', '0 0', '1 1', '2'])
        self.assertEqual(out, '0 0 2\n0 1 1\n1 0 1\n1 1 1\n')

    def test_bounding_box_negative(self):
        out = self.run_input(['3', '-10 -20', '-5 -25', '-15 -5', '3'])
        self.assertEqual(out, '-15 -5 -25 -5\n'.replace('-5','-5').replace('-25','-25'))

    def test_random_case(self):
        out = self.run_input(['4', '2 3', '2 3', '4 0', '4 0', '1'])
        self.assertEqual(out, '2 3\n4 0\n')


if __name__ == '__main__':
    unittest.main()

solutionFiles/main.py — The complete working solution. This is the answer key that passes all test cases...

def advanced_tuple_manipulation():
    """
    Process a list of 2D points (tuples) and perform one of three operations:
    1) Deduplicate while preserving the first occurrence order
    2) Count occurrences of each unique point in appearance order
    3) Compute the bounding box (min/max for x and y) of all points

    This function:
    1. Reads input from stdin
    2. Parses into a list of (x, y) tuples
    3. Executes the requested operation based on a final operation code
    4. Prints results to stdout in a deterministic format
    """

    import sys

    data = []
    try:
        line = input().strip()
    except EOFError:
        return
    if line == "":
        return

    try:
        n = int(line)
    except ValueError:
        print("Invalid input")
        return

    points = []
    for _ in range(n):
        line = input().strip()
        while line == "":
            line = input().strip()
        parts = line.split()
        if len(parts) != 2:
            print("Invalid input")
            return
        x, y = int(parts[0]), int(parts[1])
        points.append((x, y))

    # Read operation code
    try:
        op_line = input().strip()
    except EOFError:
        print("Invalid input")
        return
    while op_line == "":
        op_line = input().strip()
    try:
        op = int(op_line)
    except ValueError:
        print("Invalid input")
        return

    if op == 1:
        # Deduplicate while preserving order
        seen = set()
        result = []
        for p in points:
            if p not in seen:
                seen.add(p)
                result.append(p)
        for a, b in result:
            print(f"{a} {b}")
    elif op == 2:
        # Count occurrences in order of first appearance
        counts = {}
        order = []
        for p in points:
            counts[p] = counts.get(p, 0) + 1
            if p not in order:
                order.append(p)
        for p in order:
            print(f"{p[0]} {p[1]} {counts[p]}")
    elif op == 3:
        xs = [p[0] for p in points]
        ys = [p[1] for p in points]
        min_x, max_x = min(xs), max(xs)
        min_y, max_y = min(ys), max(ys)
        print(f"{min_x} {max_x} {min_y} {max_y}")
    else:
        print("Invalid operation")


if __name__ == "__main__":
    advanced_tuple_manipulation()

metadata.json — Task metadata: ID, title, difficulty, duration, technologies, and file paths.

{
  "taskId": "task_v28a6be434_advanced_tuple_manipulation",
  "title": "Coordinate Tuple Processor",
  "basePath": "core-python/task_v28a6be434_advanced_tuple_manipulation",
  "createdAt": "2026-04-30T04:17:43.000Z",
  "technologies": [
    "python"
  ],
  "duration": "1 hour",
  "difficulty": "Advanced",
  "problemStatementFile": "problem.json",
  "learningResources": [],
  "files": [
    {
      "name": "requirements.txt",
      "path": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/requirements.txt",
      "type": "text_file"
    },
    {
      "name": "main.py",
      "path": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/src/main.py",
      "type": "python_file"
    },
    {
      "name": "__init__.py",
      "path": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/src/__init__.py",
      "type": "python_file"
    },
    {
      "name": "test_eval.py",
      "path": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/tests/test_eval.py",
      "type": "python_file"
    },
    {
      "name": "test_main.py",
      "path": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/tests/test_main.py",
      "type": "python_file"
    },
    {
      "name": "__init__.py",
      "path": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/tests/__init__.py",
      "type": "python_file"
    },
    {
      "name": "problem.json",
      "path": "core-python/task_v28a6be434_advanced_tuple_manipulation/problem.json",
      "type": "problem_document"
    }
  ],
  "fileDetails": [
    {
      "fileName": "requirements.txt",
      "filePath": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/requirements.txt",
      "extension": ".txt",
      "contentType": "text/plain",
      "fileType": "text_file",
      "relativePath": "starterFiles/requirements.txt"
    },
    {
      "fileName": "main.py",
      "filePath": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/src/main.py",
      "extension": ".py",
      "contentType": "text/x-python",
      "fileType": "python_file",
      "relativePath": "starterFiles/src/main.py"
    },
    {
      "fileName": "__init__.py",
      "filePath": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/src/__init__.py",
      "extension": ".py",
      "contentType": "text/x-python",
      "fileType": "python_file",
      "relativePath": "starterFiles/src/__init__.py"
    },
    {
      "fileName": "test_eval.py",
      "filePath": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/tests/test_eval.py",
      "extension": ".py",
      "contentType": "text/x-python",
      "fileType": "python_file",
      "relativePath": "starterFiles/tests/test_eval.py"
    },
    {
      "fileName": "test_main.py",
      "filePath": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/tests/test_main.py",
      "extension": ".py",
      "contentType": "text/x-python",
      "fileType": "python_file",
      "relativePath": "starterFiles/tests/test_main.py"
    },
    {
      "fileName": "__init__.py",
      "filePath": "core-python/task_v28a6be434_advanced_tuple_manipulation/starterFiles/tests/__init__.py",
      "extension": ".py",
      "contentType": "text/x-python",
      "fileType": "python_file",
      "relativePath": "starterFiles/tests/__init__.py"
    },
    {
      "fileName": "problem.json",
      "filePath": "core-python/task_v28a6be434_advanced_tuple_manipulation/problem.json",
      "extension": ".json",
      "contentType": "application/json",
      "fileType": "problem_document",
      "relativePath": "problem.json"
    }
  ]
}

problem.json — Structured 12-key problem JSON for platform integration. Enforced schema with Se...

{
  "problem": {
    "id": "task_v28a6be434_advanced_tuple_manipulation",
    "title": "Coordinate Tuple Processor",
    "meta": {
      "category": "Tuples",
      "difficulty": "Advanced",
      "tags": [
        "tuples",
        "tuple-manipulation",
        "data-processing",
        "order-preservation",
        "counting",
        "bounding-box",
        "input-parsing"
      ],
      "prerequisites": [
        "Python functions",
        "Tuple and list basics",
        "Input parsing from stdin",
        "Dictionaries and sets",
        "Loops and conditionals"
      ],
      "language": "Python",
      "framework": null
    },
    "sections": [
      {
        "key": "overview",
        "displayLabel": "Overview",
        "type": "markdown",
        "style": [],
        "data": {
          "text": "This task asks you to build a small data processor that works with coordinate pairs stored as tuples. You will read a sequence of 2D points and perform one of several operations, emphasizing immutable tuple usage and efficient data handling. The solution should handle typical edge cases and operate in linear time where possible."
        }
      },
      {
        "key": "technicalChallenge",
        "displayLabel": "Technical Challenge",
        "type": "list",
        "style": [],
        "description": "Create a function advanced_tuple_manipulation() that:",
        "data": {
          "items": [
            {
              "text": "Read input from stdin in a single function"
            },
            {
              "text": "Parse lines into a list of 2-element integer tuples"
            },
            {
              "text": "Handle three operation modes (1: deduplicate preserving order, 2: count occurrences, 3: compute bounding box)"
            },
            {
              "text": "Print results in a deterministic format"
            }
          ]
        }
      },
      {
        "key": "projectStructure",
        "displayLabel": "Project Structure",
        "type": "fileTree",
        "style": [],
        "data": {
          "text": "├── requirements.txt         # Python dependencies (pytest, etc.)\n├── src/\n│   ├── __init__.py          # Package initialization file\n│   └── main.py              # YOUR CODE GOES HERE\n└── tests/\n    ├── __init__.py          # Test package initialization\n    ├── test_main.py         # Public test cases\n    └── test_eval.py         # Hidden evaluation tests for grading"
        }
      },
      {
        "key": "inputOutputSpecifications",
        "displayLabel": "Input/Output Specifications",
        "type": "group",
        "style": [],
        "data": {
          "sections": [
            {
              "key": "ioDescription",
              "displayLabel": "",
              "type": "markdown",
              "style": [],
              "data": {
                "text": "**Input:**\nThe input consists of: first an integer n, followed by n lines each containing two integers representing a point (x y), followed by an integer op indicating the operation (1, 2, or 3).\n\n**Output:**\nDepending on op: (1) print each unique point on its own line in order of first appearance; (2) print lines containing 'x y count' for each unique point in order of first appearance; (3) print a single line with 'min_x max_x min_y max_y'."
              }
            },
            {
              "key": "specificationByExample",
              "displayLabel": "Specification by Example (SBE)",
              "type": "table",
              "style": [],
              "data": {
                "title": "Specification by Example (SBE)",
                "table": {
                  "columnDefs": [
                    {
                      "key": "scenario",
                      "label": "Scenario"
                    },
                    {
                      "key": "input",
                      "label": "Input"
                    },
                    {
                      "key": "expectedOutput",
                      "label": "Expected Output"
                    },
                    {
                      "key": "notes",
                      "label": "Notes"
                    }
                  ],
                  "renderOptions": {
                    "columnWidths": {
                      "scenario": "16%",
                      "input": "22%",
                      "expectedOutput": "42%",
                      "notes": "20%"
                    }
                  },
                  "rows": [
                    {
                      "scenario": "DeduplicatePreserveOrder",
                      "input": "4\\n1 2\\n3 4\\n1 2\\n5 6\\n1",
                      "expectedOutput": {
                        "text": "1 2\\n3 4\\n5 6\\n",
                        "style": [
                          "line-pill"
                        ]
                      },
                      "notes": "Remove duplicates while preserving the order of first occurrences."
                    },
                    {
                      "scenario": "CountOccurrences",
                      "input": "5\\n1 2\\n3 4\\n1 2\\n3 4\\n1 2\\n2",
                      "expectedOutput": {
                        "text": "1 2 3\\n3 4 2\\n",
                        "style": [
                          "line-pill"
                        ]
                      },
                      "notes": "Count each unique point in the order of first appearance."
                    },
                    {
                      "scenario": "BoundingBox",
                      "input": "4\\n-1 0\\n2 5\\n-3 -2\\n0 4\\n3",
                      "expectedOutput": {
                        "text": "-3 2 -2 5\\n",
                        "style": [
                          "line-pill"
                        ]
                      },
                      "notes": "Compute min/max for x and y coordinates."
                    }
                  ]
                }
              }
            },
            {
              "key": "sampleExecution",
              "displayLabel": "Sample Execution",
              "type": "group",
              "style": [],
              "data": {
                "sections": [
                  {
                    "key": "sampleExecution1",
                    "displayLabel": "Example 1 - DeduplicatePreserveOrder",
                    "type": "markdown",
                    "style": [],
                    "data": {
                      "text": "Input:\n4\n1 2\n3 4\n1 2\n5 6\n1\nOutput:\n1 2\n3 4\n5 6",
                      "style": [
                        "line-pill"
                      ]
                    }
                  },
                  {
                    "key": "sampleExecution2",
                    "displayLabel": "Example 2 - CountOccurrences",
                    "type": "markdown",
                    "style": [],
                    "data": {
                      "text": "Input:\n5\n1 2\n3 4\n1 2\n3 4\n1 2\n2\nOutput:\n1 2 3\n3 4 2",
                      "style": [
                        "line-pill"
                      ]
                    }
                  },
                  {
                    "key": "sampleExecution3",
                    "displayLabel": "Example 3 - BoundingBox",
                    "type": "markdown",
                    "style": [],
                    "data": {
                      "text": "Input:\n4\n-1 0\n2 5\n-3 -2\n0 4\n3\nOutput:\n-3 2 -2 5",
                      "style": [
                        "line-pill"
                      ]
                    }
                  }
                ]
              }
            }
          ]
        }
      },
      {
        "key": "pointsToRemember",
        "displayLabel": "Points to Remember While Working on This",
        "type": "list",
        "style": [],
        "data": {
          "items": [
            {
              "text": "Maintain order where required by using an ordered structure or a list to record first appearances."
            },
            {
              "text": "Tuples are immutable; store as (x, y) and use them as dictionary/set keys when counting or deduplicating."
            },
            {
              "text": "Ensure proper input parsing to handle potential extra spaces or empty lines."
            }
          ]
        }
      }
    ]
  }
}

starterFiles/requirements.txt — Python dependencies needed to run the project (pytest, etc.).

pytest>=7.0.0

Back to Catalog

Saving marks the task as "reviewed"