(Titolo con grazie a @ChasBrown)

sandbox

Lo sfondo

Questa sfida è ispirata a una domanda che ho pubblicato di recente su Puzzling Stack Exchange . Non esitate a seguire il link se siete interessati alla domanda originale. In caso contrario, non ti annoierò con i dettagli qui.

I fatti

Ogni carattere ASCII standard stampabile ha un valore decimale compreso tra 32 e 126 inclusi. Questi possono essere convertiti nei corrispondenti numeri binari nell'intervallo compreso tra 100000 e 1111110 inclusi. Quando sommi i bit di questi numeri binari, finirai sempre con un numero intero compreso tra 1 e 6 inclusi.

La sfida

Dato un numero intero compreso tra 1 e 6 compreso come input, scrivere un programma o una funzione che genererà in qualsiasi formato accettabile tutti i caratteri ASCII standard stampabili in cui la somma dei bit del loro valore binario è uguale al numero intero di input.

Gli esempi / casi di test

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

Un'implementazione di riferimento Python non golfata è disponibile qui (TIO) .

Le regole

1. Supponiamo che l'input sia sempre un numero intero (o rappresentazione in stringa di un numero intero) compreso tra 1 e 6 inclusi.
2. È possibile scrivere un programma per visualizzare i risultati o una funzione per restituirli.
3. L'output può essere in qualsiasi formato ragionevole ma deve essere coerente per tutti gli input . Se si sceglie di generare una stringa tra virgolette, è necessario utilizzare lo stesso tipo di virgolette per tutti gli input.
4. Scappatoie standard vietate come al solito.
5. Questo è il codice golf, quindi vince il codice più breve in ogni lingua.

8088 assembly, IBM PC DOS, 35 30 29 byte

Codice macchina:

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

annuncio:

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

Programma eseguibile DOS per PC autonomo, immettere il numero dalla riga di comando. L'output viene visualizzato nella finestra della console.

Scarica e prova ABCT.COM (AsciiBitCounT).

Assemblaggio CP-1610 ( Intellivision ), 20 DECLE ¹ = 25 byte

Prende $N$ in R0 e un puntatore al buffer di output in R4 . Scrive tutti i caratteri corrispondenti nel buffer e segna la fine dei risultati con 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

Uscita per N = 2

NB: la parentesi di apertura assomiglia molto a una parentesi quadra di apertura nel carattere Intellivision. Entrambi i personaggi sono tuttavia distinti.

^{screenshot da jzIntv}

_{1. Un codice operativo CP-1610 è codificato con un valore di 10 bit, noto come "DECLE". Questa routine è lunga 20 DECLE, a partire da $ 4819 e termina a $ 482C (incluso).}

Python 2 , 62 byte

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

Provalo online!

05AB1E , 8 byte

žQʒÇbSOQ

Provalo online!

Spiegazione

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

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

Provalo online!

Blocco di codice anonimo che accetta un numero e restituisce una stringa di caratteri validi.

Spiegazione:

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

Possiamo usarlo per ottenere il digititsum del nostro numero binario analizzandolo come un numero decimale e modellandolo per 9, il che è valido perché l'intervallo di numeri che stiamo usando è garantito avere meno di 9 bit. Questo è aiutato dal casting automatico di Perl 6 della stringa binaria su un numero decimale quando usato in un contesto numerico.

Gelatina , 8 byte

ØṖOB§=ʋƇ

Provalo online!

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

JavaScript (Node.js) , 60 byte

Usando il trucco del modulo di Jo King

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

Provalo online!

JavaScript (Node.js) ,  70  69 byte

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

Provalo online!

Commentate

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 byte

∈Ṭ&ạhḃ+

Provalo online!

Un predicato che funziona come un generatore , accetta l'input attraverso la sua variabile di output e produce ogni carattere attraverso la sua variabile di input. Perché 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 byte

;EƶXc¤è1

Provalo o prova tutti gli ingressi

;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 o successivo), 76 byte

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

Prende input da A1, output in qualunque cella metti questa formula. Questa è una formula di matrice, quindi è necessario premere Ctrl+ Shift+ Enterper inserirlo. "2016 o successivo" è perché ha bisogno della CONCATfunzione (il deprecato CONCATENATEnon prenderà un array come argomento).

C (libreria standard), 74 67 byte

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

Utilizzando solo le funzioni di libreria standard. Grazie a @gastropner per il miglioramento da 74 a 67 byte.

Provalo online!

R , 77 68 byte

Approccio usando per loop

-9 byte grazie a Giuseppe

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

Provalo online!

In precedenza:

R , 78 69 66 byte

-12 byte grazie a Giuseppe

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

Trasforma i numeri da 32 a 126 in una matrice di bit, quindi somma le righe per trovare la corrispondenza con il numero di input.

Provalo online!

Java 10, 98 97 94 70 67 byte

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

-24 byte grazie a NahuelFouilleul .

Provalo online.

Spiegazione:

Contiene un carattere non stampabile con valore unicode 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 byte

-60 byte grazie a tutti nei commenti

Restituisce un punto java.util.stream.IntStreamdi codice

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

Provalo online!

Utilizzando HashSet, 135 byte. Restituisce un 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(""));}}

Provalo online!

C # (compilatore interattivo Visual C #) , 86 byte

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

Grazie a @ExpiredData per avermi dato l'idea di usare Sum()! Quando torno sul mio PC, sostituirò la stringa "0123456"con non stampabili, risparmiando tre byte.

Provalo online!

Dyalog APL esteso, 24 22 byte

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

Provalo online!

-2 byte grazie a ngn

22 byte alternativi in ​​Dyalog APL normale di ngn:

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

Provalo online!

Python 2 , 69 byte

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

Provalo online!

Gaia , 10 byte

₵R⟪¤cbΣ=⟫⁇

Provalo 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 byte

-4 byte grazie a Galeno

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

Provalo online!

Risposta originale

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

Provalo online!

• 2#:@i.@^8:produce i numeri binari da 0 a 255 ( 2 ^ 8è 256)
• 1#. somma ciascuno
• ]= produce una maschera binaria che mostra dove la somma è uguale all'input originale
• a.#~ mask usa quella maschera binaria per filtrare l'intero alfabeto ASCII di J. a.
• &(95{.32}.]) ma prima di farlo prendi solo gli elementi 32 ... 126 sia dall'alfabeto che dalla maschera

Perl 5 -a , 50 43 byte

@NahuelFouilleul salva 7 byte

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

Provalo online!

K (ngn / k) , 20 byte

Soluzione:

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

Provalo online!

Spiegazione:

Valutato da destra a sinistra:

`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

Codice macchina:

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

Montaggio:

    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

Programma completo . Testato con FCEUX 2.2.3, dovrebbe funzionare su qualsiasi emulatore NES standard.

Ispirato dalla risposta di Ryan Russell. Input fornito all'indirizzo della CPU $ 60. Emette nella memoria della Picture Processing Unit della console.

Wolfram Language (Mathematica) , 70 byte

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

Provalo online!

PowerShell , 83 byte

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

Provalo online!

Prende input $n, costruisce un intervallo da 32a 126ed estrae quei numeri dove |?{}: il numero, converted ToStringin base 2; convertito toCharArra y; groupEd in 0s e 1s; prendendo l' [1]indice di quel raggruppamento; prendendone la .countcausa e verificando che sia -eqnormale per il nostro input $number. Quei numeri vengono quindi lanciati come un chararray e lasciati sulla pipeline. L'output è implicito, con nuove righe tra gli elementi.

Rubino , 48 byte

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

Provalo online!

Carbone , 10 byte

Φγ⁼Σ↨℅ι²Ｉθ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

 γ          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 byte

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

Provalo online!

Rosso , 92 byte

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

Provalo online!

Ottava con pacchetto di comunicazioni, 32 byte

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

Provalo online!

Fattore , 94 byte

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

Provalo online!