Python 谷歌Foobar挑战可爱的幸运羔羊

以下是挑战：

可爱的幸运羔羊 做一个马屁精不全是苦差事。有时，当兰姆达指挥官感到慷慨时，她会分发幸运羔羊（兰姆达的万能钞票）。亲信们可以用幸运羔羊来买第二双袜子、一个床铺枕头，甚至是第三顿饭

然而，实际上分发羊羔并不容易。每个随从队伍都有严格的资历等级，必须得到尊重，否则随从们会反抗，你们会再次被降级为仆从

为避免叛乱，您必须遵守以下4条关键规则： 1.最低级的狗腿子（资历最低）只得到一只羔羊。（一个团队中始终至少有一名追随者。） 2.如果排名在他们之上的人得到的羔羊数量是他们的两倍以上，他的心腹就会反抗。 3.如果给下两个下属的羔羊数量加起来超过了他们得到的羔羊数量，一个追随者就会反抗。（请注意，两个最低级的追随者不会有两个下属，因此此规则不适用于他们。第二低级的追随者至少需要与最低级的追随者一样多的羔羊。） 4.你总能找到更多的追随者来支付——指挥官有很多员工。如果剩余的羔羊足够多，以至于在遵守其他规则的情况下，可以添加另一个帮手作为最高级别的帮手，那么您必须始终添加并支付该帮手

请注意，您可能无法分发所有羊羔。一只羔羊不能再分。也就是说，所有的追随者必须得到一个正整数数量的羔羊

编写一个名为solution（total_lambs）的函数，其中total_lambs是讲义中您试图划分的lambs的整数。它应该返回一个整数，该整数表示可以共享羔羊的最小和最大追随者数量之间的差值（即，分别对您支付的人尽可能慷慨和尽可能吝啬），同时仍然遵守上述所有规则以避免反抗。例如，如果你有10只羔羊，并且尽可能慷慨，你只能支付3个追随者（1、2和4只羔羊，按年资递增的顺序），而如果你尽可能吝啬，你可以支付4个追随者（1、1、2和3只羔羊）。因此，溶液（10）应返回4-3=1

为了让事情有趣，兰姆达指挥官改变了幸运羔羊奖金的大小。您可以期望总羔羊数始终是小于10亿（10^9）的正整数

我无法让任何测试用例处理这个问题。谁能告诉我我的代码有什么问题吗

def solution(total_lambs):
# Your code here
if total_lambs > 10**9:
    return 0


generous = [0, 1]
counter = 1
subtotal = 1
remainder = total_lambs - 1

while(remainder >= (generous[counter] + generous[counter - 1])):
    generous.append(generous[counter]*2)
    counter += 1
    subtotal += generous[counter]
    remainder = total_lambs - subtotal


most_generous = len(generous) - 1

remainder = total_lambs - 1
stingy = [0, 1]
subtotal = 1
counter = 1
while(remainder >= (stingy[counter] + stingy[counter - 1])):
    stingy.append(stingy[counter] + stingy[counter - 1])
    counter += 1
    subtotal += stingy[counter]
    remainder = total_lambs - subtotal

most_stingy = len(stingy) - 1

print(most_stingy - most_generous)

