(Título con agradecimiento a @ChasBrown)

Salvadera

El fondo

Este desafío está inspirado en una pregunta que publiqué recientemente en Puzzling Stack Exchange . Siéntase libre de seguir el enlace si está interesado en la pregunta original. Si no, no te aburriré con los detalles aquí.

Los hechos

Cada carácter ASCII estándar imprimible tiene un valor decimal entre 32 y 126 inclusive. Estos se pueden convertir a sus números binarios correspondientes en el rango de 100000 a 1111110 inclusive. Cuando sumas los bits de estos números binarios, siempre terminarás con un número entero entre 1 y 6 inclusive.

El reto

Dado un entero entre 1 y 6 inclusive como entrada, escriba un programa o función que genere en cualquier formato aceptable todos los caracteres ASCII estándar imprimibles donde la suma de los bits de su valor binario sea igual al entero de entrada.

Los ejemplos / casos de prueba

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

Aquí está disponible una implementación de referencia de Python no protegida (TIO) .

Las normas

1. Suponga que la entrada siempre será un número entero (o representación de cadena de un número entero) entre 1 y 6 inclusive.
2. Puede escribir un programa para mostrar los resultados o una función para devolverlos.
3. La salida puede estar en cualquier formato razonable pero debe ser consistente para todas las entradas . Si elige generar una cadena entre comillas, se debe utilizar el mismo tipo de comillas para todas las entradas.
4. Lagunas estándar prohibidas como de costumbre.
5. Este es el código de golf, por lo que gana el código más corto en cada idioma.

8088 ensamblado, IBM PC DOS, 35 30 29 bytes

Codigo de maquina:

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

Listado:

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

Programa ejecutable PC DOS independiente, ingrese el número desde la línea de comandos. La salida se muestra en la ventana de la consola.

Descargue y pruebe ABCT.COM (AsciiBitCounT).

Conjunto CP-1610 ( Intellivision ), 20 DECLE ¹ = 25 bytes

Toma $N$ enR0y un puntero al búfer de salida enR4. Escribe todos los caracteres coincidentes en el búfer y marca el final de los resultados conNUL.

                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

Salida para N = 2

NB: El paréntesis de apertura se parece mucho a un corchete de apertura en la fuente Intellivision. Sin embargo, ambos personajes son distintos.

^{captura de pantalla de jzIntv}

_{1. Un código de operación CP-1610 está codificado con un valor de 10 bits, conocido como 'DECLE'. Esta rutina tiene una duración de 20 DECLE, desde $ 4819 hasta $ 482C (incluida).}

Python 2 , 62 bytes

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

Pruébalo en línea!

05AB1E , 8 bytes

žQʒÇbSOQ

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Bloque de código anónimo que toma un número y devuelve una cadena de caracteres válidos.

Explicación:

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

Se puede demostrar que para cualquier número $n$ en la base $b$ , $n \equiv \text{digitsum}(n) \pmod{b-1}$ (pista: recuerda que$b \pmod{b-1}=1$ ).

Podemos usar esto para obtener el dígito de nuestro número binario analizándolo como un número decimal y modulando por 9, lo cual es válido porque el rango de números que estamos utilizando tiene una garantía de menos de 9 bits. Esto se ve ayudado por la conversión automática de Perl 6 de la cadena binaria a un número decimal cuando se usa en un contexto numérico.

Jalea , 8 bytes

ØṖOB§=ʋƇ

Pruébalo en línea!

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

JavaScript (Node.js) , 60 bytes

Usando el truco del módulo de Jo King

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

Pruébalo en línea!

JavaScript (Node.js) ,  70  69 bytes

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

Pruébalo en línea!

Comentado

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ḃ+

Pruébalo en línea!

Un predicado que funciona como un generador , toma la entrada a través de su variable de salida y produce cada carácter a través de su variable de entrada. Porque 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

Pruébalo o prueba todas las entradas

;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 posterior), 76 bytes

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

