सभी ASCII वर्णों की दी गई गणना के साथ

Question

(शीर्षक @ChasBrown के साथ धन्यवाद)

सैंडबॉक्स

पृष्ठ - भूमि

यह चुनौती एक प्रश्न से प्रेरित है जिसे मैंने हाल ही में पज़लिंग स्टैक एक्सचेंज में पोस्ट किया है । यदि आप मूल प्रश्न में रुचि रखते हैं, तो कृपया लिंक का अनुसरण करने के लिए स्वतंत्र महसूस करें। यदि नहीं, तो मैं आपको यहाँ विवरण के साथ बोर नहीं करूँगा।

तथ्यों

प्रत्येक मुद्रण योग्य मानक ASCII वर्ण में 32 और 126 के बीच एक दशमलव मान होता है। इन्हें 100000 से 1111110 की सीमा में उनकी संबंधित बाइनरी संख्या में परिवर्तित किया जा सकता है। जब आप इन बाइनरी संख्याओं के बिट्स का योग करते हैं तो आप हमेशा 1 और 6 समावेशी के बीच पूर्णांक के साथ समाप्त होंगे।

चुनौती

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

उदाहरण / परीक्षण मामले

1 -> ' @'
2 -> '!"$(0ABDHP`'
3 -> '#%&)*,1248CEFIJLQRTXabdhp'
4 -> ''+-.3569:<GKMNSUVYZ\cefijlqrtx'
5 -> '/7;=>OW[]^gkmnsuvyz|'
6 -> '?_ow{}~'

एक ungolfed पायथन संदर्भ कार्यान्वयन यहाँ (TIO) में उपलब्ध है ।

नियम

1. मान लें कि इनपुट हमेशा 1 और 6 समावेशी के बीच पूर्णांक (या पूर्णांक का स्ट्रिंग प्रतिनिधित्व) होगा।
2. आप उन्हें वापस करने के लिए परिणाम या फ़ंक्शन प्रदर्शित करने के लिए एक कार्यक्रम लिख सकते हैं।
3. आउटपुट किसी भी उचित प्रारूप में हो सकता है लेकिन सभी इनपुट के लिए संगत होना चाहिए । यदि आप एक उद्धृत स्ट्रिंग को आउटपुट करने के लिए चुनते हैं तो सभी इनपुट के लिए एक ही प्रकार के उद्धरण का उपयोग किया जाना चाहिए।
4. मानक कमियां हमेशा की तरह निषिद्ध हैं।
5. यह कोड गोल्फ है इसलिए प्रत्येक भाषा में सबसे कम कोड जीतता है।

Comments

क्या हमें दशमलव अस्सी मूल्यों की सूची को वापस करने / प्रिंट करने की अनुमति है या क्या हमें उन्हें पात्रों के रूप में रखने की आवश्यकता है (जैसे। 63बनाम । ?)?

— बेंजामिन अर्कहार्ट

वास्तविक पात्र होने चाहिए।

— एल्प्रेड्रो

"सभी प्रकार के उद्धरणों के लिए एक ही प्रकार का उपयोग किया जाना चाहिए" उदाहरण के लिए, पायथन 'डिफ़ॉल्ट रूप से एक स्ट्रिंग के स्ट्रिंग प्रतिनिधित्व के लिए एकल उद्धरण ( ) का उपयोग करता है, लेकिन दोहरे उद्धरण ( ") का उपयोग करता है यदि स्ट्रिंग में एक एकल उद्धरण और कोई दोहरे उद्धरण नहीं हैं । ऐसा नहीं है कि यह विशिष्ट मामला ज्यादा मायने रखेगा, क्योंकि आप शायद इसके प्रतिनिधित्व के बजाय वास्तविक स्ट्रिंग को वापस करने से बेहतर हैं, और आप अभी भी इनपुट के लिए इस तरह के एक स्ट्रिंग में एकल उद्धरण का उपयोग कर सकते हैं, लेकिन मुझे लगता है कि यह यहां ध्यान देने योग्य है।

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

@EriktheOutgolfer सहमत हुए। इसलिए मैंने सोचा कि यह एक अतिरिक्त नियम के रूप में फेंकना दिलचस्प हो सकता है :-)

— एलपेड्रो

