तारों से एक आदमी पृथ्वी पर आया है! सौभाग्य से, संयुक्त राज्य अमेरिका के राष्ट्रपति, डोनाल्ड ट्रम्प, एक अनंत-पक्षीय मृत्यु है। इस डाई का उपयोग करके, वह एक संख्या को जोड़ सकता है जिसे आप , पॉडंक के मेयर , को यह निर्धारित करने के लिए उपयोग करना चाहिए कि हमलावर को रोकने के लिए किसे भेजा जाना चाहिए! लेकिन सावधान रहें, आप केवल अपने मेंढक की पीठ पर सीमित मात्रा में बाइट भेज सकते हैं !

एक उपयोगकर्ता इनपुट (जो एक सकारात्मक पूर्णांक होगा) को देखते हुए, आपको उस संख्या के आधार पर एक स्ट्रिंग वापस करना होगा जो संख्या में है।

यदि संख्या एक फाइबोनैचि संख्या है , तो आपको नेस का उत्पादन करना होगा ।
यदि संख्या एक लुकास संख्या है , तो आपको लुकास का उत्पादन करना होगा ।
यदि संख्या लुकास संख्या और फाइबोनैचि संख्या दोनों है , तो आपको ट्रैविस का उत्पादन करना होगा ।
नंबर है, तो न आ लुकास संख्या है और न ही एक फाइबोनैचि संख्या , आप उत्पादन करना चाहिए Pippi ।

उदाहरण

यहाँ परीक्षण मामलों का एक गुच्छा दिया गया है:

1 => ट्रैविस
2 => ट्रैविस
3 => ट्रैविस
4 => लुकास
5 => नेस
6 => पिप्पली
7 => लुकास
8 => नेस
610 => नेस
722 => पिप्पली
843 => लुकास

नियम

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा जवाब।
आप एक पूर्ण कार्यक्रम या एक (एन अनाम) फ़ंक्शन हो सकते हैं।

बोनस

एक दो बोनस हैं जिनका उपयोग आप राष्ट्रपति ट्रम्प को तेज़ी से डेटा प्राप्त करने में मदद करने के लिए कर सकते हैं:

के लिए -15बाइट: इनपुट संख्या है 2016, तो आपको उत्पादन Trump, के रूप में वह अपने राष्ट्रपति पद के चरम पर है।

code-golf sequence fibonacci

— अवस्था
स्रोत

29

रिकॉर्ड के लिए, मैं नहीं में से एक हूँ उन Starmen।

— एलेंडिया स्ट्राटन

1

Giygas इस बारे में खुश नहीं है (ctrl + f "Giygas")

— Cilan

@DavidCarraher जैसे ही कुछ परिभाषाएँ शुरू होती हैं, 0, 1जबकि अन्य के साथ शुरू होने वाली फिबोनाची श्रृंखला बंद होती है 1, 1, मेरा मानना है कि यह आपके द्वारा उपयोग की जाने वाली परिभाषा पर निर्भर करता है। यह देखना असामान्य नहीं है कि लुकास संख्या के साथ शुरू होता है 2, 1, जैसे OEIS के दोनों संस्करण ( 1 , 2 ) हैं, लेकिन 2 से शुरू होने वाला परिभाषा चरण है।

— Sp3000

2

वोटों को छिपाया जाना चाहिए, लेकिन मैं अभी भी कहूंगा कि मुझे वास्तव में राजनीति पसंद नहीं है और इस प्रश्न पर मेरे मतदान को प्रभावित किया है । क्या प्रश्नकर्ता राजनीति को प्रश्न से हटा देगा या कम से कम मुझे कोई भी वाक्य समझाएगा जो मैंने याद किया हो? एक राजनीतिक संदर्भ को अच्छे के लिए कल्पना में पकाया जाता है, लेकिन इसे अभी भी शीर्षक से हटाया जा सकता है।

— जॉन ड्वोरक

