將陣列中的元素移動到空白位置

Question

我想在空白區域移動假元素（就像在Schelling的分離模型中一樣）。 這是陣列..（陣列中的元件被隨機放置）

'X*''O'' ''X''O*' 
'O''O'' '' ''X' 
'O'' ''X''X''O*' 
'X'' '' ''X''X' 
'X''X''O*''X''O*' 

在（0,0），（0,4），（2,4）（4,2）的元件， ，（4,4）是錯誤的，因爲它周圍沒有類似的元素（我旁邊有* *）更容易看到。 我想將這些錯誤元素移動到數組的空白位置''。它可以移動到陣列中的任何空白位置。

' ''O''X''X'' ' 
'O''O''O'' ''X' 
'O''O''X''X'' ' 
'X''O''O''X''X' 
'X''X'' ''X'' ' 

這是我的代碼。

//isArrGood is a method that checks if the element is false or true 
//arr is 2D array that is being passed in the method 

//store the false elements 
char[] falseEle = new char[arr.length * arr[0].length]; 
for(int i=0; i<arr.length; i++){ 
    for(int j=0; j<arr[i].length; j++){ 
     if(!isArrGood(arr,i,j)){ 
      falseEle[i] = arr[i][j]; 
     } 
     } 
    } 

//finds the blank space and replaces it with a false cell and finds a false cell and 
//replace it with a blank space 
for(int x=0; x<arr.length; x++){ 
    for(int y=0; y<arr[x].length; y++) { 
     if (arr[x][y] == ' ') { 
      arr[x][y] = falseEle[x]; 
     } 
     if(!isArrGood(arr,x,y){ 
     arr[x][y] = ' '; 
     } 
     } 
    } 

這就是我所得到的。
在方法中發送的當前數組（arr）是。此數組中的虛假元素在 （1,0），（2,2），（3,2）

' ' 'X' 'X' 'X' 'X' 
'O' ' ' 'X' 'X' ' ' 
' ' 'X' 'O' ' ' 'X' 
'O' 'O' 'X' ' ' 'O' 
'O' 'O' ' ' 'O' ' ' 

而這就是我得到

'' 'X' 'X' 'X' 'X' 
'O' 'O' 'X' 'X' 'O' 
'O' 'X' 'O' 'O' 'X' 
'O' 'O' 'X' 'X' 'O' 
'O' 'O' '' 'O' '' 

陣列上的非常頂級只是我想要做的一個例子。

Answer 1

你能發佈更多的代碼嗎，例如你的問題的最小，完整和可驗證的例子？

對於問題「分隔的謝林的模式」，你可以用我寫了學習的榜樣代碼：

import java.util.Random; 

public class ShellingSegregationModel 
{ 
    public static final int EMPTY = 0; 
    public static final int BLUE = 1; 
    public static final int RED = 2; 

    // number of elements for random 
    public static final int ELEMENTS = 3; 

    public static final double THRESHOLD = 0.15;   

    //size of the field 
    public int size; 

    int[][] field; 
    // temporary field for the iteration 
    int[][] temporary; 

    public int iteration; 

    public ShellingSegregationModel(int size) 
    {  
     Random random = new Random(); 
     this.size = size; 
     field  = new int[size][size]; 
     for (int y = 0; y < size; y++) 
     { 
      for (int x = 0; x < size; x++) 
      { 
       field[y][x] = random.nextInt(ELEMENTS); 
      } 
     } 
    } 

    public int getSize() 
    { 
     return size; 
    } 

    public void setField(int[][] field) 
    { 
     this.field = field; 
    } 

    public int[][] getField() 
    { 
     return field; 
    } 

    public void setTemporary(int[][] temporary) 
    { 
     this.temporary = temporary; 
    } 

    public int[][] getTemporary() 
    { 
     return temporary; 
    } 

    public int getIteration() 
    { 
     return iteration; 
    } 

    public void setIteration(int iteration) 
    { 
     this.iteration = iteration; 
    } 

    public double getThreshold() 
    { 
     return THRESHOLD; 
    } 

    //how many neighbors needed for threshold 
    public double getCalculatedThreshold() 
    { 
     return getThreshold()*8;//8 is the neighbors count total possible 
    } 

    public static String getSymbolFor(int x) 
    { 
     String s = ""; 
     switch (x) 
     {    
      case BLUE: 
       s = "x"; 
       break; 
      case RED : 
       s = "o"; 
       break; 
      case EMPTY: 
      default: 
       s = " ";     
     } 
     return s; 
    } 

    public boolean isEmpty(int x, int y) 
    { 
     return get(x,y) == EMPTY; 
    } 

    /** 
    * Prints field 
    */ 
    public void print(String message) 
    { 
     System.out.println(message); 
     for (int y = 0; y < getSize(); y++) 
     {   
      StringBuilder row = new StringBuilder(); 
      for (int x = 0; x < getSize(); x++) 
      {     
       row.append("'").append(getSymbolFor(get(x,y))).append("' "); 
      } 
      System.out.println(row.toString()); 
     } 
    } 

    public void printSameNeighorsCount(String message) 
    { 
     System.out.println(message); 
     for (int y = 0; y < getSize(); y++) 
     {   
      StringBuilder row = new StringBuilder(); 
      for (int x = 0; x < getSize(); x++) 
      {     
       row.append("'").append(sameNeighbors(x, y)).append("' "); 
      } 
      System.out.println(row.toString()); 
     } 
    } 

    public int get(int x, int y) 
    { 
     return getField()[y][x]; 
    } 

    private int add(boolean c) 
    { 
     return c ? 1 : 0; 
    } 

    public int sameNeighbors(int x, int y) 
    { 
     return isEmpty(x,y) ? 0 : 
        add(isSame(get(x,y),x ,y-1)) 
       + add(isSame(get(x,y),x-1,y-1)) 
       + add(isSame(get(x,y),x-1,y )) 
       + add(isSame(get(x,y),x-1,y+1)) 
       + add(isSame(get(x,y),x ,y+1)) 
       + add(isSame(get(x,y),x+1,y+1)) 
       + add(isSame(get(x,y),x+1,y )) 
       + add(isSame(get(x,y),x+1,y-1)); 
    }  

    private static void copyArray(int[][] src, int[][] dest) 
    {   
     for (int i = 0; i < src.length; i++) 
     { 
      dest[i] = new int[src[i].length]; 
      System.arraycopy(src[i], 0, dest[i], 0, src[i].length);    
     }     
    } 
    private void duplicateToTemporary() 
    { 
     setTemporary(new int[getField().length][]); 
     copyArray(getField(),getTemporary()); 
    } 

    // 
    private void assignFromTemporary() 
    { 
     setField(new int[getField().length][]); 
     copyArray(getTemporary(), getField()); 
    } 

    public void iterate(int iterations) 
    {   
     for (int i = 0; i < iterations; i++)   
     { 
      duplicateToTemporary(); 
      for (int y = 0; y < getSize(); y++) 
      { 
       for (int x = 0; x < getSize(); x++) 
       { 
        if (!isHappy(x,y)) 
        { 
         swap(x,y); 
        } 
       } 
      } 
      assignFromTemporary(); 
     } 
     setIteration(getIteration()+iterations); 
    } 

    //Swaps with empty random from temporary 
    public void swap(int i, int j) 
    { 
     Random random = new Random(); 
     boolean swapped = false; 
     //skip a random number of empty 
     int  skip  = random.nextInt(100); 
     while (!swapped) 
     { 
      for (int y = 0; !swapped && y < getSize(); y++) 
      { 
       for (int x = 0; !swapped && x < getSize(); x++) 
       { 
        if (getTemporary()[y][x] == EMPTY && 0 >= --skip) 
        {       
         getTemporary()[y][x] = getTemporary()[j][i]; 
         getTemporary()[j][i] = EMPTY ; 
         swapped = true; 
        } 
       } 
      } 
     } 
    } 

    public boolean isHappy(int x, int y) 
    { 
     return getCalculatedThreshold() < sameNeighbors(x, y);   
    } 

    public boolean isSame(int me, int x, int y) 
    { 
     return 
       //check bounds 
       x >= 0 && y >= 0 && x < getSize() && y < getSize() 
       //check element 
       && get(x,y) == me; 
    } 

    public static void main(String[] args) 
    { 
     ShellingSegregationModel ssm = new ShellingSegregationModel(10); 
     ssm.print("Randomly generated field");  
     ssm.printSameNeighorsCount("Same neighbors count"); 
     ssm.iterate(5); 
     ssm.print("Field after 5 iterations");  
     ssm.printSameNeighorsCount("Same neighbors count"); 
     ssm.iterate(5); 
     ssm.print("Field after 10 iterations");  
     ssm.printSameNeighorsCount("Same neighbors count"); 
     ssm.iterate(5); 
     ssm.print("Field after 15 iterations");  
     ssm.printSameNeighorsCount("Same neighbors count"); 
     ssm.iterate(50); 
     ssm.print("Field after 65 iterations");  
     ssm.printSameNeighorsCount("Same neighbors count"); 
    } 
}