আইআইইএইচ পিরামিড

34

"এইচ" এবং "আমি" অক্ষরগুলি কীভাবে খুব মিলে যায় তা আমি আকর্ষণীয় মনে করি। "এইচ" দুটি অনুভূমিক স্ট্রোক দ্বারা বেষ্টিত একটি অনুভূমিক স্ট্রোক; "আমি" একটি উল্লম্ব স্ট্রোক যা দুটি অনুভূমিক স্ট্রোক দ্বারা বেষ্টিত (আপনার ফন্টের উপর নির্ভর করে) depending আমি বাজি ধরতে পারি যে এটা ঘৃণ্য হতে পারে ... আপনি কি জানেন যে এটি আমাকে মনে করিয়ে দেয়? ফ্র্যাক্টাল !!!

নীচে "আইআইএইচএইচ" পিরামিডটি সংজ্ঞায়িত করুন: প্রথম পুনরাবৃত্তিটি হ'ল "আমি" অক্ষরের ASCII উপস্থাপনা:

---
 |
---

পরবর্তী পুনরাবৃত্তির উভয় পাশে একটি উল্লম্ব স্ট্রোক রয়েছে।

|   |
|---|
| | |
|---|
|   |

আপনি যদি মাঝখানে "আমি" কে একক অনুভূমিক স্ট্রোক হিসাবে দেখেন তবে এই দ্বিতীয় পুনরাবৃত্তিটি মূলত একটি "এইচ"। তৃতীয় পুনরাবৃত্তি শীর্ষ এবং নীচে একটি অনুভূমিক স্ট্রোক যুক্ত করে

-------
 |   |
 |---|
 | | |
 |---|
 |   |
-------

আবার আপনি যদি মাঝখানে "এইচ" কে একক উল্লম্ব স্ট্রোক হিসাবে দেখেন তবে এই পুনরাবৃত্তিটি মূলত একটি "আমি"। এই প্যাটার্নটি চলতে থাকে, প্রতিটি পুনরাবৃত্তির উপর "এইচ" এস এবং "আমি" এর মধ্যে বিকল্প হয়। রেফারেন্সের জন্য, এখানে প্রথম 6 টি পুনরাবৃত্তি রয়েছে:

1:
---
 |
---

2:
|   |
|---|
| | |
|---|
|   |

3:
-------
 |   |
 |---|
 | | |
 |---|
 |   |
-------

4:
|       |
|-------|
| |   | |
| |---| |
| | | | |
| |---| |
| |   | |
|-------|
|       |

5:
-----------
 |       |
 |-------|
 | |   | |
 | |---| |
 | | | | |
 | |---| |
 | |   | |
 |-------|
 |       |
-----------

6:
|           |
|-----------|
| |       | |
| |-------| |
| | |   | | |
| | |---| | |
| | | | | | |
| | |---| | |
| | |   | | |
| |-------| |
| |       | |
|-----------|
|           |

চ্যালেঞ্জ:

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা আইআইএইচ পিরামিডের N'th পুনরাবৃত্তি এবং একটি alচ্ছিক ট্রেলিং নিউলাইনকে আউটপুট করে । আপনার ইনপুটটি আপনি যে কোনও যুক্তিসঙ্গত বিন্যাসে চান তাতে একক ধনাত্মক পূর্ণসংখ্যা হবে। আপনি হয়তো অবৈধ ইনপুট হ্যান্ডেল করতে হবে না, যেমন অ পূর্ণসংখ্যার, সংখ্যা 1 চেয়ে ছোট, ইত্যাদি খুব অন্তত তোমার প্রোগ্রাম আবশ্যক ইনপুট জন্য সঠিক আউটপুট আপ 20 থেকে উত্পাদন যেহেতু এই হল কোড-গলফ , মানক সমস্যা অনুমতি দেওয়া হয় না এবং বাইটের মধ্যে সংক্ষিপ্ত উত্তর!

code-golf  ascii-art  fractal 
— ডিজেএমসিএমহেম
সূত্র
আমি যদি প্রতিটি সারিতে একটি করে তীরের তীর ফিরিয়ে দেব তবে তা গ্রহণযোগ্য?
— রোহান ঝুনঝুনওয়ালা
চ্যালেঞ্জের মানদণ্ডটি বেশ মেটেনি, তবে দুর্ঘটনার দ্বারা শীতল কিছু করেছে ... এটি অনলাইনে চেষ্টা করুন!
— ম্যাজিক অক্টোপাস উরন

উত্তর:

7

পাইথ , 50 40 31 25 বাইট

