밑이 10 인 양의 정수가 주어지면, n > 0이진 벽의 표현을 출력합니다.

어떻게 작동합니까?

1. 각 숫자를 이진 표현으로 변환하십시오.
2. 가장 긴 길이 (예 : 1, 2-> 1, 10->)에 선행 0을 사용하여 표시를 채 웁니다 01, 10.
3. 1벽돌이 있고 벽돌 0이없는 벽을 만듭니다 .

벽은 인쇄 가능한 문자가 벽돌을 나타내고 공백 ( 32)이 누락 된 벽돌을 나타내는 문자 블록입니다 . 벽돌 문자를 선택할 수 있습니다. 공백 문자가 아닌 한 벽을 구분할 필요는 없습니다. 누락 된 벽돌 문자는 공백이어야합니다. 아래 예제 *에서는 벽돌 을 사용 했습니다.

예

입력:

[ 15, 7, 13, 11 ]

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

3. 산출:

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

규칙

• 입력 한 내용은 10 진수로 입력해야합니다. 언어가 다른 언어를 받아들이면 사용할 수 없습니다.
• 선행 및 후행 줄 바꾸기가 허용됩니다.
• 입력은 정수, 별도의 인수 또는 합리적인 형식의 목록으로 취할 수 있습니다.
• 출력은 줄 바꿈 문자열, 행 배열, 2d 배열 등의 합리적인 형식 일 수 있습니다.
• 표준 허점 은 허용되지 않습니다.

테스트 사례

첫 번째 테스트 사례에서는 모든 레이어의 끝에 빈 벽돌이 있습니다.

[ 14, 4, 6, 2 ]

*** 
 *  
 ** 
  * 

[ 1, 2, 4, 8, 16 ]

    *
   * 
  *  
 *   
*

[ 15, 11, 15, 15 ]

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

[ 11, 10, 9, 8 ]

* **
* * 
*  *
*   

이것은 코드 골프이므로 가장 짧은 코드가 승리합니다!

MATL , 5 바이트

B42*c

온라인으로 사용해보십시오!

설명

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 바이트

' *'{~#:

온라인으로 사용해보십시오!

설명

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

젤리 , 9 바이트

Bo⁶Uz⁶ZUY

온라인으로 사용해보십시오!

편집 : J BEAT JELLY DAT 불가능한 방법> _ <

옥타브, 22 바이트

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

온라인으로 사용해보십시오

설명:

Luis Mendo 덕분에 바이트가 절약되었습니다! 또한 벽을 만들 캐릭터를 선택할 수 있다는 것을 알지 못했습니다 *.

@(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.

또는과 de2bi:

설명:

@(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),''])

다음은 TIO에서 7 바이트 이상 작동합니다.

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

여기 사용해보십시오

파이썬 3 , 88 84 71 74 72 바이트

각 줄을 나타내는 문자열 목록을 반환하는 람다.

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

온라인으로 사용해보십시오! (개행 문자로 분리 된 버전으로 연결)

설명

• lambda n:-매개 변수를 사용하여 (익명) 람다를 만듭니다 n. 암시 적으로 반환합니다.

• [...] -목록 이해력을 만듭니다.

• bin(x)[2:] -숫자의 이진 표현을 가져옵니다.

• .replace(*'0 ')-모든 발생을 0공백으로 바꿉니다 .

• .rjust(len(bin(max(n)))-2) -이진 표현을 가장 긴 길이로 채 웁니다.

• for x in n- n변수를 통해 반복 합니다 x.

변경 로그

• - (1) - (3) @Rod, 덕분에 바이트 -(...)+2= 2-(...)의 사용을rjust()

• 와 버전 추가 bin()가 작동하지 않았기 때문에 유효하지 않고, 1과 2.

• 를 사용하여 위의 버그를 수정했습니다 format().

• OP에서 허용했기 때문에 리턴 유형을 문자열 목록으로 변경했습니다.

• @Rod에서 발견하고 수정 rjust()하고로 다시 전환하는 또 다른 버그가 bin()수정되었습니다.

자바 스크립트 (ES6), 81 79 바이트

Rick Hitchcock이 제안한 것처럼 벽돌 대신 문자 대신 숫자를 사용하여 2 바이트를 절약했습니다.

브릭에 대해 1을 가진 2D 배열을 반환합니다.

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)

테스트 사례

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

하스켈 , 76 75 74 바이트

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

온라인으로 사용해보십시오!

05AB1E , 9 바이트

bí.Bí»0ð‡

온라인으로 사용해보십시오!

루비, 63 59 바이트

Alexis Andersen의 도움을 받아 -4 바이트

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

온라인으로 사용해보십시오!

R , 87 88 바이트

로 표시되는 벽 블록은 8여덟 개가 많기 때문입니다.

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

온라인으로 사용해보십시오!

입력 정수 목록은 후행 0 비트로 트리밍되고 반전 된 비트 배열로 변환됩니다.

축소 된 배열은 write배열을 다듬었을 때 결정된 열 너비와를 사용하여 출력됩니다 .

ifelse() 불행히도 벡터에서 작동하는 유일한 IF 옵션입니다.

파이썬 2 , 77 바이트

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

