अपर या लोअर वायथॉफ?

Question

सबसे पहले बात करते हैं बीट्टी सीक्वेंस की । एक सकारात्मक अपरिमेय संख्या r को देखते हुए , हम सकारात्मक पूर्णांकों को क्रम में r से गुणा करके और प्रत्येक परिणामी गणना का तल लेकर एक अनंत अनुक्रम का निर्माण कर सकते हैं । उदाहरण के लिए,

यदि r > 1 है, तो हमारे पास एक विशेष शर्त है। हम एक और अपरिमेय संख्या फार्म कर सकते हैं रों के रूप में रों = r / ( आर - 1)। यह तब अपने खुद के बीट्टी अनुक्रम, बी _एस उत्पन्न कर सकता है । साफ चाल है कि बी _आर और बी _एस रहे हैं पूरक है, जिसका अर्थ है कि हर सकारात्मक पूर्णांक ठीक दो दृश्यों में से एक में है।

यदि हम r = ϕ, स्वर्ण अनुपात सेट करते हैं, तो हमें s = r + 1, और दो विशेष क्रम मिलते हैं । कम Wythoff अनुक्रम के लिए आर :

1, 3, 4, 6, 8, 9, 11, 12, 14, 16, 17, 19, 21, 22, 24, 25, 27, 29, ... 

और ऊपरी Wythoff अनुक्रम के लिए रों :

2, 5, 7, 10, 13, 15, 18, 20, 23, 26, 28, 31, 34, 36, 39, 41, 44, 47, ... 

ये क्रमशः OEIS पर A000201 और A001950 के अनुक्रम हैं।

चुनौती

एक सकारात्मक इनपुट पूर्णांक को देखते हुए 1 <= n <= 1000, दो अलग-अलग मानों में से एक का उत्पादन यह दर्शाता है कि इनपुट कम वीथॉफ़ अनुक्रम या ऊपरी अनुक्रम में है। आउटपुट मान हो सकता है -1और 1, trueऔर false, upperऔर lower, आदि।

यद्यपि आपके सबमिट किए गए एल्गोरिदम को सैद्धांतिक रूप से सभी इनपुट के लिए काम करना होगा, व्यवहार में इसे केवल पहले 1000 इनपुट नंबर के साथ काम करना होगा।

I / O और नियम

• इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
• इनपुट और आउटपुट को आपकी भाषा के मूल संख्या प्रकार में फिट किया जा सकता है।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

यह मूल रूप से "गोल्फ द लोअर वीथॉफ सीक्वेंस" है क्योंकि ऊपरी वायथॉफ अनुक्रम को निचले एक (स्क्वरिंग फी) की तुलना में 1 अधिक ऑप की आवश्यकता होती है।

— मैजिक ऑक्टोपस Urn

Answer 1

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

f=(n,s="1",t=0)=>s[n-1]||f(n,s+t,s)

<input type=number min=1 oninput=o.textContent=this.value&amp;&amp;f(this.value)><pre id=o>

1कम और 0ऊपरी के लिए आउटपुट । स्पष्टीकरण: बूलियन मूल्यों का आंशिक सूची का उपयोग निर्माण किया जा सकता एक फाइबोनैचि की तरह पहचान: दिए गए दो सूचियों, के साथ शुरू करने 1और 10, प्रत्येक अनुवर्ती सूची, पिछले दो का संयोजन है, जिसके परिणामस्वरूप 101, 10110, 10110101आदि इस मामले में यह थोड़ा golfier के लिए है में 0सूची के दूसरे तत्व का निर्माण करने के लिए एक नकली 0 वीं प्रविष्टि और उसका उपयोग करें।

Comments

कैसा हो ...

— AdmBorkBork

मुझे पसंद है कि कैसे स्पष्टीकरण ने मुझे कम +1 समझा। आंशिक बूलियन जो फ़िज़बोनकेशी नामक एक व्यक्ति की पहचान चुराता है, जो तब निर्माण की प्रविष्टि को नकली करने के लिए अपने पोते के साथ एक साथ जुड़ा हुआ है।

— मैजिक ऑक्टोपस Urn

मैं यह जानने के लिए उत्सुक था कि यह 33-बाइट संस्करण एक सन्निकटन का उपयोग करके कितनी दूर काम कर सकता है। इसका उत्तर स्पष्ट रूप से n = 375 तक है ।

— अरनुलद

Answer 2

हास्केल , 26 बाइट्स