@ElPedro मुझे यकीन नहीं था कि क्या करना है क्योंकि यह शायद कुछ उद्धरणों के लिए एक अच्छा विचार है, क्योंकि पहले उदाहरण में एक जगह है, लेकिन सामान्य उद्धरण दोनों आउटपुट में दिखाई देते हैं :) संपादित करें: शायद फ्रेंच guillemets का उपयोग करें ( « »)? : डी

— दोष

Answer 1

8088 विधानसभा, आईबीएम पीसी डॉस, 35 30 29 बाइट्स

मशीन कोड:

be81 00ad 8afc b330 b108 d0c8 12dd e2fa 3afb 7504 b40e cd10 fec0 79ea c3

लिस्टिंग:

BE 0081     MOV  SI, 081H   ; SI = memory address of command line string
AD          LODSW           ; AL = start ASCII value (init to 20H from space on cmd line)
8A FC       MOV  BH, AH     ; BH = target number of bits (in ASCII)
        CHR_LOOP:
B3 30       MOV  BL, '0'    ; BL = counter of bits, reset to ASCII zero
B1 08       MOV  CL, 8      ; loop through 8 bits of AL
        BIT_LOOP:
D0 C8       ROL  AL, 1      ; rotate LSB of AL into CF
12 DD       ADC  BL, CH     ; add CF to BL (CH is always 0) 
E2 FA       LOOP BIT_LOOP   ; loop to next bit
3A FB       CMP  BH, BL     ; is current char the target number of bits?
75 04       JNE  NO_DISP    ; if not, do not display
B4 0E       MOV  AH, 0EH    ; BIOS write char to screen function
CD 10       INT  10H        ; display ASCII char in AL (current char in loop)
        NO_DISP: 
FE C0       INC  AL         ; increment char to next ASCII value
79 EA       JNS  CHR_LOOP   ; if char <= 127, keep looping
C3          RET             ; return to DOS

स्टैंडअलोन पीसी डॉस निष्पादन कार्यक्रम, कमांड लाइन से इनपुट नंबर। कंसोल विंडो को आउटपुट प्रदर्शित किया जाता है।

डाउनलोड करें और ABCT.COM (AsciiBitCounT) का परीक्षण करें ।

Comments

एक पल के लिए मुझे लगा कि इसने " ABCT.COM पर डाउनलोड और परीक्षण " किया, जैसे कि आपने इस उत्तर के लिए एक डोमेन पंजीकृत किया हो।

— Sparr

Answer 2

CP-1610 असेंबली ( Intellivision ), 20 DECLE ¹ = 25 बाइट्स

R0 में $N$ को लेता है और R4 में आउटपुट बफर को एक पॉइंटर । बफर में सभी मिलान वर्ण लिखते हैं और एनयूएल के साथ परिणामों के अंत को चिह्नित करते हैं ।

                ROMW    10              ; use 10-bit ROM width
                ORG     $4800           ; map this program at $4800

                ;; ------------------------------------------------------------- ;;
                ;;  test code                                                    ;;
                ;; ------------------------------------------------------------- ;;
4800            EIS                     ; enable interrupts

4801            MVII    #$103,    R4    ; set the output buffer at $103 (8-bit RAM)
4803            MVII    #2,       R0    ; test with N = 2
4805            CALL    getChars        ; invoke our routine

4808            MVII    #$103,    R4    ; R4 = pointer into the output buffer
480A            MVII    #$215,    R5    ; R5 = backtab pointer

480C  draw      MVI@    R4,       R0    ; read R0 from the buffer
480D            SLL     R0,       2     ; R0 *= 8
480E            SLL     R0
480F            BEQ     done            ; stop if it's zero

4811            ADDI    #7-256,   R0    ; draw it in white
4815            MVO@    R0,       R5

4816            B       draw            ; go on with the next entry

4818  done      DECR    R7              ; loop forever

                ;; ------------------------------------------------------------- ;;
                ;;  routine                                                      ;;
                ;; ------------------------------------------------------------- ;;
      getChars  PROC

4819            MVII    #32,      R1    ; start with R1 = 32

481B  @loop     MOVR    R1,       R3    ; copy R1 to R3
481C            CLRR    R2              ; clear R2
481D            SETC                    ; start with the carry set

481E  @count    ADCR    R2              ; add the carry to R2
481F            SARC    R3              ; shift R3 to the right (the least
                                        ; significant bit is put in the carry)
4820            BNEQ    @count          ; loop if R3 is not zero

4822            CMPR    R2,       R0    ; if R2 is equal to R0 ...
4823            BNEQ    @next

