Człowiek z gwiazd ma przyjść na Ziemię! Na szczęście prezydent Stanów Zjednoczonych Donald Trump ma nieskończoną śmierć. Korzystając z tej kości, może wyczarować liczbę, którą ty , burmistrz Podunk , musisz użyć, aby ustalić, kto powinien zostać wysłany, aby zatrzymać najeźdźcę! Ale bądź ostrożny, możesz wysłać tylko ograniczoną liczbę bajtów z tyłu swojej żaby !

Biorąc pod uwagę dane wejściowe od użytkownika (która będzie dodatnią liczbą całkowitą), musisz zwrócić ciąg w zależności od kategorii, w której znajduje się liczba.

• Jeśli liczba jest liczbą Fibonacciego , musisz podać Ness .
• Jeśli liczba jest liczbą Lucas , musisz podać Lucas .
• Jeśli numer jest zarówno liczba Lucas i liczb Fibonacciego , należy wyjście Travis .
• Jeśli numer jest ani aa liczba Lucas ani liczb Fibonacciego , należy wyjście Pippi .

Przykłady

Oto kilka przypadków testowych:

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

Zasady

• To jest gra w golfa , wygrywa najkrótsza odpowiedź w bajtach.
• Twój program może być pełnym programem lub (anonimową) funkcją.

Bonusy

Istnieje kilka bonusów, których możesz użyć, aby pomóc swojej żabie szybciej przekazywać dane prezydentowi Trumpowi:

• W przypadku -15bajtów: jeśli liczbą wejściową jest 2016, musisz wyprowadzać dane Trump, ponieważ jest on u szczytu swojej prezydentury.

Pyth, 59-15 = 44 bajty

lub 42 bajty po naprawieniu błędu

&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

Pierwsze dwa znaki ( &Q) są konieczne ze względu na błąd analizowania Pyth, który pojawia się Qpo ."awarii. Poprawka została zastosowana. Jeśli interpreter po usunięciu błędu jest dozwolony, -2 bajty.

Bez nieczytelnej kompresji ciągów:

Pyth, 63-15 = 48 bajtów

49 bajtów bez Trumpa

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

Pakiet testowy

Całkiem proste, wystarczy wygenerować sekwencje, powielić jedną i sprawdzić członkostwo.

Sekwencje są generowane, zaczynając od [1, 2]i [2, 1], a następnie stosując regułę Fibonacciego.

Julia, 146 142 121 120 bajtów

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]

Tworzy to nienazwaną funkcję, która zwraca wartość logiczną. Aby to nazwać, nadaj mu nazwę, np f=n->....

Nie golfowany:

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

Naprawiono problem i zapisano 7 bajtów dzięki Glen O!

Mathematica 143 156-15 (bonus) = 141 bajtów

Z 2 bajtami zapisanymi dzięki 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 bajtów

Zainspirowany odpowiedzią 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)]

Kluczem są dwa czysto arytmetyczne kontrole liczb Fibonacciego i Lucasa:

• njest liczbą Fibonacciego dokładnie czy 5*n*n+4czy 5*n*n-4jest kwadratem
• njest liczbą Lucas dokładnie czy 5*n*n+20czy 5*n*n-20jest kwadratem

Ta strona ma szkice próbne .

Zatem wynik zależy od wartości 5*n*n+ifor iw {4,-4,20,-20}. Funkcja fsprawdza wartość i, sprawdzając, czy odpowiadająca jej wartość nie ma pierwiastka kwadratowego z liczby całkowitej. Ma absto na celu uniknięcie błędu polegającego na przyjęciu pierwiastka z wartości ujemnej n=1, i=-20.

Funkcja fpobiera wartość liczby ndo przetestowania ze STDIN. Python ocenia to tylko raz, a nie raz na wywołanie funkcji.

To, czy liczba nie jest Fibonacciego, jest oceniane jako f(4)*f(-4)użycie niejawnej konwersji wartości logicznej na liczbę i podobnie nie dla Lucasa, i brany jest odpowiedni ciąg. Gdyby dozwolone były spacje końcowe, przeplatanie ciągów byłoby krótsze.

Python 2, 117 bajtów

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

Dla listy ciągów "Pippi Lucas Ness Travis".split()ta sama długość.

CJam, 58 55 54 bajtów

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

Naiwne podejście do generowania liczb Fibonacciego i Lucasa, a następnie liczenie wystąpień w obu przypadkach, konwertowanie na binarne i wybieranie odpowiedniego ciągu.

Wypróbuj online .

Poważnie, 69 bajtów

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

Przed tym wyzwaniem Poważnie miał wbudowane f(indeks liczb Fibonacciego, -1 jeśli nie liczba Fibonacciego) ... ale nie indeks na liście lub „jest na liście”! (Od tego czasu został dodany jako í.)

W rezultacie wydaje mi się to, czy dane wejściowe to liczba Fibonacciego:

,                              f0≤

Oto, co spędzam, generując listę liczb Lucasa:

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

I to właśnie spędzam na poszukiwaniu, czy dane wejściowe znajdują się na liście liczb Lucasa:

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

Jest to ciąg formatowany za pomocą notacji% Pythona w coś podobnego :610:=i konwertowany na funkcję, która jest następnie mapowana na tablicę i sumowana. (Liczby Lucas są unikalne, więc suma wynosi zawsze 0 lub 1.)

Dzięki @Mego za ten ostatni bit z formatowaniem łańcucha.

Perl, 133 (146-15 =) 131 (144-15 =) 129 (136-15 =) 121 bajtów

+1 bajt dla -nflagi.

$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

Z nowymi wierszami po średnikach, dla czytelności:

$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

Próbny:

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

Wydziwianie:

• Można się zastanawiać, dlaczego moje zmienne są nazwane $a, $b, $%, i $d. To doskonałe pytanie! W rzeczywistości pozwala mi to zapisać bajt.

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

  jest o jeden bajt krótszy niż

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

  Nie ma to już zastosowania, ponieważ zmieniłem kod w golfa, zmieniając układ rzeczy, powodując, że zmiana nazwy zmiennej nie zapisuje już bajtów. Zmieniłem to z powrotem, aby nazwy zmiennych znów miały sens.

• $_-2?$f+$l*2:3jest raczej interesujący. Zasadniczo musiałem wprowadzić specjalny przypadek 2dla liczb Lucasa, ponieważ mój program sprawdza, czy liczba jest liczbą Lucasa po „aktualizacji” liczb Fibonacciego i Lucasa. Tak więc 2uznano go za liczbę inną niż Lucas. $_-2?foo:barjest char krótszy niż $_==2?bar:foo. To samo służy do 2016testu.

  Nie jest to już prawdą, ponieważ udało mi się zrestrukturyzować program tak, aby nie wymagał specjalnej obudowy 2. Ale nadal używam $_-2016?stuff:Trumpzamiast $_==2016?Trump:stuff, który jest o jeden bajt dłuższy.

• Mówiąc o tym, być może zastanawiasz się, jak przeprowadziłem tę restrukturyzację. Właśnie zmusiłem program do wykonania 9 razy więcej iteracji, niż to konieczne, co kosztuje tylko 2 bajty ( *9), ale pozwala mi na dokonywanie założeń gdzie indziej, które pomagają w golfie.

• Ponieważ zmienne mają domyślnie zero,

  $f+=$_==$a

  jest krótszy niż

  $f=1if$_==$a

• Perl obsługuje słowa bez słów, więc nie muszę cytować żadnego z moich ciągów (\ o /).

Julia, 101 100 bajtów

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

Nie golfowany:

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

Oktawa, 93 bajty

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

To podejście jest podobne do mojej odpowiedzi MATLAB, z tym wyjątkiem, że Octave pozwala na indeksowanie bezpośrednio do nowej tablicy:

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

MATL (niekonkurencyjny), 57 55 54 (67-15) = 52 bajty

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

Wypróbuj online!

Wyjaśnienie

Znów podobna logika do moich innych odpowiedzi tu i tutaj .

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

Nieprzyzwyczajony do użytkowania. Mogę dodać wyjaśnienie, jeśli jutro zostanie o to poproszony, gtg do łóżka już teraz!

#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 bajtów

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

Ta sama funkcja dla Fibonnacciego i Lucasa. Jest to funkcja rekurencyjna, która przyjmuje dwie pierwsze wartości jako init.

Java, 151 bajtów

Można argumentować, że Trump nigdy nie zleciłby tej kluczowej decyzji, więc nie musielibyśmy upubliczniać tej metody, oszczędzając kolejne 7 bajtów.

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

Niegolfowany, w tym wywołanie testu głównego

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

}

Jak dotąd nie znalazłem sposobu na przetestowanie w 2016 roku i zwrócenie „Trump” w kodzie, który ma mniej niż 15 bajtów w kodzie.

C (gcc) ,  128   120   116  110 bajtów

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

Wypróbuj online!

Wyjaśnienie

Nazwijmy F(n)n-tą liczbę Fibonacciego i L(n)n-tą liczbę Lucasa.
a, bSą F(n-1), F(n)odpowiednio.
Następnie możemy obliczyć L(n) == F(n-1)+F(n+1) == 2*F(n-1) + F(n) == 2*a+b
Ta funkcja będzie kolejno obliczać liczby Fibonacciego i Lucasa, aż do n, i sprawdzi, czy nktórykolwiek z nich.
Jeśli njest liczbą Fibonacciego, pierwszy bit ozostanie ustawiony na 1
Jeśli njest liczbą Lucas, drugi bit ozostanie ustawiony na 1
o, a następnie zostanie użyty do określenia, która nazwa ma zostać wyprowadzona

Edytować

• Zaoszczędziliśmy 8 bajtów, grając w golfa w warunku pętli for: zaczynając od drugiej iteracji, mamy a<b<ci a<a+c=L(n)tak dalej ( b<=n || a+c<=n ) => a<n. Naprawdę potrzebowałem a<=npoprawnie obsługiwaćn=1
• Zaoszczędzono 4 bajty dzięki pułapowi cat! (poprawiłem także błąd, mój kod wyświetlał „2 => Ness”)
• Zapisano 6 bajtów:
  • 2 jeszcze raz dzięki ceilingcat
  • 4 poprzez usunięcie zmiennej crównej F(n+1), co było bezużyteczne, ponieważ możemy już obliczyć za F(n+1)pomocą aib

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

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

Nie golfowany:

# 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

Wykorzystuje to fakt, że

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

jest największą liczbą Lucasa niższą lub równą F (n).

Groovy, 149 bajtów

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

Kod testowy:

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

gjest zamknięciem, które generuje listę liczb na podstawie seed ( s) i wartości maksymalnej ( m). (g(i,[1,1]).contains(i)?1:0)+(g(i,[2,1]).contains(i)?2:0)znajduje indeks do użycia na podstawie liczby lucas lub fibonacci.

MATLAB, 122 119 bajtów

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

Krótkie wyjaśnienie

My najpierw utworzyć tablicę zawierającą wartości komórek do wydrukowania: {'Pippi', 'Lucas', 'Ness', 'Travis'}. Następnie, aby dowiedzieć się, którą wartość wyświetlić, sprawdzamy, czy njest to liczba Fibonacciego czy Lucasa.

W przypadku Fibonnaci stosujemy następującą formułę:

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

To sprawdza, czy albo 5*n^2 + 4czy 5*n^2 - 4są idealnym kwadratem. Jeśli anyz nich są, to jest to liczba Fibonacciego.

Wzór na liczbę Lucasa jest bardzo podobny, z tym wyjątkiem, że używamy +/- 20 zamiast 4:

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

W tym rozwiązaniu połączyłem te dwa przypadki w jeden przy użyciu macierzy:

M = [-20 -4
      20  4]

Stosując to samo równanie jak powyższe, ale zmuszając anydo rozważenia tylko pierwszego wymiaru, otrzymuję dwuelementową logiczną tablicę, w której jeśli pierwszym elementem jest true, to jest to liczba Lucasa, a jeśli drugim elementem jest trueliczba Fibonacciego .

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

Następnie, aby obliczyć indeks do mojej początkowej tablicy komórek, traktuję to jako sekwencję binarną, wykonując mnożenie elementarne tego logicznego za pomocą [2^0, 2^1]lub po prostu [1,2]. I zsumuj elementy. Oczywiście muszę dodać 1 z powodu indeksowania opartego na jednym pliku MATLAB.

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

Następnie muszę użyć subsrefi substructzaindeksować do początkowej tablicy komórek, aby uzyskać końcowy wynik.

JavaScript (ES6), 97 bajtów

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==1Wyboru jest potrzebny inny sposób nie zauważyć, że 1 jest liczbą Lucas.

Galaretka , 47 bajtów - 15 = 32 (niekonkurujące ...?)

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

Wypróbuj online!

05AB1E , 39 37 ( 52–15 premii) bajtów

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

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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