Ecco la terza città di ABACABA:

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

È fatto dalla sequenza ABACABA , che è fondamentalmente:

• A (prima iterazione)
• posto B - AB
• ripetere A - ABA (seconda iterazione)
• Luogo C - ABAC
• Ripeti ABA - ABACABA (terza iterazione)

e hai avuto l'idea.

Gli edifici hanno un'altezza (corrispondente al numero di caratteri di sottolineatura) pari alle lettere convertite in numeri come A = 1, B = 2 ecc.

Ingresso

Un numero di iterazione 1 <= n <= 26.

Produzione

La città ABACABA dell'ordine n , comprese le lettere all'inizio delle righe.

Python 2, 82 byte

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

Ho notato che nessuno aveva pubblicato il metodo di ricorsione binaria e ho deciso di provarlo ... e ora con un trucco preso in prestito da Sherlock9, è la risposta in pitone più breve! (Inoltre, grazie a xnor per un altro accorciamento.) (E poi Dennis che ne ha rasato un altro ...)

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 byte

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

Per trovare il inumero th della sequenza ABACABA, scrivi iin binario, conta il numero di zero finali e aggiungi uno. Usiamo il classico trucco dei bit i&-iper trovare la massima potenza 2che divide i, quindi calcoliamo la lunghezza dei bit. In realtà, facciamo il conto alla irovescia da 2**n-1a 0, il che va bene perché la sequenza ABACABA è simmetrica.

Tracciamo sia il numero corrente che l'ultimo della sequenza con l'aiuto di una variabile "precedente" b. Questo ci dice quanti caratteri di sottolineatura stampare come "sporgenza". L'edificio finale viene disegnato correttamente senza sporgenza perché 0viene trattato come una lunghezza di bit 1.

Il formato di stringa per la stampa viene preso da SP3000 , come è il trucco di usare il inputper stampare la prima linea.

MATL , 59 byte

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

Questo utilizza l' attuale versione (15.0.0) della lingua.

Provalo online!

(Se le lettere non hanno dovuto essere inclusi nell'output: quanto segue potrebbe funzionare, 48 byte):

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

Spiegazione

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 byte

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

Questa è un'implementazione iterativa dell'algoritmo ricorsivo dalla risposta di @ quintopia .

Provalo online!

Come funziona

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 byte

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`

Dov'è \nil carattere letterale di newline.

Python 2, 123 121 byte

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)

collegamento ideone (-2 byte grazie a @xsot)

fgenera la sequenza ABACABA come un elenco di numeri, ad es f(3) = [1, 2, 1, 3, 1, 2, 1]. L'offset dell'ingresso di 1 rispetto alla sfida della sequenza ABACABA ci consente di giocare a golf su un byte f.

La prima riga viene stampata separatamente, dopodiché tutte le altre righe vengono stampate utilizzando un'espressione che tiene conto del numero corrente e del numero successivo. Solo per divertimento, la prima riga viene stampata usando input().

Pyth - 64 62 byte

Probabilmente si potrebbe giocare a golf di più, ma abbastanza buono per ora.

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

Provalo qui!

Spiegazione:

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

-16 byte grazie a @CatsAreFluffy! La mia intera funzione ora può finalmente essere in una sola riga! :)

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

Potrebbe essere un po 'lungo e può stampare nuove linee tra un edificio e l'altro, ma fa quello che deve. Puoi provarlo tu stesso per confermarlo.

MODIFICARE:

Il mio precedente codice golf non stampava il modello giusto. Tuttavia, ora quello mostrato sopra lo fa e lo fa bene secondo me. Puoi anche eseguirlo per te stesso per confermarlo.

Nota: Il programma stampa tutte le lettere minuscole dietro ogni "costruzione". Spero che va bene.

Versione Ungolfed con Spiegazione:

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

Fondamentalmente quello che sto facendo è prima importare la funzione Dizionario ordinato del modulo collezioni e quindi creare un dizionario ordinato, con ogni lettera minuscola nell'elenco "j" assegnata al suo edificio corrispondente, con la sua lunghezza corrispondente in caratteri di sottolineatura. Quindi computo la sequenza, in base all'input dell'utente, usando la f=lambda w:"a"[w:]or f(w-1)+j[w]+f(w-1)funzione, e quindi in base alla sequenza restituita da ciò, gli edifici, con ciascuna lettera corrispondente dietro di essi, vengono stampati.

Rubino, 129 byte

funzione anonima, restituisce una stringa multilinea.

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

Ci sono 2 newline all'interno dei backtick che sono significativi e contati.

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

... o 138 se le lettere possono essere minuscole.

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`

Meno golf

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

Test

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 byte

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