ঞ @ su কমান্ড, জে + + * \ - কে + + 2lheN + + JR * 2; en * \ - KjR "||," + * dk + + জে * dKQ]] \ | 
LXR "| -") CbjyW% Q2uy + + কে * \ - + + 2lhG + + JR * 2; GKQ] \ | 
juCGQuC + + কে * @ "- |" এইচ + + 3yH + + JR * 2; GKQ \ |
ঞ @ CBujR * @ "- |" H2CjR * 2; জি কিউ \ |

পরীক্ষা স্যুট.

ব্যাখ্যা

এটি একটি পুনরাবৃত্ত আলগোরিদিম m

প্রতিটি পুনরাবৃত্তিতে আমরা তিনটি ক্রিয়া সম্পাদন করি:

  1. প্রতিটি লাইনে স্থান যুক্ত করুন এবং যুক্ত করুন
  2. অ্যারে স্থানান্তর
  3. প্রতিটি লাইনে প্রিপেন্ড এবং সংযোজন হয় "-"বা "|"পুনরাবৃত্তির সংখ্যার উপর নির্ভর করে।

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

j@CBujR*@"-|"H2CjR*2;GQ\|   input: Q
j@CBujR*@"-|"H2CjR*2;GQ\|Q  implicit filling of arguments


    u                 Q\|   for Q times, starting with "|", G as current output,
                            H as number of iterations:

                jR*2;G          prepend and append a space to each line
                                (using each line as separator, join [" "," "])
               C                transpose
     jR*      2                 prepend and append the following to each line:
        @"-|"H                      the H-th element of the string "-|" (modular indexing)

 @CB                     Q  select the Q-th element from [output,
                            transposed output] (modular indexing)
j                           join by newlines
— ফুটো নুন
সূত্র
আমি প্রতিস্থাপন ধারণা পছন্দ করি।
— তিতাস
12

পাইথন, 165 145 133 123 বাইট

একটি পুনরাবৃত্ত সমাধান:

def i(e):
 d="|";a=e*2;x=d+" "*(a-1)+d
 if e<1:return d
 if e%2:d,x=[" ","-"*(a+1)]
 return[x]+[d+z+d for z in i(e-1)]+[x]

বলা হয় print ("\n".join(i(int(sys.argv[1])))), যেখানে প্যারামিটারটি আইআইএইচ পিরামিডের পুনরাবৃত্তি সংখ্যা।

20 বাইট বাঁচানোর জন্য @ ডিজেএমসিএমহেমকে ধন্যবাদ এই পরামর্শগুলির পিছনে ধারণা গ্রহণ করা আরও 12 টি বাইট সংরক্ষণ করেছে। @ মালতীসেনকে এমন পরামর্শের জন্য ধন্যবাদ যা আরও কিছু বাইট ছাঁটাই করেছে।

ফাংশন সেট বিভেদক dকরতে "|"এবং হস্তক্ষেপ স্পেস " "(বিজোড়-সংখ্যার পুনরাবৃত্তিও জন্য) অধ: পতিত ক্ষেত্রে ফিরে সঙ্গে পুলিশ, তারপর বিভেদক রিসেট " "করুন এবং হস্তক্ষেপ স্পেস "-"এমনকি-সংখ্যাযুক্ত পুনরাবৃত্তিও জন্য। ফাংশনটি আইআইএইচ-র প্রতিটি লাইনের জন্য স্ট্রিংগুলির একটি তালিকা ফেরত দেয়, তালিকার মধ্যে সঠিক জায়গায় ফাংশনে একটি পুনরাবৃত্ত কলের ফলাফল এম্বেড করে।

— সাইমন
সূত্র
2
সুন্দর উত্তর, এবং সাইটে আপনাকে স্বাগতম! আপনার লাইনে যোগ দেওয়ার দরকার নেই, স্ট্রিংগুলির একটি তালিকা ঠিক আছে। একটি দম্পতি টিপস: 2 এবং 3 থেকে লাইন পরিবর্তন করুন if e<1:return'|'(তাদের মধ্যে কোনও নতুন লাইন নেই) তারপরে "অন্য "টিকে সরান এবং অতিরিক্ত ইনডেন্টেশনটি সরিয়ে দিন।
— ডিজেএমসিএমহেম
1
আপনি পরে জায়গা নিতে পারেন return। এছাড়াও, আপনি সেগুলি ছাড়াই লাইনগুলিকে ifসেমিকোলনগুলির সাথে একীভূত করতে পারেন এবং ইন্ডেন্টেশনটি সংরক্ষণ করতে পারেন
— মাল্টেসেন
1
আমি আপনার উত্তর সম্পাদনা করেছি। আপনি যদি আমার সম্পাদনাগুলি পছন্দ না করেন তবে নির্দ্বিধায় অনুগ্রহ করুন।
— Leaky নুন
10

