Vous êtes développeur Web et votre patron a décidé de mettre à jour le site Web de l'entreprise. Il a décidé que moins de couleur est meilleure, mais il souhaite que le site soit identique. Vous décidez à juste titre qu'il n'a aucune idée de quoi il parle, mais vous allez quand même essayer, parce que vous vous ennuyez. Étant donné que la société possède des milliers de pages Web et que chacune possède son propre CSS, vous décidez d'écrire un script pour effectuer les modifications nécessaires. L'analyse HTML n'est pas requise.

Toutes les pages utilisent actuellement une chaîne comme rgb(255,0,0)pour une couleur. Compte tenu des trois valeurs décimales représentant les valeurs RVB d'un attribut de couleur CSS (dans cet ordre), retour ou imprimer la plus courte représentation de chaîne de cette couleur, de telle sorte qu'il est utilisable pour CSS comme ceci: color:<your-result-here>;.

Voici un tableau complet des mots-clés de couleur CSS valides . Ils sont insensibles à la casse.

Exemples:

Notez que les couleurs peuvent être définies avec 12 ou 24 bits. Le modèle #ABCest une version plus courte de #AABBCC. Chuck Norris est une couleur .

Votre programme n'accepte que 3 entiers, pas une chaîne (à l'exception du "bonus" mentionné plus loin).

