निम्नलिखित मापदंडों को देखते हुए, एक ASCII ग्रिड जो रम्बी से बना है, उत्पन्न करने के लिए बाइट काउंट द्वारा मापा गया सबसे छोटा कोड लिखें:

m - एक पंक्ति में पूर्ण rhombi की संख्या
n - पंक्तियों की संख्या
s - सबसे छोटे रोम्बस का किनारा
आर - नेस्टिंग का स्तर - "बेस वाले" के अंदर कितने आरओबी होते हैं (जो ग्रिड के चौराहों के बीच फंउड होते हैं)

उदाहरण

1. Input: 5 3 1 0
Output:

/\/\/\/\/\
\/\/\/\/\/
/\/\/\/\/\
\/\/\/\/\/
/\/\/\/\/\
\/\/\/\/\/

A 5x3 grid of rhombi with side 1, no nesting

2. Input: 3 2 2 0
Output:

 /\  /\  /\
/  \/  \/  \
\  /\  /\  /
 \/  \/  \/ 
 /\  /\  /\
/  \/  \/  \
\  /\  /\  /
 \/  \/  \/ 

A 3x2 grid of rhombi with side 2, no nesting

3. Input: 5 2 1 2
Output:

///\\\///\\\///\\\///\\\///\\\
///\\\///\\\///\\\///\\\///\\\
///\\\///\\\///\\\///\\\///\\\
\\\///\\\///\\\///\\\///\\\///
\\\///\\\///\\\///\\\///\\\///
\\\///\\\///\\\///\\\///\\\///
///\\\///\\\///\\\///\\\///\\\
///\\\///\\\///\\\///\\\///\\\
///\\\///\\\///\\\///\\\///\\\
\\\///\\\///\\\///\\\///\\\///
\\\///\\\///\\\///\\\///\\\///
\\\///\\\///\\\///\\\///\\\///

A 5x2 grid of rhombi with side 1 (the smallest rhombus), level of nesting is 2

4. Input: 4 2 2 1
Output:

 //\\  //\\  //\\  //\\ 
///\\\///\\\///\\\///\\\
//  \\//  \\//  \\//  \\
\\  //\\  //\\  //\\  //
\\\///\\\///\\\///\\\///
 \\//  \\//  \\//  \\//   
 //\\  //\\  //\\  //\\ 
///\\\///\\\///\\\///\\\
//  \\//  \\//  \\//  \\
\\  //\\  //\\  //\\  //
\\\///\\\///\\\///\\\///
 \\//  \\//  \\//  \\//   

A 4x2 grid of rhombi with side 2 with level of nesting 1 

5. Input: 4 2 3 3
Output:

  ////\\\\    ////\\\\    ////\\\\    ////\\\\
 /////\\\\\  /////\\\\\  /////\\\\\  /////\\\\\
//////\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\
//////\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\
/////  \\\\\/////  \\\\\/////  \\\\\/////  \\\\\
////    \\\\////    \\\\////    \\\\////    \\\\
\\\\    ////\\\\    ////\\\\    ////\\\\    ////
\\\\\  /////\\\\\  /////\\\\\  /////\\\\\  /////
\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\//////
\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\//////
 \\\\\/////  \\\\\/////  \\\\\/////  \\\\\/////  
  \\\\////    \\\\////    \\\\////    \\\\////  
  ////\\\\    ////\\\\    ////\\\\    ////\\\\
 /////\\\\\  /////\\\\\  /////\\\\\  /////\\\\\
//////\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\
//////\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\
/////  \\\\\/////  \\\\\/////  \\\\\/////  \\\\\
////    \\\\////    \\\\////    \\\\////    \\\\
\\\\    ////\\\\    ////\\\\    ////\\\\    ////
\\\\\  /////\\\\\  /////\\\\\  /////\\\\\  /////
\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\//////
\\\\\\//////\\\\\\//////\\\\\\//////\\\\\\//////
 \\\\\/////  \\\\\/////  \\\\\/////  \\\\\/////  
  \\\\////    \\\\////    \\\\////    \\\\////  

A 4x2 grid of rhombi with side 3, level of nesting 3

जहां आवश्यक हो, किनारों और कोनों पर आंशिक रूप से दिखाई देने वाली रम्बी प्रदर्शित करना सुनिश्चित करें।

code-golf ascii-art grid

— गैलेन इवानोव
स्रोत

1

@AdmBorkBork "नेस्टिंग" से मेरा मतलब है ग्रिड के चौराहों के बीच पाए जाने वाले आधार वाले स्थानों में अंकित किए गए रम्बी की संख्या।

— गैलेन इवानोव

3

SOGL V0.12 , 20 बाइट्स

ā.I∫e+H╚╬8}:±№╬8╬¡∙*

यह कोशिश करो! इनपुट को उल्टे क्रम में लेते हैं जो वे उदाहरणों में हैं - r, s, n, m।

स्पष्टीकरण:

ā                     push an empty array - canvas
 .I∫      }           for each in range(input) (1-indexed)
    e+                  add the second input
      H                 decrement
       ╚                create a diagonal of that size
        ╬8              insert into the canvas
           :          create a duplicate of the canvas
            ±№        reverse it vertically and horizotally
              ╬8      insert that into the canvas
                ╬¡    quad-palindromize
                  ∙   multiply vertically by the next input
                   *  multiply horizontally by the next input

— dzaima
स्रोत

2

यह सिर्फ आश्चर्यजनक है, आप इस तरह के कार्यक्रम को 20 बाइट्स में कैसे संपीड़ित करते हैं।

— आउटगॉल्फ

1

यह सिर्फ शानदार है ... एक चौंका देने वाला 28 बाइट्स द्वारा चारकोल की पिटाई करने के लिए मेरी ओर से +1:

— श्री एक्सकोडर

यह वास्तव में प्रभावशाली है!

— गैलन इवानोव

@ Mr.Xcoder 19 बाइट्स अब। लेकिन फिर मैं बिल्डरों के खिलाफ हूं ∙*...

— नील

1

चारकोल में वेक्टर स्ट्रिंग का दोहराव काफी कम होता है; अगर मैं हीरे के एक तार प्रतिनिधित्व का निर्माण कर सकता हूं तो इसे दोहराने के लिए मुझे केवल 6 बाइट का खर्च आएगा। दुर्भाग्य से मुझे ऐसा करने में 50 बाइट्स लगते हैं। दूसरी ओर, हीरे को खींचने में मुझे केवल 17 बाइट्स लगते हैं, एसओजीएल से सिर्फ 1 अधिक ... लेकिन इसके बाद कैनवास को गुणा करने के लिए 20 बाइट्स लगते हैं।

— नील

8

चारकोल , 48 39 37 बाइट्स

ＵＯ⊕Ｉε\Ｆ⊖ＩζＣ¹¦¹‖ＭL≔⊗⁺ＩζＩεδＦ⊖ＮＣδ⁰Ｆ⊖ＮＣ⁰δ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＵＯ⊕Ｉε\

आकार का एक वर्ग ड्रा करें r + 1। यह आकार 1 के एक नेस्टेड हीरे का एक चौथाई है।

Ｆ⊖ＩζＣ¹¦¹

s - 1इसे सही आकार में लाने के लिए स्क्वेयर 1 स्क्वेयर राइट और डाउन बार कॉपी करें ।

‖ＭL

इसे पूर्ण नेस्टेड हीरा बनने के लिए प्रतिबिंबित करें।

≔⊗⁺ＩζＩεδ

इस नेस्टेड हीरे के आकार की गणना करें।

Ｆ⊖ＮＣδ⁰

हीरे को सही m - 1समय पर कॉपी करें ।

Ｆ⊖ＮＣ⁰δ

हीरे को नीचे की ओर कॉपी करें n - 1।

— नील
स्रोत

8

पायथन 2 , 160 159 158 बाइट्स

^{-1 जोनाथन फ्रेच को धन्यवाद}

m,n,s,r=input()
l=~-s*' '+'/'*(r-~r)+~-s*' '
for x in range(n*2):print'\n'.join(m*(l[i:i+s+r]+l.replace(*'/\\')[i:i+s+r][::-1])for i in range(r+s))[::1-x%2*2]

इसे ऑनलाइन आज़माएं!

यह इस तथ्य का उपयोग करता है कि रोम्बस के नीचे शीर्ष उल्टा है ( [::-1]), ऊपर या नीचे होने पर नियंत्रण करने range(n*2)और ~x%2*2-1नियंत्रित करने के लिए उपयोग करना।
शीर्ष (और नीचे) के लिए दाईं ओर सिर्फ बाईं ओर उल्टा है और इसके /साथ प्रतिस्थापित किया जा रहा है \-> l.replace(*'/\\')..[::-1]
पैटर्न उत्पन्न करने के लिए / नेस्टिंग ~-s*' '+'/'*(1+r*2)+~-s*' 'का उपयोग स्ट्रिंग बनाने के लिए किया जाता है जैसे /// कि iterated और कटा हुआ होगा:

   '|  //|/  '  
  ' | ///|  '  
 '  |/// | '  
'  /|//  |'

— छड़ी
स्रोत

मुझे लगता है कि (1+r*2)हो सकता है (r-~r)।

— जोनाथन फ्रेच

7

जूलिया 0.6 , 190 बाइट्स

g(n,m,s,r)=(s+=r+1;f(i,j,u=mod(i-j+r,2s),v=mod(j+i+r,2s))=(" \\/")[abs(u-r)<abs(v-r)?1+(u<=2r):1+2(v<=2r)];
for i=1:2(s-1)m println((f(i+(i-1)÷(s-1),s+j+(j-1)÷(s-1))for j=1:2(s-1)n)...)end)

यह एक कार्यात्मक समाधान है जो प्रत्येक सूचकांक जोड़ी के लिए गणना करता है i,jकि प्रतीक को क्या प्रदर्शित किया जाना चाहिए।

इसे ऑनलाइन आज़माएं!

चित्रण

एक ग्रिड के साथ शुरू करो

f(i,j,u=mod(i,2s),v=mod(j,2s))=(" -|*")[1+(u==0)+2(v==0)]
for i=1:2(s-1)m println((f(i-1,j)for j=1:2(s-1)n)...)end

---------*---------*----
         |         |    
         |         |    
         |         |    
         |         |    
         |         |    
         |         |    
         |         |    
         |         |    
         |         |    
---------*---------*----
         |         |    
         |         |    
         |         |    
         |         |    
         |         |

r > 0 मोटी लाइनों का मतलब है

f(i,j,u=mod(i+r,2s),v=mod(j+r,2s))=(" -|*")[1+(u<=2r)+2(v<=2r)]
for i=1:2(s-1)m println((f(i,j)for j=1:2(s-1)n)...)end

**-----*****-----*****--
**-----*****-----*****--
||     |||||     |||||  
||     |||||     |||||  
||     |||||     |||||  
||     |||||     |||||  
||     |||||     |||||  
**-----*****-----*****--
**-----*****-----*****--
**-----*****-----*****--
**-----*****-----*****--
**-----*****-----*****--
||     |||||     |||||  
||     |||||     |||||  
||     |||||     |||||  
||     |||||     |||||

मूल ग्रिड पर कौन सी रेखा निकटतम है, इसकी जांच करके कोनों को संभालें

f(i,j,u=mod(i+r,2s),v=mod(j+r,2s))=(" -|")[abs(u-r)<abs(v-r)?1+(u<=2r):1+2(v<=2r)]
for i=1:2(s-1)m println((f(i,j)for j=1:2(s-1)n)...)end

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

एक परी हमें हर s-1लाइन को हटाने के लिए कहती है

f(i,j,u=mod(i+r,2s),v=mod(j+r,2s))=(" -|")[abs(u-r)<abs(v-r)?1+(u<=2r):1+2(v<=2r)]
for i=1:2(s-1)m println((f(i+(i-1)÷(s-1),s+j+(j-1)÷(s-1))for j=1:2(s-1)n)...)end

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

तिरछे तिरछे होकर किया गया

f(i,j,u=mod(i-j+r,2s),v=mod(j+i+r,2s))=(" \\/")[abs(u-r)<abs(v-r)?1+(u<=2r):1+2(v<=2r)]
for i=1:2(s-1)m println((f(i+(i-1)÷(s-1),s+j+(j-1)÷(s-1))for j=1:2(s-1)n)...)end

 ///\\\  ///\\\  ///\\\ 
////\\\\////\\\\////\\\\
////\\\\////\\\\////\\\\
///  \\\///  \\\///  \\\
\\\  ///\\\  ///\\\  ///
\\\\////\\\\////\\\\////
\\\\////\\\\////\\\\////
 \\\///  \\\///  \\\/// 
 ///\\\  ///\\\  ///\\\ 
////\\\\////\\\\////\\\\
////\\\\////\\\\////\\\\
///  \\\///  \\\///  \\\
\\\  ///\\\  ///\\\  ///
\\\\////\\\\////\\\\////
\\\\////\\\\////\\\\////
 \\\///  \\\///  \\\///

— mschauer
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 154 बाइट्स

f=
(m,n,s,r)=>[...Array((s+=r)*n*2)].map((_,i)=>[...Array(s*m*2)].map((_,j)=>i/s&1^j/s&1?`\\ `[g(j%s)]:`/ `[g(s-1-j%s)],g=j=>i%s-j>r|j-i%s>r).join``).join`
`

<div oninput=o.textContent=f(+m.value,+n.value,+s.value,+r.value)>
m: <input type=number min=0 id=m><br>
n: <input type=number min=0 id=n><br>
s: <input type=number min=0 id=s><br>
r: <input type=number min=0 id=r></div>
<pre id=o>

स्निपेट का विस्तार करें

सीधे आउटपुट के प्रत्येक सेल में चरित्र की गणना करता है।

— नील
स्रोत

2

CJam, 44

q~:R+,_ff{-zR>}{_W%:~\+"\ /"f=}%_W%Wf%+*f*N*

इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

q~           read and evaluate the input
:R+          save the last number in variable R, then add the last 2 numbers (s+r)
,_           make an array [0 1 … s+r-1] and duplicate it
ff{…}        make a matrix, calculating for each (x,y) pair from the 2 arrays:
  -z         abs(x-y)
  R>         compared with R (1 if greater, 0 if not)
{…}%         transform each row of the matrix:
  _W%        duplicate and reverse it
  :~         bitwise-NOT each element (0 → -1, 1 → -2)
  \+         prepend to the original row
  "\ /"f=    replace numbers with characters from this string (by index):
              0 → '\'; 1, -2 → ' '; -1 → '/'
              this generates the "/\" part
_W%          duplicate the matrix and reverse the rows
Wf%+         reverse each row, then append (by rows) to the original matrix
              this adds the "\/" part
*            repeat the matrix (by rows) n times
f*           repeat each row m times
N*           join the rows with newlines

— aditsu
स्रोत

2

सी # (.NET कोर) , 167 बाइट्स

(c,r,s,n)=>{int w=s+n,i=0,j;var g="";for(;i<r*2*w;i++,g+="\n")for(j=0;j<c*2*w;){int y=i%w,q=(j/w+i/w+1)%2,p=~-w*q+j++%w*(1-2*q);g+=p>y+n|p<y-n?' ':"\\/"[q];}return g;}

इसे ऑनलाइन आज़माएं!

मैं अपने द्वारा प्रबंधित आकार से हैरान हूं; मैं शुरू में एक लंबे समाधान की उम्मीद कर रहा था। यह कहने में, मुझे यकीन है कि अन्य चालें हैं जो मुझे याद हैं।

DeGolfed

(c,r,s,n)=>{
    int w=s+n, // rhombus quadrant width, and height
        i=0, // string row
        j; // string column

    var g="";

    // go through every character row and column
    for(; i < r*2*w; i++, g += "\n")
        for(j = 0; j < c*2*w;)
        {
            int y = i % w, // vertical position in the quadrant
                q = ( j / w + i / w + 1) % 2, // Get the rhombus quadrant as a 0 or 1
                p = ~-w * q + j++ % w * (1-2*q); // horizontal position in quadrant. the value is either ascending or descending depending on the quadrant

            // select which character to use at this [i,j] position
            g += p > y + n | p < y - n ? ' ' : "\\/"[q];
        }

    return g;
}

— Ayb4btu
स्रोत

1

पायथन 2 , 201 189 बाइट्स

def f(m,n,s,r):Z=range(s+r);R=[r-~min(i,s+~i+r,min(s-1,r))for i in Z];L=[m*(' '*(s+~i)+'/'*R[i]+'  '*(i-r)+'\\'*R[i]+' '*(s+~i))for i in Z];print'\n'.join((L+[l[s+r:]+l[:s+r]for l in L])*n)

इसे ऑनलाइन आज़माएं!

इस तथ्य का उपयोग करता है कि नीचे शीर्ष के समान है, लेकिन स्थानांतरित कर दिया गया है:

Top:       /\/\/\
Bottom:     /\/\/\

जोनाथन फ़्रेच के लिए 22 बाइट्स धन्यवाद सहेजे

— TFeld
स्रोत

s-i-1हो सकता है s+~i, दो बाइट्स बचा रहा हो । एक और बचत r+1+min(...हो सकती है r-~min(...। एक और बाइट की बचत L=[(...)*m forहो सकती है L=[m*(...)for।

— जोनाथन फ्रीच

L+=[...];print'\n'.join(L*n)print'\n'.join((L+[...])*n)एक और बाइट को बचाने के लिए हो सकता है, जिसके परिणामस्वरूप 196 बाइट्स होंगे ।

— जोनाथन फ्रेच

195 बाइट्स , अगर एक के s+r-i-1साथ भी बदल जाती है s+~i+r।

— जोनाथन फ्रेच

190 बाइट्स ।

— जोनाथन फ्रेच

वैकल्पिक 192 बाइट्स संस्करण या 191 बाइट्स संस्करण का उपयोग करके execऔर स्ट्रिंग स्वरूपण।

— जोनाथन फ्रेच

1

पर्ल 5, 159 + 3 (-नल) बाइट्स

($m,$n,$s,$r)=@F;$s=$"x($s+$r-1);$_="$s/\\$s"x$m;$n*=2;{$t=$_;map$t=~s, ?(\S) ?,$1x$&=~y///c,ge,1..$r;print$t;redo if s, /,/ ,g&&s,\\ , \\,g||y,/\\,\\/,&&--$n}

यह ऑनलाइन की कोशिश करो

— नहुएल फौलीउल
स्रोत

ASCII रंबल ग्रिड

उदाहरण

SOGL V0.12 , 20 बाइट्स

चारकोल , 48 39 37 बाइट्स

पायथन 2 , 160 159 158 बाइट्स

जूलिया 0.6 , 190 बाइट्स

चित्रण

जावास्क्रिप्ट (ईएस 6), 154 बाइट्स

CJam, 44

सी # (.NET कोर) , 167 बाइट्स

DeGolfed

पायथन 2 , 201 189 बाइट्स

पर्ल 5, 159 + 3 (-नल) बाइट्स