চেদার , 186 177 165 154 148 131 বাইট

(n,b?,c?,q?,g=s->(n-=1)<0?s:g((q=(c=s.lines[0].len)%4>2?b='|'+" "*c+"|":b='-'*(c+2))+"\n"+s.sub(/^|$/gm,q?'|':' ')+"\n"+b))->g("|")

পুনরাবৃত্তি ব্যবহার করে। একবার গল্ফিং হয়ে গেলে ব্যাখ্যা যোগ করবে।

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

ব্যাখ্যা

এইটি কিছুটা জটিল, আমি যে সমস্ত ভেরিয়েবলগুলি ব্যবহার করছি তা ট্র্যাক করে রাখুন তবে আমি এটিকে সহজ রাখার চেষ্টা করব:

(
 n,    // Input
 b?,   // Stores row to add to top/bottom
 c?,   // Width of string 
 q?,   // false if I-ifying. true if not
 g=
   s->          // Main logic, s is generated string
    (n-=1)<0 ? s :   // Decrease input each iteration. Stop when 0
    g(               // Recurse with....
      (
        q= (         // Set `q` true if h-ifying. false if I-ifying
         c=s.lines[0].len    // Set `c` to width of string
        ) % 4>2 ?
        b='|'+" "*c+"|" :    // Set `b` to top/bottom row adding
        b='-'*(c+2)          // `*` is repeat, c is from before
      ) + "\n" + 
        s.sub(/^|$/gm,       // Add the following to beginning/end of each line
          q?'|':' '          // if H-ifying, add `|`s if I-ifying add spaces
        ) + "\n" + b         // Add bottom row, generated from before
    )
) -> g("|")     // Middle item is `|`

এটি গল্ফের জন্য ব্যথা ছিল তবে এর 55 বাইটটি মূলের চেয়ে ছোট।

— Downgoat
সূত্র
8

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

লিকি নুন 7 বাইট সংরক্ষণ করেছেন।

r=range(input()+1)
r=r[:0:-1]+r
for y in r:print''.join('| -'[[x%2,y%2+1][x&-2<y]]for x in r)
— লিন
সূত্র
বন্ধ ফর্ম: ও: ও
— লিকি নুন
আহ, অবশ্যই: প্রথমে আমার প্রয়োজন ছিল int(x/2.)কারণ আমি নিছিলাম range(-n,n+1)কিন্তু এখন আমি সেগুলি ব্যবহার করতে পারি। ধন্যবাদ!
— লিন
আমি পাইথন 2টিকে শিরোলেখগুলিতে নির্দিষ্ট করেছিলাম কারণ কেবল "পাইথন" বলার অর্থ সাধারণত কোডটি পাইথন 2 বা পাইথন 3 এর অধীনে কাজ করে যা এখানে ঘটনা নয়।
— মেগো
7

ম্যাট্রিক্স , 80 62 বাইট

একটি পুনরাবৃত্তি সমাধান (ম্যাট্রিক্সে পুনরাবৃত্তি শক্ত ...)

সাথে চালাও python matricks.py ihih.txt [[]] <input> --asciiprint

k124; FiQ% 2: V; p [m124: প্রশ্ন * 2 + + 3: 1;]; একটি {z- র: প্রশ্ন * 2 + 1 টি;} ;: বি; বনাম [M45: 1: প্রশ্ন * 2 + + 3;] ; তোমার দর্শন লগ করা {zQ * 2 + 1 টি:;} ;;: 1: এন ;;
k124; FiQ% 2: V; p [m124: প্রশ্ন * 2 + + 3: 2;]; খ 1;: বি; বনাম [M45: 2: প্রশ্নঃ * 2 + + 3;]; V1 থেকে ;;: 1: এন ;;

ব্যাখ্যা:

k124;                 # Set the matrix to '|'
F...:1:n;;            # Repeat input times, (Q is iteration variable)
  iQ%2:...:...;       # if statement, check if Q is odd or even
                      # Q is even,
    b;                # Make space to the left
    v[m45:2:Q*2+3;];  # Set the top 2 rows to '-'s
    V1;               # Rotate the matrix up 1 unit, moving the topmost row to the bottom
                      # Q is odd,
    v;                # Make space above
    b[m124:Q*2+3:2;]; # Set the 2 left columns to '|'s
    B1;               # Rotate the matrix left 1 unit, moving the leftmost row to the right
