Вот 3-й город АБАКАБА:

  _
A|_|
B|__|
A|_|_
C|___|
A|_|
B|__|
A|_|

Он состоит из последовательности ABACABA , которая в основном:

• A (1-я итерация)
• место B - AB
• повторить A - ABA (2-я итерация)
• Место C - ABAC
• Повторите ABA - ABACABA (3-я итерация)

и вы поняли идею

Здания имеют высоту (соответствует номеру подчеркивания), равную буквам, преобразованным в числа как A = 1, B = 2 и т. Д.

вход

Итерация номер 1 <= n <= 26.

Выход

ABACABA город порядка n , включая буквы в начале строк.

Python 2, 82 байта

f=lambda n,s=1:n*"'"and"  _"*s+f(n-1,0)+"_"*(n-2)+"\n%c|%s|"%(64+n,"_"*n)+f(n-1,0)

Я заметил, что никто не опубликовал метод бинарной рекурсии и решил попробовать его ... и теперь с помощью трюка, заимствованного у Sherlock9, это самый короткий ответ на языке Python! (Кроме того, спасибо xnor за еще одно сокращение.) (А затем Деннис, который побрил еще немного ...)

Ungolfed:

def f(n,s=1):
    if n>0:
        strsofar = "  _" if s==1 else ""        #prepend overhang for top-level call
        strsofar += f(n-1,0)                    #build the city above the current line
        strsofar += "_"*(n-2)                   #add the overhang to reach the current tower
        strsofar += "\n%c|%s|" % (64+n, "_"*n)  #write the current (center) line
        strsofar += f(n-1,0)                    #build the city below the current line
        return strsofar
    else: 
        return ""                               #only this line will be executed when n==0 (base case)

print "  _"+f(input())

Python 2, 99 байт

b=1;i=2**input('  _\n')-1
while i:i-=1;a=len(bin(i&-i))-2;print'%c|%s|'%(64+b,'_'*b)+'_'*(a+~b);b=a

Чтобы найти iномер последовательности ABACABA, запишите iв двоичном виде, посчитайте количество конечных нулей и добавьте один. Мы используем классический битовый трюк, i&-iчтобы найти наибольшую степень 2этого деления i, а затем вычисляем битовую длину. На самом деле, мы отсчитываем iот 2**n-1до 0, что нормально, потому что последовательность ABACABA симметрична.

Мы отслеживаем как текущий, так и последний номер последовательности с помощью «предыдущей» переменной b. Это говорит нам, сколько подчеркиваний нужно напечатать как «свес». Окончательное здание рисуется правильно, без навеса, так 0как оно имеет длину в битах 1.

Формат строки для печати взят из Sp3000 , так же как и уловка inputдля печати первой строки.

MATL , 59 байт

vi:"t@wv]!-1hPXJtPvX>"'|'@Z"63+h6MJ2+X@)(]XhcJ64+!wh!32H:(!   

Используется текущий выпуск (15.0.0) языка.

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

(Если буквы не нужно было включать в вывод: сработало бы следующее, 48 байт):

vi:"t@wv]!-1hPXJtPvX>"' |'X@1=o)@Z"63+h6MJ2+X@)(

объяснение