3

@JDDvorak: मुझे लगता है कि यह बहुत जीभ-चीक है। उदाहरण के लिए, विचार करें कि राष्ट्रपति पद के कार्यकाल 4 वर्ष हैं, और यह कि अगला चुनाव नवंबर 2016 में है। यदि ट्रम्प 2016 में अपने राष्ट्रपति पद के शिखर पर हैं ...

— एलेंडिया स्टैट्रान

4

पायथ, 59 - 15 = 44 बाइट्स

बग के ठीक होने के बाद या 42 बाइट्स

&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

पहले दो अक्षर ( &Q) आवश्यक हैं क्योंकि एक पायस पार्सिंग बग जो असफल Qहोने के बाद बनाता ."है। फिक्स लागू किया गया है। यदि पोस्ट-बगफिक्स दुभाषिया की अनुमति है, -2 बाइट्स।

अपठनीय स्ट्रिंग संपीड़न के बिना:

पायथ, 63 - 15 = 48 बाइट्स

ट्रम्प के बिना 49 बाइट्स

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

परीक्षण सूट

बहुत सरल, बस अनुक्रम उत्पन्न, एक डुप्लिकेट और सदस्यता के लिए जाँच करें।

अनुक्रम के साथ शुरू करने [1, 2]और [2, 1], और फिर नियम लागू करने से अनुक्रम उत्पन्न होते हैं ।

— isaacg
स्रोत

9

जूलिया, 146 142 121 120 बाइट्स

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]

यह एक अनाम फ़ंक्शन बनाता है जो बूलियन लौटाता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा 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

एक मुद्दा फिक्स्ड और ग्लेन हे के लिए 7 बाइट्स धन्यवाद बचाया!

— एलेक्स ए।
स्रोत

7

गणितज्ञ 143 156 - 15 (बोनस) = 141 बाइट्स

2 बाइट्स के साथ 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]

— DavidC
स्रोत

1

Falseऔर Trueसाथ बदला जा सकता 1<0है और 1>0respecively।

— लीजियनममाल 978

7

गणितज्ञ, 92 87 बाइट्स

Sp3000 के जवाब से प्रेरित ।

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

— alephalpha
स्रोत

5

अजगर 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)]

फिबोनाची और लुकास संख्या के लिए कुंजी दो विशुद्ध रूप से अंकगणितीय जांच है:

nएक फाइबोनैचि संख्या वास्तव में अगर है 5*n*n+4या 5*n*n-4एक पूर्ण वर्ग है
nएक लुकास संख्या है अगर बिल्कुल 5*n*n+20या 5*n*n-20एक पूर्ण वर्ग है

इस साइट में प्रूफ स्केच हैं ।

तो, उत्पादन के मूल्यों पर निर्भर करता है 5*n*n+iके लिए iमें {4,-4,20,-20}। समारोह fके एक मूल्य का परीक्षण करती है i, पता चल सके कि इसी मूल्य से नहीं करता है एक पूरी संख्या वर्गमूल है absवहाँ बस के लिए एक नकारात्मक की जड़ लेने का एक त्रुटि से बचने के लिए n=1, i=-20।

फ़ंक्शन STDIN से परीक्षण करने fके लिए संख्या nका मान लेता है । पायथन केवल फ़ंक्शन कॉल के अनुसार, एक बार इसका मूल्यांकन करता है।

चाहे संख्या फिबोनाची का मूल्यांकन f(4)*f(-4)संख्या रूपांतरण के लिए अंतर्निहित बूलियन का उपयोग करने के लिए नहीं किया जाता है और इसी तरह लुकास के लिए नहीं किया जाता है, और इसी स्ट्रिंग को लिया जाता है। यदि अनुगामी रिक्त स्थान की अनुमति थी, तो स्ट्रिंग इंटरलेविंग कम होगी।

— XNOR
स्रोत

प्रूफ स्केच एक मृत कड़ी है।

