Un uomo dalle stelle è arrivato sulla Terra! Fortunatamente il presidente degli Stati Uniti, Donald Trump, ha un dado a faccia infinita. Usando questo dado, può evocare un numero che tu , il sindaco di Podunk , devi usare per determinare chi dovrebbe essere inviato per fermare l'invasore! Ma fai attenzione, puoi solo inviare un numero limitato di byte sul retro della tua rana !

Dato un input dell'utente (che sarà un numero intero positivo), è necessario restituire una stringa in base alla categoria in cui si trova il numero.

• Se il numero è un numero di Fibonacci , è necessario emettere Ness .
• Se il numero è un numero Lucas , è necessario generare Lucas .
• Se il numero è sia un numero di Lucas che un numero di Fibonacci , è necessario generare Travis .
• Se il numero non è né un numero Lucas né un numero Fibonacci , è necessario generare Pippi .

Esempi

Ecco un sacco di casi di test:

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

Regole

• Questo è code-golf , vince la risposta più breve in byte.
• Il programma può essere un programma completo o una funzione (n anonima).

bonus

Ci sono un paio di bonus che puoi usare per aiutare la tua rana a portare i dati al presidente Trump più velocemente:

• Per i -15byte: se il numero di input è 2016, è necessario eseguire l'output Trump, poiché è all'apice della sua presidenza.

Pyth, 59-15 = 44 byte

o 42 byte dopo la correzione di un 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

I primi due caratteri ( &Q) sono necessari a causa di un bug di analisi Pyth che fa Qdopo il ."fallimento. È stata applicata la correzione. Se l'interprete post-bugfix è consentito, -2 byte.

Senza compressione stringibile illeggibile:

Pyth, 63-15 = 48 byte

49 byte senza Trump

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

Test Suite

Abbastanza semplice, basta generare le sequenze, duplicarne una e verificare l'appartenenza.

Le sequenze vengono generate iniziando con [1, 2]e [2, 1], quindi applicando la regola fibonacci.

Julia, 146 142 121 120 byte

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]

Questo crea una funzione senza nome che restituisce un valore booleano. Per chiamarlo, dagli un nome, ad es 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

Risolto un problema e salvato 7 byte grazie a Glen O!

Mathematica 143156-15 (bonus) = 141 byte

Con 2 byte salvati grazie 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 byte

Ispirato dalla risposta di 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 chiave sono due controlli puramente aritmetici per i numeri di Fibonacci e Lucas:

• nè un numero di Fibonacci esattamente se 5*n*n+4o 5*n*n-4è un quadrato perfetto
• nè un numero di Lucas esattamente se 5*n*n+20o 5*n*n-20è un quadrato perfetto

Questo sito ha bozze di prova .

Quindi, l'output dipende dai valori di 5*n*n+ifor iin {4,-4,20,-20}. La funzionef verifica un valore di i, controllando se il valore corrispondente non ha una radice quadrata di numero intero absÈ lì solo per evitare un errore nel prendere la radice di un negativo per n=1, i=-20.

La funzione fprende il valore del numero nda testare da STDIN. Python lo valuta solo una volta, non una volta per chiamata di funzione.

Se il numero non è Fibonacci viene valutato come f(4)*f(-4)usando la conversione implicita da booleano a numero e similmente per non Lucas, e viene presa la stringa corrispondente. Se fossero consentiti spazi finali, l'interlacciamento delle stringhe sarebbe più breve.

Python 2, 117 byte

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

Per l'elenco di stringhe, "Pippi Lucas Ness Travis".split()è della stessa lunghezza.

CJam, 58 55 54 byte

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

Approccio ingenuo alla generazione dei numeri di Fibonacci e Lucas, quindi conteggio delle occorrenze in entrambi, conversione in binario e selezione della stringa appropriata.

Provalo online .

Scherzi a parte, 69 byte

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

Prima di questa sfida, Seriamente aveva il builtin f(indice in numeri di Fibonacci, -1 se non un numero di Fibonacci) ... ma non indice in un elenco o "è in elenco"! (Da allora è stato aggiunto come í.)

Di conseguenza, questo è ciò che spendo per trovare se l'input è un numero di Fibonacci:

,                              f0≤

Questo è ciò che spendo generando un elenco di numeri Lucas:

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

E questo è ciò che spendo per trovare se l'ingresso è nell'elenco dei numeri di Lucas:

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

Questa è una stringa che viene formattata usando la notazione% di Python in qualcosa di simile :610:=e convertita in una funzione, che viene quindi mappata sull'array e sommata. (I numeri di Lucas sono unici, quindi la somma è sempre 0 o 1.)

Grazie a @Mego per l'ultimo bit con la formattazione della stringa.

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

+1 byte per la -nbandiera.

$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

Con le nuove righe dopo il punto e virgola, per leggibilità:

$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

Trucchi:

• Ci si potrebbe chiedere perché le mie variabili si chiamano $a, $b, $%, e $d. Questa è un'ottima domanda! In effetti, mi consente di salvare un byte.

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

  è un byte più breve di

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

  Questo non si applica più perché ho modificato il mio codice riordinando le cose, facendo sì che la modifica del nome della variabile non salvi più i byte. L'ho cambiato di nuovo in modo che i nomi delle variabili abbiano nuovamente senso.

