हमारे उद्देश्यों के लिए एक एबेलियन सैंडपिल , पूर्णांक निर्देशांक के साथ एक अनंत ग्रिड है, जो शुरू में रेत से खाली है। प्रत्येक सेकंड के बाद, रेत का एक दाना (0,0) रखा जाता है। जब भी ग्रिड सेल में रेत के 4 या अधिक दाने होते हैं, तो वह अपने प्रत्येक चार पड़ोसियों के पास रेत का एक दाना बिखेरता है। (X, y) के पड़ोसी हैं (x-1, y), (x + 1, y), (x, y-1), और (x, y + 1)।

जब एक सेल फैलता है, तो यह अपने पड़ोसियों को फैलाने का कारण हो सकता है। कुछ तथ्य:

यह झरना अंततः बंद हो जाएगा।
जिस क्रम में कोशिकाएं फैलती हैं वह अप्रासंगिक है; परिणाम वही होगा।

उदाहरण

3 सेकंड के बाद, ग्रिड जैसा दिखता है

.....
.....
..3..
.....
.....

4 सेकंड के बाद:

.....
..1..
.1.1.
..1..
.....

15 सेकंड के बाद:

.....
..3..
.333.
..3..
.....

और 16 सेकंड के बाद:

..1..
.212.
11.11
.212.
..1..

चुनौती

के रूप में कुछ बाइट्स में संभव के रूप में, एक समारोह है कि एक ही सकारात्मक पूर्णांक लेता लिखने टी और बाद sandpile की एक तस्वीर आउटपुट टी सेकंड।

इनपुट

आपके द्वारा चुने गए किसी भी प्रारूप में एक एकल सकारात्मक पूर्णांक टी ।

उत्पादन

टी सेकंड के बाद सैंडपाइल की एक तस्वीर , पात्रों का उपयोग करते हुए

 . 1 2 3

संपादित करें: आपके द्वारा पसंद किए गए किसी भी चार अलग-अलग वर्णों का उपयोग करें, या एक चित्र बनाएं। यदि आप ".123" या "0123" का उपयोग नहीं कर रहे हैं, तो अपने उत्तर में निर्दिष्ट करें कि वर्ण क्या दर्शाते हैं।

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

यही है, इनपुट 3 के लिए, आउटपुट होना चाहिए

4 के लिए, आउटपुट होना चाहिए

 .1.
 1.1
 .1.

स्कोरिंग

मानक गोल्फ स्कोरिंग लागू होता है।

नियम

कोई भाषा कार्य या पुस्तकालय जो पहले से ही जानते हैं कि एक सैंडपेपर की अनुमति क्या है।

संपादित करें: आउटपुट अनुभाग संपादित किया गया है, वर्ण सेट प्रतिबंध पूरी तरह से हटा दिया गया है। आपके द्वारा पसंद किए गए किसी भी चार अलग-अलग वर्णों या रंगों का उपयोग करें।

code-golf ascii-art cellular-automata

— एरिक ट्रेसलर
स्रोत

2

क्या इनपुट टी हो सकता है 0? फिर क्या है?

— लुइस मेंडो

1

क्या किसी दिए गए टाइमस्टेप के लिए यह सही है कि एक पंक्ति में कई कैस्केड हो सकते हैं? तो उस टाइमस्टैप में कैस्केड तब तक होते रहते हैं जब तक कि हर सेल 3 या उससे कम न हो जाए?

— दोष

2

@flawr: हाँ, यह सही होगा। टी = 15 और टी = 16 के बीच के अंतर को देखें।

— एल'एंडिया स्ट्रैटन

@LuisMendo इनपुट को सकारात्मक t के रूप में निर्दिष्ट किया गया है , इसलिए शून्य एक वैध इनपुट नहीं है।

— एरिक टेसलर

1

क्या यह सच है कि .खाली कोशिकाओं के लिए आवश्यक है ? क्या हमारे पास 0एक वैध खाली सेल हो सकता है?

— आंद्रे

56

आर, 378 343 297 291 बाइट्स

जैसा कि आमतौर पर, उपयोगकर्ता अपने इनपुट की आपूर्ति करता है scan()(मैं पहले से ही चर का उपयोग करता हूं t, इसलिए हमें zइसके बजाय लेने दें ), इसलिए दूसरी पंक्ति को अलग से लॉन्च किया जाना चाहिए, और फिर बाकी:

e=numeric
a=1%*%scan()
x=1
o=a>3
n=1
while(any(o)){
v=which(o,T)
if(any(v==1)){a=rbind(e(n+2),cbind(e(n),a,e(n)),e(n+2));x=x+1;n=n+2;v=which(a>3,T)}
q=nrow(v)
u=cbind(e(q),1)
l=v-u[,1:2];r=v+u[,1:2];t=v-u[,2:1];b=v+u[,2:1]
a[l]=a[l]+1;a[r]=a[r]+1;a[t]=a[t]+1;a[b]=a[b]+1
a[v]=a[v]-4
o=a>3}
a

एक सरणी के मान आउटपुट aपर tवीं पीढ़ी (0, 1, 2 या 3)।

परीक्षण के मामलों:

z=3
     [,1]
[1,]    3
z=4
     [,1] [,2] [,3]
[1,]    0    1    0
[2,]    1    0    1
[3,]    0    1    0
z=16
     [,1] [,2] [,3] [,4] [,5]
[1,]    0    0    1    0    0
[2,]    0    2    1    2    0
[3,]    1    1    0    1    1
[4,]    0    2    1    2    0
[5,]    0    0    1    0    0

यह हमें मदद करता है कि यह बात लंबवत और क्षैतिज रूप से सममित है, जिसका अर्थ है कि सबसे बाएं बिंदु को 4 की ऊंचाई मिलती है, इसका मतलब है कि सबसे ऊपर, सबसे दाहिने और सबसे निचले बिंदु भी 4 हैं।

ओह, और क्या मैंने कहा कि आप सुंदर दृश्य बना सकते हैं?

1000 बूंदों के बाद:

50000 बूँदें ()4 सेकंड) के बाद:

333333 बूंदों (minutes15 मिनट) के बाद:

आप इसे भी आकर्षित कर सकते हैं!

image(1:n,1:n,a,col=colorRampPalette(c("#FFFFFF","#000000"))(4), axes=F, xlab="", ylab="")

यह चीज़ 10000 पुनरावृत्तियों के लिए 4 सेकंड का समय लेती है, लेकिन बड़े सरणी आकार (जैसे 100000 पुनरावृत्तियों के लिए कुछ मिनट) के लिए धीमा हो जाती है। यही कारण है कि यह इतना धीमा हो जाता है (मैंने विकास दर का अनुमान लगाया है और τ (i) 89689 · i ^ 1.08 प्राप्त किया है, इसलिए प्रति अतिरिक्त अनाज तक औसत समय तब तक रहता है जब तक कि iवें कदम के बाद पूरा सैंडपाइल एक से थोड़ा बड़ा नहीं हो जाता) , और अनाज की संख्या के एक समारोह के रूप में कुल समय द्विघात (टी (i) )0.028 * i ^ 1.74) की तुलना में थोड़ा धीमा बढ़ता है:

और अब एक पूरी व्याख्या के साथ:

e=numeric # Convenient abbreviation for further repeated use
a=1%*%scan() # Creates a 1×1 array with a user-supplied number
x=1 # The coordinate of the centre
o=a>3 # Remember which cells were overflown
n=1 # Array height that is going to change over time
while(any(o)){ # If there is still any overflow
  v=which(o,T) # Get overflown cells' indices
  if(any(v==1)){ # If overflow occurred at the border, grow the array
    a=rbind(e(n+2),cbind(e(n),a,e(n)),e(n+2)) # Growing
    x=x+1 # Move the centre
    n=n+2 # Change the height
    v=which(a>3,T) # Re-index the overflowed cells
    }
  q=nrow(v) # See how many indices are overflown
  u=cbind(e(q),1) # Building block for neighbours' indices
  l=v-u[,1:2];r=v+u[,1:2];t=v-u[,2:1];b=v+u[,2:1] # L, R, T, B neighbours
  a[l]=a[l]+1;a[r]=a[r]+1;a[t]=a[t]+1;a[b]=a[b]+1 # Increment neighbours
  a[v]=a[v]-4 # Remove 4 grains from the overflown indices
  o=a>3} # See if still overflown indices remain
a # Output the matrix

मेरे जीवन में ऐसा पहली बार हुआ है जब बढ़ती वस्तुओं (जैसे a <- c(a, 1)) मूल्यों के लिए एक बड़ी खाली मैट्रिक्स को पूर्व-आवंटित करने और शून्य के अप्रयुक्त शून्य के साथ इसे धीरे-धीरे भरने की तुलना में बहुत तेजी से काम करती है।

अपडेट करें। को हटाने के द्वारा 18 बाइट्स golfed arr.indमें whichहोने की वजह से Billywob और जगह rep(0,n)के साथ e=numeric;e(n)5 के कारण मामलों में JDL , और 17 से अधिक बाइट्स के कारण JDL ।

अद्यतन 2. चूंकि सैंडपेल एबेलियन है, यह वांछित ऊंचाई के ढेर के साथ शुरू हो सकता है, इसलिए मैंने अनावश्यक लूप को हटा दिया और उत्पादकता में भारी वृद्धि प्राप्त की!

— आंद्रे कोस्टीर्का
स्रोत

1

मुझे अतिरिक्त कॉलम, पंक्ति सूचकांकों के बारे में अपनी बात मिलती है जो आप आउटपुट कर रहे हैं, लेकिन मुझे लगता है कि मैं आउटपुट को केवल "उत्तर" तक सीमित करना चाहता हूं, और इससे अधिक कुछ नहीं। मुझे खुशी है कि आपने चित्र शामिल किए, हालांकि।

— एरिक टेसलर

1

अच्छा जवाब आंद्रे! आप निश्चित रूप से कुछ बाइट्स गोल्फ कर सकते हैं, उदाहरण के लिए rep(), पूर्वनिर्धारित करने के लिए , यह देखते हुए कि आप इसे 6 बार उपयोग करते हैं। दूसरे, मुझे नहीं लगता कि आपको फ़ंक्शन के arr.ind=Tलिए विकल्प लिखने की आवश्यकता है which()। बस उपयोग करें which(...,T)।

— बिलीवॉब

1

यह परिभाषित करने n=numericऔर इसका उपयोग करने के लिए गोल्फर हो सकता है , क्योंकि इसके बजाय n(k)कम वर्ण हैं r(0,k)। हालांकि मुझे तस्वीरें पसंद हैं।

— JDL

1

एक और सुझाव: 1%*%0की तुलना में कम अक्षर है array(0,c(1,1))। इसके अलावा दूसरा तर्क u <- cbindसिर्फ 1 हो सकता है, cbindइसे डिफ़ॉल्ट रूप से पहले तर्क की लंबाई तक बढ़ा देगा।

— JDL

1

@GregMartin ने इसे ठीक किया। उसके लिए खेद है; मेरी पहली भाषा में, हम "आत्म" शब्द का उपयोग करते हैं और कभी भी प्रश्न में व्यक्ति के लिंग के बारे में परेशान नहीं होते हैं (जैसे "एक आदमी के लिए एक छोटा कदम"); फिर भी, कभी-कभी, बहुत ही दुर्लभ मौकों पर, मैं एक कुत्ते को "वह" या "वह" कहता हूं, जबकि यह "ऐसा" होना चाहिए, जब तक, जैसे, आप मालिक हैं और आप वास्तव में अपने गुदा के लिंग पर जोर देना चाहते हैं ( इस तथ्य के बावजूद कि एक महिला से पुरुष को बताना उतना कठिन नहीं है)।

— आंद्रे

13

MATL , 55 53 48 43 42 बाइट्स

@ त्रुटिपूर्ण उत्तर से प्रेरित ।

आलेखीय आउटपुट :

0i:"Gto~+XytP*+t"t4=t1Y6Z+b+w~*]]tat3$)1YG

