একটি আবাকাবা শহর তৈরি করুন

Question

এটি তৃতীয় আব্বাসা শহর:

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

এটি আবাকাবা ক্রম থেকে তৈরি করা হয়েছে , যা মূলত:

• এ (1 ম পুনরুক্তি)
• স্থান বি - এবি
• পুনরুক্তি A - ABA (দ্বিতীয় পুনরাবৃত্তি)
• প্লেস সি - অ্যাব্যাক
• পুনরাবৃত্তি ABA - ABACABA (3 য় পুনরাবৃত্তি)

এবং আপনি ধারণা পেতে।

বিল্ডিংগুলির উচ্চতা (আন্ডারস্কোরগুলির সাথে সংযুক্ত) A = 1, B = 2 ইত্যাদি হিসাবে সংখ্যায় রূপান্তরিত বর্ণগুলির সমান হয়

ইনপুট

একটি পুনরাবৃত্তি সংখ্যা 1 <= n <= 26।

আউটপুট

লাইনের শুরুতে অক্ষরগুলি সহ অ্যাব্যাকোবা শহর অর্ডার এন ।

Comments

পছন্দ করুন প্রশ্নে হাইপারলিঙ্ক হবে।

সংখ্যাটি 26 এর বেশি হয়ে গেলে আমাদের কী আউটপুট করতে হবে?

— আদনান

হ্যাঁ দয়া করে: ডি (এটি সহজ হয়ে

এটি বৈধ ইনপুট হিসাবে গণনা করা হবে না।

ইনপুটটি শূন্য হতে পারে এবং যদি তাই হয় তবে আউটপুটটি কী হওয়া উচিত? এছাড়াও, প্রথমটি বলে, 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

আমি মনে করি আমি এটি বুঝতে পেরেছি এবং এটি বেশ চালাক। আমি এই দুর্দান্ত পুনরাবৃত্তি পুরোপুরি মিস করেছি। আপনি সংরক্ষণ করতে চেয়ে উভয় পক্ষকে sf=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

iঅ্যাবাক্যাবা ক্রমটির তম সংখ্যাটি সন্ধান করতে , iবাইনারি লিখুন , চলমান শূন্যগুলির সংখ্যা গণনা করুন এবং একটি যুক্ত করুন। আমরা সেই বিভাজনের i&-iসর্বাধিক শক্তি খুঁজে পেতে ক্লাসিক বিট ট্রিকটি ব্যবহার করি , তারপরে বিট দৈর্ঘ্যের গণনা করব। আসলে, আমরা থেকে গণনা2ii2**n-1 করার 0, যা সূক্ষ্ম কারণ ABACABA ক্রম প্রতিসম হয়।

আমরা "পূর্ববর্তী" ভেরিয়েবলের সাহায্যে ক্রমের বর্তমান এবং শেষ উভয় সংখ্যা ট্র্যাক করি b। এটি আমাদেরকে বোঝায় যে "ওভারহ্যাং" হিসাবে কতগুলি আন্ডারস্কোর প্রিন্ট করতে হবে। চূড়ান্ত বিল্ডিং ওভারহ্যাং ছাড়াই সঠিকভাবে আঁকা কারণ 0বিট দৈর্ঘ্য হিসাবে বিবেচিত হয় 1।

মুদ্রণের জন্য স্ট্রিং ফর্ম্যাটটি Sp3000 থেকে নেওয়া হয়েছে , যেমন inputপ্রথম লাইনটি প্রিন্ট করতে ব্যবহার করার কৌশল ।

Answer 3

এমএটিএল , 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

সিজেম, 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

জাভাস্ক্রিপ্ট (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আক্ষরিক নিউলাইন চরিত্রটি কোথায় ।

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)

আদর্শ লিঙ্ক (-২ বাইট @ xsot ধন্যবাদ)

fসংখ্যার তালিকা হিসাবে ABACABA ক্রম উত্পন্ন করে f(3) = [1, 2, 1, 3, 1, 2, 1]। ABACABA সিকোয়েন্স চ্যালেঞ্জের সাথে তুলনা করে ইনপুটটির অফসেট 1 দিয়ে আমাদের একটি বাইটটি গল্ফ দেয় f।

প্রথম লাইনটি আলাদাভাবে মুদ্রিত হয়, তার পরে অন্যান্য সমস্ত লাইন মুদ্রণ করা হয় এমন একটি এক্সপ্রেশন ব্যবহার করে যা বর্তমান নম্বর এবং পরবর্তী নম্বর বিবেচনায় নেয়। কেবল মজাদার জন্য, প্রথম লাইনটি ব্যবহার করে মুদ্রিত হয় input()।

Comments

আপনি প্রতিস্থাপন করতে পারেন [0]সঙ্গে L।

— xsot

@ এক্সসোট আহ ধন্যবাদ, এটি বেশ ভালভাবে কাজ করে :) :) (এক্সনর যেমন একটি উত্তর পোস্ট করে!)

— 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 বাইটস @ ক্যাটসআরএফ্লুফিকে ধন্যবাদ! আমার পুরো ফাংশন এখন শেষ পর্যন্ত একক লাইনে থাকতে পারে! :)

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

এটি কিছুটা দীর্ঘ হতে পারে এবং এটি বিল্ডিংয়ের মধ্যে নতুন লাইনগুলি মুদ্রণ করতে পারে তবে এটি যা প্রয়োজন তা করে in এটি নিশ্চিত করার জন্য আপনি এটি পরীক্ষা করে নিতে পারেন।

সম্পাদনা করুন:

আমার পূর্বের গল্ফড কোড যা সঠিকভাবে সঠিক প্যাটার্নটি মুদ্রণ করে নি। যাইহোক, এখন উপরে দেখানো একটি করে এবং এটি আমার মতে এটি ভাল করে। এটি নিশ্চিত করার জন্য আপনি নিজের জন্য এটি চালাতে পারেন।

বিঃদ্রঃ: প্রোগ্রামটি প্রতিটি "বিল্ডিং" এর পিছনে সমস্ত ছোট হাতের অক্ষর মুদ্রণ করে। আমি আশা করি ঠিক আছে।

ব্যাখ্যার সাথে অদম্য সংস্করণ:

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 arev .26 হয়), এ পরিবর্তন range(26)করতে range(v)এবং এর return"\n".join(f(v))পরিবর্তে ব্যবহার করতে পারেন for।

— ক্যালকুলেটরফলাইন

-2 বাইটস: ব্যবহার করুন from collections import*এবং এর o=OrderedDictপরিবর্তেfrom collections import OrderedDict as o

— ক্যালকুলেটরফলাইন

@ ক্যাটস আরেফ্লুফি আসলে, ফলাফলগুলিতে পরিবর্তন range(26)করে range(v)একটি Index Error। এছাড়াও, return"\n".join(f(v))কেবলমাত্র এই ক্রমটি ফিরে আসবে, তবে বিল্ডিংগুলি সেগুলি নয়। এগুলি ব্যতীত আপনার টিপস বেশ ভাল ছিল were ধন্যবাদ! :)

— আর

ঠিক আছে, আমার কাছে পাইথন 3.5 নেই (আমি 3.4.1 পেয়েছি), সম্ভবত এটি আপগ্রেড করার সময় এসেছে ...

— ক্যালকুলেটরফ্লাইন

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

জাভাস্ক্রিপ্ট (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 টি যদি অক্ষর ছোট ছোট হতে পারে be

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}