Todos los desafíos
Intermedio 0 resueltos 0% de aceptación

Filtro de escala de grises

Convierte a escala de grises una cuadrícula de píxeles RGB empaquetados usando el brillo ponderado de cada canal.

Lo que aprenderás

  • Extraer el rojo, el verde y el azul de un solo entero
  • Redondear un promedio ponderado con aritmética entera
  • Volver a empaquetar los tres canales en un solo entero

Problema

Ver original (inglés)

Una imagen es una cuadrícula de píxeles, y cada píxel se guarda como un solo entero que empaqueta su color: red × 65536 + green × 256 + blue, con cada canal de 0 a 255 (el color hexadecimal #FF8000 es el entero 16744448). Para pasar la imagen a gris, a cada píxel se le da el mismo valor g en los tres canales, donde g es el brillo del píxel:

g = (299 × red + 587 × green + 114 × blue) / 1000, redondeado al entero más cercano, con las mitades hacia arriba.

Usando solo enteros, eso es g = (299 × red + 587 × green + 114 × blue + 500) / 1000 con división entera.

Implementa grayscale_filter(pixels).

Entrada

pixels: la imagen, una lista por fila. Las filas pueden tener longitudes distintas.

Salida

Devuelve una cuadrícula con la misma forma en la que cada píxel vale g × 65536 + g × 256 + g. Una imagen vacía da una cuadrícula vacía.

Restricciones

0 ≤ filas ≤ 50, 0 ≤ píxeles por fila ≤ 50

0 ≤ cada píxel ≤ 16,777,215

Ejemplos

Ejemplo 1
Entrada:
pixels = [
    [16744448, 255]
]

Salida esperada:
expected = [
    [9934743, 1907997]
]
Entrada:
std::vector<std::vector<long long>> pixels = {
    {16744448, 255}
};

Salida esperada:
std::vector<std::vector<long long>> expected = {
    {9934743, 1907997}
};
Entrada:
long[][] pixels = new long[][] {
    new long[] {16744448, 255}
};

Salida esperada:
long[][] expected = new long[][] {
    new long[] {9934743, 1907997}
};

Explicación

#FF8000 tiene rojo 255, verde 128 y azul 0: (76245 + 75136 + 0 + 500) / 1000 = 151, lo que da 151 × 65793 = 9934743. El azul puro 255 da (29070 + 500) / 1000 = 29, es decir, 1907997.

Ejemplo 2
Entrada:
pixels = [
    [0, 16777215],
    [8421504, 65280]
]

Salida esperada:
expected = [
    [0, 16777215],
    [8421504, 9868950]
]
Entrada:
std::vector<std::vector<long long>> pixels = {
    {0, 16777215},
    {8421504, 65280}
};

Salida esperada:
std::vector<std::vector<long long>> expected = {
    {0, 16777215},
    {8421504, 9868950}
};
Entrada:
long[][] pixels = new long[][] {
    new long[] {0, 16777215},
    new long[] {8421504, 65280}
};

Salida esperada:
long[][] expected = new long[][] {
    new long[] {0, 16777215},
    new long[] {8421504, 9868950}
};

Explicación

El negro se queda en 0 y el blanco en 16777215. El gris #808080 conserva 128 (8421504), y el verde puro da (149685 + 500) / 1000 = 150, es decir, 9868950.

Cómo abordarlo

Inténtalo primero por tu cuenta y luego abre las pistas una a una.

Pista 1

El rojo es (pixel / 65536) % 256, el verde es (pixel / 256) % 256 y el azul es pixel % 256; también sirven los desplazamientos y las máscaras de bits.

Pista 2

Sumar 500 antes de dividir entre 1000 redondea las mitades hacia arriba.

Pista 3

Al volver a empaquetar, pon el mismo valor de gris en los tres canales.

Complejidad esperada

tiempo O(rows × columns), espacio extra O(rows × columns)

Referencias

Este reto está adaptado para CodeUtility. Sigue el enunciado y las restricciones indicadas arriba.

Clasificación

Clasificación completa

La mejor solución aprobada de cada programador. Las más rápidas, ligeras y mejor valoradas van primero.

Aún no hay soluciones aprobadas. Resuélvelo y quédate el primer puesto.

Aprende de otros

Soluciones de la comunidad

Aún no hay soluciones publicadas. Resuelve este reto para compartir la primera.