有谁知道我在哪里可以找到SandPile（蜂窝自动机）的源代码？
提前谢谢！
答案 0 :(得分：3)
以下是Sand Pile细胞自动机Java Applet的来源： http://www.larssono.com/musings/sandpile/index.html
答案 1 :(得分：0)
@Service("sandpileAddition")
public class SandpileAddition
{
private static final Logger logger = LoggerFactory.getLogger( SandpileAddition.class );
/**
*
* @param n
* @param limitSupCase
* @param row1
* @param row2
*/
public int[][] sandPile( int n, int limitSupCase, String[] row1, String[] row2 )
{
logger.info( "sand Pile Addition" );
int[][] array = new int[n][n];
for( int i = 0; i < n; i++ )
{
String s = row1[i];
for( int j = 0; j < row1.length; j++ )
{
String z = s.substring( j, j + 1 );
array[i][j] = Integer.parseInt( z );
}
}
for( int i = 0; i < n; i++ )
{
String s = row2[i];
for( int j = 0; j < row2.length; j++ )
{
String z = s.substring( j, j + 1 );
array[i][j] += Integer.parseInt( z );
}
}
return formaterResultatSortie( distribuerGrainsSurCase( array, n, limitSupCase ), n );
}
private int[][] formaterResultatSortie( int[][] array, int n )
{
for( int i = 0; i < n; i++ )
{
for( int j = 0; j < n; j++ )
{
//System.out.print( array[i][j] );
}
//System.out.println();
}
return array;
}
private int[][] distribuerGrainsSurCase( int[][] array, int n, int limitSupCase )
{
CaseTrouvee caseTrouvee = null;
while( ( caseTrouvee = chercherCase( array, n, limitSupCase ) ) != null )
distribuerSurLesCases( array, n, caseTrouvee, limitSupCase );
return array;
}
private void distribuerSurLesCases( int[][] array, int n, CaseTrouvee caseTrouvee, int limitSupCase )
{
int i = caseTrouvee.i;
int j = caseTrouvee.j;
array[i][j] -= limitSupCase;
if( i - 1 >= 0 && i - 1 < n ) array[i - 1][j] += 1;
if( i + 1 < n ) array[i + 1][j] += 1;
if( j - 1 >= 0 && j - 1 < n ) array[i][j - 1] += 1;
if( j + 1 < n ) array[i][j + 1] += 1;
}
private CaseTrouvee chercherCase( int[][] array, int n, int limitSupCase )
{
for( int i = 0; i < n; i++ )
{
for( int j = 0; j < n; j++ )
{
if( array[i][j] >= limitSupCase ) return new CaseTrouvee( i, j );
}
}
return null;
}
class CaseTrouvee
{
public final int i;
public final int j;
public CaseTrouvee( int i, int j )
{
this.i = i;
this.j = j;
}
}
}
@ExtendWith(SpringExtension.class)
@SpringBootTest
@TestMethodOrder(OrderAnnotation.class)
public class SandpileAdditionTest
{
private static final Logger logger = LoggerFactory.getLogger( SandpileAdditionTest.class );
@Autowired
private SandpileAddition sandpileAddition;
private static final int limitSupCase = 4;
private String[] array1 = null;
private String[] array2 = null;
private int[][] expected = null;
private int matrixSize = 0;
/**
* initialized parameters before test
*
*
* @param testInfo : content parameters current test
*/
@BeforeEach
void initParams( TestInfo testInfo )
{
logger.info( "initParams" );
switch( testInfo.getTestMethod().get().getName() )
{
case "sandpileAddition07Test":
array1 = new String[] { "12123212", "21221323", "13231321", "30232213", "01123100", "32203321", "32303321", "32123321" };
array2 = new String[] { "30321311", "20231002", "12303321", "31231321", "12312323", "13123121", "13132121", "32303321" };
expected = new int[][] { { 2, 0, 1, 3, 3, 3, 1, 2 }, { 1, 3, 3, 3, 2, 1, 3, 0 }, { 3, 2, 3, 3, 1, 0, 2, 1 }, { 3, 3, 2, 1, 1, 3, 3, 3 }, { 0, 1, 2, 3, 2, 1, 2, 1 }, { 3, 2, 3, 1, 3, 2, 0, 3 }, { 1, 3, 1, 3, 2, 3, 3, 3 }, { 2, 1, 3, 2, 3, 1, 3, 3 } };
matrixSize = 8;
break;
case "sandpileAddition06Test":
array1 = new String[] { "31003", "13120", "01310", "02131", "30013" };
array2 = new String[] { "11111", "12221", "12321", "12221", "11111" };
expected = new int[][] { { 2, 2, 1, 1, 2 }, { 2, 3, 3, 2, 1 }, { 1, 3, 2, 3, 1 }, { 1, 2, 3, 3, 2 }, { 2, 1, 1, 2, 2 } };
matrixSize = 5;
break;
case "sandpileAddition05Test":
array1 = new String[] { "1212321", "1221323", "1231321", "3032213", "0123100", "3203321", "3203321" };
array2 = new String[] { "3032131", "0231002", "2303321", "1231321", "1232323", "1323121", "1332121" };
expected = new int[][] { { 1, 1, 1, 2, 2, 0, 1 }, { 3, 1, 3, 2, 2, 1, 3 }, { 3, 2, 3, 1, 2, 2, 3 }, { 0, 2, 3, 3, 2, 2, 0 }, { 2, 2, 1, 3, 3, 3, 2 }, { 3, 0, 3, 3, 3, 0, 3 }, { 3, 1, 2, 0, 2, 2, 3 } };
matrixSize = 7;
break;
case "sandpileAddition04Test":
array1 = new String[] { "121", "202", "121" };
array2 = new String[] { "020", "202", "020" };
expected = new int[][] { { 3, 1, 3 }, { 1, 0, 1 }, { 3, 1, 3 } };
matrixSize = 3;
break;
case "sandpileAddition03Test":
array1 = new String[] { "121321", "122323", "123121", "303213", "023100", "303321" };
array2 = new String[] { "303213", "023100", "303321", "121321", "122323", "123121" };
expected = new int[][] { { 0, 3, 2, 3, 3, 0 }, { 2, 1, 3, 1, 3, 2 }, { 1, 3, 3, 1, 3, 3 }, { 1, 3, 2, 2, 3, 0 }, { 2, 3, 0, 2, 3, 2 }, { 1, 0, 2, 3, 3, 2 } };
matrixSize = 6;
break;
case "sandpileAddition02Test":
array1 = new String[] { "000", "020", "000" };
array2 = new String[] { "000", "020", "000" };
expected = new int[][] { { 0, 1, 0 }, { 1, 0, 1 }, { 0, 1, 0 } };
matrixSize = 3;
break;
case "sandpileAddition01Test":
array1 = new String[] { "121", "232", "121" };
array2 = new String[] { "303", "000", "303" };
expected = new int[][] { { 2, 1, 2 }, { 1, 3, 1 }, { 2, 1, 2 } };
matrixSize = 3;
break;
case "sandpileAddition00Test":
array1 = new String[] { "121", "232", "121" };
array2 = new String[] { "303", "000", "303" };
expected = new int[][] { { 1, 1, 2 }, { 0, 3, 1 }, { 2, 0, 2 } };
matrixSize = 3;
break;
default:
break;
}
assertNotNull( sandpileAddition );
logger.info( " begin " + testInfo.getTestMethod().get().getName() );
}
/**
* destroyed parameters after test
*
* @param testInfo : content parameters current test
*/
@AfterEach
void destroy( TestInfo testInfo )
{
logger.info( "destroy" );
String callingTest = testInfo.getTestMethod().get().getName();
logger.info( " end " + callingTest );
array1 = null;
array2 = null;
expected = null;
matrixSize = 0;
}
@Test
public void sandpileAddition07Test() throws Exception
{
logger.info( "sandpileAddition07Test" );
assertEquals( true, compareMatrices( matrixSize, sandpileAddition.sandPile( matrixSize, limitSupCase, array1, array2 ), expected ) );
}
@Test
public void sandpileAddition06Test() throws Exception
{
logger.info( "sandpileAddition06Test" );
assertEquals( true, compareMatrices( matrixSize, sandpileAddition.sandPile( matrixSize, limitSupCase, array1, array2 ), expected ) );
}
@Test
public void sandpileAddition05Test() throws Exception
{
logger.info( "sandpileAddition05Test" );
assertEquals( true, compareMatrices( matrixSize, sandpileAddition.sandPile( matrixSize, limitSupCase, array1, array2 ), expected ) );
}
@Test
public void sandpileAddition04Test() throws Exception
{
logger.info( "sandpileAddition04Test" );
assertEquals( true, compareMatrices( matrixSize, sandpileAddition.sandPile( matrixSize, limitSupCase, array1, array2 ), expected ) );
}
@Test
public void sandpileAddition03Test() throws Exception
{
logger.info( "sandpileAddition03Test" );
assertEquals( true, compareMatrices( matrixSize, sandpileAddition.sandPile( matrixSize, limitSupCase, array1, array2 ), expected ) );
}
@Test
public void sandpileAddition02Test() throws Exception
{
logger.info( "sandpileAddition02Test" );
assertEquals( true, compareMatrices( matrixSize, sandpileAddition.sandPile( matrixSize, limitSupCase, array1, array2 ), expected ) );
}
@Test
public void sandpileAddition01Test() throws Exception
{
logger.info( "sandpileAddition01Test" );
assertEquals( true, compareMatrices( matrixSize, sandpileAddition.sandPile( matrixSize, limitSupCase, array1, array2 ), expected ) );
}
@Test
public void sandpileAddition00Test() throws Exception
{
logger.info( "sandpileAddition01Test" );
assertEquals( false, compareMatrices( matrixSize, sandpileAddition.sandPile( matrixSize, limitSupCase, array1, array2 ), expected ) );
}
/**
* compare two matrix contents
*
* @param n ; matrix dimension
* @param array : first matrix
* @param expected : second matrix
*
* @return return true if array is equals expected and false otherwise
*/
private boolean compareMatrices( int n, int[][] array, int[][] expected )
{
assertNotNull( array );
assertEquals( n, array.length );
assertEquals( n, array[0].length );
assertNotNull( expected );
assertEquals( n, expected.length );
assertEquals( n, expected[0].length );
for( int i = 0; i < n; i++ )
{
for( int j = 0; j < n; j++ )
{
if( array[i][j] != expected[i][j] )
{
return false;
}
}
}
return true;
}
}