— নীল
সূত্র
1
বাহ, পুনরাবৃত্তি! আমি অভিভূত.
— কনর ও'ব্রায়েন
@ কনরও'ব্রায়েন ম্যাট্রিক্সকে গতিশীল ম্যাট্রিক্স পুনরায় আকার দেওয়ার জন্য তৈরি করা হয়েছিল, সুতরাং এটি চিত্তাকর্ষক নয়, তবে যাইহোক ধন্যবাদ!
— নীল
5

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

f=
(n,[h,c,v]=n&1?`-- `:` ||`)=>n?(c+=h.repeat(n+n-1)+c)+`
${f(n-1).replace(/^|$/gm,v)}
`+c:v
;
<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>
স্নিপেট প্রসারিত করুন

পুনরাবৃত্ত সমাধানটি পূর্ববর্তী পুনরাবৃত্তি গ্রহণ করে, vঅক্ষরকে পাশগুলিতে যুক্ত করে , তারপরে cকোণগুলিতে hঅক্ষর এবং উপরের এবং নীচে বরাবর অক্ষর যুক্ত করে কাজ করে। অক্ষরের সেটটি প্রতিটি পুনরাবৃত্তিকে সহজভাবে পরিবর্তিত করে। সম্পাদনা: ফিরে 2 বাইট সংরক্ষিত vযখন n=0।

— নিল
সূত্র
4

ডায়ালগ এপিএল , 52 43 বাইট

{v=⊃⍵:h⍪⍨h⍪s,⍵,s⋄v,⍨v,s⍪⍵⍪s}⍣⎕⍪⊃v h s←'|- '

v h s←'|- 'নির্ধারণ তিনটি নাম তিন অক্ষর ( বনাম ertical, জ orizontal, গুলি গতি)

⊃ প্রথমটি, অর্থাৎ |

⍪ 1 × 1 টেবিল তৈরি করুন

{... }⍣⎕ইনপুট পান এবং ব্রেসড ফাংশনটি বহুবার প্রয়োগ করুন

 v=⊃⍵: যদি আর্গুমেন্টের উপরের-বাম অক্ষরটি উল্লম্ব হয় তবে:

  h⍪⍨ নীচে অনুভূমিক

  h⍪ উপরের দিগন্ত

  s, বাম দিকে ফাঁকা স্থান

  ⍵,s ডানদিকে ফাঁকা স্থান দিয়ে যুক্তি

 ⋄ অন্য:

  v,⍨ ডানদিকে উল্লম্ব

  v, বাম দিকে উল্লম্ব

  s⍪ উপরের স্পেস

  ⍵⍪s নীচে ফাঁকা জায়গার সাথে যুক্তি

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

— আদম
সূত্র
3

সি, 110 বাইট

#define R(A,B,C)for(A=n,B=1;A<=n;putchar(C),A-=B|=-!A)
f(n,y,x,w,v){R(y,w,10)R(x,v,"| -"[x/2*2<y?y%2+1:x%2]);}

হিসাবে আহ্বান f(n)। 111 বাইটের জন্য, আমি এটি করতে পারি:

f(n,y,x,w,v){for(y=n,w=1;y<=n;y-=w|=-!y,puts(""))for(x=n,v=1;x<=n;x-=v|=-!x)putchar("| -"[x/2*2<y?y%2+1:x%2]);}

অর্থাত্‍, #defineএক বাইট সংরক্ষণ করে।

— লিন
সূত্র
3

ডায়ালগ এপিএল, 34 বাইট

{⍉⍣⍵{b,b,⍨⍉s,⍵,⊃s b←' -|'~⊃⍵}⍣⍵⍪'|'}

{... 1x1 অক্ষরের ম্যাট্রিক্স দিয়ে শুরু করে }⍣⍵⍪'|'ধনুর্বন্ধনী ⍵বারগুলিতে ফাংশন প্রয়োগ করুন |। প্রতিটি প্রয়োগের ফলাফলটি পরবর্তী অ্যাপ্লিকেশনের পক্ষে যুক্তিযুক্ত the

s b←' -|'~⊃⍵s হ'ল স্থান এবং খ হল আর্গুমেন্টের উপরের বাম কোণে নয় এমন একটি বার ( ' -|'~'-'অনুভূমিক বারটি সরিয়ে দেয় এবং স্থান এবং উল্লম্ব বারকে সরিয়ে দেয়)

s,⍵,⊃s bবাম এবং ডানে স্থান যুক্ত করুন ( ⊃ভেক্টর এসবি থেকে পছন্দগুলি বেছে নিন)

b,b,⍨⍉ স্থানান্তর এবং বাম এবং ডানদিকে বি যোগ করুন

বিজোড় সংখ্যার জন্য এটি ফলাফল স্থানান্তরিত করে, সুতরাং একটি চূড়ান্ত ট্রান্সপোজ প্রয়োজন।

