[Question]
  [
Given an array of positive integers in base 10, where `n > 0`, output their representation of a binary wall.
**How does this work?**
1. Convert each number to it's binary representation.
2. Pad the representation with leading zeroes to the length of the longest one i.e. `1, 2` -> `1, 10` -> `01, 10`.
3. Create a wall where the `1`s are bricks and `0`s are missing bricks.
A wall is a block of characters where any printable character represents a brick and a space (`32`) represents a missing brick. You may choose any character for the brick, it need not be distinct across the wall as long as it isn't a white space character. The missing brick character must be a space. For the example below I have used `*` for the bricks.
**Example**
Input:
```
[ 15, 7, 13, 11 ]
```
1. `[ 1111, 111, 1101, 1011 ]`
2. `[ 1111, 0111, 1101, 1011 ]`
3. Output:
```
****
 ***
** *
* **
```
**Rules**
* Input must be taken in base 10, if your language accepts other bases you may not use them.
* Leading and trailing new lines are allowed.
* Input may be taken as a list of integers, separate arguments or any reasonable format.
* Output may be in any reasonable format: new line separated string, array of lines, 2d array etc.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/questions/1061/standard-loopholes-which-are-no-longer-funny) are disallowed.
**Test Cases**
Note that in the first test case all of layers have an empty brick at the end.
```
[ 14, 4, 6, 2 ]
*** 
 *  
 ** 
  * 
[ 1, 2, 4, 8, 16 ]
    *
   * 
  *  
 *   
*
[ 15, 11, 15, 15 ]
****
* **
****
****
[ 11, 10, 9, 8 ]
* **
* * 
*  *
*   
```
This is code golf so shortest code wins!
  
