ভূমিকা

এই চ্যালেঞ্জে, একটি 2 × 2 ম্যাট্রিক্সটিকে এভাবে সূচকযুক্ত করা হয়:

0 1
2 3

আমরা ফ্র্যাক্টাল-সদৃশ নিদর্শনগুলির একটি পরিবারকে সংজ্ঞায়িত করি F(L), যেখানে এই সূচকগুলির Lদৈর্ঘ্য- nতালিকা এবং F(L)আকার রয়েছে ।2ⁿ-1 × 2ⁿ-1

যদি L == [], তবে F(L)1 × 1 প্যাটার্ন #।
যদি L != [], তবে F(L)নিম্নলিখিত হিসাবে নির্মিত হয়। প্রথম উপাদানটি মুছে ফেলা দিয়ে Pপ্রাপ্ত প্যাটার্নটি হতে দিন L। পিরিয়ড দিয়ে ভরাট আকারের চারটি গ্রিড নিন এবং প্যাটার্নের সাহায্যে গ্রিডটি সূচিত করুন । তারপরে, গ্রিডগুলি তাদের মধ্যে এক স্তরের হ্যাশ ব্যবহার করে একসাথে আঠালো করুন। চারটি মামলার চিত্র এখানে রয়েছে:2^n-1-1 × 2^n-1-1.L[0]P#
```
L[0]==0  L[0]==1  L[0]==2  L[0]==3
   #...  ...#     ...#...  ...#...
[P]#...  ...#[P]  ...#...  ...#...
   #...  ...#     ...#...  ...#...
#######  #######  #######  #######
...#...  ...#...     #...  ...#   
...#...  ...#...  [P]#...  ...#[P]
...#...  ...#...     #...  ...#   
```

উদাহরণ

ইনপুট বিবেচনা করুন L = [2,0]। আমরা 1 × 1 গ্রিড দিয়ে শুরু করি এবং ডান দিক থেকে #ক্রস করি L। ডান দিকের উপাদানটি হ'ল 0, সুতরাং আমরা 1 × 1 গ্রিডের চারটি অনুলিপি নিই ., প্রথমটিকে প্রতিস্থাপন #করব এবং হ্যাশগুলির সাথে একসাথে আঠালো করব। 3 × 3 গ্রিডের ফলস্বরূপ

##.
###
.#.

পরবর্তী উপাদানটি হ'ল 2, সুতরাং আমরা 3 × 3 গ্রিডের চারটি অনুলিপি .নিয়েছি এবং তৃতীয়টিকে উপরের গ্রিডের সাথে প্রতিস্থাপন করব। চারটি গ্রিড হ'ল

...  ...  ##.  ...
...  ...  ###  ...
...  ...  .#.  ...

এবং #7 gr 7 গ্রিডে ফলাফলের সাথে তাদের একসাথে আঠালো করে তোলা

...#...
...#...
...#...
#######
##.#...
####...
.#.#...

এটি আমাদের চূড়ান্ত আউটপুট।

ইনপুট

আপনার ইনপুট Lসূচকগুলির একটি তালিকা 0, 1, 2, 3। আপনি এটি পূর্ণসংখ্যার একটি তালিকা বা সংখ্যার একটি স্ট্রিং হিসাবে নিতে পারেন। মনে রাখবেন এটি খালি থাকতে পারে এবং এতে নকল থাকতে পারে। দৈর্ঘ্য Lসর্বাধিক 5।

আউটপুট

আপনার আউটপুটটি F(L)নতুন লাইন-বিস্মৃত স্ট্রিং হিসাবে প্যাটার্ন ।

বিধি এবং স্কোরিং

আপনি একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন লিখতে পারেন। সর্বনিম্ন বাইট গণনা জয়, এবং মান লুফোলগুলি অনুমোদিত নয়।

পরীক্ষার মামলা

[]
#

[0]
##.
###
.#.

[3]
.#.
###
.##

[2,0]
...#...
...#...
...#...
#######
##.#...
####...
.#.#...

[1,1]
...#.##
...####
...#.#.
#######
...#...
...#...
...#...

[1,2,0]
.......#...#...
.......#...#...
.......#...#...
.......########
.......###.#...
.......#####...
.......#.#.#...
###############
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......

[3,3,1]
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
###############
.......#...#...
.......#...#...
.......#...#...
.......########
.......#...#.##
.......#...####
.......#...#.#.

[0,1,2,3]
.......#...#...#...............
.......#...#...#...............
.......#...#...#...............
.......#########...............
.......#.#.#...#...............
.......#####...#...............
.......#.###...#...............
################...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
###############################
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............

[0,0,1,2,3]
.......#...#...#...............#...............................
.......#...#...#...............#...............................
.......#...#...#...............#...............................
.......#########...............#...............................
.......#.#.#...#...............#...............................
.......#####...#...............#...............................
.......#.###...#...............#...............................
################...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
################################...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
###############################################################
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................

code-golf ascii-art fractal

