চ্যালেঞ্জ

একটি আকার দেওয়া হয়েছে, হ্যাশ চিহ্ন ( #) এবং স্পেসস ( ) দিয়ে তৈরি আকারের একটি ঘনক্ষেত মুদ্রণ করুন ।

উদাহরণ:

1:
  #
# # #    
  #
  #

2:
    # #
    # #
# # # # # #
# # # # # #
    # #
    # #
    # #
    # #

3:
      # # #
      # # #
      # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
      # # #
      # # #
      # # #
      # # #
      # # #
      # # #

নেট আসলে কোনও বৈধ কিউব নেট হতে পারে যা একটি ঘনককে ভাঁজ করতে পারে, উদাহরণস্বরূপ:

    # #
    # #
# # # # # # # #
# # # # # # # #
    # #
    # #

    # # # #
    # # # #
    # #
    # #
    # #
    # #
# # # #
# # # #

বিধি

ফলস্বরূপ নেট অবশ্যই জ্যামিতিকভাবে বৈধ হতে হবে (কিউবে ফোল্ডেবল)
স্ট্যান্ডার্ড লুফোলস নিষিদ্ধ
নিয়মগুলি মনোযোগ সহকারে পড়ুন
এটি কোড-গল্ফ , সংক্ষিপ্ত উত্তর জয়, তবে নির্বাচিত হবে না

— dkudriavtsev
সূত্র

1

নেতৃস্থানীয় / পিছনে স্থান / নিউলাইনস থাকতে পারে?

— ক্রিটসি লিথোস

@ ক্রিটিক্সিলিথোস হ্যাঁ

— dkudriavtsev

13

রেফারেন্সের জন্য, সমস্ত 11 কিউব নেট ।

— xnor

3

আমি যদি নিয়মগুলি মনোযোগ সহকারে না পড়ি তবে কী হবে?

— স্টেইনবার্গ

1

@ সটেনবার্গ তারপরে আপনার সমাধানটি অবৈধ

— dkudriavtsev

23

পাইথন 2, 47 বাইট

n=input()
for c in 1,4,1:exec"print'# '*c*n;"*n

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

বাম-ন্যায়সঙ্গত হওয়ার জন্য বেছে নেওয়া এই জালটি মুদ্রণ করে:

# # 
# # 
# # # # # # # # 
# # # # # # # # 
# # 
# #

লাইনগুলির কপি nবা 4*nরয়েছে '# '। প্রত্যেকটির জন্য 1,4,1, আমরা nঅনেকগুলি অনুলিপি, লাইনগুলির nজন্য বার বার প্রিন্ট করি n। একটি execলুপের ভিতরে একটি forলুপ থাকা অপব্যয়যুক্ত বলে মনে হয় তবে আমি এর চেয়ে ভাল আর দেখতে পাইনি।

বিকল্প আমি পরীক্ষিত:

lambda n:('# '*n*3+'\n')*n+('  '*n+'# '*n+'\n')*3*n

lambda n:('# '*n*3+'\n')*n+(' '*4*n+'# '*n*3+'\n')*n

def f(n):
 for c in[3]*n+[1]*3*n:print('# '*c*n).center(6*n)

def f(n):
 for c in[4]*n+[0]*n:print' '*c*n+'# '*n*3

def f(n):
 for c in[1]*n+[4]*n+[1]*n:print'# '*c*n

def f(n):
 c=1;exec("print'# '*c*n;"*n+"c^=5;"*n)*3

def f(n):
 for i in range(3*n):print'# '*[1,4,1][i/n]*n

def f(n):
 for c in 1,4,1:print('# '*c*n+'\n')*n,

def f(n):
 for c in 1,4,1:exec"print'# '*c*n;"*n

( defকার্যক্রমে সমস্ত একটি প্রোগ্রাম হিসাবে সংক্ষিপ্ত হতে পারে।)

— xnor
সূত্র

8

অক্টাভা, 58 44 42 32 বাইট

@(n)[z=repmat('# ',n);z,z,z,z;z]

আংশিকভাবে @ এক্সনরের অজগর উত্তর দ্বারা অনুপ্রাণিত।

z=repmat('# ',n);

ইনপুট 2 ফলাফলের জন্য নিম্নলিখিত প্যাটার্নের জন্য '#' এর একটি বর্গ নকশা তৈরি করে:

# #             
# # 

y=[z,z,z,z];

চারটি zঅনুভূমিকভাবে সংক্ষিপ্ত:

# # # # # # # # 
# # # # # # # # 

[z;y;z]

zএবং yএবং zউল্লম্বভাবে ঘনিভূত হয়

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

# #             
# #             
# # # # # # # # 
# # # # # # # # 
# #             
# #

পূর্ববর্তী উত্তর:

@(n){h(1:n,1:2:n*6)=1;h(1:n*4,n*2+1:2:4*n)=1;' #'(h+1)}{3}

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

টি আকারের একটি তৈরি করে

# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #      
      # # #

— rahnema1
সূত্র

6

গণিত, 77 60 52 বাইট

8 বাইট দূরে গল্ফ করার জন্য মার্টিন ইন্ডারকে ধন্যবাদ!

{±s_:=s~Table~#;b=±{a=±"# ","
"},±{a,a,a,a,"
"}}<>b&

অজানা ফাংশনটি ইতিবাচক পূর্ণসংখ্যার যুক্তি গ্রহণ করে #এবং নতুন লাইনের সাথে একটি স্ট্রিং ফিরিয়ে দেয় (একটি ট্রেলিং নিউলাইন সহ); প্রতিটি লাইনের পাশাপাশি চলার জায়গাও রয়েছে। প্রথমে আমরা ±একটি ফাংশন হিসাবে সংজ্ঞায়িত করি যা এর ইনপুট বারগুলি পুনরাবৃত্তি করে #; তারপরে aসংজ্ঞায়িত করা হয় ±"# "( #এটি একটি অক্ষর, ইনপুট নয়!) এবং এ থেকে সংক্ষিপ্ত রেখার bসেট হিসাবে সংজ্ঞায়িত করা হয় #, যখন লম্বা রেখার ±{a,a,a,a}<>nসেট হয় #। (উভয় ক্ষেত্রেই মিলের উদ্ধৃতিগুলির মধ্যে একটি আক্ষরিক লাইনফিড রয়েছে)) চূড়ান্তটি <>bসংক্ষিপ্ত রেখাগুলির সেটের দ্বিতীয় অনুলিপি সহ স্ট্রিংগুলির ফলাফলের তালিকাটিকে সম্মতি দেয়। উদাহরণ আউটপুট যখন #=2( এক্সনরের উত্তর আমাকে শিখিয়েছিল যে এই অভিযোজনটি গল্ফিয়ার):

# #     
# #     
# # # # # # # # 
# # # # # # # # 
# #     
# #

এই প্রয়োগের পূর্ববর্তী সংস্করণ:

""<>(±s_:=s&~Array~#;{b=±{a=±"# ",n="\n"},±{a,a,a,a}<>n,b})&

আসল জমা:

""<>If[(m=n~Mod~t)==0,"\n",If[n<t#||#<m<=2#,"# ","  "]]~Table~{n,4(t=3#+1)#}&

একটি স্ট্রিং আউট তৈরী করে 4*(3#+1)টুকরা, প্রতিটি যা পারেন হয় "# ", " "অথবা "\n"; সূচকের ভিত্তিতে কোন টুকরোটি ব্যবহার করতে হবে তা কেবল গণনা করে n। উদাহরণ আউটপুট যখন #=2:

# # # # # # 
# # # # # # 
    # #     
    # #     
    # #     
    # #     
    # #     
    # #

— গ্রেগ মার্টিন
সূত্র

5

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

f=
n=>`141`.replace(/./g,m=>`${`# `.repeat(n*m)}\n`.repeat(n))

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

স্নিপেট প্রসারিত করুন

আউটপুট প্রতিটি লাইন শেষে একটি পিছনে স্থান এবং একটি পিছনে নতুন লাইনের অন্তর্ভুক্ত।

— নিল
সূত্র

5

রুবি, 36 বাইট

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}

ব্যবহার:

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}
f[3]
# # #
# # #
# # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # #
# # #
# # #

রুবি, 38 বাইট

এই আকৃতিটি রুবিতে দীর্ঘতর তবে আমি আশা করি কিছু ভাষা আছে যেখানে এটি সংক্ষিপ্ত।

->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}

ব্যবহার:

g=->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}
g[3]
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #

উভয় উত্তর সংক্ষিপ্ত হতে পারে যদি এটি স্ট্রিংগুলির একটি অ্যারে (অগ্রাধিকারতভাবে) বা মুদ্রণের পরিবর্তে একক স্ট্রিংকে (কম বেশি পছন্দ করা হয়) ফেরত দেওয়ার অনুমতি দেওয়া হয়।

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

একটি স্ট্রিং ফিরে আসা আউটপুট একটি বৈধ ফর্ম হিসাবে বিবেচনা করা হয়।

— dkudriavtsev

4

স্কালা, 56 বাইট

(n:Int)=>Seq(1,4,1)map("# "*_*n+"\n")map(_*n)mkString ""

— jaxad0127
সূত্র

4

জাভাস্ক্রিপ্ট (ES6), 71

n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

পরীক্ষা

f=
n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

function update() {
  O.textContent=f(I.value)
}

update()

<input id=I type=number value=3 oninput='update()'><pre id=O></pre>

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

আমি পুরোপুরি নিশ্চিত নই, তবে আমি মনে করি আপনাকে হ্যাশগুলির সাথে ফাঁকা স্থানগুলি আউটপুট করতে হবে। (আমার উত্তরের প্রথম সম্পাদনায় শূন্যস্থানগুলি না অন্তর্ভুক্ত করার জন্যও আমি এই ভুলটি করেছি)

— ক্রিটসি লিথোস

@ ক্রিতিক্সিলিথোস উহ, পেয়েছেন ধন্যবাদ

— edc65

4

জাভা 8, 99 বাইট

l->{for(int i=-1,j;++i<3*l;)for(j=-1,k=(i/l==2)?4*l:l;++j<k;)System.out.print("# "+j>k-2?"\n":"");}

— রোমান গ্রাফ
সূত্র

4

ভি , 24 23 20 18 20 বাইট

Ài# ddÀpLyGïp3PGïp

সমস্ত লুকানো অক্ষর দেখানো হয়েছে

Ài# ^[ddÀp^VLyGïp3PGoïp

^[হয় 0x1b(এস্কেপ অক্ষর আক্ষরিক) এবং ^Vহয় 0x16( C-v)

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

আমাকে বাইকাউন্ট বাড়াতে হয়েছিল কারণ Äএই নতুন ভি টানে কমান্ডটি বাগি হচ্ছে

এই বিন্যাসে ফলাফল:

# 
# # # # 
#

একটি শীর্ষস্থানীয় নিউলাইন সহ

Hexdump:

00000000: c069 2320 1b64 64c0 7016 4c79 47ef 7033  .i# .dd.p.LyG.p3
00000010: 5047 ef70                                PG.p

ব্যাখ্যা

Ài# ^[              " Argument times insert "# "
ddÀp                " Argument times duplicate line

এখন নেটটির একটি মুখ সম্পূর্ণ হয়ে গেছে, আমাদের নেট তৈরি করতে হবে

^VLy                " Copy the face
Gïp                 " Paste it at the end of buffer
3P                  " Paste 3 times (these form the line)
Gïp                 " Paste at end of buffer again

বিকল্প স্থানটি যদি আমরা স্পেসগুলি আউটপুট না করি:

21 20 18 16 18 বাইট

Àé#ddÀpLyGïp3pGïp

(শীর্ষ সমাধান হিসাবে একই কারণে, এই টিআইও লিঙ্কটি পরিবর্তন করা হয়েছে)

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

— ক্রিটসি লিথোস
সূত্র

4

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

Ài# 5Ù4JjòÀÄk

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

00000000: c069 2320 1b35 d934 4a6a f2c0 c46b       .i# .5.4Jj...k

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

ব্যাখ্যা:

À                   " Arg 1 times:
 i# <esc>           "   Insert the string "# "
         5Ù         " Make 5 copies of this line, and put the cursor on the second copy
           4J       " Join four of these lines together
             j      " Move down to the last line
              ò     " Recursively:
               ÀÄ   "   Make Arg 1 copies of this line
                 k  "   And move up a line

— ডিজেএমসিএমহেম
সূত্র

পরিষ্কার করা, Jবিষয়টি আমি যতদূর জানি কোডিং পঙ্কিল ছিল না, আমার মনে হয় এটা শুধু nvim ডিফল্ট ছিল?

— nmjcman101

হ্যা ওটা সত্য. তবে সদৃশ অপারেটরটি অবশ্যই নিশ্চুপ ছিল। ধন্যবাদ এই নতুন সংস্করণটি অনেক সহজ।

— ডিজেএমসিএমহেম

4

জেলি , 20 19 বাইট

”#xẋ³Wẋ³K€Y
141DÇ€Y

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

-1 44874 (স্টেনবার্গ) ধন্যবাদ।

^{আমি আউটগলফ মুডিফিশফ সাহায্য করতে পারি না!}

এটি কি গল্ফযোগ্য ??? 20 19 বাইট দেখতে লিংক 1 দেখে মনে হচ্ছে অনেক বেশি ।

ব্যাখ্যা:

”#xẋ³Wẋ³K€Y Helper link. Arguments: z
”#          Character #.
            y (implicit)
  x         Repeat each element of y x times.
    ³       1st command-line argument.
   ẋ        Repeat x y times.
     W      Wrap z.
       ³    1st command-line argument.
      ẋ     Repeat x y times.
        K   Join z on spaces.
         €  Map this link on x.
          Y Join z on newlines.

141DÇ€Y Main link. Arguments: 0
141     Integer 141.
   D    Convert z to base 10.
    Ç   The above link as a monad.
     €  Map this link on x.
      Y Join z on newlines.

— এরিক দ্য আউটগল্ফার
সূত্র

এটি এখন ভি বনাম জেলি :)

— ক্রিটসি লিথোস

@ ক্রিতিক্সিলিথোস নাহ, আপনার সমাধানটি প্রথম ছিল।

— এরিক আউটগলফার

ভি এখন 18 বাইটে রয়েছে :)

— ক্রিটসি লিথোস

আপনি ব্যবহার করছেন না দ্বারা একটি বাইট ড্রপ করতে পারেন @কিন্তু operands সোয়াপিং xনিজেকে: ”#xẋ³Wẋ³K€Y।

— স্টেইনবার্গ

3

কাঠকয়লা , 20 বাইট

ＮλＧ↑λ←×⁶λ↓λ# ＤＭ×⁴λ←

কোডটি একটি স্পেস দিয়ে শেষ হয়। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

কাঠকয়লা ASCII শিল্পে বিশেষীকরণ করা একটি ভাষা। এটি অসম্পূর্ণ, বগি এবং ডকুমেন্টেড। এটি বলার অপেক্ষা রাখে না, এটি যা যা অনুমান করা হয়েছিল তা করার আগে এটি যথেষ্ট পরিমাণে বিচার এবং ত্রুটি নিয়েছিল।

Ｎλএকটি নম্বর ইনপুট λ।
Ｇবহুভুজ কমান্ড, যা আমরা এখানে একটি আয়তক্ষেত্র আঁকতে ব্যবহার করব। ↑λ←×⁶λ↓λবহুভুজের সীমানা সুনির্দিষ্ট করে: λwardর্ধ্বমুখী পদক্ষেপ, বাম দিকে times বার λধাপ এবং নিম্নমুখী λপদক্ষেপ। (এই তিনটি এর λদ্বারা λআয়তক্ষেত্র নীচে প্রান্ত অনুমিত হয় ব্লক সাইড-বাই-সাইড।)। বহুভুজটি তারপর স্ট্রিং দিয়ে পূর্ণ হয় # ।
Ｄ বর্তমান ক্যানভাসকে স্টাডাউটে ফেলে দেয়, এর ফলে এমন কিছু ঘটে:

 # # # # # # # # # #
 # # # # # # # # # #
 # # # # # # # # # #

Ｇকমান্ডের পরে , কার্সারটি ক্যানভাসের নীচে বাম কোণে রয়েছে। Ｍ×⁴λ←প্যাচসমূহ 4 গুণ leftward λপদক্ষেপ (দুই সমতূল্য λদ্বারা λব্লক)।
ক্যানভাসটি বাম দিকে সঠিক পরিমাণে প্রসারিত করে সেখানে একটি স্থান আউটপুট দেয়।
প্রোগ্রামের শেষে, ক্যানভাসটি (আবার) স্টাডআউটে পাঠানো হয়েছে:

             # # # # # # # # # #
             # # # # # # # # # #
             # # # # # # # # # #

তাদের একসাথে রাখুন এবং আপনি একটি কিউব নেট পেয়েছেন।

— DLosc
সূত্র

বাহ, আপনাকে তখন লড়াইয়ে ফিরে যেতে হয়েছিল! (বেশ কয়েক সপ্তাহ পরে ওবলং যোগ করা হয়নি।)

— নীল

2

বাশ / ইউনিক্স ইউটিলিটিস, 72 69 68 66 বাইট

b()(yes `dc<<<2o4d$n^$1^3/p`|tr 01 ' #'|head -$n);n=$1;b 1;b 4;b 1

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

এটি [4 ^ k / 3], বেস 2 তে যখন লেখা হয় তখন কে 1 এর সাথে 10101010 ... 01 হয় এমনটি ব্যবহার করে এটি কাজ করে। (এখানে বর্গাকার বন্ধনীগুলি মেঝের ক্রিয়াকে বোঝায়))

— মিচেল স্পেক্টর
সূত্র

2

পাইকে, 16 বাইট

uAD,sXF**"#

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

সমতুল্য

1 4 1]3AD,sXF**"#

