Défi simple inspiré par la popularité de mes précédents textes invisibles imprimés et imprimés de vrais textes invisibles , et le même défi de chaîne de longueur différente .

Étant donné une chaîne composée uniquement de caractères imprimables ( 0x20 to 0x7E), imprimez chaque caractère imprimable non présent dans la chaîne.

Contribution

Une chaîne ou un tableau de caractères, composé uniquement de caractères ASCII imprimables

Production

Chaque caractère ASCII imprimable n'est pas présent dans la chaîne d'entrée, dans n'importe quel ordre.

Cas de test

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

Notation

C'est du golf de code donc le moins d'octets dans chaque langue gagne

GS2 , 2 octets

ç7

Essayez-le en ligne!

Comment ça fonctionne

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

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

Notez que le résultat est aléatoire car les ensembles ne sont pas ordonnés.

Essaye-le

Étendu:

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

Il existe également une version ASCII de ∖ (-), mais elle nécessiterait un espace avant pour ne pas être analysée comme un appel de sous-routine.

Python 3.5 , 39 octets

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

Essayez-le en ligne!
Transforme l'entrée en un ensemble et le supprime de l'ensemble contenant tous les caractères ascii

Japt , 14 octets

Ho#_dÃf@bX ¥J

Essayez-le en ligne!

4 octets enregistrés grâce à Shaggy et obarakon

Haskell, 32 octets

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

Essayez-le en ligne!

Fonction de bibliothèque ennuyeuse pour la différence définie:

Haskell, 31 octets

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

MATL , 5 octets

6Y2X~

Essayez-le en ligne!

Merci à Luis Mendo d'avoir joué au golf à 8 octets!

Explication:

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

La différence d'ensemble symétrique donnera chaque élément présent dans exactement l'un des deux ensembles d'entrée. (mais pas les deux) Cela donnera toujours la bonne réponse, car l'ensemble d'entrée sera toujours un sous-ensemble du deuxième ensemble (tous ASCII imprimables).

Version originale:

32:126tGom~)c

Explication:

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 octets

ẹ;Ṭ↔x

Essayez-le en ligne!

Explication

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

JavaScript (ES6), 74 octets

Je suis sûr qu'il existe un moyen plus court de le faire!

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

Essayez-le

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 octets

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

Essayez-le en ligne!

Génère une plage hexa, inverse le vidage hexadécimal pour char et supprime les caractères présents dans le premier paramètre.

Octave, 22 20 octets

Merci à @Luis Mendo a sauvé 2 octets.

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

Essayez-le en ligne!

Autre réponse:

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

Essayez-le en ligne!

PHP, 42 octets

Entrée sous forme de tableau

Sortie sous forme de chaîne

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

Essayez-le en ligne!

PHP, 53 octets

Entrée sous forme de chaîne

Sortie sous forme de chaîne

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

remplacer <?=joinpar print_rpour une sortie en tant que tableau

Essayez-le en ligne!

CJam , 8 octets

'␡,32>q^

Où ␡est un caractère de suppression littéral.

Essayez-le en ligne!

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

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

Courez avec perl -pe.

brainfuck , 120 octets

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

Essayez-le en ligne!

Enveloppé:

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

Expliqué:

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

α@─

Essayez-le en ligne!

Remarque: vous pouvez également saisir votre entrée sous forme de chaîne ( exemple ), mais elle échoue pour le cas d'entrée vide.

Rubis, 23 18 17 octets

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

Utilise une fonction lambda selon les commentaires de @ sethrin.

Versions précédentes:

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

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

APL, 13 octets

⍞~⍨⎕UCS31+⍳95

Simple:

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

R , 50 octets

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

renvoie une fonction anonyme. Convertit la chaîne d'entrée en nombres entiers, calcule la différence définie entre la plage imprimable et les valeurs d'entrée, puis les reconvertit en chaîne et la renvoie.

Essayez-le en ligne!

PHP, 53 octets

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

Exécuter en tant que tuyau avec -r.

C #, 74 71 octets

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

Ancienne version avec création d'une plage de 74 octets:

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

05AB1E , 5 4 octets

-1 grâce à Emigna

žQsK

Essayez-le en ligne!

ž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 octets

òiÎflax
òcH ¬ ~@"<

Essayez-le en ligne!

Hexdump:

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

C (gcc) , 75 72 70 68 50 octets

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

Essayez-le en ligne!

Gelée , 8 octets

Vraiment, 8 octets? S'il vous plaît, dites-moi que j'ai raté quelque chose!

32r126Ọḟ

Essayez-le en ligne!

Comment?

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

Alternativement

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

Depuis ce défi, un nouvel atome qui produit tous les caractères ASCII imprimables ØṖ, a été introduit, ce qui rend le travail suivant sur 3 octets:

ØṖḟ

Fusain , 18 15 10 8 octets

Ｆγ¿¬№θιι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Modifier: enregistré 3 octets en s'étendant sur des caractères au lieu d'entiers. J'ai enregistré 5 octets supplémentaires lorsque j'ai découvert la γvariable non documentée qui contient les caractères ASCII imprimables. Enregistré 2 octets supplémentaires lorsque @ ASCII uniquement des entrées prédéfinies fixes en mode prolixe (la réponse est toujours valable en l'état, ce n'est que le lien d'essayer en ligne qui n'aurait pas fonctionné à l'époque).

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