— Zgarb
সূত্র

আপনার উদাহরণে, আপনি কেন 1x1 গ্রিড দিয়ে শুরু করবেন #? L !=[]উদাহরণটিতে যেমন এটিতে 1 বা ততোধিক উপাদান রয়েছে। মানে কি এই যে এফ (এল) হল সবসময় একটি #প্রথমে?

— আর কাপ,

2

@ আর কেপ ঠিক আছে, উদাহরণটি খুব পরিষ্কার নয়। সংজ্ঞাটি পুনরাবৃত্তিযোগ্য, সুতরাং L = [2,0]আপনি মাথা কেটে ফেলুন এবং প্যাটার্নটি দেখুন F([0]), তারপরে মাথা কেটে নিন [0]এবং প্যাটার্নটি দেখুন F([])যা 1x1 গ্রিড #। তারপরে আপনি 03x3 প্যাটার্নটি তৈরি করতে এর উপর কাটা-অফ সূচকটি ব্যবহার করুন 2এবং 7x7 প্যাটার্নটি তৈরি করতে সেইটিতে কাটা-অফ সূচকটি ব্যবহার করুন । আপনার প্রশ্নের উত্তর দেওয়ার জন্য: হ্যাঁ, আপনি সর্বদা 1x1 গ্রিড দিয়ে শুরু করেন কারণ এটি পুনরাবৃত্তির মূল বিষয়।

— Zgarb

সম্পর্কিত পড়া

— Sp3000

6

সিজেম, 59 47 43 41 40 বাইট

1 বাইট সংরক্ষণের জন্য Sp3000 ধন্যবাদ।

Sal~W%{_Bff|a4*I@t2/{zSf*z}:F%F}fI3ff+N*

এটি এখানে পরীক্ষা করুন।

ব্যাখ্যা

সামান্য পুরানো। পরে ঠিক করবে।

4 ডি তালিকাগুলির সমস্ত মাত্রিক পুনঃক্রমগুলি আমাকে ডিজেড করে দিচ্ছে ...

এই কোডটি পুনরাবৃত্ত সংজ্ঞাটির পরিবর্তে উদাহরণ বিভাগ থেকে পুনরাবৃত্ত অ্যালগরিদম ব্যবহার করে স্পেসিফিকেশনটি খুব আক্ষরিকভাবে প্রয়োগ করে .. একটি বড় গল্ফিং ট্রিক হল আমি #গণনার সময় পরিবর্তে ফাঁকা স্থান ব্যবহার করছি এবং কেবলমাত্র #শেষে এগুলি প্রতিস্থাপন করব যা সহজ করে তোলে কোডটি এক জায়গায় এবং আমাকে Sপরিবর্তে '#বা "#"বেশ কয়েকটিতে ব্যবহার করতে দেয় ।

Sa       e# Push [" "], i.e. a 1x1 grid containing only a space as the
         e# initial fractal.
l~       e# Read and evaluate input.
W%       e# Reverse the list.
{        e# For each list element, assigning the element to variable I...
  _      e#   Duplicate the grid.
  Eff|   e#   Map (OR 14) over each character in the grid, turning spaces into
         e#   periods and leaving periods unchanged.
  a4*    e#   Create an array with four copies of this cleared grid.
  I@t    e#   Replace the Ith element in this list with the previous grid.
  2/     e#   Split this array into a 2x2 grid of subgrids...
         e#   Now it's getting a bit weird... we've got 4 dimensions now, which are:
         e#    - Rows of the 2x2 meta-grid.
         e#    - Cells in each row of the 2x2 meta-grid (i.e. subgrids).
         e#    - Rows of each subgrid.
         e#    - Characters in each row of each subgrid.
  :z     e#   Transpose each outer row, i.e. swap dimensions 2 and 3.
         e#   We've now got in each row of the meta-grid, a list of pairs of
         e#   corresponding rows of the subgrids.
  Sff*   e#   Join those pairs of rows with a single space each. We're now down
         e#   to three dimensions:
         e#    - Rows of the 2x2 meta-grid.
         e#    - Rows of each 1x2 block of the meta-grid.
         e#    - Characters in each row of those blocks.
  :z     e#   Transpose the blocks, i.e. turn the 1x2 blocks into a list of
         e#   columns of their characters.
  z      e#   Transpose the outer grid, i.e. turn it into a list of pairs of
         e#   corresponding columns in the two 1x2 blocks.
  Sf*    e#   Join each pair of columns with a single space. We've now got the
         e#   new grid we're looking for, but it's a list of columns, i.e. transposed.
  z      e#   Fix that by transposing the entire grid once more.
}I
N*       e# Join the rows of the grid with linefeeds.
S'#er    e# Replace all spaces with #.

— মার্টিন ইন্ডার
সূত্র

3

এমএটিএল , 42 41 বাইট

'.#'4:He!XIiP"Iq@=wX*1X@WZ(l5MY(]3Lt3$)Q)

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

