Maximum Square Side length with M 1×1 and N 2×2 tiles

Given M 1×1 and N 2×2 tiles, what’s the largest side length of a square that you can make if the square must be completely filled in the middle?

Examples:

Input: M = 5, N = 1
Output: 3
Explanation: As there are 5, 1*1 squares which can be placed around one 2*2 square to give a 3*3 square.

Input: M = 2, N = 3
Output: 3

Approach: To solve the problem follow the below steps:

• The maximum side of the square that can be built should be sqrt(4*N+M).
• If this value is even, then the whole square can be divided into a series of 2*2 squares, the length being the output.
• If it’s odd, then the maximum length in building the square of 2*2 would be sqrt(4*N + M) – 1.
• Let x = sqrt(4*N+M)-1, the maximum possible squares in this case are (x*x)/4.
• As the length can’t exceed N, the check would be 4*min((x*x/4), N)+M should be greater than or equal to the earlier length (as in step 1).
• If this condition holds, then the length as in step 1 would be the output, otherwise, the output would have 1 less than the length.

Below is the implementation for the above approach:

C++

// C++ code for the above approach:
#include <bits/stdc++.h>
using namespace std;

int findTiles(int M, int N)
{
    int x = sqrt(4 * N + M);
    if (x % 2 == 0)
        return x;
    else {
        int inter = ((x - 1) * (x - 1)) / 4;
        if (4 * min(inter, N) + M >= x * x)
            return x;
        else
            return x - 1;
    }
}

// Drivers code
int main()
{
    int M = 5;
    int N = 1;

    // Function Call
    cout << findTiles(M, N);
    return 0;
}

// This code is contributed by ragul21

Java

// Java code for the above approach:
class GFG {
    public static int findTiles(int M, int N)
    {
        int x = (int)Math.sqrt(4 * N + M);
        if (x % 2 == 0)
            return x;
        else {
            int inter = ((x - 1) * (x - 1)) / 4;
            if (4 * Math.min(inter, N) + M >= x * x)
                return x;
            else
                return x - 1;
        }
    }

    // Drivers code
    public static void main(String args[])
    {
        int M = 5;
        int N = 1;

        // Function Call
        System.out.println(findTiles(M, N));
    }
}

Python3

import math

def findTiles(M, N):
    x = int(math.sqrt(4 * N + M))
    if x % 2 == 0:
        return x
    else:
        inter = ((x - 1) * (x - 1)) // 4
        if 4 * min(inter, N) + M >= x * x:
            return x
        else:
            return x - 1

# Driver code
if __name__ == "__main__":
    M = 5
    N = 1

    # Function Call
    print(findTiles(M, N))

C#

using System;

class GFG
{
    public static int findTiles(int M, int N)
    {
          // The maximum side of the square that can be built should be sqrt(4*N+M)
        int x = (int)Math.Sqrt(4 * N + M);

          // If even number then return the x
        if (x % 2 == 0)
            return x;
        else
        {
            int inter = ((x - 1) * (x - 1)) / 4;

              // check  4*min((x*x/4), N)+M should be greater than or equal to x
              // if condition satisfies then return x
              if (4 * Math.Min(inter, N) + M >= x * x)
                return x;
              // Else return x-1
            else
                return x - 1;
        }
    }

      // Drivers code
    public static void Main(string[] args)
    {
        int M = 5;
        int N = 1;
        Console.WriteLine(findTiles(M, N));
    }
}

Javascript

function findTiles(M, N) {

    // The maximum side of the square
    // that can be built should be sqrt(4*N+M)
    let x = Math.sqrt(4 * N + M);

    // If even number then return the x
    if (x % 2 === 0) {
        return x;
    }
    else {
        let inter = ((x - 1) * (x - 1)) / 4;

        // check  4*min((x*x/4), N)+M should be greater than or equal to x
        // if condition satisfies then return x
        if (4 * Math.min(inter, N) + M >= x * x) {
            return x;
        }
        // Else return x-1
        else {
            return x - 1;
        }
    }
}

// Driver code
let M = 5;
let N = 1;

// Function Call
console.log(findTiles(M, N));

Output

3

Time complexity: O(1)
Auxiliary Space: O(1)