⍉⍣⍵ট্রান্সপোজ ⍵বার (একবারে যথেষ্ট হবে, তবে এইভাবে কোডের চেয়ে ছোট)

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

— গিল
সূত্র
পিপিসিজিতে আপনাকে স্বাগতম!
— স্টিফেন
ধন্যবাদ! এখনই পার্টিতে যোগদানের চেষ্টা করছেন, এগুলি সমাধান করার জন্য প্রচুর মজাদার :)
— গিল
2

চেডার, 85 বাইট

(n,r=(-n|>n).map(v->abs v))->r.map(y->r.map(x->"| -"[(x&-2)<y?y%2+1:x%2]).fuse).vfuse

আমার প্রথম চেডার উত্তর। এটি অনলাইন চেষ্টা করুন!

যদি আমি লেখার চেষ্টা করি r=(-n|>n).map(v->abs v).mapএবং তারপরে r(y->r(x->…)), দোভাষীটি ক্র্যাশ হয়ে যায়। ; -;

— লিন
সূত্র
আপনি করতে পারেন v->abs vমধ্যে (abs)(যেমন r.map((abs))) যা একটি ফাংশন যা ABS ফাংশনের আচরণ করল ফিরে আসবে। যেমন (+)(1,2)-> 3। (^)(2,6)-> 64. এছাড়াও প্রায় 50% দ্বারা আউটগল্ফিং উপর বড় বাহ
— ডাউনগোট
না, আমি চেষ্টা করেছিলাম: Runtime Error: `abs` has no behavior for types `Number` and `Number` (কারণ mapসম্ভবত এবং তার সূচক উভয়ই গ্রহণ করে))
— লিন
আহ: / আমি ঠিক আজই এই বাগটি ঠিক করতে
— চলেছিলাম
2

এপিএল (ডায়ালগ ক্লাসিক) , 34 বাইট

'- |'[2+∘.(≤-(1+=)×2|⌈)⍨(⌽,0,⊢)⍳⎕]

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

(ব্যবহার ⎕io←1)

⍳⎕ হয় 1 2 ... N

(⌽,0,⊢) এটি একটি ট্রেন যা এটিকে পরিণত করে -N ... -1 0 1 ... N

∘.( )⍨ স্থানাঙ্কের প্রতিটি জুটির জন্য প্রথম বন্ধনীর সম্পাদন করে ⍺ ⍵

ট্রেন (≤-(1+=)×2|⌈)বা এর ডিএফএন সমতুল্য {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}একটি ম্যাট্রিক্সের মতো উত্পাদন করে:

 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1
  0  1  0  0  0  0  0  0  0  1  0
  0  1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1  1  0
  0  1  0  1  0  0  0  1  0  1  0
  0  1  0  1 ¯1 ¯1 ¯1  1  0  1  0
  0  1  0  1  0  1  0  1  0  1  0
  0  1  0  1 ¯1 ¯1 ¯1  1  0  1  0
  0  1  0  1  0  0  0  1  0  1  0
  0  1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1  1  0
  0  1  0  0  0  0  0  0  0  1  0
 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1

'- |'[2+ ]এই বৈধ সূচকগুলি তৈরি করে ⎕IO=1এবং সংশ্লিষ্ট অক্ষরগুলি বেছে নিয়েছে

— ngn
সূত্র
1

রুবি, 81 78 77 বাইট

এটি লিনের পাইথন উত্তরের উপর ভিত্তি করে । গল্ফিং পরামর্শ স্বাগত জানাই।

সম্পাদনা করুন: লিনকে 3 বাইট ধন্যবাদ। সংশোধন এবং গল্ফিং 1 বাইট জর্দানকে ধন্যবাদ।

->n{r=(-n..n).map &:abs;r.map{|y|puts r.map{|x|"| -"[x&-2<y ?y%2+1:x%2]}*""}}

Ungolfing:

def f(n)
  r = -n..n            # Range from -n to n (inclusive)
  r = r.map{|i|i.abs}  # Turns every element of r positive
  r.each do |y|
    s = ""             # a line of the fractal
    r.each do |x|      # build up the fractal based on x and y
      if x/2*2 < y
        s += " -"[y%2]
      else
        s += "| "[x%2]
      end
    end
    puts s             # print the line
  end
