সিয়ারপিনস্কি কার্পেট

23

ভাল ফ্র্যাক্টাল কে না ভালবাসে? Sierpinski কার্পেট একটি ফ্র্যাক্টাল -এর এটা একটা ধ্রুপদী উদাহরণ।

এই কাজটি সম্পন্ন করার জন্য, আপনাকে স্তরের কার্পেট উপস্থাপন করে, একটি কার্পেট প্রকারের তৈরি করতে হবে এনএবং ফলস্বরূপ চিত্রটি মুদ্রণ করতে হবে stdout(বিন্যাসের জন্য নীচে উদাহরণ দেখুন) এন। এই উইকিপিডিয়া নিবন্ধে পদক্ষেপগুলি পাওয়া যাবে ।

এই মানটি নেওয়া হবে stdinবা এর সমতুল্য হবে।

উদাহরণস্বরূপ, 4 এর ইনপুট একটি স্তর 4 গালিচা উত্পাদন করতে পারে:

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■
■   ■       ■   ■                   ■   ■       ■   ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

3 এর ইনপুট একটি স্তর 3 গালিচা উত্পাদন করতে পারে:

■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■
■   ■       ■   ■
■ ■ ■       ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■

2 এর ইনপুট একটি স্তর 2 গালিচা উত্পাদন করতে পারে:

■ ■ ■
■   ■ 
■ ■ ■

এবং 1 এর ইনপুটটি স্তরের 1 কার্পেট (কেবল একটি বর্গক্ষেত্র) উত্পাদন করবে:

■

কলামগুলির মধ্যে ফাঁকা স্থানগুলি নোট করুন।

ধারণাটি হ'ল ব্লকগুলির জন্য ■ অক্ষর এবং ফাঁকির জন্য স্থান ব্যবহার করা

রেখাটি ■ অক্ষর দিয়ে শুরু হয়।

সর্বদা হিসাবে, ক্ষুদ্রতম সমাধানটি অক্ষর গণনা অনুসারে জয়ী হয় (অ-মানক অক্ষরের কারণে)।

বিকল্পভাবে, ইউনিকোড সমর্থন করে না এমন ভাষাগুলিতে ■ চরিত্রের পরিবর্তে # টি ব্যবহার করা যেতে পারে।

code-golf  ascii-art  fractal 
— পল ক্লাভিয়ার
সূত্র
1
প্রথম উদাহরণটি কি দ্বিতীয়টির পরিবর্তে তৃতীয় স্তর নয়?
— অপ্টিমাইজার
6
দুর্দান্ত প্রশ্ন, তবে তাদের কি সেই চরিত্রগুলি হতে হবে? এগুলি ASCII নয়, যা প্রচুর ভাষাগুলির বিধান দেয়। এগুলি কি কেবল স্থান এবং এক্স বা হে হতে পারে? আমি আসলে মনে করি আপনার চিত্রটি ফাঁকা স্কোয়ারের পরিবর্তে স্পেসগুলির সাথে আরও ভাল দেখাচ্ছে।
— স্তর নদী সেন্ট
কার্পেটে স্পঞ্জ বদলেছে, ধন্যবাদ।
— পল ক্লাভিয়ার
আপনার ভাষা যদি ইউনিকোড আউটপুট সমর্থন না করে তবে কী একটি এসসিআইআই বিকল্প আছে?
— flawr
1
রেখাগুলি কি পিছনের স্থান থাকতে পারে?
— ডেনিস

উত্তর:

15

সিজেম, 38 37 31 30 28 টি অক্ষর

ওহ ভাল, আমরা অক্ষর দ্বারা গণনা করছি, সুতরাং আসুন কিছু ইউনিকোড আনপ্যাকিং করা যাক:

"B胷맋풽巓뱖ᮨ㣙¬䙧੥墱륋청"2G#b129b:c~

এটি এখানে পরীক্ষা করুন। কেবল ইনপুট ক্ষেত্রে পছন্দসই স্তরটি রেখে দিন।

ব্যাখ্যা

বেস রূপান্তর পরে, এই হয়

