一个来自星空的人来到了地球！幸运的是，美国总统唐纳德·特朗普（Donald Trump）死于无边。使用此模具，他可以想出您作为Podunk市长必须使用的数字，以确定应该派遣谁来制止入侵者！但是请注意，您只能在青蛙背面发送有限数量的字节！

给定用户输入（将为正整数），您必须根据数字所在的类别返回字符串。

• 如果该数字是斐波那契数字，则必须输出Ness。
• 如果该数字是Lucas数字，则必须输出Lucas。
• 如果数字是双方一个Lucas数和Fibonacci数，你必须输出特拉维斯。
• 如果数字是既不 AA Lucas数也不是斐波那契数，你必须输出皮皮。

例子

这是一堆测试用例：

1 =>特拉维斯
2 =>特拉维斯
3 =>特拉维斯
4 =>卢卡斯
5 =>尼斯
6 =>皮皮
7 =>卢卡斯
8 =>尼斯
610 =>尼斯
722 =>皮皮
843 =>卢卡斯

规则

• 这是代码高尔夫球，最短的答案以字节为单位。
• 您的程序可以是完整程序，也可以是（n匿名）函数。

奖金

您可以使用一些奖金来帮助您的青蛙更快地将数据提供给特朗普总统：

• 对于-15字节：如果输入数字为2016，则必须输出Trump，因为他处于总统任期的顶峰。

Pyth，59-15 = 44字节

或修正错误后的42个位元组

&Qr@c."av�a�(s��kW���"\b?q2016Q4/hMst*2.uL,eNsNQ_BS2Q4

十六进制转储：

0000000: 2651 7240 632e 2261 7601 c061 15dc 2873  &Qr@c."av..a..(s
0000010: fde0 6b57 8bd0 a1ed ed0f 225c 623f 7132  ..kW......"\b?q2
0000020: 3031 3651 342f 684d 7374 2a32 2e75 4c2c  016Q4/hMst*2.uL,
0000030: 654e 734e 515f 4253 3251 34              eNsNQ_BS2Q4

前两个字符（&Q）是必要的，因为一个Pyth解析错误，使的Q后."失效。修复程序已应用。如果允许使用错误修复后解释器，则为-2个字节。

没有不可读的字符串压缩：

Pyth，63-15 = 48个字节

没有特朗普的49个字节

@c"Pippi Ness Lucas Travis Trump")?nQ2016/hMst*2.uL,eNsNQ_BS2Q4

测试套件

非常简单，只需生成序列，重复一个序列并检查成员资格即可。

序列以[1, 2]和开头[2, 1]，然后应用fibonacci规则生成。

利亚，146个 142 121 120字节

n->split("Pippi Lucas Ness Travis")[2any(isinteger,sqrt([5n^2+4,5n^2-4]))+(n∈[2;[(g=golden)^i+(-g)^-i for i=1:n]])+1]

这将创建一个未命名的函数，该函数返回一个布尔值。要给它起个名字，例如f=n->...。

取消高尔夫：

function trump(n::Integer)
    # Determine if n is a Fibonacci number by checking whether
    # 5n^2 ± 4 is a perfect square
    F = any(isinteger, sqrt([5n^2 + 4, 5n^2 - 4]))

    # Determine if n is a Lucas number by generating Lucas
    # numbers and testing for membership
    # golden is a built-in constant containing the golden ratio
    L = n ∈ [2; [golden^i + (-golden)^-i for i = 1:n]]

    # Select the appropriate Earthbound charater using array
    # indexing on a string split into an array on spaces
    return split("Pippi Lucas Ness Travis")[2F+L+1]
end

修复了一个问题，并通过Glen O节省了7个字节！

Mathematica 143156-15 （奖励）= 141字节

使用LegionMammal978，节省了2个字节。

t_~g~l_:=(r=1<0;n=1;While[(z=l@n)<=t,If[z==t,r=1>0];n++];r);a=g[k=Input[],LucasL];
b=k~g~Fibonacci;Which[k==2016,Trump,a&&b,Travis,a,Lucas,b,Ness,2<3,Pippi]

Mathematica，92 87字节

受Sp3000的答案启发。

