एक ABACABA शहर बनाएं

Question

यहाँ 3 ABACABA शहर है:

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

यह ABACABA अनुक्रम से बना है, जो मूल रूप से है:

• ए (1 पुनरावृति)
• जगह बी - एबी
• दोहराएं ए - एबीए (दूसरा पुनरावृत्ति)
• स्थान C - ABAC
• दोहराएँ ABA - ABACABA (तीसरा पुनरावृत्ति)

और आप विचार प्राप्त करें

इमारतों की ऊँचाई (बिना संख्या के पत्राचार वाले) संख्याओं के बराबर संख्या में ए = 1, बी = 1 आदि के रूप में परिवर्तित होती है।

इनपुट

एक पुनरावृत्ति संख्या 1 <= n <= 26।

उत्पादन

आदेश के ABACABA शहर n , लाइनों के शुरू में पत्र भी शामिल है।

Comments

@DonMuesli Haha हाँ। प्रश्न में हाइपरलिंक होगा।

जब संख्या 26 से अधिक हो जाती है तो हमें आउटपुट की क्या आवश्यकता है?

— अदनान

हां कृपया: D (यह आसान नहीं होने वाला था?)

यह मान्य इनपुट के रूप में नहीं गिना जाएगा।

क्या इनपुट शून्य हो सकता है, और यदि हां, तो आउटपुट क्या होना चाहिए? इसके अलावा, पहली इनपुट, 4 इनपुट और अपेक्षित आउटपुट को सूचीबद्ध करने के लिए यह दुख नहीं होगा।

— जर्गब

Answer 1

पायथन 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)

मैंने देखा कि किसी ने भी बाइनरी रिकर्सन विधि को पोस्ट नहीं किया था और इसे शॉट देने का फैसला किया ... और अब शर्लक 9 से उधार ली गई एक ट्रिक के साथ, यह सबसे छोटा अजगर जवाब है! (इसके अलावा, एक और कमी के लिए xnor के लिए धन्यवाद।) (और फिर डेनिस जो एक मुट्ठी अधिक मुंडा ...)

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

Comments

मुझे लगता है कि मैं इसे समझता हूं और यह काफी चतुर है। मैं पूरी तरह से इस अच्छी पुनरावृत्ति से चूक गया था। आप भंडारण के बजाय दोनों पक्षों पर सहमति के द्वारा कुछ चार्ट बचा सकते हैं s, और दूसरी पंक्ति को f=lambda n:n*"?"and f(n-1)+"_"*(n-2)+"\n%c|%s|"%(64+n,"_"*n)+f(n-1);lambda n:" _"+f(n)

— एनॉन

मैं अगले करने के बारे में सोच रहा था ...

— क्विंटोपिया

@ क्विंटोपिया f=lambda n,s=1:n*"_"and" _"*s+f(n-1,0)+"_"*(n-2)+"\n%c|%s|"%(64+n,"_"*n)+f(n-1,0)को काम करना चाहिए।

— डेनिस

@ डेनिस मैं उपर्युक्त समाधान को पायथ में लागू करने का सुझाव देता हूं। मुझे संदेह है कि यह 59 बाइट्स से कम हो सकता है ... मैं यह करूँगा, लेकिन इस बिंदु पर, यह केवल आधा मेरा है ...

— क्विंटोपिया

कार्यक्रम के रूप में 81 बाइट्स , फ़ंक्शन के समान लंबाई ।

— xnor

Answer 2

पायथन 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बाइनरी में लिखें , अनुगामी शून्य की संख्या की गणना करें, और एक जोड़ें। हम उस विभाजन i&-iकी सबसे बड़ी शक्ति को खोजने के लिए क्लासिक बिट ट्रिक का उपयोग करते हैं , फिर बिट की लंबाई की गणना करते हैं। असल में, हम गिनती से नीचे करने के लिए है, जो ठीक है क्योंकि ABACABA अनुक्रम सममित है।2ii2**n-10

हम "पिछले" चर की मदद से अनुक्रम की वर्तमान और अंतिम संख्या को ट्रैक करते हैं b। यह हमें बताता है कि "ओवरहांग" के रूप में मुद्रित करने के लिए कितने अंडरस्कोर हैं। अंतिम इमारत को ओवरहांग के बिना सही ढंग से खींचा 0जाता है क्योंकि बिट लंबाई के रूप में माना जाता है 1।

मुद्रण के लिए स्ट्रिंग प्रारूप Sp3000 से लिया गया है , जैसा inputकि पहली पंक्ति को प्रिंट करने के लिए उपयोग करने की चाल है ।

Answer 3

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

Comments

बहुत अच्छा जवाब, लेकिन आपको इमारतों के सामने अक्षरों को आउटपुट करने की भी आवश्यकता है: पी।

— अदनान

हल किया। वैसे भी ओपी स्पष्टीकरण की प्रतीक्षा की जा रही है

— लुइस मेन्डो

मैंने वास्तव में पहले से ही यह पूछा था, लेकिन मैंने अपनी टिप्पणी हटा दी। हालांकि यह प्रतिक्रिया थी: पी।

— अदनान

एक बहुत ही सुंदर समाधान।

Answer 4

CJam, 37 35 बाइट्स

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

यह @ क्विंटोपिया के उत्तर से पुनरावर्ती एल्गोरिदम का पुनरावृत्त कार्यान्वयन है ।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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#

Answer 5

जावास्क्रिप्ट (ईएस 6), 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शाब्दिक न्यूलाइन चरित्र है।

Comments

\nअंत में, अगर कोई सोच रहा था।

— कैलक्यूलेटरफलाइन

Answer 6

पायथन 2, 123 121 बाइट्स

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 लिंक (-2 बाइट @xsot का धन्यवाद)

fसंख्या की सूची के रूप में ABACABA अनुक्रम उत्पन्न करता है, जैसे f(3) = [1, 2, 1, 3, 1, 2, 1]। ABACABA अनुक्रम चुनौती की तुलना में 1 से इनपुट की ऑफसेट हमें एक बाइट को बंद करने की सुविधा देती है f।

पहली पंक्ति को अलग से मुद्रित किया जाता है, जिसके बाद अन्य सभी पंक्तियों को एक अभिव्यक्ति का उपयोग करके मुद्रित किया जाता है जो वर्तमान संख्या और अगली संख्या को ध्यान में रखता है। बस मनोरंजन के लिए, पहली पंक्ति का उपयोग करके मुद्रित किया जाता है input()।

Comments

आप बदल सकते हैं [0]के साथ L।

— xsot

@xsot आह धन्यवाद, जो बहुत अच्छी तरह से काम करता है :) (जैसा कि xnor एक जवाब पोस्ट करता है!)

— Sp3000

Answer 7

पायथ - 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|_|"

Answer 8

पायथन 3.5 - 262 236 220 बाइट्स:

-16 बाइट्स @CatsAreFluffy की बदौलत! अब मेरा पूरा कार्य एक ही पंक्ति में हो सकता है! :)

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

यह थोड़ा लंबा हो सकता है, और यह इमारत के बीच में नई लाइनें प्रिंट कर सकता है, लेकिन इसमें उसे क्या करना चाहिए। इसकी पुष्टि के लिए आप स्वयं इसका परीक्षण कर सकते हैं।

संपादित करें:

मेरे पिछले गोल्फ कोड ने सही पैटर्न को प्रिंट नहीं किया। हालाँकि, अब ऊपर दिखाया गया है, और यह मेरी राय में अच्छा करता है। इसकी पुष्टि के लिए आप इसे अपने लिए भी चला सकते हैं।

नोट: कार्यक्रम हर "बिल्डिंग" के पीछे सभी निचले अक्षरों को प्रिंट करता है। मुझे लगता है कि यह ठीक है।

स्पष्टीकरण के साथ अनप्लग्ड संस्करण:

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

मूल रूप से मैं जो कर रहा हूं, वह पहले संग्रह मॉड्यूल के ऑर्डर किए गए डिक्शनरी फ़ंक्शन को आयात कर रहा है, और फिर सूची में प्रत्येक निचले मामले पत्र के साथ एक ऑर्डर किए गए शब्दकोश का निर्माण कर रहा है, जिसे "ज" अपनी संबंधित इमारत को सौंपा गया है, जिसकी लंबाई अंडरस्कोर में है। फिर मैं अनुक्रम का उपयोग करता हूं, उपयोगकर्ता के इनपुट के f=lambda w:"a"[w:]or f(w-1)+j[w]+f(w-1)आधार पर, फ़ंक्शन का उपयोग करते हुए , और फिर उस अनुक्रम के आधार पर, उसके पीछे प्रत्येक संबंधित पत्र के साथ इमारतों को मुद्रित किया जाता है।

Comments

आप आयात कर सकते हैं OrderedDictके रूप में oके बजाय? और बदलते opकरने के लिए pऔर itemकरने के लिए jभी काम करता है।

— R

आप if(के बजाय सभी इनपुट 1≤v drop26 हैं) को बदल range(26)सकते हैं range(v), और return"\n".join(f(v))इसके बजाय उपयोग कर सकते हैं for।

— कैलक्यूलेटरफेलीन

-2bytes: का उपयोग करें from collections import*और के o=OrderedDictबजायfrom collections import OrderedDict as o

— कैलक्यूलेटर

@CatsAreFluffy वास्तव में, एक में परिणाम के range(26)लिए बदल रहा है । इसके अलावा, करना केवल अनुक्रम को लौटाता है, लेकिन इमारतों को स्वयं नहीं। उन लोगों के अलावा, आपके सुझाव बहुत अच्छे थे। धन्यवाद! :)range(v)Index Errorreturn"\n".join(f(v))

— आर। काप

ठीक है, मेरे पास पाइथन 3.5 नहीं है (मुझे 3.4.1 मिला है), शायद इसे अपग्रेड करने का समय आ गया है ...

— CalculatorFeline

Answer 9

रूबी, 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}

Answer 10

जावास्क्रिप्ट (ईएस 6), 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>

Answer 11

पॉवरशेल, 67 बाइट्स

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