এটি প্রতিটি পুনরাবৃত্তিতে অ্যারের প্রসারিত করতে ক্রোনেক্কার পণ্য ব্যবহার করে পুনরাবৃত্তভাবে কাজ করে । অ্যারে সঙ্গে নির্মিত হয় 0এবং 1পরিবর্তে .এবং #, এবং শেষে তাদের উপযুক্ত অক্ষর দ্বারা প্রতিস্থাপিত হয়।

ইনপুট আকারের মতো অনেকগুলি পুনরাবৃত্তি হবে। ডান থেকে বামে ইনপুট প্রক্রিয়া করা হয়। আইট্রেশন সূচকটি শুরু হয় 1।

চ্যালেঞ্জের উদাহরণটি ব্যবহার করে ইনপুট সহ [2,0]অ্যারেটিকে প্রাথমিকভাবে রূপান্তরিত করা হয়

1 2
3 4

এটি এক সারি এবং একটি কলাম দ্বারা প্রসারিত প্রাথমিক 1( #) এর সাথে মিলে যায়, যার উদ্দেশ্য পরে স্পষ্ট হবে। এই কলামগুলির মানগুলি গুরুত্বপূর্ণ নয়, কারণ সেগুলি ওভাররাইট করা হবে; তারা সমানভাবে হতে পারে:

1 1
1 1

প্রতিটি পুনরাবৃত্তিতে, বিদ্যমান অ্যারেটি ক্রোনেকার-দ্বারা 2-2 শূন্য-এক অ্যারের দ্বারা গুণিত হয় যা ইনপুটটির 1বর্তমান প্রবেশের দ্বারা এবং 0অন্য এন্ট্রিগুলিতে নির্দেশিত অবস্থানে থাকে । পুনরাবৃত্তির উদাহরণে i = 1, যেহেতু ডান দিকের ইনপুট এন্ট্রি 0, তাই শূন্য- ওন্য অ্যারে

1 0
0 0

এবং এই দুটি অ্যারের ক্রোনেকার পণ্য

এরপরে, সূচকের সারি এবং কলামটি 2^iভরাট হবে:

প্রথম তিনটি সারি এবং কলামগুলি প্রথম পুনরাবৃত্তির ফলাফল গঠন করে। আগের মতো, এখানে একটি অতিরিক্ত সারি এবং কলাম রয়েছে, যা পরবর্তী পুনরাবৃত্তিতে অ্যারে বাড়ানোর জন্য দরকারী।

পুনরাবৃত্তির সময় i = 2, যেহেতু বর্তমান ইনপুট 2মানটিতে উপরের অ্যারে রয়েছে ক্রোনেক্কার-দ্বারা গুণিত

0 0
1 0

যা দেয়

 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0
 1 1 0 0 0 0 0 0
 1 1 1 1 0 0 0 0
 0 1 0 0 0 0 0 0
 0 1 0 0 0 0 0 0

এক 2^iসাথে দেয়-সারি এবং কলাম পূরণ করে

 0 0 0 1 0 0 0 0
 0 0 0 1 0 0 0 0
 0 0 0 1 0 0 0 0
 1 1 1 1 1 1 1 1
 1 1 0 1 0 0 0 0
 1 1 1 1 0 0 0 0
 0 1 0 1 0 0 0 0
 0 1 0 1 0 0 0 0

যেহেতু এটিই সর্বশেষ পুনরাবৃত্তি, তাই অতিরিক্ত সারি এবং কলামটি সরানো হয়েছে:

 0 0 0 1 0 0 0
 0 0 0 1 0 0 0
 0 0 0 1 0 0 0
 1 1 1 1 1 1 1
 1 1 0 1 0 0 0
 1 1 1 1 0 0 0
 0 1 0 1 0 0 0

এবং চূড়ান্ত ফলাফল উত্পাদন করতে চরিত্রের প্রতিস্থাপন করা হয়:

...#...
...#...
...#...
#######
##.#...
####...
.#.#...

কোডটির বিশদ বিবরণ নিম্নলিখিত:

'.#'      % Push this string. Will be indexed into
4:He!     % Push 2×2 array [1 2; 3 4]
XI        % Copy it into clipboard I
iP        % Input array and reverse it
"         % For each entry of the reversed input
  I       %   Push [1 2; 3 4] from clipboard I
  q       %   Subtract 1 to yield [0 1; 2 3]
  @=      %   Compare with current entry of the input. Gives 2×2 array
          %   with an entry equal to `1` and the rest `0`
  wX*     %   Swap. Kronecker product
  1       %   Push 1
  X@      %   Push iteration index, i
  W       %   Compute 2^i
  Z(      %   Write 1 into column 2^i
  l       %   Push 1
  5M      %   Push 2^i again
  Y(      %   Write 1 into row 2^i
]         % End for each
3Lt       % Push [1, -1j] (corresponding to index 1:end-1) twice
3$)       % Apply index. Removes last row and column
Q         % Add 1. Gives an array of values 1 and 2
)         % Index into initial string

