(Titel mit Dank an @ChasBrown)

Sandkasten

Der Hintergrund

Diese Herausforderung ist von einer Frage inspiriert, die ich kürzlich bei Puzzling Stack Exchange gepostet habe . Bitte folgen Sie dem Link, wenn Sie an der ursprünglichen Frage interessiert sind. Wenn nicht, dann werde ich Sie hier nicht mit den Details langweilen.

Die Fakten

Jedes druckbare Standard-ASCII-Zeichen hat einen Dezimalwert zwischen einschließlich 32 und 126. Diese können in ihre entsprechenden Binärzahlen im Bereich von 100000 bis einschließlich 1111110 konvertiert werden. Wenn Sie die Bits dieser Binärzahlen summieren, erhalten Sie immer eine ganze Zahl zwischen 1 und 6 einschließlich.

Die Herausforderung

Wenn eine ganze Zahl zwischen 1 und 6 als Eingabe angegeben wird, schreiben Sie ein Programm oder eine Funktion, die alle druckbaren Standard-ASCII-Zeichen in einem akzeptablen Format ausgibt, wobei die Summe der Bits ihres Binärwerts gleich der eingegebenen ganzen Zahl ist.

Die Beispiele / Testfälle

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

Eine ungolfed Python-Referenzimplementierung ist hier verfügbar (TIO) .

Die Regeln

1. Angenommen, die Eingabe ist immer eine Ganzzahl (oder eine Zeichenfolgendarstellung einer Ganzzahl) zwischen 1 und einschließlich 6.
2. Sie können ein Programm schreiben, um die Ergebnisse anzuzeigen, oder eine Funktion, um sie zurückzugeben.
3. Die Ausgabe kann in jedem vernünftigen Format erfolgen, muss jedoch für alle Eingaben konsistent sein . Wenn Sie eine Zeichenfolge in Anführungszeichen ausgeben möchten, muss für alle Eingaben derselbe Anführungszeichentyp verwendet werden.
4. Standardlücken wie gewohnt verboten.
5. Dies ist Code Golf, so dass der kürzeste Code in jeder Sprache gewinnt.

8088-Assembly, IBM PC DOS, 35 30 29 Bytes

Maschinensprache:

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

Auflistung:

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

Eigenständiges ausführbares PC-DOS-Programm, Eingabe der Nummer über die Befehlszeile. Die Ausgabe wird im Konsolenfenster angezeigt.

Laden Sie ABCT.COM (AsciiBitCounT) herunter und testen Sie es.

CP-1610- Baugruppe ( Intellivision ), 20 DECLEs ¹ = 25 Byte

Übernimmt $N$ in R0 und einen Zeiger auf den Ausgabepuffer in R4 . Schreibt alle übereinstimmenden Zeichen in den Puffer und markiert das Ende der Ergebnisse mit NUL .

                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

Ausgabe für N = 2

NB: Die öffnende Klammer ähnelt einer öffnenden eckigen Klammer in der Intellivision-Schriftart. Beide Zeichen sind jedoch unterschiedlich.

^{Screenshot von jzIntv}

_{1. Ein CP-1610-Opcode wird mit einem 10-Bit-Wert codiert, der als "DECLE" bezeichnet wird. Diese Routine ist 20 DECLE lang und beginnt bei 4819 USD und endet bei 482 USD (im Lieferumfang enthalten).}

Python 2 , 62 Bytes

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

Probieren Sie es online!

05AB1E , 8 Bytes

žQʒÇbSOQ

Probieren Sie es online!

Erläuterung

ž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

Perl 6 , 41 34 Bytes

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

Probieren Sie es online!

Anonymer Codeblock, der eine Zahl annimmt und eine Zeichenfolge gültiger Zeichen zurückgibt.

Erläuterung:

{                                }  # 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$

Wir können dies verwenden, um das Digitsum unserer Binärzahl zu erhalten, indem wir sie als Dezimalzahl analysieren und mit 9 modulieren. Dies ist gültig, da der von uns verwendete Zahlenbereich garantiert weniger als 9 Bits hat. Dies wird durch die automatische Umwandlung der Binärzeichenfolge in eine Dezimalzahl in Perl 6 in einem numerischen Kontext unterstützt.

Gelee , 8 Bytes

ØṖOB§=ʋƇ

Probieren Sie es online!

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

JavaScript (Node.js) , 60 Byte

Mit Jo Kings Modulo-Trick

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

Probieren Sie es online!

JavaScript (Node.js) ,  70 bis  69 Byte

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

Probieren Sie es online!

Kommentiert

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

Brachylog , 7 Bytes

∈Ṭ&ạhḃ+

Probieren Sie es online!

Ein Prädikat, das als Generator fungiert , Eingaben über seine Ausgabevariable entgegennimmt und jedes Zeichen über seine Eingabevariable erzeugt. Weil Brachylog.

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

Japt , 9 Bytes

;EƶXc¤è1

Probieren Sie es aus oder testen Sie alle Eingaben

;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

Excel (2016 oder höher), 76 Byte

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

Übernimmt die Eingabe von A1 und gibt sie in jeder Zelle aus, in die Sie diese Formel einfügen. Dies ist eine Matrixformel. Sie müssen also Ctrl+ Shift+ drücken, Enterum sie einzugeben. Das "2016 oder später" ist, weil es die CONCATFunktion benötigt (der veraltete CONCATENATEnimmt kein Array als Argument).

C (Standardbibliothek), 74 67 Bytes

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

Verwenden Sie nur Standard-Bibliotheksfunktionen. Danke an @gastropner für die Verbesserung von 74 auf 67 Bytes.

Probieren Sie es online!

R , 77 68 Bytes

Annäherung mit for-Schleife

-9 Bytes dank Giuseppe

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

Probieren Sie es online!

Vorher:

R , 78 69 66 Bytes

-12 Bytes dank Giuseppe

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

Wandelt die Zahlen 32 bis 126 in eine Bitmatrix um und summiert dann über die Zeilen, um herauszufinden, welche mit der eingegebenen Zahl übereinstimmen.

Probieren Sie es online!

Java 10, 98 97 94 70 67 Bytes

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

-24 Bytes dank NahuelFouilleul .

Probieren Sie es online aus.

Erläuterung:

Enthält ein nicht druckbares Zeichen mit Unicode-Wert 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

Java 8, 131 71 Bytes

-60 Bytes danke an alle in den Kommentaren

Gibt eine java.util.stream.IntStreamder Codepunkte zurück

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

Probieren Sie es online!

Mit HashSet 135 Bytes. Rückgabe a 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(""));}}

Probieren Sie es online!

C # (Visual C # Interactive Compiler) , 86 Byte

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

Vielen Dank an @ExpiredData, dass Sie mir die Idee zur Verwendung gegeben haben Sum()! Wenn ich wieder auf meinen PC "0123456"komme, ersetze ich die Zeichenfolge durch nicht druckbare Zeichen und spare drei Bytes.

Probieren Sie es online!

Dyalog APL Extended, 24 22 Bytes

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

Probieren Sie es online!

-2 Bytes dank ngn

Alternative 22 Bytes in der regulären Dyalog APL von ngn:

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

Probieren Sie es online!

Python 2 , 69 Bytes

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

Probieren Sie es online!

Gaia , 10 Bytes

₵R⟪¤cbΣ=⟫⁇

Probieren Sie es online!

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

J , ³¹ 27 Bytes

-4 Bytes dank Galen

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

Probieren Sie es online!

Ursprüngliche Antwort

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

Probieren Sie es online!

• 2#:@i.@^8:erzeugt die Binärzahlen 0 bis 255 ( 2 ^ 8ist 256)
• 1#. summiert jeden
• ]= Erzeugt eine binäre Maske, die anzeigt, wo die Summe der ursprünglichen Eingabe entspricht
• a.#~ mask verwendet diese Binärmaske, um das vollständige ASCII-Alphabet von J zu filtern a.
• &(95{.32}.]) aber bevor Sie dies tun, nehmen Sie nur die Elemente 32 ... 126 aus dem Alphabet und der Maske

Perl 5 -a , 50 43 Bytes

@NahuelFouilleul spart 7 Bytes

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

Probieren Sie es online!

K (ngn / k) , 20 Bytes

Lösung:

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

Probieren Sie es online!

Erläuterung:

Bewertet von rechts nach links:

`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

6502 Assembly (NES), 22 Byte

Maschinensprache:

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

Versammlung:

    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

Volles Programm . Getestet mit FCEUX 2.2.3, sollte auf jedem Standard-NES-Emulator funktionieren.

Inspiriert von Ryan Russells Antwort. Eingabe bei CPU-Adresse $ 60. Ausgabe in den Speicher der Picture Processing Unit der Konsole.

Wolfram Language (Mathematica) , 70 Byte

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

Probieren Sie es online!

PowerShell , 83 Byte

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

Probieren Sie es online!

Nimmt die Eingabe aus $n, erstellt eine Reihe von 32auf 126und zieht jene Zahlen , bei denen |?{}: die Zahl, converted ToStringin der Basis 2; umgewandelt toCharArra y; groupeingeteilt in 0s und 1s; den [1]Index dieser Gruppierung nehmen; Nehmen Sie das .countund überprüfen Sie, -eqob es mit unserer Eingangsnummer übereinstimmt $n. Diese Zahlen werden dann als char-array geworfen und in der Pipeline belassen. Die Ausgabe erfolgt implizit mit Zeilenumbrüchen zwischen Elementen.

Ruby , 48 Bytes

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

Probieren Sie es online!

Kohle , 10 Bytes

Φγ⁼Σ↨℅ι²Ｉθ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

PHP , 72 Bytes

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

Probieren Sie es online!

Rot , 92 Bytes

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

Probieren Sie es online!

Oktave mit Kommunikationspaket, 32 Bytes

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

Probieren Sie es online!

Faktor 94 Bytes

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

Probieren Sie es online!