(l!!)
l=0:do x<-l;[1-x..1]

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

कोई तैरता नहीं, असीमित सटीकता। दो बाइट्स के लिए H.PWiz के लिए धन्यवाद।

Comments

यह भी 26 बाइट्स होगा, लेकिन मुझे समझ नहीं आता कि यह काम क्यों नहीं करता है

— H.PWiz

@ H.PWiz मुझे लगता है कि यह इसलिए है क्योंकि खाली सूची एक निश्चित बिंदु है।

— xnor

आह, मैंने उस पर विचार नहीं किया था, और एक "समतुल्य" विधि के साथ तुलना कर रहा था जो इस्तेमाल किया गया था ~(x:t)। धन्यवाद

— H.PWiz

@ H.PWiz / xnor तकनीकी रूप से हास्केल में उपयोग किया जाने वाला निश्चित बिंदु, सबसे छोटा एक है, यहाँ नीचे / है undefined। तथ्य यह है कि दो अलग-अलग परिभाषित लोग हैं और बस आकस्मिक है।

— अर्जन जोहानसन

Answer 3

पायथन , 25 बाइट्स

lambda n:-n*2%(5**.5+1)<2

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

बहुत ही सरल स्थिति का उपयोग करता है:

nकम Wythoff अनुक्रम में है अगर बिल्कुल -n%phi<1।

ध्यान दें कि भले ही -nऋणात्मक होने पर भी मोडुलो परिणाम सकारात्मक हो , यह मिलान करते हुए कि पायथन मोडुलो कैसे करता है।

प्रमाण: चलो a = -n%phi, जो सीमा में है 0 <= a < phi। हम कुछ सकारात्मक पूर्णांक के लिए -nmodulo phiको विभाजित कर सकते हैं । उस तक पहुंचें ।-n = -k*phi + akn+a = k*phi

यदि a<1, तब n = floor(n+a) = floor(k*phi), और ऐसा ही कम वायथॉफ अनुक्रम में है।

नहीं 1 <= a < phiतो हमारे पास ऐसा है

n+1 = floor(n+a) = floor(k*phi)
n > n+a-phi = k*phi - phi = (k-1)*phi

तो nबीच की खाई में गिर जाता है floor((k-1)*phi)और floor(k*phi) और निचले Wythoff अनुक्रम द्वारा याद किया जाता है।

यह इस कोड से मेल खाता है:

lambda n:-n%(5**.5/2+.5)<1

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

हम एक बाइट को दोगुना करके बचाते हैं -(n*2)%(phi*2)<2।

Comments

क्या आप बता सकते हैं कि सूत्र कैसे आता है? मैंने इसे अनुक्रम परिभाषाओं से प्राप्त करने की कोशिश की, लेकिन जंगल में खो गया।

— सूंदर -

@ सूंदर ने एक प्रमाण जोड़ा।

— xnor

Answer 4

05AB1E , 9 बाइट्स

L5t>;*óså

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

---

0 का मतलब ऊपरी है, 1 का मतलब कम है। पहले 100 का प्रयास करें : इसे ऑनलाइन आज़माएं!

---

    CODE   |      COMMAND      # Stack (Input = 4)
===========+===================#=======================
L          | [1..a]            # [1,2,3,4]
 5t>;      | (sqrt(5) + 1)/2   # [phi, [1,2,3,4]]
     *     | [1..a]*phi        # [[1.6,3.2,4.8,6.4]]
      ó    | floor([1..a]*phi) # [[1,3,4,6]]
       så  | n in list?        # [[1]]

---

रॉ कमांड डंप:

----------------------------------
Depth: 0
Stack: []
Current command: L

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4]]
Current command: 5

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], '5']
Current command: t

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 2.23606797749979]
Current command: >

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 3.23606797749979]
Current command: ;

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 1.618033988749895]
Current command: *

----------------------------------
Depth: 0
Stack: [[1.618033988749895, 3.23606797749979, 4.854101966249685, 6.47213595499958]]
Current command: ó

----------------------------------
Depth: 0
Stack: [[1, 3, 4, 6]]
Current command: s

----------------------------------
Depth: 0
Stack: [[1, 3, 4, 6], '4']
Current command: å
1
stack > [1]

Comments

मेरे पास समान था, लेकिन ï:) का उपयोग करते हुए

— Emigna

@ मिगना मुझे आश्चर्य हुआ कि गणितीय गणितीय स्थिरांक में नहीं था। 5t>;एक 2 बटर के लायक नहीं हो सकता है, हालांकि ...

