Для целого числа, nкоторое удовлетворяет n > 0, запишите его значение как нисходящий путь на основе его двоичного представления.

правила

• Первый (самый значимый) установленный бит всегда находится в верхнем левом углу.
• Когда следующий бит установлен (a 1), нарисуйте символ («заполненный») на следующей строке в том же столбце, что и предыдущий нарисованный символ. Попробуйте использовать пробелы («пусто») для заполнения, но любой символ будет делать, если он всегда одинаков.
• Когда следующий бит не установлен (a 0), нарисуйте символ («заполненный») в той же строке непосредственно справа от предыдущего нарисованного символа.
• Ваш код должен поддерживать числа по крайней мере с 20 значащими битами.
• Напишите полную программу, функцию, лямбду и т. Д., Но без фрагмента.
• Не допускаются начальные пробелы (или "пустые" символы) / строки
• Разрешено любое количество конечных пробелов (или «пустых» символов) / строк
• Допускается любой вид одномерного ввода: число, строка, массив логических значений и т. Д. Однако порядок битов не трогайте.
• Допускается любой вид визуального 2D-вывода: в stdout, строке (с любыми двумя различными значениями, представляющими «заполненный» и «пустой»), вы даже можете вывести матрицу, если хотите. Список чисел, кажется, трудно согласовать с правилом «без пробелов», но я открыт для него, если вы найдете способ его использовать. Примечание: если вы решили напечатать или вернуть строку, используемые символы должны быть символами ASCII в диапазоне кодовых точек [32-126].
• Стандартные лазейки запрещены.
• Это Codegolf, поэтому выигрывает самый короткий код.

Примеры

Вход: 1

*

Вход: 2

**

Вход: 3

*
*

Вход: 4

***

Вход: 5

**
 *

Вход: 6

*
**

Вход: 7

*
*
*

Вход: 25

*
***
  *

Вход: 699050

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

Ввод: 1047552

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

Вход: 525311

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

Желе , 8 байт

¬œṗ+\Ṭz0

Монадическая ссылка, принимающая число в виде списка единиц и нулей (например, 13is [1,1,0,1]), возвращающего список списков единиц и нулей, где первый список является первой строкой.

Попробуйте онлайн! или посмотрите отформатированный набор тестов

Как?

¬œṗ+\Ṭz0 - Link: list L           e.g. [1,1,0,0,1,1,0,1] (i.e. 205)
¬        - logical NOT L               [0,0,1,1,0,0,1,0]
    \    - cumulative reduce L by:
   +     -   addition                  [1,2,2,2,3,4,4,5]
 œṗ      - partition @ truthy indices  [[1,2],[2],[2,3,4],[4,5]]
     Ṭ   - un-truth (vectorises)       [[1,1],[0,1],[0,1,1,1],[0,0,0,1,1]]
      z0 - transpose with filler 0     [[1,0,0,0],[1,1,1,0],[0,0,1,0],[0,0,1,1],[0,0,0,1]]
         -                        i.e.  1000
                                        1110
                                        0010
                                        0011
                                        0001

MATL , 14 байтов

J_iB^YsJ+'o-'&XG

Создает графический вывод в виде пути, начинающегося с координат (0,0). Попробуйте это в MATL Online! Или посмотрите некоторые автономные примеры ниже:

• Вход 7:

  

  Выход:

  

• Вход 699050:

  

  Выход:

  

Если вы предпочитаете, вы можете увидеть путь в виде комплексных координат для 9 байтов :

J_iB^YsJ+

Попробуйте онлайн!

объяснение

J_      % Push -1j (minus imaginary unit)
i       % Push input number
B       % Convert to binary. Gives an array of 0 and 1 digits
^       % Power, element-wise. A 0 digit gives 1, a 1 digit gives -1j
Ys      % Cumulative sum. Produces the path in the complex plane
J+      % Add 1j, element-wise. This makes the complex path start at 0
'o-'    % Push this string, which defines plot makers
&XG     % Plot

MATL , 10 байт

YsG~YsQ1Z?

Вводит массив двоичных цифр. Выводит матрицу.

Попробуйте онлайн!

объяснение