• $_-2?$f+$l*2:3è leggermente interessante. Fondamentalmente, ho dovuto fare un caso speciale 2per i numeri di Lucas perché il mio programma controlla se un numero è un numero di Lucas dopo aver "aggiornato" i numeri di Fibonacci e Lucas. Quindi è 2stato considerato un numero non di Lucas. $_-2?foo:barè un carattere più corto di $_==2?bar:foo. La stessa cosa viene utilizzata per il 2016test.

  Anche questo non è più vero perché sono stato in grado di ristrutturare il programma in modo da non richiedere il case speciale 2. Ma uso ancora $_-2016?stuff:Trumpinvece di $_==2016?Trump:stuff, che è un byte più lungo.

• A proposito, forse ti starai chiedendo come ho fatto questa ristrutturazione. Ho appena fatto il programma fare 9 volte più iterazioni del necessario, il che costa solo 2 byte ( *9) ma mi permette di fare ipotesi altrove che aiutano a ridurre le cose da golf.

• Poiché le variabili sono impostate su zero,

  $f+=$_==$a

  è più corto di

  $f=1if$_==$a

• Perl supporta le parole nude, quindi non devo citare nessuna delle mie stringhe (\ o /).

Julia, 101 100 byte

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

Ottava, 93 byte

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

Questo approccio è simile alla mia risposta MATLAB con l'eccezione che Octave ti consente di indicizzare direttamente in un nuovo array:

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

MATL (senza concorrenza), 57 55 54 (67-15) = 52 byte

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

Provalo online!

Spiegazione

Ancora una volta, una logica simile alle altre mie risposte qui e qui .

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 con uso. Posso aggiungere spiegazioni se richiesto domani, gtg a letto ora!

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

Stessa funzione per Fibonnacci e Lucas. È una funzione ricorsiva che accetta i primi due valori come init.

Java, 151 byte

Si potrebbe sostenere che Trump non avrebbe mai esternalizzato questa decisione cruciale, quindi non dovremmo rendere pubblico il metodo, risparmiando altri 7 byte.

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

Non golfato, inclusa l'invocazione del test principale

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

}

Finora non ho trovato il modo di testare per il 2016 e restituire "Trump" nel codice che è meno di 15 byte nel codice.

C (gcc) ,  128   120   116  110 byte

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

Provalo online!

Spiegazione

Chiamiamo l' F(n)ennesimo numero di Fibonacci e L(n)l'ennesimo numero di Lucas.
a, bsono F(n-1), F(n)rispettivamente.
Quindi possiamo calcolare L(n) == F(n-1)+F(n+1) == 2*F(n-1) + F(n) == 2*a+b
Questa funzione calcolerà in successione i numeri di Fibonacci e Lucas, fino a n, e controllerà se nce ne sono.
Se nè un numero di Fibonacci, il primo bit di osarà impostato su 1
Se nè un numero di Lucas, il secondo bit di osarà impostato su1
o verrà quindi utilizzato per determinare il nome da emettere

modificare

• Risparmiato 8 byte giocando a golf le condizioni del for-loop: a partire dalla seconda iterazione, abbiamo a<b<ce a<a+c=L(n), quindi ( b<=n || a+c<=n ) => a<n. In realtà avevo bisogno a<=ndi gestire correttamenten=1
• Risparmiato 4 byte grazie a ceilingcat! (anche corretto un errore, il mio codice stava producendo "2 => Ness")
• 6 byte salvati:
  • 2 grazie ancora a ceilingcat
  • 4 rimuovendo la variabile c, uguale a F(n+1), che era inutile poiché possiamo già calcolare F(n+1)con aeb

Perl 5,10, 119-15 (bonus) = 104 byte

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

Questo sfrutta il fatto che

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

è il massimo numero di Lucas inferiore o uguale a F (n).

Groovy, 149 byte

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

Codice di prova:

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

gè una chiusura che genera un elenco di numeri basato su un seed ( s) e un valore massimo ( m). (g(i,[1,1]).contains(i)?1:0)+(g(i,[2,1]).contains(i)?2:0)trova l'indice da utilizzare in base al numero di lucas o fibonacci.

MATLAB, 122 119 byte

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

Breve spiegazione

Per prima cosa creiamo un array di celle contenente i valori per la stampa: {'Pippi', 'Lucas', 'Ness', 'Travis'}. Quindi per capire quale valore visualizzare, controlliamo se nè un numero di Fibonacci o Lucas.

Per Fibonnaci, utilizziamo la seguente formula:

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

Questo controlla se uno 5*n^2 + 4o entrambi 5*n^2 - 4sono un quadrato perfetto. Seany ne sono, allora è un numero di Fibonacci.

La formula per un numero di Lucas è molto simile con l'eccezione che usiamo +/- 20 invece di 4:

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

In questa soluzione ho combinato questi due casi in uno usando la matrice:

M = [-20 -4
      20  4]

Applicando la stessa equazione di quelle sopra, ma forzando anya considerare solo la prima dimensione, ottengo un array logico a due elementi in cui se il primo elemento è true, allora è un numero di Lucas e se il secondo elemento è true, è un numero di fibonacci .

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

Quindi, per calcolare l'indice nel mio array di celle iniziale, lo considero una sequenza binaria eseguendo la moltiplicazione saggia di questo booleano con [2^0, 2^1]o semplicemente [1,2]. E sommare gli elementi. Ovviamente devo aggiungere 1 a causa dell'indicizzazione su base unica di MATLAB.

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

Quindi devo usare subsrefe substructindicizzare l'array di celle iniziale per ottenere il risultato finale.

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

Il a==1controllo è necessario altrimenti non noto che 1 è un numero Lucas.

Gelatina , 47 byte - 15 = 32 (non in competizione ...?)

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

Provalo online!

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

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

Provalo online o verifica tutti i casi di test .

Spiegazione:

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