Travis[Ness,Lucas,Pippi][[{2,1}.Product[Abs@Sign[{Fibonacci@n,LucasL@n}-#],{n,0,2#}]]]&

蟒蛇2，107

f=lambda i,n=input():abs(5*n*n+i)**.5%1>0
print["Travis","Lucas","Ness","Pippi"][f(4)*f(-4)+2*f(20)*f(-20)]

关键是对Fibonacci和Lucas数进行两次纯算术检验：

• n确切地是5*n*n+4或是 5*n*n-4一个完美的平方就是斐波那契数
• n到底是卢卡斯数5*n*n+20还是 5*n*n-20正平方

这个站点有证明草图。

因此，输出取决于in 中5*n*n+ifor 的值。该函数通过检查相应的值是否不具有整数平方根来测试值，是否存在只是为了避免对取负的根的错误。i{4,-4,20,-20}fiabsn=1, i=-20

该函数从STDIN获取要测试f的数字值n。Python仅对此求值一次，而不对每个函数调用求一次。

该数字是否为非斐波那契数被评估为f(4)*f(-4)使用隐式布尔到数字的转换，类似地，不是卢卡斯，则采用相应的字符串。如果允许尾随空格，则字符串交织会更短。

Python 2，117字节

F=[1]
L=[2,1]
n=input()
exec 2*n*"F,L=L+[sum(L[-2:])],F;"
print["Pippi","Lucas","Ness","Travis"][(n in F)*2+(n in L)]

对于字符串列表，"Pippi Lucas Ness Travis".split()长度是相同的。

CJam，58 55 54字节

ri5Zbe!f{1${_-2>:++}*&!}2b"Travis Ness Lucas Pippi"S/=

生成斐波那契数和卢卡斯数，然后计算两者中的出现次数，转换为二进制数并选择适当的字符串的简单方法。

在线尝试。

严重的是69个字节

,;;r`;F@2+F+`M2@q@#"%d="%£MΣ@f0≤2*+["Pippi","Lucas","Ness","Travis"]E

在挑战之前，认真地拥有内置f函数（斐波纳契数的索引，如果不是斐波那契数，则为-1）...但是列表或“在列表中”则没有索引！（此后已添加为í。）

因此，如果输入的是斐波那契数，这就是我要花费的时间：

,                              f0≤

这是我用来生成卢卡斯数字列表的内容：

  ;r`;F@2+F+`M2@q

这就是我要查找的输入是否在卢卡斯数字列表中的内容：

 ;                @#":%d:="%£MΣ

该字符串使用Python的％表示法格式化为:610:=，然后转换为函数，然后将该函数映射到数组并求和。（卢卡斯数是唯一的，因此总和始终为0或1。）

感谢@Mego提供了字符串格式的最后一点。

Perl，133 （146-15 =）131 （144-15 =）129（136-15 =）121字节

+1字节的-n标志。

$a=$d=1;$b=$c=2;$f+=$_==$a,$l+=$_==$c,($a,$b,$c,$d)=($b,$a+$b,$d,$c+$d)while$a<$_*9;say$_-2016?(Pippi,Ness,Lucas,Travis)[$f+$l*2]:Trump

在分号后使用换行符，以提高可读性：

$a=$d=1;$b=$c=2;
$f+=$_==$a,$l+=$_==$c,($a,$b,$c,$d)=($b,$a+$b,$d,$c+$d)while$a<$_*9;
say$_-2016?(Pippi,Ness,Lucas,Travis)[$f+$l*2]:Trump

演示：

llama@llama:...code/perl/ppcg64476trump$ for x in 1 2 3 4 5 6 7 8 610 722 843 2016; do echo -n "$x => "; echo $x | perl -n trump.pl; done
1 => Travis
2 => Travis
3 => Travis
4 => Lucas
5 => Ness
6 => Pippi
7 => Lucas
8 => Ness
610 => Ness
722 => Pippi
843 => Lucas
2016 => Trump

技巧：

• 你可能会奇怪，为什么我的变量命名为$a，$b，$%，和$d。这是一个很好的问题！实际上，它允许我保存一个字节。

  (stuff) ... ,$l+=$_==$%while$a<$_

  比1个字节短

  (stuff) ... ,$l+=$_==$c while $a<$_

  这不再适用，因为我通过重新整理代码来修改代码，导致变量名更改为不再保存字节。我将其改回，以使变量名再次有意义。

• $_-2?$f+$l*2:3很有趣。基本上，我必须2对Lucas数字进行特殊处理，因为我的程序会在 “更新”斐波那契和Lucas数字之后检查数字是否为Lucas数字。因此2被认为不是Lucas号码。$_-2?foo:bar是比短的字符$_==2?bar:foo。相同的东西用于2016测试。

  这也不再成立，因为我能够重组程序，而无需特殊外壳2。但是我仍然使用$_-2016?stuff:Trump而不是$_==2016?Trump:stuff，它要长一个字节。

• 说到这，您可能想知道我是如何进行此重组的。我只是使程序进行了比必要次数多9倍的迭代，这仅花费了2个字节（*9），但允许我在其他地方进行假设，以帮助降低高尔夫球的负担。

• 由于变量默认为零，

  $f+=$_==$a

  短于

  $f=1if$_==$a

• Perl支持裸字，因此我不必引用任何字符串（\ o /）。

朱莉娅101 100字节

n->split("Pippi Lucas Ness Travis")[[2;1]⋅(sum(i->[i[];trace(i)].==n,Any[[1 1;1 0]].^(0:n)).>0)+1]

取消高尔夫：

function f(n)
  k=Any[[1 1;1 0]].^(0:n) # Produces characteristic matrices of Fibonacci
                          # numbers from 0 to n
  F=sum(i->i[]==n,k)      # Check if n is a Fibonacci number by checking
                          # the first value in each matrix for n
  L=sum(i->trace(i)==n,k) # Check if n is a Lucas number by checking
                          # the trace of each matrix for n
  I=[2;1]⋅[F;L]+1         # Calculate 2F+L+1, which is the index for the next step
  S=split("Pippi Lucas Ness Travis") # Creates array with four strings
                          # saves a byte compared with directly creating array
  return S[I]
      # This uses the above calculations to determine which of the four to return
end

八度，93字节

@(n){'Pippi','Lucas','Ness','Travis'}{(1:2)*any(~rem(real(sqrt(5*n^2+[-20,-4;20,4])),1)).'+1}

这种方法类似于我的MATLAB答案，不同之处在于Octave允许您直接索引到新数组中：

{'a', 'b', 'c'}{2}    %// b

MATL（非竞争），57 55 54（67-15）= 52字节

20Kht_vi2^5*+X^Xj1\~a2:*sG2016=-'Lucas Ness Travis Trump Pippi'Ybw)

在线尝试！

说明

同样，这里和这里的逻辑与我的其他答案相似。

20      % Number literal
K       % Retrieve the number 4 from the K clipboard (the default value)
h       % Horizontal concatenation to produce [20 4]
t       % Duplicate elements
_v      % Negate and vertically append elements (yields [20, 4; -20 -4])
i2^     % Explicitly grab the input and square it
5*      % Multiply by 5
+       % Add this to the matrix ([20, 4; -20 -4])
X^      % Take the square root
Xj      % Ensure that the result is a real number
1\      % Get the decimal component
~       % Create a logical arrays where we have TRUE when no remainder
a       % For each column determine if any element is TRUE
2:      % Create the array 1:2
*       % Perform element-wise multiplication with boolean
s       % Sum the result to yield an index
G       % Explicitly grab the input (again)
2016=   % Check to see if it is 2016 (yields TRUE (1) if equal)
-       % Then subtract the boolean from the index. Since 2016 is NOT a
        % Fibonacci or Lucas number, the original index is 0. Subtracting
        % this boolean, will make this index now -1. For all other non-2016
        % numbers this will have no effect on the index.
'Lucas Ness Travis Trump Pippi' % Create the possible strings values 
        % Note: the 0 index wraps around to the end hence Pippi being at the end.
        % The next to last entry ('Trump') is ONLY accessible via a -1 index as
        % discussed above
Yb      % Split at the spaces to create a cell array
w       % Flip the top two stack elements
)       % Retrieve the desired value from the cell array

C ++ 11、176 + 15（#include）= 191

#include<mutex>
[](int n){std::function<int(int,int)>c=[&](int f,int s){return f-s>n?0:s-n?c(s,f+s):1;};int l=c(2,1),f=c(1,1);l&f?puts("Travis"):l?puts("Lucas"):f?puts("Ness"):puts("Pippi");}

放心使用。如果明天有要求，我可以添加解释，现在就可以睡觉了！

#include <functional>
#include <cstdio>
int main()
{
    auto r = [](int n)
    {
        std::function<int(int, int)> c = [&](int f, int s)
        {
            return f - s > n ? 0 : f - n ? c(s, f + s) : 1;
        };
        int l = c(2, 1), f = c(1, 1);
        l & f ? puts("Travis") : l ? puts("Lucas") : f ? puts("Ness") : puts("Pippi");
    };

    for (int i : { 1, 2, 3, 4, 5, 6, 7, 8, 610, 722, 843 })
    {
        printf("%i - ", i); r(i);
    }
}

Javascript（ES6），108个字节

x=>(f=(a,x,y)=>a==y||a==x?1:a<y?0:f(a,y,x+y),b=f(x,0,1),c=f(x,2,1),b&&c?'Travis':b?'Ness':c?'Lucas':'Pippi')

斐波那契和卢卡斯的功能相同。这是一个将前两个值用作init的递归函数。

Java，151个字节

您可能会辩称，特朗普永远不会外包这个至关重要的决定，因此我们不必公开该方法，而又可以节省7个字节。

public String t(int n){return"Pippi,Lucas,Ness,Travis".split(",")[2*f(n,1,1)+f(n,2,1)];}int f(int a,int x,int y){return a==x||a==y?1:a<y?0:f(a,y,x+y);}

取消测试，包括测试主调用

public class Trump {

    //Test Invokation
    public static void main(String[] args) {
        int[] n = {1, 2, 3, 4, 5, 6, 7, 8, 610, 722, 843, 2016 };
        for(int i = 0; i < n.length; ++i) {
            System.out.println(""+ n[i] + " => " + new Trump().t(n[i]));
        }
    }


    public String t(int n) {        
        return "Pippi,Lucas,Ness,Travis".split(",")[2*f(n,1,1)+f(n,2,1)];               
    }
    int f(int a,int x,int y) {             
        return a==x||a==y?1:a<y?0:f(a,y,x+y);           
    }

}

我到目前为止还没有办法测试2016年并返回少于15个字节的代码中的“ Trump”。

C（GCC） ， 128个   120   116  110字节

a;b;o;f(n){for(o=b=0,a=1;a<=n;b=a+b,a=b-a)o|=(b==n)+2*(2*a+b==n);n=o?o-1?o-2?"Travis":"Lucas":"Ness":"Pippi";}

在线尝试！

说明

让我们命名F(n)第n个斐波那契数和L(n)第n个Lucas数。
a，b是F(n-1)，F(n)分别。
然后，我们可以计算出L(n) == F(n-1)+F(n+1) == 2*F(n-1) + F(n) == 2*a+b
该函数将依次计算Fibonacci和Lucas数，最高为n，并检查其中是否n有一个。
如果n是斐波那契数，则将其的第一位o设置为1
如果n是卢卡斯数，则将其第二位o设置为1
o将用于确定要输出的名称

编辑

• 通过查看for循环的条件节省了8个字节：从第二次迭代开始，我们有a<b<cand a<a+c=L(n)，所以( b<=n || a+c<=n ) => a<n。我实际上需要a<=n正确处理n=1
• 多亏了ceilingcat，节省了4个字节！（还纠正了一个错误，我的代码输出了“ 2 => Ness”）
• 保存了6个字节：
  • 2再次感谢ceilingcat
  • 4通过删除c等于的变量，F(n+1)这是没有用的，因为我们已经可以F(n+1)使用a和进行计算b

Perl 5.10，119-15（奖励）= 104字节

$_=<>;$j=1;($i,$j)=($j,$i+$j)while$_>$i;say$_-2016?(Pippi,Lucas,Ness,Travis)[($_==$i)*2|$_==3*$j-4*$i|$_-1>>1==0]:Trump

取消高尔夫：

# Read line from stdin
$_ = <>;

# Find first Fibonacci number greater than or equal to input.
# Store this number in $i and the next Fibonacci number in $j.
$j = 1;
($i, $j) = ($j, $i + $j) while $_ > $i;

say $_ - 2016
  ? (Pippi,Lucas,Ness,Travis)[
      ($_ == $i) * 2 |          # Bitwise OR with 2 if Fibonacci number
      $_ == 3 * $j - 4 * $i |   # Bitwise OR with 1 if Lucas number >= 3
      $_ - 1 >> 1 == 0          # Bitwise OR with 1 if Lucas number <= 2
    ]
  : Trump

这利用了以下事实：

L(n-2) = 3 * F(n+1) - 4 * F(n)

是小于或等于F（n）的最大卢卡斯数。

Groovy，149个字节

f={i->g={m,s->while(s[-2]<=m)s<<s[-2]+s[-1];s}
println(["Pippi","Ness","Lucas","Travis"][(g(i,[1,1]).contains(i)?1:0)+(g(i,[2,1]).contains(i)?2:0)])}

测试代码：

[1,2,3,4,5,6,7,8,610,722,843].each {
    print "$it => "
    f(it)
}

g是一个闭包，它基于种子（s）和最大值（m）生成数字列表。(g(i,[1,1]).contains(i)?1:0)+(g(i,[2,1]).contains(i)?2:0)根据卢卡斯或斐波那契数找到要使用的索引。

MATLAB，122个 119字节

@(n)subsref({'Pippi','Lucas','Ness','Travis'},substruct('{}',{(1:2)*any(~rem(real(sqrt(5*n^2+[-20,-4;20,4])),1)).'+1}))

简要说明

我们首先创建一个包含要打印的值的单元格数组{'Pippi', 'Lucas', 'Ness', 'Travis'}。然后找出要显示的值，然后检查n是斐波那契数还是卢卡斯数。

对于斐波那契，我们使用以下公式：

any(~rem(sqrt(5*n^2 + [-4 4]), 1))

这将检查是否任何5*n^2 + 4或5*n^2 - 4有一个完美的正方形。如果any是，则为斐波那契数。

Lucas数的公式非常相似，除了我们使用+/- 20而不是4：

any(~rem(sqrt(5*n^2 + [-20 20]), 1))

在此解决方案中，我使用矩阵将这两种情况合并为一种：

M = [-20 -4
      20  4]

通过应用与上述相同的公式，但是any仅考虑第一个维度，我得到了一个由两个元素组成的逻辑数组，如果第一个元素为true，则它为卢卡斯数，如果第二个元素为true，则为斐波那契数。

any(~rem(sqrt(5*n^2 + [-20 -4;20 4]), 1))

然后，要计算进入我的初始单元格数组的索引，我可以通过将该布尔值与[2^0, 2^1]或进行元素逐个相乘，将其视为二进制序列[1,2]。并对元素求和。显然，由于MATLAB的基于索引的索引，我必须加1。

index = (1:2) * any(~rem(real(sqrt(5*n^2+[-20,-4;20,4])),1)).' + 1;

然后，我必须使用subsref和substruct索引到初始单元格数组中以获得最终结果。

JavaScript（ES6），97个字节

x=>[['Pippi','Lucas'],['Ness','Travis'],f=(a,x,y=1)=>a>x?f(a,y,x+y):a==x||a==1][+f(x,0)][+f(x,2)]

该a==1检查是必要，否则我没有注意到，1是Lucas数。

果冻，47个字节-15 = 32（不竞争...？）

+2ḶÆḞ⁸eð+ị“©ḤʠhMṂƁÞḄṭAƓ»Ḳ¤µ2+С-⁸eḤ
“¡Ỵ¦»Ç⁼?⁽¥Ð

在线尝试！

05AB1E，39 37（52-15奖金）字节

2016Qi.•ªb‚•ë>ÅG¹å_¹ÅF¹åi.•F_ïk|»9•ë.•?®B'5n•}2äsè}™

在线尝试或验证所有测试用例。

说明：

2016Qi                # If the input equals 2016:
      .•ªb‚•          #  Push "trump" to the stack
ë                     # Else:
 >ÅG                  #  List of Lucas numbers up to and including the input+1
    ¹å                #  Check if the input is in this list (1 if truthy; 0 if falsey)
      _               #  Invert the boolean (0→1 and 1→0)
 ¹ÅF                  #  List of Fibonacci numbers up to and including the input
    ¹åi               #  If the input is in this list:
       .•F_ïk|»9•     #   Push string "travisnessi" to the stack
    ë                 #  Else:
     .•?®B'5n•        #   Push string "pippilucas" to the stack
    }                 #  Close the inner if-else
     2ä               #  Split the string into two parts
                      #   i.e. "travisnessi" → ["travis","nessi"]
                      #   i.e. "pippilucas" → ["pippi","lucas"]
       sè             #  Index the Lucas result into the list of two strings
}                     # Close the outer if-else
 ™                    # And output the top of the stack in title-case