Ys    % Implicit input: array of binary digits. Cumulative sum. This gives the
      % row coordinates
G     % Push input again
~     % Negate: change 0 to 1 and 1 to 0
Ys    % Cumulative sum
Q     % Add 1. This gives the column coordinates
1Z?   % Matrix containing 1 at those row and column coordinates and 0 otherwise.
      % Implicit display

Python 2 , 100 99 81 78 73 66 байт

a='';x=0
for c in input():a+=('\n'+' '*x)*c+'*';x+=1-c
print a[1:]

Попробуйте онлайн!

Рекурсивная версия:

Python 2 , 71 69 67 байт

f=lambda n,x=0:n and('\n'[:x]+' '*x)*n[0]+'*'+f(n[1:],x+1-n[0])or''

Попробуйте онлайн!

Древесный уголь , 22 20 19 11 10 байт

Ｆ⮌Ｓ¿Ｉι↑*←*

Пока только мой второй древесный уголь.

Принимает входные данные в виде двоичной строки (то есть 699050как 10101010101010101010).

-9 байт благодаря @Neil, предложившему вернуться назад.

Попробуйте онлайн.

Объяснение:

Прочитайте STDIN как строку в обратном порядке:

Reverse(InputString())
⮌Ｓ

Зациклите его двоичные цифры в виде строк ι:

For(Reverse(InputString()))
Ｆ⮌Ｓ

Если ιприведенное число равно 1, напечатайте *вверх, иначе напечатайте *влево.

If(Cast(i)) Print(:Up,"*"); Else Print(:Left,"*");
¿Ｉι↑*←*

C # (.NET Core) , 155 123 120 113 101 байт

Сохранено 32 байта благодаря тому, что входные данные могут быть получены в виде массива битов.
Сохранено 7 байтов благодаря @auhmaan.
Сохранено 10 байтов благодаря @KevinCruijssen.

n=>{var m="";for(int i=0,c=1;i<n.Length;)m+=n[i++]<1?c++%1+"":(i>1?"\n":"")+"0".PadLeft(c);return m;}

Попробуйте онлайн!

05AB1E , 18 17 14 байтов

γ€gć¸s>«1IÔ·ÌΛ

Попробуйте онлайн!

объяснение

γ€g             # Push the input as the array as chuncks of consecutive elements, map with length
   ć¸s>«        # Increment each value except the first one
        1I      # Push 1 and the input       
          Ô     # Push connected uniquified input (first elements of each chunck of consecutive elements in the input)
           ·Ì   # Map each with 2 * a + 2
             Λ  # Draw canvas :-)

• 3 байта благодаря @Emigna

05AB1E объяснение холста

Python 2 , 59 байт

s=p='\n'
for x in input():s+=p*x+'*';p+=' '[x:]
print s[2:]

Попробуйте онлайн!

Основано на решении TFeld .

Haskell , 65 байт

f(a:b)|a="*":f b|(x:y)<-f b=('*':x):map(' ':)y
f[]=["*"]
f.tail

Попробуйте онлайн!

Принимает ввод как список логических значений.

Карри PAKCS, 70 байт

u(a:b)=('*':a):map(' ':)b
f(a:b)|a="*":f b|1>0=u$f b
f[]=["*"]
f .tail

Порт Хаскелла отвечает, но поскольку <-в Curry не работает, нам нужно создать вспомогательную функцию u. Нам также нужно добавить пробел между fи .так, чтобы Curry анализировал его как композицию, а не точку.

Это также работает в MCC Curry, но не работает в Sloth Curry (единственном поддерживаемом TIO).

Haskell , 74 70 67 62 байта

tail.("\n"%)
s%(x:r)=([1..x]>>s)++'*':(s++[' '|x<1])%r
s%[]=""

Попробуйте онлайн! Принимает список нулей и единиц в качестве входных данных и возвращает разделенную строкой строку.

Вдохновленный ответом xnor .

Эмоджикод , 251 байт

🐖🎅🏿🍇🍦b🔡🐕2🍦c🔤*🔤🍮e🔤🔤🍮y🔤🔤🍦k🍡b🔂i k🍇🍊😛🔡i🔤1🔤🍇🍊😛y e🍇🍉🍓🍇😀y🍉🍮y🔤🔤🍮y🍪e c🍪🍉🍓🍇🍮y🍪y c🍪🍮e🍪🔤 🔤 e🍪🍉🍉😀y🍉