— एसक्यूबी

@SQB लगता है कि पृष्ठ नीचे चला गया है, मैं इसे फिर से नहीं ढूँढ सकता।

— 22

4

पायथन 2, 117 बाइट्स

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

स्ट्रिंग सूची के लिए, "Pippi Lucas Ness Travis".split()समान लंबाई है।

— Sp3000
स्रोत

3

CJam, 58 55 54 बाइट्स

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

फिबोनाची और लुकास संख्या पैदा करने का फिर से दृष्टिकोण दोनों में होने वाली घटनाओं की गणना करता है, बाइनरी में परिवर्तित होता है, और उपयुक्त स्ट्रिंग उठाता है।

इसे ऑनलाइन आज़माएं ।

— Sp3000
स्रोत

3

गंभीरता से, 69 बाइट्स

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

इस चुनौती से पहले, गंभीर रूप से बिलिन था f(फाइबोनैचि संख्याओं में सूचकांक, -1 यदि एक फाइबोनैचि संख्या नहीं) ... लेकिन सूची में "या सूची में नहीं है"! (यह तब से जोड़ा गया है í)

नतीजतन, यह वह है जो मैं खर्च करता हूं अगर इनपुट एक फाइबोनैचि संख्या है:

,                              f0≤

यह वह है जो मैं लुकास संख्याओं की सूची बनाने में खर्च करता हूं:

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

और यह वह है जिसे मैं लुकास संख्या की सूची में इनपुट होने पर खोजने में खर्च करता हूं:

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

यह एक स्ट्रिंग है जिसे पायथन के% संकेतन का उपयोग करते हुए प्रारूपित किया जाता है :610:=, और एक फ़ंक्शन में परिवर्तित किया जाता है, जिसे बाद में सरणी पर मैप किया जाता है और सारांशित किया जाता है। (लुकास संख्या अद्वितीय हैं, इसलिए योग हमेशा 0 या 1. होता है)

स्ट्रिंग प्रारूपण के साथ उस अंतिम बिट के लिए @ मीगो का धन्यवाद।

— lirtosiast
स्रोत

3

पर्ल, 133 (146-15 =) 131 (144-15 =) 129 (136-15 =) 121 बाइट्स

-nध्वज के लिए +1 बाइट ।

$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

पठनीयता के लिए अर्धविराम के बाद नई कहानियों के साथ:

$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

डेमो:

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

ट्रिक्स:

क्यों मेरे चर नाम हैं आप सोच रहे होंगे हो सकता है $a, $b, $%, और $d। यह एक अच्छा प्रश्न है! वास्तव में, यह मुझे एक बाइट को बचाने की अनुमति देता है।

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

एक बाइट से छोटा है
```
(stuff) ... ,$l+=$_==$c while $a<$_
```
यह अब लागू नहीं होता है क्योंकि मैंने चीजों को फिर से व्यवस्थित करके अपना कोड गोल्फ किया है, जिससे चर नाम परिवर्तन अब बाइट्स को नहीं बचा सकेगा। मैंने इसे वापस बदल दिया ताकि चर नाम फिर से समझ में आए।
$_-2?$f+$l*2:3हल्के से दिलचस्प है। मूल रूप से, मुझे 2लुकास संख्याओं के लिए विशेष-मामला करना पड़ा क्योंकि मेरा कार्यक्रम यह जांचता है कि क्या फाइबोनैचि और लुकास संख्याओं को "अपडेट" करने के बाद एक संख्या एक लुकास संख्या है। इसलिए 2नॉट-लुकास नंबर माना जाता था। $_-2?foo:barकी तुलना में एक छोटा है $_==2?bar:foo। एक ही चीज का उपयोग 2016परीक्षण के लिए किया जाता है ।

यह भी अब सच नहीं है क्योंकि मैं विशेष-आवरण की आवश्यकता नहीं करने के लिए कार्यक्रम का पुनर्गठन करने में सक्षम था 2। लेकिन मैं अभी भी $_-2016?stuff:Trumpइसके बजाय का उपयोग करता हूं $_==2016?Trump:stuff, जो एक बाइट लंबा है।
जिसके बारे में बोलते हुए, आप सोच रहे होंगे कि मैंने यह पुनर्गठन कैसे किया। मैंने सिर्फ कार्यक्रम को आवश्यकता से 9 गुना अधिक पुनरावृत्तियों के लिए बनाया है, जिसमें केवल 2 बाइट्स ( *9) की लागत है लेकिन मुझे कहीं और धारणा बनाने की अनुमति देता है जो गोल्फ सामान को नीचे लाने में मदद करता है।
क्योंकि चर शून्य से डिफ़ॉल्ट होते हैं,
```
$f+=$_==$a
```
से छोटा है
```
$f=1if$_==$a
```
पर्ल नंगे पासवर्ड का समर्थन करता है, इसलिए मुझे अपने किसी भी तार (\ o /) को उद्धृत करने की आवश्यकता नहीं है।

— Doorknob
स्रोत

क्या यह दो बाइट्स कम नहीं है?

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ कार्यक्रम स्वयं 132 बाइट्स है, और मैंने एक जोड़ा क्योंकि इसे -nध्वज के साथ बुलाया जाना चाहिए (जैसा कि उत्तर में उल्लेख किया गया है)।

— दरवाज़े

ओह मैं समझा। -nझंडा क्या करता है?

— कॉनर ओ'ब्रायन

1

@ C @O'Bʀɪᴇɴ यह while(<>) { ... }आपके कार्यक्रम के चारों ओर एक लूप मानता है । देखें: पर्ल डॉक्स ।

— दरवाज़े

1

@DomHastings वह नहीं था, लेकिन मैंने <s> रूपांतरित किया, उसे प्रति प्रयास करने के लिए मना लिया।

— एक स्पेगेटो

2

जूलिया, 101 100 बाइट्स

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

— ग्लेन हे
स्रोत

बहुत बढ़िया समाधान! मैट्रिक्स और ट्रेस दृष्टिकोण प्रतिभाशाली है। यह बहुत बुरा है कि इसके लिए {}वैकल्पिक सिंटैक्स खराब Any[]है; जो एक दो बाइट्स को बचाएगा।

— एलेक्स ए।

2

ऑक्टेव, 93 बाइट्स

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

यह दृष्टिकोण मेरे MATLAB के जवाब के समान है कि ऑक्टेव आपको सीधे एक नए सरणी में अनुक्रमित करने की अनुमति देता है:

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

— Suever
स्रोत

2

MATL (गैर-प्रतिस्पर्धात्मक), 57 55 54 (67-15) = 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

फिर, यहाँ और यहाँ मेरे अन्य उत्तरों के समान तर्क ।

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

— Suever
स्रोत

1

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

उपयोग के साथ अपुष्ट। यदि कल अनुरोध किया गया हो तो मैं स्पष्टीकरण जोड़ सकता हूं, अब बिस्तर पर gtg!

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

— Zereges
स्रोत

1

@sysreq मुझे नहीं लगता कि यह बोनस के लिए है, सिर्फ बयान शामिल करें।

— चरण

@ मुझे पता है, मैं बाइट के आकार को दो भागों (कोड + शामिल) में विभाजित कर रहा हूं, जब मैं केवल फ़ंक्शन और पूरे कार्यक्रम को पोस्ट नहीं करता।

— Zereges

1

जावास्क्रिप्ट (ईएस 6), 108 बाइट्स

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

Fibonnacci और Lucas के लिए समान कार्य। यह एक पुनरावर्ती फ़ंक्शन है जो पहले दो मानों को इनिट के रूप में लेता है।

— Naouak
स्रोत

1

जावा, 151 बाइट्स

