Um homem das estrelas chegou à Terra! Felizmente, o presidente dos Estados Unidos, Donald Trump, tem um dado infinito. Usando esse dado, ele pode conjurar um número que você , o prefeito de Podunk , deve usar para determinar quem deve ser enviado para impedir o invasor! Mas tenha cuidado, você só pode enviar uma quantidade limitada de bytes na parte de trás do seu sapo !

Dada uma entrada do usuário (que será um número inteiro positivo), você deve retornar uma string, dependendo da categoria em que o número estiver.

• Se o número for um número de Fibonacci , você deverá enviar o Ness .
• Se o número for um número de Lucas , você deverá gerar a saída de Lucas .
• Se o número é tanto um número Lucas e um número de Fibonacci , você deve saída Travis .
• Se o número é nem aa número Lucas , nem um número de Fibonacci , você deve saída Pippi .

Exemplos

Aqui estão alguns casos de teste:

1 => Travis
2 => Travis
3 => Travis
4 => Lucas
5 => Ness
6 => Pippi
7 => Lucas
8 => Ness
610 => Ness
722 => Pippi
843 => Lucas

Regras

• Isso é código-golfe , a resposta mais curta em bytes vence.
• Seu programa pode ser um programa completo ou uma função (n anônima).

Bónus

Existem alguns bônus que você pode usar para ajudar seu sapo a enviar os dados ao presidente Trump mais rapidamente:

• Para -15bytes: se o número de entrada for 2016, você deve enviar Trump, pois ele está no auge de sua presidência.

Pitão, 59 - 15 = 44 bytes

ou 42 bytes após a correção de um bug

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

Hexdump:

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

Os dois primeiros caracteres ( &Q) são necessários devido a um erro de análise Pyth que ocorre Qapós a ."falha. Correção foi aplicada. Se o interpretador pós-correção de bug for permitido, -2 bytes.

Sem compressão de string ilegível:

Pitão, 63 - 15 = 48 bytes

49 bytes sem Trump

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

Suíte de teste

Bem simples, basta gerar as seqüências, duplicar uma e verificar a associação.

As sequências são geradas iniciando com [1, 2]e [2, 1], e depois aplicando a regra de fibonacci.

Julia, 146 142 121 120 bytes

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]

Isso cria uma função sem nome que retorna um booleano. Para chamá-lo, dê um nome, por exemplof=n->... .

Ungolfed:

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

Corrigido um problema e economizado 7 bytes graças ao Glen O!

Mathematica 143 156-15 (bônus) = 141 bytes

Com 2 bytes salvos, graças a LegionMammal978.

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 bytes

Inspirado pela resposta do Sp3000 .

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

Python 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)]

A chave é duas verificações puramente aritméticas dos números de Fibonacci e Lucas:

• né um número de Fibonacci exatamente se 5*n*n+4ou 5*n*n-4é um quadrado perfeito
• né um número de Lucas exatamente se 5*n*n+20ou 5*n*n-20é um quadrado perfeito

Este site tem esboços de provas .

Portanto, a saída depende dos valores de 5*n*n+ifor iin {4,-4,20,-20}. A função ftesta um valor de i, verificando se o valor correspondente não possui uma raiz quadrada de número inteiro. absExiste apenas para evitar um erro de obter a raiz negativa de n=1, i=-20.

A função fpega o valor do número npara testar a partir de STDIN. O Python avalia isso apenas uma vez, não uma vez por chamada de função.

Se o número não é Fibonacci, é avaliado como f(4)*f(-4)usando a conversão implícita de booleano para número e de forma semelhante para não Lucas, e a sequência correspondente é obtida. Se espaços à direita fossem permitidos, a intercalação de cordas seria mais curta.

Python 2, 117 bytes

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)]

Para a lista de cadeias, "Pippi Lucas Ness Travis".split()é o mesmo comprimento.

CJam, 58 55 54 bytes

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

Abordagem ingênua de gerar os números de Fibonacci e Lucas e depois contar as ocorrências em ambos, converter em binário e escolher a sequência apropriada.

Experimente online .

Sério, 69 bytes

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

Antes desse desafio, o Seriamente possuía o fíndice interno (índice em números de Fibonacci, -1 se não for um número de Fibonacci) ... mas não o índice em uma lista ou "está na lista"! (Desde então, foi adicionado como í.)

Como resultado, é isso que gasto descobrindo se a entrada é um número de Fibonacci:

,                              f0≤

É isso que gasto gerando uma lista de números de Lucas:

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

E é isso que gasto descobrindo se a entrada está na lista de números de Lucas:

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

Essa é uma string sendo formatada usando a notação% Python em algo parecido :610:=e convertida em uma função, que é mapeada sobre o array e somada. (Os números de Lucas são únicos, portanto, a soma é sempre 0 ou 1.)

Obrigado ao @Mego pelo último bit com a formatação da string.

Perl, 133 (146-15 =) 131 (144-15 =) 129 (136-15 =) 121 bytes

+1 byte para o -nsinalizador.

$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

Com novas linhas após ponto e vírgula, para facilitar a leitura:

$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

Demo:

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

Truques:

• Você pode estar se perguntando por que meus variáveis são nomeados $a, $b, $%, e $d. Essa é uma excelente questão! De fato, isso me permite salvar um byte.

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

  é um byte menor que

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

  Isso não se aplica mais porque eu joguei meu código reorganizando as coisas, fazendo com que a alteração do nome da variável não salvasse mais bytes. Eu mudei de volta para que os nomes das variáveis ​​fizessem sentido novamente.

