Desafio simples inspirado na popularidade do meu texto invisível de impressão anterior e nos desafios de texto invisível real e com o mesmo comprimento de desafio de sequência diferente .

Dada uma sequência que consiste apenas em caracteres imprimíveis ( 0x20 to 0x7E), imprima todos os caracteres imprimíveis que não estão presentes na sequência.

Entrada

Uma sequência ou matriz de caracteres que consiste apenas em caracteres ASCII imprimíveis

Resultado

Todos os caracteres ASCII imprimíveis que não estão presentes na sequência de entrada, em qualquer ordem.

Casos de teste

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

Pontuação

Isso é código-golfe, e o menor número de bytes em cada idioma ganha

GS2 , 2 bytes

ç7

Experimente online!

Como funciona

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

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

Observe que o resultado é aleatório porque Set s não é ordenado.

Teste-o

Expandido:

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

Há também uma versão ASCII do ∖ (-), mas isso exigiria um espaço antes dele, para que não seja analisado como uma chamada de sub-rotina.

Python 3.5 , 39 bytes

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

Experimente online!
Transforma a entrada em um conjunto e remova-a do conjunto que contém todos os caracteres ascii

Japonês , 14 bytes

Ho#_dÃf@bX ¥J

Experimente online!

Economizou 4 bytes graças a Shaggy e obarakon

Haskell, 32 bytes

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

Experimente online!

Função de biblioteca chata para definir a diferença:

Haskell, 31 bytes

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

MATL , 5 bytes

6Y2X~

Experimente online!

Obrigado a Luis Mendo por jogar 8 bytes de desconto!

Explicação:

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

A diferença de conjunto simétrico fornecerá todos os elementos presentes em exatamente um dos dois conjuntos de entrada. (mas não ambos) Isso sempre dará a resposta correta, pois o conjunto de entrada sempre será um subconjunto do segundo conjunto (todos ASCII imprimíveis).

Versão original:

32:126tGom~)c

Explicação:

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

Braquilog , 5 bytes

ẹ;Ṭ↔x

Experimente online!

Explicação

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

JavaScript (ES6), 74 bytes

Tenho certeza de que há uma maneira mais curta de fazer isso!

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

Tente

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>

Bater ,47 43 40 bytes

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

Experimente online!

Gera intervalo hexa, inverte hex dump para char e remove os caracteres presentes no primeiro parâmetro.

Oitava, 22 20 bytes

Graças a @Luis Mendo, foram salvos 2 bytes.

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

Experimente online!

Outra resposta:

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

Experimente online!

PHP, 42 bytes

Entrada como matriz

Saída como string

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

Experimente online!

PHP, 53 bytes

Entrada como string

Saída como string

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

substituir <?=join com print_ruma saída como matriz

Experimente online!

CJam , 8 bytes

'␡,32>q^

Onde ␡ está um caractere de exclusão literal.

Experimente 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 bytes

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

Corra com perl -pe.

brainfuck , 120 bytes

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

Experimente online!

Embrulhado:

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

Explicado:

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

α@─

Experimente online!

Nota: você também pode inserir sua entrada como uma sequência ( exemplo ), mas ela falhará no caso de entrada vazio.

Ruby, 23 18 17 bytes

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

Usa uma função lambda de acordo com os comentários de @ sethrin.

Versões prévias:

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

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

APL, 13 bytes

⍞~⍨⎕UCS31+⍳95

Direto:

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

retorna uma função anônima. Converte a sequência de entrada em números inteiros, calcula a diferença definida entre o intervalo imprimível e os valores de entrada e, em seguida, converte-os novamente em uma sequência e a retorna.

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

Corra como cano com -r.

C #, 74 71 bytes

using System.Linq;s=>new int[95].Select((n,i)=>(char)(i+32)).Except(s);

Versão antiga com a criação de um intervalo para 74 bytes:

using System.Linq;s=>Enumerable.Range(32,95).Select(n=>(char)n).Except(s);

05AB1E , 5 4 bytes

-1 graças a Emigna

žQsK

Experimente 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 ¬ ~@"<

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

Experimente online!

Gelatina , 8 bytes

Sério, 8 bytes? Por favor, diga-me que perdi alguma coisa!

32r126Ọḟ

Experimente online!

Quão?

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

alternativamente

“ ~‘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

Desde esse desafio, um novo átomo que produz todos os caracteres ASCII imprimíveis ØṖ, foi introduzido, fazendo o seguinte trabalho por 3 bytes:

ØṖḟ

Carvão , 18 15 10 8 bytes

Ｆγ¿¬№θιι

Experimente online! Link é a versão detalhada do código. Editar: salvou 3 bytes, passando por caracteres em vez de números inteiros. Salvei mais 5 bytes quando descobri a γvariável não documentada que contém os caracteres ASCII imprimíveis. Economizou mais 2 bytes quando as entradas predefinidas corrigidas apenas pelo @ ASCII no modo detalhado (a resposta ainda é válida como está, é apenas o link do try it online que não teria funcionado no momento).

Mathematica, 35 bytes

20~CharacterRange~126~Complement~#&

Função anônima. Pega uma lista de caracteres como entrada e retorna uma lista de caracteres como saída.

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

Conversões feitas neste programa:

• A -> int main(int argc, char **argv) {
• O -> for(
• @ -> argv
• P -> putchar
• Fechamento inserido automaticamente ));}

O programa resultante se parece com:

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

Experimente online!

Pitão , 17 bytes

Vr32 127I!}CNzpCN

A abordagem ingênua.

Explicação:

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

Teste online!

Clojure, 60 ou 49 bytes

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

Esses "aplicativos" estão me matando: / Oh, se retornar uma lista é bom, então isso é um pouco menor.

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