Leggi il colore a modo mio

16

Sistemi diversi hanno modi diversi di descrivere i colori, anche se tutti parlano nello spazio RGBA. Uno sviluppatore front-end che abbia familiarità con i CSS potrebbe preferire #RRGGBBAA. Ma gli sviluppatori Android potrebbero preferire #AARRGGBB. Quando si gestisce il formato di file AAS, #AABBGGRRè necessario. È troppo confuso. Forse abbiamo bisogno di un programma in grado di convertire tra diversi formati di colore.

Ingresso:

L'ingresso contiene 3 parti:

  • Il colore da trasformare (ad es. #1459AC0F), Una stringa che inizia con un segno acuto #seguito da 8 cifre esadecimali.
  • Il formato del colore dato (es. #RRGGBBAA), Una stringa che inizia con #seguita da 8 lettere che rientrano in 4 gruppi diversi e ogni gruppo è uno di RR/ GG/ BB/ AA.
  • Il formato in cui convertire.

Produzione:

  • Stampa il colore in formato convertito

Casi test:

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

Input / output non fanno distinzione tra maiuscole e minuscole. È possibile immettere / emettere in qualsiasi modo accettabile.

Regole:

Questo è il codice golf, i codici più corti (in byte) di ogni lingua vincente

code-golf  string  color 
— tsh
fonte
AARRGGBBè oggettivamente il miglior formato colore. Se qualcosa si aspetta 24 bit RRGGBBe invece gli dai 32 bit AARRGGBB, può semplicemente ignorare il byte superiore e continuare a funzionare.
— 12
2
Il colore DEADBEEF sembra un po 'Salmon-y.
— Magic Octopus Urn
1
Sono stato un sviluppatore web front-end per anni e non avevo mai sentito parlare di #RRGGBBAA fino ad oggi, vorrei che più browser lo supportassero.
— DasBeasto,
@ 12Me21 E la domanda successiva è quale endianness sia migliore.
— TSH

Risposte:

10

APL (Dyalog Unicode) , 6 byte SBCS

Programma completo. Richiede STDIN per Originale, quindi Destinazione, quindi Colore. Stampa il risultato su STDOUT.

⍞[⍞⍋⍞]

Provalo online!

  ⍞ richiedere l'originale

 ⍞⍋ richiedere Target e trovare gli indici in Original che trasformerebbero Original in Target

⍞[... ] richiede il colore e usa gli indici sopra ottenuti per riordinare il colore

— Adamo
fonte
8

JavaScript (ES6), 53 52 byte

Salvato 1 byte grazie a @tsh

Prende come ingresso 3 parametri distinti: (Color, From, To).

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

Provalo online!

— Arnauld
fonte
(C,F,T)=>T.replace(/\w/g,(x,i)=>C[F.search(x)-~i%2])salva un byte
— tsh
@tsh Nice one. ^^
— Arnauld,
5

Stax , 8 byte

ç▼☺↔kàÅJ

Esegui ed esegui il debug

Questo programma accetta input in questo formato.

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

Ecco la versione non pacchetto commentata non pacchetto dello stesso programma.

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

Esegui questo

— ricorsivo
fonte
4

Retina 0.8.2 , 33 byte

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

Provalo online! Il link include casi di test. Spiegazione:

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

Per ogni coppia di caratteri identici, cerca un'altra copia di quella coppia, quindi prima il nono e l'ottavo carattere e sostituisci la coppia con quei caratteri. Questo è possibile solo per le coppie di caratteri nel formato di destinazione e li sostituisce con il risultato desiderato.

.*#
#

Elimina il colore e il formato sorgente.

— Neil
fonte
3

Haskell , 108 104 100 94 87 byte

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

Provalo online!

Vecchia versione

Grazie a Laikoni per accorciare 6 byte trovando un modo più breve di usare 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

Provalo online!

Spiegazione:

  • il p funzione "analizza" una stringa ignorando il comando iniziale# gruppi (liste) iniziali e di ritorno di 2 caratteri.
  • l' (!)operatore prende come input il colore e il formato di input e restituisce una funzione che accetta come parametro il formato di output e restituisce il colore convertito. Si è scoperto che la versione senza punti era più corta, ma ho iniziato con la versione più leggibile:

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

Provalo online!

— Cristian Lupascu
fonte
3

Perl 5 -p , 33 32 27 byte

Fornisci input nell'ordine: target, originale, numero

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

Provalo online!

Per ogni personaggio nell'input trova lo stesso carattere un numero pari di posti in avanti, quindi da lì vai in avanti di altri 10 caratteri e prendi quel personaggio in sostituzione. Se non riesci a fare questi passaggi, sostituisci con niente.

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

05AB1E , 10 byte

2FI2ô™J}I‡

Provalo 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.

Questo funziona perché cambio l'input da:

AARRGGBB

Per:

AaRrGgBb

Quindi ogni valore è mappato in modo univoco, quindi posso usare la traslitterazione.

Gli argomenti sono invertiti.

— Urna di polpo magico
fonte
2

Java 10, 179 105 102 byte

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

Whipping -77 byte grazie a @ OlivierGrégoire .

Spiegazione:

Provalo 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
— Kevin Cruijssen
fonte
1
105 byte Crea la stringa dalla destinazione trovando l'elemento target nel formato di origine.
— Olivier Grégoire,
@ OlivierGrégoire Sapevo che sarebbe stato possibile senza quella fastidiosa mappa. Grazie mille, -74 byte proprio lì!
— Kevin Cruijssen,
102 byte passando a Java 10, che ora è supportato su TIO.
— Olivier Grégoire,
2

J , 5 byte

/:i./

L'argomento a sinistra è il colore. L'argomento giusto è una matrice di caratteri in cui la prima riga è il formato di destinazione e la seconda riga è il formato originale. Provalo online!

— FrownyFrog
fonte
1

CJam, 14 byte

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

Provalo online!

L'input è un array nell'ordine 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
}
— geokavel
fonte
0

Python 2, 62 byte

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

SmileBASIC, 144 byte

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
— 12Me21
fonte
0

C (clang) , 89 byte

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

Provalo online!

Accetta il valore di input in a, in formato in ie out in formato o. Restituisce il valore inb

Trucchi minori: memorizzazione del risultato binvece della stampa per salvare byte. La domanda non lo impedisce.

C (clang) , 100 byte

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

Provalo online!

C (gcc) , 181 byte

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

Provalo online!

Crea un RGBAvalore nella c[]matrice in base al formato i, quindi stampa nel oformato

— GPS
fonte
Suggerisci char*a,b[10],*i,*o;f(x)invece di char *a,b[10],*i,*o;f(x,y)e x+=2)bcopy(a+(long)index(i,o[x])-i,b+x,2);invece dib[x++]=a[y=index(i,o[x])-i],b[x++]=a[y+1]);
— ceilingcat il
0

Clojure 1.8, 156 byte

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

Provalo online non ha il supporto Clojure 1.8. Molto strano!

— Giosuè
fonte
0

Perl 6 , 55 51 46 byte

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

Provalo online!

Accetta un elenco (colore, originale, target) come input. Suddivide ogni stringa di input in componenti, crea un hash mapping delle chiavi di origine in valori di colore, cerca i valori di colore nell'ordine delle chiavi di destinazione, quindi formatta il risultato.

— nwellnhof
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.