आप तर्क दे सकते हैं कि ट्रम्प कभी भी इस महत्वपूर्ण निर्णय को आउटसोर्स नहीं करेंगे, इसलिए हमें विधि को सार्वजनिक नहीं करना होगा, जिससे एक और 7 बाइट की बचत होगी।

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

परीक्षण-मुख्य आह्वान सहित अनपढ़

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

}

मुझे 2016 के लिए परीक्षण करने और "ट्रम्प" को कोड में वापस करने का कोई तरीका नहीं मिला जो कि कोड में 15 बाइट्स से कम है।

— janschweizer
स्रोत

अपने स्पष्टीकरण की पहली पंक्ति से प्यार करें!

— स्कॉट

1

सी (जीसीसी) , 128 120 116 110 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

चलो F(n)n-th फाइबोनैचि संख्या और L(n)n-वें लुकास संख्या का नाम दें ।
a, bकर रहे हैं F(n-1), F(n)क्रमशः।
फिर हम गणना कर सकते हैं कि L(n) == F(n-1)+F(n+1) == 2*F(n-1) + F(n) == 2*a+b
यह फ़ंक्शन क्रमिक रूप से फाइबोनैचि और लुकास संख्याओं की गणना करेगा n, और जांच करेगा कि nउनमें से कोई भी है या नहीं।
यदि nएक फाइबोनैचि संख्या है, तो 1 का थोड़ा सा oसेट 1
अगर nएक लुकास संख्या के लिए किया जाएगा, तो दूसरी बिट को oनिर्धारित करने के 1
oलिए उपयोग किया जाएगा कि किस नाम को आउटपुट किया जाए

संपादित करें

लूप की स्थिति को नियंत्रित करके 8 बाइट्स सहेजे गए: दूसरी पुनरावृत्ति पर शुरू, हमारे पास a<b<cऔर a<a+c=L(n)इसलिए ( b<=n || a+c<=n ) => a<n। मुझे वास्तव में a<=nसही ढंग से संभालने की जरूरत थीn=1
सेविंग के लिए 4 बाइट्स धन्यवाद! (एक गलती को भी सुधारा, मेरा कोड "2 => नेस" आउटपुट कर रहा था)
सहेजे गए 6 बाइट्स:
- 2 फिर से सीलिंग करने के लिए धन्यवाद
- 4 चर को हटाने के द्वारा c, के बराबर F(n+1)है, जो बेकार था के बाद से हम पहले से ही गणना कर सकते हैं F(n+1)के साथ aऔरb

— Annyo
स्रोत

के b+=aबजाय सुझावb=a+b

— छत पर

0

पर्ल 5.10, 119 - 15 (बोनस) = 104 बाइट्स

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

यह इस तथ्य का फायदा उठाता है कि

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

सबसे बड़ी लुकास संख्या F (n) से कम या बराबर है।

— nwellnhof
स्रोत

0

ग्रूवी, 149 बाइट्स

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

टेस्ट कोड:

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

gएक क्लोजर है जो एक बीज ( s) और अधिकतम मूल्य ( m) के आधार पर संख्याओं की एक सूची बनाता है । (g(i,[1,1]).contains(i)?1:0)+(g(i,[2,1]).contains(i)?2:0)संख्या लुकास या रिट्रेसमेंट के आधार पर उपयोग करने के लिए सूचकांक पाता है।

— जे एटकिन
स्रोत

0

MATLAB, 122 119 बाइट्स

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

संक्षिप्त विवरण

हम पहले एक सेल सरणी बनाते हैं जिसमें प्रिंट करने के लिए मान होते हैं {'Pippi', 'Lucas', 'Ness', 'Travis'}:। फिर यह पता लगाने के लिए कि किस मूल्य को प्रदर्शित करना है, हम यह देखने के लिए nजांचते हैं कि क्या फाइबोनैचि या लुकास संख्या है।

Fibonnaci के लिए, हम निम्नलिखित सूत्र का उपयोग करते हैं:

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

यह देखने के लिए जाँच करता है कि या तो एक पूर्ण वर्ग है 5*n^2 + 4या 5*n^2 - 4नहीं। यदि anyवे हैं, तो यह एक फाइबोनैचि संख्या है।

एक लुकास संख्या के लिए सूत्र है बहुत अपवाद के साथ इसी तरह की है कि हम +/- 20 के बजाय 4 का उपयोग करें:

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

इस समाधान में मैंने मैट्रिक्स का उपयोग करके इन दो मामलों को एक में जोड़ दिया:

M = [-20 -4
      20  4]

उपरोक्त समान समीकरणों को लागू करने से, लेकिन anyकेवल पहले आयाम पर विचार करने के लिए बाध्य होने पर, मुझे एक दो तत्व तार्किक सरणी मिलती है जहां यदि पहला तत्व है true, तो यह एक लुकास संख्या है और यदि दूसरा तत्व है true, तो यह एक रिटेनर संख्या है ।

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

फिर अपने प्रारंभिक सेल सरणी में सूचकांक की गणना करने के लिए, मैं इस बूलियन के तत्व-वार गुणन के साथ [2^0, 2^1]या बस प्रदर्शन करके एक द्विआधारी अनुक्रम के रूप में मानता हूं [1,2]। और तत्वों का योग। जाहिर है मुझे MATLAB के एक-आधारित अनुक्रमण के कारण 1 जोड़ना होगा।

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

फिर मुझे अंतिम परिणाम प्राप्त करने के लिए प्रारंभिक सेल सरणी में उपयोग करना subsrefऔर substructअनुक्रमण करना होगा।

— Suever
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 97 बाइट्स

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==1जांच की जरूरत है अन्यथा मैं की सूचना नहीं है कि 1 एक लुकास संख्या है।

— नील
स्रोत

0

जेली , 47 बाइट्स - 15 = 32 (गैर-प्रतिस्पर्धात्मक ...?)

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

इसे ऑनलाइन आज़माएं!

— आउटगोल्फर को एरिक करें
स्रोत

0

05AB1E , 39 37 (52 - 15 बोनस) बाइट्स

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

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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

— केविन क्रूज़सेन
स्रोत

ट्रम्पन को रोकने के लिए ट्रम्प को आपकी मदद की आवश्यकता है!

उदाहरण

नियम

बोनस

पायथ, 59 - 15 = 44 बाइट्स

पायथ, 63 - 15 = 48 बाइट्स

जूलिया, 146 142 121 120 बाइट्स

गणितज्ञ 143 156 - 15 (बोनस) = 141 बाइट्स

गणितज्ञ, 92 87 बाइट्स

अजगर 2, 107

पायथन 2, 117 बाइट्स

CJam, 58 55 54 बाइट्स

गंभीरता से, 69 बाइट्स

पर्ल, 133 (146-15 =) 131 (144-15 =) 129 (136-15 =) 121 बाइट्स

जूलिया, 101 100 बाइट्स

ऑक्टेव, 93 बाइट्स

MATL (गैर-प्रतिस्पर्धात्मक), 57 55 54 (67-15) = 52 बाइट्स

C ++ 11, 176 + 15 (#include) = 191

जावास्क्रिप्ट (ईएस 6), 108 बाइट्स

जावा, 151 बाइट्स

सी (जीसीसी) , 128 120 116 110 बाइट्स

व्याख्या

संपादित करें

पर्ल 5.10, 119 - 15 (बोनस) = 104 बाइट्स

ग्रूवी, 149 बाइट्स

MATLAB, 122 119 बाइट्स

जावास्क्रिप्ट (ईएस 6), 97 बाइट्स

जेली , 47 बाइट्स - 15 = 32 (गैर-प्रतिस्पर्धात्मक ...?)

05AB1E , 39 37 (52 - 15 बोनस) बाइट्स