[Question]
  [
Inspired by [this](https://codegolf.stackexchange.com/q/63056/43319) wonderful (based on the number of views and votes) challenge, which, in my humble opinion, has way too few answers.
Given (by any means) a list of strings, return (by any means) a set of letters that, when removed from the given strings, leaves the total length of (what remains of) the strings as small as possible, while keeping each string unique and at least one character long.
**Examples:**
Given "Day" and "day"; return "ay", because the given strings will be "D" and "d" when the characters "ay" are removed.
Given "Hello World!", "Hello world.", and "Hello world"; return "Helo Wrd" gives because the strings will be "!", "w.", and "w" when the characters "Helo Wrd" (with a space) are removed.
Given "century", "decade", "year", "month", "week", "day", "hour", "minute", and "second"; return "centurdowi" because the given words will be "y", "a", "ya", "mh", "k", "ay", "h", "m", "s" when the characters "centurdowi" are removed.
The order and format of the returned set is not important.
  
[Answer]
## Haskell, ~~138~~ 130 bytes
```
import Data.List
c=concat
f i=snd$minimum[(length$c q,s)|s<-subsequences$nub$c i,q<-[map(filter(`notElem`s))i],nub q==q,all(>"")q]
```
Usage example: `f ["century", "decade", "year", "month", "week", "day", "hour", "minute", "second"]` -> `"centurdoki"`.
This is a brute force approach.
```
     s<-subsequences$nub$c i  -- concatenate input i to a single string, remove
                              -- duplicates and make a list of all subsequences
       q<-[map(filter(...))i] -- remove chars appearing in subsequence s from all
                              -- input words, call result q
          nub q==q            -- keep those s where q has no duplicates (i.e. each
                              -- resulting string is unique) and
            all(>"")q         -- contains no empty strings
  (length$c q,s)              -- make pairs from all kept s, where the first element
                              -- is the combines length of all strings in q,
                              -- second element is s itself
snd$minimum                   -- find minimum of those pairs and discard length
```
Edit: @Seeq helped me saving 8 bytes. Thanks!
[Answer]
# [JavaScript (V8)](https://v8.dev/), 288 bytes
```
s=>(l=[...new Set(s.join``)],g=[],[...Array(2**l[L="length"])].map((x,i)=>l.filter((c,j)=>(i&2**j))).filter(x=>new Set(h=s.map(m=>[...m].filter(n=>!x.includes(n)).join``)).size==s[L]&&h.every(n=>n[L])&&g.push(h.reduce((a,b)=>a+b[L],0))).map(x=>[x,g.shift()]).sort((a,b)=>a[1]-b[1])[0][0])
```
[Try it online!](https://tio.run/##XVA9b8MgEN37KxIPFqQEpZ26YKlShw7ZOnRASCH22cbF2AKc2P3zLsR1K0VC3B3v455o5EW63Kre7y8vc8lmxzKkGaeUGrhuPsAjR5tOmdMJC1IxLkjEXq2VE3re7TQ/skSDqXydCCxoK3uERqIwyzQtlfZgEcpJE2ak0iBoMMYrMLJsXVIzd9O2LIv@rVg5hmXbkSqT66EAh0xQ/8bB1KlvYMzxo0jTmsIF7BT5JjzgNK1oP7ga1dRCMeSAkCTnEEM@ngNODjFH3BhC8JFU1NWq9AiLYNtZ/8fmT2J/DhfmBxEOnnurjEcl4smbnBKySYpQBMYP/8A7aN1tPjuri21kLPM1zvRuvlPmYPxgF1vIZQGxm0DaWNvOhF8OzRXga90cSt0NC67M4G8KB3lnbt7zDw "JavaScript (V8) – Try It Online")
Explanation:
```
s=>                                     // Arrow function with argument s
(l=[...new Set(s.join``)],              // Create a set l containing every character in s
                                          // Sets automatically remove duplicates
                                          // This converts the set back to an array, since arrays are easier to work with
g=[],                                   // Create an empty array g
[...Array(2**l[L="length"])]            // Create an array with length 2 ** number_of_inputs
.map((x,i)=>l.filter((c,j)=>(i&2**j)))  // Populate the array with each combination of characters in l
.filter(x=>new Set(h=s.map(m=>          // Filter the array (with each combination being x)
  [...m].filter(n=>!x.includes(n))        // For each inputted string, after removing the characters in x
  .join``)).size==s[L]&&                  // Check if the number of unique strings is equal to the number of inputs
  h.every(n=>n[L])&&                      // Ensure every string is at least one character
  g.push(h.reduce((a,b)=>a+b[L],0)))      // Push the total length to g
.map(x=>[x,g.shift()])                  // For each item x in the array, put it in an array with its corresponding item in g
.sort((a,b)=>a[1]-b[1])[0][0])          // Sort the array to find the shortest valid result, and output it
```
[Answer]
# Pyth, 34
Takes input in the format `["century", "decade", "year", "month", "week", "day", "hour", "minute", "second"]`. Golfing tips are appreciated, as always.
```
hh.mlsebfqlQl{eTf!}keTm,dm-kdQy{sQ
```
[Answer]
# Pyth, 24 bytes
```
hols-RNQf<}kJ-RTQ{IJy{sQ
```
[Try it online.](http://pyth.herokuapp.com/?code=hols-RNQf%3C%7DkJ-RTQ%7BIJy%7BsQ&input=%5B%22Hello+World!%22%2C+%22Hello+world.%22%2C+%22Hello+world%22%5D&debug=0) [Test suite.](http://pyth.herokuapp.com/?code=hols-RNQf%3C%7DkJ-RTQ%7BIJy%7BsQ&input=%5B%22Hello+World!%22%2C+%22Hello+world.%22%2C+%22Hello+world%22%5D&test_suite=1&test_suite_input=%5B%22Day%22%2C+%22day%22%5D%0A%5B%22Hello+World!%22%2C+%22Hello+world.%22%2C+%22Hello+world%22%5D%0A%5B%22century%22%2C+%22decade%22%2C+%22year%22%2C+%22month%22%2C+%22week%22%2C+%22day%22%2C+%22hour%22%2C+%22minute%22%2C+%22second%22%5D&debug=0)
Note that the last test case will take a little while to run.
Takes input in array form, like `["Day", "day"]`.
Another interesting one I found and [isaacg](https://codegolf.stackexchange.com/users/20080/isaacg) [improved](https://codegolf.stackexchange.com/questions/67261/remove-letters-while-keeping-strings-unique/67360?noredirect=1#comment163248_67360) (also 24 bytes):
```
-J{sQhlDsM.A#f{ITm-RdQyJ
```
]