end
— Sherlock9
সূত্র
পারবেন তো .map(&:abs)?
— লিন
@ লিন ওয়েল স্পটেড অন্য কোন পরামর্শ?
— শার্লক 9
প্রথমটি *কিছু করছে না। আপনি *""পরিবর্তে ব্যবহার করতে পারেন .join। এছাড়াও, pউদ্ধৃতি চিহ্নগুলির সাথে প্রতিটি লাইনের চারপাশে ব্যবহার করা (এটি inspectতার যুক্তিগুলিতে কল করে), যা আপনাকে অযোগ্য ঘোষণা করতে পারে।
— জর্ডান
এছাড়াও, আপনি &:abs( map &:abs) এর আশেপাশে প্রথম বন্ধনীগুলি সরাতে পারেন । Array#productনেস্টেড mapএর পরিবর্তে আপনি কিছু করতে সক্ষম হতে পারেন তবে এটি লাইন ব্রেকগুলি জটিল করে তুলবে।
— জর্ডান
@ জর্দান আপনার প্রথম চারটি ইঙ্গিতগুলি কাজ করে r.product(r).mapতবে এটি (তবে এটি কার্যকর) দীর্ঘতর এবং খুব সহজেই লাইনটি ব্রেক করার অনুমতি দেয় না।
— শার্লক 9
1

ম্যাটল্যাব, 168 163 বাইট

এটি সম্ভবত এটির সবচেয়ে চালাক উপায় নয়: সমস্ত দিকের স্ট্রিংটি nপদক্ষেপে প্রসারিত করা :

function s=g(n);s='|';for m=1:n;if mod(m,2);a=45;b=a;c=0;else a='|';b=0;c=a;end;s=[a repmat(b,1,2*m-1);repmat(c,2*m-1,1) s];s(:,end+1)=s(:,1);s(end+1,:)=s(1,:);end

ব্যবহার: হিসাবে সংরক্ষণ করুন g.m(আমি কি এটি বাইট গণনায় যোগ করতে হবে?) এবং কল কল g(15)।

Ungolfed:

function s=g(n)

% // Initialize s
s = '|';

for m=1:n
   % // Decide if odd or even number and which symbol to add where
   if mod(m,2)
      a=45;b=a;c=0; % // char(45) is '-' and char(0) is ' ' (thx to Luis Mendo)
   else
      a='|';b=0;c=a;
   end
      % // Add symbols at top and left to s
      s = [a repmat(b,1,2*m-1);repmat(c,2*m-1,1) s];
      % // Add symbols at right and bottom to s
      s(:,end+1) = s(:,1);
      s(end+1,:) = s(1,:);
end
— Wauzl
সূত্র
আপনি প্রতিস্থাপন করতে পারেন ' 'দ্বারা 0(একটি স্থান হিসাবে মতলব একইরূপে গৃহস্থালির কাজ 0) এবং '-' দ্বারা 45। ফাইলের নামটি বাইট গণনায় অন্তর্ভুক্ত করতে হবে না
— লুইস মেন্ডো
1

আসলে , 48 45 44 বাইট

এটি আসলে আমার রুবির উত্তরটি পোর্ট করার একটি প্রয়াস। এটি উপায় দীর্ঘ এবং গল্ফিং পরামর্শ খুব প্রশংসা করা হয়। এটি অনলাইন চেষ্টা করুন!

u;±ux♂A╗╜`╝╜";2@%2╛%u╛(2±&<I'-' '|++E"£MΣ.`M

এখানে একটি 46-বাইট সংস্করণ রয়েছে যা নেস্টেড ফাংশনগুলি আলাদা করে দেয় যাতে আমরা "| -"কম বাইটে সংজ্ঞা দিতে পারি । এটি অনলাইন চেষ্টা করুন!

u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£MΣ."%£M

Ungolfing:

প্রথম অ্যালগরিদম

u         Increment implicit input.
;±u       Duplicate, negate, increment. Stack: [-n n+1]
x♂A       Range [-n, n+1). Abs(x) over the range.
╗         Save list to register 0. Let's call it res.
╜         Push res so we can iterate over it.
  `         Start function (with y from map() at the end)
  ╝         Save y to register 1.
  ╜         Push res so we can iterate over it.
    "         Start function as string (with x from map() at the end)
    ;         Duplicate x.
    2@%       x mod 2.
    2╛%u      y mod 2 + 1.
    ╛(2±&<I   If x&-2 < y, then y%2+1, else x%2.
    '-' '|++  Push "| -" (We're inside a string right now,
                          so we need to push each char individually)
    E         Grab index of "| -"
    "£        End string and turn into function.
  M         Map over res.
  Σ.        sum() (into a string) and print.
  `         End function.
M         Map over res.

দ্বিতীয় অ্যালগরিদম

u;±ux♂A╗╜                  Create res as before.
`;2@%2╛%u╛(2±&<I"| -"E`#   The inner function from the first algorithm put into a list.
                             The only change to the function is the definition of "| -".
"╝╜  £MΣ."                 Most of the outer function from the first algorithm as a string.
   %r      %               %-formats the list into the outer function.
            £M             Turns the string into a function, maps over res.
— Sherlock9
সূত্র
u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£Mεj."%£Mআপনার কাছে বর্তমানে যা আছে তার চেয়ে লম্বা (2 বাইট দ্বারা) তবে এটি সংক্ষিপ্ত করার উপায়গুলির জন্য আপনি কিছু অনুপ্রেরণার সন্ধান করতে পারেন যা আমি দেখছি না।
— ঐ মেগো
1

ক্যানভাস , 19 18 17 14 বাইট

|╶［ ｅ↷ｌ|＊ｅ｝╶［↷

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

যদি আমাকে 90% ated ঘোরানো অন্য প্রতিটি আউটপুট আউটপুট দেওয়ার অনুমতি দেওয়া হয়, তবে শেষ 4 টি অক্ষর সরানো যেতে পারে।

ব্যাখ্যা (কিছু অক্ষরকে ~ মনোস্পেসে দেখতে পরিবর্তন করা হয়েছে):

|               push "|" - the canvas
 ╶[       }     repeat input times
    e             encase the canvas in spaces horizontally
     ↷            rotate the canvas 90°
      l|*         push "-" repeated the canvas height times vertically
         e        and encase the canvas if two of those horizontally
           ╶[   repeat input times
             ↷    rotate the canvas 90°
— dzaima
সূত্র
আমি 6 বাইট হারাব যদি তারাও এই সীমাবদ্ধতাটি আলগা করে দেয়: পি।
— ম্যাজিক অক্টোপাস উরন
@ ম্যাজিক অ্যাক্টপাস ভাল ওয়েল করুন, আমার জন্য -5 বাইট তৈরি করুন: পি (আপনার উত্তরটি কোনও ট্রান্সপোজ লুপ থেকেও উপকৃত হতে পারে?)
— জিজাইমা
আমার বাস্তবায়ন হয় একটি TRANSPOSE লুপ: ডি।
— ম্যাজিক অক্টোপাস উরন
1

05 এ বি 1 ই , 29 28 বাইট

„|-S¹>∍ƶćsvy‚˜.Bζ}¹Fζ}»R.∞.∊

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

-1 ধন্যবাদ জাইমাকে ...

এটি একটি পুনরাবৃত্তি সমাধান।

মূলত নিম্নলিখিত প্যাটার্নটি তৈরি করে এটি তৈরি করা হয়:

['|','--','|||',...]

তারপরে, জোড়া হিসাবে, প্রতিটি উপাদান একসাথে স্থানান্তর এবং প্যাডিং যোগ করুন।

প্রতিটি পুনরাবৃত্তির পরে স্থানান্তরিত করে, আমরা প্যাটার্নের একক কোণ তৈরি করি।

তারপরে, আমরা 05AB1E এর প্রতিবিম্ব কমান্ডগুলি ব্যবহার করতে পারি।

„|-S                         # Push ['|','-']
    ¹>∍                      # Extended to input length.
       ƶ                     # Each element multiplied by its index.
        ćs                   # Extract head of list, swap remainder to top.
          v      }           # For each element in the '|-' list...
           y‚˜               # Wrap current 2D array with new entry, flatten.
              .Bζ            # Pad and transpose, leaving it transposed for the next addition.
                 }           # End loop.
                  ¹Fζ}       # Transpose N times.
                      »R     # Bring it all together into a newline string, reverse.
                        .∞.∊ # Mirror horizontally, then vertically with overlap.
— ম্যাজিক অক্টোপাস উরন
সূত্র
0

গণিত, 158 164 বাইট

f[n_]:=Print/@StringJoin/@Map[{{{"|","|", },{ , , }},{{"|", ,"-"},{ ,"-","-"}}}[[##]]&@@#&,Table[{1+i~Mod~2, 1+j~Mod~2, 2+Sign[Abs[i]-Abs[j]]}, {i,-n,n}, {j,-n,n}],{2}]

গাণিতিকভাবে স্থানাঙ্কগুলিতে (i, j) সঠিক চিহ্ন গণনা করা হয়, যেখানে উভয়ই -n থেকে n পর্যন্ত চলে। মানব বিন্যাসিত:

f[n_]:=Print/@
 StringJoin/@
  Map[
   {{{"|","|", },{ , , }},{{"|", ,"-"},{ ,"-","-"}}[[##]]&@@#&,
   Table[{1+i~Mod~2,1+j~Mod~2,2+Sign[Abs[i]-Abs[j]]},{i,-n,n},{j,-n,n}],
   {2}]
— গ্রেগ মার্টিন
সূত্র
@ অ্যাডম সেই থ্রেডের পয়েন্টারটির জন্য আপনাকে ধন্যবাদ!
— গ্রেগ মার্টিন
0

পিএইচপি, 166 বাইট

আমার প্রথম অ্যাপ্রোচটি বন্ধ করে 100 বাইটেরও বেশি গল্ফ করেছে এবং এটি এখনও এখানে দীর্ঘতম উত্তর।

function i($n){for($m=['|'];$k++<$n;){array_unshift($m,$m[]=str_repeat(' -'[$f=$k&1],2*$k-1));foreach($m as$i=>&$r)$r=($c='||- '[2*$f+($i&&$i<2*$k)]).$r.$c;}return$m;}

ভাঙ্গন

function h($n)
{
    for($m=['|'];$k++<$n;)
    {
        array_unshift($m,$m[]=str_repeat(' -'[$f=$k&1],2*$k-1));
        foreach($m as$i=>&$r)
            $r=($c='||- '[2*$f+($i&&$i<2*$k)]).$r.$c;
    }
    return$m;
}

ungolfed

function ihih($n)
{
    $m=['|'];                   // iteration 0
    for($k=1;$k<=$n;$k++)       // loop $k from 1 to $n
    {
        $f=$k&1;                        // flag for odd iterations
        // add lines:
        $r=str_repeat(' -'[$f],2*$k-1); // new line: ' ' for even, '-' for odd iterations
        $m[]=$r;                                // append
        array_unshift($m,$r);                   // prepend
        // add columns:
        foreach($m as$i=>&$r)           // for each line
        {
            $c='| '[$f];                        // '|' for even, ' ' for odd iterations
            if($f && (!$i || $i==2*$k)) $c='-'; // '-' in corners for odd iterations
            $r=$c.$r.$c;                        // prepend and append character
        }
    }
    return $m;
}
— তিতাস
সূত্র
0

হাস্কেল , ১১০ বাইট

f 0=["|"]
f n|odd n=g ' '!n$'-'|1>0=g '|'$id!n$' '
g c=map$(c:).(++[c])
(g!n)c|p<-g.f$n-1=(:p)<>pure$c<$head p

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

ব্যাখ্যা / Ungolfed

সহায়ক ফাংশনটি gএকটি অক্ষর এবং স্ট্রিংগুলির একটি তালিকা নেয়, তারপরে এটি প্রতিটি অক্ষরে প্রাক-পূর্বে যুক্ত হয়:

g c = map (\s-> [c] ++ s ++ [c])

এর পরে অপারেটর (!)একটি ফাংশন ( g), একটি সংখ্যা ( n) এবং একটি অক্ষর ( c) গ্রহণ করে। এটি তারপরে আউটপুটটি গণনা করে n-1, এতে ফাংশনটি প্রয়োগ করে gএবং cপ্রারম্ভ এবং শেষের সাথে একই প্রস্থের একটি স্ট্রিং যুক্ত করে :

(g ! n) c | prev <- g $ f (n-1), ln <- [c | _ <- head p]
          = [ln] ++ prev ++ [ln]

এগুলির সাথে আমরা আউটপুটগুলি পুনরাবৃত্তভাবে উত্পন্ন করতে প্রস্তুত, প্রথমে আমাদের বেস কেসটি কভার করতে হবে:

f 0 = ["|"]

এবং তারপরে পুনরাবৃত্তি:

-- for odd n: the previous output needs a space at the end and beginning and then a string of '-' characters at the top and bottom
f n | odd n     = (g ' ' ! n) '-'
-- for even n: the previous output needs a line of spaces at the top and bottom and then each line needs to be enclosed with '|' characters
    | otherwise = g '|' $ (id ! n ) ' '
— ბიმო
সূত্র
0

স্ট্যাক্স , 22 বাইট

âeò↕\┐▄┤╚╬8φ8Δ☺Pä≤δ₧߃

এটি চালান এবং এটি ডিবাগ করুন

আনপ্যাকড, নিরবচ্ছিন্ন এবং মন্তব্য করা হয়েছে, এটি দেখতে এটির মতো দেখাচ্ছে।

'|          string literal "|"
{           begin block to repeat
  . |G      push " |", then jump to trailing `}` below 
  '-z2lG    push ["-",[]], then jump to trailing `}` below again
}N          repeat block according to number specified in input
m           output each row in grid

}           goto target - `G` from above jumps to here
  i@        modularly index into pair using iteration index
  ~         push to input stack
  {;|Sm     surround each row with the extracted element
  M         transpose grid

এটি চালান

— রিকার্সিভ
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.