Hier ist die 3. ABACABA-Stadt:

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

Es besteht aus der ABACABA- Sequenz, die im Grunde genommen wie folgt lautet:

• A (1. Iteration)
• platzieren Sie B - AB
• wiederhole A - ABA (2. Iteration)
• Platzieren Sie C - ABAC
• Wiederhole ABA - ABACABA (3. Iteration)

und Sie bekommen die Idee.

Die Gebäude haben eine Höhe (entsprechend der Anzahl der Unterstriche), die den Buchstaben entspricht, die in Zahlen wie A = 1, B = 2 usw. Umgewandelt wurden

Eingang

Eine Iterationsnummer 1 <= n <= 26.

Ausgabe

Die ABACABA-Stadt der Ordnung n , einschließlich der Buchstaben am Zeilenanfang.

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)

Mir ist aufgefallen, dass niemand die binäre Rekursionsmethode veröffentlicht hat und beschlossen hat, es zu versuchen ... und jetzt ist es mit einem von Sherlock9 geliehenen Trick die kürzeste Python-Antwort! (Auch danke an xnor für eine weitere Verkürzung.) (Und dann Dennis, der eine Handvoll mehr rasiert hat ...)

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

Um idie dritte Nummer der ABACABA-Sequenz zu finden, schreiben Sie ibinär, zählen Sie die Anzahl der nachfolgenden Nullen und addieren Sie eine. Wir verwenden den klassischen Bit-Trick i&-i, um die größte Potenz 2dieser Teilungen zu finden iund dann die Bitlänge zu berechnen. Tatsächlich zählen wir ivon 2**n-1bis abwärts 0, was in Ordnung ist, da die ABACABA-Sequenz symmetrisch ist.

Wir verfolgen sowohl die aktuelle als auch die letzte Nummer der Sequenz mit Hilfe einer "vorherigen" Variablen b. Dies sagt uns, wie viele Unterstriche als "Überhang" zu drucken sind. Das endgültige Gebäude wird korrekt ohne Überhang gezeichnet, da 0es als Bitlänge behandelt wird 1.

Das Zeichenfolgenformat für den Druck wird von Sp3000 übernommen , ebenso wie der Trick, mit dem inputdie erste Zeile gedruckt wird.

MATL , 59 Bytes

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

Dies verwendet die aktuelle Version (15.0.0) der Sprache.

Probieren Sie es online!

(Wenn die Buchstaben nicht in der Ausgabe enthalten sein müssten: das Folgende würde funktionieren, 48 Bytes):

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

Erläuterung

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

Dies ist eine iterative Implementierung des rekursiven Algorithmus aus der Antwort von @ quintopia .

Probieren Sie es online!

Wie es funktioniert

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`

Wo \nist das wörtliche Newline-Zeichen?

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)

ideone link (-2 bytes dank @xsot)

ferzeugt die ABACABA-Sequenz als Liste von Zahlen, z f(3) = [1, 2, 1, 3, 1, 2, 1]. Der Versatz der Eingabe um 1 im Vergleich zur ABACABA-Sequenzherausforderung lässt uns ein Byte nach innen spielenf .

Die erste Zeile wird separat gedruckt. Danach werden alle anderen Zeilen mit einem Ausdruck gedruckt, der die aktuelle und die nächste Nummer berücksichtigt. Nur zum Spaß wird die erste Zeile mit gedruckt input().

Pyth - 64 62 Bytes

Vielleicht könnte man mehr Golf spielen, aber für den Moment gut genug.

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

Probieren Sie es hier aus!

Erläuterung:

            |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 dank @CatsAreFluffy! Meine gesamte Funktion kann jetzt endlich in einer einzigen Zeile stehen! :)

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

Es kann ein bisschen lang sein, und es kann neue Zeilen zwischen den Gebäuden drucken, aber es tut, was es braucht. Sie können es selbst testen, um es zu bestätigen.

BEARBEITEN:

Mein vorheriger Golf-Code druckte überhaupt nicht das richtige Muster. Aber jetzt tut es der oben gezeigte und meiner Meinung nach tut es gut. Sie können es auch selbst ausführen, um dies zu bestätigen.

Hinweis: Das Programm druckt alle Kleinbuchstaben hinter jedem "Gebäude". Ich hoffe das ist okay.

Ungolfed Version mit Erklärung:

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

Grundsätzlich importiere ich zuerst die Funktion "Geordnetes Wörterbuch" des Collections-Moduls und erstelle dann ein geordnetes Wörterbuch, wobei jeder Kleinbuchstabe in der Liste "j" dem entsprechenden Gebäude mit der entsprechenden Länge in Unterstrichen zugewiesen wird. Dann berechne ich die Sequenz basierend auf den Eingaben des Benutzers unter Verwendung der f=lambda w:"a"[w:]or f(w-1)+j[w]+f(w-1)Funktion und dann basierend auf der Sequenz, die dadurch zurückgegeben wird, werden die Gebäude mit den entsprechenden Buchstaben dahinter ausgedruckt.

Ruby, 129 Bytes

Anonyme Funktion, gibt eine mehrzeilige Zeichenfolge zurück.

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

Es gibt 2 Zeilenumbrüche in den Backticks, die signifikant und gezählt sind.

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

... oder 138, wenn die Buchstaben klein geschrieben werden können.

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`

Weniger golfen

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

Prüfung

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}