सारांश

ASCII कला चुनौतियों की हालिया लोकप्रियता से प्रेरित, इस चुनौती का उद्देश्य ASCII बिसात बनाना है, जिस पर शतरंज खेला जा सकता है।

एक प्रोग्राम लिखें जो एक सकारात्मक पूर्णांक nको एक तर्क के रूप में stdin, या उपयोगकर्ता इनपुट के रूप में लेता है , और nx nचौकों के साथ एक चेकबोर्ड को आउटपुट करता है, साथ ही एक सीमा जो 1 वर्ण मोटी है।

प्रत्येक वर्ग 2x2 वर्ण होना चाहिए। चौकों को सामान्य बारी-बारी से सफेद-काले (पहले सफेद, जैसा कि शीर्ष-बाएं कोने में) एक चेकरबोर्ड के पैटर्न का पालन करना चाहिए। सफेद वर्गों को अंतरिक्ष से बाहर किया जाना चाहिए ( ) वर्ण, और काले वर्गों को पाउंड ( #) वर्णों से बनाया जाना चाहिए ।

सीमा को एक वर्ग के लंबवत या लंबवत बिंदु पर -प्लस ( +) के साथ डैश ( ) से बाहर किया जाना चाहिए ।

इनपुट

बिसात में वर्गों की संख्या (वर्गों में आयाम) की संख्या का प्रतिनिधित्व करने में सकारात्मक पूर्णांक, प्रत्येक वर्ग 2x2 वर्णों के साथ।

उदाहरण के परिणाम

n=2

+--+--+
|  |##|
|  |##|
+--+--+
|##|  |
|##|  |
+--+--+

n=3

+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
|##|  |##|
|##|  |##|
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+

n=4

+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+

... और इसी तरह।

ट्रेलिंग स्पेस और नई लाइनें स्वीकार्य हैं।
आप एक संपूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं।
कोई अग्रणी स्थान नहीं।
आपके कार्यक्रम को n = 15 के लिए सही परिणाम प्रदर्शित करने चाहिए।
कम-ज्ञात गूढ़ भाषाओं और समान के लिए, भाषा का लिंक प्रदान करें।
n=0उत्पादन करना चाहिए +। (वैकल्पिक, लेकिन अत्यधिक अनुशंसित और प्रोत्साहित किया गया।)
बाइट्स में सबसे छोटा कोड जीतता है, क्योंकि यह कोड गोल्फ है।

code-golf ascii-art

— kdragon
स्रोत

2

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यहाँ अच्छा काम, विशेष रूप से आपकी पहली चुनौती के लिए। मैं आपका अधिक सामान देखने के लिए उत्सुक हूं।

— एलेक्स ए।

मुझे लगता है "आपके कार्यक्रम को n = 15 के लिए सही परिणाम प्रदर्शित करने चाहिए।" का अर्थ है "n = 15 तक"?

— जॉन ड्वोरक

"आपके कार्यक्रम को n = 10 के लिए सही परिणाम प्रदर्शित करने चाहिए।" यदि आपका प्रोग्राम ठीक से n = 15 तक प्रस्तुत नहीं कर सकता है, तो इसे पोस्ट नहीं किया जाना चाहिए। लेकिन इसका मतलब यह नहीं है कि आपको शोषण / शोषण करना चाहिए और एक ऐसा प्रोग्राम लिखना चाहिए जो केवल n = 15 तक जा सकता है।

— kdragon

मैं परीक्षण किया काम कर जवाब वोट दें, भले ही वे उत्पादन नहीं करते +के लिए n=0।

— kdragon

क्षमा करें मैंने विजेता को कभी स्वीकार नहीं किया। अब स्वीकार कर रहे हैं।

— kdragon

16

जे, 24 बाइट्स

एक अनाम फ़ंक्शन:

2 2&$&.>@(' #'{~2|+/~@i.)

उपयोग:

   f =: 2 2&$&.>@(' #'{~2|+/~@i.)
   f 4
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+

— लिन
स्रोत

1

&.>से छोटा है each। ध्यान दें कि यह तभी काम करता है जब BoxFormवह सेट हो ASCII।

— रैंडम जूल

10

अजगर 2, 79

N=3*input()+1
for i in range(N):print('+||- #- #+||-# -# '*N)[3**i%7/2%3:3*N:3]

प्रत्येक पंक्ति के लिए, पैटर्न में से एक का चयन करता है

+--+--+--+--+--+
|  |##|  |##|  |
|##|  |##|  |##|

और 3*n+1इसके पात्रों को प्रिंट करता है। पैटर्न को इसके पहले 6 वर्णों को दोहराते हुए चुना जाता है, जिसे स्ट्रिंग इंटरलेविंग ट्रिक के साथ चुना जाता है, जो सही लंबाई का एक स्निपेट निकालने का काम भी करता है।

दोहराए जाने वाले पैटर्न [0,1,1,0,2,2] को देने वाले iअंकगणितीय अभिव्यक्ति द्वारा सही पैटर्न को पंक्ति सूचकांक modulo 6 के मूल्य के आधार पर चुना जाता है 3**i%7/2%3। मैंने इसे इस तथ्य का उपयोग करके पाया कि x**i%7इसकी अवधि है 6, फिर xसही पैटर्न प्राप्त करने के लिए और विभिन्न पोस्टप्रोसेसिंग के विभिन्न मूल्यों की कोशिश कर रहा है ।

— XNOR
स्रोत

9

पायथ, ३,

VJh*3Qsm@?+\|*2@" #"+/N3/d3%N3"+--"dJ

बल्कि एक साथ हैक किया गया, लेकिन छोटा।

प्रदर्शन।

— isaacg
स्रोत

9

CJam, 43 42 बाइट्स

ri3*)_2m*{_3f%:!2b\3f/:+2%(e|"#|-+ "=}%/N*

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

प्रत्येक समन्वय को एक चार्ट में मैप किया जाता है, जैसे कि शीर्ष बाएं कोने है (0, 0) -> "+"। विशेष रूप से, हम गणना करते हैं

[(y%3 == 0)*2 + (x%3 == 0)] or [(x//3 + y//3) % 2 - 1]

और "#|-+ "तदनुसार स्ट्रिंग में सूचकांक ।

— Sp3000
स्रोत

6

रेटिना , 106 बाइट्स

1
$_0$_x
1(?=1*0)
+--
1(?=1*x)
s
(0s.*?0)s
$1o
(s\D*?)s
$1o
s
|  
o
|##
\D*?x
$0$0
0
+n
x
|n
(.*?n).*
$0$1

इनपुट को एकरी के रूप में लेता है ( इस मेटा चर्चा के आधार पर )।

प्रत्येक पंक्ति को अपनी स्वयं की फ़ाइल पर nजाना चाहिए और फ़ाइलों में नई पंक्ति में बदलना चाहिए। यह अव्यवहारिक है, लेकिन आप कोड को चिह्न के रूप में -sध्वज के साथ, एक फ़ाइल के रूप में चला सकते हैं n। nयदि आप चाहें, तो आप पठनीयता के लिए आउटपुट में newlines को बदल सकते हैं । उदाहरण के लिए:

> echo -n 111|retina -s checkerboard|tr n '\n'
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
|##|  |##|
|##|  |##|
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+

आगे गोल्फिंग और कुछ स्पष्टीकरण बाद में आता है।

— randomra
स्रोत

4

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

n=>Array(n*3+1).fill("+--".repeat(n)+"+").map((v,i)=>v.replace(/./g,(k,x)=>i%3?"|  |##|  "[x%6+(i%6>2)*3]:k)).join`
`

स्निपेट:

<input type="range" min=2 max=15 step=1 value=1 id="i" oninput="o.textContent=f(this.value)"><pre id="o"></pre><script>function f(n){ return Array.apply(0,Array(n*3+1)).map(function(){return "+--".repeat(n)+"+"}).map(function(v,i){ return v.replace(/./g,function(k,x) { return i%3?"|  |##|  "[x%6+(i%6>2)*3]:k}) }).join("\n") };o.textContent=f(2)</script>

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

अनाम फ़ंक्शन। +--+--+--...लाइनों की एक पूरी सरणी के साथ शुरू होता है , और उचित लाइनों पर, के +लिए |और -के रूप में या के लिए उपयुक्त बदलता #है।

अभिव्यक्ति जो प्रतिस्थापन चरित्र को तय करती है "| |##| "[x%6+(i%6>2)*3], शायद आगे चलकर गोल्फ हो सकती है, लेकिन मैंने पाया है कि लंबे समय तक, अनावश्यक स्ट्रिंग एक जटिल गणना की तुलना में अधिक पात्रों को बचाता है।

— apsillers
स्रोत

अच्छा ES6 उपयोग! स्निपेट में स्लाइडर से प्रभाव एक अच्छा जोड़ है। क्या आप एक स्पष्टीकरण और असंबद्ध संस्करण प्रदान कर सकते हैं?

— kdragon

3

सीजेएम, 59 बाइट्स

यह बहुत लंबा है ..

ri:I," #"f=2f*_I({__sff^_}*]'|I)*f.\2/Nf*'+I)*"--"*aI)*.\N*

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

3

ES6, 106 बाइट्स के साथ कॉफीस्क्रिप्ट

f=(n,y=z='+--'[r='repeat'](n)+'+\n')->y+=('|##|  '[r](n).substr(i%2*3,n*3)+'|\n')[r](2)+z for i in[1..n];y

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

न्यूलाइन्स महत्वपूर्ण हैं और प्रत्येक को 1 बाइट के रूप में गिना जाता है।

स्पष्ट वापसी ने इसे थोड़ा लंबा कर दिया:

f=n=>{for(i=0,y=z='+--'[r='repeat'](n)+`+
`;i<n;)y+=('|##|  '[r](n).substr(++i%2*3,n*3)+`|
`)[r](2)+z;return y}

डेमो

लेखन के समय, फ़ायरफ़ॉक्स ईएस 6 के साथ संगत एकमात्र प्रमुख ब्राउज़र है।

f=n=>{for(i=0,y=z='+--'[r='repeat'](n)+`+
`;i<n;)y+=('|##|  '[r](n).substr(++i%2*3,n*3)+`|
`)[r](2)+z;return y}

// Demonstration related things
document.getElementById('O').innerHTML = f(document.getElementById('n').value);

document.getElementById('n').addEventListener('change', function () {
  document.getElementById('O').innerHTML = f(this.value);
});

<p><input id=n type=number min=0 step=1 value=6></p>
<pre><output id=O></output></pre>

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

— rink.attendant.6
स्रोत

3

अजगर 3, 114 108 100

def f(n):
 for i in range(3*n+1):print(("|##|  "*n+"|")[::i//3%2*2-1][:3*n+1]if i%3 else"+--"*n+"+")

पिछले समाधान

108

def f(n):
 for i in range(3*n+1):
  a=("|##|  "*n+"|")[::i//3%2*2-1][:3*n+1];print(a if i%3 else"+--"*n+"+")

114

def f(n):a="+--"*n+"+\n";b="|  |##"*n+"|";print(a+a.join(([(b[:3*n+1]+"\n")*2,(b[::-1][:3*n+1]+"\n")*2]*n)[:n])+a)

118 (प्रस्तुत नहीं)

def f(n):
 for i in range(3*n+1):print((("|##|  "*n)[:3*n+1]if i//3%2 else("|  |##"*n)[:3*n+1])if i%3 else"+--"*n+"+")

— एकध्रुवीय
स्रोत

3

सीजेएम, 46 बाइट्स

li3*)_2m*[{_3f/2f%:=\3f%:g+2b"+-|#+-| "=}/]/N*

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

खैर, मैं उम्मीद कर रहा था कि मेरे पास कम से कम एक मूल समाधान होगा (मैं आमतौर पर अपने दम पर काम करने से पहले अन्य उत्तरों को नहीं देखता हूं)। पता चला है कि @ Sp3000 पहले से ही बहुत कुछ किया था, केवल बेहतर है। लेकिन जब से मैंने पहले से ही काम किया है, मैंने सोचा कि मैं इसे वैसे भी पोस्ट करूंगा।

स्पष्टीकरण:

li    Get input n.
3*)   Calculate 3*n+1, which is the total width/height.
_     Copy size. We'll need it at the end to insert the newlines.
2m*   Calculate cartesian power with 2. This enumerates all coordinate pairs.
[     Wrap characters in array for split operation at the end.
  {     Loop over all coordinate pairs.
    _     Copy coordinate pair.
    3f/   Divide coordinates by 3.
    2f%   Modulo 2. This characterizes even/odd squares.
    :=    Compare the two coordinates. This gives 0/1 for white/black squares.
    \3f%  Grab second copy of coordinates, and calculate modulo 3.
    :g    Sign. This gives 0 for grid lines, 1 for interior of squares.
    +     Concatenate the two results. We now have a 3 bit code.
    2b    Convert the 3 bits to a number in range 0..7.
    "+-|#+-| "
          Lookup table to convert 0..7 number to character.
    =     Lookup character.
  }/    End loop over coordinate pairs.
]     End wrapping characters.
/     Split character array into lines.
N*    And join them with newlines.

— रेटो कोराडी
स्रोत

2

HackVM , 158 बाइट्स

निश्चित रूप से विजेता नहीं, लेकिन एचवीएम में ऐसा करना एक अच्छी चुनौती थी।

आकार को पहले मेमोरी सेल में रखें और निम्नलिखित कोड का उपयोग करें:

77*1+c0<0^84*1+?1-11<-1>99*85++0^cc77*1+c066*5+-g!0<0^45*2+?1-95*0^0^2-PPP064*-6-gd95*2-P25*P$1<2>555**1-P0<0^76*6-?1-12<-2>2<3*48*+0^PP555**1-P076*2+-gd25*P$

नोट: कोड को काम करने के लिए ठीक एक लाइन में होना चाहिए।

स्पष्टीकरण:

Call PLUSHDASHLINE
77*2+c

Read the cell and skip if done
0<0^84*1+?1-

  Flip row parity
  11<-1>

  Call NORMALLINE twice
  99*85++0^cc

  Call PLUSHDASHLINE
  77*1+c

Jump back to start of loop
066*5+-g!


DEFINE_PLUSDASHLINE
0<0^45*2+?1-95*0^0^2-PPP064*-6-gd95*2-P25*P$

DEFINE_NORMALLINE
1<2>555**1-P0<0^76*6-?1-12<-2>2<3*48*+0^PP555**1-P076*2+-gd25*P$

कोड 2 फ़ंक्शन को कॉल करता है PLUSHDASHLINEऔर NORMALLINE, समता के लिए एक वैश्विक स्थिति बनाए रखता है (यानी एक सेल में ' 'या एक डाल करने के लिए '#')।

इसके लिए स्पष्टीकरण PLUSDASHLINE:

Repeat N times
0<0^45*2+?1-

  Print "+--"
  95*0^0^2-PPP

End Repeat
064*-6-g

Print "+"
d95*2-P

Print "\n"
25*P

Return
$

इसके लिए स्पष्टीकरण NORMALLINE:

Copy Parity into Cell 2
1<2>

Print '|'
555**1-P

Repeat N times
0<0^76*6-?1-

  Flip Cell 2 (i.e. Flip Column Parity)
  12<-2>

  Calculate ' ' or '#' based upon parity
  2<3*48*+0^

  Print it twice
  PP

  Print '|'
  555**1-P

End Repeat
076*2+-g

Print "\n"
d25*P

Return
$

अगर किसी ने इसे और बेहतर बनाने के टिप्स दिए तो इसे सराहेंगे :)

— जय बोसमिया
स्रोत

2

अजगर 2, 98

n=input()
f=lambda a,b,s:s+s.join(([a*2,b*2]*n)[:n])+s+'\n'
print f(f(*' #|'),f(*'# |'),f(*'--+'))

सबसे छोटा तरीका नहीं है, लेकिन एक मनोरंजक तरीका है। फ़ंक्शन fदो स्ट्रिंग्स में होता है a,bऔर एक विभाजक होता है sऔर इसके तर्कों को इंटरलीव करता है saasbbsaasbbsaas। बोर्ड की पंक्तियों को उनके संबंधित पात्रों के साथ इस रूप में बनाया जाता है, फिर परिणाम उत्पन्न करने के लिए खुद को इस तरह से इंटरलेय किया जाता है।

— XNOR
स्रोत

यह के लिए अवैध उत्पादन का उत्पादन करता है n=0। अधिकांश समाधान (जिसे स्वीकार किया जाएगा) "+" का उत्पादन करता है। यह समाधान सामान्य अनुगामी 2 newlines (जिसकी अनुमति है) को छोड़कर "++ (newline) ++" का उत्पादन करता है।

— kdragon

@DragonGuy समस्या कहती है कि इनपुट एक धनात्मक पूर्णांक है।

— xnor

लेकिन कम से कम 0. के लिए एक कमबैक होना चाहिए नकारात्मक गिरावट की आवश्यकता नहीं है। 0. से कम संख्या के लिए कोई नियम नहीं होगा। यह समाधान 1. से कम किसी भी चीज़ के लिए "++ (newline) ++" देता है

— kdragon

@DragonGuy जब आप इनपुट आवश्यकताओं को निर्दिष्ट करते हैं, तो इसका मतलब है कि इनपुट को उन आवश्यकताओं को पूरा करने की गारंटी है, और जब वे मामले में नहीं होते हैं तो मनमाने ढंग से कार्य कर सकते हैं। मैंने देखा है कि आपने इस पोस्ट के बाद "n = 0 का उत्पादन + करना चाहिए" जोड़ने के लिए प्रश्न संपादित किया था, लेकिन उत्तर के बाद नियमों को बदलने से पहले से ही हतोत्साहित किया जाता है ।

— xnor

मैं उस नियम के बारे में सोच रहा था (प्रश्न से पहले कई प्रश्न पढ़ें), लेकिन चूंकि यह बहुत सारे उत्तरों को प्रभावित करने वाला नहीं था, इसलिए मुझे नहीं लगा कि यह कोई समस्या होगी। प्रश्न को स्पष्टता प्रदान करने और इसे वैकल्पिक बनाने के लिए संपादित किया गया।

— kdragon

2

रूबी: 83 वर्ण

f=->n{puts d=?++'--+'*n,(0...n).map{|i|[?|+'%2s|'*n%(['','##',''][i%2,2]*n)]*2<<d}}

नमूना रन:

irb(main):001:0> f=->n{puts d=?++'--+'*n,(0...n).map{|i|[?|+'%2s|'*n%(['','##',''][i%2,2]*n)]*2<<d}}
=> #<Proc:0x000000007c51a0@(irb):1 (lambda)>

irb(main):002:0> f[0]
+
=> nil

irb(main):003:0> f[1]
+--+
|  |
|  |
+--+
=> nil

irb(main):004:0> f[2]
+--+--+
|  |##|
|  |##|
+--+--+
|##|  |
|##|  |
+--+--+
=> nil

irb(main):005:0> f[3]
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
|##|  |##|
|##|  |##|
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
=> nil

— आदमी काम पर है
स्रोत

2

रूबी, 87

->n{a=[b="+--",c="|  |##",c,b,d="|##|  ",d]
0.upto(n*3){|i|puts"".ljust(n*3+1,a[i%6])}}

यह एक अनाम फ़ंक्शन है। इसे इस तरह से कॉल करें (सभी संभावनाएं 0 से 5 तक)

f=->n{a=[b="+--",c="|  |##",c,b,d="|##|  ",d]
0.upto(n*3){|i|puts"".ljust(n*3+1,a[i%6])}}

6.times{|j|f.call(j)}

यह ljustएक रिक्त स्ट्रिंग पर विधि का उपयोग करता है । रूबी औचित्य के लिए एक पैडिंग स्ट्रिंग को निर्दिष्ट करने की अनुमति देता है, इसलिए हम प्रति क्रम में ljustतीन संभावित पैडिंग स्ट्रिंग्स में से एक के साथ उपयोग करते हैं , जैसा कि आदेश दिया गया है ।b,c,dabccbdd

— स्तर नदी सेंट
स्रोत

1

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

n->(t="+--"^n*"+";a="|  ";b="|##";m=n÷2;c=n%2>0;p=println;p(t);for i=1:n p(((i%2<1?(b*a)^m*b^c:(a*b)^m*a^c)*"|\n")^2*t)end)

यह एक अनाम फ़ंक्शन बनाता है जो पूर्णांक को स्वीकार करता है और प्रिंटआउट को प्रिंट करता है।

असंगठित + स्पष्टीकरण:

function f(n)
    # Define the portions of the board
    t = "+--"^n * "+"
    a = "|  "
    b = "|##"

    # There will be n÷2 repeated a*b or b*a per line
    m = n ÷ 2

    # If n is odd, there will be an extra a or b
    c = n % 2 != 0

    # Print the top
    println(t)

    # Print each horizontal section of the board
    for i = 1:n
        # In even numbered sections, b precedes a
        j = (i % 2 == 0 ? (b*a)^m * b^c : (a*b)^m * a^c) * "|\n"
        println(j^2 * t)
    end
end

— एलेक्स ए।
स्रोत

1

जावास्क्रिप्ट, ईएस 6 149

n=>(r="+--".repeat(n)+"+",[...r].map((_,i)=>i%3?(x=i%6&&i%6<3?" ":"#",[...r].map((_,e)=>e%3?e%6&&e%6<3?x:"#"==x?" ":"#":"|").join('')):r).join('\n'))

लिखने में बहुत मज़ा आता है हालाँकि यह थोड़ा लंबा है

फ़ायरफ़ॉक्स पर काम करता है

1 - ओपन कंसोल

2 - निम्नलिखित टाइप करें

console.log((n=>(r="+--".repeat(n)+"+",[...r].map((_,i)=>i%3?(x=i%6&&i%6<3?" ":"#",[...r].map((_,e)=>e%3?e%6&&e%6<3?x:"#"==x?" ":"#":"|").join('')):r).join('\n')))(15));

आउटपुट (n = 15):

+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

— अफोंसो माटोस
स्रोत

क्या आप अन्य ES6 समाधानों की तरह एक स्निपेट जोड़ सकते हैं? इससे परीक्षण आसान हो जाएगा।

— kdragon

मैं 5 मिनट की सीमा में अपनी टिप्पणी संपादित करने जा रहा था, लेकिन मेरा कनेक्शन दोषपूर्ण था। क्या आप अन्य ES6 समाधानों की तरह एक स्निपेट जोड़ सकते हैं? इससे परीक्षण आसान हो जाएगा। एक जावास्क्रिप्ट प्रो और ES6 दोपहर के लिए, यह फ़ायरफ़ॉक्स स्क्रैचपैड में काम नहीं करता है।

— kdragon

@DragonGuy किया, देखें कि क्या यह आपके लिए काम करता है।

— अफोंसो माटोस

1

अंत में, आप अभी भी तीन बाइट्स को प्रतिस्थापित करके बचा सकते हैं join('\n') के साथ join` `है, जहां अंतरिक्ष मैं अर्थ है लिखा एक वास्तविक नई लाइन चरित्र।

— चिरू

1

हास्केल, 99

यह आंशिक रूप से कैटगोकैट द्वारा पिछले हास्केल उत्तर से प्रेरित है ; मैंने अपना खुद का संस्करण लिखा, फिर इसे देखा, फिर एक और लिखा। मैं एक ही नियम से खेल रहा हूं - इनपुट एक तर्क है, लेकिन आउटपुट स्टडआउट है। (यदि यह एक शुद्ध कार्य हो सकता है, तो 7 वर्णों को घटाएं putStr$।)

f n=putStr$unlines$t$map t$y[a,b,b,a,c,c]where t=take(n*3+1)
a=y"+--"
b=y"|  |##"
c=drop 3b
y=cycle

हम t3 n + 1 वर्णों के एक क्षेत्र का उपयोग करने के लिए निर्मित एक अनन्त चेकरबोर्ड से लेते हैं cycle, और यह वह है। दूसरे उत्तर से जो प्राथमिक विचार मैंने लिया, वह यह है कि सीमा और चेकर दोनों कोशिकाओं के पैटर्न को एक साथ रखा जाए तार में रखना।

मेरे पहले संस्करण (140 अक्षर) ने प्रत्येक बिंदु पर चरित्र की गणना करने की रणनीति का उपयोग किया, जो इस से अधिक जटिल समस्या के लिए बेहतर हो सकता है।

f n=putStr$unlines$map(\y->map(g y)r)r where r=[0..n*3]
g y x=s(s '+'y '|')x$s '-'y$cycle" #"!!(x`div`3+y`div`3)
s c i d|i`mod`3==0=c|True=d

— केविन रीड
स्रोत

मुझे खुशी है कि आपकी प्रेरणा से इस तरह के स्मार्ट जवाब का पता चला :)

— अफोंसो माटोस

इस फाइल के साथ लिखने cat <<EOF > sol1.hsऔर गिनती के साथ मुझे 84 बाइट्स मिलते हैं du -b sol1.hs।

— kdragon

@DragonGuy मैंने अभी भी वही काम किया है और अभी भी 99 मिलते हैं। wcसहमत हैं, और मैंने चरित्रहीन करने के लिए जाँच की। क्या यह 84-बाइट संस्करण चलता है ? यदि हां, तो मैं इसे ले

— केविन रीड

1

हास्केल, 118

यह मेरा पहला हैस्केल कोड गोल्फ उत्तर है और यहाँ यह है:

f n=mapM_(putStrLn.s)[0..3*n]where;d x=(++)$take(3*n)$cycle x;s x|x`mod`3<1=d"+--""+"|x`mod`6<3=d"|  |##""|"|1<2=d"|##|  ""|"

अधिक पठनीय संस्करण:

func num = do
    let -- Range
        rag = 3 * num
        -- `+--+`
        a = d "+--" "+"
        -- `|  |##`
        b = d "|  |##" "|"
        -- `|##|  `
        c = d "|##|  " "|"
        -- generate line
        d x y = take rag (cycle x) ++ y
        -- step
        step x
            | x `mod` 6 `elem` [1, 2] = b
            | x `mod` 3 == 0          = a
            | otherwise               = c

    mapM_ (putStrLn . step) [0..rag]

उत्पादन

*Main> :load test
[1 of 1] Compiling Main             ( test.hs, interpreted )
Ok, modules loaded: Main.
*Main> f 1
+
*Main> f 4
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
*Main> f 15
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

— अफोंसो माटोस
स्रोत

f 11 खाली बॉक्स का उत्पादन करना चाहिए, f 0सिर्फ प्लस चिन्ह का उत्पादन करना चाहिए ।

— केड

@ Vioz- मेरा बुरा, इसलिए यह कोड को और भी कम कर देता है: P

— Afonso Matos

1

C - 119 101

अब @ Sp3000 उत्तर के समान गणना का उपयोग करता है। इसके अलावा युगल अनुकूलन।

i,j;f(n){for(i=j=0;j<=n*3;i++)putchar(i-n*3-1?" -|+#"[!(j%3)+2*!(i%3)?:(i/3+j/3)%2*4]:(j-=i=-1,10));}

मुझे लगता है कि ?:यह एक जीसीसी विस्तार है ...

पुराना उत्तर:

f(n){int i,j;char p[]=" -|+";for(i=j=0;j<=n*3;*p=" #"[(i++/3+j/3)%2])putchar(i-n*3-1?p[!(j%3)+2*!(i%3)]:(j-=i=-1,10));}

यह 2 निर्देशांक रखता है और ईमानदारी से गणना करता है कि प्रत्येक जोड़े के लिए कौन से चरित्र को प्रिंट करना है। मुद्रित करने के लिए वर्णों की सूची सरणी में संग्रहीत की जाती है और यह अकेला "अनियंत्रित" ग्रिड प्रिंट करता है। सरणी का पहला तत्व काले वर्गों को आकर्षित करने के लिए संशोधित किया गया है।

मैं इसे बदल सकता हूं ताकि दो स्वतंत्र निर्देशांक के बजाय यह एक मान नीचे या (शायद और भी बेहतर) गिना जा सके, लेकिन अभी वह मेरे सिर के चारों ओर लपेट नहीं सकता है।

बोनस - एक प्रोग्राम में किसी भी अन्य संख्या के परिणाम के साथ 3 को प्रतिस्थापित करना जो विभिन्न सेल आकार के साथ मान्य चेकबोर्ड खींचता है।

— aragaer
स्रोत

1

awk - 91

{
    for(k=i=3*$0+1;i--;print"")
        for(j=k;j--;)printf i%3?j%3?234~(i+j)%6?FS:"#":j%3?"-":"|":"+"
}

इसे 100 से नीचे लाने के लिए काफी लड़ाई हुई थी। पीछे की ओर गिना जाना और मैच ऑपरेटर का उपयोग करना सफलताएं थीं;) बाकी सब बहुत सीधा तर्क है।

— Cabbie407
स्रोत

0

पाइके, 47 बाइट्स, गैर-प्रतिस्पर्धात्मक

"+--"Q*\+j+i
QQ]Uas 2%" #"@2*)F\|JjR+"+
"+2*pi
<Newline needed>

यहाँ यह कोशिश करो!

— नीला
स्रोत

ASCII चेकरबोर्ड ड्रा करें

सारांश

उदाहरण के परिणाम

टिप्पणियाँ

जे, 24 बाइट्स

अजगर 2, 79

पायथ, ३,

CJam, 43 42 बाइट्स

रेटिना , 106 बाइट्स

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

सीजेएम, 59 बाइट्स

ES6, 106 बाइट्स के साथ कॉफीस्क्रिप्ट

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

डेमो

अजगर 3, 114 108 100

पिछले समाधान

108

114

118 (प्रस्तुत नहीं)

सीजेएम, 46 बाइट्स

HackVM , 158 बाइट्स

अजगर 2, 98

रूबी: 83 वर्ण

रूबी, 87

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

जावास्क्रिप्ट, ईएस 6 149

हास्केल, 99

हास्केल, 118

C - 119 101

awk - 91

पाइके, 47 बाइट्स, गैर-प्रतिस्पर्धात्मक