Low-Quality Problems - Practice Coding Problems

Low-Quality Problems - Problem

Database Easy

You're working as a data analyst for a coding practice platform and need to identify which problems are performing poorly based on user feedback.

Given a Problems table that tracks user engagement for each coding problem:

Column Name	Type
problem_id	int
likes	int
dislikes	int

Your task is to find all low-quality problems where the like percentage is strictly less than 60%.

Like Percentage Formula: likes / (likes + dislikes) * 100

Return the problem_id of all low-quality problems ordered by problem_id in ascending order.

Example: If a problem has 3 likes and 7 dislikes, the like percentage is 3/(3+7) = 30%, which is less than 60%, so it's low-quality.

Input & Output

example_1.sql — Basic Case

$ Input: Problems table: | problem_id | likes | dislikes | |------------|-------|----------| | 6 | 1748 | 2205 | | 7 | 2519 | 1086 | | 8 | 3547 | 2538 |

› Output: | problem_id | |------------| | 6 | | 8 |

💡 Note: Problem 6: 1748/(1748+2205) = 44.2% < 60% (low-quality). Problem 7: 2519/(2519+1086) = 69.9% ≥ 60% (good quality). Problem 8: 3547/(3547+2538) = 58.3% < 60% (low-quality). Results are ordered by problem_id.

example_2.sql — Edge Case

$ Input: Problems table: | problem_id | likes | dislikes | |------------|-------|----------| | 1 | 3 | 2 | | 2 | 6 | 4 | | 3 | 1 | 1 |

› Output: | problem_id | |------------| | 3 |

💡 Note: Problem 1: 3/(3+2) = 60% ≥ 60% (not low-quality). Problem 2: 6/(6+4) = 60% ≥ 60% (not low-quality). Problem 3: 1/(1+1) = 50% < 60% (low-quality). Only problem 3 qualifies.

example_3.sql — All Low Quality

$ Input: Problems table: | problem_id | likes | dislikes | |------------|-------|----------| | 10 | 1 | 9 | | 5 | 2 | 8 | | 15 | 0 | 1 |

› Output: | problem_id | |------------| | 5 | | 10 | | 15 |

💡 Note: Problem 10: 1/(1+9) = 10% < 60%. Problem 5: 2/(2+8) = 20% < 60%. Problem 15: 0/(0+1) = 0% < 60%. All problems are low-quality, sorted by problem_id: [5, 10, 15].

Constraints

1 ≤ problem_id ≤ 10⁵
0 ≤ likes, dislikes ≤ 10⁵
likes + dislikes > 0 (each problem has at least one vote)
The result should be ordered by problem_id in ascending order

Visualization

Tap to expand

Understanding the Visualization

Input Data

Each problem has likes and dislikes from user feedback

Calculate Total

Add likes + dislikes to get total votes for each problem

Find Percentage

Divide likes by total votes to get like percentage

Apply Threshold

Keep only problems where like percentage < 60%

Sort Results

Order qualifying problem IDs in ascending order

Key Takeaway

🎯 Key Insight: This problem demonstrates how SQL can efficiently filter data using mathematical operations in WHERE clauses, making it perfect for percentage-based quality assessments.

Asked in

a Amazon 15 G Google 12 f Meta 8 ⊞ Microsoft 6

This database problem requires a simple SQL query that calculates the like percentage for each problem and filters those below 60%. The key insight is using mathematical division in the WHERE clause: likes / (likes + dislikes) < 0.6. The solution runs in O(n) time with a single table scan and automatic sorting by problem_id.

Common Approaches

Approach	Time	Space	Notes
✓ Basic SQL Query with Division	O(n)	O(1)	Direct calculation of like percentage using division and WHERE clause

Basic SQL Query with Division — Algorithm Steps

Calculate total votes as (likes + dislikes)
Calculate like percentage as likes / total_votes
Filter where like percentage < 0.6 (60%)
Order results by problem_id ascending

Visualization

Tap to expand

Step-by-Step Walkthrough

Read Each Row

Database scans through each problem record

Calculate Total Votes

Computes likes + dislikes for each row

Calculate Like Percentage

Divides likes by total votes to get percentage

Apply Filter

Keeps only rows where percentage < 0.6

Sort Results

Orders qualifying problem_ids in ascending order

Code -

solution.c — C

// SQL solution using C with MySQL C API
#include <stdio.h>
#include <stdlib.h>
#include <mysql/mysql.h>

typedef struct {
    int problem_id;
    int likes;
    int dislikes;
} Problem;

int compare_ints(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int* findLowQualityProblems(Problem* problems, int size, int* resultSize) {
    int* result = (int*)malloc(size * sizeof(int));
    *resultSize = 0;
    
    for (int i = 0; i < size; i++) {
        int totalVotes = problems[i].likes + problems[i].dislikes;
        double likePercentage = (double)problems[i].likes / totalVotes;
        
        if (likePercentage < 0.6) {
            result[*resultSize] = problems[i].problem_id;
            (*resultSize)++;
        }
    }
    
    qsort(result, *resultSize, sizeof(int), compare_ints);
    return result;
}

// SQL query
const char* SQL_QUERY = """
    SELECT problem_id
    FROM Problems
    WHERE likes / (likes + dislikes) < 0.6
    ORDER BY problem_id ASC
""";

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all rows in the table

✓ Linear Growth

Space Complexity

O(1)

No additional space needed beyond result set

✓ Linear Space

23.5K Views

Medium Frequency

~8 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Basic SQL Query with Division — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler