रैंडम ASCII आर्ट ऑफ़ द डे # 5: डायमंड टिलिंग्स

21

मैश अप टाइम!

यह मेरी रैंडम गोल्फ ऑफ़ द डे और ऑप्टिमाइज़र ASCII आर्ट ऑफ़ द डे सीरीज़ दोनों की # 5 किस्त है । इस चुनौती में आपका सबमिशन दोनों लीडरबोर्ड की ओर गिना जाएगा (जो आप लिंक किए गए पोस्ट को पा सकते हैं)। बेशक, आप इसे किसी भी अन्य कोड गोल्फ चुनौती की तरह मान सकते हैं, और इसका जवाब दिए बिना किसी भी श्रृंखला के बारे में चिंता किए बिना।

छेद 5: हीरा झुकाव

एक नियमित षट्भुज हमेशा हीरे के साथ टाइल की जा सकती है जैसे:

हम इन झुकावों के ASCII कला प्रतिनिधित्व का उपयोग करेंगे। साइड-लंबाई 2 के एक षट्भुज के लिए, इस तरह के 20 झुकाव हैं:

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

एक साइड की लंबाई को देखते हुए N, आपको Nयादृच्छिक पर साइड की लंबाई के हेक्सागोन के लिए इस तरह की एक टाइलिंग उत्पन्न करनी चाहिए । सटीक वितरण कोई फर्क नहीं पड़ता, लेकिन प्रत्येक टाइलिंग को गैर-शून्य संभावना के साथ लौटाया जाना चाहिए।

इसके लिए N ≤ 4, आपके सबमिशन को 1 मिनट के भीतर कम से कम 80% समय पर एक टाइलिंग का उत्पादन करना होगा और कम से कम 80% झुकाव को 1 मिनट के भीतर उत्पन्न करना होगा। अधिकांश दृष्टिकोणों को इस नियम के बारे में चिंता करने की ज़रूरत नहीं होगी (यह बहुत ही उदार है) - यह बहुत भोले-भाले अस्वीकृति-आधारित एल्गोरिदम को नियमबद्ध करने के लिए है जब तक कि एक टाइलिंग नहीं होती है।

आपको यह जानना पसंद होगा कि दिए गए N के लिए संभावित झुकाव की कुल संख्या OEIS A008793 में पाई जा सकती है ।

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

आपको षट्भुज को संरेखित करने के लिए आवश्यक से अधिक अग्रणी स्थान का उत्पादन नहीं करना चाहिए (जो कि षट्भुज के बाएं कोने में है, उसके सामने कोई स्थान नहीं होना चाहिए)। प्रत्येक पंक्ति में Nअनुगामी स्थान हो सकते हैं (आवश्यक रूप से लगातार नहीं, इसलिए आप उदाहरण के लिए एक आयताकार आउटपुट हो सकते हैं, षट्भुज के बाउंडिंग बॉक्स को प्रिंट कर सकते हैं)।

यह कोड गोल्फ है, इसलिए सबसे छोटा सबमिशन (बाइट्स में) जीतता है। और निश्चित रूप से, प्रति उपयोगकर्ता सबसे कम सबमिशन भी श्रृंखला के समग्र लीडरबोर्ड में प्रवेश करेगा।

लीडरबोर्ड

प्रत्येक श्रृंखला की पहली पोस्ट एक लीडरबोर्ड उत्पन्न करती है।

यह सुनिश्चित करने के लिए कि आपके उत्तर दिखाए गए हैं, कृपया प्रत्येक मार्कलाइन के साथ निम्नलिखित मार्कडाउन टेम्प्लेट का उपयोग करके प्रत्येक उत्तर को शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

(भाषा को वर्तमान में नहीं दिखाया गया है, लेकिन स्निपेट की आवश्यकता होती है और इसे पार्स किया जाता है, और मैं भविष्य में एक उप-भाषा लीडरबोर्ड जोड़ सकता हूं।)

code-golf  ascii-art  combinatorics  random  tiling 
— मार्टिन एंडर
स्रोत
3
क्या यह सिर्फ मुझे है जो 3 डी में उदाहरण छवि को देखता रहता है?
— 22
3
@ LegionMammal978 नहीं, यह पूरी तरह से सामान्य है। ;) (और शायद चुनौती का सामना करने का एक अच्छा तरीका है।)
— मार्टिन एंडर
For N ≤ 4, your submission must produce a tiling within 1 minute at least 80% of the time.बहुत आसान: एक ही समय का 80%, मूल टाइलिंग, अन्यथा मुझे जो भी समय में एक और टाइलिंग मिलती है वह मुझे चाहिए
— edc65
@ edc65 अच्छी बात है, मुझे लगता है कि rephrase।
— मार्टिन एंडर