— मैजिक ऑक्टोपस Urn

हाँ, मैं आधा याद कर रहा था कि यह हो सकता है (लेकिन यह नहीं है)। ऐसा लगता है जैसे हमें कुछ जोड़ना चाहिए।

— इमीना

@ ईमनिगा मैं निश्चित रूप से जेली उत्तर कानूनी रूप से यह है, लेकिन एक फी में निर्मित हैह के साथ है।

— मैजिक ऑक्टोपस Urn

Haha मैं एक ही था, लेकिन उपयोग ïऔर ¢lol :) हमारे सभी समाधान इतने निकट से संबंधित हैं

— श्री एक्सकोडर

Answer 5

जेली , 5 बाइट्स

N%ØpỊ

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

Xnor के पायथन गोल्फ के लिए 1 बाइट का धन्यवाद सहेजा गया ।

---

जेली , 6 बाइट्स

×€ØpḞċ

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

कम के लिए 1 और ऊपरी के लिए 0 रिटर्न देता है ।

×€ØpḞċ – Full Program / Monadic Link. Argument: N.
×€     – Multiply each integer in (0, N] by...
  Øp   – Phi.
    Ḟ  – Floor each of them.
     ċ – And count the occurrences of N in that list.

$(0,\:N]\cap \mathbb{Z}$$\varphi > 1$$N > 0$$0 < N < N\varphi$

Comments

मैं अनुमान लगा रहा हूँ कि उनमें से एक phi: P के लिए 1-बाइट स्थिर है?

— मैजिक ऑक्टोपस Urn

नहीं, एक दो बाइट एक:Øp

— श्री Xcoder

हे, मेरे 4-बाइट से बेहतर 05AB1E में:5t>;

— मैजिक ऑक्टोपस Urn

Answer 6

ब्रेन-फ्लैक , 78 बाइट्स

([{}]()){<>{}((([()]))){{<>({}())}{}(([({})]({}{})))}<>([{}]{}<>)}<>({}()){{}}

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

आउटपुट कम और 0ऊपरी के लिए कुछ भी नहीं करता है । अधिक समझदार आउटपुट योजना में बदलाव करने पर 6 बाइट का खर्च आएगा।

Answer 7

पायथन 2 , 39 33 32 बाइट्स

^{-6 बाइट्स मिस्टर एक्सकोडर
-1 बाइट की बदौलत Zacharý को धन्यवाद}

lambda n,r=.5+5**.5/2:-~n//r<n/r

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

Falseकम और Trueऊपरी के लिए रिटर्न

Comments

lambda n,r=(1+5**.5)/2:-~n//r<n/r6 बाइट्स बचाता है।

— श्री एक्सकोडर

इसके अलावा, lambda n,r=.5+5**.5/2:-~n//r<n/rएक बाइट को दाढ़ी बनाने के लिए भी काम करना चाहिए

— Zacharý

Answer 8

जूलिया 0.6 , 16 बाइट्स

n->n÷φ<-~n÷φ

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

संख्याओं के साथ खेलते समय, मैं इस संपत्ति में आया था: मंजिल (n / =) == मंजिल ((n + 1) / /) अगर n ऊपरी व्यर्थोफ अनुक्रम में है, और फर्श (n / φ) <मंजिल ( (n + 1) / φ) यदि n कम वीथॉफ अनुक्रम में है। मुझे पता नहीं चला है कि यह संपत्ति कैसे आती है, लेकिन यह कम से कम n = 100000 (और शायद परे) तक सही परिणाम देता है।

---

पुराना उत्तर:

जूलिया 0.6 , 31 बाइट्स

n->n∈[floor(i*φ)for i∈1:n]

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

trueकम और falseऊपरी वीथॉफ़ अनुक्रम के लिए रिटर्न ।

Comments

चूंकि n तक की संख्याओं का n / the कम है और अन्य ऊपरी हैं, क्रमिक निचली संख्याओं के बीच औसत अंतर φ है; निम्न संख्याओं को by से विभाजित करने से आपको एक अनुक्रम मिलता है जहां औसत अंतर 1 है; यह पूर्णांक होने के लिए उस अनुक्रम के फर्श के लिए संभव बनाता है। मेरा गणित हालांकि इसे और आगे ले जाने के लिए पर्याप्त नहीं है।

— नील

Answer 9

पायथ , 8 बाइट्स