온라인으로 사용해보십시오!

APL (Dyalog) , 30 22 20 14 바이트

@ Adám 덕분에 6 바이트 절약

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

온라인으로 사용해보십시오!

( ⎕IO←0이것은 많은 컴퓨터에서 기본값 이라고 가정 합니다)

이것은 입력을 배열로 취하고 *s와 s를 가진 행렬을 반환합니다 .

설명

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

T-SQL, 290 바이트

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

용도 1벽돌 조각에 대한 입력 테이블에서 오는 가정@

설명이없는 언 골프

-- 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 바이트

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

벽돌은 1입니다

매스 매 티카, 48 바이트

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

벽돌은 #

C # (. NET 코어) , 112 + 18 = 130 86 + 41 = 127 바이트

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

온라인으로 사용해보십시오!

바이트 수에는에서 41 바이트가 포함됩니다 using System.Linq;using C=System.Convert;. 1벽의 캐릭터로 사용합니다 . 그럼에도 불구하고 이것은 C #조차도 너무 길다 ...

레티 나 , 63 바이트

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

온라인으로 사용해보십시오! 설명:

.+
$*#<

단항으로 변환하고 접미사 a로 변환하십시오 <.

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

이진으로 변환합니다.

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

모든 것이 <왼쪽에 도달 하면 모두 삭제하십시오.

m`^<
 <

<왼쪽에 이미 도달 한 공간 앞에 공백을 삽입하십시오 .

(.)<
<$1

모든 <s를 한 단계 왼쪽으로 이동하십시오 . 헹구고 반복하십시오.

PowerShell , 100 바이트

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

온라인으로 사용해보십시오!

윽, convertPowerShell에서 바이너리로 보내고하는 것은 매우 고통스러운 것입니다. 플러스 .length에 y를 호출 공간, 플러스 긴와 전화 그들이 모두 같은 만들려면-replace0.padLeft().length 모두가 긴 제출까지 추가.

100 세 미만의 골프 제안은 환영합니다.

PHP, 84 바이트

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

다행히 비트 연산은 log 결과를 int로 . float는 여기서 작동하지 않습니다.

온라인으로 사용해보십시오 .

클로저, 185 바이트

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

언 골프 버전 :

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

인수를 목록으로 취하는 익명 함수 행을리스트로 돌려줍니다.

다른 답변을 읽으면 더 작을 수 있습니다. clojure.string/replace외설적 인 양의 문자를 작성합니다 ..

Japt , 33 30 바이트

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

온라인으로 사용해보십시오!

@Justin Mariner 덕분에 3 바이트 절약

설명

¡                              // 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 '*'

파이썬 3 , 92 90 바이트

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

온라인으로 사용해보십시오!

줄 목록을 반환합니다. 그것들을 쌓아 올리면 실제로 제대로 정렬되었음을 알 수 있습니다.

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

고장

본질적으로 배열을 이진으로 변환 한 다음 모든 0을 공백으로 바꿉니다. N각 줄의 앞에 공백이 추가됩니다 N = [length of longest line] - [length of line].

-1 bytes Xoder 씨에게 감사합니다

온라인으로 사용해보십시오!

Japt , 11 바이트

m¤z3 z ·r0S

온라인으로 사용해보십시오!

설명

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

자바 (7), 130 (108) 88 바이트

@TheLethalCoder 덕분에 22 개 저장 @Xanderhall 덕분에 20 개 저장

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

언 골프 드 :

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

파이썬 2, 217 바이트

2 시간의 코딩 후 나는 numpy가 이것에 대한 나쁜 생각이라고 결정했다.

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

우분투에서의 사용법

numpy 설치

python2 -m pip install numpy

파일 이름 만들기 i형식의 입력으로14 4 6 2

운영

python2 prog.py

8 , 232 (254) 250 바이트

암호

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

주석이 달린 언 골프 버전

\ 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 ;

이 단어는 순서대로 호출해야합니다 (예 참조).

사용법 및 예

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
****
 ***
** *
* **

또는 더 명확하게

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

Pyth, 16 바이트

j_MC.tm_X.Bd\0\ 

여기에서 시도하십시오. 후행 공간을 염두에 두십시오.

엑셀 VBA, ₁₇₀ 161 바이트

골프

1 2 3 .. n범위에서 형식 을 입력 하고 범위 [A1]를 통해 해당 이진 벽을 VBE 즉시 창으로 출력하는 익명 VBE 즉시 창 기능[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

형식화 :

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

언 골프

Sub형식 Array(1, 2, 3...)을 입력하고 범위를 통해 해당 이진 벽을 VBE 즉시 창으로 출력하는 전체 루틴[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

숯 , 20 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 각 입력 번호를 이진수로 수동 변환하지만 오른쪽에서 왼쪽 순서로 인쇄하여 작동합니다. Charcoal에는 목록을 입력하는 좋은 방법이 없으므로 입력을 줄 바꿈으로 끝나는 문자열로 사용합니다. 그렇지 않으면 불행히도 현재 21 바이트를 사용하는 다음과 같은 내용을 작성합니다.

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 이 버전은 입력 배열을 벡터화하지만 출력은 -바이트로 저장되는 s 로 하드 코딩됩니다 .