मेरे पिछले प्रिंट अदृश्य पाठ और प्रिंट वास्तविक अदृश्य पाठ चुनौतियों की लोकप्रियता से प्रेरित सरल चुनौती , और समान लंबाई अलग स्ट्रिंग चुनौती।

केवल मुद्रण योग्य वर्णों ( 0x20 to 0x7E) से युक्त स्ट्रिंग को देखते हुए, स्ट्रिंग में मौजूद प्रत्येक मुद्रण योग्य वर्ण को प्रिंट करें।

इनपुट

केवल स्ट्रिंग करने योग्य ASCII वर्णों से मिलकर एक स्ट्रिंग, या वर्णों की सरणी

उत्पादन

प्रत्येक मुद्रण योग्य ASCII वर्ण किसी भी क्रम में इनपुट स्ट्रिंग में मौजूद नहीं है।

परीक्षण के मामलों

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

स्कोरिंग

यह प्रत्येक भाषा की जीत में कोड-गोल्फ इतनी कम बाइट्स है

code-golf string

— Skidsdev
स्रोत

यदि कोई सरणी लौटाता है, तो क्या हम प्रयुक्त वर्णों के स्थान पर खाली तत्वों को शामिल कर सकते हैं?

— शैगी

@ यकीन है, यह ठीक है

— Skidsdev

@ राड मेरी योजना को लीक नहीं करता है:

— स्काइडदेव

क्या आउटपुट पात्रों के तारों का एक सेट ऑब्जेक्ट हो सकता है ? set( 'a', 'b', 'c' )

— ब्रैड गिलबर्ट

1

@MikhailV केवल अगर आपकी भाषा ASCII वर्णों का उत्पादन करने में असमर्थ है

— Skidsdev

11

जीएस 2, 2 बाइट्स

ç7

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

— डेनिस
स्रोत

6

पर्ल 6 , 29 बाइट्स

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

ध्यान दें कि परिणाम यादृच्छिक है क्योंकि सेट s अव्यवस्थित हैं।

झसे आज़माओ

विस्तारित:

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

इसका ASCII संस्करण भी है ∖ (-), लेकिन इसके पहले एक स्थान की आवश्यकता होगी ताकि यह सबरूटीन कॉल के रूप में पार्स न हो।

— ब्रैड गिल्बर्ट b2gills
स्रोत

6

पायथन 3.5 , 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!
इनपुट को एक सेट में बदल देता है, और इसे सभी एस्की पात्रों वाले सेट से हटा देता है

— छड़ी
स्रोत

यह केवल पायथन 3.5 के बाद काम करता है।

— गबोर फेकेट

5

जाप , 14 बाइट्स

Ho#_dÃf@bX ¥J

इसे ऑनलाइन आज़माएं!

4 बाइट्स बचाए, जो शगी और ओबरकॉन के लिए धन्यवाद है

— टॉम
स्रोत

1

ध्वज की आवश्यकता नहीं है (प्रश्न पर मेरी टिप्पणी का उत्तर देखें)। बदलें 127के साथ #एक बाइट बचाने के लिए और दूर करने के लिए Uएक और बचाने के लिए।

— शैगी

1

आप ¦कुछ बाइट्स को बचाने के लिए अपने तर्कों का उपयोग और पुनर्व्यवस्थित कर सकते हैं । इसके अलावा, 127 को TIO

— ऑलिवर

1

: यह 14 बाइट्स के लिए नीचे मिल गया ethproductions.github.io/japt/...

— शैगी

1

नहीं, आप इसके साथ काम करते हैं, टॉम - जैसा कि आपने पहले कहा था, मुझे जल्दी पोस्ट करना सीखना होगा! : डी

— शैगी

1

एक 10 बाइट संस्करण लेकिन दुर्भाग्य से गैर-प्रतिस्पर्धात्मक: ethproductions.github.io/japt/…

— झबरा

4

हास्केल, 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सेट अंतर के लिए बोरिंग लाइब्रेरी फ़ंक्शन:

हास्केल, 31 बाइट्स

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

— nimi
स्रोत

4

MATL , 5 बाइट्स

6Y2X~

