Bir abelya kumu , bizim amaçlarımız için, başlangıçta kumdan boş tam sayı koordinatlarına sahip sonsuz bir ızgaradır. Her saniyeden sonra, (0,0) 'a bir kum tanesi yerleştirilir. Bir ızgara hücresi 4 veya daha fazla kum taneciğine sahip olduğunda, dört komşusunun her birine aynı anda bir kum taneciği döker. (X, y) 'nin komşuları (x-1, y), (x + 1, y), (x, y-1) ve (x, y + 1)' dir.

Bir hücre döküldüğünde, komşularının dökülmesine neden olabilir. Bazı gerçekler:

• Bu çağlayan sonunda duracak.
• Hücrelerin dökülme sırası önemsizdir; sonuç aynı olacaktır.

Örnek

3 saniye sonra ızgara

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

4 saniye sonra:

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

15 saniye sonra:

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

Ve 16 saniye sonra:

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

Meydan okuma

Mümkün olduğu kadar az baytta, tek bir pozitif tamsayı t alan ve t saniyenin ardından kum parçasının resmini çıkaran bir fonksiyon yazın .

Giriş

Tek bir pozitif tamsayı t , istediğiniz formatta.

Çıktı

Sandviçin t saniye sonra karakterlerini kullanarak çekilmiş resmi

 . 1 2 3

Düzenleme: İstediğiniz dört karakterden birini kullanın veya resim çizin. ".123" veya "0123" kullanmıyorsanız, cevabınızdaki karakterlerin ne anlama geldiğini belirtin.

Örneklerden farklı olarak, çıktınız, sandpile'ın sıfır olmayan bölümünü göstermek için gereken en az satır ve sütunu içermelidir.

Yani giriş 3 için çıkış

 3

4 için, çıktı olmalıdır

 .1.
 1.1
 .1.

puanlama

Standart golf puanlaması uygulanır.

kurallar

Sandpile'a izin verildiğini zaten bilen hiçbir dil işlevi veya kitaplığı yoktur.

Düzenleme: Çıkış bölümü düzenlendi, karakter kümesi kısıtlaması tamamen kaldırıldı. Beğendiğiniz dört farklı karakter veya rengi kullanın.

R, 378 343 297 291 bayt

Genellikle, kullanıcı girişini şu şekilde sağlar scan()(Ben zaten değişkeni kullandım t, o yüzden almamıza izin verin z), böylece ikinci satır ayrı olarak başlatılmalı ve sonra gerisi:

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

Değerlerini içeren bir dizi çıkışını aen tinci nesil (0, 1, 2 ya da 3).

Test durumları:

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

Bu şeyin hem dikey hem de yatay olarak simetrik olmasına yardımcı oluyor, yani en soldaki nokta 4, yani en üst, en sağ ve en düşük nokta 4.

Oh, ve güzel görselleştirmeler yapabileceğinizi söyledim mi?

1000 damladan sonra:

50000 damladan sonra (seconds4 saniye):

333333 damladan sonra (-15 dakika):

Sen de çizebilirsin!

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

Bu işlem 10000 yineleme için 4 saniye sürdü, ancak daha büyük dizi boyutları için (örneğin 100000 yineleme için birkaç dakika) önemli ölçüde yavaşladı. Bu yüzden çok yavaşlıyor (büyüme oranını olduğu gibi tahmin ettim ve τ (i) obtained689 · i ^ 1.08 olarak hesapladım, bu yüzden tüm zımparalama işleminin bir iadımdan sonra yerleşene kadar bir tane başına tane başına ortalama süre ) , ve tahıl sayısının bir fonksiyonu olarak toplam süre kuadratik olarak biraz daha yavaş büyür (T (i) ≈0.028 * i ^ 1.74):

Ve şimdi tam bir açıklama ile:

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

Bu, hayatımda ilk kez büyüyen nesnelerin (gibi a <- c(a, 1)), değerler için büyük bir boş matris ayırmadan ve onu yavaş yavaş kullanılmayan bir ton sıfır ile doldurmaktan çok daha hızlı çalıştığı zamandır.

Güncelleme. Çıkararak 18 bayt golfed arr.indolarak whichbağlı Billywob ve değiştirilmesi rep(0,n)ile e=numeric;e(n)bağlı 5 durumlarda JDL ve sayesinde 17 daha bayt JDL .

2. Güncelleme Sandviç Abelian olduğu için istenen yükseklikte bir yığınla başlayabilir, bu yüzden fazlalık döngüyü çıkardım ve üretkenlikte büyük bir artış elde ettim!

MATL , 55 53 48 43 42 bayt

@ Flawr'ın cevabından ilham almıştır .

Grafiksel çıktı :

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

MATL Online'da deneyin! . Giriş için yaklaşık 10 saniye sürer 30. Sayfayı yenilemeniz ve çalışmazsa tekrar "Çalıştır" düğmesine basmanız gerekebilir.

İşte girdi için örnek bir sonuç 100:

ASCII çıkışı (43 bayt) :

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

Çevrimiçi deneyin!

açıklama

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

Matlab, 160 156 148 bayt

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,'']

İlk nönce ortada bir yerlerde , çok büyük bir matris yaratıldı . Ardından, kademelendirme çok uygun bir 2d evrişim ile hesaplanır. Sonunda fazlalıklar kesilir ve her şey bir dizeye dönüştürülür.

İçin örnek çıktı t=100

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

Her zamanki gibi:

Evrişim başarının anahtarıdır.

Python 2, 195 1 24 = 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 için çıktı

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"yeterince iyi" bir üst sınır olarak kullanıldığında LOT gereksiz bir dolum ve yineleme vardır, ancak n = 200, bir saniyede hala tamamlanır ve n = 500, yaklaşık 12 saniyede

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

değiştirilmesi return xyoluyla imshow(x)ekleyerek, bir karakter ekler ve çirkin interpolated resmi çıktılar imshow(x,'gray',None,1,'nearest')bulanık interpolasyon özellikleri kadar çıktı getiren kaldırır

Perl, 157 147 bayt

İçin +1 içerir -p

STDIN'deki sayımla çalıştırın, haritayı 0123STDOUT'a kullanarak yazdırır :

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$_}{

Python 3 2, 418 385 362 342 330 bayt

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))

Düzenleme: @ Qwerp-Derp sayesinde 6 bayt kaydedildi

@ Andreï Kostyrka'ya verilen tüm kredi, çünkü bu onun R kodunun Python'a doğrudan çevrilmesidir.

JavaScript, 418 416 406 400 393 bayt

Konsoldaki çıktıyı gösteren adsız bir işlev oluşturur.

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)">

Nim, 294 karakter

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]

Derle ve Çalıştır:

nim c -r sandbox.nim 1000

Notlar:

1. Sabit bir masa boyutu kullanan daha kısa bir sürüm bulabildim, ancak bunu dinamik olanın lehine düzenledim.
2. Sanal alan hesaplandıktan sonra, xorta satırın başındaki sıfır sütun sayısı olarak hesaplanır.
3. Görüntü için, tablo xher bir uçtan satır ve sütunlar hariç tutularak dilimlenir .

Verim

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

Scala, 274 bayt

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)
}

Kullanımı:

scala sandpile.scala <iterations>

Bunun hakkında açıklayacak çok şey olduğunu sanmıyorum. Temel olarak, merkeze yalnızca bir tane kum taneciği ekler. Sonra 4'ten büyük olup olmadığını kontrol eder, öyleyse dökülür ve 4'ten büyük tüm komşuları kontrol eder, dökülür, vb. Oldukça hızlıdır.

Verim:

• t = 10000 72ms
• t = 20000 167ms
• t = 30000 419ms
• t = 40000 659ms
• t = 100000 3413ms
• t = 1000000 yaklaşık 6 dakika

J, 76 bayt

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

pGirişin etrafında bir sıfır kenarlığını dolduran bir fiil tanımlarım . Ana fiil bir dizi giriş olarak alır. Daha sonra ilk sırayı 4 veya daha fazla tahıl içeren herhangi bir kum için kontrol eder. Biri varsa, yastıklı kullanımı dışında aynı diziyi çıkarır p, aksi takdirde düşen taneleri simüle etmek için 2d evrişim gerçekleştirir. Ana fiil güç operatörünü kullanarak yakınsamaya kadar tekrarlanır ^:_.

kullanım

   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 için sonucu hesaplamak yaklaşık 46 saniye sürer ve sonuç, viewmatmonokrom renk şeması ile addon kullanılarak görüntülenebilir .

C 229 (birçok uyarı ile)

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]));}

APL (Dyalog Unicode) , 51 bayt ^SBCS

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

Çevrimiçi deneyin!

PHP, 213 bayt

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++];

özyinelemeli $pbüyüklüğü hatırlayarak kümeyi oluşturur $m; daha sonra iç içe döngülerle yazdırır.
İle koş -r.