Un homme des étoiles est venu sur Terre! Heureusement, le président des États-Unis, Donald Trump, a un dé à l'infini. En utilisant ce dé, il peut créer un numéro que vous , le maire de Podunk , devrez utiliser pour déterminer qui doit être envoyé pour arrêter l'envahisseur! Mais attention, vous ne pouvez envoyer qu'un nombre limité d'octets au dos de votre grenouille !

Étant donné une entrée utilisateur (qui sera un entier positif), vous devez renvoyer une chaîne en fonction de la catégorie dans laquelle se trouve le nombre.

• Si le nombre est un nombre de Fibonacci , vous devez générer Ness .
• Si le nombre est un nombre Lucas , vous devez sortir Lucas .
• Si le numéro est à la fois un numéro Lucas et un numéro Fibonacci , vous devez générer Travis .
• Si le numéro n'est ni un numéro Lucas ni un numéro Fibonacci , vous devez sortir Pippi .

Exemples

Voici un tas de cas de test:

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

Règles

• C'est code-golf , la réponse la plus courte en octets gagne.
• Votre programme peut être un programme complet ou une fonction (n anonyme).

Bonus

Il y a quelques bonus que vous pouvez utiliser pour aider votre grenouille à transmettre les données au président Trump plus rapidement:

• Pour les -15octets: si le nombre entré est 2016, vous devez sortir Trump, car il est au sommet de sa présidence.

Pyth, 59 - 15 = 44 octets

ou 42 octets après la correction d'un bogue

&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

Les deux premiers caractères ( &Q) sont nécessaires en raison d’un bogue d’analyse Pyth qui échoue Qaprès .". Le correctif a été appliqué. Si l'interpréteur post-correctif est autorisé, -2 octets.

Sans compression de chaîne illisible:

Pyth, 63 - 15 = 48 octets

49 octets sans atout

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

Suite de tests

Assez simple, il suffit de générer les séquences, de les dupliquer et de vérifier leur appartenance.

Les séquences sont générées en commençant par [1, 2]et [2, 1], puis en appliquant la règle de fibonacci.

Julia, 146 142 121 120 octets

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]

Cela crée une fonction sans nom qui renvoie un booléen. Pour l'appeler, donnez-lui un nom, par exemple f=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

Correction d'un problème et enregistrement de 7 octets grâce à Glen O!

Mathematica 143 156 - 15 (bonus) = 141 octets

Avec 2 octets sauvegardés grâce à 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 octets

Inspiré par la réponse de 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)]

La clé est deux contrôles purement arithmétiques pour les nombres de Fibonacci et Lucas:

• nest un nombre de Fibonacci exactement si 5*n*n+4ou 5*n*n-4est un carré parfait
• nest un nombre Lucas exactement si 5*n*n+20ou 5*n*n-20est un carré parfait

Ce site a des sketches .

La sortie dépend donc des valeurs de 5*n*n+ifor iin {4,-4,20,-20}. La fonction fteste une valeur de i, en vérifiant si la valeur correspondante n'a pas de racine carrée de nombre entier.abs y a juste là pour éviter une erreur de prendre la racine d'un négatif pour n=1, i=-20.

La fonction f prend la valeur du nombre nà tester à partir de STDIN. Python ne l’évalue qu’une fois, pas une fois par appel de fonction.

Si le nombre n'est pas Fibonacci est évalué comme f(4)*f(-4)utilisant la conversion implicite booléen en nombre et de la même manière pour pas Lucas, et la chaîne correspondante est prise. Si les espaces de fin étaient autorisés, l'entrelacement des chaînes serait plus court.

Python 2, 117 octets

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

Pour la liste de chaînes, a "Pippi Lucas Ness Travis".split()la même longueur.

CJam, 58 55 54 octets

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

Une approche naïve consistant à générer les nombres de Fibonacci et de Lucas, puis à compter les occurrences dans les deux cas, à convertir en binaire et à sélectionner la chaîne appropriée.

Essayez-le en ligne .

Sérieusement, 69 octets

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

Avant ce défi, Sérieusement avait le construit f (index dans les nombres de Fibonacci, -1 sinon un nombre de Fibonacci) ... mais pas dans une liste ou "est dans la liste"! (Il a été ajouté depuis í.)

En conséquence, voici ce que je passe à chercher si l'entrée est un nombre de Fibonacci:

,                              f0≤

C'est ce que je passe à générer une liste de numéros Lucas:

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

Et voici ce que je passe à chercher si l'entrée est dans la liste des nombres de Lucas:

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

C'est une chaîne formatée à l'aide de la notation% Python en quelque chose comme :610:=, et convertie en une fonction, qui est ensuite mappée sur le tableau et sommée. (Les nombres Lucas sont uniques, la somme est toujours égale à 0 ou 1.)

Merci à @Mego pour ce dernier bit avec le formatage de chaîne.

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

+1 octet pour le -ndrapeau.

$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

Avec des retours à la ligne après le point-virgule, par souci de lisibilité:

$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

Démo:

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

Des trucs:

• Vous pourriez vous demander pourquoi mes variables sont nommées $a, $b, $%et $d. C'est une excellente question! En fait, cela me permet de sauvegarder un octet.

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

  est un octet plus court que

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

  Cela ne s'applique plus parce que j'ai modifié mon code en réarrangeant les choses, empêchant ainsi le changement de nom de variable de sauvegarder des octets. Je l'ai changé pour que les noms de variables aient à nouveau un sens.