4825            MVO@    R1,       R4    ; ... write R1 to the output buffer

4826  @next     INCR    R1              ; advance to the next character
4827            CMPI    #127,     R1    ; and loop until 127 is reached
4829            BLT     @loop

482B            MVO@    R3,       R4    ; write NUL to mark the end of the output

482C            JR      R5              ; return

                ENDP

एन = 2 के लिए आउटपुट

नायब: प्रारंभिक कोष्ठक इंटेलीजेंस फ़ॉन्ट में एक उद्घाटन वर्ग ब्रैकेट की तरह दिखता है। हालांकि दोनों ही किरदार अलग हैं।

^{स्क्रीनशॉट jzIntv से}

---

_{1. एक सीपी -1610 ओपकोड को 10-बिट मान के साथ एन्कोड किया गया है, जिसे 'DECLE' के रूप में जाना जाता है। यह दिनचर्या 20 DECLE लंबी है, $ 4819 से शुरू होकर $ 482C (समाहित) पर समाप्त होगी।}

Comments

+1 सिर्फ (ए) इन्टेलिविज़न के लिए एक समाधान है, और (बी) पहला इंटेलीविज़न कोड जो मैंने कभी देखा है।

— आठ-बिट गुरु

@ इंटेलीविजन पर आठ-बिटगुरु कोडिंग काफी मजेदार है। और आज के होमब्रे गेम 16-बिट रॉम में लिखे गए हैं, जो सीपीयू की पूरी शक्ति (अहम ...) को अनलॉक करते हैं। :)

— अरनौलद

प्रभावशाली! नहीं पता था कि Intellivision एक फ्रेम बफर और एक चरित्र सेट में बनाया गया था। यकीन के लिए अटारी 2600 की तुलना में बहुत अधिक उन्नत है। बहुत अच्छी तरह से किया!

— 640KB

@gwaugh ग्रॉस (ग्राफिक्स रॉम के लिए) में सभी मुद्रण योग्य ASCII वर्ण और कुछ सामान्य चित्रमय आकृतियाँ शामिल हैं। मजेदार तथ्य: इसमें कुछ निष्पादन योग्य कोड भी शामिल हैं जो मुख्य रॉम में फिट नहीं थे।

— अरनुलद

निश्चित रूप से 2600 से अधिक उन्नत है, लेकिन यदि मेमोरी काम करती है, तो मैटल ने रोम में छिपे किसी भी उन्नत सामान को प्रकट नहीं किया, इसलिए तीसरे पक्ष के देवता या तो सीधे मशीन कोड तक सीमित थे या अपने दम पर फैंसी सामान को बाहर निकालना था। । एपोक्रिफल हो सकता है।

— ब्राहफ्ल

Answer 3

पायथन 2 , 62 बाइट्स

lambda n:[chr(i)for i in range(32,127)if bin(i).count('1')==n]

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

Comments

sum(map(int,bin(i)[2:]))==nbin(i).count('1')==n7 बाइट्स बचाने के लिए बन सकता है ।

— mypetlion

Answer 4

05AB1E , 8 बाइट्स

žQʒÇbSOQ

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

व्याख्या

žQ        # push the printable ascii characters
  ʒ       # filter, keep elements whose
   Ç      # character code
    b     # converted to binary
     SO   # has a digit sum
       Q  # equal to the input

Answer 5

पर्ल 6 , 41 34 बाइट्स

{chrs grep *.base(2)%9==$_,^95+32}

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

अनाम कोड ब्लॉक जो एक नंबर लेता है और वैध वर्णों का एक स्ट्रिंग लौटाता है।

स्पष्टीकरण:

{                                }  # Anonymous code block taking a number
      grep                ,^95+32   # Filter from the range 32 to 126
           *.base(2)                # Where the binary of the digit
                    %9                # When parsed as a decimal modulo 9
                      ==$_            # Is equal to the input
 chrs                               # And convert the list of numbers to a string

यह साबित किया जा सकता है कि किसी भी संख्या के लिए $n$ आधार में $b$ , $n \equiv \text{digitsum}(n) \pmod{b-1}$ (सुराग: याद रखें कि$b \pmod{b-1}=1$ )।