[Answer]
# [MATL](https://github.com/lmendo/MATL), 5 bytes
```
B42*c
```
[Try it online!](https://tio.run/##y00syfn/38nESCv5//9oQ0MdBUMDHQVLHQWLWAA "MATL – Try It Online")
### Explanation
```
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
```
[Answer]
# [J](http://jsoftware.com/), 8 bytes
```
' *'{~#:
```
[Try it online!](https://tio.run/##FYnLCYAwFMDunSIgWPXk07Z@ii4jFvHiAIKr175LSMidc2JbsXT2/arVmPO4HpqY2npHPBMyIkJEHI7AoFromJGg4fUrvVbRnoU55x8 "J – Try It Online")
## Explanation
```
' *'{~#:  Input: array of integers
      #:  Convert each to binary with left-padding
' *'{~    Use the digits to index into the string ' *'
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
Bo⁶Uz⁶ZUY
```
[Try it online!](https://tio.run/##y0rNyan8/98p/1HjttAqIBEVGvn///9oQ1MdBXMdBUNjIDaMBQA "Jelly – Try It Online")
EDIT: HOW J BEAT JELLY DAT IMPOSSIBLE >\_<
[Answer]
# Octave, 22 bytes
```
@(x)[dec2bin(x)-16,'']
```
[Try it online](https://tio.run/##y08uSSxL/Z9mq6en999Bo0IzOiU12SgpMw/I1DU001FXj/2fphFtaGptbm1obG1oGKv5HwA)
**Explanation:**
Saved some bytes thanks to Luis Mendo! Also, I didn't notice that I could choose which character to build the wall with, not only `*`.
```
@(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.
```
---
Or with `de2bi`:
**Explanation:**
```
@(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),''])
```
---
The following works on TIO, for 7 bytes more:
```
@(x)fliplr([42*(dec2bin(x)>48),''])
```
[Try it here](https://tio.run/##y08uSSxL/Z9mq6en999Bo0Iz2sRISyMlNdkoKTMPyLUzsdDUUVeP/Z@mEW1oam1ubWhsbWgYq/kfAA)
[Answer]
# [Python 3](https://docs.python.org/3/), ~~88 84 71 74~~ 72 bytes
A lambda that returns a list of Strings, representing each line.
```
lambda n:[bin(x)[2:].replace(*'0 ').rjust(len(bin(max(n)))-2)for x in n]
```
[Try it online! (link to the newline separated version)](https://tio.run/##jctBDoIwEIXhvaeYsOmMqQRQjJJwEsqiSIkQGEitST19LXsXLl7e5vu3j3uufA5DrcKsl67XwFXTjYyemqJqU2u2WT8MHkUGglI7vV8OZ8O4m0V7ZCI6FTSsFjyMDNyGzY7sUCgW6bRGNmCTlxLyPG7/siWShvs6Uaw4ocOvYMeZhLuE2x8cIi8kXKKO3RViQuEL "Python 3 – Try It Online")
## Explanation
* `lambda n:` - Creates an (anonymous) lambda, with a parameter `n`. Returns implicitly.
* `[...]` - Creates a list comprehension.
* `bin(x)[2:]` - Gets the binary representations of the numbers.
* `.replace(*'0 ')` - Replaces all the occurrences of `0` with a space.
* `.rjust(len(bin(max(n)))-2)` - Pads the binary representations to the length of the longest one.
* `for x in n` - Iterates through `n`, with the variable `x`.
---
### Changelog
* *-~~1~~ - 3 bytes thanks to @Rod, `-(...)+2` = `2-(...)`, use of `rjust()`*
* ~~Added a version with `bin()` instead, that was invalid since it didn't work for `1` and `2`.~~
* ~~Fixed the bug above using `format()`.~~
* Changed return type to list of Strings, because it was allowed by the OP.
* Fixed yet another bug using `rjust()` and switching back to `bin()`, spotted and fixed by @Rod.
[Answer]
## JavaScript (ES6), ~~81~~ 79 bytes
*Saved 2 bytes by using numbers instead of characters for the bricks, as suggested by Rick Hitchcock*
Returns a 2D array with 1's for the bricks.
```
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)
```
### Test cases
```
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 ])))
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~76~~ ~~75~~ 74 bytes
```
f x|all(<1)x=x>>[""]|a<-f$map(`div`2)x=zipWith(++)a$map(cycle[" ","*"]!!)x
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P02hoiYxJ0fDxlCzwrbCzi5aSSm2JtFGN00lN7FAIyElsyzBCChTlVkQnlmSoaGtrZkIlkmuTM5JjVZSUNJR0lKKVVTUrPifm5iZZ1tQWhJcUqRSmpeTmZdarJIWrWBoqqNgrqNgaAzEhgqx/wE "Haskell – Try It Online")
[Answer]
# Ruby, ~~63~~ 59 bytes
-4 bytes with help from Alexis Andersen
```
->*n{puts n.map{|i|("%#{('%b'%n.max).size}b"%i).tr'0',' '}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf104rr7qgtKRYIU8vN7GguiazRkNJVblaQ101SV0VJFahqVecWZVam6SkmqmpV1KkbqCuo66gXlv7Py3a0FRHwVxHwdAYiA1j/wMA "Ruby – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 87 ~~88~~ bytes
Wall blocks represented by an `8`, because, well lots of eights.
```
write(ifelse((I=sapply(scan(),intToBits))[(M=max(which(I>0,T)[,1])):1,],8,' '),1,M,,'')
```
[Try it online!](https://tio.run/##BcE7CoAwEAXAq6TLLrzC7VTQws7CLp1YBIm44A8TUE8fZ@6cn1tTIF3CFgNR30R/XdtHcfYHMfRI7uw0ReaRhmb3Lz2rziv1bQHHI2RirgUTSlhjGYIBsJaziJHCVKbMPw "R – Try It Online")
Input integer list is converted to array of bits which are trimmed of trailing 0 bits and reversed.
The reduced array is then output using `write` and a column width which was determined when the array was trimmed.
`ifelse()` is the only IF option that works on vectors unfortunately.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~30~~ ~~22~~ ~~20~~ 14 bytes
*Saved 6 bytes thanks to @Adám*
```
' *'[⍉2⊥⍣¯1⊢⎕]
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkGXI862h3/qytoqUc/6u00etS19FHv4kPrDR91LQKqif0PlP7vyKVhaKpgrmBorGBoqMkFFAfqVFfnAombKJgomCkYoYkqGAGFLRQMzdDETYEGKIBIUzQJoKiBgqWChSYA "APL (Dyalog Unicode) – Try It Online")
(assumes `⎕IO←0` as this is default on many machines)
This takes input as an array and returns a matrix with `*`s and s.
### Explanation
```
2⊥⍣¯1⊢⎕       Convert input to binary (returns a transposed matrix of 1s and 0s)
⍉              Transpose
' *'[ ... ]    Index into this string
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 9 bytes
```
bí.Bí»0ð‡
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/6fBaPafDaw/tNji84VHDwv//ow1NdRTMdRQMjYHYMBYA "05AB1E – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 100 bytes
```
$args|%{if(($c=($a=[convert]::ToString($_,2)).length)-gt$l){$l=$c}$a-replace0,' '}|%{$_.padleft($l)}
```
[Try it online!](https://tio.run/##DcxBCoMwEADAr/SwxQRUWpEehLyivRWRkK5RWJIQl/Zg8/bV@zAp/jBvCxKJgM1@@1/3dVYKnFFgzdvF8MXM4zC84pPzGryCqe60bgmD50U3noH0DmTAFbBNxkTW4a2uLlU5M5jaZD@EM6vTFRG599LLQ7oD "PowerShell – Try It Online")
Ugh, `convert`ing to binary in PowerShell is so painful. Plus `.length`y calls to `-replace` the `0` with spaces, plus a long `.padLeft()` call to make them all the same `.length`, all adds up to a long submission.
Golfing suggestions to get below 100 are welcome.
[Answer]
# 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
```
Uses `1` for the brick piece, assumes input comes from table `@`
Ungolfed, with some explanation
```
-- 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
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~77~~ 75 bytes
```
lambda k:[[' *'[i>>y&1]for y in range(len(bin(max(k)))-3,-1,-1)]for i in k]
```
[Try it online!](https://tio.run/##PY1BDoIwEEX3nOKvpDUlsahESeAitYsSQRugEOhCTl/bGkkmmXlvfvLnzb4nk7uuerhBjc1ToS@FSHFMha7r7cBlNy3YoA0WZV4tGVpDGm3IqD6kp5RmZ5ZxPzQGdQj20tl2tSsqiAQQ4BcGPwVDDsl@yt9R3hh4sdurJ/@K@7rbYE4Md5@GTGQSmkJDKItNpc/NizY24g4dCUj/7L4 "Python 2 – Try It Online")
[Answer]
# Mathematica, 40 bytes
```
Grid@PadLeft@IntegerDigits[#,2]/. 0->""&
```
Bricks are 1s
# Mathematica, 48 bytes
```
Grid@PadLeft@IntegerDigits[#,2]/.{0->"",1->"#"}& 
```
Bricks are #
[Answer]
# PHP, 84 bytes
```
while(++$i<$argc)echo strtr(sprintf("\n%".-~log(max($argv),2).b,$argv[$i]),10,"* ");
```
Luckily, the bit operation casts the `log` result to int. float wouldn´t work here.
[Try it online](http://sandbox.onlinephpfunctions.com/code/a51cbe200ffc13107212f264a8520b3501ef05c1).
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 112+18=130 86+41=127 bytes
```
a=>a.Select(n=>C.ToString(n,2).Replace("0"," ").PadLeft(C.ToString(a.Max(),2).Length))
```
[Try it online!](https://tio.run/##vZBPawIxEMXv@ymGPW0gDa79j@4eKm1pqyBa8GA9pHHcBnYTm0RbET/7NuuK9VCKh9KB5PB4M795I@yJ0AbLhZUqg@HKOixYV6r3Vq10kp3W0WqJxrWCQPEC7ZwLhBupuFmNeJ4H6wB8iZxbC32jM8OLrVLrVVnHnRSw1HIKPS5VZJ3xhPEEuMks2fu@O6ra0e8WSrSlcuMJhf1CeY7CSa0su0eFRgr2cKsWBRr@mmO7Hp@mMIMkKHmScjbEqiNSSdphz3q4NUSKNgkb4Dz3iaKwEdIQQsL6fNrFmYsOjJz1@GdEKnsXVebeCCn9OX7Y1t/K6hzZyEiH/pi4y8oetc8dvqiQwixS@OHDryE@p3BJIT71L4YNIaR13NBjfb/CKTQpnFG48vSLf6d7fNygcO35f8ceIJ8@4erQtQnqfxOUXw "C# (.NET Core) – Try It Online")
The byte count includes 41 bytes from `using System.Linq;using C=System.Convert;`. Uses `1` as character for the wall. Nonetheless, this is way too long even for C#...
[Answer]
# [Retina](https://github.com/m-ender/retina), 63 bytes
```
.+
$*#<
+`(#+)\1
$1 
 #
#
{T`<`_`^(<.+(¶|$))+$
m`^<
 <
(.)<
<$1
```
[Try it online!](https://tio.run/##K0otycxL/P9fT5tLRUvZhks7QUNZWzPGkEvFUIFLQZlLmas6JMEmIT4hTsNGT1vj0LYaFU1NbRWu3IQ4Gy4FGy4NPU0bLhsVw///DU24TLjMuIwA "Retina – Try It Online") Explanation:
```
.+
$*#<
```
Convert to unary, and suffix a `<`.
```
+`(#+)\1
$1 
 #
#
```
Convert to binary.
```
{T`<`_`^(<.+(¶|$))+$
```
Once all the `<`s have reached the left, delete them all.
```
m`^<
 <
```
Insert a space before any `<`s that have already reached the left.
```
(.)<
<$1
```
Move all the `<`s left one step. Rinse and repeat.
[Answer]
# 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)))
```
## Ungolfed version:
```
(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)))
```
Anonymous function that takes the argument as a list. Returns the lines as list.
Reading the other answers, I bet it could be smaller. `clojure.string/replace` takes an obscene amount of chars to write..
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~33~~ 30 bytes
```
¡'0p(¡X¤lÃn o)-X¤l)+X¤)£" *"gX
```
[Try it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=oScwcCihWKRsw24gbyktWKRsKStYpCmjIiAqImdY&input=WzE0LDQsNiwyXS1S)
Saved 3 bytes thanks to [@Justin Mariner](https://codegolf.stackexchange.com/users/69583/justin-mariner)
### Explanation
```
¡                              // 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 '*'
```
[Answer]
# [Python 3](https://docs.python.org/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]]
```
[Try it online!](https://tio.run/##NYzBCsIwEAV/5d2yq6loFA8FvyTksNUEF9I0hB7062N7EOY0DFO/63sp197TI8s8vQQyegNzoBwLTVpolg8JMw@7UB4cHxVpaVBo8Xuh7N0YTi3WLM9I5mzsduB/Awmh16ZlpUQel5vFxt3CITD3Hw "Python 3 – Try It Online")
Returns a list of lines. Stacking them up shows they do indeed align properly.
```
['111 ', ' 1  ', ' 11 ', '  1 ']
>>>
 111 
  1  
  11 
   1 
```
# The breakdown
Essentially converts the array to binary, then replaces all 0's with spaces. `N` number of spaces are added to the front of each line where `N = [length of longest line] - [length of line]`.
`-1 bytes` Thanks to Mr. Xoder
[Try it online!](https://tio.run/##NcpBCsIwEEbhq/y7zNRWNIqLQk8Ss5hqggNpGkIXevpoF8JbPb7y2V5rvrQ43VuSZX4KZHQGpqMUMs2aaZE3CTMP@1AeLB8Uca1QaHa7UHZ29McaSpJHoM6cYPgvIN63UjVvFMnhfO3x69bDwjO3Lw "Python 3 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 11 bytes
```
m¤z3 z ·r0S
```
[Try it online!](https://codepen.io/justinm53/full/NvKjZr?code=baR6MyB6ILdyMFM=&inputs=WzE0LCA0LCA2LCAyXQ==,WzEsIDIsIDQsIDgsIDE2XQ==,WzE1LCAxMSwgMTUsIDE1XQ==,WzExLCAxMCwgOSwgOF0=)
## Explanation
```
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
```
[Answer]
# Java 7, ~~130~~ ~~108~~ 88 bytes
Saved 22 thanks to @TheLethalCoder
Saved 20 thanks to @Xanderhall
```
void a(int[]b){for(int i:b)System.out.println(Long.toBinaryString(i).replace('0',' '));}
```
Ungolfed:
```
void a(int[]b){
    for(int i:b)
        System.out.println(Long.toBinaryString(i).replace('0', ' '));       
}
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 98 bytes
```
$p=$args|%{$n=$_;31..0|?{($n-shr$_)%2}}|sort
$args|%{$n=$_;-join($p[-1]..0|%{' *'[($n-shr$_)%2]})}
```
[Try it online!](https://tio.run/##VZHxaoMwEMb/z1McIc4kxFLb2W0MWd@jFBlbtnaIOuPYQPPs7pKo2JDjSy73y3dwTf2rW3PRZTmyD8ihH1mTs9f20wxRz6qcFc/7dLPZDi89Z1ViLi0rRLSzdjB125HbyuSrvlacNackPTsm6mOQ8WkNnq2woyXkyAlRnKeZggcF6R4jFYqTWOKKFUEwqJQQFBMxEcJT9wpwHxTsZgYCA5NOd0wsDBZ76hGtDh4DXMHLF07A8hMEW3eY/8hcmxhOs5t2fXtqdZerdh2yVfCE5gGCBZpN5GzmISJggAh64txZeTWdYvqv0W@dfschsSI8tNr8lB0m7nB2R1fm85RxOr3RRH/TBaWCrkFix38 "PowerShell – Try It Online")
The script uses the fact that an integer contains no more than 32 bits.
The first line calculates positions of the bits with 1. The second line renders a binary wall.
[Answer]
# Python 2, 217 bytes
After 2 hours of coding i decided, that numpy is bad idea for this
```
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()
```
## Usage in Ubuntu
Install numpy
```
python2 -m pip install numpy
```
Create file named `i` with input in format `14 4 6 2`
Run
```
python2 prog.py
```
[Answer]
# [8th](http://8th-dev.com/), ~~232~~ ~~254~~ 250 bytes
**Code**
```
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
```
**Ungolfed version with comments**
```
\ 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 ;
```
These words must be invoked in sequence (see example)
**Usage and examples**
```
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
****
 ***
** *
* **
```
Or more clearly
```
ok> [15,11,15,15] f f1 f2 f3
****
* **
****
****
```
[Answer]
# Pyth, 16 bytes
```
j_MC.tm_X.Bd\0\ 
```
[Try it here.](http://pyth.herokuapp.com/?code=j_MC.tm_X.Bd%5C0%5C+&input=%5B15%2C+7%2C+13%2C+11%5D&debug=0) Mind the trailing space.
[Answer]
# Excel VBA, ~~170~~ 161 Bytes
### Golfed
Anonymous VBE immediate window function that that takes input of format `1 2 3 .. n` from range `[A1]` and outputs the corresponding binary wall to the VBE Immediate window via range `[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
```
Formatted:
```
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
```
### Ungolfed
Full `Sub`routine that takes input of format `Array(1, 2, 3...)` and outputs the corresponding binary wall to the VBE Immediate window via range `[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
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 20 bytes
```
ＷＳ«⸿≔ＩιιＷι«←§ *ι≧÷²ι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/788IzMnVUHDM6@gtCS4pCgzL11DU1OhmoszAMgu0VCKKVLStObidCwuzkzP03BOLC7RyNTUUcgECUL1ZoLVQzVY@aSmlegoOJZ45qWkVmgoKWgpgVSDlHP6JhZAzAnKTM8oAdpZ4pJZlpmSqqNgBDWxlqv2/39DEy4TLjMuI67/umU5AA "Charcoal – Try It Online") Link is to verbose version of code. Works by manually converting each input number to binary but printing it in right-to-left order. I take the input as a newline terminated string as Charcoal doesn't have a good way of inputting lists otherwise I would write something like this which unfortunately currently takes 21 bytes:
```
ＷＳ⊞υＩιＷ⌈υ«Ｅυ﹪κ²↓⸿≧÷²υ
```
[Try it online!](https://tio.run/##Lc0xC4MwEIbhufkVwSmBdKhIh3YqunQQpF27BBVzNCZicloo/e3pCa7fPS/XGj23XtuUVgO25@LuJozPOIMbhJS8wWAEKl7qEAVIeWW7q/UHRhwFEvqyQ0NBpHHacO07tF68Fc/lluzXS@VXp3j2mrNtJHwLAQb3gMFEehwrWKDrqVIcSfxSOhWsYGeWs3Rc7B8 "Charcoal – Try It Online") Link is to verbose version of code. This version vectorises over the input array, although its output is hardcoded to `-`s which saves a byte.
[Answer]
# [K (ngn/k)](https://bitbucket.org/ngn/k), 8 bytes
```
" *"@+2\
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NSklBS8lB2yjmf5q6hqGpgrmCobGCoaG1oYmCiYKZgpG1oYIRkGWhYGhmDZQ2NFQAkabWIIaBgqWCheZ/AA "K (ngn/k) – Try It Online")
Takes input as a list of integers, outputs as a list of strings.
* `2\` convert (implicit input) to base-2 representation
* `+` transpose result
* `" *"@` replace 0's with  and 1's with `*`
]