इसे ऑनलाइन आज़माएं!

लुइस मेंडो के लिए 8 बाइट्स गोल्फिंग के लिए धन्यवाद !

स्पष्टीकरण:

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

सममितीय सेट अंतर प्रत्येक तत्व को देगा जो दो इनपुट सेटों में से एक में मौजूद है। (लेकिन दोनों नहीं) यह हमेशा सही उत्तर देगा, क्योंकि इनपुट सेट हमेशा दूसरे सेट (सभी मुद्रण योग्य ASCII) का सबसेट होगा।

मूल संस्करण:

32:126tGom~)c

स्पष्टीकरण:

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

— DJMcMayhem
स्रोत

3

ब्रेकीलॉग , 5 बाइट्स

ẹ;Ṭ↔x

इसे ऑनलाइन आज़माएं!

व्याख्या

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

— Fatalize
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 74 बाइट्स

मुझे यकीन है कि ऐसा करने का एक छोटा तरीका है!

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

कोशिश करो

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>

स्निपेट का विस्तार करें

— झबरा
स्रोत

1

Array(95)लापता को शामिल करने के लिए होना चाहिए~

— मालीव

क्या वह हमेशा वहाँ थी, @ मालिवेल्ली? }जब मैंने इसे लिखा था, तो अंतिम चरित्र शपथ ले सकता था । अब तय है, धन्यवाद।

— झबरा

विश्वास नहीं किया जा सकता है कि C # इसके लिए जावास्क्रिप्ट से छोटा है, विशेष रूप से क्योंकि मुझे अपना उपयोग शामिल करना है।

— TheLethalCoder

1

@ लेथलॉकर, String.fromCharCodeएक गिट है, इसीलिए! : डी

— झबरा

@ शगुन मैं दुन्नो, मैं सिर्फ आपके कोड को देख रहा था कि यह कैसे काम करता है और मैंने अपने कीबोर्ड पर शाब्दिक रूप से प्रत्येक प्रतीक टाइप ~किया और देखा कि इसमें कुछ भी बदलाव नहीं हुआ लेकिन यह कल्पना में था। इसके अलावा, "कोशिश यह" भाग को अद्यतन करने की आवश्यकता है।

— मालीवैल

3

बैश ,४। ४३ 40 बाइट्स

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

इसे ऑनलाइन आज़माएं!

हेक्सा रेंज उत्पन्न करता है, पहले पैरामीटर में मौजूद एक हटाए गए वर्णों को हटाने के लिए हेक्स डंप को इन्वर्ट करता है।

— marcosm
स्रोत

3

ऑक्टेव, 22 20 बाइट्स

@Luis मेंडू की बदौलत 2 बाइट बच गईं।

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

इसे ऑनलाइन आज़माएं!

अन्य उत्तर:

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

इसे ऑनलाइन आज़माएं!

— rahnema1
स्रोत

1

@(s)setxor(' ':'~',s)1 बाइट बचाता है

— लुइस मेन्डो

@LuisMendo बहुत अच्छा! लेकिन मुझे लगता है कि यह एक अलग बात है। मेरा सुझाव है कि आप इसे एक नए उत्तर के रूप में पोस्ट करें :)

— rahnema1

1

नहीं, यह वास्तव में सिर्फ एक मामूली सुधार है। मुझे खुशी होगी कि आप चाहें तो इसे पोस्ट करें। BTW @(s)setxor(32:'~',s)भी काम करने लगता है --- और उसी के लिए टिप्पणी :-)

— लुइस मेंडो

1

@LuisMendo धन्यवाद, मैं सहमत हूं क्योंकि (लुइस) ने कहा।

— rahnema1

2

PHP, 42 बाइट्स

सरणी के रूप में इनपुट

स्ट्रिंग के रूप में आउटपुट

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

इसे ऑनलाइन आज़माएं!

PHP, 53 बाइट्स

इनपुट स्ट्रिंग के रूप में

स्ट्रिंग के रूप में आउटपुट

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

की जगह <?=joinके साथ print_rसरणी के रूप में एक निर्गम के लिए

इसे ऑनलाइन आज़माएं!

— जार्ग हुल्सरमन
स्रोत

शायद आपको PHP का एक गोल्फ संस्करण बनाना चाहिए: P

— CalculatorFeline

@ कैलाकटरफेलिन मुझे यकीन है कि मौजूद है, लेकिन यह वास्तव में अच्छा नहीं है

— जार्ज ह्यूल्समैन

शायद आपको एक अच्छा बनाना चाहिए। चरण 1: स्वचालित प्रारंभिक टैग।

— कैलक्यूलेटरफलाइन

@CalculatorFeline मैंने आपके लिए लिंक खोजा है। github.com/barkermn01/PGP-php-CodeGolf मुझे एक बनाने का कोई शौक नहीं है

— Jörg Hülsermann

1

@CalculatorFeline बनाना PHP को एक गोल्फ भाषा बनाना नष्ट कर देता है जो PHP के साथ गोल्फिंग में मज़ा है (कम से कम मेरे लिए): आपको कॉलिंग फ़ंक्शन (जिसमें अक्सर लंबे नाम होते हैं), लूप का उपयोग करके, विभिन्न इनपुट विधियों और इतने पर के बीच लगातार संतुलन रखना पड़ता है। Step 1: automatic starting tagअच्छी तरह से php -r... लेकिन इस उदाहरण में क्योंकि यह भुगतान नहीं करता echoहै की तुलना में लंबा है <?=।

— क्रिस्टोफ

2

सीजेएम , 8 बाइट्स

'␡,32>q^

जहां ␡एक शाब्दिक डिलीट कैरेक्टर है।

इसे ऑनलाइन आज़माएं!

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

— बिजनेस कैट
स्रोत

नोट के रूप में, -इसके बजाय काम करता है ^।

— फलों

2

पर्ल, 39 बाइट्स

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

साथ चलाना perl -pe।

— ग्रिमी
स्रोत

जब मैं इसे चलाता हूं तो मुझे त्रुटि संदेश मिलता है 'बेयरवर्ड, जहां ऑपरेटर (eval 1) लाइन 2, "y / हैलो वर्ल्ड! // ड्र" के पास अपेक्षित है ...

— क्रिस

पूर्ण कमांड-लाइन echo 'Hello World!' | perl -pe 's!.*!"pack(c95,32..126)=~y/$_//dr"!ee':। यह मेरे लिए Perl v5.14 और v5.24 दोनों पर काम करता है।

— ग्रैमी

यह पर्ल v5.10 है जो काम नहीं कर रहा है ... 5.10 और 5.14 के बीच एक बदलाव होना चाहिए।

— क्रिस

2

ब्रेनफक , 120 बाइट्स

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

इसे ऑनलाइन आज़माएं!

लपेटा हुआ:

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

व्याख्या की:

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

— Doorknob
स्रोत

2

ओम , 3 बाइट्स

α@─

इसे ऑनलाइन आज़माएं!

नोट: आप अपने इनपुट को एक स्ट्रिंग ( उदाहरण ) के रूप में दर्ज कर सकते हैं , लेकिन यह खाली इनपुट मामले के लिए विफल रहता है।

— FrodCube
स्रोत

2

रूबी, 23 18 17 बाइट्स

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

@ सेथरिन की टिप्पणियों के अनुसार एक लंबो फ़ंक्शन का उपयोग करता है।

पिछला संस्करण:

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

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

— मार्क थॉमस
स्रोत

क्या sएसटीडीआईएन से पढ़ा नहीं जाना चाहिए या फ़ंक्शन तर्क के रूप में आपूर्ति की जाती है? चुनौती यह भी निर्दिष्ट करती है कि इनपुट को वर्णों के एक सरणी के रूप में दिया जा सकता है। एक दमदार लैम्ब्डा में बदलने और छोड़ने के लिए chars16-बाइट समाधान देता है।

— कैनशोडेज़

मुझे वास्तव में यकीन नहीं था कि इनपुट को कैसे संबोधित किया जाना है, यह देखते हुए कि यह स्पष्ट रूप से निर्दिष्ट नहीं किया गया था। कुछ अन्य उत्तर हैं जो एक चर में इनपुट के अस्तित्व को मानते हैं। क्या एक कोडगॉल्फ सम्मेलन है? मैं ऐसा नहीं करता।