हम अपने द्विआधारी संख्या के अंक को दशमलव संख्या के रूप में और 9 द्वारा moduloing के रूप में प्राप्त करने के लिए इसका उपयोग कर सकते हैं, जो मान्य है क्योंकि हम जिस संख्या का उपयोग कर रहे हैं वह 9 बिट से कम होने की गारंटी है। जब यह संख्यात्मक संदर्भ में उपयोग किया जाता है, तो यह एक दशमलव संख्या में बाइनरी स्ट्रिंग के पर्ल 6 की स्वचालित कास्टिंग के साथ मदद करता है।

Answer 6

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

ØṖOB§=ʋƇ

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

ØṖ       printable ascii character list
  OB     to binary
    §    popcount
     =   equal to input?
      ʋƇ filter (implicitly output)

Answer 7

जावास्क्रिप्ट (Node.js) , 60 बाइट्स

जो राजा की मोडुलो चाल का उपयोग करना

n=>(g=x=>x>>7?'':Buffer(x.toString(2)%9-n?0:[x])+g(x+1))(32)

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

---

जावास्क्रिप्ट (Node.js) ,  70  69 बाइट्स

n=>(g=x=>x>>7?'':Buffer((h=x=>x&&x%2+h(x>>1))(x)-n?0:[x])+g(x+1))(32)

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

टिप्पणी की गई

n => (              // n = input
  g = x =>          // g = recursive function, taking a byte x
    x >> 7 ?        //   if x = 128:
      ''            //     stop recursion and return an empty string
    :               //   else:
      Buffer(       //     create a Buffer:
        (h = x =>   //       h = recursive function taking a byte x
          x &&      //         stop if x = 0
          x % 2 +   //         otherwise, add the least significant bit
          h(x >> 1) //         and do a recursive call with floor(x / 2)
        )(x)        //       initial call to h
        - n ?       //       if the result is not equal to n:
          0         //         create an empty Buffer (coerced to an empty string)
        :           //       else:
          [x]       //         create a Buffer consisting of the character x
      ) +           //     end of Buffer()
      g(x + 1)      //     append the result of a recursive call to g with x + 1
)(32)               // initial call to g with x = 32

Comments

जोआ के मोडुलो ट्रिक का उपयोग करके 60 बाइट्स ।

— झबरा

@ शगुन ओह। वह अच्छा है।

— Arnauld

Answer 8

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

∈Ṭ&ạhḃ+

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

एक विधेय जो एक जनरेटर के रूप में कार्य करता है , अपने आउटपुट चर के माध्यम से इनपुट लेता है, और अपने इनपुट चर के माध्यम से प्रत्येक चरित्र का उत्पादन करता है। क्योंकि ब्रेजलॉग।

           The input variable (which is an element of the output)
∈          is an element of
 Ṭ         the string containing every printable ASCII character
  &        and the input
   ạh      converted to a codepoint
     ḃ     converted to a list of binary digits
      +    sums to
           the output variable (which is the input).

Answer 9

Japt , 9 बाइट्स

;EƶXc¤è1

यह कोशिश करो या सभी आदानों का परीक्षण करें

;EƶXc¤è1     :Implicit input of integer U
;E            :Printable ASCII
  Æ           :Filter each X
   ¶          :Test U for equality with
    Xc        :  Character code of X
      ¤       :  To binary string
       è1     :  Count the 1s

Answer 10

एक्सेल (2016 या बाद में), 76 बाइट्स

=CONCAT(IF(LEN(SUBSTITUTE(DEC2BIN(ROW(32:126)),0,))=A1,CHAR(ROW(32:126)),""))

A1 से इनपुट लेता है, जिस भी सेल में आप यह फॉर्मूला रखते हैं, उसमें आउटपुट होता है। यह एक सरणी सूत्र है, इसलिए आपको इसे इनपुट करने के लिए Ctrl+ Shift+ दबाना Enterहोगा। "2016 या बाद में" है क्योंकि इसे CONCATफ़ंक्शन की आवश्यकता है (पदावनत CONCATENATEतर्क के रूप में कोई सरणी नहीं लेगा)।

Comments

यह मुझे पंसद है। मैं एक लोटस नोट्स और 123 आदमी हूँ इसलिए यह मेरे लिए काम करता है :-)

— ElPedro

Answer 11

सी (मानक पुस्तकालय), 74 67 बाइट्स

i;j;k;f(n){for(i=31;i<126;k||puts(&i))for(k=n,j=++i;j;j/=2)k-=j&1;}

