Java 从一片L*B的面包中找出我能做多少片最大的正方形

所以我正在研究一个hackerRank挑战，其中输入是一片面包的L和B，输出应该是我能得到的完美方形切片的数量（没有剩余）

玛莎正在地铁面试。其中一轮面试要求她将l*b大小的面包切成相同的小块，每一块都是正方形，边长最大，没有剩余的面包

我觉得我的代码可以完成这项工作，但我总是会出错。因为我看不出它出了什么问题，所以我希望有人能帮我指出哪里出了问题

我的代码：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

public static void main(String[] args) {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
    Scanner STDIN = new Scanner(System.in);
    int l = 0;
    int b = 0;
    int count = STDIN.nextInt();

    for(int i = 0; i<count; i++){
        l = STDIN.nextInt();
        b = STDIN.nextInt(); 

        if(l>b){
            check(l,b);
        }
        else if(b>l){
            check(l,b);
        }
        else{
            check(l,b);
        }
        System.out.print("\n");
    }
}

public static boolean square (int n){
    int sqrt = (int) Math.sqrt(n);
    if(sqrt*sqrt == n){
        return true;    
    }
    else{
        return false;
    }
}
public static void check(int first, int second){
    int mult = first*second;

    if(square(first)){
    System.out.print(second);            
    }
    else if(square(second)){
    System.out.print(first);             
    }
    else{
    factors(mult);   
    }    
}
public static void factors(int n){
    //int B = 0;
    //int A = 0;

    for(int i = 1; i<=n; i++){
        if(n%i == 0){            

            if(square((n/i))){
                     System.out.print((i));
                     break;                    
            }
        }

    }
}
}

import java.io.*；
导入java.util.*；
导入java.text.*；
导入java.math.*；
导入java.util.regex.*；
公共类解决方案{
公共静态void main（字符串[]args）{
/*在此处输入代码。从STDIN读取输入。将输出打印到STDOUT。您的类应命名为Solution*/
扫描仪标准输入=新扫描仪（System.in）；
int l=0；
int b=0；
int count=STDIN.nextInt（）；
对于（int i=0；ib）{
支票（l，b）；
}
else如果（b>l）{
支票（l，b）；
}
否则{
支票（l，b）；
}
系统输出打印（“\n”）；
}
}
公共静态布尔平方（int n）{
intsqrt=（int）Math.sqrt（n）；
如果（sqrt*sqrt==n）{
返回true；
}
否则{
返回false；
}
}
公共静态无效检查（int-first，int-second）{
int mult=第一个*第二个；
if（正方形（第一个））{
系统输出打印（秒）；
}
else if（平方（秒））{
系统输出打印（第一）；
}
否则{
因子（mult）；
}    
}
公共静态空隙系数（int n）{
//int B=0；
//int A=0；
对于（int i=1；i求l和b的GCD。然后件数=（l/GCD）*（b/GCD）

对于（int j=1；j求l和b的GCD。然后件数=（l/GCD）*（b/GCD）

对于（int j=1；j，以下是解决上述问题的代码：

package subway;

import java.util.Scanner;

public class MarthaProblem {
    public static void main(String[] nag){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        for(int i=0;i<t;i++){
            if(t>=1 && t<=1000){
                int l = sc.nextInt();
                int b = sc.nextInt();
                if((l>=1 && l<=1000)&&(b>=1 && b<=1000)){
                    System.out.println(calculate(l,b));
                }
            }
        }
    }
    public static int calculate(int l, int b){
        return ((l/(gcd(l,b)))*(b/(gcd(l,b))));
    }

    public static int gcd(int l,int b){
        if(b==0){
            return l;
        }else{
            return gcd(b, l%b);
        }
    }
}

package地铁；
导入java.util.Scanner；
公共类马氏问题{
公共静态void main（字符串[]nag）{
扫描仪sc=新的扫描仪（System.in）；
int t=sc.nextInt（）；
对于（int i=0；i=1&&t=1&&l=1&&b以下是解决上述问题的代码：

package subway;

import java.util.Scanner;

public class MarthaProblem {
    public static void main(String[] nag){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        for(int i=0;i<t;i++){
            if(t>=1 && t<=1000){
                int l = sc.nextInt();
                int b = sc.nextInt();
                if((l>=1 && l<=1000)&&(b>=1 && b<=1000)){
                    System.out.println(calculate(l,b));
                }
            }
        }
    }
    public static int calculate(int l, int b){
        return ((l/(gcd(l,b)))*(b/(gcd(l,b))));
    }

    public static int gcd(int l,int b){
        if(b==0){
            return l;
        }else{
            return gcd(b, l%b);
        }
    }
}

package地铁；
导入java.util.Scanner；
公共类马氏问题{
公共静态void main（字符串[]nag）{
扫描仪sc=新的扫描仪（System.in）；
int t=sc.nextInt（）；
对于（int i=0；i=1&&t=1&&l=1&&b，我看到if（l>b）{check（l，b）；}else if（b>l）{check（l，b）；}else{check（l，b）；}总是解析为check（l，b）不管怎样。这可能是问题的根源。@BlakeHood复制/粘贴/确实没有思考问题。只是为了确保我理解问题：给你一个尺寸为
l
和
b
的矩形，并要求你将其切割成所有边长相等且最大化的正方形（并且没有残余）？如果这是对的，我们谈论的是整数长度还是分数长度（即，我假设
l
和
b
是整数，但生成的正方形的边长可能是1.5吗）？问题是我没有考虑“现实生活”术语。我不能在将一片面包切成碎片后将其粘贴在一起。@BlakeHood绝对正确，但是，我需要重新考虑这个过程，而不是只是复制/粘贴问题以找到解决方案。我立即看到if（l>b）{check（l，b）；}else if（b>l）{check（l，b）；}否则{check（l，b）；}总是决定检查（l，b）不管怎样。这可能是问题的根源。@BlakeHood复制/粘贴/确实没有思考问题。只是为了确保我理解问题：给你一个尺寸为
l
和
b
的矩形，并要求你将其切割成所有边长相等且最大化的正方形（并且没有残余）？如果这是对的，我们谈论的是整数长度还是分数长度（即，我假设
l
和
b
是整数，但生成的正方形的边长可能是1.5吗）？问题是我没有考虑“现实生活”术语。我不能将一块面包切成碎片后再粘贴在一起。@BlakeHood绝对正确，但是，我需要重新思考这个过程，而不是只是复制/粘贴问题以找到解决方案。我很晚才回复这篇文章，我的解决方案可能是必需的，也可能不是必需的。但是，这将是对某些人的参考和帮助。这个解决方案是f或者找到玛莎正在地铁面试。在没有剩余面包的情况下找到可能边长的最大值。很抱歉在我之前的评论中没有提供完整的信息。这是我在stack overflow中的第一篇解决方案帖子。如果我犯了任何错误，请让我知道。GCD有助于找到可能边长的数量，但我们没有为了求可能边的最大值，我编制了程序（l/（GCD）*b/（GCD））。我很晚才回复这篇文章，我的解决方案可能是必需的，也可能不是必需的。但是，这将是对某些人的一个参考和帮助。这个解决方案是为了找到玛莎正在地铁面试的人。在没有剩余面包的情况下找到可能的边长的最大值。很抱歉在我之前的评论中没有提供完整的信息。这是我的建议堆栈溢出中的第一个解决方案。如果我犯了任何错误，请告诉我。GCD有助于找到可能边的数量，但我们必须找到可能边的最大值。因此，我制作了程序（l/（GCD）*b/（GCD））。