Dada una matriz de enteros positivos en la base 10, donde n > 0, generan su representación de una pared binaria.

¿Como funciona esto?

1. Convierta cada número en su representación binaria.
2. Rellene la representación con ceros a la longitud del más largo, es decir, 1, 2-> 1, 10-> 01, 10.
3. Crea un muro donde los 1s son ladrillos y 0faltan ladrillos.

Un muro es un bloque de caracteres donde cualquier carácter imprimible representa un ladrillo y un espacio ( 32) representa un ladrillo perdido. Puede elegir cualquier personaje para el ladrillo, no necesita ser distinto a través de la pared siempre que no sea un personaje de espacio en blanco. El personaje de ladrillo que falta debe ser un espacio. Para el siguiente ejemplo, he usado *para los ladrillos.

Ejemplo

Entrada:

[ 15, 7, 13, 11 ]

1. [ 1111, 111, 1101, 1011 ]
2. [ 1111, 0111, 1101, 1011 ]

3. Salida:

   ****
    ***
   ** *
   * **
   

Reglas

• La entrada debe tomarse en la base 10, si su idioma acepta otras bases, no puede usarlas.
• Se permiten nuevas líneas iniciales y finales.
• La entrada puede tomarse como una lista de enteros, argumentos separados o cualquier formato razonable.
• La salida puede estar en cualquier formato razonable: cadena separada por línea nueva, matriz de líneas, matriz 2D, etc.
• Las lagunas estándar no están permitidas.

Casos de prueba

Tenga en cuenta que en el primer caso de prueba, todas las capas tienen un ladrillo vacío al final.

[ 14, 4, 6, 2 ]

*** 
 *  
 ** 
  * 

[ 1, 2, 4, 8, 16 ]

    *
   * 
  *  
 *   
*

[ 15, 11, 15, 15 ]

****
* **
****
****

[ 11, 10, 9, 8 ]

* **
* * 
*  *
*   

Este es el código de golf, ¡el código más corto gana!

MATL , 5 bytes

B42*c

Pruébalo en línea!

Explicación

B     % Implicitly input an array of numbers. Convert to binary. 
      % Gives a matrix with each row corresponding to a number
42    % Push 42 (ASCII code of '*')
*     % Multiply
c     % Convert to char. Char 0 is displayed as space. Implicitly display

J , 8 bytes