केवल मानक पुस्तकालय कार्यों का उपयोग करना। धन्यवाद 74 से 67 बाइट्स से सुधार के लिए @gastropner पर जाएं।

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

Comments

67 बाइट्स

— गैस्ट्रोपनर

@gastropner जो एक अद्भुत सुधार है! धन्यवाद!

— क्रिस्टा

मुझे लगता है कि आपको f(1)मामले में जगह लेने के लिए सूचकांक 31 पर शुरू करने की आवश्यकता है (क्योंकि यह ++iस्किप करता है)।

— लाम्बेबेटा

@LambdaBeta आप बिल्कुल सही हैं, धन्यवाद!

— क्रिस्टा

Answer 12

आर , 77 68 बाइट्स

लूप के लिए उपयोग करना दृष्टिकोण

-9 बाइट्स ग्यूसेप के लिए धन्यवाद

n=scan();for(i in 32:126)if(sum(intToBits(i)>0)==n)cat(intToUtf8(i))

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

पहले:

आर , 78 ९ ६ ९ 66 बाइट्स

-12 बाइट्स ग्यूसेप के लिए धन्यवाद

a=32:126;cat(intToUtf8(a[colSums(sapply(a,intToBits)>0)==scan()]))

32 से 126 की संख्या को बिट्स के एक मैट्रिक्स में बदल देता है और फिर उन पंक्तियों में रकम लगाता है जो इनपुट नंबर से मेल खाते हैं।

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

Comments

intToBits(x)>0इसके बजाय का उपयोग करेंas.single

— Giuseppe

अच्छा, मैंने कोशिश की |0और एक त्रुटि मिली और बस यह मान लिया कि तर्क ऑपरेटर काम नहीं करेंगे।

— एरोन हेमैन

66 बाइट्स के sapplyबजाय "पिछले" दृष्टिकोण का उपयोग करते हुएmatrix

— Giuseppe

Answer 13

जावा 10, 98 97 94 70 67 बाइट्स

n->{for(var c='';c-->31;)if(n.bitCount(c)==n)System.out.print(c);}

-24 बाइट्स NahuelFouilleul के लिए धन्यवाद ।

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

स्पष्टीकरण:

इसमें यूनीकोड ​​वैल्यू के साथ एक unprintable कैरेक्टर होता है 127।

n->{                         // Method with Integer parameter and no return-type
  for(var c='';c-->31;)     //  Loop character `c` in the range ['~', ' '] / (127,31):
    if(n.bitCount(c)         //   If the amount of 1-bits in the two's complement binary
                             //   representation of the current characters
                    ==n)     //   equals the input:
      System.out.print(c);}  //    Print the current character

Comments

-24bytes Long.bitCount का उपयोग करते हुए

— नाहुएल फूइउल

@ नाहुएलफौइलुल आह, मैं हमेशा जावा में बने उस भवन के बारे में भूल जाता हूँ! बहुत बहुत धन्यवाद। और 3 और बाइट्स का उपयोग करके बचाया जा सकता है n.bitCount। :)

— केविन क्रूज़सेन

हाँ, जावा एक बार फिर जावास्क्रिप्ट को हरा देता है! मुझे उन चरित्र चुनौतियों से प्यार है: पी

— ओलिवियर ग्रेजायर

Answer 14

जावा 8, 131 71 बाइट्स

-60 बाइट्स सभी को टिप्पणियों में धन्यवाद

देता है java.util.stream.IntStreamकोडपॉइंट्स का रिटर्न देता है

n->java.util.stream.IntStream.range(32,127).filter(i->n.bitCount(i)==n)

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

हैशसेट का उपयोग करते हुए, 135 बाइट्स। एक रिटर्न Set<Object>:

n->new java.util.HashSet(){{for(int i=31;i++<126;add(Long.toBinaryString(i).chars().map(c->c-48).sum()==n?(char)i+"":""),remove(""));}}

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

Comments

128 बाइट्स

— डेटा

गैर-स्थैतिक संदर्भ reeeeeee से स्थैतिक उपयोग। धन्यवाद।

— बेंजामिन अर्कहार्ट

Long.toBinaryString(i) हो सकता है Long.toString(i,2);

— केविन क्रूज़सेन

@ केविनक्रूजसेन कि मेरी पहली टिप्पणी क्या है

— समय सीमा समाप्त 7

@KevinCruijssen तुम सही हो। यहाँ निश्चित संस्करण है: (अभी भी) 71 बाइट्स । और हाँ, मैंने आपके संस्करण को देखा, जिसे मैंने 10 मिनट से भी कम समय पहले उखाड़ दिया था;)

— ओलिवियर ग्राएगेयर

Answer 15

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 86 बाइट्स

n=>Enumerable.Range(32,95).Where(x=>"0123456".Sum(g=>x>>g-48&1)==n).Select(x=>(char)x)

मुझे उपयोग करने के लिए विचार देने के लिए @ExpiredData का धन्यवाद Sum()! जब मैं अपने पीसी पर वापस आऊंगा, तो मैं "0123456"तीन बाइट्स को सहेजते हुए स्ट्रिंग को अनप्रिंटर्सटल्स से बदल दूंगा ।

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

Comments

योग और - गणना के बजाय और ==

— डाटा समय सीमा समाप्त

@ExpiredData उपयोग करने के लिए विचार के लिए धन्यवाद Sum()!

— अज्ञान

Answer 16

Dyalog एपीएल विस्तारित, 24 22 बाइट्स

⎕ucs a⌿⍨⎕=+⌿2⊤a←32…126

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

-2 बाइट्स ngn के लिए धन्यवाद

वैकल्पिक 22 बाइट्स नियमित रूप से Dyalog APL में ngn द्वारा:

⎕ucs 32+⍸⎕=32↓+/↑,⍳7⍴2

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

Comments

(expr )∘=-> ⎕=expr

— ngn

बिना विस्तारित: ⎕ucs 32+⍸⎕=32↓+/↑,⍳7⍴2(←io) 0)

— ngn

Answer 17

पायथन 2 , 69 बाइट्स

lambda n:[chr(i)for i in range(32,127)if sum(map(int,bin(i)[2:]))==n]

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

Comments

जब मैंने अपना रेफ कार्यान्वयन लागू किया, तो ठीक यही मुझे मिला। +1

— ElPedro

Answer 18

गैया , 10 बाइट्स

₵R⟪¤cbΣ=⟫⁇

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

		| implicit input, n
₵R		| push printable ascii
  ⟪	⟫⁇	| filter the list where:
   ¤cbΣ		| the sum of the code point in binary
       =	| is equal to n

Answer 19

जे , ³¹ 27 बाइट्स

-4 बाइट्स गैलेन के लिए धन्यवाद

[:u:32+[:I.]=1#.32#:@+i.@95

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

मूल उत्तर

a.#~&(95{.32}.])]=1#.2#:@i.@^8:

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

• 2#:@i.@^8:255 के माध्यम से बाइनरी नंबर 0 पैदा करता है ( 2 ^ 8256 है)
• 1#. हर एक को कहते हैं
• ]= एक बाइनरी मास्क का उत्पादन करता है जहां योग मूल इनपुट के बराबर होता है
• a.#~ mask J के पूर्ण ascii वर्णमाला को फ़िल्टर करने के लिए उस बाइनरी मास्क का उपयोग करता है a.
• &(95{.32}.]) लेकिन ऐसा करने से पहले केवल 32 ... 126 दोनों वर्णमाला और मुखौटा से तत्व लेते हैं

Comments

[:u:32+[:I.]=1#.32#:@+i.@95 27 बाइट्स के लिए

— गैलेन इवानोव

धन्यवाद गैलेन। TIL आप कर सकते हैंi.@95

— योना

Answer 20

पर्ल 5 -a , 50 43 बाइट्स

@ नाहुएलफौइलुल 7 बाइट बचाता है

map{$_=chr;unpack('B*')%9-"@F"||say}32..126

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

Comments

के "@F"बजाय का उपयोग करके एक बाइट बचा सकता है$F[0]

— नहुएल फोइउलुल

48 बाइट्स

— नहुएल फोइलुल

%9@JoKing द्वारा चाल का उपयोग करके 43 बाइट्स

— नहुएल फौलीउल

Answer 21

K (ngn / k) , 20 बाइट्स

समाधान:

`c$32+&(+/2\32+!95)=

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

स्पष्टीकरण:

मूल्यांकन दाएं-बाएं:

`c$32+&(+/2\32+!95)= / the solution
                   = / equals?
       (          )  / do this together
               !95   / range 0..94
            32+      / add 32, so range 32..126
          2\         / break into base-2
        +/           / sum up
      &              / indices where true
   32+               / add 32
`c$                  / cast to character

Answer 22

6502 विधानसभा (एनईएस), 22 बाइट्स

मशीन कोड:

a0 1f a6 60 c8 98 30 fb ca 0a b0 fc d0 fb e8 d0 f1 8c 07 20 f0 ec

सभा:

    ldy #$1f ; Y holds the current character code
NextCharacter:
    ldx $60 ; load parameter into X
    iny
    tya
    bmi (NextCharacter + 1) ; exit at char 128, #$60 is the return opcode

CountBits:
    dex
Continue:
    asl
    bcs CountBits
    bne Continue

CompareBitCount:
    inx ; fixes off-by-one error and sets Z flag if bit count matches
    bne NextCharacter
    sty $2007
    beq NextCharacter ; always branches

पूरा कार्यक्रम । FCEUX 2.2.3 के साथ परीक्षण किया गया, किसी भी मानक NES एमुलेटर पर काम करना चाहिए।

रेयान रसेल के जवाब से प्रेरित। सीपीयू पते पर दिया गया इनपुट $ 60 है। कंसोल की पिक्चर प्रोसेसिंग यूनिट मेमोरी को आउटपुट देता है।

Comments

नमस्कार और पीपीसीजी में आपका स्वागत है। क्या कारतूस के निर्माण के अलावा आपके समाधान को सत्यापित करने का कोई तरीका है, यानी ऑनलाइन (ऑनलाइन) एमुलेटर या विनिर्देश?

— जोनाथन फ्रीच

@JonathanFrech मैंने एक पूरा कार्यक्रम जोड़ा है जिसे इकट्ठा करके स्थानीय स्तर पर चलाया जा सकता है। जैसा कि मैं समझता हूं, एनईएस पर्यावरण वास्तव में कोडगुल्फ के लिए मानकीकृत नहीं है।

— नकारात्मक सात

Answer 23

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 70 बाइट्स

FromCharacterCode/@Select[32~Range~126,s=#;Tr@IntegerDigits[#,2]==s&]&

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

Answer 24

शक्ति कोशिका , 83 बाइट्स

param($n)[char[]](32..126|?{([convert]::ToString($_,2)|% t*y|group)[1].count-eq$n})

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

इनपुट लेता है $n, उन से एक सीमा बनाता 32है 126और उन नंबरों को निकालता है जहां |?{}: संख्या, आधार में convertएड ; परिवर्तितToString2t oCharArra y; groupएड इन 0एस एंड 1एस; [1]उस समूहन का सूचकांक लेना ; लेने के .countलागू होने, और यह जांच करना कि यह -eqहमारे इनपुट करने के लिए UAL $nभूरा रंग। फिर उन नंबरों को एक char-रे के रूप में डाला जाता है और पाइप लाइन पर छोड़ दिया जाता है। आउटपुट निहित है, तत्वों के बीच नए सिरे से।

Answer 25

रूबी , 48 बाइट्स

->n{(' '..?~).select{|x|x.ord.digits(2).sum==n}}

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

Answer 26

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

Φγ⁼Σ↨℅ι²Ｉθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

 γ          Predefined ASCII characters
Φ           Filtered by
      ι     Current character's
     ℅      ASCII code
    ↨       Converted to base
       ²    Literal 2
   Σ        Summed
  ⁼         Equals
         θ  First input
        Ｉ   Cast to integer
            Implicitly printed

Answer 27

PHP , 72 बाइट्स

for($x=31;$x++<126;)echo$argn==count_chars(decbin($x),1)[49]?chr($x):'';

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

Comments

count_chars(decbin($x),1)[49] बस हो सकता है decbin($x)%9

— जो किंग

Answer 28

लाल , 92 बाइट्स

func[n][repeat k 95[if n = length? replace/all enbase/base c: form #"^_"+ k 2"0"""[prin c]]]

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

Answer 29

संचार पैकेज के साथ ऑक्टेव , 32 बाइट्स

@(n)t(sum(de2bi(t=' ':'~')')==n)

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

Answer 30

फैक्टर , 94 बाइट्स

: f ( n -- n s ) 94 [0,b] [ 32 + 2 >base [ 49 = ] count over = ] filter [ 32 + ] map >string ;

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

Comments

यह आवश्यक व्हाट्सएप की एक प्रभावशाली राशि है

— असंबंधित स्ट्रिंग

@ असंबंधित स्ट्रिंग हां, यह है :)

— गैलेन इवानोव