Попробуйте онлайн!

Это определенно не решение для игры в гольф, но нет ни одного живого человека, который бы считал код эмодзи языком игры в гольф. Тем не менее, в процессе подчинения себя ужасам, которые являются синтаксисом кода смайликов в попытках научить себя этому чудовищу языка, я был приятно удивлен тем, насколько мощным и эффективным он может быть 😀

Explaination:

🐋 🚂 🍇    👴 Define Class
🐖🎅🏿🍇    👴 Define Method
🍦b🔡🐕2    👴Convert Input integer to binary string
🍦c🔤*🔤    👴 asterisk string
🍮e🔤🔤    👴 Spacing string
🍮y🔤🔤    👴 output string
🍦k🍡b    👴 translate to iteratable
🔂i k🍇    👴 for-in loop to iterate over each digit 
🍊😛🔡i🔤1🔤🍇    👴 if digit is 1:
🍊😛y e🍇🍉    👴 don't print initial newline
🍓🍇😀y🍉    👴 print spaces + asterisks
🍮y🔤🔤    👴 reset output string
🍮y🍪e c🍪🍉    👴 add correct number of spaces and one asterisk
🍓🍇    👴 if digit is 0:
🍮y🍪y c🍪    👴 add an asterisk to the output string
🍮e🍪🔤 🔤 e🍪    👴 add another space to the space string
🍉🍉
😀y    👴 print one last output string
🍉🍉
🏁🍇    👴 Start Program
 🎅🏿 699050    👴 Call Method
🍉

JavaScript (ES6), 48 байт

Тот же формат ввода / вывода и та же логика, что и в рекурсивной версии ниже.

a=>a.map((n,i)=>n?i&&p+0:+(p+=' '),p=`
`).join``

Попробуйте онлайн!

Или 42 байта, если этот формат приемлем.

Рекурсивная версия, 56 байт

Принимает ввод как массив целых чисел (0 или 1). Используется 0для заполненных и пространство для пустых.

f=([n,...a],p=`
`,x=0)=>1/n?(n?x+0:+(p+=' '))+f(a,p,p):a

Попробуйте онлайн!

комментарии

f = (               // f = recursive function taking:
  [n, ...a],        //   n = current bit; a[] = remaining bits
  p = `\n`,         //   p = padding string, initialized to a linefeed
  x = 0             //   x = 0 on the 1st iteration / equal to p after that
) =>                //
  1 / n ?           // if n is defined:
    ( n ?           //   if n = 1:
        x + 0       //     append x + 0 --> either the integer 0 on the first iteration
                    //                      or the padding string followed by a '0'
      :             //   else:
        +(          //     append the integer 0 (whitespace coerced to a number)
          p += ' '  //     and append a space to the padding string
        )           //
    ) + f(a, p, p)  //   append the result of a recursive call with x = p
  :                 // else:
    a               //   append the empty array a[], forcing coercion to a string

Утилиты Bash + GNU, 38

dc -e?2op|sed 's/\B1/^K^H*/g;s/[10]/*/g'

Здесь ^Kи ^Hнаходятся буквальные символы управления вертикальной табуляции и возврата. Они плохо отображаются в браузерах, поэтому этот сценарий может быть воссоздан следующим образом:

base64 -d <<< ZGMgLWU/Mm9wfHNlZCAncy9cQjEvCwgqL2c7cy9bMTBdLyovZyc= > binpath.sh

Запустить в терминале. Ввод осуществляется через STDIN.

Этот ответ может слишком сильно расширить спецификации - на самом деле в каждой строке вывода нет начальных символов - все позиционирование выполняется с помощью управляющих символов. Если это слишком большая часть, то выходные данные могут быть переданы по каналу |col -x|tacдля дополнительных 11 байтов.

Пакетная, 113 байт

@set s=
:l
@shift
@if %1.==0. set s=%s%+&goto l
@echo %s%+
@if not %s%.==. set s=%s:+= %
@if %1.==1. goto l