v        % vertically concatenate the stack contents: gives an empty array
i:       % input number n. Generate [1,2,...,n]
"        % for each k in [1,2,...n]
  t      %   duplicate
  @      %   push k
  wv     %   swap, vertically concatenate
]        % end. Poduces the numeric ABACABA: [1 2 1 3 1 2 1]: ceiling heights
!        % transpose into a row
-1h      % append -1
PXJ      % reverse array. Copy into clipboard J
tP       % duplicate. Reverse again, so undo the reversing
v        % vertically concatenate reversed and non-reversed row arrays
X>       % max of each column. Gives array of wall heights: [1 2 2 3 3 2 2 1]
"        % for each value in that array
  '|'    %   push "floor" char
  @      %   push height
  Z"     %   create string with that many spaces
  63+    %   transform spaces into "wall" chars, '_'
  h      %   concatenate horizontally
  6M     %   push "floor" char '|' again, to be used as ceiling
  J      %   push array of ceiling heights
  2+X@)  %   index into that to get height of current building
  (      %   at that position, overwrite the string with '|'
]        % end
Xhc      % concatenate all strings into a 2D char array, padding with spaces
J        % push array of ceiling heights (numeric ABACABA sequence)
64+      % add 64 to transform into letters
!        % transpose into column array
wh       % swap, concatenate horizontally. This appends letters below the floor
!        % transpose
32H:(    % overwrite first two positions (in linear order) with spaces
!        % transpose back. Implicitly display

CJam, 37 35 байт

SS'_Lri{[H)'_*_2>N@H'A+'|@'|6$]+}fH

Это итеративная реализация рекурсивного алгоритма из ответа @ quintopia .

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

Как это устроено

SS'_     e# Push two spaces and an underscore.
L        e# Push "".
ri       e# Read an integer I from STDIN.
{        e# For each H in [0 ... I-1]:
  [      e#   Set an array marker.
    H)   e#     Push Push H+1.
    '_*  e#     Push a string of that many underscores.
    _2>  e#   Push a copy and remove the first two underscores.
    N    e#   Push a linefeed.
    @    e#   Rotate the longer string of underscores on top of it.
    h'A+ e#   Add H to the character 'A', pushing the corresponding letter.
    '|  e#    Push a vertical bar.
    @   e#    Rotate the string of underscores on top of it.
    '|  e#    Push another vertical bar.
    6$  e#    Push a copy of the previous iteration (initially "").
  ]     e#   Wrap everything up to the former marker in an array.
}fH     e#

JavaScript (ES6), 162 байта

n=>(a=[...Array(1<<n)]).map((_,i)=>i?(a[i]=String.fromCharCode(64+(n=1+Math.log2(i&-i)))+`|${"_".repeat(n)}|`,a[i-1]+='_'.repeat(--n&&--n)):a[i]='  _')&&a.join`\n`

Где \nбуквальный символ новой строки.

Python 2, 123 121 байт

f=lambda n:n*[n]and f(n-1)+[n]+f(n-1)
L=f(input('  _\n'))
for i,j in zip(L,L[1:]+L):print'%c|%s|'%(64+i,'_'*i)+'_'*(j+~i)

ссылка идеона (-2 байта благодаря @xsot)

fгенерирует последовательность ABACABA в виде списка чисел, например f(3) = [1, 2, 1, 3, 1, 2, 1]. Смещение входного значения на 1 по сравнению с проблемой последовательности ABACABA позволяет нам сыграть в байте f.

Первая строка печатается отдельно, после чего все остальные строки печатаются с использованием выражения, которое учитывает текущий номер и следующий номер. Просто для удовольствия, первая строка печатается с использованием input().

Pyth - 64 62 байта

Вероятно, можно было бы играть в гольф больше, но пока достаточно.

Lsl.&Jhb_J"  _"Vtt^2Qpr@G=ZyN1p"|_"p*\_Zp\|W<=hZyhNp\_)d)"A|_|

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

Объяснение:

            |Predefined vars: Q = evaluated input, G = lowercase alphabet
L           |Lambda definition. y(b) = return (following code)
   .&       |bitwise and
     Jhb    |J = b + 1, pass b + 1 to the bitwise and
        _J  |-J
  l         | base 2
 s          |̲c̲o̲n̲v̲e̲r̲t̲ ̲t̲o̲ ̲i̲n̲t̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲
          "  _"                              |print "  _" with a trailing newline
               Vtt^2Q                        |For N in 2^Q - 2
                     pr      1               |print in caps
                         =ZyN                |Z = y(N) remember the first lambda?
                       @G                    |G[Z], basically convert 1-26 to A-Z
                              p"|_"          |print "|_", no trailing newline
                                   p*\_Z     |print "_" Z times
                                        p\|  |̲p̲r̲i̲n̲t̲ ̲"̲|̲"̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲ ̲
                                           W<=hZyhN             |While ++Z<y(N+1)
                                                   p\_          |print "_"
                                                      )k        |end while,
                                                                |print newline
                                                        )"A|_|  |end for,
                                                                |print "A|_|"

Python 3,5 - 262 236 220 байт:

-16 байт благодаря @CatsAreFluffy! Вся моя функция теперь, наконец, может быть в одной строке! :)

from collections import*
def a(v):o=OrderedDict;j=[chr(i+97)for i in range(26)];d=o((j[i],('  '+'_'*(i+1)+'\n'+j[i]+'|'+'_'*(i+1)+'|'))for i in range(26));f=lambda w:'a'[w:]or f(w-1)+j[w]+f(w-1);[print(d[g])for g in f(v)]

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

РЕДАКТИРОВАТЬ:

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

Примечание . Программа печатает все строчные буквы за каждым «зданием». Я надеюсь, что все в порядке.

Ungolfed версия с объяснением:

from collections import*
def a(v):
    o=OrderedDict # Assign the OrderedSict function to "o"
    j=[chr(i+97)for i in range(26)] # Create a list with all 26 lowercase letters of the alphabet
    d=o((j[i],('  '+'_'*(i+1)+'\n'+j[i]+'|'+'_'*(i+1)+'|'))for i in range(26)) # Create a dict assigning each letter it's corresponding building with its corresponding length
    f=lambda w:'a'[w:]or f(w-1)+j[w]+f(w-1) # Return the ABACABA sequence based on the user input
    [print(d[g])for g in f(v)] # Print out the building according to the sequence returned by the above lambda function (thanks to @CatsAreFluffy for this method to print it! :) )

По сути, я сначала импортирую функцию упорядоченного словаря модуля коллекций, а затем создаю упорядоченный словарь, в котором каждой строчной букве в списке «j» назначается соответствующее здание с соответствующей длиной в подчеркиваниях. Затем я вычисляю последовательность, основываясь на вводе пользователем, используя f=lambda w:"a"[w:]or f(w-1)+j[w]+f(w-1)функцию, а затем на основе последовательности, возвращаемой этим, здания, с соответствующей буквой за ними, распечатываются.

Рубин, 129 байт

Анонимная функция, возвращает многострочную строку.

->x{a=->n{n<1?[]:(b=a[n-1];b+[n]+b)}
r="  _
"
a[x].zip(a[x][1,9**x]<<0).map{|n,m|r+=(64+n).chr+"|#{?_*n}|#{?_*(m+~n)if m>n}
"}
r}

JavaScript (ES6), 143

Есть 2 символа новой строки внутри обратных кавычек, которые являются значительными и учитываются.

n=>`  _
`+(r=n=>n?[...r(n-1),n,...r(n-1)]:[])(n).map((x,i,t,u=n=>'|'+'_'.repeat(n>0&&n))=>String.fromCharCode(x+64)+u(x)+u(t[i+1]-x-1)).join`
`

... или 138, если буквы могут быть строчными.

n=>`  _
`+(r=n=>n?[...r(n-1),n,...r(n-1)]:[])(n).map((x,i,t,u=n=>'|'+'_'.repeat(n>0&&n))=>(x+9).toString(36)+u(x)+u(t[i+1]-x-1)).join`

Меньше гольфа

n=>{
  // recursive function for ABACABA returning an array of integers
  var r=n=>n?[...r(n-1),n,...r(n-1)]:[]
  // function to build "|__..."
  // if argument <=0 just returns the vertical bar
  var u=n=>'|'+'_'.repeat(n>0&&n)
  var t = r(n)
  t = t.map((x,i)=>
    // current building + extension to the len of next building if needed
    String.fromCharCode(x+64)+u(x)+u(t[i+1]-x-1)
  )
  return ' _\n' // the top line is fixed
    + t.join('\n')
}

Тестовое задание

solution=
n=>`  _
`+(r=n=>n?[...r(n-1),n,...r(n-1)]:[])(n).map((x,i,t,u=n=>'|'+'_'.repeat(n>0&&n))=>String.fromCharCode(x+64)+u(x)+u(t[i+1]-x-1)).join`
`

function update() {
  var n=+N.value
  if (n>=0 && n<=26) O.textContent=solution(n)
}

update()

#N { width: 2em }

N:<input id=N value=4 oninput='update()'><pre id=O></pre>

Powershell, 67 байт

1..(Read-Host)|%{'  _'}{$x+=@([char]($_+96)+'|'+'_'*$_+'|')+$x}{$x}