Einfache Herausforderung, inspiriert von der Popularität meines vorherigen Drucks von unsichtbarem Text und Drucke echte unsichtbare Textherausforderungen und die gleiche Länge unterschiedlicher Zeichenfolgenherausforderung .

Bei einer Zeichenfolge, die nur aus druckbaren Zeichen ( 0x20 to 0x7E) besteht, wird jedes druckbare Zeichen gedruckt, das nicht in der Zeichenfolge enthalten ist.

Eingang

Eine Zeichenfolge oder ein Zeichenfeld, das nur aus druckbaren ASCII-Zeichen besteht

Ausgabe

Jedes druckbare ASCII-Zeichen, das nicht in der Eingabezeichenfolge enthalten ist, in beliebiger Reihenfolge.

Testfälle

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

Wertung

Dies ist Code-Golf, so dass die wenigsten Bytes in jeder Sprache gewinnen

GS2 , 2 Bytes

ç7

Probieren Sie es online!

Wie es funktioniert

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

Beachten Sie, dass das Ergebnis zufällig ist, da Mengen ungeordnet sind.

Probier es aus

Erweitert:

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

Es gibt auch eine ASCII-Version von ∖ (-), die jedoch ein Leerzeichen benötigt, damit sie nicht als Unterprogrammaufruf analysiert wird.

Python 3.5 , 39 Bytes

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

Probieren Sie es online!
Verwandelt die Eingabe in eine Menge und entfernt sie aus der Menge, die alle ASCII-Zeichen enthält

Japt , 14 Bytes

Ho#_dÃf@bX ¥J

Probieren Sie es online!

4 Bytes dank Shaggy und Obarakon gespeichert

Haskell, 32 Bytes

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

Probieren Sie es online!

Langweilige Bibliotheksfunktion für die eingestellte Differenz:

Haskell, 31 Bytes

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

MATL , 5 Bytes

6Y2X~

Probieren Sie es online!

Danke an Luis Mendo für das Golfen mit 8 Bytes!

Erläuterung:

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

Die symmetrische Satzdifferenz gibt jedes Element an, das in genau einem der beiden Eingabesätze vorhanden ist. (aber nicht beides) Dies gibt immer die richtige Antwort, da die Eingabemenge immer eine Teilmenge der zweiten Menge ist (alles druckbare ASCII).

Originalfassung:

32:126tGom~)c

Erläuterung:

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

Probieren Sie es online!

Erläuterung

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

JavaScript (ES6), 74 Byte

Ich bin mir sicher, dass es dafür einen kürzeren Weg gibt!

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

Versuch es

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"

Probieren Sie es online!

Erzeugt einen Hexa-Bereich, invertiert das Hexa-Dump in ein Zeichen und entfernt Zeichen, die im ersten Parameter enthalten sind.

Oktave, 22 bis 20 Bytes

Dank @Luis hat Mendo 2 Bytes gespart.

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

Probieren Sie es online!

Andere Antwort:

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

Probieren Sie es online!

PHP, 42 Bytes

Eingabe als Array

Ausgabe als String

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

Probieren Sie es online!

PHP, 53 Bytes

Eingabe als String

Ausgabe als String

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

Ersetzen Sie <?=joinmit print_rfür eine Ausgabe als Array

Probieren Sie es online!

CJam , 8 Bytes

'␡,32>q^

Wo ␡ist ein wörtliches Löschzeichen.

Probieren Sie es 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

Laufen Sie mit perl -pe.

Brainfuck , 120 Bytes

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

Probieren Sie es online!

Gewickelt:

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

Erklärt:

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

α@─

Probieren Sie es online!

Hinweis: Sie können Ihre Eingabe auch als Zeichenfolge eingeben ( Beispiel ), dies schlägt jedoch für den leeren Eingabefall fehl.

Rubin, 23 18 17 Bytes

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

Verwendet eine Lambda-Funktion gemäß @ sethrins Kommentaren.

Vorherige Versionen:

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

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

APL, 13 Bytes

⍞~⍨⎕UCS31+⍳95

Einfach:

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

Gibt eine anonyme Funktion zurück. Konvertiert die Eingabezeichenfolge in Ganzzahlen, berechnet die eingestellte Differenz zwischen dem druckbaren Bereich und den Eingabewerten und konvertiert sie dann zurück in eine Zeichenfolge und gibt sie zurück.

Probieren Sie es 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);

Als Rohr mit laufen lassen -r.

C #, 74 71 Bytes

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

Alte Version mit einem Bereich für 74 Bytes:

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

05AB1E , 5 4 Bytes

-1 danke an Emigna

žQsK

Probieren Sie es 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 ¬ ~@"<

Probieren Sie es 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));}

Probieren Sie es online!

Gelee , 8 Bytes

Wirklich 8 Bytes? Bitte sag mir, dass ich etwas verpasst habe!

32r126Ọḟ

Probieren Sie es online!

Wie?

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

Alternative

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

Seit dieser Herausforderung wurde ein neues Atom eingeführt, das alle druckbaren ASCII-Zeichen liefert. ØṖDamit funktioniert Folgendes für 3 Bytes:

ØṖḟ

Kohle , 18 15 10 8 Bytes

Ｆγ¿¬№θιι

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: Speichert 3 Bytes, indem Zeichen anstelle von ganzen Zahlen überstrichen werden. Weitere 5 Bytes wurden gespeichert, als ich die undokumentierte γVariable entdeckte, die die druckbaren ASCII-Zeichen enthält. Weitere 2 Bytes wurden gespeichert, wenn @ ASCII-only vordefinierte Eingaben im ausführlichen Modus festlegte.

Mathematica, 35 Bytes

20~CharacterRange~126~Complement~#&

Anonyme Funktion. Nimmt eine Liste von Zeichen als Eingabe und gibt eine Liste von Zeichen als Ausgabe zurück.

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

In diesem Programm vorgenommene Konvertierungen:

• A -> int main(int argc, char **argv) {
• O -> for(
• @ -> argv
• P -> putchar
• Automatisch eingefügtes Schließen ));}

Das resultierende Programm sieht folgendermaßen aus:

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

Probieren Sie es online!

Pyth , 17 Bytes

Vr32 127I!}CNzpCN

Der naive Ansatz.

Erläuterung:

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

Online testen!

Clojure, 60 oder 49 Bytes

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

Diese "Apply" s bringen mich um: / Oh, wenn es in Ordnung ist, eine Liste zurückzugeben, ist dies etwas kürzer.

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