语言

Question

这是我在google foobar第3级面临的问题。所以问题如下。

有两种类型：马赫炸弹（M）和法图拉炸弹（F）。这些炸弹一旦被释放到LAMBCHOP的内部工作中，将自动部署到您已识别的所有战略要点并同时销毁它们。

但是有一些捕获量。首先，炸弹通过两个不同的过程中的一个进行自我复制：每一个马赫炸弹都从一个Facula炸弹中取出一个同步装置;对于每一个马赫炸弹，都会制造一个Facula炸弹; 每个Facula炸弹都会自发地制造出一个马赫炸弹。

例如，如果你有3枚马赫炸弹和2枚法图拉炸弹，它们可以生产3枚马赫炸弹和5枚法图拉炸弹，或5枚马赫炸弹和2枚法图拉炸弹。每个周期都可以更改复制过程。

其次，你需要确保你有足够数量的Mach和Facula炸弹来摧毁LAMBCHOP设备。太少了，设备可能会存活下来。太多了，你可能会使大容量电容器过载并在空间站的核心产生一个奇点 - 不好！

最后，当你到达时，你只能将每种类型的炸弹中的一种 - 一个Mach，一个Facula - 走私到船上，所以这就是你必须要开始的。（因此可能无法部署炸弹来摧毁LAMBCHOP，但这不会阻止你尝试！）

您需要知道生成正确数量的炸弹以摧毁LAMBCHOP需要多少复制周期（代）。写一个函数答案（M，F），其中M和F是所需的Mach和Facula炸弹的数量。 返回需要通过的最少代数（作为一个字符串），然后才能获得销毁LAMBCHOP所需的确切炸弹数量，或者如果不能这样做则“不可能”字符串完成了！ M和F将是正整数不大于10 ^ 50 的字符串表示。例如，如果M =“2”且F =“1”，则需要传递一代，因此答案将为“1”。但是，如果M =“2”且F =“4”，则不可能。

语言

要提供Python解决方案，请编辑solution.py 要提供Java解决方案，请编辑solution.java

测试用例

输入：（字符串）M =“2” （字符串）F =“1” 输出：（字符串）“1”

输入：（字符串）M =“4” （字符串）F =“7” 输出：（字符串）“4”

由于它的输入是字符串中的数字，并且可以长达10 ^ 50，我在java中使用 BigInteger类。我用过的方法是给我TLE。任何人都可以告诉我如何进一步优化它？

我在java中的代码。

打包com.google.challenges;

import java.math.BigInteger;

public class Answer {   
    public static String answer(String M, String F) { 

    if(M.equals("1") && F.equals("1"))
    {
        return "0";
    }
    BigInteger ans = func(new BigInteger(M),new BigInteger(F));
    if(ans.compareTo(new BigInteger("-1")) == 0)
    {
        return "impossible";
    }
    else
    {
        return ans.toString();
    }
    }   
    public static BigInteger func(BigInteger m,BigInteger f)
    {
        int check;
        BigInteger steps = new BigInteger("0");
        BigInteger one = new BigInteger("1");
        while((check = m.compareTo(f)) != 0)
        {
            if(check == -1)
            {
                f = f.subtract(m);
            }
            else
            {
                m = m.subtract(f);
            }
            steps = steps.add(one);
            if(m.compareTo(one) == 0 || f.compareTo(one) == 0)
                break;
        }
        int mComparedTof = m.compareTo(f);
        int mCompareToOne = m.compareTo(one);
        int fCompareToOne = f.compareTo(one);
        if(mCompareToOne == 0 && fCompareToOne == 0)
        {
            return steps;
        }
        else if(mComparedTof == 0 && mCompareToOne != 0)
        {
            return new BigInteger("-1");
        }
        else if(mCompareToOne == 0)
        {
            steps = steps.add(f.subtract(one));
            return steps;
        }
        else
        {
            return steps.add(m.subtract(one));
        }
    }

}

Answer 1

我不使用Java，但是由于该问题带有算法标记，因此您可以使用以下算法：

#!/usr/bin/python
#bomb-baby
#For given (m,f) combo check if they can be subtracted to reach (1,1) using formulas m=m-f or f=f-m. Count the number of operations needed to reach (1,1)

def solution(x,y):
    m=int(x)
    f=int(y)
    cnt=0
    while((m>1 or f>1) and (m!=0 and f!=0)):
        if(m>f):
            if(m>1000*f):
                cnt+=int(m/f)
                m-=int(m/f)*f                       
            else:
                m-=f
                cnt+=1
        elif(f>m):
            if(f>1000*m):           
                cnt+=int(f/m)
                f-=int(f/m)*m           
            else:
                f-=m
                cnt+=1
        else:
            return "impossible"

    return str(cnt)

#print solution(7,4)
print solution(100000,10)

google foobar bomb_baby。 TLE

语言

测试用例

1 个答案: