Aqui está a terceira cidade da ABACABA:

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

É feito da sequência ABACABA , que é basicamente:

• A (1ª iteração)
• lugar B - AB
• repita A - ABA (2ª iteração)
• Local C - ABAC
• Repita ABA - ABACABA (3ª iteração)

e você entendeu a ideia.

Os edifícios têm uma altura (correspondida pelo número de sublinhados) igual às letras convertidas em números como A = 1, B = 2, etc.

Entrada

Um número de iteração 1 <= n <= 26.

Resultado

A cidade da ABACABA de ordem n , incluindo as letras no início das linhas.

Python 2, 82 bytes

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

Percebi que ninguém havia postado o método de recursão binária e decidiu tentar ... e agora, com um truque emprestado de Sherlock9, é a resposta mais curta em python! (Além disso, obrigado a xnor por mais uma redução.) (E então Dennis, que raspou um punhado mais ...)

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 bytes

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

Para encontrar o inúmero th da sequência ABACABA, escreva iem binário, conte o número de zeros à direita e adicione um. Usamos o truque de bits clássico i&-ipara encontrar a maior potência 2que divide ie depois calcular o tamanho do bit. Na verdade, fazemos a contagem iregressiva de 2**n-1para 0, o que é bom porque a sequência ABACABA é simétrica.

Nós rastreamos o número atual e o último da sequência com a ajuda de uma variável "anterior" b. Isso nos diz quantos sublinhados devem ser impressos como a "saliência". O edifício final é desenhado corretamente sem excesso porque 0é tratado como tendo comprimento de bit 1.

O formato da string para impressão é extraído do Sp3000 , como é o truque de usar o inputpara imprimir a primeira linha.

MATL , 59 bytes

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

Isso usa a versão atual (15.0.0) do idioma.

Experimente online!

(Se as letras não precisassem ser incluídas na saída: o seguinte funcionaria, 48 bytes):

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

Explicação

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 bytes

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

Esta é uma implementação iterativa do algoritmo recursivo da resposta da @ quintopia .

Experimente online!

Como funciona

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 bytes

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`

Onde \nestá o caractere literal de nova linha.

Python 2, 123 121 bytes

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)

link ideone (-2 bytes graças a @xsot)

fgera a sequência ABACABA como uma lista de números, por exemplo f(3) = [1, 2, 1, 3, 1, 2, 1]. O deslocamento da entrada em 1 comparado ao desafio de sequência da ABACABA nos permite obter um byte emf .

A primeira linha é impressa separadamente, após o que todas as outras linhas são impressas usando uma expressão que leva em consideração o número atual e o próximo número. Apenas por diversão, a primeira linha é impressa usando input().

Pitão - 64 62 bytes

Provavelmente poderia jogar mais, mas bom o suficiente por enquanto.

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

Experimente aqui!

Explicação:

            |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 bytes:

-16 bytes graças a @CatsAreFluffy! Agora toda a minha função pode finalmente estar em uma única linha! :)

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

Pode demorar um pouco e pode imprimir novas linhas entre as construções, mas faz o que é necessário. Você pode testá-lo para confirmar.

EDITAR:

Meu código anterior de golfe não imprimiu o padrão certo. No entanto, agora o mostrado acima faz, e faz bem na minha opinião. Você também pode executá-lo para confirmar isso.

Nota: O programa imprime todas as letras minúsculas atrás de cada "edifício". Espero que esteja tudo bem.

Versão não destruída com explicação:

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! :) )

Basicamente, o que estou fazendo é primeiro importar a função Dicionário Ordenado do módulo de coleções e, em seguida, criar um dicionário ordenado, com cada letra minúscula na lista "j" sendo atribuída ao edifício correspondente, com o comprimento correspondente em sublinhados. Depois, calculo a sequência, com base na entrada do usuário, usando a f=lambda w:"a"[w:]or f(w-1)+j[w]+f(w-1)função e, em seguida, com base na sequência retornada por isso, os edifícios, com a letra correspondente de cada um, são impressos.

Ruby, 129 bytes

Função anônima, retorna uma sequência de linhas múltiplas.

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

Existem 2 linhas novas nos backticks que são significativas e contadas.

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

... ou 138 se as letras puderem estar em minúsculas.

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`

Menos golfe

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')
}

Teste

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 bytes

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