Implement a Paginated Medical-Record Filter Without Guessing an Ambiguous Rule

Question

The candidate is asked to implement a paginated filter for medical records without making assumptions about ambiguous filtering rules.

Codemia · Accepted Answer

To implement a paginated medical-record filter, I will first define the requirements and understand the data structure. The goal is to filter records based on user input and return a specific page of results. I will ensure that the implementation is flexible enough to handle various filtering criteria without making assumptions.

Here is a basic implementation in Python:

```python
class MedicalRecord:
    def __init__(self, patient_id, name, condition):
        self.patient_id = patient_id
        self.name = name
        self.condition = condition

class MedicalRecordFilter:
    def __init__(self, records):
        self.records = records

def filter_records(self, filters, page, page_size):
        filtered_records = [record for record in self.records if self.matches_filters(record, filters)]
        start_index = (page - 1) * page_size
        return filtered_records[start_index:start_index + page_size]

def matches_filters(self, record, filters):
        return all(getattr(record, key) == value for key, value in filters.items())
```

In this code, I create a `MedicalRecord` class and a `MedicalRecordFilter` class that handles filtering and pagination.

The time complexity of the filtering operation is O(n) where n is the number of records, as we need to check each record against the filters. The pagination operation is O(1) for slicing the list of filtered records. Overall, the efficiency can be improved by optimizing the data storage (e.g., using a database with indexing).

While implementing this filter, I would consider edge cases such as empty filter criteria, invalid page numbers, and ensuring that the user receives an appropriate response when no records match the filters. Additionally, I would implement error handling to manage unexpected inputs gracefully.

This implementation provides a robust starting point for filtering medical records. It can be further enhanced by integrating with a database for larger datasets and implementing more complex filtering logic as needed.

Implement a Paginated Medical-Record Filter Without Guessing an Ambiguous Rule

Oracle

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Sharpen Your Skills on Codemia

Sample Answer

Approach

Implementation

Submit Your Answer

Oracle Software Engineer Interview Guide

Related Questions

Design a scalable Search System

Design a Video Streaming for Rippling

Design a Load Balancing Service

Design a Image Processing Service

Build a high-throughput Image Processing Pipeline