Принимает список битов в качестве аргументов командной строки. Использует +вместо того, *потому что *имеет особое значение внутри %s:...=...%расширений.

Java 10, 100 106 байт

b->{var s="";int i=0,j;for(var c:b){if(c)for(s+="\n",j=i;j-->0;)s+=0;else++i;s+=1;}return s.substring(1);}

Принимает массив логических значений и возвращает строку ( 0s пустые, 1s заполнены). Попробуйте это онлайн здесь .

Спасибо Оливье Грегуару за то, что он помог мне сыграть в гольф и предупредил меня о том, что мой формат вывода не соответствует спецификации.

Безголовая версия:

b -> { // lambda taking an array of booleans as argument
    var s = ""; // the output String
    int i = 0,  // the number of "empty" characters to output
    j;          // iterator variable for outputting the "empty" characters
    for(var c : b) { // iterate over the boolean array (the binary digits)
        if(c) // if it's a '1'
            for(s += "\n", // output a newline
            j = i; j-- > 0;) s += 0; // output the "empty" characters
        else // if it's a '0'
            ++i; // move one to the right on the next line
        s += 1; // output the "filled" character
    }
    return s.substring(1); // output the constructed String, minus the leading newline
}

Java (JDK 10) , 83 байта

a->{int m[][]=new int[20][20],r=0,i=0;for(int b:a)m[r+=i<1?0:b][i++-r]=1;return m;}

Попробуйте онлайн!

• Поддерживает не более 20 бит.
• Введите как int[]
• Вывести как int[][]

Haskell , 126 байт

