How to place the smaller rectangles inside larger rectangle using Java?

Question

I stumbled upon a problem which i would like to solve it using Java. User inputs Larger Rectangle dimension (i.e L_width and L_height) and smaller rectangle dimension (i.e S_width and S_height). I would like to place as many smaller rectangle inside the larger rectangle and show it graphically.

for example: When the Larger Rectangle size is 4 x 5 and smaller rectangle size is 2 x 2, then the maximum number of smaller rectangle that i would be able to place it inside the larger rectangle is 4. I would like to show them graphically.

As im new to java, i wanted to know how i can approach this problem from programmatic point of view and what concept i have to use to achieve the same.

---

Initial code for calculating the maximum number of rectangles. Can any1 help me to show this result graphically using java

// Code Starts
import java.awt.Graphics;
import java.util.Scanner; 

import javax.swing.JComponent;
import javax.swing.JFrame;

//Class to store the output of layout
class layout{
    private int Cnt_BW_CW=0; // BoardWidth and CardWidth are arranged together
    private int Cnt_BW_CH=0;
    private int option=0;    // Option 1: width-width Option 2: width-height

    public int getCnt_BW_CW (){
        return Cnt_BW_CW;
    }
    public int getCnt_BW_CH (){
        return Cnt_BW_CH;
    }
    public int getoption (){
        return option;
    }

    public void setCnt_BW_CW (int newValue){
        Cnt_BW_CW = newValue;
    }
    public void setCnt_BW_CH (int newValue){
        Cnt_BW_CH = newValue;
    }
    public void setoption (int newValue){
        option = newValue;
    }
}

// Stores the Dimension
class Dimension{
    private float w,h;
    Scanner input = new Scanner( System.in );

    public Dimension(){
        System.out.print( "Enter Width: " ); 
        w = input.nextInt(); 
        System.out.print( "Enter Height: " ); 
        h = input.nextInt(); 
    }
    public Dimension(float width, float height){
        w = width;
        h = height;
    }
    public float getWidth (){
        return w;
    }
    public float getHeight (){
        return h;
    }
    public void setWidth (float newWidth){
        w = newWidth;
    }
    public void setHeight (float newHeight){
        h = newHeight;
    }
}

class MyCanvas extends JComponent {
    private static final long serialVersionUID = 1L;

    public void paint(Graphics g) {
        g.drawRect (10, 10, 200, 200);  
      }
}

public class boundedRect {
  @SuppressWarnings("unused")

  public static void main(String[] a) {
    Dimension Board = new Dimension();
    Dimension Card = new Dimension();
    int Cnt =0;

    Cnt = NumOfRect(Board, Card);
    System.out.printf( "Number of Cards:%d",Cnt );

    JFrame window = new JFrame();
    window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    window.setBounds(30, 30, 300,300);
    window.getContentPane().add(new MyCanvas());
    window.setVisible(true);
  }

  public static int NumOfRect(Dimension b,Dimension c){
      float bw,bh,cw,ch;
      int bw_cw,bh_ch,bw_ch,bh_cw;
      int SameDimensionCnt,DiffDimensionCnt;
      int count;
      layout Result = new layout();

      bw =b.getWidth(); bh = b.getHeight();
      cw =c.getWidth(); ch = c.getHeight();

      if (bw < cw || bh < ch){
          System.out.println( "Board and Card Dimension mismatch" );
          System.exit(0);
      }

      bw_cw = (int)Math.floor(bw/cw);
      bh_ch = (int)Math.floor(bh/ch);
      SameDimensionCnt = bw_cw * bh_ch; 
      Result.setCnt_BW_CW(SameDimensionCnt);

      bw_ch = (int)Math.floor(bw/ch);
      bh_cw = (int)Math.floor(bh/cw);
      DiffDimensionCnt = bw_ch * bh_cw;
      Result.setCnt_BW_CH(DiffDimensionCnt);

      System.out.printf( "Matching BW x CW: %d\n",SameDimensionCnt );
      System.out.printf( "Matching BW x CH: %d\n",DiffDimensionCnt );

      if (SameDimensionCnt < DiffDimensionCnt ){
          count = DiffDimensionCnt;
          System.out.println( "Align Board Width and Card Height" );
          Result.setoption(2);
      }else {
          count = SameDimensionCnt;
          System.out.println( "Align Board Width and Card Width" );
          Result.setoption(1);
      }
      return count;
  }
}

Answer 1

So you want to tile a large rectangle with a number of smaller rectangles. First define a class to represent the small rectangles, and create a data structure (probably an ArrayList) to hold them. Use a nested for loop to walk over the area of the large rectangle in S_width/S_height steps, and create as many small rectangles as will fit. Add them to the ArrayList as they are created. Search for ArrayList on Google to find the Java docs if you need them.

Then you need to write the code to draw them on the screen. For that, look up the official Java Tutorial on Google and read the section on graphics.

Try writing the code first and if you have problems, post your code here (you can edit the question).