— লুইস মেন্ডো
সূত্র

2

হাস্কেল, 123 122 বাইট

unlines.foldr(#)["#"]
n#p=zipWith(++)(r++h:t)$('#':)<$>u++h:s where b='.'<$p<$p;h='#'<$p;(r:s:t:u:_)=drop n$cycle[p,b,b,b]

ব্যবহারের উদাহরণ:

*Main> putStr $ (unlines.foldr(#)["#"]) [2,3,1]
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
###############
...#...#.......
...#...#.......
...#...#.......
########.......
...#.###.......
...#####.......
...#.#.#.......

কিভাবে এটা কাজ করে:

                ["#"]      -- starting with "#" 
        foldr(#)           -- fold the function # from the right into the input
unlines                    -- and join the result with newlines

n#p=                       -- helper function #
                           -- n: next index, p: fractal so far
    zipWith(++)            -- join the left and right part elementwise
       (r++h:t)            -- left part
       ('#':) <$> u++h:s   -- right part (prepend '#' to each line for vertical
                           -- separator

                           -- helper
b='.'<$p<$p                -- b is a blank square of the same size as p
h='#'<$p                   -- h is a line of '#' of the same length as p
(r:s:t:u:_)=               -- drop the first n elements of the infinite
    drop n$cycle[p,b,b,b]  --   list [p,b,b,b,p,b,b,b,p,b,b,b,...] and
                           --   assign the next 4 element to r,s,t,u.
                           --   As r,s,t,u are always inserted at the
                           --   same position in the fractal, we get the
                           --   variants by assigning different values.

— nimi
সূত্র

1

জাভাস্ক্রিপ্ট (ES6), 171 152 বাইট

([d,...a],h=`#`,r=`replace`)=>d<4?(s=f(a)[r](/.+/g,s=>(t=s[r](/./g,`.`),d&1?t+h+s:s+h+t)),t=s[r](/.+/g,w=t+h+t),w=`
${w[r](/./g,h)}
`,d&2?t+w+s:s+w+t):h

পুনরাবৃত্ত কলের ফলাফল নেয়, তারপরে প্রতিটি লাইনকে নিজের সাথে একটি হ্যাশ প্লাস একই দৈর্ঘ্যের বিন্দুগুলির একটি স্ট্রিং প্রতিস্থাপন করে, যদি প্রয়োজন হয় বিপরীত ক্রমে, তারপরে আংশিক ফলাফলটি নিউলাইন এবং কেন্দ্রীয় কলাম ব্যতীত বিন্দুগুলির একটি স্ট্রিং তৈরি করে আশেপাশের নতুন লাইনের সাথে হ্যাশগুলির একটি স্ট্রিং এবং পরে হ্যাশগুলির একটি স্ট্রিং যথাযথ ক্রমে সেই তিনটি স্ট্রিংয়ের সাথে মিলিত হয়।

— নিল
সূত্র

1

রুবি, 143 134 বাইট

একটি বেনামী ফাংশন।

প্রথম লাইনের পুনর্বিন্যাসের মাধ্যমে 1 বাইট সংরক্ষণ করা হয়েছে। উপায় z পরিবর্তন করে 6 টি বাইট সংরক্ষণ করা হয় একটি সূত্র থেকে টেবিলের দিকে বাড়ানো হয়। ভেরিয়েবল অপসারণ করে 2 বাইট সংরক্ষণ করা হয়েছে w।

->a{r=-1+u=2<<a.size
s=(?.*r+$/)*r
a<<0
z=r*u/2-1
a.each{|i|r/=2
(-r..r).each{|j|s[z+j]=s[z+j*u]=?#}
z+=-r/2*[u+1,u-1,1-u,-u-1][i]}
s}

পরীক্ষা প্রোগ্রামে অসম্পূর্ণ

f=->a{
  r=w=(u=2<<a.size)-1        #w=length of line excluding newline, u=length of line including newline.
  s=(?.*w+$/)*w              #initialize string s with w rows of w dots terminated by newlines.
  z=w*u/2-1                  #z is the centre of the fractal
  a<<0                       #add a dummy value to the end of a
  a.each{|i|                 #for each element in a
    r/=2                     #r is the radius of the current iteration: ....15,7,3,1
    (-r..r).each{|j|         #for j=-r to r
      s[z+j]=s[z+j*u]=?#     #overwrite . with #, forming horizontal and vertical lines
    }
    z+=-r/2*(u+1)+           #move z to centre of upper left quarter (where it should be if i=0)
      i%2*(q=r+1)+           #move across if i=1,3
      i/2%2*q*u              #and down if i=2,3  
  }
s}                           #return string

puts $/,f[[]]

puts $/,f[[0]]

puts $/,f[[3]]

puts $/,f[[2,0]]

puts $/,f[[1,1]]

puts $/,f[[1,2,0]]

puts $/,f[[3,3,1]]

puts $/,f[[0,1,2,3]]

puts $/,f[[0,0,1,2,3]]

— স্তর নদী সেন্ট
সূত্র

0

রুবি, 150 বাইট

বেনামে ফাংশন। স্ট্রিংগুলির তালিকা তৈরি করতে একটি পুনরাবৃত্ত কলটি ব্যবহার করে, প্রতি লাইনে একটি স্ট্রিং, তারপরে সবগুলি একসাথে যোগ দেয়।

->i{f=->l{s=2**l.size-1;g=[[?.*s]*s]*4;m=->x,y{x.zip(y).map{|a,b|a+?#+b}}
s<1?[?#]:(g[l.shift]=f[l];m[*g[0,2]]+[?#*(2*s+1)]+m[*g[2,2]])}
f[i].join"
"}

— মান কালি
সূত্র

0

পাইথন 3.5, 1151 বাইট:

একটি কোড গল্ফ বেশি না, তবে ওহ ভাল। আমি যেখানে পারি সেখানে সময়ের সাথে সাথে আরও ছাঁটাই করার চেষ্টা করবে।

def x(s):
 y=[''];l=['#'];k=[' ']
 for z in s[::-1]:y.append(z)
 y=y[::-1]
 for h in range(len(y)):
  if y[-1]!='':u=(int(y.pop())&3)
  else:u=y.pop()
  if len(l)<2:k.append(u);p=((2**(len(k)-1))-1);l.append((('.'*p+'#'+'.'*p+'\n')*p)+'#'*((p*2)+1)+'\n'+(('.'*p+'#'+'.'*p+'\n')*p))
  else:
   if len(l)>2:del l[0]
   p=((2**(len(k)-1))-1);a=[[_+i for i in range(p)]for _ in range(len(l[1]))if _%((p*2)+2)==0 and _!=(((p*2)+2)*(p))];b=[[_+i for i in range(p)]for _ in range(len(l[1]))if _%(int(((p*2)+2)/2))==0 and _!=(int(((p*2)+2)/2)*((p)*2))and _ not in[g for i in a for g in i]];W=[g for i in a[:len(a)-(int(len(a)/2)):1]for g in i];B=[g for i in b[:len(b)-(int(len(b)/2)):1]for g in i];C=[g for i in a[len(a)-(int(len(a)/2)):len(a):1]for g in i];T=[g for i in b[len(b)-(int(len(b)/2)):len(b):1]for g in i];f=list(l[1])
   for i in list(''.join(l[0].split())):
    if u==0:f[W[0]]=i;del W[0]
    elif u==1:f[B[0]]=i;del B[0]
    elif u==2:f[C[0]]=i;del C[0]
    elif u==3:f[T[0]]=i;del T[0]
   del l[0];k.append(u);p=((2**(len(k)-1))-1);l.append(''.join(f));l.append((('.'*p+'#'+'.'*p+'\n')*p)+'#'*((p*2)+1)+'\n'+(('.'*p+'#'+'.'*p+'\n')*p))
 print(l[-2])

এটি করার একটি দুর্দান্ত নিখুঁত উপায়, তবে, বর্তমানে নিখুঁতভাবে কাজ করে এবং যেমন আপনি দেখতে পাচ্ছেন কোনও বাহ্যিক মডিউল / লাইব্রেরি ব্যবহার করে না । উপরন্তু, এটা গ্রহণ করতে পারেন উপায় প্রদান তালিকায় চেয়ে বেশি 5 আইটেম sকোনো সঠিকতা (যে, আপনার হার্ডওয়ার এটা সব ব্যবস্থা করতে সক্ষম হলে) হারানো ছাড়া। এটি সমস্ত প্রয়োজনীয়তা পূরণ করে এবং আমি যা পেয়েছি তাতে আমি আর খুশি হতে পারি না। :)

এটি এখন কেবলমাত্র 0=>3মানগুলির কোনও হিসাবে পরিসরের মধ্যে থাকা কোনও সংখ্যাকেই গ্রহণ করতে পারে না , তবে বিটওয়াইস অপারেটরকে ধন্যবাদ কোনও সংখ্যা , সময়সীমা &! আপনি তাদের সম্পর্কে এখানে আরও পড়তে পারেন । এখন, উদাহরণস্বরূপ, [4,4,1,2,3]ইনপুট তালিকাটি একই হিসাবে[0,0,1,2,3] ।

দ্রষ্টব্য: ইনপুট অবশ্যই তালিকা হিসাবে সরবরাহ হবে

ব্যাখ্যার সাথে নিরবচ্ছিন্ন:

def x(s):
 # Create 3 lists:
 # `y` is for the values of `s` (the list provided) and an empty element for the 
 # first pattern
 # `l` is reserved for the pattersn created through each item in list `y`
 # `k` is created for the value of `p` which is the main value through which the 
 # pattern is created.
 y=[''];l=['#'];k=[' ']
 # Reverse s, and then add each element from `s` to `y` 
 # (in addition to the empty element) 
 for z in s[::-1]:
     y.append(z)
 # `y` should now equal the list created, but reversed
 # If not reversed, then, if, for instance, the input is `0,1,2` and list `y` 
 # therefore contains `'',2,1,0`, the empty element will be called at the end, 
 # which is NOT what we want.
 y=y[::-1]
 # The main loop; will be iterated through the length of `y` number of times
 for h in range(len(y)):
  # Here is where each element from the end of `y` is recieved as `u` for 
  # use in the pattern in each iteration.
  # As you can also see, a bitwise operator (`&`) is used here so that 
  # ALL numbers can be accepted. Not just those in the range `0-4`.     
  # However, that will happen only if the value of y[-1] (the last elment in y) is 
  # NOT ''.
  if y[-1]!='':
      u=(int(y.pop())&3)
  else:
      u=y.pop()
  # If the length of list `l` is less than 2 
  # (which means it only contains `#`), then do the following:
  if len(l)<2:
      # Append `u` to `k`
      k.append(u)
      # Use the length of `k` as `n` in the operation `(2^(n-1)-1)` to get the 
      # length of the dot filled part of the new pattern.
      p=((2**(len(k)-1))-1)
      # Add that pattern to the list (currently empty, 
      # i.e. containing no other pattern in any other quadrant)
      l.append((('.'*p+'#'+'.'*p+'\n')*p)+'#'*((p*2)+1)+'\n'+(('.'*p+'#'+'.'*p+'\n')*p))
  # Now, if the length of l is >=2, do the following:
  else:
   # If the length of l is >2, then delete the first element in list `l` 
   # (this will happen only once, when the `#` is still the first element)
   if len(l)>2:
       del l[0]
   # Again, use the length of `k` as `n` in the operation `(2^(n-1)-1)`
   # to get the length of the dot filled part of the pattern.
   p=((2**(len(k)-1))-1)
   # Create a list with all the index values of all the dot elements on the left hand 
   # side of the grid l[-1], and the index value + i where i is every integer in 
   # the range `0-p` (this way, it will create lists within a list, each 
   # which contain `p` number of integers, which are all indexes of all the dots on 
   # the very left side of the grid) 
   a=[[_+i for i in range(p)]for _ in range(len(l[1]))if _%((p
      *2)+2)==0 and _!=(((p*2)+2)*(p))]
   # Create another list with all the index values of the dots using the same 
   # strategy as above, but this time, those in the right half of the grid. 
   b=[[_+i for i in range(p)]for _ in range(len(l[1]))if _%(int(((p*2)+2)/2))==0 
      and _!=(int(((p*2)+2)/2)*((p)*2))and _ not in[g for i in a for g in i]]
   # Create 4 lists, each containing index values specific to each of the 
   # 4 quadrants of the grid.
   # W is the list, based on A, containing all the indexes for the 1st quadrant of 
   # the grid in l[-1] containing dots (index 0 in the grid)
   W=[g for i in a[:len(a)-(int(len(a)/2)):1]for g in i]
   # B is the list, this time based on b, containing all indexes for the 2nd 
   # dot-filled quadrant of the grid l[-1] (index 1 in the grid)
   B=[g for i in b[:len(b)-(int(len(b)/2)):1]for g in i]
   # C is the list, also, like W, based on a, containg all the index values for 
   # the 3rd dot-filled quadrant of the grid in l[-1] (index 2 in the grid)
   C=[g for i in a[len(a)-(int(len(a)/2)):len(a):1]for g in i]
   # T is the final list, which, also like B, is based on b, and contains all the 
   # index values for the final (4th) dot-filled quadrant of the grid in l[-1] 
   T=[g for i in b[len(b)-(int(len(b)/2)):len(b):1]for g in i];f=list(l[1])
   # Finally, in this `for` loop, utilize all the above lists to create the new 
   # pattern, using the last two elements in list `l`, where each character of grid 
   # l[-2] (the second to last element) is added to the correct index of grid l[-1] 
   # based on the value of `u`
   for i in list(''.join(l[0].split())):
    if u==0:
        f[W[0]]=i
        del W[0]
    elif u==1:
        f[B[0]]=i
        del B[0]
    elif u==2:
        f[C[0]]=i
        del C[0]
    elif u==3:
        f[T[0]]=i
        del T[0]
   # Delete the very first element of `l`, as it is now not needed anymore
   del l[0]
   # Append `u` to list`k` at the end of the loop this time
   k.append(u)
   # Update the value of `p` with the new value of length(k)
   p=((2**(len(k)-1))-1)
   # Append the new patter created from the for-loop above to list `l`
   l.append(''.join(f))
   # Append a new, empty pattern to list `l` for use in the next iteration
   l.append((('.'*p+'#'+'.'*p+'\n')*p)+'#'*((p*2)+1)+'\n'+(('.'*p+'#'+'.'*p+'\n')*p))
 # When the above main loop is all finished, print out the second-to-last elment in 
 # list `l` as the very last element is the new, empty grid created just in case 
 # there is another iteration
 print(l[-2])

বিস্তৃত এবং আরও অনেকগুলি দৃষ্টি আকর্ষণীয় ব্যাখ্যা:

আরও বিস্তৃত এবং আরও দৃষ্টি আকর্ষণীয় ব্যাখ্যার জন্য, উপরের কোডটিতে "প্রধান" -লুপটি দ্বিতীয় বার যাবার ক্ষেত্রে ইনপুট তালিকাটি বিবেচনা করুন [0,2]। এই ক্ষেত্রে, "প্রধান" তালিকার উপাদানগুলি হ'ল l:

.#.
###
##.

এবং

...#...
...#...
...#...
#######
...#...
...#...
...#...

এবং তালিকায় yকেবল এটিই থাকবে 0। পাইথনের গ্রিডের শেষ উপাদানটিকে সূচিকরণের পদ্ধতিটি গ্রহণ করে l[-1]আমরা গ্রিডের খুব বাম উপাদানগুলিকে লেবেল করতে পারি :

 0 ...#...\n 7        
 8 ...#...\n 15
16 ...#...\n 23
   #######\n <- Ignore this as it is nothing but `#`s and a new line
32 ...#...\n 39
40 ...#...\n 47
48 ...#...\n 55

আপনি কি প্যাটার্ন দেখতে পাচ্ছেন? গ্রিডের একেবারে বামে প্রতিটি সূচকে 8 এর একাধিক হয় এবং যেহেতু সমীকরণটি ব্যবহার 2^(n-1)-1করে গ্রিডের প্রতিটি বিভাগের দৈর্ঘ্য পাওয়া যায়, তাই আমরা গ্রিডের ((2^(n-1)-1)*2)+2শীর্ষ প্রান্তের দৈর্ঘ্যটি সন্ধান করতে পারি (মাঝের #গুলি এবং \nশেষে অন্তর্ভুক্ত করতে +2 )। আমরা সেই সমীকরণটি ব্যবহার করতে পারি, যা আমরা iতালিকা তৈরি করে যে কোনও আকারের গ্রিডের বাম দিকে প্রতিটি উপাদানটির সূচক মানগুলি খুঁজতে ডাকব এবং প্রতিটি _সংখ্যার তালিকায় সংযোজন করব, যা আমরা কল করব , পরিসীমাতে 0=>length of grid l[-1], যেমন যে আইটেমটি একাধিক i, এবং এমনও যে _সমান নয়i*(2^(n-1)-1) , যাতে আমরা মধ্যম অংশটি বাদ দিতে পারি#গুলি উপরের অর্ধেকটি নীচের অর্ধেক থেকে পৃথক করে। তবে আমরা বাম দিক থেকে সমস্ত বিন্দু উপাদান চাই এবং কেবল খুব বাম দিকে থাকা উপাদানগুলিই চাই না। ঠিক আছে, এটির জন্য একটি সংশোধন রয়েছে, এবং এটি কেবলমাত্র তালিকার সাথে তালিকা যুক্ত করা হবে i+hযেখানে প্রতি পরিসরের 0=>2^(n-1)প্রতিটি সংখ্যার প্রত্যেক সময় রেঞ্জের থেকে একটি মান 0=>length of grid l[-1]তালিকায় যুক্ত করা হবে, যাতে প্রতিবার, সেখানে থাকবে বিন্দুগুলির এক চতুর্ভুজ দৈর্ঘ্যের হিসাবে তালিকায় অনেকগুলি সংখ্যক মান যুক্ত হয়েছে। এবং যে তালিকা a।

তবে এখন, ডান অর্ধেকের বিন্দুগুলি সম্পর্কে কীভাবে? ঠিক আছে, আসুন আমরা সূচকে অন্যভাবে দেখি:

   0 ...# 4  ...\n 7        
   8 ...# 12 ...\n 15
  16 ...# 20 ...\n 23
     #######\n <- Ignore this as it is nothing but `#`s and a new line
  32 ...# 36 ...\n 39
  40 ...# 44 ...\n 47
  48 ...# 52 ...\n 55

          ^
          | 

          These are the values we are looking at now

আপনি দেখতে পাচ্ছেন যে মাঝখানে মানগুলি এখন আমাদের প্রয়োজন যা হ'ল গ্রিডের ডানদিকে ডটগুলির প্রতিটি বিভাগের সূচকের সূচনা হিসাবে । এখন, এখানে প্যাটার্নটি কী? ঠিক আছে, যদি এটি ইতিমধ্যে যথেষ্ট পরিমাণে সুস্পষ্ট না হয় তবে এখন মাঝারি মানগুলি হ'ল সমস্ত গুণফল i/2! যে তথ্য দিয়ে, আমরা এখন আরেকটি তালিকা তৈরি করতে পারেন, bযা থেকে এর গুণিতক i/2ব্যাপ্তি থেকে যোগ করা হয় 0=>length of grid l[-1]যেমন যে যে পরিসর, যা আমরা আবার ডাকব থেকে প্রতিটি পূর্ণসংখ্যা _, তাই নয় কি সমান (i/2)*(p*2)লাইন বাদ দেওয়ার #শীর্ষ পৃথক s এবং নিম্নভাগ, এবং যেমন _ ইতিমধ্যে একটি তালিকায় নেই, যেহেতু সত্যই আমাদের 8,16,32, ইত্যাদি প্রয়োজন নেই don't তালিকায়b। এবং এখন আবার আমরা কেবল সেই নির্দিষ্ট সূচিগুলি চাই না। আমরা গ্রিডের ডানদিকে সমস্ত বিন্দু চাই। ঠিক আছে, আমরা যেমন তালিকায় করেছি ঠিক তেমন a, এখানে আমরা প্রতিটি সংখ্যার পরিসীমা যেখানে রয়েছে তার bতালিকাগুলিতেও যুক্ত করতে পারি ।_+hh0=>2^(n-1)

এখন, আমাদের দুটি তালিকা রয়েছে aএবং bপ্যাকড এবং প্রস্তুত রয়েছে ed এখন কীভাবে আমরা এগুলি একত্রিত করব? এই যেখানে তালিকা হয় W, T, G, এবং Cআসা। তারা গ্রিড বিন্দু প্রতিটি নির্দিষ্ট পাদ থেকে ইনডেক্স রাখা হবে l[-1]। উদাহরণস্বরূপ, আসুন Wগ্রিডের চতুর্ভুজ 1 (সূচক 0) এর সমান সূচকগুলির জন্য তালিকা হিসাবে তালিকা সংরক্ষণ করুন । এই তালিকায় আমরা 2^(n-1)তালিকা থেকে প্রথম তালিকাগুলি যুক্ত করব a, যেহেতু তালিকায় aগ্রিডের বাম অর্ধেক অংশের বিন্দুগুলির জন্য সমস্ত সূচী রয়েছে এবং তারপরে সেগুলি সমস্ত বিভক্ত করুন যাতে Wএখন (2^(n-1))*(2^(n-1))উপাদান থাকে। আমরা তালিকার জন্য একই করব T, তবে সেই Tতফাতের সাথে তালিকায় থাকা উপাদানগুলি থাকবেb , যেহেতুTচতুর্ভুজ 2 (সূচক 1) এর জন্য সংরক্ষিত। তালিকা Gতালিকা হিসাবে একই হবে Wছাড়া এটা তালিকা থেকে উপাদানগুলি বাকি থাকতে হবে a, এবং তালিকা Cতালিকা হিসাবে একই Tছাড়া এটা এখন তালিকা থেকে উপাদানগুলি বাকি রয়েছে b। এবং এটাই! গ্রিডে বিন্দুযুক্ত প্রতিটি কোয়াড্র্যান্টের জন্য এখন আমাদের সূচক মান রয়েছে , সবগুলি প্রতিটি চতুর্ভুজের সাথে সম্পর্কিত চারটি তালিকায় বিভক্ত। আমরা এখন এই 4 টি তালিকা ব্যবহার করতে পারি (ডাব্লু, টি, জি, সি) প্রোগ্রামটিকে গ্রিড l[-1]থেকে প্রতিটি অক্ষরের সাথে গ্রিডে প্রতিস্থাপন করা উচিত l[0], যা তালিকার একেবারে প্রথম উপাদান l। মানটি 0এখানে থাকায় এটি গ্রিড l[0]ব্যবহারের তালিকার সাথে প্রথম কোয়াড্রেন্ট (সূচক 0) এর সমস্ত বিন্দু প্রতিস্থাপন করবেW।

অতএব, আমাদের অবশেষে নিম্নলিখিতগুলি রয়েছে:

.#.#...
####...
##.#...
#######
...#...
...#...
...#...

রক্ষে! দীর্ঘ প্রক্রিয়া, তাই না? তবে এটি পুরোপুরি কাজ করে এবং আবারও আমি আর সুখী হতে পারি না। :)

— আর কাপ
সূত্র

একটি সূচকযুক্ত ফ্র্যাক্টাল আঁকুন

ভূমিকা

উদাহরণ

ইনপুট

আউটপুট

বিধি এবং স্কোরিং

পরীক্ষার মামলা

সিজেম, 59 47 43 41 40 বাইট

ব্যাখ্যা

এমএটিএল , 42 41 বাইট

ব্যাখ্যা

হাস্কেল, 123 122 বাইট

জাভাস্ক্রিপ্ট (ES6), 171 152 বাইট

রুবি, 143 134 বাইট

রুবি, 150 বাইট

পাইথন 3.5, 1151 বাইট:

ব্যাখ্যার সাথে নিরবচ্ছিন্ন:

বিস্তৃত এবং আরও অনেকগুলি দৃষ্টি আকর্ষণীয় ব্যাখ্যা: