可爱的幸运小羊

做一个追随者并不都是苦差事。偶尔，当指挥官 Lambda 感到慷慨时，她会分发 Lucky LAMBs（Lambda 的万能钱币）。追随者可以使用幸运小羊来购买第二双袜子、铺位枕头，甚至是每日第三餐！

然而，实际上传递 LAMB 并不容易。每个追随者小队都有严格的资历等级，必须尊重 - 否则追随者会反抗，你们都会再次被降级为奴才！

为了避免叛乱，您必须遵循 4 条关键规则： 1. 最年轻的追随者（资历最低）正好得到 1 只 LAMB。（团队中总是至少有 1 名追随者。） 2. 如果排名在他们之上的人获得的 LAMB 数量是他们的两倍以上，则追随者会反抗。3. 如果给下两个下属的 LAMB 数量加起来超过了他们得到的 LAMB 数量，一个追随者就会反抗。（请注意，两个最低级的追随者不会有两个下属，因此该规则不适用于他们。第二个最低级的追随者至少需要与最初级的追随者一样多的 LAMB。） 4. 你总能找到支付更多的追随者 - 指挥官有很多员工。

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

编写一个名为 solution(total_lambs) 的函数，其中 total_lambs 是您尝试划分的讲义中 LAMB 的整数。它应该返回一个整数，该整数表示可以共享 LAMB 的最小和最大数量的追随者之间的差异（即，分别对您支付的人尽可能慷慨和尽可能小气），同时仍然遵守上述所有规定规避暴乱的规则。例如，如果你有 10 只 LAMB，并且尽可能慷慨，你只能支付 3 个心腹（1、2 和 4 个 LAMB，按资历递增），而如果你尽可能小气，你可以支付 4心腹（1、1、2 和 3 只 LAMB）。因此，solution(10) 应该返回 4-3 = 1。

为了让事情变得有趣，指挥官 Lambda 会改变 Lucky LAMB 支出的大小。您可以期望 total_lambs 始终是小于 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)

标签： python

解决方案

/* 可爱的幸运羊

做一个追随者并不都是苦差事。偶尔，当感觉大方时，指挥官 Lambda 会分发 Lucky LAMBs（Lambda 的万能钱币）。追随者可以使用幸运小羊来购买第二双袜子、铺位枕头，甚至是每日第三餐！

然而，实际上传递 LAMB 并不容易。每个追随者小队都有严格的资历排名，必须尊重 - 否则追随者会反抗，你们都会再次被降级为奴才！

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

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

为了让事情变得有趣，指挥官 Lambda 会改变 Lucky LAMB 支出的大小。您可以期望 total_lambs 始终是小于 10 亿 (10 ^ 9) 的正整数。

语言

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

测试用例

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

-- Python 案例 -- 输入：solution.solution(143) 输出：3

输入：solution.solution(10) 输出：1

-- Java 案例 -- 输入：Solution.solution(143) 输出：3

输入：Solution.solution(10) 输出：1 */

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);
        }
}

python - Google Foobar Challenge 可爱的幸运羊

问题描述

可爱的幸运小羊

解决方案

/* 可爱的幸运羊

语言

测试用例

推荐阅读