Proste wyzwanie zainspirowane popularnością mojego poprzedniego wydruku niewidocznego tekstu i wydruku prawdziwych niewidzialnych wyzwań tekstowych oraz wyzwanie o tej samej długości i różnej długości .

Biorąc pod uwagę ciąg znaków składający się wyłącznie z drukowalnych znaków ( 0x20 to 0x7E), wypisz każdy drukowalny znak nieobecny w ciągu.

Wejście

Ciąg znaków lub tablica znaków składająca się wyłącznie z drukowalnych znaków ASCII

Wynik

Każdy drukowany znak ASCII nieobecny w ciągu wejściowym, w dowolnej kolejności.

Przypadki testowe

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

Punktacja

To jest golf golfowy, więc wygrywa najmniej bajtów w każdym języku

GS2 , 2 bajty

ç7

Wypróbuj online!

Jak to działa

    (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 bajtów

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

Zauważ, że wynik jest losowy, ponieważ Zestawy s są nieuporządkowane.

Sprawdź to

Rozszerzony:

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

Istnieje również wersja ASCII ∖ (-), ale wymagałaby spacji, aby nie została przeanalizowana jako wywołanie podprogramu.

Python 3.5 , 39 bajtów

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

Wypróbuj online!
Zamienia dane wejściowe w zestaw i usuwa je ze zbioru zawierającego wszystkie znaki ascii

Japt , 14 bajtów

Ho#_dÃf@bX ¥J

Wypróbuj online!

Zaoszczędź 4 bajty dzięki Shaggy i obarakon

Haskell, 32 bajty

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

Wypróbuj online!

Nudna funkcja biblioteki dla ustawionej różnicy:

Haskell, 31 bajtów

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

MATL , 5 bajtów

6Y2X~

Wypróbuj online!

Dzięki Luis Mendo za grę w golfa o 8 bajtów!

Wyjaśnienie:

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

Różnica symetrycznych zestawów da każdy element, który jest obecny dokładnie w jednym z dwóch zestawów wejściowych. (ale nie oba) To zawsze da właściwą odpowiedź, ponieważ zestaw wejściowy zawsze będzie podzbiorem drugiego zestawu (wszystkie ASCII do wydruku).

Orginalna wersja:

32:126tGom~)c

Wyjaśnienie:

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 bajtów

ẹ;Ṭ↔x

Wypróbuj online!

Wyjaśnienie

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

JavaScript (ES6), 74 bajty

Jestem pewien, że jest na to krótszy sposób!

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

Spróbuj

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>

Grzmotnąć ,47 43 40 bajtów

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

Wypróbuj online!

Generuje zakres hexa, odwraca zrzut heksowy na char i usuwa znaki obecne w pierwszym parametrze.

Oktawa, 22 20 bajtów

Dzięki @Luis Mendo zapisano 2 bajty.

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

Wypróbuj online!

Inna odpowiedź:

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

Wypróbuj online!

PHP, 42 bajty

Wprowadź jako tablicę

Dane wyjściowe jako ciąg

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

Wypróbuj online!

PHP, 53 bajtów

Wprowadź jako ciąg

Dane wyjściowe jako ciąg

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

zastępuje <?=joinsię print_rna wyjście jako matrycy

Wypróbuj online!

CJam , 8 bajtów

'␡,32>q^

Gdzie ␡jest dosłowny znak usuwania.

Wypróbuj 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 bajtów

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

Uruchom z perl -pe.

pieprzenie mózgu , 120 bajtów

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

Wypróbuj online!

Owinięty:

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

Wyjaśniono:

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

α@─

Wypróbuj online!

Uwaga: możesz również wprowadzić dane wejściowe jako ciąg znaków ( przykład ), ale nie powiedzie się to w przypadku pustej wielkości danych wejściowych.

Rubin, 23 18 17 bajtów

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

Używa funkcji lambda zgodnie z komentarzami @ sethrin.

Poprzednie wersje:

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

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

APL, 13 bajtów

⍞~⍨⎕UCS31+⍳95

Bezpośredni:

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

R , 50 bajtów

function(s)intToUtf8(setdiff(32:126,utf8ToInt(s)))

zwraca anonimową funkcję. Konwertuje ciąg wejściowy na liczby całkowite, oblicza ustawioną różnicę między zakresem drukowania a wartościami wejściowymi, a następnie konwertuje je z powrotem na ciąg i zwraca go.

Wypróbuj online!

PHP, 53 bajty

for($k=31;$k++<126;)~strstr($argn,$k)?:print chr($k);
# or
for($k=31;$k++<126;)echo~strstr($argn,$k)?"":chr($k);

Uruchom jako potok z -r.

C #, 74 71 bajtów

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