' *'{~#:

Pruébalo en línea!

Explicación

' *'{~#:  Input: array of integers
      #:  Convert each to binary with left-padding
' *'{~    Use the digits to index into the string ' *'

Jalea , 9 bytes

Bo⁶Uz⁶ZUY

Pruébalo en línea!

EDITAR: CÓMO J BATE JELLY DAT IMPOSIBLE> _ <

Octava, 22 bytes

@(x)[dec2bin(x)-16,'']

Pruébalo en línea

Explicación:

¡Ahorré algunos bytes gracias a Luis Mendo! Además, no me di cuenta de que podía elegir con qué personaje construir el muro, no solo *.

@(x)                    % Take the input as a column vector
    dec2bin(x)          % Convert each row of the input to a string with 1 and 0
                        % It gets automatically padded with zeros, to fit the longest number
    dec2bin(x)-16       % Subtract 16, to get from the ASCII-values of 1/0 (48/49)
                        % to 32/33 (space and !)
@(x)[dec2bin(x)-16,'']  % Concatenate with the empty string to convert it to a string.

O con de2bi:

Explicación:

@(x)                          % Take the input as a column vector
               de2bi(x)       % Convert each row of the input to a binary number.
                              % Gets automatically padded to fit the longest number
            42*de2bi(x)       % Multiply the matrix by 42, which is the ASCII-value for *
           [42*de2bi(x),'']   % Concatenate the matrix with the empty string to convert
                              % it to a string. 0 are automatically displayed as spaces
@(x)fliplr([42*de2bi(x),''])

Lo siguiente funciona en TIO, para 7 bytes más:

@(x)fliplr([42*(dec2bin(x)>48),''])

Pruébalo aquí

Python 3 , 88 84 71 74 72 bytes

Una lambda que devuelve una lista de cadenas, que representa cada línea.

lambda n:[bin(x)[2:].replace(*'0 ').rjust(len(bin(max(n)))-2)for x in n]

Pruébalo en línea! (enlace a la versión separada de nueva línea)

Explicación

• lambda n:- Crea una lambda (anónima), con un parámetro n. Devuelve implícitamente.

• [...] - Crea una lista de comprensión.

• bin(x)[2:] - Obtiene las representaciones binarias de los números.

• .replace(*'0 ')- Reemplaza todas las ocurrencias de 0con un espacio.

• .rjust(len(bin(max(n)))-2) - Rellena las representaciones binarias a la longitud de la más larga.

• for x in n- Itera a través n, con la variable x.

Registro de cambios

• - 1 - 3 bytes gracias a @Rod, -(...)+2= 2-(...), uso derjust()

• En su bin()lugar, se agregó una versión con , que no era válida ya que no funcionaba para 1y 2.

• Se corrigió el error anterior usando format().

• Se cambió el tipo de retorno a la lista de Cadenas, porque fue permitido por el OP.

• Se corrigió otro error al usar rjust()y volver a bin(), detectado y reparado por @Rod.

JavaScript (ES6), 81 79 bytes

Ahorró 2 bytes usando números en lugar de caracteres para los ladrillos, como lo sugirió Rick Hitchcock

Devuelve una matriz 2D con 1 para los ladrillos.

f=(a,b=[],x=1)=>a.every(n=>n<x)?a.map(n=>b.map(i=>n&i?1:' ')):f(a,[x,...b],x*2)

Casos de prueba

f=(a,b=[],x=1)=>a.every(n=>n<x)?a.map(n=>b.map(i=>n&i?1:' ')):f(a,[x,...b],x*2)

format = a => a.map(s => s.join``).join`\n`

console.log(format(f([ 14, 4, 6, 2 ])))
console.log(format(f([ 1, 2, 4, 8, 16 ])))
console.log(format(f([ 15, 11, 15, 15 ])))
console.log(format(f([ 11, 10, 9, 8 ])))

Haskell , 76 75 74 bytes

f x|all(<1)x=x>>[""]|a<-f$map(`div`2)x=zipWith(++)a$map(cycle[" ","*"]!!)x

Pruébalo en línea!

05AB1E , 9 bytes

bí.Bí»0ð‡

Pruébalo en línea!

Ruby, 63 59 bytes

-4 bytes con ayuda de Alexis Andersen

->*n{puts n.map{|i|("%#{('%b'%n.max).size}b"%i).tr'0',' '}}

Pruébalo en línea!

R , 87 88 bytes

Bloques de pared representados por un 8, pues, muchos ochos.

write(ifelse((I=sapply(scan(),intToBits))[(M=max(which(I>0,T)[,1])):1,],8,' '),1,M,,'')

Pruébalo en línea!

La lista de enteros de entrada se convierte en una matriz de bits que se recortan de 0 bits finales y se invierten.

La matriz reducida se emite con writeun ancho de columna que se determinó cuando se recortó la matriz.

ifelse() es la única opción IF que funciona en vectores desafortunadamente.

Python 2 , 77 bytes

lambda k:[[' *'[i&2**y>0]for y in range(len(bin(max(k)))-3,-1,-1)]for i in k]

Pruébalo en línea!

APL (Dyalog) , 30 22 20 14 bytes

Guardado 6 bytes gracias a @ Adám

' *'[⍉2⊥⍣¯1⊢⎕]

Pruébalo en línea!

(se supone ⎕IO←0que esto es predeterminado en muchas máquinas)

Esto toma la entrada como una matriz y devuelve una matriz con *sy s.

Explicación

2⊥⍣¯1⊢⎕       Convert input to binary (returns a transposed matrix of 1s and 0s)
⍉              Transpose
' *'[ ... ]    Index into this string

T-SQL, 290 bytes

declare @ int;select @=max(log(a,2))+1from @i;with t as(select convert(varchar(max),a%2)b,a/2c,@-1m,ROW_NUMBER()over(order by(select 1))r from @i union all select convert(varchar(max),concat(c%2,b))b,c/2c,m-1,r from t where m>0)select replace(b,0,' ')from t where m=0group by r,b order by r

Usos 1para la pieza de ladrillo, supone que la entrada proviene de la tabla@

Ungolfed, con alguna explicación

-- assume input is presented in an input table
declare @input table (a int)
insert into @input values (15), (7), (13), (11)

---- start here

-- figure out how many characters are needed, by taking log2
declare @max int
select @max = max(log(a, 2)) + 1
from @input

-- recursive cte
-- will join against itself, recursively finding each digit in the binary string
;with cte as
(
    select 
        convert(varchar(max), a % 2) as b, -- is the least significant bit 1 or 0
        a / 2 as c, -- remove least significant bit, for the next run
        @max - 1 as max, -- keep track of iterations left
        ROW_NUMBER() over (order by (select 1)) as rn -- keep the order of the input
    from @input

    union all -- recursive loop
              -- below columns follow the same pattern

    select convert(varchar(max), 
        concat(cte.c % 2, cte.b)) as b, -- prepend the current binary string with the newest least significant bit
        cte.c / 2 as c, 
        cte.max - 1, 
        cte.rn
    from cte
    where cte.max > 0
)
select replace(b, 0, ' ') -- swap 0s for space
from cte
where max = 0 -- only take the last iteration
group by rn, b -- grab each unique input, 
               -- need to group by row number so it can be ordered by
               -- need to group by binary string, so it can be selected
order by rn -- sort by the order the input arrived in

Mathematica, 40 bytes

Grid@PadLeft@IntegerDigits[#,2]/. 0->""&

Los ladrillos son 1s

Mathematica, 48 bytes

Grid@PadLeft@IntegerDigits[#,2]/.{0->"",1->"#"}& 

Los ladrillos son #

C # (.NET Core) , 112 + 18 = 130 86 + 41 = 127 bytes

a=>a.Select(n=>C.ToString(n,2).Replace("0"," ").PadLeft(C.ToString(a.Max(),2).Length))

Pruébalo en línea!

El recuento de bytes incluye 41 bytes de using System.Linq;using C=System.Convert;. Usos 1como personaje para el muro. Sin embargo, esto es demasiado tiempo incluso para C # ...

Retina , 63 bytes

.+
$*#<
+`(#+)\1
$1 
 #
#
{T`<`_`^(<.+(¶|$))+$
m`^<
 <
(.)<
<$1

Pruébalo en línea! Explicación:

.+
$*#<

Convertir a unario y sufijo a <.

+`(#+)\1
$1 
 #
#

Convierte a binario.

{T`<`_`^(<.+(¶|$))+$

Una vez que todos los <s hayan alcanzado la izquierda, elimínelos a todos.

m`^<
 <

Inserte un espacio antes de cualquier <s que ya haya llegado a la izquierda.

(.)<
<$1

Mueve todos los <s a la izquierda un paso. Enjuague y repita.

PowerShell , 100 bytes

$args|%{if(($c=($a=[convert]::ToString($_,2)).length)-gt$l){$l=$c}$a-replace0,' '}|%{$_.padleft($l)}

Pruébalo en línea!

Ugh, convertbinario en PowerShell es muy doloroso. Además de .lengthllamadas Y a -replacela 0con espacios, además de una larga .padLeft()llamada para que sean todos iguales .length, todo suma a una larga presentación.

Las sugerencias de golf para llegar a menos de 100 son bienvenidas.

PHP, 84 bytes

while(++$i<$argc)echo strtr(sprintf("\n%".-~log(max($argv),2).b,$argv[$i]),10,"* ");

Afortunadamente, la operación de bits arroja el logresultado a int. flotador no funcionaría aquí.

Pruébalo en línea .

Clojure, 185 bytes

(fn[i](let[b(map #(Long/toBinaryString %)i)](map #(clojure.string/replace(clojure.string/replace(format(str"%0"(reduce(fn[l i](max l(count i)))0 b)"d")(read-string %))"1""#")"0"" ")b)))

Versión sin golf:

(fn [i]
    (let [b (map #(Long/toBinaryString %) i)]
        (map
            #(clojure.string/replace
                (clojure.string/replace
                    (format
                        (str "%0"
                            (reduce
                                (fn [l i] (max l(count i))) 0 b)
                            "d")
                        (read-string %))
                        "1"
                        "#")
                "0"
                " ")
        b)))

Función anónima que toma el argumento como una lista. Devuelve las líneas como lista.

Leyendo las otras respuestas, apuesto a que podría ser más pequeño. clojure.string/replacetoma una cantidad obscena de caracteres para escribir ...

Japt , 33 30 bytes

¡'0p(¡X¤lÃn o)-X¤l)+X¤)£" *"gX

Pruébalo en línea!

Guardado 3 bytes gracias a @Justin Mariner

Explicación

¡                              // map input integers
    (¡X¤lÃn o)                 // longest binary string length
              -X¤l)            // minus current binary string length
 '0p                           // repeat zero
                   +X¤)        // concat with current binary string
                       £       // map chars of binary string
                        " *"gX // swap 0 and 1 with ' ' and '*'

Python 3 , 92 90 bytes

lambda a:[' '*(len(bin(max(a)))-len(i)-2)+i for i in[bin(i)[2:].replace(*'0 ')for i in a]]

Pruébalo en línea!

Devuelve una lista de líneas. Apilarlos muestra que realmente se alinean correctamente.

['111 ', ' 1  ', ' 11 ', '  1 ']
>>>
 111 
  1  
  11 
   1 

La caida

Esencialmente convierte la matriz a binario, luego reemplaza todos los 0 con espacios. Nnúmero de espacios se agregan al frente de cada línea donde N = [length of longest line] - [length of line].

-1 bytes Gracias al señor Xoder

Pruébalo en línea!

Japt , 11 bytes

m¤z3 z ·r0S

Pruébalo en línea!

Explicación

m¤z3 z ·r0S  Implicit input of array
m¤           Map the array to binary strings
  z3 z       Rotate right 270° and then right 90°. This adds left padding to each string
       ·r0S  Join with newlines and replace 0s with spaces

Java 7, 130 108 88 bytes

Guardado 22 gracias a @TheLethalCoder Guardado 20 gracias a @Xanderhall

void a(int[]b){for(int i:b)System.out.println(Long.toBinaryString(i).replace('0',' '));}

Sin golf:

void a(int[]b){
    for(int i:b)
        System.out.println(Long.toBinaryString(i).replace('0', ' '));       
}

Python 2, 217 bytes

Después de 2 horas de codificación decidí que ese numpy es una mala idea para esto

import numpy as n
i=n.loadtxt("i")
o=[n.copy(i)]
o[0].fill(10)
while n.count_nonzero(i)>0:
 o.append(i%2+32)
 i=n.vectorize(lambda x:x//2)(i)
print n.fliplr(n.array(o).T).astype('uint8').view('c').tostring().decode()

Uso en Ubuntu

Instalar numpy

python2 -m pip install numpy

Crear archivo nombrado icon entrada en formato14 4 6 2

correr

python2 prog.py

8 ° , 232 254 250 bytes

Código

0 >r a:new swap ( nip 2 base drop >s decimal s:len r> n:max >r a:push ) a:each drop a:new swap ( nip '0 G:c# r@ G:#> s:fmt a:push ) a:each drop rdrop a:new swap ( nip /0/ " " s:replace! a:push ) a:each drop ( nip /1/ "*" s:replace! . cr ) a:each drop

Versión sin golf con comentarios

\ convert to binary and save longest string length
: f 0 >r a:new swap ( nip 2 base drop >s decimal s:len r> n:max >r a:push ) a:each drop ;

\ pad binary number with zero
: f1 a:new swap ( nip '0 G:c# r@ G:#> s:fmt a:push ) a:each drop rdrop ;

\ replace every 0 with space
: f2 a:new swap ( nip /0/ " " s:replace! a:push ) a:each drop ;

\ replace every 1 with * and print each line of bricks
: f3 ( nip /1/ "*" s:replace! . cr ) a:each drop ;

Estas palabras deben invocarse en secuencia (ver ejemplo)

Uso y ejemplos

ok> [15,7,13,11] 0 >r a:new swap ( nip 2 base drop >s decimal s:len r> n:max >r a:push ) a:each drop a:new swap ( nip '0 G:c# r@ G:#> s:fmt a:push ) a:each drop rdrop a:new swap ( nip /0/ " " s:replace! a:push ) a:each drop ( nip /1/ "*" s:replace! . cr ) a:each drop
****
 ***
** *
* **

O más claramente

ok> [15,11,15,15] f f1 f2 f3
****
* **
****
****

Pyth, 16 bytes

j_MC.tm_X.Bd\0\ 

Pruébalo aquí. Cuidado con el espacio final.

Excel VBA, ₁₇₀ 161 Bytes

Golfed

Función de ventana inmediata anónima de VBE que toma la entrada del formato 1 2 3 .. ndel rango [A1]y emite la pared binaria correspondiente a la ventana VBE Inmediata a través del rango[B1,C1,2:2]

n=Split([A1]):[A2].Resize(1,UBound(n)+1)=n:[C1]="=Int(1+Log(B1,2))":For Each i In n:[B1]=i:?Replace(Replace([Right(Rept(0,C1)&Dec2Bin(B1),C1)],1,"*"),0," "):Next

Formateado:

n=Split([A1])
[A2].Resize(1,UBound(n)+1)=n
[C1]="=Int(1+Log(B1,2))"
For Each i In n
[B1]=i
?Replace(Replace([Right(Rept(0,C1)&Dec2Bin(B1),C1)],1,"*"),0," ")
Next

Sin golf

SubRutina completa que toma la entrada de formato Array(1, 2, 3...)y emite el muro binario correspondiente a la ventana VBE Inmediato a través del rango[A1,B1,2:2]

Sub a(ByRef n As Variant)
    Let Range("A1").Resize(1,UBound(n)+1) = n
    Let Range("C1").Value = "=Int(1+Log(A1,2))"
    Dim i As Integer
    For Each i In n
        Let Range("A1").Value = i
        Debug.Print Replace(
                            Replace(
                                    [Right( Rept( 0, C1) & Dec2Bin( B1), C1)],
                                    1,
                                    "*"
                            ),
                            0,
                            " "
                    )
    Next
End Sub

Carbón de leña , 20 bytes

ＷＳ«⸿≔ＩιιＷι«←§ *ι≧÷²ι

Pruébalo en línea! El enlace es a la versión detallada del código. Funciona convirtiendo manualmente cada número de entrada a binario pero imprimiéndolo en orden de derecha a izquierda. Tomo la entrada como una cadena terminada en nueva línea, ya que el carbón no tiene una buena manera de ingresar listas, de lo contrario, escribiría algo como esto, que desafortunadamente actualmente toma 21 bytes:

ＷＳ⊞υＩιＷ⌈υ«Ｅυ﹪κ²↓⸿≧÷²υ

Pruébalo en línea! El enlace es a la versión detallada del código. Esta versión se vectoriza sobre la matriz de entrada, aunque su salida está codificada en -s, lo que ahorra un byte.