— मार्क थॉमस

@ सेथ्रिन एक दमदार मेमने के साथ यह 20 चर नहीं होगा? ->(s){[*' '..?~]-s)}

— मार्क थॉमस

आपके लंबोदर में सभी कोष्ठक वैकल्पिक हैं। लेकिन मैं एक बाइट को मिस कर सकता था। अन्य भाषाएँ या तो इनपुट को स्पष्ट रूप से स्वीकार करती हैं या stdinएक वैश्विक चर के लिए बाध्य होती हैं। रूबी के $<लिए एक शॉर्टकट है, stdinलेकिन लंबोदर छोटे होते हैं। इनपुट और आउटपुट पर कन्वेंशन यहाँ हैं । मैं भी ऐसा नहीं करता, इसलिए यदि नियम नहीं हैं तो मुझे लगता है कि मुझे बताएं।

— canhascodez

2

एपीएल, 13 बाइट्स

⍞~⍨⎕UCS31+⍳95

सीधा:

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

— user70088
स्रोत

1

आर , 50 बाइट्स

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

एक अनाम फ़ंक्शन देता है। इनपुट स्ट्रिंग को पूर्णांक में परिवर्तित करता है, प्रिंट करने योग्य रेंज और इनपुट मानों के बीच सेट अंतर की गणना करता है, और फिर उन्हें एक स्ट्रिंग में परिवर्तित करता है और इसे वापस करता है।

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत

1

PHP, 53 बाइट्स

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

साथ पाइप के रूप में चलाएँ -r।

— टाइटस
स्रोत

मैंने कोई और खेल का मैदान नहीं छोड़ा है

— Jörg Hülsermann

@ JörgHülsermann आप करते हैं। आपको बस इसे साझा करना होगा।

— टाइटस

1

सी #, 74 71 बाइट्स

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

74 बाइट्स के लिए एक सीमा बनाने के साथ पुराना संस्करण:

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

— TheLethalCoder
स्रोत

1

05AB1E , 5 4 बाइट्स

-1 Emigna को धन्यवाद

žQsK

इसे ऑनलाइन आज़माएं!

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

— रिले
स्रोत

@FrodCube ओह ... मैं लिंक अपडेट करना भूल गया। यह अब काम करना चाहिए। टीआईओ (खाली इनपुट)

— रिले

1

वी , 20 बाइट्स

òiÎflax
òcH ¬ ~@"<

इसे ऑनलाइन आज़माएं!

Hexdump:

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

— DJMcMayhem
स्रोत

1

सी (जीसीसी) , 75 72 70 68 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— cleblanc
स्रोत

क्या आप ||"मानक" सी पर इस काम को करने के लिए उपयोग कर सकते हैं ?

— नील

@ नील हां || भी काम करता है। "मानक" सी का हिस्सा नहीं है?

— क्लेब्लांक

मैंने हमेशा सोचा था कि यह एक जीसीसी एक्सटेंशन था।

— नील

@ नील यह सही है। ?:एक GNU एक्सटेंशन है। यह क्लैंग और tcc में भी काम करता है।

— डेनिस

1

जेली , 8 बाइट्स

वास्तव में, 8 बाइट्स? कृपया, मुझे बताओ कि मैं कुछ याद किया!

32r126Ọḟ

इसे ऑनलाइन आज़माएं!

कैसे?

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

वैकल्पिक रूप से

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

चूंकि यह एक नया परमाणु है जो सभी मुद्रण योग्य ASCII वर्णों की पैदावार करता है ØṖ, इसे 3 बाइट्स के लिए निम्न कार्य करते हुए पेश किया गया है:

ØṖḟ

— जोनाथन एलन
स्रोत

नहीं, तुम कुछ भी याद नहीं किया

— आउटगॉल्फ को एरिक करें

1

चारकोल , 18 15 10 8 बाइट्स