3li(#,{3b1f&2b}%_f{f{&S9632c?S}N}

ইউনিকোড চরিত্রের সাথে কেবল যা লিখেছেন তা নীচের মতো 9632c:

3li(#,{3b1f&2b}%_f{f{&S'■?S}N}

এই কোড নিম্নলিখিত পর্যবেক্ষণ উপর ভিত্তি করে: যদি আমরা স্থানাঙ্ক তাকান (X, Y) প্রতিটি কক্ষের, তাহলে আমরা একটি খালি সেল পেতে, যখনই উভয় এক্স এবং ওয়াই একটি আছে1 তাদের বেস-3 উপস্থাপনা একই অবস্থানে। আপনি যদি এটির বিষয়ে চিন্তা করেন তবে ছোট আকারের পুনরাবৃত্তি প্যাটার্নটি তাৎপর্যপূর্ণ বেস -3 ডিজিট, পরবর্তী পরবর্তী উল্লেখযোগ্য অঙ্কটি পরবর্তী বৃহত্তর স্কেলের পুনরাবৃত্তি পরিচালনা করে।

3                                      "Push a 3 on the stack.";
 li(                                   "Read input, convert to integer, decrement.";
    #                                  "Raise to that power. This yields the dimensions.";
     ,                                 "Turn into a range array.";
      {       }%                       "Map the block onto the array.";
       3b                              "Convert to base 3.";
         1f&                           "Bit-wise AND each digit with 1.";
            2b                         "Convert to base 2.";
                _                      "Duplicate this list.";
                 f{          }         "Map this block onto one list, with the second list
                                        as an additional parameter.";
                   f{      }           "Map this block onto the second list, with the first
                                        list's current element as an additional parameter.";
                                       "I.e. this iterates over all coordinate pairs.";
                     &                 "Bitwise AND to check that the base-3 representations
                                        had a 1 in the same position.";
                      S'■?             "Select the right character.";
                          S            "Push a space.";
                            N          "Push a newline";

ফলাফলযুক্ত অ্যারের সামগ্রীগুলি স্বয়ংক্রিয়ভাবে মুদ্রিত হয়।

তিনটি বাইট শেভ করার জন্য ডেনিসকে ধন্যবাদ।

— মার্টিন ইন্ডার
সূত্র
2
#0<'■S-> #~S'■1 অক্ষর সংরক্ষণ করে।
— অপ্টিমাইজার
আপনি প্রতিস্থাপন করতে পারেন [1_]a#~সঙ্গে 3Yba&।
— ডেনিস
পছন্দ করুন ধন্যবাদ!
— মার্টিন ইন্ডার
@ ডেনিস আমি ভুলে যেতে থাকি যা &সত্যবাদী / মিথ্যা মান উত্পন্ন করে (বা এমনকি এটি বিদ্যমান)। অ্যারেতে কিছু উপাদান রয়েছে কিনা তা পরীক্ষা করার জন্য সিজাম টিপসে কোনও পোস্টের পক্ষে মূল্যবান হতে পারে।
— মার্টিন ইন্ডার
1
@Ypnypn নাপ এটি আরও দীর্ঘ দেখায় তবে এটি ইউনিকোডের অক্ষরগুলি মনোস্পেস নয়। আনপ্যাকড কোডটিতে 30 টি অক্ষর রয়েছে।
— মার্টিন ইন্দার
7

মতলব (113) (110) (99) (85)

আপনি এটি এখানে চেষ্টা করতে পারেন (আপনাকে প্রতিস্থাপন করতে হবেinput('') আপনার পছন্দসই ইনপুটটি ))

এখন 99 জনকে ধন্যবাদ! আর এখন নিচে 85 টি আরটিএলকে ধন্যবাদ!

Golfed: 

a=ones(3);a(5)=0;c=1;for i=2:input('');c=kron(c,a);end;disp(char(kron(c,[1,0])*3+32))

Ungolfed:

a=ones(3);a(5)=0;c=1;  %creating the template / anchor
for i=2:input('');
    c=kron(c,a);       %recursive iterations
end;
disp(char(kron(c,[1,0])*3+32))


d=[c,c]*0;  %this is all just for adding the additional spaces
d(:,1:2:end)=c;
disp(char(d*3+32));    %converting to spaces (32) and # (35)

ব্যাখ্যা:

আমি এই কাজের জন্য ক্রোনেকার পণ্যটি অপব্যবহার করছি। (এটি প্রতিটি স্বেচ্ছা আকারের ম্যাট্রিক্সের জন্য সংজ্ঞায়িত একটি বিশেষ পণ্য Example উদাহরণ:

A = [1,2] is a 3x2 matrix, B is a nxm matrix.
    [3,4]
    [5,6]

তারপর 

kron(A,B) = [1*B , 2*B] is a 2n x 2m matrix.
            [3*B , 4*B]
            [5*B , 6*B]

সুতরাং n = 5 (পুরানো গণনা পদ্ধতিতে এটি 4) এর উদাহরণ রয়েছে;

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   #                                                       #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
— flawr
সূত্র
ধন্যবাদ, আমি লক্ষ্য করি না যে প্রয়োজনীয়তাগুলি পরিবর্তন হয়েছে। আমি
— কোডটিও
পরিবর্তে d=zeros(size([c,c]))আপনার ব্যবহার করা উচিত d=[c c]*0।
— ই
চমৎকার, একটি প্রস্তাবনা: পরিবর্তনশীল dঅপব্যবহারের দ্বারা এড়ানো যায় kron: আরো একবার disp(char(kron(c,[1,0])*3+32));,
— আরটিএল
5

পাইথন - 100

r=range(3**~-input())
for i in r:print" ".join("# "[any(i/3**k%3==j/3**k%3==1for k in r)]for j in r)
— Wrzlprmft
সূত্র
5

পার্ল 5: 68 টি অক্ষর

স্টিন উপর এন ।

#!/usr/bin/perl -l
//,print map/2/?"  ":"■ ",map$_+$',@,for@,=grep!/[24-9]/,0..3x<>/10

স্থানাঙ্কের তালিকার একটি দশমিক কোডেড ত্রৈমাসিক উপস্থাপনা প্রথমে উত্পাদিত হয় @,(নাম নির্বাচন করা হয়েছে @,এবং এর মধ্যে স্থানের প্রয়োজন নেই এবং for) অঙ্কগুলি 0, 1 এবং 3 ব্যবহার করে এখন দশমিক ডোমেনে x এবং y স্থানাঙ্ক যুক্ত করার সাথে একটি 2 থাকবে ফলস্বরূপ যদি এবং কেবলমাত্র যদি মিলনীয় পজিশনে দুটি থাকে। অভ্যন্তরীণ লুপের ডিফল্ট ভেরিয়েবল দ্বারা ছায়াযুক্ত হলে বাহ্যিক লুপ ( ) থেকে পোস্টম্যাচ ভেরিয়েবলের //ডিফল্ট ভেরিয়েবল প্রচার করতে ব্যবহৃত হয় ।$_for$'map

— nutki
সূত্র
4

জাভা, 330 283 টি অক্ষর

class T{public static void main(String[]a){int n=Integer.valueOf(a[0]);int m=(int)Math.pow(3,n-1);for(n=0;n<m;n++){for(int j=0;j<m;){String s="#";int x=n;int y=j++;while(x>0||y>0){if(x%3==1&&y%3==1){s=" ";}x/=3;y/=3;}p(s);}p("\n");}}static void p(String s){System.out.print(""+s);}}

পরম আপনি চান আকার। অ্যালগরিদমের জন্য কোনও অপ্টিমাইজেশন না থাকলে আমি সমস্ত কিছু বাদ দিয়ে চেষ্টা করেছি tried

এইগুলি সরানোর জন্য @ স্ট্রেচমানিয়াকে ধন্যবাদ i এবং ঘোষণাগুলি পরিষ্কার মোটামুটি কিছুটা নিচে নেমেছে।

পঠনযোগ্য কোড

class T {
    public static void main(String[] a) {
        int n = Integer.valueOf(a[0]);
        int m = (int) Math.pow(3, n - 1);
        for (n = 0; n < m; n++) {
            for (int j = 0; j < m;) {
                String s = "#";
                int x = n;
                int y = j++;
                while (x > 0 || y > 0) {
                    if (x % 3 == 1 && y % 3 == 1) {
                        s = " ";
                    }
                    x /= 3;
                    y /= 3;
                }
                p(s);
            }
            p("\n");
        }
    }

    static void p(String s) {
        System.out.print("" + s);
    }
}
— কম্পাস
সূত্র
আপনি করতে পারেন এমন প্রধান আরগ হিসাবে আপনি ক্লাসের আগে "পাবলিক" থেকে মুক্তি পেতে পারেন String[]aএবং যদি আপনি কেবল iএকবার ব্যবহার করে থাকেন তবে আপনি পদ্ধতি থেকে মুক্তি পাওয়ার থেকে ভাল better
— প্রসারিত পাগল
@ স্ট্রেচমনিয়াক টিপসটির জন্য ধন্যবাদ। আমি এগুলিকে কিছুটা বাস্তবায়ন করব।
— কমপাস
3
কেন আপনি পৃথিবীতে ""+sআপনার pপদ্ধতিতে করেন? একেবারে কোনও উদ্দেশ্য ছাড়াই এটি তিনটি অতিরিক্ত অক্ষর। এমনকি যদি sধরণটি ছাড়াও কিছু ছিল Stringতবে এটি সম্পূর্ণ অপ্রয়োজনীয় হবে।
— ডেভিড কনরাড
1
এটি পরিবর্তন static void p(int s){System.out.print((char)s);}এবং প্রধান এটিকে মধ্যে int s=35;, s=32;এবং p(10);(পরিবর্তে p("\n");) এবং আরো কয়েকটি অক্ষর সংরক্ষণ।
— ডেভিড কনরাড
আপনি পরিবর্তন করে সাত অক্ষর সংরক্ষণ করতে পারবেন Integer.valueOfকরারnew Byte
— Ypnypn
4

র‌্যাকেট 230 229 225 220

গল্ফ করার জন্য র‌্যাকেটের সেরা সময় নয়।

Golfed:

(define(s n)(letrec([t(λ(x y)(if(or(= x 0)(= y 0))"■"(if(=(modulo x 3)(modulo y 3)1)" "(t(floor(/ x 3))(floor(/ y 3))))))][i(expt 3(- n 1))])(for-each displayln(for/list([r i])(string-join(for/list([c i])(t r c))" ")))))

Ungolfed:

(define (s n)
  (letrec ([t (λ (x y)
                (if (or (= x 0) (= y 0)) 
                    "■"
                    (if (= (modulo x 3) (modulo y 3) 1)
                        " "
                        (t (floor (/ x 3)) (floor (/ y 3))))))]
           [i (expt 3 (- n 1))])
    (for-each displayln 
              (for/list ([r i])
                (string-join 
                 (for/list ([c i]) 
                   (t r c)) " ")))))
— ম্যাথু বাটারিক
সূত্র
4

সি: 123 118 111 104 টি অক্ষর

আমার পার্ল সমাধান হিসাবে একই ধারণা উপর ভিত্তি করে। কিছু স্পেস যুক্ত করার পরে:

m=0x55555555;
x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&m?"":"%c%c",x&x/n&m?32:35,x&n-1?32:10);
}

প্রতিটি অঙ্ককে 2 বিট দিয়ে কোডিংয়ের জন্য টের্নারি সিস্টেম ব্যবহার করে। অবৈধ মান (দুটি বিজোড়-এমনকি অবস্থানে থাকা) এর সাথে ফিল্টার করা হয় x & (x>>1) & 0b01010101। উভয় স্থানাঙ্ক এক মানেই সংরক্ষণ করা হয়, তাই পিক্সেলের রঙ চেক করে নেমে যায় x & (x >> 2 * n) & 0b01010101।nসুবিধার জন্য 2 একটি শক্তি হিসাবে সংরক্ষণ করা হয়।

সম্পাদন করা

defineএকটি সাধারণ ধ্রুবক সঙ্গে প্রতিস্থাপন m।

সম্পাদনা 2

0x5555555মুখোশটি দিয়ে প্রতিনিধিত্ব করা যেতে পারে (1LL<<32)/3, তবে আমাদের কেবল nসেই বিটগুলির প্রয়োজন তাই n/3যথেষ্ট।

x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&n*n/3?"":"%c%c",x&x/n&n/3?32:35,x&n-1?32:10);
}

