Sistemas diferentes têm maneiras diferentes de descrever cores, mesmo que todos falem no espaço RGBA. Um desenvolvedor front-end familiarizado com CSS pode preferir #RRGGBBAA. Mas os desenvolvedores do Android podem preferir #AARRGGBB. Ao manipular o formato de arquivo AAS, #AABBGGRRé necessário. Isso é muito confuso. Talvez precisemos de um programa que possa converter entre diferentes formatos de cores.

Entrada:

A entrada contém 3 partes:

• A cor a ser transformada (por exemplo #1459AC0F), uma sequência que começa com um sinal nítido #seguido por 8 dígitos hexadecimais.
• O formato da cor fornecida (por exemplo #RRGGBBAA), uma sequência iniciada #por 8 letras, que se enquadram em 4 grupos diferentes e cada grupo é um de RR/ GG/ BB/ AA.
• O formato para o qual converter.

Resultado:

• Saída da cor no formato convertido

Casos de teste:

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

Entrada / saída não diferenciam maiúsculas de minúsculas. Você pode entrada / saída de qualquer maneira aceitável.

Regras:

Esse é o código de golfe, os códigos mais curtos (em bytes) de cada idioma

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

Programa completo. Solicita no STDIN o Original, o Destino e a Cor. Imprime o resultado em STDOUT.

⍞[⍞⍋⍞]

Experimente online!

  ⍞ solicitação de Original

 ⍞⍋ solicitar Target e encontrar os índices no Original que tornariam Original no Target

⍞[… ] Solicite cores e use os índices obtidos acima para reordenar cores

JavaScript (ES6), 53 52 bytes

Guardado 1 byte graças a @tsh

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

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

Experimente online!

Stax , 8 bytes

ç▼☺↔kàÅJ

Execute e depure

Este programa recebe entrada neste formato.

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

Aqui está a versão descompactada e não empacotada comentada do mesmo 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

Execute este

Python 2 , 59 bytes

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

Experimente online!

Retina 0.8.2 , 33 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

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

Para cada par de caracteres idênticos, procure outra cópia desse par e, em seguida, o nono e o oitavo caracteres antes e substitua o par por esses caracteres. Isso só é possível para os pares de caracteres no formato de destino e os substitui pelo resultado desejado.

.*#
#

Exclua a cor e o formato de origem.

Haskell , 108 104 100 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))

Experimente online!

Versão antiga

^{Agradecemos a Laikoni por reduzir 6 bytes, encontrando uma maneira mais curta 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

Experimente online!

Explicação:

• a pfunção "analisa" uma string ignorando os #grupos inicial e retornado (listas) de 2 caracteres.
• o (!)operador toma como entrada a cor e o formato de entrada e retorna uma função que assume como parâmetro o formato de saída e retorna a cor convertida. Descobriu-se que a versão pointfree era mais curta, mas comecei com a versão mais legível:

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

Experimente online!

Perl 5 -p , 33 32 27 bytes

Dê entrada na ordem: destino, original, número

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

Experimente online!

Para cada caractere na entrada, encontre o mesmo caractere com um número par de lugares para a frente e, a partir daí, prossiga com mais 10 caracteres e leve esse caractere como substituto. Se você não pode executar essas etapas, substitua por nada.

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

05AB1E , 10 bytes

2FI2ô™J}I‡

Experimente online!

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.

Isso funciona porque eu altero a entrada de:

AARRGGBB

Para:

AaRrGgBb

Portanto, cada valor é mapeado exclusivamente, para que eu possa usar o transliterado.

Os argumentos são invertidos.

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;}

Surpreendente -77 bytes graças a @ OlivierGrégoire .

Explicação:

Experimente online.

(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./

O argumento da esquerda é a cor. O argumento correto é uma matriz de caracteres em que a primeira linha é o formato de destino e a segunda linha é o formato original. Experimente online!

CJam, 14 bytes

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

Experimente Online!

Entrada é uma matriz na ordem inversa.

{
 `#\      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

Vermelho , 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]]

Experimente online!

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]]]

Experimente online!

Gelatina , 6 bytes

ẹЀQị⁵

Experimente online!

Programa completo.

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

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]);}

Experimente online!

Recebe o valor de entrada a, no formato in ie out, no formato in o. Retorna o valor emb

Fraude menor: armazenar o resultado em bvez de imprimir para salvar bytes. A pergunta não a desaprova.

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);}

Experimente online!

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);}}

Experimente online!

Cria um RGBAvalor na c[]matriz com base no formato ie depois imprime no 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)))))

Ungolfed

  (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)))))

Experimente online não tem suporte ao Clojure 1.8. Muito estranho!

Perl 6 , 55 51 46 bytes

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

Experimente online!

Leva uma lista (cor, original, destino) como entrada. Divide cada sequência de entrada em componentes, cria chaves de origem de mapeamento Hash para valores de cores, pesquisa valores de cores na ordem das chaves de destino e formata o resultado.