(#)n=maximum.map(!!n)
f l|s<-scanl1(zipWith(+))$(\a->[1-a,a])<$>l=unlines[[last$' ':['#'|elem[x,y]s]|x<-[0..0#s]]|y<-[1..1#s]]

Ввод в виде списка нулей и единиц. Преобразует число в смещение x↦[1-x,x]и вычисляет частичные суммы. Окончательный вывод выполняется с использованием двух вложенных списков.

Попробуйте онлайн!

R , 59 байт

function(n,x=sum(n|1))matrix(1:x^2%in%cumsum((n-1)%%x+1),x)

Попробуйте онлайн!

Принимает ввод как массив битов.

Возвращает логическую матрицу TRUEи, FALSEпредставляющую a *и a , соответственно.

Также есть некоторые вещи в нижнем колонтитуле для печати матрицы, соответствующей спецификациям выше, для простоты тестирования.

APL + WIN, 65 или 46 байт

Запрашивает ввод целого числа

n←+/i←((1+⌊2⍟n)⍴2)⊤n←⎕⋄m←(n,n)⍴' '⋄m[⊂[2](+\i),[1.1]1++\~i]←'*'⋄m

или для числового вектора двоичного представления целого числа

m←(2⍴+/n←⎕)⍴' '⋄m[⊂[2](+\i),[1.1]1++\~i]←'*'⋄m

при условии, что я правильно прочитал комментарии к определенным ответам и последний вход разрешен.

Pyth, 23 байта

p\*VtQINp+b*Zd.?=hZ)p\*

Попробуй здесь

объяснение

p\*VtQINp+b*Zd.?=hZ)p\*
p\*                       Print the leading *.
   VtQ                    For each bit (excluding the leading 1)...
      IN      .?   )      ... If the bit is set...
        p+b*Zd            ... Print a newline and a bunch of spaces...
                =hZ       ... Otherwise, increase the count of spaces...
                    p\*   ... Then print the next *.

Perl 5 -p , 54 36 байт

s/./$&?"
".$"x$i.1:++$i&&1/ge;s/.//s

Попробуйте онлайн!

Сократите это после того, как я понял, что ввод может быть немного строкой.

SmileBASIC, 64 59 57 байт

INPUT N@L
GPSET X,Y
B=N<0X=X+B
Y=Y+(X>B)N=N<<1ON!N GOTO@L

Старший бит (знаковый бит) проверяется, и если он равен 1, позиция X увеличивается. Если бит знака меньше позиции X (то есть бит знака равен 0, а X не равен 0), позиция Y увеличивается.

Первое движение всегда будет горизонтальным, поэтому движение Y блокируется до окончания первого движения X. Это гарантирует, что позиция Y не увеличивается в течение первых 0 бит.

Затем N смещается влево, и это повторяется до тех пор, пока N не достигнет 0.

Рубин , 63 байта

->n{s=""
n.to_s(2).gsub(/./){$&==?1?"
"+s+?*:(s+=" ";?*)}[1,n]}

Попробуйте онлайн!

Japt , 19 17 байт

Ë?R+Tî +Q:°T©Qìx
Ë?                 // Map over the input and if the current value is 1:
  R+               // Return a new line and
    Tî +           // a space repeated T (with initial value 0) times and
        Q          // a \".
         :         // If the current value is 0:
          °T       // Increment T
            ©Q     // and return \".
              Ã    // When all of that is done,
               ¬   // turn the array into a string
                x  // and trim it, removing the excess new line at the start.

Принимает ввод как массив битов, например [1,0,1], вывод "вместо *.
Побрил два байта благодаря Оливеру .

Попробуйте онлайн!

Python 2, 113 байт

def f(a):
 o='*';r=[o]
 for i in bin(a)[3:]:
  if'0'<i:r+=[' '*len(r[-1][1:])]
  r[-1]+=o
 print'\n'.join(r)

Не уверен, что это считается (он выводит массив каждой из строк), но если это так, тогда я изменю свой счетчик байтов на 103:

def f(a):
 o='*';r=[o]
 for i in bin(a)[3:]:
  if'0'<i:r+=[' '*len(r[-1][1:])]
  r[-1]+=o
 print r

TI-Basic (TI-84 Plus CE), 85 байт

Prompt L
1→X
1→Y
DelVar [A]
sum(LL
{Ans,1-Ans+dim(LL→dim([A]
1→[A](Y,X
For(I,2,dim(LL
Y+LL(I→Y
X+not(LL(I→X
1→[A](Y,X
End
[A]

Запрашивает логический список, возвращает матрицу 0 и 1.

Просматривает список, увеличивая X, если следующий «бит» равен 0, изменяя Y в противном случае, затем добавляя 1 к матрице в этом месте, и возвращает матрицу в конце.

TI-Basic - это токенизированный язык .

• 1 байт: Prompt , L* 6, (перевод строки) * 12, 1* 5, →* 7, X* 5, Y* 5, sum(, _L* 5, {, Ans* 2, ,* 5, -, +* 3, dim(* 3, (* 4, For(, I* 3, 2, not(, End= 73 байт
• 2 байта: Delvar , [A]* 5 = 12 байт
• Всего: 85 байт

TI-Basic (TI-84 Plus CE), 56 байт

Prompt L
1→X
1→Y
Output(Y,X,"*
For(I,2,dim(LL
Y+LL(I→Y
X+not(LL(I→X
Output(Y,X,"*
End

Те же процессы, что и выше, но с использованием графического вывода (ограничено размером экрана: 10 строк, 26 столбцов, максимум 10 1 и 25 0) вместо добавления в матрицу.

Pyth, 30 байт

JZFG.BQIsGIJk)p+*ZdN.?pN=hZ)=J

Попробуйте онлайн!

Использует "вместо* .

Q=eval(input())
Z=0
J=Z
for G in "{0:b}".format(Q):
    if int(G):
        if J:
            print()
        print(Z*' '+'"',end='')
    else:
        print('"',end='')
        Z+=1
    J=Q

x86 .COM, 32 байта

00h: 66 D1 E6 66 0F BD CE BF 24 AD 8E DF 41 66 0F A3 
10h: CE 19 DB 81 E3 9E 00 8D 79 02 C6 05 2A E2 EE C3 

fun:
shl esi, 1
bsr ecx, esi
mov di, $ad24
mov ds, di
inc cx
lab2:
bt esi, ecx
sbb bx,bx
and bx,158
lea di,[di+2+bx]
mov [di],byte '*'
lab1:loop lab2
ret  

APL (Dyalog Classic) , 18 байт

+⌿↑1↑¨⍨-+\,¨∘~⍨0,⎕

Попробуйте онлайн!