সম্পাদনা 3

নাবালিকা টুইটগুলি। স্ক্যানফের উপর নির্ভরশীল এক 2 চর লাভের কার্যকরকরণের জন্য লোডিং মানের আগে nকার্যকর করা হচ্ছে --n। ইওল কেবল অনুসরণ করতে পারে #, দুহ ।

x;
main(n){
  n=scanf("%d",&n)<<2*--n;
  for(x=n*n;x--;)
    x&x/2&n*n/3||printf(x&x/n&n/3?"  ":x&n-1?"# ":"#\n");
}
— nutki
সূত্র
3

এইচটিএমএল / জাভাস্ক্রিপ্ট, 205 অক্ষর

ওবফাসকাটভিট , 205 চারস

document.write(unescape(escape('🁳𨱲𪑰𭀾𬰽𙰦𫡢𬱰𞰧𞱮🐴𞱭👍𨑴𪀮𬁯𭰨𜰬𫠭𜐩𞱦𫱲𚁩🐰𞱩🁭𞱩𚰫𛁤𚀧🁢𬠾𙰩𚑻𩡯𬠨𪠽𜀻𪠼𫐻𚑩𩠨𨰨𪐬𪠫𚰩𚑤𚀧𘰧𚐻𩑬𬱥𘁤𚁳𚑽𩡵𫡣𭁩𫱮𘁣𚁸𛁹𚑻𭱨𪑬𩐨𮁼𯁹𚑻𪑦𚁸𙐳🐽𜐦𙡹𙐳🐽𜐩𬡥𭁵𬡮𘀰𞱸👦𚁸𚐻𮐽𩠨𮐩𯑲𩑴𭑲𫠠𜑽𩡵𫡣𭁩𫱮𘁦𚁡𚑻𬡥𭁵𬡮𘁍𨑴𪀮𩡬𫱯𬠨𨐯𜰩𯑦𭑮𨱴𪑯𫠠𩀨𨐩𮱤𫱣𭑭𩑮𭀮𭱲𪑴𩐨𬰫𨐩𯐼𛱳𨱲𪑰𭀾🁳𭁹𫁥🠪𮱦𫱮𭀭𩡡𫑩𫁹𞠢𠱯𭑲𪑥𬠢').replace(/uD./g,'')))

