Sfida semplice ispirata dalla popolarità del mio precedente testo invisibile di stampa e stampa vere e proprie sfide di testo invisibile e la stessa sfida di stringa diversa lunghezza .

Data una stringa composta solo da caratteri stampabili ( 0x20 to 0x7E), stampa tutti i caratteri stampabili non presenti nella stringa.

Ingresso

Una stringa o matrice di caratteri, composta solo da caratteri ASCII stampabili

Produzione

Ogni carattere ASCII stampabile non presente nella stringa di input, in qualsiasi ordine.

Casi test

Input:  "Hello, World!"
Output: ""#$%&'()*+-./0123456789:;<=>?@ABCDEFGIJKLMNOPQRSTUVXYZ[\]^_`abcfghijkmnpqstuvwxyz{|}~"
========
Input:  "Hi!"
Output: " "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghjklmnopqrstuvwxyz{|}~"
========
Input:  ""
Output: " !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
========
Input:  " !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
Output: ""

punteggio

Si tratta di code-golf quindi vince il minor numero di byte in ogni lingua

GS2 , 2 byte

ç7

Provalo online!

Come funziona

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

Perl 6 , 29 byte

{[~] keys (' '..'~')∖.comb}

Si noti che il risultato è casuale perché i Set non sono ordinati.

Provalo

Allargato:

{
  [~]        # 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
}

Esiste anche una versione ASCII di ∖ (-), ma richiederebbe uno spazio prima che non venga analizzato come una chiamata di subroutine.

Python 3.5 , 39 byte

lambda n:{*map(chr,range(32,127))}-{*n}

Provalo online!
Trasforma l'input in un set e rimuoverlo dal set contenente tutti i caratteri ASCII

Japt , 14 byte

Ho#_dÃf@bX ¥J

Provalo online!

Salvato 4 byte grazie a Shaggy e obarakon

Haskell, 32 byte

f x=[y|y<-[' '..'~'],all(/=y)x] 

Provalo online!

Funzione di libreria noiosa per la differenza impostata:

Haskell, 31 byte

import Data.List
([' '..'~']\\)

MATL , 5 byte

6Y2X~

Provalo online!

Grazie a Luis Mendo per il golf a 8 byte di sconto!

Spiegazione:

   X~   % The symmetric set difference
6Y2     % Between all printable ASCII
        % And the input string (implicit)
        % Implicitly display

La differenza del set simmetrico fornirà tutti gli elementi presenti esattamente in uno dei due set di input. (ma non entrambi) Questo darà sempre la risposta giusta, poiché il set di input sarà sempre un sottoinsieme del secondo set (tutto ASCII stampabile).

Versione originale:

32:126tGom~)c

Spiegazione:

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

Brachylog , 5 byte

ẹ;Ṭ↔x

Provalo online!

Spiegazione

ẹ          Split the input string into a list of chars
 ;Ṭ↔x      Exterminate the chars from the string Ṭ of printable ASCII chars

JavaScript (ES6), 74 byte

Sono sicuro che c'è un modo più breve per farlo!

s=>[...Array(95)].map((_,y)=>s.includes(c=String.fromCharCode(y+32))?"":c)

Provalo

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>

bash ,47 43 40 byte

printf %x {32..126}|xxd -r -p|tr -d "$1"

Provalo online!

Genera intervallo hexa, inverte il dump esadecimale in carattere e rimuove i caratteri presenti nel primo parametro.

Ottava, 22 20 byte

Grazie a @Luis Mendo risparmiato 2 byte.

@(s)setxor(32:'~',s)

Provalo online!

Altra risposta:

@(s)setdiff(' ':'~',s)

Provalo online!

PHP, 42 byte

Input come array

Uscita come stringa

<?=join(array_diff(range(" ","~"),$_GET));

Provalo online!

PHP, 53 byte

Inserisci come stringa

Uscita come stringa

<?=join(array_diff(range(" ","~"),str_split($argn)));

sostituire <?=joincon print_rper un output come array

Provalo online!

CJam , 8 byte

'␡,32>q^

Dov'è ␡un carattere di eliminazione letterale.

