아벨 sandpile는 , 우리의 목적을 위해, 모래의 처음에 빈 정수 좌표 무한 그리드입니다. 매초마다 모래 알갱이가 (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..

도전

가능한 한 적은 바이트로 단일 양의 정수 t 를 취하고 t 초 후에 sandpile의 그림을 출력하는 함수를 작성하십시오 .

입력

선택한 모든 형식 의 단일 양의 정수 t 입니다.

산출

문자를 사용하여 t 초 후 샌드 파일 사진

 . 1 2 3

편집 : 좋아하는 네 개의 다른 문자를 사용하거나 그림을 그립니다. ".123"또는 "0123"을 사용하지 않는 경우 답에서 문자가 의미하는 것을 지정하십시오.

예제와 달리, 출력에는 샌드 파일의 0이 아닌 부분을 표시하는 데 필요한 최소한의 행과 열이 포함되어야합니다.

즉, 입력 3의 경우 출력은

 3

4의 경우 출력은

 .1.
 1.1
 .1.

채점

표준 골프 득점이 적용됩니다.

규칙

샌드 파일이 무엇인지 이미 알고있는 언어 함수 나 라이브러리는 없습니다.

편집 : 출력 섹션이 편집되었으며 문자 세트 제한이 완전히 해제되었습니다. 원하는 네 가지 고유 한 문자 나 색상을 사용하십시오.

R, 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 방울 떨어 뜨린 후 (≈15 분) :

당신도 그것을 그릴 수 있습니다!

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

이 작업은 10000 회 반복에 4 초가 걸리지 만 더 큰 배열 크기 (예 : 100000 회 반복에 몇 분)에서는 상당히 느려집니다. 그렇기 때문에 성장 속도가 느리고 ( τ (i) ≈ 689 · i ^ 1.08을 얻었으므로 i단계 이후에 전체 모래 더미가 침전 될 때까지 1 개의 추가 곡물 당 평균 시간이 1 보다 약간 큽니다) 곡물 수의 함수로서의 총 시간은 2 차보다 조금 느리게 성장합니다 (T (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)큰 빈 행렬을 미리 할당하고 0을 사용하지 않는 점진적으로 채우는 것보다 객체를 키우는 것보다 훨씬 빨리 작동하는 것은 인생에서 처음 입니다.

최신 정보. 제거하여 18 바이트 Golfed arr.ind에서 which때문에 Billywob 및 교체 rep(0,n)와 e=numeric;e(n)때문에 5 개 인스턴스에 JDL 및 때문에 17 이상의 바이트 JDL .

업데이트 2. 샌드 파일은 Abelian이므로 원하는 높이의 스택으로 시작할 수 있으므로 중복 루프를 제거하고 생산성을 크게 향상 시켰습니다!

MATL , 55 53 48 43 42 바이트

@flawr의 답변에서 영감을 얻었습니다 .

그래픽 출력 :

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

MATL Online에서 사용해보십시오! . 입력하는 데 약 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

MATLAB, 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...

언제나처럼 :

컨볼 루션은 성공의 열쇠입니다.

파이썬 2, 195 +1 +24 = 220217

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은 1 초 안에 완료되고 n = 500은 약 12 ​​초 안에 완료됩니다

언 골프

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')가 출력됩니다. 추가 하면 흐릿한 보간이 제거되어 출력이 사양에 도달합니다.

펄, 157147 바이트

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

파이썬 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 바이트 저장

이것은 그의 R 코드를 파이썬으로 직접 변환하기 때문에 @ Andreï Kostyrka에 대한 모든 공로입니다.

자바 스크립트, 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)">

님, 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

노트:

1. 고정 테이블 크기를 사용하는 더 짧은 버전을 만들 수 있었지만 동적 버전을 선호하여 편집했습니다.
2. 샌드 박스가 계산되면 x중간 행의 시작 부분에서 0 열의 수로 계산됩니다.
3. 표시를 위해 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

스칼라, 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 = 20000 167ms
• t = 30000 419ms
• t = 40000 659ms
• t = 100000 3413ms
• t = 1000000 약 6 분

J, 76 바이트

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

p입력 주위에 0의 경계를 채우는 동사 를 정의합니다 . 주동 사는 배열을 입력으로받습니다. 그런 다음 첫 번째 행에서 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단색 색 구성표가있는 애드온을 사용하여 표시 될 수 있습니다 .

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

APL (Dyalog Unicode) , 51 바이트 ^SBCS

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

온라인으로 사용해보십시오!

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.