একটি ডায়মন্ড টাইলিং স্কেল আপ

27

যে কোনও নিয়মিত ষড়ভুজ হীরা দিয়ে টাইলস করা যায়, উদাহরণস্বরূপ:

   ______
  /_/_/\_\
 /_/\_\/\_\
/\_\/_/\/_/\
\/_/\_\/_/\/
 \_\/_/\_\/
  \_\_\/_/

আমরা উপরের আকারের টাইলিং বিবেচনা করব 1(যেহেতু হীরার দিকগুলি এক /বা \প্রতিটি দিয়ে তৈরি )। আকারের একই টাইলিংয়ের 2মতো দেখতে হবে:

      ____________ 
     /   /   /\   \  
    /___/___/  \___\ 
   /   /\   \  /\   \  
  /___/  \___\/  \___\ 
 /\   \  /   /\  /   /\  
/  \___\/___/  \/___/  \ 
\  /   /\   \  /   /\  /
 \/___/  \___\/___/  \/ 
  \   \  /   /\   \  /
   \___\/___/  \___\/ 
    \   \   \  /   /
     \___\___\/___/

আপনার কাজটি হ'ল একটি ASCII আর্ট টাইলিং (আকারের 1) ইনপুট হিসাবে, ধনাত্মক পূর্ণসংখ্যার সাথে N(দশমিক বা আনারিতে), পছন্দসই আউটপুটটির আকার উল্লেখ করে receive তারপরে আপনার একই টাইলিংয়ের একটি ছোট আকারের সংস্করণ আউটপুট করা উচিত।

মনে রাখবেন যে, ষড়ভূজ যে কোনো আকারের হতে পারে এবং 1x1x1 হিসাবে ছোট হিসাবে (তিন হিরে ধারণকারী)।

ষড়ভুজ আকারটি সারিবদ্ধ করার জন্য ইনপুট বা আউটপুট উভয়কেই কোনও চলমান স্পেস থাকতে হবে না বা প্রয়োজনের চেয়ে বেশি নেতৃস্থানীয় স্পেস থাকতে হবে না। ইনপুট এবং আউটপুট উভয়ই বিকল্পভাবে একটি একক পেছনের নতুন লাইন ধারণ করতে পারে (এই পছন্দটি ইনপুট এবং আউটপুট জন্য একই হতে হবে না)।

আপনি STDIN (অথবা নিকটতম বিকল্প), কমান্ড-লাইন আর্গুমেন্ট বা ফাংশন আর্গুমেন্টের মাধ্যমে ইনপুট নিয়ে কোনও প্রোগ্রাম বা ফাংশন লিখতে এবং STDOUT (বা নিকটতম বিকল্প), ফাংশন রিটার্ন মান বা ফাংশন (আউট) প্যারামিটারের মাধ্যমে ফলাফল আউটপুট করতে পারেন।

এটি কোড গল্ফ, তাই সংক্ষিপ্ত উত্তরটি (বাইটে) জিতেছে।

উদাহরণস্বরূপ

এখানে আপনার জমা দেওয়ার পরীক্ষা করতে আপনি কয়েকটি মুখ্য ইনপুট টিলিংস ব্যবহার করতে পারেন।

 __
/_/\
\_\/

  ____
 /_/\_\
/\_\/_/\
\/_/\_\/
 \_\/_/

   ______
  /_/_/\_\
 /_/\_\/\_\
/\_\/_/\/_/\
\/_/\_\/_/\/
 \_\/_/\_\/
  \_\_\/_/

    ________
   /_/\_\_\_\
  /\_\/\_\_\_\
 /\/_/\/_/_/\_\
/\/\_\/_/_/\/\_\ 
\/\/_/\_\_\/\/_/
 \/\_\/_/\_\/_/
  \/\_\_\/_/_/
   \/_/_/_/_/

নিম্নলিখিত স্নিপেট ইনপুট N = 1মাধ্যমে সম্পর্কিত আউটপুট রয়েছে N = 6।

কোড স্নিপেট দেখান