Provalo online!

'␡,       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.

Perl, 39 byte

s!.*!"pack(c95,32..126)=~y/$_//dr"!ee

Corri con perl -pe.

Brainfuck , 120 byte

+[+[>+<+<]>]>-[[>>]+[<<]>>-],[<+++++[>------<-]>-[>[>>]+[<<]>-]>[>>]<[-]<[-<<]>,]++++++++[->++++<]>[>[-<.>]<[->>+<<]>>+]

Provalo online!

avvolto:

+[+[>+<+<]>]>-[[>>]+[<<]>>-],[<+++++[>--
----<-]>-[>[>>]+[<<]>-]>[>>]<[-]<[-<<]>,
]++++++++[->++++<]>[>[-<.>]<[->>+<<]>>+]

Ha spiegato:

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

Ohm , 3 byte

α@─

Provalo online!

Nota: è anche possibile inserire un input come stringa ( esempio ), ma non riesce per il caso di input vuoto.

Rubino, 23 18 17 byte

->s{[*' '..?~]-s}

Utilizza una funzione lambda come da commenti di @ sethrin.

Versione precedente:

[*' '..?~]-s.chars

(' '..'~').to_a-s.chars

APL, 13 byte

⍞~⍨⎕UCS31+⍳95

semplice:

       31+⍳95  ⍝ A vector 32 .. 126
   ⎕UCS        ⍝ as characters
 ~⍨            ⍝ without
⍞              ⍝ those read from character input.

R , 50 byte

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.

Provalo online!

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.

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

05AB1E, 5 4 bytes

-1 thanks to Emigna

žQsK

Try it online!

žQ   # Push all printable characters
  s  # Swap input to the top
   K # Push a with no b's (remove input characters from all printable character)

V, 20 bytes

òiÎflax
òcH ¬ ~@"<

Try it online!

Hexdump:

00000000: f269 ce66 1b6c 6178 0af2 6348 20ac 207e  .i.f.lax..cH . ~
00000010: 1b40 223c                                .@"<

C (gcc), 75 72 70 68 50 bytes

i;f(s){for(i=31;++i<127;strchr(s,i)?:putchar(i));}

Try it online!

Jelly, 8 bytes

Really, 8 bytes? Please, tell me I missed something!

32r126Ọḟ

Try it online!

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:

ØṖḟ

Charcoal, 18 15 10 8 bytes

Ｆγ¿¬№θιι

Try it online! Link is to verbose version of code. Edit: Saved 3 bytes by ranging over characters instead of integers. Saved a further 5 bytes when I discovered the undocumented γ variable which holds the printable ASCII characters. Saved a further 2 bytes when @ASCII-only fixed predefined inputs in verbose mode (the answer is still valid as it stands, it's only the try it online link that wouldn't have worked at the time).

Mathematica, 35 bytes

20~CharacterRange~126~Complement~#&

Anonymous function. Takes a list of characters as input and returns a list of characters as output.

Lua, 78 bytes

s=io.read()for i=32,126 do c=string.char(i)io.write(s:find(c,1,1)and""or c)end

shortC, 33 bytes

i;AOi=31;++i<'~';strchr(*@,i)?:Pi

Conversions made in this program:

• A -> int main(int argc, char **argv) {
• O -> for(
• @ -> argv
• P -> putchar
• Auto-inserted closing ));}

The resulting program looks like:

i;int main(int argc, char **argv){for(i=31;++i<'~';strchr(*argv,i)?:putchar(i));}

Try it online!

Pyth, 17 bytes

Vr32 127I!}CNzpCN

The naive approach.

Explanation:

Vr32 127I!}CNzpCN
Vr32 127             For N in [32, 127[
           CN        Get the ASCII character for the code N
        I!}  z       If it is in the input string...
              pCN    ...then print it

Test it online!

Clojure, 60 or 49 bytes

#(apply str(sort(apply disj(set(map char(range 32 127)))%)))

These "apply"s are killing me :/ Oh, if returning a list is fine then this is a bit shorter.

#(sort(apply disj(set(map char(range 32 127)))%))