다음은 세 번째 ABACABA 도시입니다.

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

산출

줄 시작 부분의 문자를 포함하여 순서 n 의 ABACABA 도시 .

파이썬 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에서 빌린 트릭으로 가장 짧은 파이썬 답변입니다! (또한 단축을위한 xnor 덕분입니다.) (그리고 소수의 면도를 한 Dennis는 ...)

언 골프 드 :

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

파이썬 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

iABACABA 시퀀스의 수 를 찾으려면 i이진수로 쓰고 후행 0의 수를 세고 1을 더하십시오. 우리는 고전적인 비트 트릭 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#

자바 스크립트 (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리터럴 개행 문자는 어디에 있습니까 ?

파이썬 2, 123121 바이트

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 링크 ( @xsot 덕분에 2 바이트)

fABACABA 시퀀스를 숫자 목록으로 생성합니다 (예 :) f(3) = [1, 2, 1, 3, 1, 2, 1]. ABACABA 시퀀스 챌린지 와 비교하여 1의 입력 오프셋으로 바이트 인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|_|"

파이썬 3.5- 3.5-262 236220 바이트 :

@CatsAreFluffy 덕분에 -16 바이트! 내 전체 기능은 이제 한 줄에있을 수 있습니다! :)

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

기본적으로 내가하고있는 일은 먼저 collections 모듈의 Ordered Dictionary 기능을 가져온 다음 목록 "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}

자바 스크립트 (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>

파워 쉘, 67 바이트

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