Los diferentes sistemas tienen diferentes formas de describir los colores, incluso si todos están hablando en el espacio RGBA. Un desarrollador front-end que esté familiarizado con CSS puede preferir #RRGGBBAA. Pero los desarrolladores de Android pueden preferir #AARRGGBB. Cuando se maneja el formato de archivo AAS, #AABBGGRRes necesario. Eso es muy confuso. Quizás necesitemos un programa que pueda convertir entre diferentes formatos de color.

Entrada:

La entrada contiene 3 partes:

• El color a transformar (p #1459AC0F. Ej. ), Una cadena que comienza con un signo agudo #seguido de 8 dígitos hexadecimales.
• El formato del color dado (p #RRGGBBAA. Ej. ), Una cadena que comienza con #8 letras seguidas de 4 grupos diferentes y cada grupo es uno de RR/ GG/ BB/ AA.
• El formato para convertir.

Salida:

• Salida del color en formato convertido

Casos de prueba:

Color, OriginalFormat, TargetFormat -> Result
#12345678, #RRGGBBAA, #AARRGGBB -> #78123456
#1A2B3C4D, #RRGGBBAA, #AABBGGRR -> #4D3C2B1A
#DEADBEEF, #AARRGGBB, #GGBBAARR -> #BEEFDEAD

Entrada / salida son mayúsculas y minúsculas. Puede ingresar / emitir de cualquier manera aceptable.

Reglas:

Este es el código de golf, los códigos más cortos (en bytes) de cada idioma ganado

APL (Dyalog Unicode) , ^{SBCS de} 6 bytes

Programa completo Solicita STDIN para Original, luego Destino, luego Color. Imprime el resultado en STDOUT.

⍞[⍞⍋⍞]

Pruébalo en línea!

  ⍞ solicitud de original

 ⍞⍋ solicite Target y encuentre los índices en Original que convertirían Original en Target

⍞[... ] solicite Color y use los índices obtenidos anteriormente para reordenar Color

JavaScript (ES6), 53 52 bytes

Guardado 1 byte gracias a @tsh

Toma de entrada como 3 parámetros distintos: (Color, From, To).

(C,F,T)=>T.replace(/\w/g,(x,i)=>C[F.search(x)-~i%2])

Pruébalo en línea!

Stax , 8 bytes

ç▼☺↔kàÅJ

Ejecutar y depurarlo

Este programa toma la entrada en este formato.

"{Color}" "{OriginalFormat}" "{TargetFormat}"

Aquí está la versión desempaquetada y no comentada del mismo programa.

u       drop duplicated characters from target format
{       for each character remaining in target format, map using block...
  [     duplicate original format at second position in stack
  |I    get all indices of target character in original format
  xs@   retrieve characters from those indices from the color string
m       perform map
        output implicitly when complete

Ejecute este

Python 2 , 59 bytes

lambda c,o,t:'#'+''.join(c[o.find(v):][:2]for v in t[1::2])

Pruébalo en línea!

Retina 0.8.2 , 33 bytes

(.)(?<=(..).{7}\1\1.*)\1
$2
.*#
#

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

(.)(?<=(..).{7}\1\1.*)\1
$2

Para cada par de caracteres idénticos, busque otra copia de ese par, y luego los caracteres noveno y octavo antes de eso, y reemplace el par con esos caracteres. Esto solo es posible para los pares de caracteres en el formato de destino, y los reemplaza con el resultado deseado.

.*#
#

Eliminar el color y el formato de origen.

Haskell , 108104100 94 87 bytes

(s,(r@(x,y):z))!c|x==c=(s++[y],z)|(p,q)<-(s,z)!c=(p,r:q)
c%i=fst.(foldl(!)("",zip i c))

Pruébalo en línea!

Versión antigua

^{¡Gracias a Laikoni por acortar 6 bytes al encontrar una forma más corta de usar lookup!}

f(Just x)=x
p('#':z)=p z
p(x:y:z)=[x,y]:p z
p e=[]
c!i=('#':).(f.(`lookup`zip(p i)(p c))=<<).p

Pruébalo en línea!

Explicación:

• la pfunción "analiza" una cadena al ignorar los #grupos (listas) iniciales y de retorno de 2 caracteres.
• el (!)operador toma como entrada el color y el formato de entrada y devuelve una función que toma como parámetro el formato de salida y devuelve el color convertido. Resultó que la versión sin puntos era más corta, pero comencé con la versión más legible:

f c i o='#':concat[x#zip(p<$>[i,c])|x<-p o]

Pruébalo en línea!

Perl 5 -p , 33 32 27 bytes

Dar entrada en el orden: objetivo, original, número

#!/usr/bin/perl -p
s%.%$2x/(..)+$&(.){10}/g%eg

Pruébalo en línea!

Para cada carácter en la entrada, encuentre el mismo carácter un número par de lugares hacia adelante y luego desde allí avance 10 caracteres más y tome ese carácter como reemplazo. Si no puede hacer estos pasos, reemplácelos por nada.

    +--even-+----10---+   
    |       |         |
#AARRGGBB #RRGGBBAA #12345678
    |    >-will get removed-<
    v
    2

05AB1E , 10 bytes

2FI2ô™J}I‡

Pruébalo en línea!

2F     }   # Loop twice...
  I        # First 2 inputs.
   2ô™     # Title case in pairs of 2.
      J    # Rejoin together.
        I  # Last input (The color).
         ‡ # Transliterate, put color in pattern from a into pattern from b.

Esto funciona porque cambio la entrada de:

AARRGGBB

A:

AaRrGgBb

Entonces, cada valor se asigna de manera única, luego puedo usar transliterate.

Los argumentos se invierten.

Java 10, 179 105 102 bytes

(a,b,c)->{var r="#";for(int i=1,t;i<9;)r+=a.substring(t=b.indexOf(c.substring(i,i+=2)),t+2);return r;}

La friolera de -77 bytes gracias a @ OlivierGrégoire .

Explicación:

Pruébalo en línea.

(a,b,c)->{            // Method with String as three parameters and return-type
  var r="#";          //  Result-String, starting at "#"
  for(int i=1,t;i<9;  //  Loop `i` from 1 to 9 (exclusive)
    r+=               //   Append the result with:
       a.substring(   //    A substring from the first input,
        t=b.indexOf(  //    where an index is determined in the second input
           c.substring(i,i+=2)),t+2);
                      //    based on a substring of the third input
    return r;}        //  Return the result-String

J , 5 bytes

/:i./

El argumento izquierdo es el color. El argumento correcto es una matriz de caracteres donde la primera fila es el formato de destino y la segunda fila es el formato original. Pruébalo en línea!

CJam, 14 bytes

{'#\1f>2f/~er}

Pruébalo en línea!

La entrada es una matriz en el orden inverso.

{
 `#\      e# Push '#'+[input array] on to stack
  1f>     e# Remove the '#' symbol from each input string
  2f/     e# Split each input string into an array of substrings of length 2.
  ~       e# Dump the substring-arrays from the container array onto the stack
  er      e# Perform a string replace operation
}     

Python 2, 62 bytes

lambda c,s,e:[c[s.index(e[i]):][:2]for i in range(1,len(e),2)]

SmileBASIC, 144 bytes

DEF R C,I,O
C[0]="&H
A=R+G+B
RGBREAD VAL(C)OUT VAR(I[1]),VAR(I[3]),VAR(I[5]),VAR(I[7])?"#";RGB(VAR(O[1]),VAR(O[3]),VAR(O[5]),VAR(O[7]))END

Rojo , 154 120 114 bytes

func[c o t][g: func[q][parse q[skip collect 4 keep 2 skip]]
prin"#"foreach p g t[prin pick g c index? find g o p]]

Pruébalo en línea!

Python 3 , 102 bytes

lambda x,a,b:['#']+[[x[i:i+2]for i in range(1,len(x),2)][i]for i in[a[1::2].index(i)for i in b[1::2]]]

Pruébalo en línea!

Jalea , 6 bytes

ẹЀQị⁵

Pruébalo en línea!

Programa completo

Argumento 1:
Argumento original 2:
Argumento de destino 3: Color

C (clang) , 89 bytes

char *a,b[10],*i,*o;f(x,y){*b=*a;for(x=1;x<8;b[x++]=a[y=index(i,o[x])-i],b[x++]=a[y+1]);}

Pruébalo en línea!

Toma el valor de entrada en a, en formato dentro iy fuera de formato o. Devuelve el valor enb

Truco menor: almacenando el resultado en blugar de imprimir para guardar bytes. La pregunta no lo rechaza.

char *a,b[10],*i,*o;f(x,y){*b=*a;for(x=1;x<8;b[x]=a[y=index(i,o[x])-i],b[x+1]=a[y+1],x+=2);puts(b);}

Pruébalo en línea!

char *a,*i,*o;c[4],x,y,z;g(x){x=x==82?0:x==71?1:x==66?2:3;}f(){a++;for(;z<2;z++){i=(z?o:i)+1;for(y=0;y<7;z?printf("%s%2X","#"+!!y,c[g(i[y])]):sscanf(a+y,"%2X",&c[g(i[y])]),y+=2);}}

Pruébalo en línea!

Crea un RGBAvalor en una c[]matriz según el formato i, luego imprime en oformato

Clojure 1.8, 156 bytes

(fn[c o t](reduce #(str %(val %2))""(sort-by key(reduce-kv #(let[s(clojure.string/index-of t(nth o %2))](assoc %(if(contains? % s)(inc s)s)%3)){}(vec c)))))

Sin golf

  (fn [c o t]
    (reduce
     #(str % (val %2))
     ""
     (sort-by key
              (reduce-kv
               #(let [s (clojure.string/index-of t (nth o %2))]
                  (assoc %
                         (if (contains? % s) (inc s) s)
                         %3))
               {}
               (vec c)))))

Pruébelo en línea no tiene soporte Clojure 1.8. ¡Muy extraño!

Perl 6 , 55 51 46 bytes

{[~] %(@^b Z=>@^a){@^c}}o*.map(*.comb(/\w?./))

Pruébalo en línea!

Toma una lista (color, original, destino) como entrada. Divide cada cadena de entrada en componentes, crea claves de origen de mapeo de hash para valores de color, busca valores de color en el orden de las teclas de destino y luego formatea el resultado.