Ｆγ¿¬№θιι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: पूर्णांक के बजाय पात्रों को लेकर 3 बाइट्स सहेजे गए। एक और 5 बाइट्स सहेजे जब मैंने अनडाइग्रेटेड γवैरिएबल की खोज की जो मुद्रण योग्य ASCII वर्ण रखता है। @ ASCII- केवल फिक्स्ड पूर्वनिर्धारित निविष्टियाँ वर्बोज़ मोड में उत्तर देने पर आगे 2 बाइट्स सहेजे गए (इसका उत्तर अभी भी मान्य है क्योंकि यह खड़ा है, यह केवल उस ऑनलाइन लिंक का प्रयास है जो उस समय काम नहीं किया होगा)।

— नील
स्रोत

8 बाइट्स (जब तक कि पहले से तैयार इनपुट्स वापस काम नहीं कर रहे थे)

— केवल

@ ASCII- केवल वे वर्बोज़ मोड में काम नहीं कर रहे थे ... उन्होंने शायद सक्सेस मोड में काम किया होगा, लेकिन मुझे वर्बोज़ लिंक पसंद हैं।

— नील

0

मैथेमेटिका, 35 बाइट्स

20~CharacterRange~126~Complement~#&

अनाम फ़ंक्शन। इनपुट के रूप में वर्णों की एक सूची लेता है और आउटपुट के रूप में वर्णों की एक सूची देता है।

— LegionMammal978
स्रोत

0

लूआ, 78 बाइट्स

s=io.read()for i=32,126 do c=string.char(i)io.write(s:find(c,1,1)and""or c)end

— गप्पी
स्रोत

0

शॉर्ट सी , 33 बाइट्स

i;AOi=31;++i<'~';strchr(*@,i)?:Pi

इस कार्यक्रम में किए गए रूपांतरण:

A -> int main(int argc, char **argv) {
O -> for(
@ -> argv
P -> putchar
ऑटो-डाला बंद ));}

परिणामी कार्यक्रम ऐसा दिखता है:

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

इसे ऑनलाइन आज़माएं!

— एमडी एक्सएफ
स्रोत

0

पायथ , 17 बाइट्स

Vr32 127I!}CNzpCN

भोला दृष्टिकोण।

स्पष्टीकरण:

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

इसे ऑनलाइन टेस्ट करें!

— जिम
स्रोत

0

क्लोजर, 60 या 49 बाइट्स

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

ये "लागू करें" मुझे मार रहे हैं: / ओह, यदि सूची वापस करना ठीक है तो यह थोड़ा कम है।

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

— NikoNyrh
स्रोत

लापता पात्रों को मुद्रित करें

इनपुट

उत्पादन

परीक्षण के मामलों

स्कोरिंग

जीएस 2, 2 बाइट्स

यह काम किस प्रकार करता है

पर्ल 6 , 29 बाइट्स

विस्तारित:

पायथन 3.5 , 39 बाइट्स

जाप , 14 बाइट्स

हास्केल, 32 बाइट्स

हास्केल, 31 बाइट्स

MATL , 5 बाइट्स

ब्रेकीलॉग , 5 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 74 बाइट्स

कोशिश करो

बैश ,४। ४३ 40 बाइट्स

ऑक्टेव, 22 20 बाइट्स

PHP, 42 बाइट्स

PHP, 53 बाइट्स

सीजेएम , 8 बाइट्स

पर्ल, 39 बाइट्स

ब्रेनफक , 120 बाइट्स

ओम , 3 बाइट्स

रूबी, 23 18 17 बाइट्स

एपीएल, 13 बाइट्स

आर , 50 बाइट्स

PHP, 53 बाइट्स

सी #, 74 71 बाइट्स

05AB1E , 5 4 बाइट्स

वी , 20 बाइट्स

सी (जीसीसी) , 75 72 70 68 50 बाइट्स

जेली , 8 बाइट्स

कैसे?

चारकोल , 18 15 10 8 बाइट्स

मैथेमेटिका, 35 बाइट्स

लूआ, 78 बाइट्स

शॉर्ट सी , 33 बाइट्स

पायथ , 17 बाइट्स

स्पष्टीकरण:

क्लोजर, 60 या 49 बाइट्स