• $_-2?$f+$l*2:3é levemente interessante. Basicamente, eu tive um caso especial 2para os números de Lucas porque meu programa verifica se um número é um número de Lucas depois de "atualizar" os números de Fibonacci e Lucas. Então 2foi considerado um número não-Lucas. $_-2?foo:baré um caractere mais curto que $_==2?bar:foo. A mesma coisa é usada para o2016 teste.

  Isso também não é mais verdade porque pude reestruturar o programa para não exigir um revestimento especial 2. Mas ainda uso em $_-2016?stuff:Trumpvez de $_==2016?Trump:stuff, que é um byte a mais.

• Falando nisso, você pode estar se perguntando como eu fiz essa reestruturação. Acabei de fazer o programa fazer 9 vezes mais iterações do que o necessário, o que custa apenas 2 bytes ( *9), mas me permite fazer suposições em outros lugares que ajudam a resolver problemas do golfe.

• Como as variáveis ​​padrão são zero,

  $f+=$_==$a

  é mais curto que

  $f=1if$_==$a

• O Perl suporta palavras de barra, por isso não preciso citar nenhuma das minhas strings (\ o /).

Julia, 101 100 bytes

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

Ungolfed:

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

Oitava, 93 bytes

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

Essa abordagem é semelhante à minha resposta do MATLAB com a exceção de que o Octave permite indexar diretamente em uma nova matriz:

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

MATL (Não Competente), 57 55 54 (67-15) = 52 bytes

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

Experimente Online!

Explicação

Novamente, lógica semelhante às minhas outras respostas aqui e aqui .

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

Ungolfed com uso. Posso adicionar uma explicação, se solicitado amanhã, GTG para a cama agora!

#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 bytes

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')

Mesma função para Fibonnacci e Lucas. É uma função recursiva que aceita os dois primeiros valores como init.

Java, 151 bytes

Você poderia argumentar que Trump nunca terceirizaria essa decisão crucial, para que não precisássemos tornar o método público, economizando outros 7 bytes.

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

Ungolfed incluindo a chamada principal de teste

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

}

Até agora, não encontrei nenhuma maneira de testar em 2016 e retornar "Trump" em código com menos de 15 bytes.

C (gcc) ,  128   120   116  110 bytes

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

Experimente online!

Explicação

Vamos citar F(n) o n-ésimo número de Fibonacci e L(n)o n-ésimo número de Lucas.
a, bsão F(n-1), F(n)respectivamente.
Em seguida, podemos calcular L(n) == F(n-1)+F(n+1) == 2*F(n-1) + F(n) == 2*a+b
Esta função calculará sucessivamente os números de Fibonacci e Lucas, até n, e verificará se nhá algum deles.
Se nfor um número de Fibonacci, o 1º bit oserá definido como 1
Se nfor um número de Lucas, o 2º bit oserá definido como1
o será usado para determinar qual nome será emitido

Editar

• Economizados 8 bytes, alterando a condição do loop for: a partir da segunda iteração, temos a<b<ce a<a+c=L(n), portanto ( b<=n || a+c<=n ) => a<n. Eu realmente precisavaa<=n lidar corretamenten=1
• Economizou 4 bytes graças ao ceilingcat! (também corrigi um erro, meu código estava emitindo "2 => Ness")
• 6 bytes salvos:
  • 2 graças a ceilingcat novamente
  • 4 removendo a variável cigual a F(n+1)que era inútil, pois já podemos calcular F(n+1)com aeb

Perl 5.10, 119 - 15 (bônus) = 104 bytes

$_=<>;$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

Ungolfed:

# 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

Isso explora o fato de que

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

é o maior número de Lucas menor ou igual a F (n).

Groovy, 149 bytes

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

Código do teste:

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

gé um fechamento que gera uma lista de números com base em uma semente ( s) e um valor máximo ( m). (g(i,[1,1]).contains(i)?1:0)+(g(i,[2,1]).contains(i)?2:0)localiza o índice a ser usado com base no número sendo lucas ou fibonacci.

MATLAB, 122 119 bytes

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

Breve explicação

Primeiro criamos uma matriz de células contendo os valores para imprimir: {'Pippi', 'Lucas', 'Ness', 'Travis'}. Em seguida, para descobrir qual valor exibir, verificamos sen é um número de Fibonacci ou Lucas.

Para Fibonnaci, usamos a seguinte fórmula:

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

Isso verifica se um quadrado é perfeito 5*n^2 + 4ou 5*n^2 - 4não. E seany eles são, então é um número de Fibonacci.

A fórmula para um número de Lucas é muito semelhante, com exceção de que usamos +/- 20 em vez de 4:

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

Nesta solução, combinei esses dois casos em um usando a matriz:

M = [-20 -4
      20  4]

Ao aplicar a mesma equação acima, mas forço anya considerar apenas a primeira dimensão, recebo uma matriz lógica de dois elementos em que se o primeiro elemento for true, então é um número de Lucas e se o segundo elemento for true, é um número de fibonacci .

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

Em seguida, para calcular o índice em minha matriz inicial de células, trato isso como uma sequência binária executando a multiplicação por elementos deste booleano com [2^0, 2^1]ou simplesmente [1,2]. E somar os elementos. Obviamente, tenho que adicionar 1 por causa da indexação baseada em MATLAB.

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

Então eu tenho que usar subsrefe substructindexar na matriz de células inicial para obter o resultado final.

JavaScript (ES6), 97 bytes

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 a==1verificação é necessária, caso contrário, não percebo que 1 é um número de Lucas.

Gelatina , 47 bytes - 15 = 32 (não concorrente ...?)

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

Experimente online!

05AB1E , 39 37 bytes (52 - 15 bônus)

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

Experimente online ou verifique todos os casos de teste .

Explicação:

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