Desafío simple inspirado en la popularidad de mi impresión anterior de texto invisible e impresión de desafíos de texto invisible real , y el mismo desafío de cadena diferente .

Dada una cadena que consta de solo caracteres imprimibles ( 0x20 to 0x7E), imprima todos los caracteres imprimibles que no estén presentes en la cadena.

Entrada

Una cadena o conjunto de caracteres, que consta de solo caracteres ASCII imprimibles

Salida

Todos los caracteres ASCII imprimibles no están presentes en la cadena de entrada, en ningún orden.

Casos de prueba

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

Puntuación

Este es el código de golf, por lo que gana menos bytes en cada idioma

GS2 , 2 bytes

ç7

Pruébalo en línea!

Cómo 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}

Tenga en cuenta que el resultado es aleatorio porque los conjuntos s no están ordenados.

Pruébalo

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
}

También hay una versión ASCII de ∖ (-), pero requeriría un espacio antes para que no se analice como una llamada de subrutina.

Python 3.5 , 39 bytes

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

Pruébalo en línea!
Convierte la entrada en un conjunto y la elimina del conjunto que contiene todos los caracteres ascii.

Japt , 14 bytes

Ho#_dÃf@bX ¥J

Pruébalo en línea!

Guardado 4 bytes gracias a Shaggy y Obarakon

Haskell, 32 bytes

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

Pruébalo en línea!

Función de biblioteca aburrida para establecer la diferencia:

Haskell, 31 bytes

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

MATL , 5 bytes

6Y2X~

Pruébalo en línea!

¡Gracias a Luis Mendo por jugar 8 bytes de descuento!

Explicación:

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

La diferencia de conjunto simétrico dará a cada elemento presente en exactamente uno de los dos conjuntos de entrada. (pero no ambos) Esto siempre dará la respuesta correcta, ya que el conjunto de entrada siempre será un subconjunto del segundo conjunto (todo ASCII imprimible).

Versión original:

32:126tGom~)c

Explicación:

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 bytes

ẹ;Ṭ↔x

Pruébalo en línea!

Explicación

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

JavaScript (ES6), 74 bytes

¡Estoy seguro de que hay una forma más corta de hacer esto!

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

Intentalo

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 bytes

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

Pruébalo en línea!

Genera rango hexa, invierte el volcado hexadecimal para eliminar caracteres eliminados presentes en el primer parámetro.

Octava, 22 20 bytes

Gracias a @Luis Mendo ahorró 2 bytes.

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

Pruébalo en línea!

Otra respuesta:

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

Pruébalo en línea!

PHP, 42 bytes

Entrada como matriz

Salida como cadena

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

Pruébalo en línea!

PHP, 53 bytes

Entrada como cadena

Salida como cadena

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

reemplazar <?=joincon print_runa salida como matriz

Pruébalo en línea!

CJam , 8 bytes

'␡,32>q^

Donde ␡es un carácter de eliminación literal.

Pruébalo en línea!

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

Corre con perl -pe.

brainfuck , 120 bytes

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

Pruébalo en línea!

Envuelto:

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

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

α@─

Pruébalo en línea!

Nota: también puede ingresar su entrada como una cadena ( ejemplo ), pero falla para el caso de entrada vacía.

Ruby, 23 18 17 bytes

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

Utiliza una función lambda según los comentarios de @ sethrin.

Versión anterior:

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

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

APL, 13 bytes

⍞~⍨⎕UCS31+⍳95

Sencillo:

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

devuelve una función anónima Convierte la cadena de entrada en enteros, calcula la diferencia establecida entre el rango imprimible y los valores de entrada, y luego los vuelve a convertir en una cadena y la devuelve.

Pruébalo en línea!

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

Ejecutar como tubería con -r.

C #, 74 71 bytes

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

Versión antigua con la creación de un rango de 74 bytes:

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

05AB1E , 5 4 bytes

-1 gracias a Emigna

žQsK

Pruébalo en línea!

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

Pruébalo en línea!

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

Pruébalo en línea!

Jalea , 8 bytes

¿De verdad, 8 bytes? ¡Por favor, dime que me perdí algo!

32r126Ọḟ

Pruébalo en línea!

¿Cómo?

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 este desafío ØṖ, se ha introducido un nuevo átomo que produce todos los caracteres ASCII imprimibles, haciendo que el siguiente trabajo para 3 bytes:

ØṖḟ

Carbón , 18 15 10 8 bytes

Ｆγ¿¬№θιι

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: guardado 3 bytes al pasar por caracteres en lugar de enteros. Guarde otros 5 bytes cuando descubrí la γvariable indocumentada que contiene los caracteres ASCII imprimibles. Se guardaron otros 2 bytes cuando @ ASCII solo fijó entradas predefinidas en modo detallado (la respuesta sigue siendo válida en su estado actual, es solo el enlace en línea probarlo que no hubiera funcionado en ese momento).

Mathematica, 35 bytes

20~CharacterRange~126~Complement~#&

Función anónima. Toma una lista de caracteres como entrada y devuelve una lista de caracteres como salida.

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

Conversiones realizadas en este programa:

• A -> int main(int argc, char **argv) {
• O -> for(
• @ -> argv
• P -> putchar
• Cierre de inserción automática ));}

El programa resultante se ve así:

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

Pruébalo en línea!

Pyth , 17 bytes

Vr32 127I!}CNzpCN

El enfoque ingenuo.

Explicación:

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

¡Pruébalo en línea!

Clojure, 60 o 49 bytes

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

Estas "solicitudes" me están matando: / Oh, si devolver una lista está bien, entonces esto es un poco más corto.

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