Voici la 3ème ville ABACABA:

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

Il est constitué de la séquence ABACABA , qui est essentiellement:

• A (1ère itération)
• place B - AB
• répéter A - ABA (2e itération)
• Place C - ABAC
• Répétez ABA - ABACABA (3e itération)

et vous avez l'idée.

Les bâtiments ont une hauteur (correspondant au nombre de soulignements) égale aux lettres converties en nombres comme A = 1, B = 2, etc.

Contribution

Un numéro d'itération 1 <= n <= 26.

Production

La ville ABACABA d'ordre n , y compris les lettres au début des lignes.

Python 2, 82 octets

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

J'ai remarqué que personne n'avait posté la méthode de récursion binaire et j'ai décidé de lui donner un coup de feu ... et maintenant avec une astuce empruntée à Sherlock9, c'est la réponse la plus courte en python! (Aussi, merci à xnor pour un raccourcissement de plus.) (Et puis Dennis qui a rasé une poignée de plus ...)

Non golfé:

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 octets

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

Pour trouver le inuméro e de la séquence ABACABA, écrivez ien binaire, comptez le nombre de zéros de fin et ajoutez-en un. Nous utilisons le truc de bits classique i&-ipour trouver la plus grande puissance de 2ces divisions i, puis calculons la longueur des bits. En fait, nous comptons ide 2**n-1à 0, ce qui est bien car la séquence ABACABA est symétrique.

Nous suivons à la fois le numéro actuel et le dernier de la séquence à l'aide d'une variable "précédente" b. Cela nous indique le nombre de traits de soulignement à imprimer en tant que "surplomb". Le bâtiment final est dessiné correctement sans surplomb car il 0est traité comme ayant une longueur de bit 1.

Le format de chaîne pour l'impression provient de Sp3000 , tout comme l'astuce inputpour imprimer la première ligne.

MATL , 59 octets

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

Cela utilise la version actuelle (15.0.0) de la langue.

Essayez-le en ligne!

(Si les lettres ne devaient pas être incluses dans la sortie: ce qui suit fonctionnerait, 48 octets):

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

Explication

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 octets

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

Il s'agit d'une implémentation itérative de l'algorithme récursif de la réponse de @quintopia .

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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`

Où se \ntrouve le caractère de nouvelle ligne littéral.

Python 2, 123 121 octets

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)

lien ideone (-2 octets grâce à @xsot)

fgénère la séquence ABACABA sous la forme d'une liste de nombres, par exemple f(3) = [1, 2, 1, 3, 1, 2, 1]. Le décalage de l'entrée de 1 par rapport au défi de séquence ABACABA nous permet de jouer un octet dansf .

La première ligne est imprimée séparément, après quoi toutes les autres lignes sont imprimées en utilisant une expression qui prend en compte le numéro actuel et le numéro suivant. Juste pour le plaisir, la première ligne est imprimée en utilisant input().

Pyth - 64 62 octets

On pourrait probablement jouer au golf plus, mais assez bien pour l'instant.

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

Essayez-le ici!

Explication:

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

-16 octets grâce à @CatsAreFluffy! Ma fonction entière peut maintenant enfin être sur une seule ligne! :)

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

Il peut être un peu long et imprimer de nouvelles lignes entre les bâtiments, mais il fait ce qu'il faut. Vous pouvez le tester vous-même pour le confirmer.

ÉDITER:

Mon code de golf précédent n'a pas imprimé le bon motif. Cependant, maintenant celui montré ci-dessus le fait, et il le fait bien à mon avis. Vous pouvez également l'exécuter vous-même pour le confirmer.

Remarque: Le programme imprime toutes les lettres minuscules derrière chaque "bâtiment". J'espère que ça va.

Version non golfée avec explication:

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

Fondamentalement, ce que je fais, c'est d'abord importer la fonction Dictionnaire ordonné du module collections, puis créer un dictionnaire ordonné, chaque lettre minuscule de la liste "j" étant affectée à son bâtiment correspondant, avec sa longueur correspondante en traits de soulignement. Ensuite, je calcule la séquence, en fonction de l'entrée de l'utilisateur, en utilisant la f=lambda w:"a"[w:]or f(w-1)+j[w]+f(w-1)fonction, puis en fonction de la séquence renvoyée par cela, les bâtiments, avec la lettre correspondante de chacun derrière, sont imprimés.

Rubis, 129 octets

Fonction anonyme, retourne une chaîne multiligne.

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

Il y a 2 sauts de ligne à l'intérieur des backticks qui sont importants et comptés.

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 si les lettres peuvent être en minuscules.

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`

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

Tester

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 octets

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