[Question]
  [
Simple challenge inspired by the popularity of my previous [print invisible text](https://codegolf.stackexchange.com/questions/122703) and [print real invisible text](https://codegolf.stackexchange.com/questions/123447) challenges, and the [same length different string](https://codegolf.stackexchange.com/questions/123539) challenge.
Given a string consisting of only printable characters (`0x20 to 0x7E`), print every printable character not present in the string.
## Input
A string, or array of characters, consisting of only printable ASCII characters
## Output
Every printable ASCII character not present in the input string, in any order.
## Testcases
```
Input:  "Hello, World!"
Output: ""#$%&'()*+-./0123456789:;<=>?@ABCDEFGIJKLMNOPQRSTUVXYZ[\]^_`abcfghijkmnpqstuvwxyz{|}~"
========
Input:  "Hi!"
Output: " "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghjklmnopqrstuvwxyz{|}~"
========
Input:  ""
Output: " !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
========
Input:  " !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
Output: ""
```
## Scoring
This is code-golf so fewest bytes **in each language** wins
  
[Answer]
# [GS2](https://github.com/nooodl/gs2), 2 bytes
```
ç7
```
[Try it online!](https://tio.run/nexus/gs2#@394ufn//x6pOTn5Ogrh@UU5KYoA "GS2 – TIO Nexus")
### How it works
```
    (implicit) Push the sting of all characters in STDIN on the stack.
ç   Push the string of all printable ASCII characters.
 7  Perform symmetric set difference.
    (implicit) Print the result to STDOUT.
```
[Answer]
# [Python 3.5](https://docs.python.org/3/), 39 bytes
```
lambda n:{*map(chr,range(32,127))}-{*n}
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHPqlorN7FAIzmjSKcoMS89VcPYSMfQyFxTs1a3Wiuv9n9BUWZeiUaahpJHak5Ovo5CeH5RToqikqbmfwA "Python 3 – Try It Online")  
Turns input into a set, and remove it from the set containing all ascii characters
[Answer]
# [Perl 6](https://perl6.org), 29 bytes
```
{[~] keys (' '..'~')∖.comb}
```
Note that the result is random because [Set](https://docs.perl6.org/language/setbagmix)s are unordered.
[Test it](https://tio.run/nexus/perl6#tc9LWtswEAfwvU4xGIrtYMu8W2KcUt60pVCebfNoHVsEJ7YlJBkIabLmBD0AnIPLcAFWrFPHhI/syAbt5pu/5jeTCALn89izUdSEcY/6BJxuq9gpQ4M0BWgqqBirHVW/v/6HPRpV2900uCSJkOBAGMREaDquccI0q1JZNItOuWDpmFNJuTatY58QFrks30IA@2kC0ohSLuTg4e5Gebi7tSwskqqQXJs0cuaUjtooSVc6SOfbiIVuDBMZZqMTyvuuWQCtFMQskUaJXDLiSeLr0BPS1UqciCTsLZcdk8XstOUHbg2eer0yEP0iOwoLyiWu0yA24Hmi8fQXM8JD1O5u9Yo8gLJJwpAacEx56I8oaCeRWUNRRsfejauanpswsTU5NT0zOzf//sNC3l50Ch@XPi2vrK6tb2x9/vJ1@9vO7ve9/YPDox8/fxVL5crvP27VO6mdBvVGFLMzIZPzi8vmVetvu6Mgp//QywLBIAsvrjE0fDwo@yS1640wiik746/pg/TIcPbma3gwtP625MBtHeUxpqbneqfkPw "Perl 6 – TIO Nexus")
## Expanded:
```
{
  [~]        # reduce using string concatenation
             # (shorter than ｢join '',｣)
  keys       # get the keys from the Set object resulting from the following
  (' '..'~') # Range of printable characters
  ∖          # Set minus (this is not \ )
  .comb      # split the input into individual characters
}
```
There is also an ASCII version of `∖` `(-)`, but it would require a space before it so that it isn't parsed as a subroutine call.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 14 bytes
```
Ho#_dÃf@bX ¥J
```
[Try it online!](https://tio.run/nexus/japt#@@@Rr1wfn3K4Oc0hKULh0FKv//@VPFJzcvJ1FMLzi3JSFJUA "Japt – TIO Nexus")
Saved 4 bytes thanks to Shaggy and obarakon
[Answer]
## Haskell, 32 bytes
```
f x=[y|y<-[' '..'~'],all(/=y)x] 
```
[Try it online!](https://tio.run/nexus/haskell#@5@mUGEbXVlTaaMbra6grqenXqceq5OYk6Ohb1upWRGr8D83MTNPwVahoLQkuKTIJ09BRSFNQckjU1HpPwA "Haskell – TIO Nexus")
Boring library function for set difference: 
### Haskell, 31 bytes
```
import Data.List
([' '..'~']\\)
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 5 bytes
```
6Y2X~
```
[Try it online!](https://tio.run/nexus/matl#@28WaRRR9/@/ukdqTk6@OgA "MATL – TIO Nexus")
Thanks to Luis Mendo for [golfing 8 bytes off!](http://chat.stackexchange.com/transcript/message/37783520#37783520)
Explanation:
```
   X~   % The symmetric set difference
6Y2     % Between all printable ASCII
        % And the input string (implicit)
        % Implicitly display
```
*Symmetric set difference* will give every element that is present in exactly one of the two input sets. (but not both) This will always give the right answer, since the input set will always be a subset of the second set (all printable ASCII).
Original version:
```
32:126tGom~)c
```
Explanation:
```
32:126          % Push the range 32-126
      t         % Duplicate it on the stack
       G        % Push the input
        o       % Convert it to character points
         m      % Is member (0 for each char that isn't in input, 1 for each char that is)
          ~     % Logical NOT
           )    % Take the truthy elements of this array from the previous array (All Printable ASCII)
            c   % Display as a string
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 5 bytes
```
ẹ;Ṭ↔x
```
[Try it online!](https://tio.run/nexus/brachylog2#@/9w107rhzvXPGqbUvH/v5JHak5Ovo5CeH5RToqi0v8oAA "Brachylog – TIO Nexus")
### Explanation
```
ẹ          Split the input string into a list of chars
 ;Ṭ↔x      Exterminate the chars from the string Ṭ of printable ASCII chars
```
[Answer]
## Perl, 39 bytes
```
s!.*!"pack(c95,32..126)=~y/$_//dr"!ee
```
Run with `perl -pe`.
[Answer]
# JavaScript (ES6), 74 bytes
I'm sure there's a shorter way to do this!
```
s=>[...Array(95)].map((_,y)=>s.includes(c=String.fromCharCode(y+32))?"":c)
```
---
## Try it
```
let f=
s=>[...Array(95)].map((_,y)=>s.includes(c=String.fromCharCode(y+32))?"":c)
oninput=_=>o.innerText=f(i.value).join``
o.innerText=f(i.value="Hello, World!").join``
```
```
<input id=i><pre id=o>
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~47 43~~ 40 bytes
```
printf %x {32..126}|xxd -r -p|tr -d "$1"
```
[Try it online!](https://tio.run/nexus/bash#@19QlJlXkqagWqFQbWykp2doZFZbU1GRoqBbpKBbUFMCJFMUlFQMlf7//w8A "Bash – TIO Nexus")
Generates hexa range, inverts hex dump to char an removes characters present in first parameter.
[Answer]
# Octave, ~~22~~ 20 bytes
Thanks to @Luis Mendo saved 2 bytes.
```
@(s)setxor(32:'~',s)
```
[Try it online!](https://tio.run/nexus/octave#@@@gUaxZnFpSkV@kYWxkpV6nrlOs@T8xr1hDySM1JydfRyE8vygnRVFJ8z8A "Octave – TIO Nexus")
Other answer:
```
@(s)setdiff(' ':'~',s)
```
[Try it online!](https://tio.run/nexus/octave#@@@gUaxZnFqSkpmWpqGuoG6lXqeuU6z5PzGvWEPJIzUnJ19HITy/KCdFUUnzPwA "Octave – TIO Nexus")
[Answer]
# APL, 13 bytes
```
⍞~⍨⎕UCS31+⍳95
```
Straightforward:
```
       31+⍳95  ⍝ A vector 32 .. 126
   ⎕UCS        ⍝ as characters
 ~⍨            ⍝ without
⍞              ⍝ those read from character input.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
```
žQsм
```
[Try it online!](https://tio.run/##yy9OTMpM/f//6L7A4gt7/v/3SM3JyddRCM8vyklRBAA "05AB1E – Try It Online")
```
žQsм  # full program
   м  # remove...
  s   # implicit input...
   м  # from...
žQ    # all ASCII characters
      # implicit output
```
[Answer]
# PHP, 42 Bytes
Input as array
Output as string
```
<?=join(array_diff(range(" ","~"),$_GET));
```
[Try it online!](https://tio.run/nexus/php#s7EvyCjgUol3dw2xjVbyUNJRSgXiHCjOB2IQVADicCi/CCqXAsSKSrHWXPZ2/23sbbPyM/M0EouKEivjUzLT0jSKEvPSUzXAOuuUNHXANmhqWv//DwA "PHP – TIO Nexus")
# PHP, 53 Bytes
Input as string
Output as string
```
<?=join(array_diff(range(" ","~"),str_split($argn)));
```
replace `<?=join` with `print_r` for an output as array
[Try it online!](https://tio.run/nexus/php#s7EvyCjgUkksSs@zVfJIzcnJ11EIzy/KSVFUsuayt/tvY2@blZ@Zp5FYVJRYGZ@SmZamUZSYl56qoaSgpKNUp6SpU1xSFF9ckJNZogE2RVNT0/r/fwA "PHP – TIO Nexus")
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 8 bytes
```
'␡,32>q^
```
Where `␡` is a literal delete character.
[Try it online!](https://tio.run/nexus/cjam#@69er2NsZFcY9/@/R2pOTr6OQnh@UU6KIgA "CJam – TIO Nexus")
```
'␡,       e# The range of all characters up to ~.
   32>    e# Slice it to be the range of all characters from space to ~.
      q^  e# Symmetric set difference with the input.
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/tio-transpilers), 120 bytes
```
+[+[>+<+<]>]>-[[>>]+[<<]>>-],[<+++++[>------<-]>-[>[>>]+[<<]>-]>[>>]<[-]<[-<<]>,]++++++++[->++++<]>[>[-<.>]<[->>+<<]>>+]
```
[Try it online!](https://tio.run/nexus/brainfuck#RY0xCoBADAS/onUuviBs7Q8slnTaHRz4fzizIjgQwiZDMo1GWFgkEk4CaYxK8GwME4S/hEvB71RWCLpKk5b2QYdaSKnd9mqoV7ptOed@9T7acoy7n@sD "brainfuck – TIO Nexus")
Wrapped:
```
+[+[>+<+<]>]>-[[>>]+[<<]>>-],[<+++++[>--
----<-]>-[>[>>]+[<<]>-]>[>>]<[-]<[-<<]>,
]++++++++[->++++<]>[>[-<.>]<[->>+<<]>>+]
```
Explained:
```
+[+[>+<+<]>]>-         initialize what we will now consider cell 0 to 95
[[>>]+[<<]>>-]         initialize cells 2 4 etc 95*2 to 1; end on cell 0 at 0
,[                     main input loop (for each char of input)
  <+++++[>------<-]>-  subtract 31 from the input
  [>[>>]+[<<]>-]       lay a trail of (input minus 31) ones in the empty spaces
  >[>>]<[-]<[-<<]>     use the trail to clear the appropriate "print" flag
,]                     keep reading input until it ends
++++++++[->++++<]>     initialize the cell directly before flag 1 to 32
[                      we'll let the accumulator overflow; no harm done
  >[-<.>]              print the accumulator if the flag is still set
  <[->>+<<]>>+         shift over the accumulator and increment it
]
```
[Answer]
# [Ohm](https://github.com/MiningPotatoes/Ohm), 3 bytes
```
α@─
```
[Try it online!](https://tio.run/nexus/ohm#@39uo8OjKQ3//0ere6jrqKcCcQ4U5wOxAhCXQ9lFUPEU9dj/AA "Ohm – TIO Nexus")
Note: you can also enter your input as a string ([example](https://tio.run/nexus/ohm#@39uo8OjKQ3//3uk5uTkK4TnF@WkKP4HAA "Ohm – TIO Nexus")), but it fails for the empty input case.
[Answer]
# Ruby, 23 18 17 bytes
```
->s{[*' '..?~]-s}
```
Uses a lambda function as per @sethrin's comments.
Previous versions:
```
[*' '..?~]-s.chars
(' '..'~').to_a-s.chars
```
[Answer]
## [Julia](https://julialang.org/), 21 bytes
```
s->setdiff(' ':'~',s)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
*Really, 8 bytes? Please, tell me I missed something!*
```
32r126Ọḟ
```
**[Try it online!](https://tio.run/nexus/jelly#@29sVGRoZPZwd8/DHfP///@vFJKRqlBYmpmcrZBUlF@ep5CWX6GQVZpbkJqikF@WWqRQApTPSayqVEjJTy/WUwIA "Jelly – TIO Nexus")**
### How?
```
32r126Ọḟ - Main link: list of characters s
32r126   - inclusive range from 32 to 126 = [32,33,...,125,126]
      Ọ  - cast ordinals to characters = list of printable characters
       ḟ - filter discard if in s
```
---
Alternatively
```
“ ~‘r/Ọḟ - Main link
“ ~‘     - code-page indexes = [32,126]
    r/   - reduce by inclusive range = [32,33,...,125,126]
      Ọ  - cast from ordinals to characters = list of printable characters
       ḟ - filter discard if in s
```
---
Since this challenge a new atom which yields all printable ASCII characters, `ØṖ`, has been introduced making the following work for 3 bytes:
```
ØṖḟ
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 5 bytes
```
PADCa
```
Removes all chacracters in the input from a predefined variable.
[Try it online!](https://tio.run/##K8gs@P8/wNHFOfH///8eqTk5@YoA "Pip – Try It Online")
# [Pip](https://github.com/dloscutoff/pip), 9 bytes
```
PARM(X^a)
```
Converts the characters of the input to regex, and removes the characters from the printable ASCII builtin.
[Try it online!](https://tio.run/##K8gs@P8/wDHIVyMiLlHz////Hqk5OfmKAA "Pip – Try It Online")
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~14~~ 10 bytes
```
⍞~⍨' '…'~'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qKM97f@j3nl1j3pXqCuoP2pYpl6nDhL9rwAEaVzqjk7OLq7qAA "APL (Dyalog Extended) – Try It Online")
-4 bytes from Adám!(inclusive range)
## Explanation
```
   ' '…'~'     range of chars in visible ASCII range
  ⍨            flip the arguments of the function on the left
⍞~             Get all characters not in input 
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 7 6 bytes
```
`.-srd\`
-srd\
```
`.-` `-` Subtract the second string from the first:
1. `srd\` Create a range from space char to the delete char
2. *implicitly read input*
[Try it online!](https://tio.run/##K6gsyfj/X0@3uCglpv7/fyWP1JycfIXw/KKcFEUlAA "Pyth – Try It Online")
[Answer]
# MUMPS, 35 bytes
```
r r,! f i=32:1:126 w:r'[$c(i) $c(i)
```
**Explanation**
* Assign input to `r` and write a newline (`!`)
* Loop from 32 to 126 and if r doesn't contain (`'[`) the character representation of the ASCII value (`$char()`, can be shortened to `$c()`), write the that character representation.
* You can attach conditionals to commands with a colon. So `w:1>0 "True"` is the same as `if 1>0 write "True"`
[Try the code here](https://tio.run/##yy3NLSj@/18BCMqLMktSFZQ8UnNy8nUUwvOLclIUlf7/BwA)
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), ~~39~~ 32 bytes
```
$a=$args
' '..'~'|?{$_-cnotin$a}
```
Added splatting and case sensitivity
[Try it online!](https://tio.run/##DczNCkBAEADg@z7F0GQveANx9ADu2jTslnY0SPLz6sP961v4IFk9zXMxsJDiCBVciq5CJ9NqLNiytK@96wv7Yoi8hYju0ccYDPG3aRug8ySUg@cDnBCcvCd1arL/akJU/QA "PowerShell Core – Try It Online")
Inspired by `colsw`'s answer
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 3 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
kcḍ
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728JKM0Ly_faMGCpaUlaboWS7OTH-7oXVKclFwMFVmw1iM1JydfRyE8vygnRREiCAA)
#### Explanation
```
kcḍ  # Implicit input
  ḍ  # Symmetric set difference with...
kc   # ...all printable ASCII characters
     # Implicit output
```
[Answer]
# [Factor](https://factorcode.org/), ~~26~~ 25 bytes
-1 byte by using `∖` from `math.unicode` instead of `diff`, as suggested by @chunes
```
[ 32 126 [a,b] swap ∖ ]
```
[Try it online!](https://tio.run/##JYxZVsIwGIXfu4qfOIFSlKKo4DwBDjggorZVQxtoIE1K2oKK@OwK3IRL8M2luJFa4eUO3z3ntrAVCBnVa5VqqQBdIjlh4JNeSLhFfHBx4GRCTi1hk0mRmLfjgQogfcygqCiM8hggBB1B@ZgmQVX/TyAV6ZDTIKvlQcfppgn@AHvw@/EJZuTGSQf084Vi@Ubgh1KKkNvgScoDMIFgy4mGCgAqE8ZEGhpCMjuBxoROfCyQMNDU9MzsXDI1v5BWM4tLWS23vJJfXVsvFDc2t7Z3dvf2Dw6PSuXK8cnpWfX84vKqdl2/adze3euGYT48PuGmZZNW26GdLnO58HrSD8L@4Pnldfg2ekfK6A8 "Factor – Try It Online")
TIO uses an old build of Factor; on the latest version, `[a,b]` from `math.ranges` has moved to `[a..b]` from `ranges`.
### Explanation
| Code | Explanation | Stack |
| --- | --- | --- |
| `[ ... ]` | Quotation (anonymous function) | `"Hello!"` |
| `32 126 [a,b]` | Inclusive range from 32 to 126 | `"Hello!" T{ range f 32 95 1 }` |
| `swap` | Swap so range is below input | `T{ range f 32 95 1 } "Hello!"` |
| `∖` | Set difference | `" \"#$%&'()*+,-./012..."` |
This works because in Factor, a string is basically a list of codepoints, and all sequences are `set`s.
[Answer]
# [R](https://www.r-project.org/), 50 bytes
```
function(s)intToUtf8(setdiff(32:126,utf8ToInt(s)))
```
returns an anonymous function. Converts the input string to integers, computes the set difference between the printable range and the input values, and then converts them back to a string and returns it.
[Try it online!](https://tio.run/nexus/r#S7P9n1aal1ySmZ@nUayZmVcSkh9akmahUZxakpKZlqZhbGRlaGSmUwoUC8n3zCsBKtLU/J@moe6RmpOTr6MQnl@Uk6KorvkfAA "R – TIO Nexus")
[Answer]
# PHP, 53 bytes
```
for($k=31;$k++<126;)~strstr($argn,$k)?:print chr($k);
# or
for($k=31;$k++<126;)echo~strstr($argn,$k)?"":chr($k);
```
Run as pipe with `-r`.
[Answer]
# C#, ~~74~~ 71 bytes
```
using System.Linq;s=>new int[95].Select((n,i)=>(char)(i+32)).Except(s);
```
Old version with creating a range for 74 bytes:
```
using System.Linq;s=>Enumerable.Range(32,95).Select(n=>(char)n).Except(s);
```
]