ছাপিয়ে না পারার কারণে

এটি বাইট-কাউন্ট কমাতে কয়েকটি কৌশল ব্যবহার করে:

এটি তালিকাটি উপস্থাপনের জন্য কিছু অ-ছাপ ব্যবহারযোগ্য [1, 4, 1]
XF স্বয়ংক্রিয়ভাবে স্ট্যাক আউটপুট ডাম্প
"#শেষের স্ট্রিংটি সর্বশেষের সাথে অদলবদল হয় *, যার অর্থ সমাপ্তি "প্রয়োজন হয় না। এটি স্পষ্টতই ঘটে যখন শেষ টোকেনটি একটি স্ট্রিং থাকে।

u                -      [1, 4, 1]
     AD          -     apply(*, ^, input)
       ,         -    zip(^)
        s        -   sum(^)
          F**"#  -  for i in ^:
           *     -    ^ * input
            *    -   ^ * v
             "#  -    "# "
         X       - splat(^)

— নীল
সূত্র

2

পাইথন 2 , 68 71 65 বাইট

@ সাগিক্স্পকে ধন্যবাদ দিয়ে 6

def f(i,c=1):
 print(' '*i*4,'')[c>i]+'# '*i*3
 if i*2>c:f(i,c+1)

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

@ এক্সনরকে মারধর করার কোনও উপায়ের অভাবে আমি আমার পুনরাবৃত্ত ফাংশনটি কেবল বিকল্প পদ্ধতির হিসাবে পোস্ট করব। চ (5) প্রিন্টের জন্য

                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # #

এই প্যাটার্নটি কেবলমাত্র এই কারণে বেছে নেওয়া হয়েছিল যে এটি অন্য সকলের থেকে পৃথক দুটি অংশে বিভক্ত হতে পারে।

— ElPedro
সূত্র

2

জায়গা কোথায়?

— dkudriavtsev

1

আউটপুটে ফাঁকা স্থান ছাড়া এটি বৈধ নয়।

— মেগো

স্পেস যোগ করার জন্য আমার ভুল +3। আপডেট করা হয়েছে।

— এলপেডরো

1

আসলে আপনি এমনকি জে প্রয়োজন কেন? আপনি পুরোপুরি আই এর সাথে নতুন সংজ্ঞা দিতে পারেন এবং ~ 6 বাইট সংরক্ষণ করতে পারেন!

— sagiksp

@ সাগিক্স্প - ধন্যবাদ আপনার পরামর্শ ব্যবহার করে আপডেট হয়েছে।

— এলপেড্রো

2

পিএইচপি, 64 62 বাইট

ক্রিস্টোফকে ধন্যবাদ 2 বাইট সংরক্ষণ করা ।

while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("
",$a,"# ");

এর মতো নেট প্রিন্ট করে:

# #
# #
# # # # # # # #
# # # # # # # #
# #
# #

(একটি শীর্ষস্থানীয় নিউলাইন সহ)

— user63956
সূত্র

1

while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("\n",$a,"# ");2 বাইট সংরক্ষণ

— ক্রিস্টোফ

1

ব্যাচ, 111 বাইট

@set s=
@set i=@for /l %%i in (1,1,%1)do @
%i%call set s=%%s%% #
%i%echo%s%
%i%echo%s%%s%%s%%s%
%i%echo%s%

— নিল
সূত্র

1

পুশি , 32 29 28 বাইট

কিউব নেটটি বাম-ন্যায়সঙ্গত প্রিন্ট করে। এটি গল্ফ করা কঠিন ছিল ...

&V:`# `;{:";N^:4:";T'.;TD^:"

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

— FlipTack
সূত্র

1

রেটিনা , 39 37 বাইট

এটি আমার প্রথমবারের মতো রেটিনা ব্যবহার করছে, আমি কীভাবে কীভাবে করব তা বোঝার চেষ্টা করছি।

.+
$*#
#
# 
\`# 
$_¶
G`.
)*%`^
$_$_$_

(চতুর্থ এবং 5 তম লাইনের পরে দুটি পিছনে স্থান সহ)

2 বাইট গল্ফ করার জন্য মার্টিন ইন্ডারকে ধন্যবাদ!

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

— সিংহরাশি
সূত্র

@ মার্টিনইেন্ডার আপনাকে ধন্যবাদ, আমি সেই প্রয়োজনীয়তাটি লক্ষ্য করিনি, এখন এটি সঠিক হওয়া উচিত। আমি কীভাবে এটি গল্ফ করার চেষ্টা করব সে সম্পর্কে আপনার কোনও পরামর্শ আছে?

— লিও

অনেক উজ্জ্বল ধারণা না থাকলেও tio.run/nexus/… দুটি বাইট সংরক্ষণ করে। আপনি যে গোষ্ঠীর আউটপুট পতাকা রয়েছে তার সমস্ত কিছু মোড়কের মাধ্যমে পেছনের লাইনফিডগুলি এড়াতে পারবেন (এবং গ্রুপটি যেহেতু প্রোগ্রামটি সর্বশেষ জিনিস, আউটপুট পতাকাটি নিঃশব্দ থাকার জন্য ডিফল্ট হয়)। অন্যান্য বাইট $_খালি লাইনটি সরিয়ে দেওয়ার পরে কিছু কিছু স্যুইচ করে নীচে চতুর্থটি এড়ায় । tio.run/nexus/… একই বাইট গণনা তবে কিছুটা কুরুচিপূর্ণ।

— মার্টিন এেন্ডার

@ মার্টিনএেন্ডার টিপসটির জন্য আপনাকে ধন্যবাদ, এবং এই ভাষার জন্যও আপনাকে ধন্যবাদ, এটি সত্যিই দুর্দান্ত!

— লিও

সদয় শব্দগুলির জন্য আপনাকে ধন্যবাদ। :) আপনার যদি কোনও প্রশ্ন থাকে বা বিষয়গুলি নিয়ে আলোচনা করতে চান তবে এটির জন্য একটি চ্যাটরুম রয়েছে । এটি বর্তমানে বরং শান্ত, তবে লোকেরা যদি প্রশ্ন থাকে তবে আমি এটিকে হিমশীতল রাখার চেষ্টা করছি (এবং আপনি যে কোনও সময় আমাকে পিং করতে সক্ষম হবেন)।

— মার্টিন এেন্ডার

1

কিউবিআইসি , 52 67 40 বাইট

সম্পূর্ণ পুনরায় লেখা:

:[a*3|G=G+@#`][a*2|G=G+@ `][a|?G][a|?_fG

এটি এখন এই প্যাটার্নটি ব্যবহার করে:

###--
--###

যেখানে -স্থানগুলি ভরাট হয়।

:        Read 'a' from the command line        > Assume 3
[a*3|    Create 3 segments times 'a' filling   > 3*3 = 9
G=G+@#`] Define A$ to be '#' and add this to G > G = "#########" 
[a*2|    Create 2 segments times 'a' spacer
G=G+@ `] Define B$ to be ' ' and add this to G > G = "#########       " 
[a|      FOR d == 1; d <= a; d++
?G]      Display G$:
            "#########       " 
            "#########       " 
            "#########       " 
[a|      FOR e == 1; e <= a; e++
?_fG     Display G$ in reverse (_f...|):
            "      #########" 
            "      #########" 
            "      #########" 
         (For loop and function call to Flip impicitly closed by QBIC)

— steenbergh
সূত্র

এই উত্তরটি অবৈধ OP

— এরিক আউটগলফার

পুনঃটুইট হয়েছে

— স্টেইনবার্গ

2

চ্যালেঞ্জের জন্য উপযুক্ত ভাষার নাম!

— ফ্লিপট্যাক

1

পিপ , 28 17 16 বাইট

15 বাইট কোডের, -nপতাকা জন্য +1 ।

"# "Xa*_RLaM141

কমান্ড-লাইন আর্গুমেন্ট হিসাবে আকার নেয়। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

                 a is 1st cmdline arg
       _         Build a lambda function
     a*          (a) times argument
"# "X            Repeat string "# " that many times
        RLa      Wrap in a list and repeat list (a) times
           M141  Map that function to the characters of 141
                 Autoprint (-n flag separating list items with newlines)

নিম্নলিখিতটি কীভাবে ডেটা সংশোধিত হয় ঠিক তা নয়, তবে এটি প্রাথমিক ধারণা দেয় (এর জন্য a=2):

141

[1;4;1]

[2;8;2]

["# # ";"# # # # # # # # ";"# # "]

[["# # ";"# # "];["# # # # # # # # ";"# # # # # # # # "];["# # ";"# # "]]

# # 
# # 
# # # # # # # # 
# # # # # # # # 
# # 
# #

— DLosc
সূত্র

0

05 এ বি 1 ই , 13 বাইট

D141S×S*„# ×»

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

ব্যাখ্যা

উদাহরণ ইনপুট n=2

D              # duplicate input
               # STACK: 2, 2
 141S          # push the list [1,4,1]
               # STACK: 2, 2, [1,4,1]
     ×         # repeat each item in the list input_no times
               # STACK: 2, [11, 44, 11]
      S        # split into list of digits
               # STACK: 2, [1, 1, 4, 4, 1, 1]
       *       # multiply each digit with input
               # STACK: [2, 2, 8, 8, 2, 2]
        „# ×   # repeat the string "# " for each item in the list
               # STACK: ['# # ','# # ','# # # # # # # # ','# # # # # # # # ','# # ','# # ']
            »  # join by newlines
               # OUTPUT: # # 
                         # # 
                         # # # # # # # # 
                         # # # # # # # # 
                         # # 
                         # #

— Emigna
সূত্র

0

সি #, 152 বাইট

n=>{var m="";foreach(int c in new[]{1,4,1})for(int i=0,j;i++<n;){for(j=0;j++<c;)m+=new System.Text.StringBuilder().Insert(0,"# ",n);m+="\n";}return m;};

— TheLethalCoder
সূত্র

0

স্মাইলব্যাসিক, 57 50 বাইট

INPUT S
E$=("#"*S*3+CHR$(10))*S?E$SCROLL-S*2,-1?E$

ব্যাখ্যা:

INPUT SIZE
PART$=("#"*SIZE*3+CHR$(10))*S 'generate half of the pattern
PRINT PART$ 'print half the pattern
SCROLL SIZE*-2,-1 'scroll the text 2 squares right (and 1 character down)
PRINT PART$ 'print half the pattern again

প্রথম PRINT এর পরে (আকার = 2, @ কর্সারের অবস্থান):

######
######

@

এসসিআরএল এর পরে:

    ######
    ######
@

দ্বিতীয় প্রিন্টের পরে:

    ######
    ######
######
######
@

— 12Me21
সূত্র

এই ক্ষেত্রে আপনি স্থানগুলি এড়িয়ে যেতে পারেন

— dkudriavtsev

0

কমন লিস্প, 83 81 79 বাইট

(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))

ব্যবহার:

(funcall #'(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))2)

আউটপুট:

# # # # # #
# # # # # #
    # # 
    # # 
    # # 
    # #       
    # # 
    # #

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

in format there is control string (inside "") and arguments after it
certain commands in string can use arguments (for example ~a displays argument)
~v{~} - takes argument and does commends inside {~} number of times 
                                      (number is given by argument)
       we can write text in loop body - it'll get displayed. Even if
       in loop body there are none commends to use arguments loop itself                 
       will consume one argument (it doesn't matter what it'll be -
       it doesn't seem to affect output)
~% - newline
~n* - jump n arguments forward (relative)
~n:* - jump n arguments backwards (relative)
~n@* - jump to argument n (global, counting from 0)

~v@{~v{# ~}~%~1@*~} <--- we make x rowns, 3x columns of string "# ". 
                         ~1@* is used during looping, it also means we end on argument 1. 
                         (second argument: (* x 3))
~v@{~vt~0@*~v{# ~}~%~} <--- we now make 3x rows, x columns of "(spaces)# "
                         ~vt - is used to move to accurate column. 
                         Here it takes argument (* x 2) - this is 
                         minimal number of columns to display. It uses
                         space as default character for missing characters
                         (when string inside <~> is shorter than min 
                         number of columns). I use it to make (* x 2) spaces, 
                         by giving it no text.
      ~0@* <--- after making spaces we have no new arguments, we go back to
                argument number zero - it is used to determine number of columns in our block

উন্নতির জন্য আদর্শ স্বাগত জানানো হয়।

নির্দিষ্ট আকারের কিউব নেট মুদ্রণ করুন

চ্যালেঞ্জ

বিধি

পাইথন 2, 47 বাইট

অক্টাভা, 58 44 42 32 বাইট

গণিত, 77 60 52 বাইট

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

রুবি, 36 বাইট

রুবি, 38 বাইট

স্কালা, 56 বাইট

জাভাস্ক্রিপ্ট (ES6), 71

জাভা 8, 99 বাইট

ভি , 24 23 20 18 20 বাইট

ব্যাখ্যা

21 20 18 16 18 বাইট

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

জেলি , 20 19 বাইট

কাঠকয়লা , 20 বাইট

ব্যাখ্যা

বাশ / ইউনিক্স ইউটিলিটিস, 72 69 68 66 বাইট

পাইকে, 16 বাইট

পাইথন 2 , 68 71 65 বাইট

পিএইচপি, 64 62 বাইট

ব্যাচ, 111 বাইট

পুশি , 32 29 28 বাইট

রেটিনা , 39 37 বাইট

কিউবিআইসি , 52 67 40 বাইট

পিপ , 28 17 16 বাইট

ব্যাখ্যা

05 এ বি 1 ই , 13 বাইট

সি #, 152 বাইট

স্মাইলব্যাসিক, 57 50 বাইট

কমন লিস্প, 83 81 79 বাইট

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