Toma entradas de A1, salidas en cualquier celda en la que coloque esta fórmula. Esta es una fórmula de matriz, por lo que debe presionar Ctrl+ Shift+ Enterpara ingresarla. El "2016 o posterior" se debe a que necesita la CONCATfunción (el obsoleto CONCATENATEno tomará una matriz como argumento).

C (biblioteca estándar), 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;}

Usando solo funciones de biblioteca estándar. Gracias a @gastropner por mejorar de 74 a 67 bytes.

Pruébalo en línea!

R , 77 68 bytes

Enfoque utilizando para bucle

-9 bytes gracias a Giuseppe

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

Pruébalo en línea!

Previamente:

R , 78 69 66 bytes

-12 bytes gracias a Giuseppe

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

Convierte los números 32 a 126 en una matriz de bits y luego suma a través de las filas para encontrar cuál coincide con el número de entrada.

Pruébalo en línea!

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 gracias a NahuelFouilleul .

Pruébalo en línea.

Explicación:

Contiene un carácter no imprimible con valor 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 bytes

-60 bytes gracias a todos en los comentarios

Devuelve un java.util.stream.IntStreamcódigo de

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

Pruébalo en línea!

Usando HashSet, 135 bytes. Devuelve 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(""));}}

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 86 bytes

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

¡Gracias a @ExpiredData por darme la idea de usar Sum()! Cuando vuelva a mi PC, reemplazaré la cadena "0123456"por no imprimibles, ahorrando tres bytes.

Pruébalo en línea!

Dyalog APL Extended, 24 22 bytes

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

Pruébalo en línea!

-2 bytes gracias a ngn

Alternativa de 22 bytes en Dyalog APL regular por ngn:

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

Pruébalo en línea!

Python 2 , 69 bytes

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

Pruébalo en línea!

Gaia , 10 bytes

₵R⟪¤cbΣ=⟫⁇

Pruébalo en línea!

		| 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 gracias a Galen

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

Pruébalo en línea!

Respuesta original

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

Pruébalo en línea!

• 2#:@i.@^8:produce los números binarios del 0 al 255 ( 2 ^ 8es 256)
• 1#. suma cada uno
• ]= produce una máscara binaria que muestra dónde la suma es igual a la entrada original
• a.#~ mask usa esa máscara binaria para filtrar el alfabeto ascii completo de J a.
• &(95{.32}.]) pero antes de hacerlo, tome solo los elementos 32 ... 126 del alfabeto y la máscara

Perl 5 -a , 50 43 bytes

@NahuelFouilleul ahorra 7 bytes

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

Pruébalo en línea!

K (ngn / k) , 20 bytes

Solución:

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

Pruébalo en línea!

Explicación:

Evaluado de derecha a izquierda:

`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

Conjunto 6502 (NES), 22 bytes

Codigo de maquina:

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

Montaje:

    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

Programa completo . Probado con FCEUX 2.2.3, debería funcionar en cualquier emulador NES estándar.

Inspirado por la respuesta de Ryan Russell. Entrada dada en la dirección de la CPU $ 60. Salidas a la memoria de la unidad de procesamiento de imágenes de la consola.

Wolfram Language (Mathematica) , 70 bytes

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

Pruébalo en línea!

PowerShell , 83 bytes

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

Pruébalo en línea!

Toma entrada $n, construye un rango de32 a 126y saca esos números donde |?{}: el número, converted ToStringen la base 2; toCharArra convertido y; grouped en 0sy 1s; tomando el [1]índice de esa agrupación; tomando el .countmismo y verificando que sea -equal para nuestro número de entrada $n. Esos números se lanzan como una charmatriz y se dejan en la tubería. La salida es implícita, con nuevas líneas entre elementos.

Ruby , 48 bytes

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

Pruébalo en línea!

Carbón , 10 bytes

Φγ⁼Σ↨℅ι²Ｉθ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 γ          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):'';

Pruébalo en línea!

Rojo , 92 bytes

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

Pruébalo en línea!

Octava con paquete de comunicaciones, 32 bytes

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

Pruébalo en línea!

Factor , 94 bytes

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

Pruébalo en línea!