MATL ऑनलाइन पर यह कोशिश करो! । इनपुट के लिए लगभग 10 सेकंड लगते हैं 30। यदि यह काम नहीं करता है तो आपको पृष्ठ को ताज़ा करने और "रन" को फिर से दबाने की आवश्यकता हो सकती है।

यहां इनपुट के लिए एक उदाहरण परिणाम दिया गया है 100:

ASCII आउटपुट (43 बाइट्स) :

0i:"Gto~+XytP*+t"t4=t1Y6Z+b+w~*]]tat3$)48+c

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

व्याख्या

0          % Push a 0. This is the initial array. Will be resized in first iteration
i:         % Take input n. Generate range [1 2 ... n]
"          % For each, i.e. repeat n times
  Gto~+    %   Push input and add negate parity. This "rounds up" n to odd number
           %   m = n or n+1
  Xy       %   Identity matrix with that size
  tP*      %   Multiply element-wise by vertically flipped copy. This produces a
           %   matrix with a 1 in the center and the rest entries equal to 0
  +        %   Add to previous array. This updates the sandpile array
  t        %   Duplicate
  "        %   For each column (i.e. repeat m times)
    t4=    %     Duplicate. Compare with 4 element-wise. This gives a 2D mask that
           %     contains 1 for entries of the sandpile array that equal 4, and 0
           %     for the rest
    t      %     Duplicate
    1Y6    %     Predefined literal: [0 1 0; 1 0 1; 0 1 0]
    Z+     %     2D convolution, maintaining size
    b      %     Bubble up to bring sandpile array to top
    +      %     Element-wise addition. This adds 1 to the neighbours of a 4
    w      %     Swap to bring copy of mask to top
    ~*     %     Multiply bu negated mask. This removes all previous 4
  ]        %  End
]          % End
t          % Duplicate the updated sandpile array
a          % 1D mask that contains 1 for columns that contain a 1. This will be
           % used as a logical index to select columns
t          % Duplicate. This will be used as logical index to select rows (this
           % can be done because of symmetry)
3$)        % Keep only those rows and columns. This trims the outer zeros in the
           % sandpile array
1YG        % Display as scaled image

— लुइस मेंडो
स्रोत

3

मुझे जलन हो रही है 1Y6।

— दोष

1

@flawr लेकिन आपका ~mod(spiral(3),2)बहुत अधिक चालाक है :-)

— लुइस

11

मतलाब, 160 156 148 बाइट्स

n=input('');z=zeros(3*n);z(n+1,n+1)=n;for k=1:n;x=z>3;z=z+conv2(+x,1-mod(spiral(3),2),'s');z(x)=z(x)-4;end;v=find(sum(z));z=z(v,v);[z+48-(z<1)*2,'']

पहले एक रास्ता बहुत बड़ा मैट्रिक्स बनाया जाता है, nकहीं बीच में। फिर कैस्केडिंग की गणना बहुत सुविधाजनक 2d दृढ़ संकल्प के साथ की जाती है। अंत में अतिरिक्त छंटनी की जाती है और पूरी चीज को एक स्ट्रिंग में बदल दिया जाता है।

उदाहरण के लिए आउटपुट t=100

...121...
..32.23..
.3.323.3.
123.3.321
2.23.32.2
123.3.321
.3.323.3.
..32.23..
...121...

हमेशा की तरह:

बातचीत सफलता की कुंजी है।

— flawr
स्रोत

v=any(z)इसके बजाय v=find(sum(z))(मैं अपने उत्तर में इसका उपयोग कर रहा हूं)। इसके अलावा, 2*~zके बजाय(z<1)*2

— लुइस Mendo

मेरा कंप्यूटर इनपुट पर जम गया है n=500... यह n=400कई सेकंड के लिए प्रसंस्करण किया गया था । क्या मुझसे कुछ ग़लत हो रहा है?

— आंद्रे

@ AndrekaKostyrka यह मेरे लिए काम करता है (Matlab R2015b)

— लुइस

1

@ Andre inputKostyrka nइस कार्यक्रम के एक इनपुट के लिए एक 3*n x 3*nमैट्रिक्स उत्पन्न करता है, इसलिए इसे 9*n^2संख्याओं के बारे में संग्रहीत करने की आवश्यकता है । इसके अलावा यह पूरी तरह से अक्षम है, क्योंकि हमारे पास 1 अप एन से पूरी तरह से अनावश्यक लंबा चलना है। लेकिन फिर यह कोड-गोल्फ है , एक कार्यक्रम को कुशल बनाना एक अलग कप चाय है।

— दोष

@ Andre @Kostyrka आप विरल मैट्रिस (दूसरी पंक्ति:) का उपयोग करके z=sparse(zeros(2*n+1))और लूप टू के लिए बदलकर इसे और अधिक मेमोरी कुशल बना सकते हैं while any(z(:)>3)। तो आप भी सिर्फ एक बार सजा कर्नेल गणना कर सकते हैं kern = 1-mod(spiral(3),2):।

— दोष

9

पायथन 2, 195 +1 +25 = 220 217

from pylab import*
ifrom scipy.signal import convolve2d as c
k=(arange(9)%2).reshape(3,3)
def f(n):g=zeros((n,n),int);g[n/2,n/2]=n;exec"g=c(g/4,k,'same')+g%4;"*n;return g[any(g,0)].T[any(g,0)]

n = 16 के लिए आउटपुट

array([[0, 0, 1, 0, 0],
       [0, 2, 1, 2, 0],
       [1, 1, 0, 1, 1],
       [0, 2, 1, 2, 0],
       [0, 0, 1, 0, 0]])

n"अच्छा-पर्याप्त" ऊपरी बाउंड के रूप में उपयोग करके अनावश्यक पैडिंग और पुनरावृत्तियों का एक बहुत कुछ है, लेकिन n = 200 अभी भी एक सेकंड में पूरा हुआ और n = 500 लगभग 12 सेकंड में

ungolfed

from pylab import*
from scipy.signal import convolve2d as c
k=array([0,1,0],
        [1,0,1],
        [0,1,0])
def f(n):
  g=zeros((n,n))                 # big grid of zeros, way bigger than necessary
  g[n/2,n/2]=n                   # put n grains in the middle
  exec"g=c(g/4,k,'same')+g%4;"*n # leave places with <4 grains as is, convolve the rest with the kernel k, repeat until convergence (and then some more)
  return g[any(g,0)].T[any(g,0)] # removes surrounding 0-rows and columns

की जगह return xसे imshow(x)एक चरित्र कहते हैं और एक बदसूरत अंतर्वेशित छवि आउटपुट बताया imshow(x,'gray',None,1,'nearest')धुँधली प्रक्षेप चश्मा अप करने के लिए उत्पादन में लाने को हटा

— DenDenDo
स्रोत

जब मैं अपने कोड को चलाने मैं निम्नलिखित त्रुटि मिलती है: ImportError: No module named convolve2d। मुद्दे import scipy.signal.convolve2d as cको from scipy.signal import convolve2d as cहल करने के लिए बदल रहा है । मैं 0.16.1 संस्करण का उपयोग कर रहा हूं, क्या मुझे पुराने या नए संस्करण की आवश्यकता है? या मुद्दा कुछ और है?

— एंड्रयू एपस्टीन

अजीब, अब जब कि आप उल्लेख करते हैं कि यह मेरे लिए भी काम नहीं करता है या तो। मैंने संभवत: पहली बार इंटरेक्टिव मोड में इसे ठीक किया, फिर इसे छोटा कर दिया और त्रुटि को नजरअंदाज कर दिया, लेकिन समारोह स्मृति में रहा

— डेनडेनडो

6

पर्ल, 157 147 बाइट्स

के लिए +1 शामिल है -p

STDIN पर गिनती के साथ चलाएँ, 0123STDOUT का उपयोग करके मैप को प्रिंट करता है :

sandpile.pl <<< 16

sandpile.pl:

#!/usr/bin/perl -p
map{++substr$_,y///c/2-1,1;/4
/?$.+=s%^|\z%0 x$..$/%eg+!s/\b/0/g:s^.^$&%4+grep{3<substr$\,0|$_+"@+",1}-$.-2,-2,0,$.^eg while/[4-7]/}($\="0
")x$_}{

— टन हास्पेल
स्रोत

5

पायथन 3 2, 418 385 362 342 330 बाइट्स

w='[(i,j)for i in r(n)for j in r(n)if a[i][j]>3]'
def f(z):
 a,x,r=[[z]],0,range
 for _ in[0]*z:
  n=len(a);v=eval(w)
  if[1for b,c in v if(b==0)+(c==0)]:n+=2;a=[[0]*n]+[[0]+a[i]+[0]for i in r(n-2)]+[[0]*n];x+=1;v=eval(w)
  for c,d in v:exec'a[c+%s][d+%s]+=1;'*4%(-1,0,1,0,0,-1,0,1);a[c][d]-=4
 for i in a:print''.join(map(str,i))

संपादित करें: @ Qwerp-Derp के लिए 6 बाइट्स सहेजे गए

सारा श्रेय @ Andreka Kostyrka को, क्योंकि यह पायथन में उनके आर कोड का सीधा अनुवाद है।

— एंड्रयू एपस्टीन
स्रोत

मुझे लगता है कि आप a,x,rफ़ंक्शन तर्क के असाइनमेंट को स्थानांतरित कर सकते हैं ।

— लवजो

1

मैंने आपके कोड को कुछ बाइट्स से नीचे कर दिया है ... यह बहुत नहीं है, लेकिन यह करना होगा। क्या आपको बुरा लगता है अगर मैं आपके उत्तर पर एक संपादन करता हूं और अगर मैं पायथन के संस्करण को पायथन 2 में बदल देता हूं?

— Qwerp-Derp

@ Qwerp-Derp: मुक्त महसूस करो! मुझे यह देखना अच्छा लगेगा कि आपने क्या किया है।

— एंड्रयू एपस्टीन

3

जावास्क्रिप्ट, 418 416 406 400 393 बाइट्स

एक अनाम फ़ंक्शन बनाता है जो कंसोल पर आउटपुट प्रदर्शित करता है।

var f =
    t=>{a=(q,w)=>Math.max(q,w);c=_=>{x=a(p[0],x);y=a(p[1],y);m[p]=(g(p)+1)%4;if(!m[p]){s.push([p[0],p[1]]);}};x=y=0,m={};g=k=>{v=m[k];return!v?0:v;};m[o=[0,0]]=1;s=[];while(--t){m[o]=(m[o]+1)%4;if(!m[o]){s.push(o);}while(s.length){p=s.pop();p[0]++;c();p[0]-=2;c();p[0]++;p[1]++;c();p[1]-=2;c();p[1]++;}}s='';for(i=-x;i<=x;i++){for(j=-y;j<=y;j++){v=g([i,j]);s+=v==0?'.':v;}s+='\n';}console.log(s);}

<input id="i" type="number"><input type="button" value="Run" onclick="var v = +document.getElementById('i').value; if (v>0) f(v)">

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

— hetzi
स्रोत

1

चेतावनी: मैंने इनपुट के बिना 'रन' दबाया, और मेरी स्क्रीन दुर्घटनाग्रस्त हो गई (अनंत लूप)। जैसा मैं था वैसा मूर्ख मत बनो।

— रोबर्रर्ट-एस

1

@Roberrrt मैंने इसे रोकने के लिए अपना उत्तर अपडेट किया।

— 13

3

निम, 294 वर्ण

import os,math,sequtils,strutils
var
 z=parseFloat paramStr 1
 y=z.sqrt.toInt+1
 w=y/%2
 b=y.newSeqWith newSeq[int] y
 x=0
proc d(r,c:int)=
 b[r][c]+=1;if b[r][c]>3:b[r][c]=0;d r-1,c;d r,c+1;d r+1,c;d r,c-1
for i in 1..z.toInt:d w,w
while b[w][x]<1:x+=1
for r in b[x..< ^x]:echo join r[x..< ^x]

संकलित करें और चलाएँ:

nim c -r sandbox.nim 1000

टिप्पणियाँ:

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

प्रदर्शन

nim c --stackTrace:off --lineTrace:off --threads:off \ 
      --checks:off --opt:speed sandbox.nim

time ./sandbox   10000       0.053s
time ./sandbox   20000       0.172s
time ./sandbox   30000       0.392s
time ./sandbox   40000       0.670s
time ./sandbox  100000       4.421s
time ./sandbox 1000000    6m59.047s

— डैनी किरचमीयर
स्रोत

3

स्काला, 274 बाइट्स

val t=args(0).toInt
val s=(Math.sqrt(t)+1).toInt
val (a,c)=(Array.ofDim[Int](s,s),s/2)
(1 to t).map{_=> ?(c,c)}
println(a.map{_.mkString}.mkString("\n"))
def?(b:Int,c:Int):Unit={
a(b)(c)+=1
if(a(b)(c)<4)return
a(b)(c)=0
?(b+1,c)
?(b-1,c)
?(b,c+1)
?(b,c-1)
}

उपयोग:

scala sandpile.scala <iterations>

मुझे नहीं लगता कि इस बारे में समझाने के लिए बहुत कुछ है। मूल रूप से यह सिर्फ रेत के एक दाने को केंद्र में जोड़ता है। फिर यह जांचता है कि क्या यह 4 से बड़ा है, यदि ऐसा है तो यह खत्म हो जाएगा और 4 से बड़े सभी पड़ोसियों के लिए जाँच करेगा, यह बहुत तेज़ है, आदि।

प्रदर्शन:

t = 10000 72ms
t = २०००० १६7 मी
t = 30000 419 मी
t = 40000 659 मी
t = 100000 3413 मी
t = 1000000 लगभग 6 मिनट

— AmazingDreams
स्रोत

मेरे कार्यक्रम से पता चलता है कि, (0,0) पर केंद्रित, सैंडपाइल पहली बार 15 के t = 1552 के त्रिज्या से टकराता है। इसे स्टोर करने के लिए 31x31 सरणी की आवश्यकता होगी (निर्देशांक -15 से 15 समावेशी)। क्या आप सुनिश्चित हैं कि यह t = 5000 के माध्यम से सही है?

— एरिक ट्रेसलर

मुझे यकीन नहीं है कि यह सही है, हालांकि मुझे लगता है कि मुझे तर्क सही मिला है? मुझे t> 5593

— अमेजनड्रीमर्स

जब मैं वृद्धि करता हूं और फिर तुरंत स्पिलेज की जांच करता हूं तो यह टी = 1552 पर सीमा से बाहर चला जाता है। मैं कहूंगा कि यह सही कार्यान्वयन है। मैंने कोड अपडेट किया।

— अमेजिंगड्रीम

संकलक अनुकूलन के साथ सी या फोरट्रान में प्रत्यक्ष सरणी हेरफेर द्वारा केवल आपके प्रदर्शन को पीटा जा सकता है। मुझे तुमसे ईर्ष्या है।

— आंद्रे

@ Andre @Kostyrka, हाँ, यह वह जगह है जहाँ शिला चमकती है! मेरा आउटपुट स्पेक्स के अनुरूप नहीं है, इसलिए मुझे उस पर काम करना होगा

— अमेज़िंगड्रॉप्स

2

जे, 76 बाइट्स

p=:0,.~0,.0,~0,]
p`(4&|+3 3([:+/@,*&(_3]\2|i.9));._3[:<.4%~p)@.([:*/4>{.)^:_

मैं एक क्रिया को परिभाषित करता हूं pजो इनपुट के चारों ओर शून्य की सीमा को पैड करता है। मुख्य क्रिया इनपुट के रूप में एक सरणी लेती है। यह किसी भी सैंडपाइल के लिए पहली पंक्ति की जांच करता है जिसमें 4 या अधिक अनाज होते हैं। यदि कोई करता है, तो यह उसी सरणी को गद्देदार का उपयोग करके छोड़कर pकरता है, और अन्यथा यह गिरने वाले अनाज को अनुकरण करने के लिए 2d दृढ़ संकल्प करता है। पावर ऑपरेटर का उपयोग करके अभिसरण तक मुख्य क्रिया को दोहराया जाता है ^:_।

प्रयोग

   p =: 0,.~0,.0,~0,]
   f =: p`(4&|+3 3([:+/@,*&(_3]\2|i.9));._3[:<.4%~p)@.([:*/4>{.)^:_
   f 15
0 3 0
3 3 3
0 3 0
   f 50
0 0 0 1 0 0 0
0 0 3 1 3 0 0
0 3 2 2 2 3 0
1 1 2 2 2 1 1
0 3 2 2 2 3 0
0 0 3 1 3 0 0
0 0 0 1 0 0 0
   timex 'r =: f 50000'
46.3472
   load 'viewmat'
   ((256#.3&#)"0<.255*4%~i._4) viewmat r

N = 50000 के लिए परिणाम की गणना करने में लगभग 46 सेकंड लगते हैं , और viewmatएक मोनोक्रोम रंग योजना के साथ एडऑन का उपयोग करके परिणाम प्रदर्शित किया जा सकता है ।

आकृति

— मील की दूरी पर
स्रोत

2

सी 229 (बहुत सारी चेतावनियों के साथ)

G[99][99],x,y,a=99,b=99,c,d;S(x,y){if(++G[y][x]>3)G[y][x]=0,S(x+1,y),S(x-1,y),S(x,y+1),S(x,y-1);a=x<a?x:a;b=y<b?y:b;c=x>c?x:c;d=y>d?y:d;}F(t){for(;t--;)S(49,49);for(y=b;y<=d;y++){for(x=a;x<=c;x++)printf("%d ",G[y][x]);puts("");}}

/* call it like this */
main(_,v)char**v;{F(atoi(v[1]));}

— जेरी यिर्मयाह
स्रोत

ठीक है, मैं हार जाता हूं: आपकी व्यूह 99 से 98 क्यों है?

— एरिक ट्रेसलर

@ EricTressler मुझे परीक्षण में यह कैसे नहीं मिला ?!

— जेरी यिर्मयाह

2

एपीएल (Dyalog यूनिकोड) , 51 बाइट्स ^SBCS

{m⌿r/⍨m←⌈/×r←(4∘|+{+/⊢/4 2⍴⌊⍵÷4}⌺3 3)0,∘⍉∘⌽⍣4⊢⍵}⍣≡⍪

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

— NGN
स्रोत

1

PHP, 213 बाइट्स

function d($x,$y){global$p,$m;$m=max($m,$x);$q=&$p[$y][$x];if(++$q>3){$q=0;d($x+1,$y);d($x-1,$y);d($x,$y+1);d($x,$y-1);}}while($argv[1]--)d(0,0);for($y=-$m-1;$y++<$m;print"\n")for($x=-$m;$x<=$m;)echo+$p[$y][$x++];

पुनरावर्ती $pआकार में याद करते हुए ढेर को बनाता है $m; फिर नेस्टेड छोरों के साथ प्रिंट करता है।
के साथ भागो -r।

— टाइटस
स्रोत

एक सैंडपाइल का निर्माण करें

उदाहरण

चुनौती

इनपुट

उत्पादन

स्कोरिंग

नियम

आर, 378 343 297 291 बाइट्स

MATL , 55 53 48 43 42 बाइट्स

व्याख्या

मतलाब, 160 156 148 बाइट्स

पायथन 2, 195 +1 +25 = 220 217

पर्ल, 157 147 बाइट्स

पायथन 3 2, 418 385 362 342 330 बाइट्स

जावास्क्रिप्ट, 418 416 406 400 393 बाइट्स

निम, 294 वर्ण

प्रदर्शन

स्काला, 274 बाइट्स

जे, 76 बाइट्स

प्रयोग

सी 229 (बहुत सारी चेतावनियों के साथ)

एपीएल (Dyalog यूनिकोड) , 51 बाइट्स SBCS

PHP, 213 बाइट्स

एपीएल (Dyalog यूनिकोड) , 51 बाइट्स ^SBCS