Complementary colors

Question

Given an input of a color in #rrggbb hex format, output its RGB complement in the same format.

The RGB complement R₂G₂B₂ of any color R₁G₁B₁ is defined as the color with R₂ value 255 - R₁, B₂ value 255 - B₁, and G₂ value 255 - G₁.

Hex digits may be either in uppercase (#FFAA20) or lowercase (#ffaa20). The case of the input and output need not be consistent (so you may take input in lowercase but output in uppercase, and vice versa).

Since this is code-golf, the shortest code in bytes wins.

Test cases (note that since giving your program/function its own output should result in the original input (it is involutory), the test cases should work in both directions):

In/Out   Out/In
----------------
#ffffff  #000000
#abcdef  #543210
#badcab  #452354
#133742  #ecc8bd
#a1b2c3  #5e4d3c
#7f7f80  #80807f

Answer 1

R, 62 bytes

f=function(a)sprintf('#%06x',(8^8-1)-strtoi(substr(a,2,7),16))

Answer 2

PowerShell, 48 bytes

param($a)"#{0:x6}"-f(16MB-1-("0x"+$a.Trim('#')))

Necessarily takes input via param($a) as a string, delimited with ' or ", since C:\Tools\Scripts\Golfing> .\complementary-colors #a1b2c3 on the PowerShell command line will treat #a1b2c3 as a comment and summarily ignore it.

Left-to-right, the "#{0:x6}"-f(...) formats our output calculations back into hexadecimal with a guaranteed 6 characters (to account for input #ffffff). Inside the parens, we subtract our input number from 0xffffff. We do this by leveraging the fact that PowerShell parses hexadecimal numbers in format 0xNNN, so we construct a proper-format hex number from our input number $a. (Note that concatenation plus .Trim() is shorter than .Replace() here by one byte.) We also leverage the MB unary operator via 16MB-1 to construct 16777215 instead of 0xffffff.

Answer 3

TeaScript, 24 bytes

"#"+S(8**8-1-xS1)t16))x6

Bugs in the interpreter aren't letting me get this shorter :(

Try it online

Answer 4

PHP, 37 bytes

printf('#%06x',8**8-1-hexdec($argn));

Try it online!

Or if you prefer to be more bit-wise (and byte-foolish) about it:

PHP, 38 bytes

printf('#%06x',~hexdec($argn)&8**8-1);

Try it online!

Answer 5

Thunno 2, 4 bytes

kfḲṆ

Try it online!

Thunno 2 j, 11 bytes

ḣ²Hɠ⁻_Ḥ2ṛ'#

Try it online!

Explanation

kfḲṆ  # Implicit input
kf    # Hexadecimal characters: "0123456789ABCDEF"
  Ḳ   # Bifurcate: duplicate and reverse
   Ṇ  # Transliterate: [0-9A-F] -> [F-A9-0]
      # Implicit output

ḣ²Hɠ⁻_Ḥ2ṛ'#  '# Implicit input
ḣ             # Remove the leading "#"
 ²            # Split into pairs
  H           # Convert each from hexadecimal
   ɠ⁻_        # Subtract each from 255
      Ḥ       # Convert each to hexadecimal
       2ṛ     # Pad with 0s to length 2
         '#  '# Push "#" to the stack
              # Implicit output of joined stack

Answer 6

Ruby, 31 bytes

->s{"#%6x"%(8**8-1-s[1..].hex)}

Attempt This Online!

Answer 7

05AB1E, 6 bytes

15Ýh‡

Try it online or verify all test cases.

Or with the more straight-forward approach (15 bytes):

ćs2ôH₅αh2jð0:J«

Try it online or verify all test cases.

Explanation:

15Ý         # Push a list in the range [0,15]
   h        # Convert each integer to a hexadecimal character
    Â       # Bifurcate this list; short for Duplicate & Reverse copy
     ‡      # Transliterate the (implicit) input-string using these two lists
            # (after which the result is output implicitly)

ć           # Extract head of the (implicit) input-string; push remainder-string and
            # first item separately to the stack
s           # Swap so the remainder-string is at the top
 2ô         # Split it into pairs
        H   # Convert each string in the triplet from hexadecimal to an integer
         ₅α # Take the absolute difference with 255
        h   # Convert it back to hexadecimal
   2jð0:    # Pad leading 0s to single hexadecimal characters if necessary:
   2j       #  Pad potential leading spaces to make all strings of length 2
     ð0:    #  Then replace all spaces with 0s
 J          # Join the triplet of pairs back to a string
«           # Append it back to the "#" that's on the stack
            # (after which the result is output implicitly)