0, 0, 0         ->  #000        (same as #000000, but shorter)
255, 0, 0       ->  red
0, 128, 128     ->  TEAL
139, 0, 0       ->  DarkRed     (OR #8B0000)
72, 61, 139     ->  #483D8B
255, 255, 254   ->  #fffffe
255, 85, 255    ->  #f5f        (same as #ff55ff, but shorter)

Scoring / Règles

• Le code le plus court gagne!
• Les failles standard sont interdites , à l'exception des fonctions intégrées.
• -50% octets (le bonus est arrondi vers le bas) si vous acceptez n'importe quel * sélecteur de couleur valide et produisez le plus court. Tout comme DarkSlateBlueles sorties #483D8B, les #F00sorties red, etc.
  • * Cela inclut uniquement les RVB, les codes hexadécimaux et les noms.
  • Notez que certaines couleurs ont des noms alternatifs en raison de X11 (comme Fuchsiaet Magenta, ou Cyanet Aqua). Les autres noms sont inclus dans la liste chaînée des mots-clés de couleur CSS selon la norme W3.
• CSS3 est Turing complet . Ça vaudrait une prime.

Modifier:

• VEUILLEZ EXÉCUTER VOTRE CODE SUR LES CAS D'ESSAI!

Perl, 212 - 50% = 106 octets

use aliased Graphics::ColorNames,G;sub c{tie%c,G,CSS;$_=pop;$c={reverse%c}->{$_=sprintf'%02x'x(@0=/(\d+, ?)((?1))(\d+)/)||$c{s/#(.)(.)(.)$|#/\1\1\2\2\3\3/r},@0};s/(.)\1(.)\2(.)\3|/#\1\2\3/;y///c>length$c&&$c||$_}

Avec des nouvelles lignes ajoutées:

use aliased Graphics::ColorNames,G;
sub c{
  tie%c,G,CSS;$_=pop;
  $c={reverse%c}->{
    $_=sprintf'%02x'x(@0=/(\d+, ?)((?1))(\d+)/)||$c{s/#(.)(.)(.)$|#/\1\1\2\2\3\3/r},@0
  };
  s/(.)\1(.)\2(.)\3|/#\1\2\3/;
  y///c>length$c&&$c||$_
}

Cas de test

use feature say;

say c '#f00';
say c '#FF0000';
say c '#112233';
say c '#f0ffff';
say c 'azure';
say c 'DARKSLATEBLUE';
say c 'rgb(255, 127, 80)';
say c 'rgb(255, 255, 254)';
say c 'rgb(255,228,196)';

Sortie

red
red
#123
azure
azure
#483d8b
coral
#fffffe
bisque

Perl, pas de bonus, 144 octets

use aliased Graphics::ColorNames,G;sub c{tie%c,G,CSS;$c={reverse%c}->{$_=sprintf'%02x'x3,@_};s/(.)\1(.)\2(.)\3|/#\1\2\3/;y///c>length$c&&$c||$_}

Avec des nouvelles lignes ajoutées:

use aliased Graphics::ColorNames,G;
sub c{
  tie%c,G,CSS;
  $c={reverse%c}->{
    $_=sprintf'%02x'x3,@_
  };
  s/(.)\1(.)\2(.)\3|/#\1\2\3/;
  y///c>length$c&&$c||$_
}

Graphics::ColorNames n'est pas un module de base, mais il existe depuis 2001. Vous devrez peut-être l'installer via:

cpan install Graphics::ColorNames
cpan install Graphics::ColorNames::CSS

La représentation hexadécimale est préférée si le nom de la couleur a la même longueur.

Cas de test

use feature say;

say c 0, 0, 0;
say c 255, 0, 0;
say c 0, 128, 128;
say c 139, 0, 0;
say c 72, 61, 139;
say c 255, 255, 254;
say c 255, 85, 255;

Sortie

#000
red
teal
#8b0000
#483d8b
#fffffe
#f5f

C # 6 527 octets / 2 bonus = 264

EDIT: Woot! J'ai finalement obtenu la réponse bonus avec un score inférieur à la réponse de base!

J'ai écrit juste une fonction. Il nécessite une usingdéclaration (incluse.)

C # a une belle liste de couleurs connues avec lesquelles travailler, mais il insiste pour inclure le canal Alpha. Les couleurs connues incluent également toutes les couleurs du système, dont deux ont des noms de moins de 7 caractères, il fallait donc les supprimer.

Voici la solution bonus, prenant en charge des formats tels que:

• 12, 34, 56
• #123
• #123456
• DarkSlateBlue

Complètement golfé:

using System.Drawing;int H(string s,int i,int l)=>Convert.ToInt32(s.Substring(i*l+1,l),16)*(l<2?17:1);string D(string a){int i=17,j=a.Length/3,n;var d=a.Split(',');Color k,c=a[0]<36?Color.FromArgb(H(a,0,j),H(a,1,j),H(a,2,j)):Color.FromName(a);c=c.A>0?c:Color.FromArgb(int.Parse(d[0]),int.Parse(d[1]),int.Parse(d[2]));j=c.R%i+c.G%i+c.B%i<1?3:6;n=c.ToArgb();a="#"+(j<6?c.R/i<<8|c.G/i<<4|c.B/i:n&0xffffff).ToString("x"+j);for(i=26;i++<167;k=Color.FromKnownColor((KnownColor)i),a=n==k.ToArgb()&k.Name.Length<=j?k.Name:a);return a;}

Indentation et nouvelles lignes pour plus de clarté:

using System.Drawing;
int H(string s,int i,int l)=>Convert.ToInt32(s.Substring(i*l+1,l),16)*(l<2?17:1);
string C(string a){
    int i=17,j=a.Length/3,n;
    var d=a.Split(',');
    Color k,c=a[0]<36
        ?Color.FromArgb(H(a,0,j),H(a,1,j),H(a,2,j))
        :Color.FromName(a);
    c=c.A>0?c:Color.FromArgb(int.Parse(d[0]),int.Parse(d[1]),int.Parse(d[2]));
    j=c.R%i+c.G%i+c.B%i<1?3:6;
    n=c.ToArgb();
    a="#"+(j<6?c.R/i<<8|c.G/i<<4|c.B/i:n&0xffffff).ToString("x"+j);
    for(i=26;i++<167;
        k=Color.FromKnownColor((KnownColor)i),
        a=n==k.ToArgb()&k.Name.Length<=j?k.Name:a
    );
    return a;
}

C #, 265 octets

Voici la solution de base.

using System.Drawing;string C(int r,int g,int b){int i=17,c=r<<16|g<<8|b,j=r%i+g%i+b%i<1?3:6;var o="#"+(j<6?r/i<<8|g/i<<4|b/i:c).ToString("x"+j);for(i=26;i++<167;){var k=Color.FromKnownColor((KnownColor)i);o=c<<8==k.ToArgb()<<8&k.Name.Length<=j?k.Name:o;}return o;}

Indentation et nouvelles lignes pour plus de clarté:

using System.Drawing;

string C(int r,int g,int b){
    int i=17,
        c=r<<16|g<<8|b,
        j=r%i+g%i+b%i<1?3:6;
    var o="#"+(j<6?r/i<<8|g/i<<4|b/i:c).ToString("x"+j);
    for(i=26;i++<167;){
        var k=Color.FromKnownColor((KnownColor)i);
        o=c<<8==k.ToArgb()<<8&k.Name.Length<=j?k.Name:o;
    }
    return o;
}

Mathematica 207 242 500-250 = 250 octets

Mise à jour:
cela fonctionne avec des entrées composées de triplets RVB, de noms de couleurs ou de nombres hexadécimaux.

(12 bits) La sortie de profondeur de couleur fonctionne désormais correctement, grâce à un excellent article sur la réduction de profondeur de couleur . L'idée de base est que, si un triple RVB {r, g, b}, où r, g et b sont compris entre 0 et 255, (c'est-à-dire hex 00-ff) peut être représenté sans perte comme un nombre dans la plage de 0 à 15 (c.-à-d. 0-f), alors on peut utiliser le nombre hexadécimal à 3 chiffres au lieu du nombre à 6 chiffres. Il s'avère que cela se produit chaque fois que 17 (c'est-à-dire 255/15) divise r, g et b.

Seules les fonctions intégrées sont utilisées. Mathematica a des règles pour remplacer les noms de couleurs HTML par des triplets RVB. Par exemple, une règle est "Teal"-> RGBColor[0, 128, 128]. Lorsque ces règles sont inversées, les valeurs RVB (recalibrées à la plage, {0, 255}) peuvent être remplacées par des noms de couleur.

q=ColorData["HTML","ColorRules"];
j=q/.{(c_ -> RGBColor[r_,g_,b_]):> (Floor[255{r,g,b}]-> c)};
k=Reverse/@j;
v@l_:=And@@IntegerQ/@(l/17);
y@l_:=If[v@l,l/17,l];
h@l_:="#"<>(IntegerString[#,16,If[v@l,1,2]]&/@y@l)
o@h_:=Module[{c=(StringLength[h1=StringDrop[h,1]]==6)},FromDigits[#,16]&/@StringPartition[h1,If[c,2,1]]*If[c,1,17]]
u@l_:=ToString[l/.j]
m@s_:=s/.q/.RGBColor[r_,g_,b_]:>Floor[255{r,g,b}]
f@n_:=SortBy[{u@n,h@n},StringLength][[1]]
z@d_:= (If[StringQ@d,If[StringTake[d,1]=="#",e=o@d,e=m@d],e=d];f@e)

Exemples

z /@ {{0, 0, 0}, {255, 0, 0}, {0, 128, 128}, {139, 0, 0}, {255, 255, 
   255}, {72, 61, 139}, {255, 255, 254}, {255, 85, 255}}

{"# 000", "Rouge", "Sarcelle", "# 8b0000", "#fff", "# 483d8b", "#fffffe", "# f5f"}

z /@ {"Red", "DarkSlateBlue", "Teal", "Black"}

{"Rouge", "# 483c8b", "Sarcelle", "# 000"}

z /@ {"#000", "#f00", "#008080", "#8b0000", "#fff", "#483d8b", "#fffffe", "#f5f"}

{"# 000", "Rouge", "Sarcelle", "# 8b0000", "#fff", "# 483d8b", "#fffffe", \ "# f5f"}

Code commenté, non golfé

(* règles pour remplacer un nom de couleur par un échantillon de couleur, par exemple RGBColor{255,17,0}

q=ColorData["HTML","ColorRules"];

(* règles pour remplacer une liste de 3 entiers par le nom de couleur respectif, s'il en existe un. Et les mêmes règles, inversées. *)

rulesListsToColorNames=(q)/.{(c_ -> RGBColor[r_,g_,b_]):> (Floor[255{r,g,b}]-> c)};

rulesColorsToLists=Reverse/@rulesListsToColorNames;

(* teste si une couleur hexadécimale 24 bits peut être représentée comme une couleur 12 bits sans perte. reducepeut changer l'expression 24 bits en une expression 12 bits. *)

depthReducible[l_List]:=And@@IntegerQ/@(l/17);
reduce[l_List]:=If[depthReducible@l,l/17,l];

(* La liste RVB a été remplacée par un numéro Hex *)

fromListToHex[l_List]:="#"<>(IntegerString[#,16,If[depthReducible@l,1,2]]&/@reduce[l])

(* Le numéro hexadécimal est devenu la liste RVB. *)

fromHexToList[h_String]:=Module[{c=(StringLength[h1=StringDrop[h,1]]==6)},
FromDigits[#,16]&/@StringPartition[h1,If[c,2,1]]*If[c,1,17]
]

(* Plus de conversions *)

fromListToColorName[l_List]:=ToString[l/.rulesListsToColorNames]
fromColorNameToHex[s_String]:=fromListToHex[s/.rulesColorsToLists]
fromColorNameToList[s_String]:=s/.q/.RGBColor[r_,g_,b_]:>Floor[255{r,g,b}]

(* choisit l'expression CSS valide la plus courte d'une couleur *)

f@n_List:=SortBy[{fromListToColorName[n],fromListToHex[n]},StringLength][[1]]

(* convertit toute entrée en une liste RVB et appelle f *)

returnShortestColor[d_]:= 
 (If[StringQ[d],
   If[StringTake[d,1]=="#",
     e=fromHexToList@d,
     e=fromColorNameToList@d],
   e=d];
f@e)

CoffeeScript, 411 404 388 384 382/2 = 191

UPD: Je suis presque sûr que c'est le résultat final

J'espère que c'est correct à utiliser window.document.*. Vérifiez la rgbfonction et evalappelez.

s=(c,rgb=(r,g,b)->(2**24+(r<<16)+(g<<8)+b).toString 16)->d=y=document.body;r=(q=(a)->y.style.color=a;d[b='#'+eval(getComputedStyle(y).color)[1...].replace /(.)\1(.)\2(.)\3/,'$1$2$3']=a;b) c;(d='NavyGreenTealIndigoMaroonPurpleOliveGraySiennaBrownSilverPeruTanOrchidPlumVioletKhakiAzureWheatBeigeSalmonLinenTomatoCoralOrangePinkGoldBisqueSnowIvoryRed'.match /.[a-z]+/g).map(q);d[r]||r

Résultats de test

rgb(   0,   0,   0 ) -> #000
rgb( 255,   0,   0 ) -> Red
rgb(   0, 128, 128 ) -> Teal
rgb( 139,   0,   0 ) -> #8b0000
rgb(  72,  61, 139 ) -> #483d8b
rgb( 255, 255, 254 ) -> #fffffe
rgb( 255,  85, 255 ) -> #f5f
darkslateblue        -> #483d8b
indigo               -> Indigo
#f00                 -> Red

Code commenté

s = ( c,
    rgb = ( r, g, b ) ->
        return ( 2 ** 24 + ( r << 16 ) + ( g << 8 ) + b )
        .toString( 16 )
) ->

Cela permettra d'économiser quelques octets.

    d = y = document.body

qLa fonction placera la couleur d'entrée document.body.style.coloret obtiendra la couleur compilée comme rgb(...). Il enregistrera également le résultat comme hexColor:inputColordans d. Remarquez l' evalutilisation. rgb(100,100,100)est un appel de fonction JavaScript valide avec trois arguments numériques. rgbLa fonction convertira les arguments en une seule notation HEX 24/12 (comme #fff, #f0f0f0).

    r = (
        q = ( a ) ->
            y.style.color = a
            b = '#' + eval( getComputedStyle( y ).color )[ 1... ].replace( /(.)\1(.)\2(.)\3/, '$1$2$3' )
            d[ b ] = a
            return b
    )( c )

Fractionner la chaîne en un tableau de noms de couleurs, créer un objet de recherche.

    ( d = 'NavyGreenTeal...'.match( /.[a-z]+/g )).map( q )

Et renvoyez HEX s'il n'y a pas de variante plus courte d.

    return d[ r ] or r

Stylet, 238 234/2 = 117

Plus de solution de type CSS! Le stylet a déjà un grand support pour la manipulation des couleurs, donc la fonction souhaitée est assez petite et peu jouée au golf.

f(c){for n in split(' ''navy green teal indigo maroon purple olive gray sienna brown silver peru tan orchid plum violet khaki azure wheat beige salmon linen tomato coral orange pink gold bisque snow ivory red'){lookup(n)==c?c=s(n):c}}

Testez-le ici

body
  color f(rgb(0, 0, 0))
  color f(rgb(255, 0, 0))
  color f(rgb(0, 128, 128))
  color f(rgb(139, 0, 0))
  color f(rgb(72, 61, 139))
  color f(rgb(255, 255, 254))
  color f(rgb(255, 85, 255))
  color f(darkslateblue)
  color f(indigo)
  color f(#f00)
  color f(rgba(255,0,0,1))
  color f(rgba(255,0,0,0.5))

Matlab 617

Beaucoup de prétraitement et de codage en dur. L'ensemble minimal de noms de couleurs que vous devez prendre en compte sont les suivants. Dommage que Matlab n'ait pas de noms de couleurs intégrés = /

function s=f(r,g,b);
t=255;
c=[r,g,b];
a=[0 t t;240 t t;245 245 220;t 228 196;0 0 t;165 42 42;t 127 80;0 t t;t 215 0;75 0 130;t t 240;240 230 140;0 t 0;250 240 230;t 165 0;218 112 214;205 133 63;t 192 203;221 160 221;t 0 0;250 128 114;160 82 45;t 250 250;210 180 140;t 99 71;238 130 238;245 222 179;t t t;t t 0];
s=textscan('aqua azure beige bisque blue brown coral cyan gold indigo ivory khaki lime linen orange orchid peru pink plum red salmon sienna snow tan tomato violet wheat white yellow','%s');
i=find(ismember(a,c,'rows'));
k=1;
if i>0;s=s{1}{i};elseif ~any(mod(c,16));k=16;end;d=dec2hex(c/k,2-(k>1))';s=['#',d(:)']

Python 3, 857 795 octets

Le fait d'avoir à spécifier manuellement toutes les couleurs acceptées requises a augmenté le nombre d'octets sur celui-ci: /

c(a)prend un argument, aqui se présente sous la forme de rgb(#,#,#). De cela, le rgb et les crochets sont supprimés et la chaîne est ensuite divisée par des virgules en un tableau. c(x,y,z)prend 3 pouces, les valeurs r, g et b de la couleur rgb à traiter. Nous les mettons ensemble dans un tableau a. Nous utilisons ensuite la fonction intégrée de Python hexqui convertit un nombre Base 10 en un nombre Base 16 sur notre tableau et créons une chaîne hexadécimale (cela se fait dans la forboucle). Les ifinstructions convertissent les couleurs comme 000000en 000et remplacent les couleurs connues à l'aide d'un dictionnaire.

Le voici (merci à @undergroundmonorail pour avoir des conseils sur ;Python):

def c(x,y,z):
  a=[x,y,z];b="";
  for i in a:
    i=hex(i)[2:]
    if len(i)<2:i="0"+i;
    b+=i
  k={"00ffff":"AQUA","f0ffff":"AZURE","f5f5dc":"BEIGE","ffe4c4":"BISQUE","0000ff":"BLUE","a52a2a":"BROWN","ff7f50":"CORAL","ffd700":"GOLD","808080":"GRAY","008000":"GREEN","4b0082":"INDIGO","fffff0":"IVORY","f0e68c":"KHAKI","00ff00":"LIME","faf0e6":"LINEN","800000":"MAROON","000080":"NAVY","808000":"OLIVE","ffa500":"ORANGE","da70d6":"ORCHID","cd853f":"PERU","ffc0cb":"PINK","dda0dd":"PLUM","800080":"PURPLE","ff0000":"RED","fa8072":"SALMON","a0522d":"SIENNA","c0c0c0":"SILVER","fffafa":"SNOW","d2b48c":"TAN","008080":"TEAL","ff6347":"TOMATO","ee82ee":"VIOLET","f5deb3":"WHEAT","ffff00":"YELLOW"}
  if b[:3]==b[3:]:b=b[:3];
  if b in k:b=k[b];
  else:b="#"+b;
  return b

Ancienne version:

def c(a):
  a=a[4:-1].split(",")
  b=""
  for i in a:
    i=hex(int(i))[2:]
    if len(i)<2:
      i="0"+i
    b+=i
  k = {"00ffff":"AQUA","f0ffff":"AZURE","f5f5dc":"BEIGE","ffe4c4":"BISQUE","0000ff":"BLUE","a52a2a":"BROWN","ff7f50":"CORAL","ffd700":"GOLD","808080":"GRAY","008000":"GREEN","4b0082":"INDIGO","fffff0":"IVORY","f0e68c":"KHAKI","00ff00":"LIME","faf0e6":"LINEN","800000":"MAROON","000080":"NAVY","808000":"OLIVE","ffa500":"ORANGE","da70d6":"ORCHID","cd853f":"PERU","ffc0cb":"PINK","dda0dd":"PLUM","800080":"PURPLE","ff0000":"RED","fa8072":"SALMON","a0522d":"SIENNA","c0c0c0":"SILVER","fffafa":"SNOW","d2b48c":"TAN","008080":"TEAL","ff6347":"TOMATO","ee82ee":"VIOLET","f5deb3":"WHEAT","ffff00":"YELLOW"}
  if b[:3]==b[3:]:
    b=b[:3]
  if b in k:
    b=k[b]
  else:
    b="#"+b
  return "color:"+b+";"

J'y ajouterai peut-être le bonus, je ne sais pas encore. Il pourrait certainement le faire avec 50% d'octets!

-Toastrackenigma

JavaScript (ES6), 499 611

Modifier Ajout des cas de test dans la question

Remarque: J'ai conservé uniquement les noms de couleurs plus courts que l'équivalent hexadécimal.

Note 2: cela peut sûrement être joué plus ...

f=(r,g,b,k='#'+(r%17|g%17|b%17?1<<24|r<<16|g<<8|b:4096|(r*256+g*16+b)/17).toString(16).slice(1))=>
("#d2b48cTAN#f00RED#ff7f50CORAL#f5deb3WHEAT#ff6347TOMATO#ffd700GOLD#008000GREEN#faf0e6LINEN#f5f5dcBEIGE#da70d6ORCHID#4b0082INDIGO#ffc0cbPINK#f0e68cKHAKI#008080TEAL#ee82eeVIOLET#dda0ddPLUM#fa8072SALMON#ffa500ORANGE#a0522dSIENNA#800000MAROON#800080PURPLE#ffe4c4BISQUE#f0ffffAZURE#fffff0IVORY#cd853fPERU#808000OLIVE#c0c0c0SILVER#fffafaSNOW#a52a2aBROWN#000080NAVY#808080GRAY"
.match(k+'([A-Z]+)')||[,k])[1]

// TEST
;[[0,0,0,'#000'],[255,0,0,'red'],[0,128,128,'TEAL'],[139,0,0,'#8B0000'],[72,61,139,'#483D8B'],[255,255,254,'#fffffe'],[255,85,255,'#f5f']]
.forEach(([r,g,b,t])=>(x=f(r,g,b),o+=r+','+g+','+b+' -> '+x+' '+(x.toUpperCase()==t.toUpperCase()?'ok':'error('+t+')')+'\n'),o='')
O.innerHTML=o

function go()
{
  var r,g,b
  [r,g,b] = I.value.match(/\d+/g)
  O.innerHTML=r+','+g+','+b+' -> '+f(r,g,b)+'\n'+O.innerHTML
}

R,G,B: <input id=I><button onclick="go()">--></button>
<pre id=O></pre>

Moins golfé

f=(r,g,b) => (
   k='#'+(
     r%17|g%17|b%17
     ? 1<<24|r<<16|g<<8|b
     : 4096|r/17<<8|g/17<<4|b/17
    ).toString(16).slice(1),
   s = "#d2b48cTAN#f00RED#ff7f50CORAL#f5deb3WHEAT#ff6347TOMATO#ffd700GOLD#008000GREEN#faf0e6LINEN#f5f5dcBEIGE#da70d6ORCHID#4b0082INDIGO#ffc0cbPINK#f0e68cKHAKI#008080TEAL#ee82eeVIOLET#dda0ddPLUM#fa8072SALMON#ffa500ORANGE#a0522dSIENNA#800000MAROON#800080PURPLE#ffe4c4BISQUE#f0ffffAZURE#fffff0IVORY#cd853fPERU#808000OLIVE#c0c0c0SILVER#fffafaSNOW#a52a2aBROWN#000080NAVY#808080GRAY",
   m = s.match(k+'([A-Z]+)'), // names are upper, hex codes are lower
   (m || [,k])[1] // if no match use the code
)