Ein Mann von den Sternen ist auf die Erde gekommen! Zum Glück hat der Präsident der Vereinigten Staaten, Donald Trump, einen unendlichen Tod. Mit diesem Würfel kann er eine Zahl heraufbeschwören, mit der Sie , der Bürgermeister von Podunk , bestimmen müssen, wer geschickt werden soll, um den Eindringling zu stoppen! Aber seien Sie vorsichtig, Sie können nur eine begrenzte Anzahl von Bytes auf die Rückseite Ihres Frosches senden !

Bei einer Benutzereingabe (bei der es sich um eine positive Ganzzahl handelt) müssen Sie abhängig von der Kategorie, in der sich die Zahl befindet, eine Zeichenfolge zurückgeben.

• Wenn die Zahl eine Fibonacci-Zahl ist , müssen Sie Ness ausgeben .
• Wenn die Nummer eine Lucas-Nummer ist , müssen Sie Lucas ausgeben .
• Wenn die Nummer sowohl eine Lucas-Nummer als auch eine Fibonacci-Nummer ist , müssen Sie Travis ausgeben .
• Wenn die Zahl weder aa Lucas Nummer noch eine Fibonacci - Zahl , müssen Sie Ausgabe Pippi .

Beispiele

Hier sind einige Testfälle:

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

Regeln

• Dies ist Code-Golf , die kürzeste Antwort in Bytes gewinnt.
• Ihr Programm kann ein vollständiges Programm oder eine (nicht anonyme) Funktion sein.

Boni

Es gibt ein paar Boni, mit denen Sie Ihrem Frosch helfen können, die Daten schneller zu Präsident Trump zu bringen:

• Für -15Bytes: Wenn die Eingabenummer ist 2016, müssen Sie ausgeben Trump, da er sich auf dem Höhepunkt seiner Präsidentschaft befindet.

Pyth, 59-15 = 44 Bytes

oder 42 Bytes nachdem ein Fehler behoben wurde

&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

Die ersten beiden Zeichen ( &Q) sind notwendig , weil ein Pyth Parsing Fehler, macht Qnach ."scheitern. Fix wurde angewendet. Wenn der Post-Bugfix-Interpreter zulässig ist, -2 Byte.

Ohne unlesbare String-Komprimierung:

Pyth, 63-15 = 48 Bytes

49 Bytes ohne Trump

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

Test Suite

Ganz einfach, erstellen Sie einfach die Sequenzen, duplizieren Sie eine und überprüfen Sie die Mitgliedschaft.

Sequenzen werden generiert, indem mit [1, 2]und begonnen [2, 1]wird und dann die Fibonacci-Regel angewendet wird.

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]

Dadurch wird eine unbenannte Funktion erstellt, die einen Booleschen Wert zurückgibt. Um es zu nennen, geben Sie ihm einen Namen, z 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

Problem behoben und 7 Bytes dank Glen O gespart!

Mathematica 143 156 - 15 (Bonus) = 141 Bytes

Mit 2 Bytes dank LegionMammal978 gespeichert.

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

Inspiriert von der Antwort von 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)]

Der Schlüssel sind zwei rein arithmetische Prüfungen für Fibonacci und Lucas Zahlen:

• nist eine Fibonacci-Zahl, genau wenn 5*n*n+4oder 5*n*n-4ist ein perfektes Quadrat
• nist eine Lucas-Zahl, genau wenn 5*n*n+20oder 5*n*n-20ist ein perfektes Quadrat

Diese Seite hat Beweisskizzen .

Die Ausgabe hängt also von den Werten von 5*n*n+ifor iin ab {4,-4,20,-20}. Die Funktion ftestet einen Wert von i, indem sie prüft, ob der entsprechende Wert keine ganze Quadratwurzel hat. Dies absdient nur dazu, einen Fehler bei der Wurzelbildung eines Negativs für zu vermeiden n=1, i=-20.

Die Funktion fübernimmt den Wert der nzu testenden Zahl aus STDIN. Python wertet dies nur einmal aus, nicht einmal pro Funktionsaufruf.

Ob die Zahl nicht Fibonacci ist, wird unter f(4)*f(-4)Verwendung der impliziten Umwandlung von Booleschen Werten in Zahlen und in ähnlicher Weise für Lucas nicht bewertet , und die entsprechende Zeichenfolge wird verwendet. Wenn nachfolgende Leerzeichen zulässig wären, wäre das String-Interleaving kürzer.

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