• $_-2?$f+$l*2:3est légèrement intéressant. En gros, je devais utiliser des cas particuliers 2pour les numéros Lucas, car mon programme vérifie si un numéro est un numéro Lucas après avoir "mis à jour" les numéros de Fibonacci et Lucas. Ainsi a 2été considéré un nombre non-Lucas $_-2?foo:barest un omble plus court que $_==2?bar:foo. La même chose est utilisée pour le2016 test.

  Cela n’est plus vrai non plus parce que j’ai pu restructurer le programme de manière à ne pas exiger de cas spécial 2. Mais j'utilise toujours $_-2016?stuff:Trumpau lieu de $_==2016?Trump:stuff, qui est un octet de plus.

• En parlant de cela, vous vous demandez peut-être comment j'ai procédé à cette restructuration. Je viens de faire que le programme fasse 9 fois plus d'itérations que nécessaire, ce qui ne coûte que 2 octets ( *9) mais me permet de faire des suppositions ailleurs qui aident le terrain de golf.

• Parce que les variables par défaut à zéro,

  $f+=$_==$a

  est plus court que

  $f=1if$_==$a

• Perl supporte les mots nus, je n'ai donc pas besoin de citer mes chaînes (\ o /).

Julia, 101 à 100 octets

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

Octave, 93 octets

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

Cette approche est similaire à ma réponse MATLAB à l'exception du fait qu'Octave vous permet d'indexer directement dans un nouveau tableau:

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

MATL (non compétitif), 57 55 54 (67-15) = 52 octets

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

Essayez-le en ligne!

Explication

Encore une fois, logique similaire à mes autres réponses ici et ici .

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 avec l'utilisation. Je peux ajouter une explication si demandé demain, gtg au lit maintenant!

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

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

Même fonction pour Fibonnacci et Lucas. C'est une fonction récursive qui prend les deux premières valeurs comme init.

Java, 151 octets

Vous pourriez prétendre que Trump n'externaliserait jamais cette décision cruciale, de sorte que nous n'aurions pas à rendre la méthode publique, ce qui permettrait d'économiser 7 octets supplémentaires.

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 y compris invocation test-main

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

}

Jusqu'à présent, je n'ai trouvé aucun moyen de tester pour 2016 et de renvoyer "Trump" dans un code inférieur à 15 octets.

C (gcc) ,  128   120   116  110 octets

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

Essayez-le en ligne!

Explication

Appelons le F(n)nième nombre de Fibonacci et L(n)le nième nombre de Lucas.
a, bsont F(n-1), F(n)respectivement.
Ensuite, nous pouvons calculer L(n) == F(n-1)+F(n+1) == 2*F(n-1) + F(n) == 2*a+b
Cette fonction calcule successivement les nombres de Fibonacci et de Lucas, jusqu’à n, et vérifie s’il en nest.
Si nest un numéro de Fibonacci, le premier bit de osera défini sur 1
Si nest un nombre de Lucas, le deuxième bit de osera défini sur1
o sera ensuite utilisé pour déterminer quel nom sortie

modifier

• Sauvegardé 8 octets en jouant au golf la condition de la boucle for: à partir de la deuxième itération, nous avons a<b<cet a<a+c=L(n), donc ( b<=n || a+c<=n ) => a<n. J'ai réellement besoin a<=nde gérer correctementn=1
• 4 octets sauvés grâce à ceilingcat! (corrige également une erreur, mon code donnait "2 => Ness")
• Enregistré 6 octets:
  • 2 grâce à ceilingcat à nouveau
  • 4 en supprimant la variable cégale à F(n+1), ce qui était inutile puisque nous pouvons déjà calculer F(n+1)avec aetb

Perl 5.10, 119 - 15 (bonus) = 104 octets

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

Cela exploite le fait que

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

est le plus grand nombre de Lucas inférieur ou égal à F (n).

Groovy, 149 octets

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

Code de test:

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

gest une fermeture qui génère une liste de nombres basée sur un seed ( s) et une valeur max ( m).(g(i,[1,1]).contains(i)?1:0)+(g(i,[2,1]).contains(i)?2:0)trouve l'index à utiliser en fonction du nombre lucas ou fibonacci.

MATLAB, 122 119 octets

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

Brève explication

Nous créons d’abord un tableau de cellules contenant les valeurs à imprimer: {'Pippi', 'Lucas', 'Ness', 'Travis'} . Ensuite, pour déterminer la valeur à afficher, nous vérifions s’il ns’agit d’un nombre de Fibonacci ou de Lucas.

Pour Fibonnaci, nous utilisons la formule suivante:

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

Ceci vérifie si soit 5*n^2 + 4 ou l'5*n^2 - 4 est un carré parfait. Siany tel est le cas, il s'agit d'un numéro de Fibonacci.

La formule pour un numéro Lucas est très similaire à l'exception que nous utilisons +/- 20 au lieu de 4:

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

Dans cette solution, j'ai combiné ces deux cas en un seul en utilisant la matrice:

M = [-20 -4
      20  4]

En appliquant la même équation que celles ci-dessus, mais en ne prenant anyen compte que la première dimension, j'obtiens un tableau logique à deux éléments où, si le premier élément est true, il s'agit d'un nombre de Lucas et si le deuxième élément est true, il s'agit d'un nombre de Fibonacci. .

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

Ensuite, pour calculer l'index dans mon tableau de cellules initial, je le traite comme une séquence binaire en effectuant une multiplication élément par élément de ce booléen avec [2^0, 2^1]ou simplement [1,2]. Et résumer les éléments. Évidemment, je dois ajouter 1 en raison de l'indexation à une base de MATLAB.

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

Ensuite, je dois utiliser subsrefet substructindexer dans le tableau de cellules initial pour obtenir le résultat final.

JavaScript (ES6), 97 octets

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

Le a==1chèque est nécessaire sinon je ne remarque pas que 1 est un numéro Lucas.

Gelée , 47 octets - 15 = 32 (non compétitif ...?)

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

Essayez-le en ligne!

05AB1E , 39 37 (52 - 15 bonus) octets

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

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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