Önceki baskı görünmez metnimin popülaritesinden esinlenen basit zorluk ve gerçek görünmez metin zorlukları ve aynı uzunlukta farklı dize zorluğu yazdırın .

Yalnızca yazdırılabilir karakterlerden ( 0x20 to 0x7E) oluşan bir dize verildiğinde, dizede bulunmayan her yazdırılabilir karakteri yazdırın.

Giriş

Yalnızca yazdırılabilir ASCII karakterlerden oluşan bir dize veya karakter dizisi

Çıktı

Giriş dizesinde bulunmayan her yazdırılabilir ASCII karakteri herhangi bir sırada.

testcases

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

puanlama

Bu kod golf , her dilde en az bayt kazanır

GS2 , 2 bayt

ç7

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Set s sıralanmamış olduğu için sonucun rastgele olduğunu unutmayın .

Dene

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
}

Bir ASCII sürümü de vardır ∖ (-), ancak alt program çağrısı olarak ayrıştırılmaması için önce boşluk gerekir.

Python 3.5 , 39 bayt

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

Çevrimiçi deneyin!
Girişi bir kümeye dönüştürür ve tüm ascii karakterlerini içeren kümeden kaldırır

Japt , 14 bayt

Ho#_dÃf@bX ¥J

Çevrimiçi deneyin!

Shaggy ve obarakon sayesinde 4 bayt kurtardı

Haskell, 32 bayt

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

Çevrimiçi deneyin!

Set farkı için sıkıcı kütüphane fonksiyonu:

Haskell, 31 bayt

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

MATL , 5 bayt

6Y2X~

Çevrimiçi deneyin!

8 bytes kapalı golf için Luis Mendo için teşekkürler !

Açıklama:

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

Simetrik küme farkı , iki giriş kümesinden tam olarak birinde bulunan her öğeyi verecektir. (ancak her ikisi birden değil) Bu, her zaman doğru cevabı verecektir, çünkü giriş kümesi her zaman ikinci kümenin bir alt kümesi olacaktır (tüm yazdırılabilir ASCII).

Orijinal versiyon:

32:126tGom~)c

Açıklama:

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 bayt

ẹ;Ṭ↔x

Çevrimiçi deneyin!

açıklama

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

JavaScript (ES6), 74 bayt

Eminim bunu yapmanın daha kısa bir yolu var!

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

Dene

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>

darbe ,47 43 40 bayt

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

Çevrimiçi deneyin!

Hexa aralığı oluşturur, onaltılı dökümü tersine çevirir ve ilk parametrede bulunan karakterleri kaldırır.

Oktav, 22 20 bayt

@Luis Mendo sayesinde 2 bayt kurtardı.

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

Çevrimiçi deneyin!

Diğer cevap:

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

Çevrimiçi deneyin!

PHP, 42 Bayt

Dizi olarak giriş

Dize olarak çıktı

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

Çevrimiçi deneyin!

PHP, 53 Bayt

Dize olarak giriş

Dize olarak çıktı

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

dizi olarak bir çıktı için <?=joinile değiştirprint_r

Çevrimiçi deneyin!

CJam , 8 bayt

'␡,32>q^

␡Gerçek bir silme karakteri nerede .

Çevrimiçi deneyin!

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

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

İle çalıştırın perl -pe.

brainfuck, 120 bytes

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

Try it online!

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
]

Ohm, 3 bytes

α@─

Try it online!

Note: you can also enter your input as a string (example), but it fails for the empty input case.

Ruby, 23 18 17 bytes

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

Uses a lambda function as per @sethrin's comments.

Previous versions:

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

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

APL, 13 bytes

⍞~⍨⎕UCS31+⍳95

Straightforward:

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

R, 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!

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