code-golf  ascii-art  tiling 
— মার্টিন ইন্ডার
সূত্র
20
আমি দেখতে পাচ্ছি যে আপনি এখন হীরাতে আগ্রহী যে আপনি নিজের ব্যবহারকারীর নামের পাশে পেয়েছেন।
— ব্যবহারকারী 12205
3
@ স্পেস: তারা কী বলে তা আপনি জানেন: হীরা একটি মডারেটরের সেরা বন্ধু।
— অ্যালেক্স এ।
আমি মনে করি আমি উত্তরটি জানি, তবে আমি আশা করি যে আমি ভুল: লিডিং ফাঁকা লাইনগুলি অগ্রণী স্থান হিসাবে গণ্য হবে, যা আপনি অবৈধ হিসাবে ঘোষণা করেছিলেন? আমার প্রাথমিক সমাধানটি N-1খালি রেখাগুলি নিয়েছে। :(
— রেটো কোরাদি
@ রিটোকোরাদি আসলে কোনও শীর্ষস্থানীয় নিউলাইন নেই। দুঃখিত।
— মার্টিন ইন্ডার
1
আমি বের করলাম. আমার জন্য প্রায় 10 বাইট খরচ। আমি যখন সমস্যাটি প্রথম চিনতে পেরেছিলাম তখন তত খারাপ লাগে না।
— রেটো কোরাডি

উত্তর:

8

সিজেম, 85 79 76 72 বাইট

li:Tlf*NqN/T,f{ff{"_/"2$#_1<@+*~ST*@t}:+z{S+e`);e~{"_ "/"__"*W%}T2**N}/}

আকারটি প্রথম লাইনে হওয়া উচিত। এবং হীরা অনুসরণ করে।

খুব গল্ফ করা হয়নি ... এবং অর্ধেক চরিত্রগুলি বিবরণ থেকে এসেছে।

ব্যাখ্যা (পূর্ববর্তী সংস্করণ)

li:T            e# Read the size and save to T.
qN/             e# Read and split to lines.
\,fm*           e# Convert each character X to [X 0] [X 1]... [X T(]
{~              e# For each [X I] in each line:
    ST*         e# T spaces.
    \           e# I.
    "_\\"3$#    e# If X is '_, '\ or '/, return Y = 0, 1, -1 respectively.
    _W>@+       e# If it was '_ or '\, increase I by one.
    *(          e# I * Y - 1.
    @t          e# Set the character at that position to X.
}f%
:z:+            e# Make the returned lists from each iteration across T lines.
{S+e`);e~N+}%   e# Boring details to remove trailing spaces and append a newline.
T(>(\s          e# Boring details to extract the first line and only work on others.
{_{"_ "/"__"*W%}2*_@=!}g
                e# Boring details to make underlines expand left and right.
— jimmy23013
সূত্র
10

পাইথন 2, 164

def g(s,n,j=1):
 for W in s.split("\n"):exec"O=p='';d=0\nfor c in W:q=' _'[j*'_'in p+c];e=[n-j,j-1][c=='/'];O+=q*(e+d)+[c,q][c>'^'];p=c;d=n+~e\nprint O;j-=1;"*j;j=n

পরীক্ষার ক্ষেত্রে আউটপুট।

তো, এখানে কি চলছে?

মূল ধারণাটি হ'ল মূল চরিত্রের প্রতিটি চরিত্রই একটি n*nব্লকে পরিণত হয়। উদাহরণস্বরূপ, n = 4 এর জন্য, /হতে পারে

   /
  /
 /
/___

আসল চরিত্রটি প্রতিটি লাইনে একবার উপস্থিত হয় এবং এর উভয় পাশে প্যাডিং রয়েছে। এখানে, এটা বাম, এবং এবং _ডান দিকে। কেবল নীচের সারিটি প্যাড করা যেতে পারে '_'; বাকি সবসময় ' '।

প্রধান অসুবিধাটি হ'ল ডানদিকে প্যাডিং আসন্ন প্রতীকের উপর নির্ভর করতে পারে। বিশেষত, '/ 'এর থেকে আলাদা প্যাডিং রয়েছে '/_', সুতরাং আমাদের কিছুটা সামনের দিকে দরকার। তদ্ব্যতীত, স্থানগুলিকে পিছনে ফেলে এড়াতে, আমাদের লক্ষ রাখতে হবে যে আমরা শেষের প্রতীক এবং ডানদিকে প্যাডিং থেকে বিরত থাকি।

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

এখন কোডটি উপরের করা যাক।

def g(s,n,j=1):
    for W in s.split("\n"):
        while j:
            O=p='';d=0
            for c in W:
                q=' _'[j*'_'in p+c]
                e=[n-j,j-1][c=='/']
                O+=q*(e+d)+[c,q][c>'^']
                p=c
                d=n+~e
            print O;j-=1;
        j=n

ইনপুট স্ট্রিংটি হল sএবং স্কেল-ফ্যাক্টর n। আমরা অনুলিপি সহ nপ্রতিটি ইনপুট লাইনের জন্য লাইন-বাই-লাইনে মুদ্রণ করি । প্রথম লাইনটি একবারে অনুলিপি করা হয়, যা আমরা 1 এ শুরু করে প্রতিটি লুপে পরিবর্তন করে এটি অর্জন করি ।Wj=n,n-1,...,2,1jn

আমরা ইনপুট লাইনের মাধ্যমে পুনরাবৃত্তি করি, প্রিন্ট করার জন্য লাইনটি জমে O। প্রথমত, আমরা উপযুক্ত প্যাডিং চরিত্রটি বের করি q, যা আমরা নীচের লাইনে থাকলে আন্ডারস্কোর এবং বর্তমান বা পূর্ববর্তী অক্ষরটি একটি আন্ডারস্কোর এবং অন্যথায় একটি স্থান।

তারপরে, আমরা বামে ( e) রেখে কত প্যাডিং রাখব তা স্থির করব । জন্য /, এটা j-1, এবং পরিপূরক (লাইন-অনুলিপি সংখ্যা কমে সঙ্গে কমছে) n-jজন্য \। আমরা অন্যান্য চরিত্রগুলিকেও একইরকম আচরণ করি। উদাহরণস্বরূপ, যদিও _মনে হচ্ছে এটি একটি সারি nআন্ডারস্কোর দেয় তবে এটি আসলে একটি একক আন্ডারস্কোর দেয়, বাম এবং ডানদিকে আন্ডারস্কোর দ্বারা প্যাড করে। এটি অদৃশ্য বলে মনে হচ্ছে, তবে এটি আমাদের একই কাঠামোর সাথে _এবং একই সাথে কাজ করতে দেয় /এবং \"কেন্দ্রীয়" আন্ডারস্কোরের অবস্থানটি গুরুত্ব দেয় না, তাই আমরা এটিকে এবং তার সাথে একসাথে \; এই পছন্দটি বিশেষ কেসিং ছাড়াই শীর্ষ সারিকে কার্যকর করে তোলে।

এরপরে, আমরা আউটপুট স্ট্রিংয়ে যুক্ত করব। আমরা প্যাডিং প্রতীক qএবং বর্তমান প্যাডিংয়ের পরিমাণটি বের করেছি e, তবে আমাদের dআগের প্রতীক থেকে প্যাডিং debtণও মনে রাখা দরকার । সুতরাং, আমরা যোগ করুন q*(e+d)। তারপরে, আমরা বর্তমান প্রতীকটি যুক্ত করব c, কেবলমাত্র নীচের নীচে থাকা সারিটিতে আন্ডারস্কোরগুলি এড়াতে হবে না, যা আমরা আন্ডারস্কোরগুলিকে প্যাডিং প্রতীকটিতে রূপান্তর করে ঠিক করি।

অবশেষে, আমরা প্যাডিং debtণের পরিমাণ রেকর্ড করি যা n+~dবর্তমান বাম-প্যাডিংয়ের পরিপূরক । আমরা বর্তমান চিহ্নটিও এতে রেকর্ড করি p, যাতে আমরা পরে জানতে পারি যে আগের প্রতীকটি ছিল কিনা _।

— xnor
সূত্র
3

জাভাস্ক্রিপ্ট ( ES6 ) 274 281 289 338

// GOLFED
F=(b,n)=>{
b=b[R='replace'](/ |_/g,c=>c[T='repeat'](n))[R](/_(?=[\\\/])/g,'_'[T](n))[R](/\/\\/g,`/${'  '[T](n-1)}\\`)
.split('\n');
for(i=l=b.length*n-n+1;--i;)
b[i]=i%n?b[i+1][R](/_/g,' ')[R](/\/ ?/g,' /')[R](/ \\(.)?/g,'\\$1$1')
:' '[T](i>l/2?n-1:0)+b[i/n];
return b.join('\n')}


// UNGOLFED
U=(b,n)=>{
  b=b
  .replace(/ |_/g,c=>c.repeat(n))
  .replace(/_(?=[\/\\])/g,'_'.repeat(n))
  .replace(/\/\\/g,`/${'  '.repeat(n-1)}\\`)
  .split('\n');
  for(i=l=b.length*n-n+1;--i;)
  {
    if(i%n)
     b[i]=b[i+1]
     .replace(/_/g,' ')
     .replace(/\/ ?/g,' /')
     .replace(/ \\/g,'\\ ').replace(/ +$/,'')
     .replace(/ \\(.)?/g,'\\$1$1')
    else {
      b[i]=b[i/n]
      if(i>l/2)b[i]=' '.repeat(n-1)+b[i];
    }
  }
  return b.join('\n')
}

//TEST

test=[
' __\n/_/\\\n\\_\\/',
'  ____\n /_/\\_\\\n/\\_\\/_/\\\n\\/_/\\_\\/\n \\_\\/_/',
'   ______\n  /_/_/\\_\\\n /_/\\_\\/\\_\\\n/\\_\\/_/\\/_/\\\n\\/_/\\_\\/_/\\/\n \\_\\/_/\\_\\/\n  \\_\\_\\/_/',
'    ________\n   /_/\\_\\_\\_\\\n  /\\_\\/\\_\\_\\_\\\n /\\/_/\\/_/_/\\_\\\n/\\/\\_\\/_/_/\\/\\_\\\n\\/\\/_/\\_\\_\\/\\/_/\n \\/\\_\\/_/\\_\\/_/\n  \\/\\_\\_\\/_/_/\n   \\/_/_/_/_/'
]

test.forEach(t=>{
  var row = '<td>'+t+'<td>'
  for(rr=2;rr<5;rr++)
    row += '<td>'+F(t,rr)+'</td>'
  OUT.innerHTML += '<tr>'+row+'</tr>'
})
td {
  font-family: monospace;
  white-space: pre;
}
(better full page)
<table id=OUT></table>
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
3

পাইথন 2, 217 211 195 194 190

b,f,s='\/ '
R=str.replace
def m(g,n,z=1):
 for d in g.split('\n'):
    for i in range(z):a=z+~i;print[i,a][d[-1]>f]*s+R(R(R(R(d,s,s*n),'_','_ '[i<z-1]*(z+n-1)),f+b,f+s*2*i+b),b+f,b+s*2*a+f);z=n

6 বাইট Sp3000 ধন্যবাদ।

ফোন করুন mপ্রথম আর্গুমেন্ট একটি স্ট্রিং, এবং দ্বিতীয় যুক্তি পুনরাবৃত্তি নম্বর হিসাবে হীরা হয়ে পড়ে থাকে।

এটি একটি 3-পদক্ষেপের স্ট্রিং প্রতিস্থাপনের ক্রমের উপর ভিত্তি করে:

  • প্রথমে, রেখার উপর নির্ভর করে আন্ডারস্কোরগুলি 2n-1 স্পেস বা আন্ডারস্কোর দিয়ে প্রতিস্থাপন করুন।
  • দ্বিতীয়ত, মধ্যবর্তী স্থানগুলির সংখ্যা 2 থেকে 2 * (এন -1) লাইনের উপর দিয়ে /\দিয়ে প্রতিস্থাপন করুন / \।
  • তৃতীয়ত, প্রতিস্থাপন \/সঙ্গে \ /হস্তক্ষেপ স্পেস সংখ্যা লাইন ধরে 2 2 * (ঢ -1) থেকে যাচ্ছে সঙ্গে।

তারপরে, নেতৃস্থানীয় স্থানগুলি ঠিক পেতে এবং প্রথম লাইনটি ডান পেতে বিভিন্ন ধরণের শঙ্কা রয়েছে।

নোট করুন যে প্রোগ্রামের চূড়ান্ত লাইনটি 4 টি স্পেস নয়, একটি ট্যাব হওয়া উচিত। মার্কডাউন ট্যাবগুলি সমর্থন করে না।

— isaacg
সূত্র
দুটি গল্ফ: (i+(n-i+~i)*(d[-1]>f)) --> [i,n+~i][d[-1]>f]এবং আপনি কেবল '_'একবার ব্যবহার করেন , তাই আপনি এটি নির্ধারণ করে একটি বাইট অপচয় করেন।
— Sp3000
3

পাইথন, 272 238 228 243 বাইট

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

s,u,f,b=' _/\\'
r=str.replace
def d(t,n,j=1):
 for p in t.split('\n'):
  for k in range(n-j,n):m,v=n+~k,'_ '[k<n-1];print r(r(r(r(r(r(r(r(p,f+u,'(_'),u+b,'_)'),s,s*n),u,v*n),f,s*m+f+s*k),'(',v*m+f+v*k),b,s*k+b+s*m),')',v*k+b+v*m).rstrip();j=n

শ্বেত স্পেস সহ সংস্করণ এবং পাঠযোগ্যতার জন্য ছোট ছোট ইউনিটে বিভক্ত বিবৃতি:

s, u, f, b = ' ', '_', '/', '\\'
def d(t, n):
    j = n - 1
    for p in t:
        for k in range(j, n):
            m, v = n - 1 - k, '_ '[k < n - 1]
            q = p[:-1]
            q = q.replace(f + u, '(_')
            q = q.replace(u + b, '_)')
            q = q.replace(s, s * n)
            q = q.replace(u, v * n)
            q = q.replace(f, s * m + f + s * k)
            q = q.replace('(', v * m + f + v * k)
            q = q.replace(b, s * k + b + s * m)
            q = q.replace(')', v * k + b + v * m)
            print q
            j = 0

এখানে মৌলিক পদ্ধতিটি হ'ল:

  1. ইনপুট সমস্ত লাইন উপর লুপ।
  2. প্রতিটি লাইনের জন্য, Nপ্রতিটি লুপের পুনরাবৃত্তিতে আউটপুট লাইন উত্পন্ন করে আউটপুট আকারের উপর লুপ করুন। আউটপুট শুরুর সময় খালি লাইন তৈরি এড়াতে প্রথম লাইনের জন্য একটি বিশেষ কেস রয়েছে যেখানে কেবলমাত্র শেষ আউটপুট লাইন তৈরি করা হয়।
  3. লাইনের প্রতিটি অক্ষরকে অক্ষর দ্বারা প্রতিস্থাপন করুন N, যেখানে:
    • প্রতিটি স্থান Nস্পেস দ্বারা প্রতিস্থাপিত হয় ।
    • প্রতিটি আন্ডারস্কোরটি Nপ্রথম N -1লুপ পুনরাবৃত্তির জন্য স্পেস দ্বারা প্রতিস্থাপিত হয় এবং Nশেষ লুপ পুনরাবৃত্তির জন্য আন্ডারস্কোর হয়।
    • স্ল্যাশ এবং ব্যাকস্ল্যাশগুলি N - 1ফাঁকা স্থান বা আন্ডারস্কোর দিয়ে প্যাড করা থাকে ।

এখানে সবচেয়ে জটিল অংশটি হ'ল স্ল্যাশ / ব্যাকস্ল্যাশগুলির প্যাডিং পরবর্তী (স্ল্যাশগুলির জন্য) বা পূর্ববর্তী (ব্যাকস্ল্যাশগুলির জন্য) ইনপুট চরিত্রের উপর নির্ভর করে স্পেস বা আন্ডারস্কোর ব্যবহার করে। স্ট্রিং প্রতিস্থাপনের কৌশলটি এটি ভালভাবে ফিট করে নি।

এর সমাধানের জন্য আমি যা করেছি তা হ'ল আমি প্রথমে নির্দিষ্ট দুটি চরিত্রের সমন্বয়টি বিভিন্ন চরিত্রের সাথে প্রতিস্থাপন করি, যাতে প্রকৃত প্রতিস্থাপনের সময় আমি তাদের সাথে আলাদাভাবে আচরণ করতে পারি। উদাহরণস্বরূপ, /_দ্বারা প্রতিস্থাপিত হয় (_। এর পরে, (কার্যকরভাবে একটি "স্ল্যাশ অনুসরণ করে আন্ডারস্কোর", যা তারপরে সেই অনুযায়ী প্রতিস্থাপন করা যায়।

ফাংশনটি পরীক্ষার জন্য ব্যবহৃত প্রধান প্রোগ্রাম:

import sys
import Golf

n = int(sys.argv[1])
t = ''.join(sys.stdin).rstrip()

Golf.d(t, n)
— রেটো কোরাদি
সূত্র
1
n-1-kহলn+~k
— পুনরাবৃত্ত হবে
সম্পূর্ণ প্রকাশের স্বার্থে: আমি সবেমাত্র পেয়েছি যে আমার সমাধানটি কিছু পিছনে স্থান তৈরি করে। যেহেতু আউটপুট সংজ্ঞায় এটি অনুমোদিত নয়, এটি প্রয়োজনীয়তা পূরণ করে না। সবচেয়ে খারাপ ক্ষেত্রে, আমাকে .rstrip()আরও 9 টি চরিত্রের জন্য যুক্ত করতে হবে । আমি আশা করি আমি আরও ভাল করতে পারি, এবং 5 টি অক্ষর কেটে নেওয়ার একটি উপায়ও পেয়েছি।
— রেটো কোরাডি
দেখে মনে হচ্ছে আপনার ইনপুট ফর্ম্যাটটি অনুমোদিত নয়। sys.stdinকোনও অনুমোদিতযোগ্য ইনপুট প্যারামিটার নয় - আপনার নিজের স্ট্রিংটি নিজেই পরিচালনা করতে হবে।
— isaacg
আচ্ছা আপনি ব্যবহার করতে পারেন sys.stdinএবং int(sys.argv[1])আশা তাদের ভেরিয়েবল হিসাবে গৃহীত হবে দ্বারা কিন্তু আপনি তাদের বিনামূল্যে জন্য পেতে করত না হন (অর্থাৎ, ন্যায্য খেলা ছিল, তাহলে আপনি এছাড়াও alias লেখা আশা করতে পারে rangeএবং replace` এবং অন্য যাই হোক না কেন আপনি predefine হতে হবে) ।
— মার্টিন এন্ডার
@ মার্টিনবাটনার এটি বলছে যে আমি ইনপুটটিকে একটি ফাংশন আর্গুমেন্ট হিসাবে নিতে পারি। আমি কি এখানে এটি করছি না? আমি যাই হোক না কেন স্ট্রিংয়ের তালিকায় ফাংশন যুক্তিটি পরিবর্তন করতে যাচ্ছি। ঠিক আছে? এটি খুব আলাদা নয়, যেহেতু উভয় stdinএবং স্ট্রিংয়ের একটি তালিকা স্ট্রিং সিকোয়েন্স।
— 31o15
1

পার্ল, 132

#!perl -p
INIT{$f=pop}s!.!$&x$f!ge;s! $!! while s!\\+\K\\|/(/)! $1!;
for$x(2..m!/!*$f){print y!_! !r;s!\\.?! \\!g;s!./(.)?!/$1$1!g;s!_ !__!g}

সংযুক্ত এসটিডিএন এবং এআরজিভি ইনপুট। উদাহরণ:

$ perl ~/hex.pl <~/hex.txt 3
         __________________
        /     /     /\     \
       /     /     /  \     \
      /_____/_____/    \_____\
     /     /\     \    /\     \
    /     /  \     \  /  \     \
   /_____/    \_____\/    \_____\
  /\     \    /     /\    /     /\
 /  \     \  /     /  \  /     /  \
/    \_____\/_____/    \/_____/    \
\    /     /\     \    /     /\    /
 \  /     /  \     \  /     /  \  /
  \/_____/    \_____\/_____/    \/
   \     \    /     /\     \    /
    \     \  /     /  \     \  /
     \_____\/_____/    \_____\/
      \     \     \    /     /
       \     \     \  /     /
        \_____\_____\/_____/
— nutki
সূত্র
1

রুবি 236 237

->i,z{i.split(?\n).map{|l|z.times.map{|y|l.size.times.map{|i|z.times.map{|x|c=l[i]
z<y+2&&(l[i-1..i]=='_\\'||l[i..i+1]=='/_')&&o=?_
(c<?!||(x==y&&c==?\\)||(z==y+1&&c>?^)||(x+y+1==z&&c==?/))&&o=c
o||' '}.join}.join.rstrip}-['']}.join ?\n}

অনলাইন পরীক্ষা: http://ideone.com/e6XakQ

গল্ফ করার আগে এই কোড:

-> diamond, zoom {
  diamond.split(?\n).map do |l|
    zoom.times.map do |y|
      l.size.times.map do |i|
        zoom.times.map do |x|
          out_char = crt_char = l[i]

          out_char = ' '

          # _ has to be continued under / or \
          if zoom == y+1 && l[i-1..i]=='_\\'
            out_char = ?_
          end
          if zoom == y+1 && l[i..i+1]=='/_'
            out_char = ?_
          end

          # logic to "zoom" \, / and _ characters 
          out_char = crt_char if crt_char == ' '
          out_char = crt_char if x==y && crt_char == ?\\  
          out_char = crt_char if zoom==y+1 && crt_char == ?_
          out_char = crt_char if x+y+1==zoom && crt_char == ?/

          out_char
        end.join
      end.join.rstrip
    end - ['']
  end.join ?\n
}
— ক্রিশ্চিয়ান লুপাস্কু
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.