All challenges
Medium 0 solved 0% acceptance

Grayscale Filter

Turn a grid of packed RGB pixels into grayscale using weighted channel brightness.

What you'll learn

  • Unpack red, green and blue from one integer
  • Round a weighted average using integer arithmetic
  • Pack three channels back into one integer

Problem

An image is a grid of pixels, and each pixel is stored as one integer that packs its color: red × 65536 + green × 256 + blue, with each channel from 0 to 255 (the hex color #FF8000 is the integer 16744448). To make the image gray, give every pixel the same value g in all three channels, where g is the pixel's brightness:

g = (299 × red + 587 × green + 114 × blue) / 1000, rounded to the nearest whole number with halves rounded up.

Using integers only, that is g = (299 × red + 587 × green + 114 × blue + 500) / 1000 with integer division.

Implement grayscale_filter(pixels).

Input

pixels: The image, one list per row. Rows may have different lengths.

Output

Return a grid of the same shape where each pixel is g × 65536 + g × 256 + g. An empty image gives an empty grid.

Constraints

0 ≤ rows ≤ 50, 0 ≤ pixels per row ≤ 50

0 ≤ each pixel ≤ 16,777,215

Examples

Example 1
Input:
pixels = [
    [16744448, 255]
]

Expected output:
expected = [
    [9934743, 1907997]
]
Input:
std::vector<std::vector<long long>> pixels = {
    {16744448, 255}
};

Expected output:
std::vector<std::vector<long long>> expected = {
    {9934743, 1907997}
};
Input:
long[][] pixels = new long[][] {
    new long[] {16744448, 255}
};

Expected output:
long[][] expected = new long[][] {
    new long[] {9934743, 1907997}
};

Explanation

#FF8000 has red 255, green 128, blue 0: (76245 + 75136 + 0 + 500) / 1000 = 151, giving 151 × 65793 = 9934743. Pure blue 255 gives (29070 + 500) / 1000 = 29, so 1907997.

Example 2
Input:
pixels = [
    [0, 16777215],
    [8421504, 65280]
]

Expected output:
expected = [
    [0, 16777215],
    [8421504, 9868950]
]
Input:
std::vector<std::vector<long long>> pixels = {
    {0, 16777215},
    {8421504, 65280}
};

Expected output:
std::vector<std::vector<long long>> expected = {
    {0, 16777215},
    {8421504, 9868950}
};
Input:
long[][] pixels = new long[][] {
    new long[] {0, 16777215},
    new long[] {8421504, 65280}
};

Expected output:
long[][] expected = new long[][] {
    new long[] {0, 16777215},
    new long[] {8421504, 9868950}
};

Explanation

Black stays 0 and white stays 16777215. Gray #808080 keeps 128 (8421504), and pure green gives (149685 + 500) / 1000 = 150, so 9868950.

How to approach it

Try on your own first, then open one hint at a time.

Hint 1

Red is (pixel / 65536) % 256, green is (pixel / 256) % 256 and blue is pixel % 256; shifts and masks work too.

Hint 2

Adding 500 before dividing by 1000 rounds halves up.

Hint 3

Put the same gray value in all three channels when packing it back.

Expected complexity

O(rows × columns) time, O(rows × columns) extra space

References

This challenge is adapted for CodeUtility. Follow the statement and constraints above.

The best passing solution of each coder. Faster, smaller and better-reviewed solutions rank higher.

No passing solutions yet. Solve it to take first place.

Learn from others

Community solutions

No published solutions yet. Solve this challenge to share the first one.