/sM*.n3S

यहाँ कोशिश करो!

कम के लिए 1 और ऊपरी के लिए 0 रिटर्न देता है ।

Answer 10

वोल्फ्राम भाषा (गणितज्ञ) , 26 बाइट्स

#~Ceiling~GoldenRatio<#+1&

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

एक पूर्णांक nनिम्न वीथॉफ़ अनुक्रम आइफ़ में है ceil(n/phi) - 1/phi < n/phi।

प्रमाण है कि ceil(n/phi) - 1/phi < n/phi...

पर्याप्त मात्रा में:

1. चलो ceil(n/phi) - 1/phi < n/phi।

2. फिर, ceil(n/phi) * phi < n + 1।

3. ध्यान दें n == n/phi * phi <= ceil(n/phi) * phi।

4. इसलिए, n <= ceil(n/phi) * phi < n + 1।

5. चूंकि nऔर ceil(n/phi)पूर्णांक हैं, हम फर्श और राज्य की परिभाषा को लागू करते हैं floor(ceil(n/phi) * phi) == n, और nनिचले वीथॉफ अनुक्रम में है।

ज़रूरी; गर्भनिरोधक द्वारा प्रमाण:

1. चलो ceil(n/phi) - 1/phi >= n/phi।

2. फिर, ceil(n/phi) * phi >= n + 1।

3. ध्यान दें n + phi > (n/phi + 1) * phi > ceil(n/phi) * phi

4. इसलिए n > (ceil(n/phi) - 1) * phi।

5. चूंकि (ceil(n/phi) - 1) * phi < n < n + 1 <= ceil(n/phi) * phi, nनिचले वीथऑफ सीक्वेंस में नहीं है।

Comments

यह भी कोई गोल त्रुटि नहीं है।

— user202729

Answer 11

जाप , 10 बाइट्स

ऊपरी के लिए निचले और झूठे के लिए सही रिटर्न ।

õ_*MQ fÃøU

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

स्पष्टीकरण:

õ_*MQ fÃøU
             // Implicit U = Input
õ            // Range [1...U]
 _           // Loop through the range, at each element:
  *MQ        //   Multiply by the Golden ratio
      f      //   Floor
       Ã     // End Loop
        øU   // Return true if U is found in the collection

Comments

मैं था इस 10 के लिए भी बाइट्स।

— झबरा

Answer 12

जावा 10, 77 53 52 बाइट्स

n->{var r=Math.sqrt(5)/2+.5;return(int)(-~n/r)<n/r;}

पोर्ट ऑफ़ @ रॉड का पायथन 2 उत्तर ।
-1 बाइट @ ज़ाचारी को धन्यवाद ।

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

---

पुराने 77 76 बाइट्स उत्तर:

n->{for(int i=0;i++<n;)if(n==(int)((Math.sqrt(5)+1)/2*i))return 1;return 0;}

-1 बाइट की बदौलत @ovs 'के लिए मैंने पिछले हफ्ते खुद से सिफारिश की थी

1कम के लिए रिटर्न ; 0ऊपरी के लिए।

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

स्पष्टीकरण:

n->{                    // Method with integer as both parameter and return-type
  for(int i=0;++i<=n;)  //  Loop `i` in the range [1, `n`]
    if(n==(int)((Math.sqrt(5)+1)/2*i))
                        //   If `n` is equal to `floor(Phi * i)`:
      return 1;         //    Return 1
  return 0;}            //  Return 0 if we haven't returned inside the loop already

i*Phiलेने के द्वारा गणना की जाती है (sqrt(5)+1)/2 * i, और हम तब दशमलव को कम करने के लिए इसे एक पूर्णांक में कास्टिंग करके फर्श करते हैं।

Comments

++i<=nआपके पुराने उत्तर पर हो सकता है i++<n।

— ओवंस

@ovs of बेशक ..>। < मैं वास्तव में पिछले हफ्ते किसी और को इस गोल्फ की सिफारिश की , योग्य .. धन्यवाद।

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

मुझे लगता है कि यह -1 बाइट के लिए काम करना चाहिए:n->{var r=Math.sqrt(5)/2+.5;return(int)(-~n/r)<n/r;}

— ज़ाचारि

@ Zacharý यह वास्तव में करता है, धन्यवाद!

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

Answer 13

हास्केल , 153 139 126 79 बाइट्स

असीमित परिशुद्धता!

l=length
f a c|n<-2*l a-c,n<0||l a<a!!n=c:a|1>0=a
g x=x==(foldl f[][1..x+1])!!0

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

व्याख्या

परिणाम के अर्थ की गणना करने के लिए स्वर्ण अनुपात के एक सन्निकटन का उपयोग करने के बजाय वे इनपुट के आकार के रूप में त्रुटियों से ग्रस्त हैं। यह उत्तर नहीं है। इसके बजाय यह OEIS पर उपलब्ध कराए गए सूत्र का उपयोग करता है जो कि aइस तरह का अद्वितीय अनुक्रम है

∀n . b(n) = a(a(n))+1

bआदेशित प्रशंसा कहां है।

Comments

"आप आउट होने से पहले सभी सच नहीं थे ...

— नील

@ नील अच्छी बात है। मुझे आपका उत्तर याद आ गया होगा।

— गेहूं जादूगर

यद्यपि आपका उत्तर इस तथ्य से सीमित है कि जावास्क्रिप्ट में एक अभिन्न प्रकार नहीं है?

— गेहूं जादूगर

ठीक है, यह पहले से अच्छी तरह से स्मृति से बाहर चलेगा ...

— नील

Answer 14

ब्रेकीलॉग , 8 बाइट्स

≥ℕ;φ×⌋₁?

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

विधेय सफल होता है यदि इनपुट निम्न व्यथोफ़ अनुक्रम में है और विफल रहता है यदि यह ऊपरी व्याथॉफ़ अनुक्रम में है।

 ℕ          There exists a whole number
≥           less than or equal to
            the input such that
  ;φ×       multiplied by phi
     ⌋₁     and rounded down
       ?    it is the input.

यदि समाप्त करने में विफलता एक वैध आउटपुट विधि है, तो पहले बाइट को छोड़ा जा सकता है।

Comments

यह संभवत: पहली बार φहै जब ब्राचलॉग कार्यक्रम का उपयोग किया जाता है। आखिर कार!

— घातक

Answer 15

MATL , 8 बाइट्स

t:17L*km

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

व्याख्या

t      % Implicit input. Duplicate
:      % Range
17L    % Push golden ratio (as a float)
*      % Multiply, element-wise
k      % Round down, element-wise
m      % Ismember. Implicit output

Answer 16

के (ओके) , 20 बाइट्स

समाधान:

x in_(.5*1+%5)*1+!x:

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

स्पष्टीकरण:

x in_(.5*1+%5)*1+!x: / the solution
                  x: / save input as x
                 !   / generate range 0..x
               1+    / add 1
              *      / multiply by
     (       )       / do this together
           %5        / square-root of 5
         1+          / add 1
      .5*            / multiply by .5
    _                / floor
x in                 / is input in this list?

Answer 17

TI-BASIC (TI-84), 18 बाइट्स

max(Ans=iPart((√(5)+1)/2randIntNoRep(1,Ans

इनपुट में है Ans।
आउटपुट में है Ansऔर स्वचालित रूप से मुद्रित है।
प्रिंट 1यदि इनपुट निचले क्रम में है या 0यदि यह ऊपरी क्रम में है।

संयोग से, यह कार्यक्रम केवल के लिए चलेगा $0<N<1000$ ।

उदाहरण:

27
             27
prgmCDGFA
              1
44
             44
prgmCDGFA
              0

स्पष्टीकरण:

max(Ans=iPart((√(5)+1)/2randIntNoRep(1,Ans    ;full program, example input: 5
                        randIntNoRep(1,Ans    ;generate a list of random integers in [1,Ans]
                                               ; {1, 3, 2, 5, 4}
              (√(5)+1)/2                      ;calculate phi and then multiply the resulting
                                              ;list by phi
                                               ; {1.618 4.8541 3.2361 8.0902 6.4721}
        iPart(                                ;truncate
                                               ; {1 4 3 8 6}
    Ans=                                      ;compare the input to each element in the list
                                              ;and generate a list based off of the results
                                               ; {0 0 0 0 0}
max(                                          ;get the maximum element in the list and
                                              ;implicitly print it

---

नोट: TI-BASIC एक टोकन भाषा है। कैरेक्टर काउंट बाइट काउंट नहीं के बराबर होता है ।

Answer 18

CQuents , 5 बाइट्स

?F$`g

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

व्याख्या

?         output true if in sequence, false if not in sequence
          each term in the sequence equals:

 F        floor (
  $               index * 
   `g                     golden ratio
     )                                 ) implicit