এইচটিএমএল / জেএস, 298 চারস

এইচটিএমএল হোয়াইটস্পেসের সাথে কীভাবে খেলছে তার কারণে কয়েকটি অক্ষর এনএসপি চরকে উত্সর্গ করতে হয়েছিল। এছাড়াও, বেশিরভাগ ব্রাউজারের ডিফল্ট ফন্টটি কুরিয়ার নয়, তাই আমাকে এটিতেও সেট করতে হয়েছিল। স্টাইলিংয়ের প্রায় 20 টি অক্ষর। যদি এটির জন্য সরাসরি ইনপুট পদ্ধতি প্রয়োজন হয় তবে আমি এটি যুক্ত করতে পারি তবে বর্তমানে ইনপুট পরিবর্তন করা একটি আলাদা মানকে n সেট করে দিচ্ছে।

ডেমো

<script>s='&nbsp;';n=4;m=Math.pow(3,n-1);for(i=0;i<m;i++,d('<br>')){for(j=0;j<m;)if(c(i,j++))d('#');else d(s)}function c(x,y){while(x||y){if(x%3==1&&y%3==1)return 0;x=f(x);y=f(y)}return 1}function f(a){return Math.floor(a/3)}function d(a){document.write(s+a)}</script><style>*{font-family:"Courier"

পঠনযোগ্য এইচটিএমএল / জেএস

<script>
    s='&nbsp;';
    n=4;
    m=Math.pow(3,n-1);
    for(i=0;i<m;i++,d('<br>')){
        for(j=0;j<m;)
            if(c(i,j++))
                d('#');
            else d(s)
    }
    function c(x,y){
        while(x||y){
            if(x%3==1&&y%3==1)
                return 0;
            x=f(x);
            y=f(y)
        }
        return 1
    }
    function f(a){
        return Math.floor(a/3)
    }
    function d(a){
        document.write(s+a)
        }
</script>
<style>
*{font-family:"Courier"
— কম্পাস
সূত্র
3

সিজেম, 38 35 32 31 টি অক্ষর

"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

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

উদাহরণ রান

$ cjam <(echo '"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~') <<< 3; echo
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■

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

"՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

ইউনিকোড স্ট্রিংটি বেস 60,000 ( 6e4b) থেকে বেস 128 ( 128b), ক্যাসটরে ( :c) থেকে ক্যারেক্টারে ( ) রূপান্তর করে এবং ফলাফলটি স্ট্রিংয়ের মূল্যায়ন করে (~ ) ।

ফলস্বরূপ, নিম্নলিখিত কোডটি কার্যকর করা হয়:

"■ "                                " C := '■ '                                           ";
    li(                             " J := int(input()) - 1                               ";
       {                      }*    " for I in range(J):                                  ";
        z]A*                        "   T := [zip(C)] * 10                                ";
            ):,                     "   U := pop(T)                                       ";
               Sf*                  "   V := [ ' ' * len(u) : u ∊ U ]                     ";
                  4\t               "   U[4] := V                                         ";
                     3/{:+z~}%      "   C := { c : c ∊ zip(concat(u)), u ∊ U.split(3) }   ";
                              zN*  " print '\n'.join(zip(C))                              ";
— ডেনিস
সূত্র
3

পাইথন 3 - 116 113 টি অক্ষর

সম্পাদনা: আচ্ছা, আমি নিজের চেয়ে বেশি পছন্দ না এমন কৌশলটি ব্যবহার করেছি এবং কোডটি 3 বাইট দ্বারা সংকুচিত করেছি। ডান্নো যদি এটি সর্বোত্তম সম্ভাব্য উপায় তবে আমি এটির সাথে যাব।

exec(bytes('ⱴ㵬❛離₠崧氬浡摢⁡㩺癥污稨✫潦⁲湩琠❝਩潦⁲⁩湩爠湡敧椨瑮椨灮瑵⤨⴩⤱爺瀬氽✨㍛✪Ⱙ⡬嬢⭫‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠㩴牰湩⡴⥩','utf-16')[2:].decode('utf-8'))

এটিতে কিছু মুদ্রণযোগ্য অক্ষর থাকতে পারে, সুতরাং স্ট্রিংয়ের একটি মুদ্রণযোগ্য সংস্করণ এখানে।

'ⱴ㵬❛離₠崧氬浡摢\u2061㩺癥污稨✫\u206b潦\u2072\u206b湩琠❝\u0a29潦\u2072\u2069湩爠湡敧椨瑮椨灮瑵⤨\u2d29⤱爺瀬氽✨㍛✪Ⱙ⡬嬢\u2b6b‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠\u206e㩴牰湩⡴⥩'

খুব দুর্দান্ত নয়, তবে কমপক্ষে কয়েকটি ভাষায় মারধর করে।

এটি কিতে প্রসারিত:

t=['■ ']
for i in range(int(input())-1):r,p=[k*3for k in t],[k+'  '*(3**i)+k for k in t];t=r+p+r
for i in t:print(i)

কেউ যদি দেখতে না পারে যে এটি কীভাবে কাজ করে তবে কিছুটা দোষ না দেওয়া:

t=['■ ']                                     # iteration 1
for i in range(int(input()) - 1):            # do n-1 more iterations
    r = [k * 3 for k in t]                   # first & last rows are the last carpet x3
    p = [k + '  ' * (3 ** i) + k for k in t] # middle row: last carpet, space, last carpet
    t = r + p + r                            # and put them to the new carpet
for i in t:                                  # print final iteration
    print(i)
— PurkkaKoodari
সূত্র
বাহ অজগর, এটি চিত্তাকর্ষক
— পল ক্লাভিয়ার
3

গণিত, 71 বাইট

Grid@Nest[ArrayFlatten@ArrayPad[{{0}},1,{{#}}]&,1,#]/.{0->"",1->"■"}&

ইনপুট

3

আউটপুট

এখানে চিত্র বর্ণনা লিখুন

— J42161217
সূত্র
আমি আপনাকে মোট লতার মতো অনুসরণ করেছি +1;)।
— ম্যাজিক অক্টোপাস উরন
আপনি কি সাবস্টিটিউশন সিস্টেমের সাহায্যে এটি সংক্ষিপ্ত করতে পারবেন বলে মনে করেন ?
— ভিটিলিয় কৌরভ
2

বাশ + কোর্টিলস, 105 ইউনিকোড অক্ষর

যেহেতু আমরা অক্ষরগুলি গণনা করছি না বাইটগুলি:

eval `iconv -tunicode<<<潦⡲眨㌽⨪␨ⴱ⤱琬〽琻眼眪琻⬫⤩笻戠ꂖ昻牯⠨㵸╴ⱷ㵹⽴㭷㹸簰祼〾砻㴯ⰳ⽹㌽⤩笻⠠砨㌥ㄭ籼╹ⴳ⤱簩扼尽簠硼〽紻瀻楲瑮⁦␢⁢㬢⠨╴⵷⭷⤱簩敼档㭯੽|cut -b3-`

এর ডিকোডেড আকারে:

খাঁটি বাশ, 143 বাইট

for((w=3**($1-1),t=0;t<w*w;t++));{
b=■
for((x=t%w,y=t/w;x>0||y>0;x/=3,y/=3));{
((x%3-1||y%3-1))||b=\ ||x=0
}
printf "$b "
((t%w-w+1))||echo
}

কমান্ড-লাইন আর্গুমেন্ট থেকে ইনপুট নেওয়া হয়:

আউটপুট:

$ ./sierpinskicarpet.sh 3
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
$
— ডিজিটাল ট্রমা
সূত্র
2

সি শার্প

সম্পূর্ণ প্রোগ্রাম - 237:

using System;class P{static void Main(string[] a){int b=(int)Math.Pow(3,int.Parse(a[0])-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}Console.WriteLine(g);}}}

লিনকিউপ্যাড - 166 + Math.Ceiling(Math.Log(a + 1) / Math.Log(10))

int a=3;int b=(int)Math.Pow(3,a-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}g.Dump();}
— উইলিয়াম বার্বোসা
সূত্র
আমি জানি এটি প্রায় তিন বছর কেটে গেছে, তবে আপনি এর মতো কয়েকটি জিনিস গল্ফ করতে পারেন: using System;class P{static void Main(string[]a){string g,h;for(int b=(int)Math.Pow(3,int.Parse(a[0])-1),c=-1,d,e,f;++c<b;Console.WriteLine(g))for(g="",d=0;d<b;g+=h)for(h="■",e=c,f=d++;e>0|f>0;e/=3,f/=3)h=e%3==1&f%3==1?" ":h;}}( ২২৯ বাইট / ২২7 অক্ষর ) ( ■= ৩ বাইট, যাতে আপনি এটির #পাশাপাশি 2 বাইট সংরক্ষণ করতে পারেন )। আমি মূলত সবকিছু লুপের ভিতরে রেখে দিয়েছি যাতে আর বন্ধুর প্রয়োজন হয় না।
— কেভিন ক্রুইজসেন
2

সি - 154

স্টিডিন থেকে ইনপুট। আমি একটি অতিরিক্ত ফাংশন এড়ানোর জন্য একটি ভাল উপায় অনুসন্ধান করার চেষ্টা করেছি, তবে কোনওটিই সামনে আসতে পারিনি।

অক্ষর গণনা শুধুমাত্র প্রয়োজনীয় স্থান অন্তর্ভুক্ত।

p(l,x,y){
    return l?x/l&y/l&1||p(l/3,x%l,y%l):0;
}
x,y;
main(v){
    scanf("%d",&v);
    v=pow(3,--v);
    for(;y<v;y++,puts(""))
        for(x=0;x<v;)
            printf("%c ",p(v,x++,y)?32:35);
}
— Allbeert
সূত্র
1

পিএইচপি, 194 অক্ষর

nকমান্ড লাইনে প্রথম আর্গুমেন্ট হিসাবে পেয়েছি।

<?php
function d(&$a,$n,$e,$x,$y){if(--$n)for(;$i<9;)$p=pow(3,$n)|d($a,$n,$e|$i==4,$x+$p*$j,$y+$p*($i-$j)/3)|$j=++$i%3;else$a[$x][$y]=$e?" ":■;}@d($a,$argv[1]);foreach($a as$s)echo join($s),"
";

সুপাঠ্য

<?php

function draw(&$array, $n, $empty, $x, $y) {
    $n--;
    if ($n != 0) {
        for ($i = 0; $i < 9; $i++) {
            $j = $i % 3;
            $p = pow(3, $n);
            draw($array, $n, $empty || $i == 4, $x + $p * $j, $y + $p * ($i - $j) / 3);
        }
    } else {
        $array[$x][$y] = $empty ? " " : "#";
    }
}

$array = array();
draw($array, $argv[1], false, 0, 0);
foreach ($array as $line) {
    echo join($line), "\n";
}
— Gedrox
সূত্র
1
আপনি যদি এর ■পরিবর্তে চরটি ব্যবহার করেন তবে আপনি #উদ্ধৃতিগুলি সরিয়ে 2 টি অক্ষর সংরক্ষণ করতে পারেন।
— ইসমাইল মিগুয়েল
1

230 টি অক্ষর স্কেল করুন

গল্ফ কোড:

object T extends App {def m=math.pow(3,args(0).toInt-1).toInt-1;def p=print _;val x=0 to m;x.map{n=>x.map{j=>if(q(n,j)==1)p(" #");else p("  ")};p("\n");};def q(n:Int,j:Int):Int={if(n>0|j>0)if((n%3&j%3)==1)0 else q(n/3,j/3)else 1}}

অবহেলিত কোড:

object T extends App {
  def m = math.pow(3, args(0).toInt - 1).toInt - 1;

  def p = print _;
  val x = 0 to m;
  x.map { n => x.map { j => if (q(n, j) == 1) p(" #"); else p("  ")}; p("\n");};

  def q(n: Int, j: Int): Int = {
    if (n > 0 | j > 0) if ((n % 3 & j % 3) == 1) 0 else q(n / 3, j / 3) else 1
  }
}

শুধুমাত্র প্রয়োজনীয় স্থান অন্তর্ভুক্ত করা হয়।

— Mathill
সূত্র
1

ভি , 21 বাইট (প্রতিদ্বন্দ্বী)

é*Àñ}yPgvr PGï3pyGHP

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

Hexdump:

00000000: e92a c0f1 167d 7950 6776 7220 5047 ef33  .*...}yPgvr PG.3
00000010: 7079 4748 50                             pyGHP

ভি চ্যালেঞ্জের চেয়ে নতুন, সুতরাং এটি অবশ্যই প্রতিদ্বন্দ্বী হিসাবে চিহ্নিত করা উচিত। তবে তবুও, এই উত্তরটি অন্য সমস্তগুলির চেয়ে ওয়াএআয়ে আরও খাটো হওয়া ভাল, এমনকি চরিত্রগুলির চেয়ে বাইটে গণনা করাও ভাল।

— ডিজেএমসিএমহেম
সূত্র
কেবল একটি অনুস্মারক; এটি আর প্রতিযোগিতামূলক নয়
— রেডক্লুভার
1

ওকে, 40 বাইট

`0:" #"{(x-1)(,'//3 3#111101111b*9#,)/1}

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

এটি দিয়ে শুরু হয় 1, এবং তারপরে এটি গ্রিডে আঁকুন (1 1 1;1 0 1;1 1 1), এটি এটি একইভাবে গ্রিডে আঁকায় ইত্যাদি প্রয়োজনীয় বারবার পুনরাবৃত্তি করে।

— zgrep
সূত্র
1

সি # (.নেট কোর) , 162 বাইট

n=>{var f="";int s=(int)Math.Pow(3,n),z=0;while(z<s*s){int x=z%s,y=z/s,h=1;for(;x>0|y>0;y/=3,x/=3)if(y%3==1&x%3==1)h=0;f+=" #"[h]+(z++%s<s-1?" ":"\n");}return f;}

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

Degolfed

n=>{
    var f="";
    int s=(int)Math.Pow(3,n),z=0;

    while(z<s*s)
    {
        int x=z%s, y=z/s, h=1;
        for(; x>0 | y>0; y/=3, x/=3)
            if(y%3==1 & x%3==1)
                h=0;

        f += " #"[h] + (z++%s<s-1? " " : "\n");
    }

    return f;
}
— Ayb4btu
সূত্র
0

আর , 92 টি অক্ষর

বিশেষ চরিত্রের সাথে 94 বাইট।

write(c(" ","■")[1+Reduce("%x%",rep(list(matrix(c(1,1,1,1,0,1),3,3)),n<-scan()-1),1)],1,3^n)

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

— : Giuseppe
সূত্র
আমি কেবল অবাক হয়েছি 4 বছর পরেও লোকেরা এটি করছে
— পল ক্লাভিয়ার
1
@ পলক্লেভিয়ার এটি একটি দুর্দান্ত চ্যালেঞ্জ; আপনার গর্বিত হওয়া উচিত :)
— জিউসেপ
0

ক্যানভাস , 17 16 17 টি অক্ষর

■；╷［⌐ ＋２×；┌∔∔；３＊＋

এখানে চেষ্টা করুন!

-1: লুপের ভিতরে প্রথমটি মুছার পরিবর্তে ব্যবহৃত ［হয় । ｛；
+1: স্থির ত্রুটিপূর্ণ আচরণ: ■মূল পোস্টে উল্লিখিত হিসাবে এখন স্তর 1 এর সাথে মিল রয়েছে ।

— hakr14
সূত্র
এটি একটি নতুন is কমত্য প্রতিযোগিতামূলক হয়।
— এরিক দ্য আউটগল্ফার
@ এরিকথ আউটগলফার ওহ, আমাকে জানাতে ধন্যবাদ!
— hakr14
এবং হ্যাঁ, এই ক্ষেত্রে স্কোর হল 17, কিন্তু আমরা বাইটে সমাধান, না অক্ষর (ক্যানভাস একটি কোড পেজ আছে) গণনা।
— এরিক আউটগল্ফার
@ এরিকথ আউটগলফার সাধারণত হ্যাঁ, তবে এই চ্যালেঞ্জটি বহুগুণে ■থাকার কারণে অক্ষরগুলি ব্যবহার করে । মূল পোস্টে নীচের দিকে তাই বলে।
— hakr14
আপনার সমস্ত ইনপুটগুলিতে আপনাকে একটি যুক্ত করতে হবে। 1 এর একটি স্কোয়ার ফিরিয়ে দেওয়া উচিত (অর্থাত এখানে 0 কী ফিরে আসে)
— পল ক্লাভিয়ার
0

পিপ -S , 30 টি অক্ষর

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3

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

মূল ধারণা: বেস 3 এ একটি সমন্বিত গ্রিড বিবেচনা করুন কার্পেটের গর্তগুলি ঘটে যেখানে 1) এক্স-কো-অর্ডিনেটের একটি ট্রিট 1এবং 2) y- স্থানাঙ্কের একই পদে ট্রিটও হয় 1।

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3
                                i is 0; a is 1st cmdline arg (implicit)
                        3**a/3  Width/height of the carpet
                      MC        Make a coordinate grid that size and map this function
                                to the coordinate pairs:
                    g            Take each [x y] pair
                  MS             Map this function to each coord and add the results:
         {aTB3   }                Convert to base 3
              R2i                 Replace 2's with 0's
                                  E.g. 15 -> 120 -> 100 and 16 -> 121 -> 101
                                 When we add the results, we get [15 16] -> 201
      MX{            }           Take the max of that list (0, 1, or 2)
"■■ "@                           Use that to index into this string (resulting in a space
                                 iff two 1's coincided to make a 2, or ■ otherwise)
                                Print the resulting nested list with each sublist on its
                                own line and space-delimited (implicit, -S flag)

অনুরূপ সমাধান, একই সংখ্যক অক্ষর কিন্তু -২ বাইট: {2N({aTB3R2i}MSg)?s'■}MC3**a/3

— DLosc
সূত্র
0

কে (এনএনজি / কে) , 50 বাইট

ধন্যবাদ @ ডিএলকাস আমাকে মনে করিয়ে দেওয়ার জন্য আমার কলামগুলির মধ্যে ফাঁকা স্থান আউট করা উচিত

1@"\n"/"# "1_',/'1,''+/''a*/:\:a:+2!!1_(. 0:"")#3;

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

— ngn
সূত্র
@ ডিএলসকে ধন্যবাদ, অন্যান্য অদ্ভুত প্রয়োজনীয়তাগুলিও স্থির করে: স্ট্যান্ডিন / স্টডআউটটি আর্গ / ফলাফলের পরিবর্তে; একের পর এক "স্তর"
— এনএনজি
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.