जवाबों:

10

CJam, 105 बाइट्स

ri:A" __"e*A,2f*:B,[W1]{J+B:):B,{N1$S*"\/"J%A2*4$-:D*
0{;B{_1&!2mr+J*m1e>D(2*e<}%__:)&}g:B{'_t}/+@J+}*}fJ;

स्क्रॉलिंग से बचने के लिए न्यूलाइन जोड़ा गया। इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

यह समाधान प्रत्येक पंक्ति को एक ज़िगज़ैग के रूप में शुरू करता है, फिर उस पर N अंडरस्कोर लगाता है, जो पिछली पंक्ति और उनकी एक जोड़ी नियमों के आधार पर होता है। मुझे वर्णों के सादे 2 डी मैट्रिक्स के रूप में आउटपुट को देखते हुए टिप्पणियों की एक श्रृंखला से यह मिला:

  • प्रत्येक पंक्ति में बिल्कुल N अंडरस्कोर है
  • अंडरस्कोर को पूरी तरह से दोहराए जाने वाले ज़िगज़ैग पैटर्न बनाने के लिए / या \ के साथ प्रतिस्थापित किया जा सकता है ( /\शीर्ष आधा \/में, नीचे आधे में)
  • अंडरस्कोर पक्षों को छू नहीं सकता है, और किसी अन्य अंडरस्कोर से सटे नहीं हो सकता है
  • अगली पंक्ति में जाने पर, प्रत्येक अंडरस्कोर की स्थिति -1, 0 या 1 से बदल जाती है
  • इससे अधिक, /_/केवल -1 या 0 से \_\बदल सकता है , और केवल 0 या 1 से बदल सकता है
  • प्रारंभिक अंडरस्कोर पदों के लिए हम या तो एक "_ "पैटर्न या एक " _"पैटर्न का उपयोग कर सकते हैं , दोनों ठीक हैं
  • उपरोक्त नियम सभी झुकाव प्राप्त करने के लिए पर्याप्त हैं

इसलिए मैंने पिछले अंडरस्कोर पदों को ध्यान में रखते हुए इसे लागू करने का फैसला किया, उन्हें एक यादृच्छिक कारक (प्रत्येक अंडरस्कोर के लिए 2 विकल्प) के साथ संशोधित किया और नियमों को संतुष्ट होने तक दोहराता रहा। अनुकूलन की प्रक्रिया में, मैं हेक्सागोन के बाईं ओर (रिक्त स्थान शामिल नहीं) के सापेक्ष अंडरस्कोर पदों पर स्विच करता हूं।

ri:A" __"e*       read the input (A) and generate the top line
A,2f*:B           make an array [0 2 4 ... 2A-2] and store in B
                  these are the initial positions for the underscores
,                 B's length = A, used as the initial number of leading spaces
                  let's call it C
[W1]{…}fJ         for J in [-1 1] (top half, bottom half)
  J+              add J to C
  B:):B           increment the underscore positions (adjustment before each half)
  ,{…}*           repeat A times
    N1$S*         add a newline and C spaces
    "\/"J%        take "\/" and reverse it if J=-1 (zigzag pattern)
    A2*4$-:D*     calculate D=A*2-C and repeat the pattern
    0             dummy value (for the next loop)
    {…}g          do-while
      ;B          pop last value and push B
      {…}%        apply block to each item (say x)
        _1&!      duplicate x and calculate !(x&1) (for /_/ vs \_\)
        2mr+      randomly add 0 or 1
        J*m       multiply by J and subtract from x
        1e>       limit the minimum value to 1
        D(2*e<    and the maximum value to 2*(D-1)
      __:)&       check if the modified array has any adjacent values
    :B            store the new positions in B
    {'_t}/        place underscores over the zigzag pattern
    +@J+          bring C to the top and add J to it
;                 pop C

पुराना "3 डी" संस्करण, 189 बाइट्स:

ri:A" __"e*aA4*S*aA2**+[0-2XXW1]:C;"/\_\\\/_/":D;A3m*{{C2/.f*:.+~
A(2*+:V;A+:U;2{UI+1$1$=4{_V+D4/I=@=t}/t}fI}:F~}/[0Y1WWW]:C;
"/_/\\\_\/":D;AaA*:B;A{A[_{_BI=e<)mr}fI]:B;{BQ={[PQR]F}fR}fQ}fPN*

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

— aditsu
स्रोत
+1 भयानक काम के लिए और इसलिए भी कि एक और वोट आपको 10k प्रतिनिधि में डाल देगा, लेकिन ज्यादातर भयानक काम के लिए। (ओह हे, वह देखो। 10k :) पर बधाई।)
— एलेक्स ए।
पैटर्न पर एक महान विश्लेषण! मैं इसका उपयोग अपने उत्तर के लिए करूँगा।
— अनातोली
6

पायथन 2, 337 335 324 318 311 300 296 बाइट्स

from random import*
n=input()
R=range(n*2)
b=[]
l=[]
for i in R:o=abs(i-n)-(i<n);b+=[o];l+=[list(' '*o+'\//\\'[i<n::2]*(n*2-o))]
for i in R[:n]:
 o=1;p=n+i*2
 for j in R:r=randint(0,p<n*3+i*2-j);p+=(r or-1)*(o==r);q=p<=b[j];o=r|q;p+=q;l[j][p]='_';b[j]=p+1
for s in[' '*n+'__'*n]+l:print''.join(s)

इस तरह हीरे की एक षट्भुज बनाने के लिए सबसे पहले विचार है:

  ____
 /\/\/\
/\/\/\/\
\/\/\/\/
 \/\/\/

और फिर इसे अंडरस्कोर के निचले रास्तों से भरें, जैसे:

  ____                          ____
 /_/\/\                        /\_\/\
/_/\/\/\    or maybe this:    /\/_/\/\
\_\/\/\/                      \/_/\/\/
 \_\/\/                        \_\/\/

जोड़े गए सभी रास्तों के साथ अंतिम परिणाम तब कुछ इस तरह दिखाई देगा:

  ____                          ____  
 /_/\_\                        /\_\_\ 
/_/\/_/\    or maybe this:    /\/_/\_\
\_\/_/\/                      \/_/\/_/
 \_\_\/                        \_\/_/

काफी कोड यह सुनिश्चित करने में जाता है कि ये रास्ते सीमा से बाहर न जाएं या प्रत्येक को पार न करें।

अनगोल्ड कोड:

# Initialize l with all diamonds
blocked = []
l = [[] for _ in range(n*2)]
for i in range(n*2):
    offset = n-i-1 if i<n else i-n
    blocked.append(offset)
    l[i] += ' '*offset + ('/\\' if i<n else '\/')*(2*n - offset)

# Generate the random _'s
for i in range(n):
    oldright = True
    pos = n + i*2
    for j in range(n*2):
        # Go randomly right (true) or left (false), except when you out of bounds on the right side
        right = randint(0, 1) and pos < n*3 + i*2 - j
        if right == oldright:
            pos += 1 if right else -1
        if pos <= blocked[j]:
            right = True
            pos += 1
        l[j][pos] = '_'
        blocked[j] = pos + 1
        oldright = right

# Print the result
print ' '*n + '__'*n
for s in l:
    print ''.join(s)
— मैटी
स्रोत
1
मैंने अभी देखा कि आपका आउटपुट गलत है। आपको अपने दो एक्सापल परिणामों (ऊपर दाएं और नीचे दाएं) में त्रिकोण मिले हैं।
— मार्टिन एंडर
1
@MartinEnder एल्गोरिदम के विचार को दर्शाने के लिए उदाहरणों में केवल एक 'अंडरस्कोर' का रास्ता दिखाया गया था। अंतिम आउटपुट में सभी पथ हैं (इस मामले में 2), जो त्रिकोण को समाप्त करता है। मैंने अंतिम आउटपुट के उदाहरणों में भी जोड़ा।
— मैटी
ओह्ह मैं देख रहा हूँ, यह समझ में आता है। स्पष्टीकरण के लिए धन्यवाद।
— मार्टिन एंडर
2
मुझे लगता है कि आप छोटा कर सकते हैं randint(0,1)*(p<n*3+i*2-j)करने के लिए randint(0,p<n*3+i*2-j)।
— 12M2121
ऊँ हाँ, धन्यवाद!
— मैटी
4

पर्ल, 174 168 166 161

#!perl -n
for$l(-$_..$_){$t=/_/?join'',map'/_'x($%=rand
1+(@z=/__?/g)).'/\\'.'_\\'x(@z-$%),split/\/\\/:__
x$_;$l>0&&$t!~s!^.(\\.*/).$!$1!?redo:print$"x abs$l-.5,$_=$t.$/}

मुझे आजमाओ ।

— nutki
स्रोत
यह हमेशा एक ही टाइलिंग उत्पन्न करता है (कम से कम ideone पर)
— aditsu
यदि आप लिंक पर क्लिक करते हैं तो @aditsu, Ideone एक कैश्ड परिणाम दिखाता है। आपको वास्तव में इसे फिर से चलाने के लिए कांटा चाहिए।
— नटकी
2

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

बस वहाँ होने के लिए ...

यह सभी झुकावों का निर्माण करता है, फिर एक यादृच्छिक चुनें। मेरे लैपटॉप पर N = 4 के लिए 232848 झुकाव का समय ~ 45 सेकंड है। मैंने N = 5 की कोशिश नहीं की।

EcmaScript 6 होने के नाते यह फ़ायरफ़ॉक्स पर ही चलता है।

F=n=>{
  for(i=s=r=b='';i<n;i++)
    s='\n'+b+'/\\'[R='repeat'](n-i)+'_\\'[R](n)+s,
    r+='\n'+b+'\\/'[R](n-i)+'_/'[R](n),
    b+=' ';
  for(h=[t=0],x=[s+r];s=x[t];t++)
    for(d='';!d[n*3];d+='.')
      if(l=s.match(r=RegExp("(\n"+d+"/)\\\\_(.*\n"+d+"\\\\)/_","g")))
        for(j=2<<l.length;j-=2;h[z]||(h[z]=x.push(z)))
          z=s.replace(r,(r,g,h)=>(k+=k)&j?g+'_/'+h+'_\\':r,k=1);
  return b+'__'[R](n)+x[Math.random()*t|0]
}


function go()
{
  var n = N.value | 0,
  t0 = performance.now(),
  r = F(n),
  t1 = performance.now();
  
  O.innerHTML = r+'\n\nTime (msec): '+(t1-t0)
}
N: <input id=N value=3><button onclick="go()">GO</button>
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
क्रोमियम 42 में मुझे "
— बिना पढ़ा हुआ वाक्य रचना
1
@aditsu यह ES6 है, क्रोम: फ़ायरफ़ॉक्स: हाँ। क्या यह एक प्रसिद्ध तथ्य नहीं है?
— edc65
मेरे पास कोई विचार नहीं था, मुझे उम्मीद थी कि क्रोमियम नवीनतम और सबसे बड़ी चीज का उपयोग करेगा, जो कि इसके-जाहिरा तौर पर-नहीं-जावास्क्रिप्ट। समझाने के लिए धन्यवाद।
— aditsu
मैंने इसे अब फ़ायरफ़ॉक्स (31.5.3) में चलाया और यह N = 1, 2 या 3 के लिए काम करता है, लेकिन N = 4 के लिए यह लगभग 10 सेकंड तक चलता है, खत्म होता है और कुछ भी नहीं दिखाता है (और कंसोल में कोई त्रुटि नहीं है )
— aditsu
@aditsu सुनिश्चित नहीं है ... शायद सैंडबॉक्स में जावास्क्रिप्ट चुपचाप समय सीमा से अधिक होने पर मार दिया जाता है dom.max_script_run_time। इसके बारे में एक वैश्विक प्राथमिकता है: विन्यास, मेरा 30 पर सेट है।
— edc65
1

स्माइलबेसिक, 241 बाइट्स

INPUT N
T=N*2CLS?" "*N;"__"*N
DIM B[T]FOR I=-1TO N-1O=1P=N+I*2FOR J=0TO T-1IF I<0THEN O=ABS(J0N+.5)<<0B[J]=O?" "*O;MID$("\/\",J<N,2)*(T-O)ELSE R=P<N*3+I*2-J&&RND(2)P=P+(R*2-1)*(O==R)A=P<=B[J]R=R||A:P=P+A:LOCATE P,J+1?"_"B[J]=P+1O=R
NEXT
NEXT

माटी के जवाब के आधार पर भारी

— 12Me21
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.