Tous les défis
Moyen 0 résolus 0 % de réussite

Filtre niveaux de gris

Convertissez en niveaux de gris une grille de pixels RGB codés sur un entier, en pondérant la luminosité de chaque composante.

Ce que vous allez apprendre

  • Extraire le rouge, le vert et le bleu d'un seul entier
  • Arrondir une moyenne pondérée avec des entiers uniquement
  • Recombiner trois composantes en un seul entier

Problème

Une image est une grille de pixels, et chaque pixel est stocké sous la forme d'un seul entier qui code sa couleur : red × 65536 + green × 256 + blue, chaque composante allant de 0 à 255 (la couleur hexadécimale #FF8000 correspond à l'entier 16744448). Pour passer l'image en gris, donnez à chaque pixel la même valeur g sur les trois composantes, où g est la luminosité du pixel :

g = (299 × red + 587 × green + 114 × blue) / 1000, arrondi à l'entier le plus proche, les demis étant arrondis vers le haut.

Avec uniquement des entiers, cela donne g = (299 × red + 587 × green + 114 × blue + 500) / 1000 en division entière.

Implémentez grayscale_filter(pixels).

Entrée

pixels : l'image, une liste par ligne. Les lignes peuvent avoir des longueurs différentes.

Sortie

Renvoyez une grille de même forme où chaque pixel vaut g × 65536 + g × 256 + g. Une image vide donne une grille vide.

Contraintes

0 ≤ lignes ≤ 50, 0 ≤ pixels par ligne ≤ 50

0 ≤ chaque pixel ≤ 16 777 215

Exemples

Exemple 1
Entrée :
pixels = [
    [16744448, 255]
]

Sortie attendue :
expected = [
    [9934743, 1907997]
]
Entrée :
std::vector<std::vector<long long>> pixels = {
    {16744448, 255}
};

Sortie attendue :
std::vector<std::vector<long long>> expected = {
    {9934743, 1907997}
};
Entrée :
long[][] pixels = new long[][] {
    new long[] {16744448, 255}
};

Sortie attendue :
long[][] expected = new long[][] {
    new long[] {9934743, 1907997}
};

Explication

#FF8000 a pour rouge 255, vert 128 et bleu 0 : (76245 + 75136 + 0 + 500) / 1000 = 151, ce qui donne 151 × 65793 = 9934743. Le bleu pur 255 donne (29070 + 500) / 1000 = 29, donc 1907997.

Exemple 2
Entrée :
pixels = [
    [0, 16777215],
    [8421504, 65280]
]

Sortie attendue :
expected = [
    [0, 16777215],
    [8421504, 9868950]
]
Entrée :
std::vector<std::vector<long long>> pixels = {
    {0, 16777215},
    {8421504, 65280}
};

Sortie attendue :
std::vector<std::vector<long long>> expected = {
    {0, 16777215},
    {8421504, 9868950}
};
Entrée :
long[][] pixels = new long[][] {
    new long[] {0, 16777215},
    new long[] {8421504, 65280}
};

Sortie attendue :
long[][] expected = new long[][] {
    new long[] {0, 16777215},
    new long[] {8421504, 9868950}
};

Explication

Le noir reste 0 et le blanc reste 16777215. Le gris #808080 garde 128 (8421504), et le vert pur donne (149685 + 500) / 1000 = 150, donc 9868950.

Comment l'aborder

Essayez d'abord seul, puis ouvrez les indices un par un.

Indice 1

Le rouge vaut (pixel / 65536) % 256, le vert (pixel / 256) % 256 et le bleu pixel % 256 ; les décalages de bits et les masques marchent aussi.

Indice 2

Ajouter 500 avant de diviser par 1000 arrondit les demis vers le haut.

Indice 3

Mettez la même valeur de gris dans les trois composantes en recombinant le pixel.

Complexité attendue

temps O(rows × columns), espace supplémentaire O(rows × columns)

Références

Ce défi a été adapté pour CodeUtility. Suivez l'énoncé et les contraintes ci-dessus.

La meilleure solution validée de chaque codeur. Les plus rapides, les plus légères et les mieux notées passent devant.

Aucune solution validée pour l'instant. Résolvez-le et prenez la première place.

Apprenez des autres

Solutions de la communauté

Aucune solution publiée pour l'instant. Résolvez ce défi pour partager la première.