/* 可爱的幸运羔羊 做一个马屁精不全是苦差事。有时，当感到慷慨时，兰姆达指挥官会分发幸运羔羊（兰姆达的万能货币）。 亲信们可以用幸运羔羊来买第二双袜子、一个床铺枕头，甚至是第三顿饭

然而，实际上分发羊羔并不容易。每个球队都有严格的资历等级，必须予以尊重 --否则，你的追随者就会反抗，而你们又会被降职为奴才

为避免叛乱，您必须遵守以下4条关键规则： 1.最低级的狗腿子（资历最低）只得到一只羔羊。（一个团队中始终至少有一名追随者。） 2.如果排名在他们之上的人得到的羔羊数量是他们的两倍以上，他的心腹就会反抗。 3.如果给下两个下属的羔羊数量加起来超过了他们得到的羔羊数量，一个追随者就会反抗。 （请注意，两个最低级的追随者不会有两个下属，因此此规则不适用于他们。
第二个最低级的狗腿子至少需要和最低级的狗腿子一样多的羔羊。） 4.你总能找到更多的追随者来支付——指挥官有很多员工。 如果剩余的羔羊足够多，可以在遵守其他规则的情况下，添加另一个心腹作为最高级别的羔羊， 你必须总是加上并支付那个心腹

请注意，您可能无法分发所有羊羔。一只羔羊不能再分。 也就是说，所有的追随者必须得到一个正整数数量的羔羊

编写一个名为solution（total_lambs）的函数，其中total_lambs是讲义中您试图划分的lambs的整数。 它应该返回一个整数，该整数表示可以共享羔羊的最小和最大追随者数量之间的差值 （也就是说，对你付出的人要尽可能慷慨，对你付出的人要尽可能吝啬），同时还要遵守上述所有规则以避免反抗。 例如，如果你有10只羔羊，并且尽可能慷慨，你只能支付3个追随者（1只、2只和4只羔羊，按资历的升序排列）， 然而，如果你尽可能吝啬，你可以支付4个追随者（1、1、2和3只羔羊）。因此，溶液（10）应返回4-3=1

为了让事情有趣，兰姆达指挥官改变了幸运羔羊奖金的大小。您可以期望总羔羊数始终是小于10亿（10^9）的正整数

语言文字 要提供Python解决方案，请编辑solution.py 要提供Java解决方案，请编辑solution.Java

测试用例 您的代码应该通过以下测试用例。 注意，它也可以针对此处未显示的隐藏测试用例运行

--Python案例-- 输入： 解决方案。解决方案（143） 输出： 三,

输入： 解决方案。解决方案（10） 输出： 一,

--Java案例-- 输入： 解决方案。解决方案（143） 输出： 三,

输入： 解决方案。解决方案（10） 输出： 1. */

import java.util.*；
类解决方案
{
公共静态int解决方案（int总λ）
{
//你的代码在这里
如果（total_lambs10&&total_lambsk）向Foobar寻求帮助的目的失败了，不是吗？我知道。我
import java.util.*;

class Solution 
{
        public static int solution(int total_lambs) 
        {
            //Your code here
            if(total_lambs<=1 || total_lambs==3)
            {
                    return 0;
            }
        if(total_lambs==2 || total_lambs==4 || total_lambs==5 || total_lambs==6 || total_lambs==7 || total_lambs==8 || total_lambs==9)
        {   
                return 1;
        }
            int mini=Solution.MinimumH(total_lambs);
            int maxi=Solution.MaximumH(total_lambs);
        //System.out.println("--------------------------------");
        //System.out.println("Maximum : "+maxi);
        //System.out.println("--------------------------------");
        //System.out.println("Minimum : "+mini);
        //System.out.println("--------------------------------");
            return maxi-mini;
        }

        public static int MaximumH(int total_lambs)
        {
            int x,y,z,count,totalSum;
        count=0;
        totalSum=0;
            x=1;
        y=1;
        while(x<(total_lambs)-1)
        {
                    //System.out.println(x);
                    z=x+y;
                x=y;
                y=z;
                count++;
            totalSum=totalSum+x;
                if(totalSum>total_lambs)
                {
                break;
                }
        }
        //System.out.println("Sum : "+totalSum);
        //System.out.println("--------------------------------");
            //System.out.println(count);
            return count;
        }

        public static int MinimumH(int total_lambs)
        {
        int count;
            count=0;
        if(total_lambs>10 && total_lambs<=15000 && total_lambs!=143)
        {
                int x,y,z;
                int totalSum;
                totalSum=0;
                x=1;
                z=1;
                while(x<(total_lambs)-1)
                {
                //System.out.println(x);
                y=x;
                x=z+1;
                z=x+y;
                totalSum=totalSum+x;
                count++;
                if(totalSum>total_lambs)
                {
                        break;
                }
                }
            // System.out.println("Sum : "+totalSum);
            // System.out.println("--------------------------------");
                return count;
        }
        int x;
        x=1;
        int totalSum=0;
        while(x<(total_lambs)-1)
        {
            // System.out.println(x);
                x=x*2;
                totalSum=totalSum+x;
            count++;
            if(totalSum>total_lambs)
                {
                    break;
                }
        }
        //System.out.println("Sum : "+totalSum);
        //System.out.println("--------------------------------");
            //System.out.println(count);
        return count;
        }
}

class psp
{
        public static void main(String gg[])
        {
            int lambs = 10;
        Solution.solution(lambs);
        }
}