Für die Stringliste "Pippi Lucas Ness Travis".split()ist die Länge gleich.

CJam, 58 55 54 Bytes

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

Naiver Ansatz, die Fibonacci-und Lucas-Zahlen zu generieren, dann die Vorkommen in beiden zu zählen, in Binärdaten umzuwandeln und die entsprechende Zeichenfolge auszuwählen.

Probieren Sie es online aus .

Im Ernst, 69 Bytes

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

Vor dieser Herausforderung hatte Seriously das Builtin f(Index in Fibonacci-Nummern, -1, wenn keine Fibonacci-Nummer) ... aber kein Index in einer Liste oder "ist in Liste"! (Es ist seitdem als hinzugefügt worden í.)

Infolgedessen verbringe ich folgende Zeit damit, herauszufinden, ob die Eingabe eine Fibonacci-Zahl ist:

,                              f0≤

Das ist, was ich damit verbringe, eine Liste von Lucas-Nummern zu generieren:

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

Und das ist es, was ich damit verbringe, herauszufinden, ob die Eingabe in der Liste der Lucas-Zahlen enthalten ist:

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

Dies ist eine Zeichenfolge, die mit der% -Notation von Python in so etwas wie formatiert :610:=und in eine Funktion konvertiert wird, die dann über das Array gemappt und summiert wird. (Die Lucas-Zahlen sind eindeutig, die Summe ist also immer 0 oder 1.)

Vielen Dank an @Mego für das letzte Bit bei der String-Formatierung.

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

+1 Byte für das -nFlag.

$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

Mit Zeilenumbrüchen nach Semikolons zur besseren Lesbarkeit:

$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

Tricks:

• Sie fragen sich vielleicht, warum meine Variablen mit dem Namen $a, $b, $%, und $d. Das ist eine hervorragende Frage! In der Tat erlaubt es mir, ein Byte zu speichern.

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

  ist ein Byte kürzer als

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

  Dies gilt nicht mehr, da ich meinen Code durch Neuanordnen von Dingen golfen habe und die Änderung des Variablennamens dazu führte, dass keine Bytes mehr gespeichert wurden. Ich habe es zurückgesetzt, damit Variablennamen wieder Sinn machen.

• $_-2?$f+$l*2:3ist leicht interessant. Grundsätzlich musste ich 2für Lucas-Nummern einen Sonderfall machen, da mein Programm prüft, ob eine Nummer eine Lucas-Nummer ist, nachdem die Fibonacci- Nummer und die Lucas-Nummer "aktualisiert" wurden. So 2galt eine Nicht-Lucas-Nummer. $_-2?foo:barist ein Zeichen kürzer als $_==2?bar:foo. Das Gleiche wird für den 2016Test verwendet.

  Dies gilt auch nicht mehr, da ich das Programm so umstrukturieren konnte, dass keine Sondergehäuse erforderlich sind 2. Aber ich benutze $_-2016?stuff:Trumpstattdessen immer noch $_==2016?Trump:stuff, was ein Byte länger ist.

• Apropos, Sie fragen sich vielleicht, wie ich diese Umstrukturierung durchgeführt habe. Ich habe das Programm soeben dazu gebracht, 9-mal mehr Iterationen als nötig durchzuführen, was nur 2 Bytes ( *9) kostet, aber es mir ermöglicht, Annahmen zu treffen, die beim Golfspielen helfen.

• Da Variablen standardmäßig auf Null gesetzt sind,

  $f+=$_==$a

  ist kürzer als

  $f=1if$_==$a

• Perl unterstützt Barewords, daher muss ich keine meiner Zeichenfolgen (\ o /) angeben.

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

Oktave, 93 Bytes

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

Dieser Ansatz ähnelt meiner MATLAB-Antwort, mit der Ausnahme, dass Sie mit Octave direkt in ein neues Array indexieren können:

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

MATL (nicht konkurrierend), 57 55 54 (67-15) = 52 Bytes

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

Probieren Sie es online!

Erläuterung

Wieder eine ähnliche Logik wie meine anderen Antworten hier und hier .

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 mit Gebrauch. Ich kann eine Erklärung hinzufügen, wenn ich morgen darum gebeten werde, jetzt ins Bett zu gehen!

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

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

Gleiche Funktion für Fibonnacci und Lucas. Es ist eine rekursive Funktion, die die ersten beiden Werte als init verwendet.

Java, 151 Bytes

Man könnte argumentieren, dass Trump diese wichtige Entscheidung niemals auslagern würde, sodass wir die Methode nicht veröffentlichen müssten, um weitere 7 Bytes zu sparen.

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 inklusive Test-Hauptaufruf

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

}

Ich habe bis jetzt keine Möglichkeit gefunden, für 2016 zu testen und "Trump" in Code zurückzugeben, der weniger als 15 Byte Code enthält.

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

Probieren Sie es online!

Erläuterung

Nennen wir F(n)die n-te Fibonacci-Zahl und L(n)die n-te Lucas-Zahl.
a, bSind F(n-1), F(n)jeweils.
Dann können wir berechnen L(n) == F(n-1)+F(n+1) == 2*F(n-1) + F(n) == 2*a+b
Diese Funktion berechnet nacheinander die Zahlen von Fibonacci und Lucas bis nund prüft, ob neine davon vorliegt.
Wenn nes sich um eine Fibonacci-Nummer handelt, wird das 1. Bit von oauf gesetzt. 1
Wenn nes sich um eine Lucas-Nummer handelt, wird das 2. Bit von oauf gesetzt, 1
oum zu bestimmen, welcher Name ausgegeben werden soll

Bearbeiten

• 8 Bytes gespart, indem der Zustand der for-Schleife golfen wurde: ab der zweiten Iteration haben wir a<b<cund a<a+c=L(n), also ( b<=n || a+c<=n ) => a<n. Ich musste eigentlich a<=nrichtig damit umgehenn=1
• 4 Bytes gespart dank ceilingcat! (korrigierte auch einen Fehler, mein Code gab "2 => Ness" aus)
• 6 Bytes gespeichert:
  • 2 nochmals dank ceilingcat
  • 4 durch Entfernen der Variablen c, gleich F(n+1), was nutzlos war, da wir bereits F(n+1)mit aund rechnen könnenb

Perl 5.10, 119 - 15 (Bonus) = 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

Dies nutzt die Tatsache aus, dass

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

ist die größte Lucas-Zahl kleiner oder gleich 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)])}

Testcode:

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

gist ein Abschluss, der eine Liste von Zahlen basierend auf einem sStartwert ( m) und einem Maximalwert ( ) generiert . (g(i,[1,1]).contains(i)?1:0)+(g(i,[2,1]).contains(i)?2:0)Findet den zu verwendenden Index basierend auf der Zahl "Lucas" oder "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}))

Kurze Erklärung

Zuerst erstellen wir eine Zellenmatrix mit den Werten drucken: {'Pippi', 'Lucas', 'Ness', 'Travis'}. Um herauszufinden, welcher Wert angezeigt werden soll, prüfen wir, ob nes sich um eine Fibonacci-Zahl oder eine Lucas-Zahl handelt.

Für Fibonnaci verwenden wir die folgende Formel:

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

Diese prüft, ob entweder 5*n^2 + 4oder 5*n^2 - 4sind ein perfektes Quadrat. Wenn anyja, dann ist es eine Fibonacci-Zahl.

Die Formel für eine Lucas-Zahl ist sehr ähnlich, mit der Ausnahme, dass wir +/- 20 anstelle von 4 verwenden:

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

In dieser Lösung habe ich diese beiden Fälle mithilfe der Matrix zu einem zusammengefasst:

M = [-20 -4
      20  4]

Durch Anwenden der gleichen Gleichung wie oben, jedoch anyunter Berücksichtigung der ersten Dimension, erhalte ich ein logisches Array mit zwei Elementen, wobei, wenn das erste Element trueeine Lucas-Zahl ist und wenn das zweite Element trueeine Fibonacci-Zahl ist .

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

Um dann den Index in mein anfängliches Zellenarray zu berechnen, behandle ich dies als binäre Sequenz, indem ich eine elementweise Multiplikation dieses Booleschen mit [2^0, 2^1]oder einfach durchführe [1,2]. Und summiere die Elemente. Offensichtlich muss ich wegen MATLABs einseitiger Indizierung 1 hinzufügen.

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

Dann muss ich subsrefund substructin das anfängliche Zellenarray indizieren, um das Endergebnis zu erhalten.

JavaScript (ES6), 97 Byte

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

Die a==1Prüfung wird benötigt, da ich sonst nicht bemerke, dass 1 eine Lucas-Nummer ist.

Jelly , 47 Bytes - 15 = 32 (nicht konkurrierend ...?)

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

Probieren Sie es online!

05AB1E , 39 37 (52 - 15 Bonus) Bytes

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

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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