पृष्ठभूमि

1-2-3-जनजातीय अनुक्रम

एक दूसरे के लिए कल्पना करें कि आप निम्नलिखित के साथ मानक पुनरावृत्ति फॉर्मूला को प्रतिस्थापित करके एक रिट्राइव अनुक्रम बना सकते हैं:

$tribonacci$

मूल रूप से, अगला पाने के लिए अंतिम दो को जोड़ने के बजाय, आप अंतिम तीन को जोड़ते हैं। यह 1-2-3-जनजातीय अनुक्रम का आधार है।

ब्राउन का मानदंड

ब्राउन का मानदंड यह बताता है कि आप किसी पूर्णांक मान को किसी अनुक्रम के सदस्यों के योग के रूप में प्रस्तुत कर सकते हैं:

$x उप n बराबर 1$
n1 से अधिक सभी के लिए , $x उप n 2 से कम x उप n - 1$

चुनौती के लिए इसका क्या मतलब है

आप निम्नलिखित प्रारंभिक स्थितियों द्वारा गठित 1-2-3-ट्रिबोनैचि अनुक्रम के सदस्यों के योग के रूप में किसी भी सकारात्मक पूर्णांक का वर्णन कर सकते हैं:

$आरंभिक स्थितियां$

इस रूप में जाना जाता है, इस क्रम में प्रत्येक मूल्य के लिए, शब्दों के बीच का अनुपात कभी भी 2 से अधिक नहीं होता है (लगभग 1.839 पर औसत अनुपात)।

इस संख्यात्मक प्रतिनिधित्व प्रणाली में कैसे लिखें

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

1  2  3  6 11 20 37 68

फिर, आप अपना नंबर दर्शाए जाने के लिए लेते हैं (हमारे परीक्षणों के लिए, आइए इसे कहते हैं 63) और दिए गए 1-2-3-ट्रिबोनैचि के मूल्यों का पता लगाएं, जो कि 63 की राशि है (पहले सबसे बड़े मूल्यों का उपयोग करके!) । यदि संख्या योग का हिस्सा है, तो इसके नीचे एक 1 डालें, यदि नहीं तो 0।

1  2  3  6 11 20 37 68
0  0  0  1  0  1  1  0

आप किसी भी पूर्णांक के लिए ऐसा कर सकते हैं - बस सत्यापित करें कि आप अपने दिए गए इनपुट के नीचे सबसे बड़े मूल्यों का उपयोग करते हैं!

परिभाषा (अंत में)

एक प्रोग्राम या फ़ंक्शन लिखें nजो 1 और आपकी भाषा की अधिकतम सीमा के बीच निम्नलिखित कुछ सकारात्मक पूर्णांक इनपुट (किसी भी मानक आधार में लिखा गया) करेगा:

मान को परिभाषित 1-2-3-त्रिभुज के संख्यात्मक प्रतिनिधित्व में परिवर्तित करें।
इस बाइनरी-जैसे प्रतिनिधित्व का उपयोग करना, और इसे पढ़ें जैसे कि यह बाइनरी था। इसका मतलब यह है कि अंक समान रहते हैं, लेकिन उनका मतलब क्या होता है।
इस बाइनरी नंबर को लें और इसे मूल संख्या के आधार में परिवर्तित करें।
इस नए नंबर को आउटपुट करें या लौटाएं।

हालाँकि, जब तक आउटपुट मान्य है, आपको इन चरणों का पालन करने की आवश्यकता नहीं है। यदि आप जादुई रूप से कुछ ऐसा फॉर्मूला खोजें जो छोटा हो (और गणितीय रूप से समतुल्य हो), इसका उपयोग करने के लिए स्वतंत्र महसूस करें।

उदाहरण

फ़ंक्शन fको परिभाषा द्वारा वर्णित फ़ंक्शन होने दें, और दिए []गए चरणों का प्रतिनिधित्व करें (जैसा कि थोड़ा-सा एंडियन, हालांकि यह बात नहीं होनी चाहिए) (आपको इस प्रक्रिया का पालन करने की आवश्यकता नहीं है, यह सिर्फ वर्णित प्रक्रिया है):

>>> f(1)
[1]
[1]
[1]
1

>>> f(5)
[5]
[0, 1, 1]
[6]
6

>>> f(63)
[63]
[0, 0, 0, 1, 0, 1, 1]
[104]
104

— एडिसन क्रम्प
स्रोत

क्या मैं एक अलग कार्यक्रम प्रस्तुत कर सकता हूं, जो छोटा नहीं है, यह प्रश्न तेजी से हल करेगा? log (log (n)) + n समय लॉग के विपरीत (n) + n समय। जाओ एनएच पावर मैट्रिक्स।

— f --n

@LliwTelracs मैं आपको अपने समाधान पोस्ट करने से नहीं रोक सकता। बस उस समाधान विधि को अपने ज्ञान को संक्षिप्त रूप में लक्षित करें जैसा कि आप सुनिश्चित कर सकते हैं कि आप अभी भी सही क्षेत्र में प्रतिस्पर्धा कर रहे हैं।

— एडिसन क्रम्प

ठीक है, कम से कम यह करने के लिए नहीं जा रहा है। इस मैट्रिक्स का तेजी से विस्तार हास्यास्पद रूप से होता है

— fɛnɪt Febk

2

@LliwTelracs शायद इसे अपनी मौजूदा पोस्ट में एक परिशिष्ट के रूप में जोड़ें।

— जोनाथन एलन

आपकी चुनौती उन लोगों के लिए अवैध है जो चित्र नहीं दिखा सकते हैं।

— माइंडविन

7

जावास्क्रिप्ट 117 111 बाइट्स

5 बाइट से गोल्फ की मदद करने के लिए @theonlygusti को धन्यवाद

x=>{r=0;a=[1,2,3];i=1;while(a[++i]<x)a[i+1]=a[i]+a[i-1]+a[i-2];for(;x;i--)if(x>=a[i]){r+=1<<i;x-=a[i]}return r}

यह काम किस प्रकार करता है

सबसे पहले, फ़ंक्शन सभी ट्रिब्यून नंबर उत्पन्न करता है जब तक कि यह इनपुट से अधिक नहीं मिलता है

a=[1,2,3];i=1;for(;a[++i]<x;)a[i+1]=a[i]+a[i-1]+a[i-2];

अगला, यह संख्याओं की सूची को उलटता है। यदि कोई संख्या इनपुट से कम है, तो यह 2 ^ (उस नंबर का इंडेक्स) को रिटर्न वैल्यू में जोड़ता है और उस नंबर से इनपुट को कम करता है।

for(;x;i--)if(x>=a[i]){r+=1<<i;x-=a[i]}

अंत में यह परिणाम देता है।

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

— fənɛtɪk
स्रोत

1

a[++i]<xएक बाइट को बचाने के लिए हालत के लिए अंदर क्या है ?

— theonlygusti

1

इसके अलावा, आप के x>0साथ बदल सकते हैं x। एक और 2 बाइट्स सहेजें।

— theonlygusti

यह एक बहुत अच्छा एल्गोरिथ्म है। oo

— Addison Crump

7

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

रॉड के लिए -3 बाइट्स धन्यवाद ( रीप काम करता है के iसाथ एक इंट में बूलियन कास्टिंग के लिए स्वच्छ चाल )+i`+i`

n=input()
x=[3,2,1]
r=''
while x[0]<n:x=[sum(x[:3])]+x
for v in x:i=n>=v;n-=v*i;r+=`+i`
print int(r,2)

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

— जोनाथन एलन
स्रोत

1

आप '01'[i]`+i`

— रॉड

iएक बूलियन एक int नहीं है। संपादित करें - ओह +i, स्वच्छ।

— जोनाथन एलन

3

@Rod है कि पायथन 2 युक्तियाँ और चाल में चाल?

— एडिसन क्रम्प

@VoteToClose मुझे ऐसा नहीं लगता

— रॉड 16

7

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

यहाँ, हम reduce()एक पुनरावर्ती कार्य पर उपयोग कर रहे हैं । हम मानते हैं कि आउटपुट 31-बिट है (जो कि सबसे बड़ी अहस्ताक्षरित मात्रा है जिसे जेएस आसानी से बिटवाइज़ ऑपरेशन के लिए आसानी से काम कर सकता है)।

n=>[...Array(x=31)].reduce(p=>(c=(F=k=>k<4?k:F(--k)+F(--k)+F(--k))(x--))>n?p:(n-=c,p|1<<x),0)

प्रदर्शन के लिहाज से, यह स्पष्ट रूप से बहुत कुशल नहीं है।

जिज्ञासु के लिए:

F()एन + 1 reduce()पुनरावृत्तियों बनाम एन पुनरावृत्तियों के लिए कॉल की संख्या के बीच का अनुपात जल्दी से ट्रिबोनैचि कॉन्स्टेंट () 1.83929) की ओर परिवर्तित होता है। इसलिए, आउटपुट में प्रत्येक अतिरिक्त बिट की लागत पिछले एक की तुलना में लगभग दो बार होती है।
31 बिट्स के साथ, F()फ़ंक्शन को 124 मिलियन बार एक अच्छा कहा जाता है।

परीक्षा

NB: इसे पूरा करने में 1 या 2 सेकंड का समय लग सकता है।

कोड स्निपेट दिखाएं

let f =

n=>[...Array(x=31)].reduce(p=>(c=(F=k=>k<4?k:F(--k)+F(--k)+F(--k))(x--))>n?p:(n-=c,p|1<<x),0)

console.log(f(63))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

वाह, जब मैं इसका उपयोग करता हूं तो मेरा ब्राउज़र बंद हो जाता है। xD

— Addison Crump

@VoteToClose प्रदर्शन के लिहाज से, यह काफी अक्षम है। :-) परीक्षण कोड बहुत लंबे समय तक नहीं चलना चाहिए, हालांकि। मेरे बॉक्स में, मुझे फ़ायरफ़ॉक्स में लगभग 600ms और क्रोम में 900ms मिलते हैं। क्या यह आपकी तरफ से बहुत धीमा है?

— Arnauld

जैसे, ५ सेकंड। xD

— Addison Crump

@VoteToClose अब थोड़ा तेज होना चाहिए। 32 वें पुनरावृत्ति व्यर्थ था, इसलिए मैंने आउटपुट को एक अहस्ताक्षरित 31-बिट पूर्णांक तक सीमित कर दिया है।

— अरनौलद

6

गणितज्ञ, 78 74 बाइट्स

Fold[#+##&,#~NumberDecompose~Reverse@LinearRecurrence[{1,1,1},{1,2,3},#]]&

LinearRecurrence[{1,1,1},{1,2,3},#]1-2-3 जनजातीय संख्या के इनपुट के बराबर लंबाई की एक सूची बनाता है। ( प्रारंभिक मूल्यों के {1,1,1}अनुसार, पिछले तीन शब्दों के योग का प्रतिनिधित्व करता है {1,2,3}।) फिर #~NumberDecompose~सूची के तत्वों के योग के रूप में इनपुट लिखने का लालची तरीका खोजता है (यह वही फ़ंक्शन है जो मौद्रिक राशि को गुणकों में घटा देगा। उपलब्ध मुद्राएँ, उदाहरण के लिए)। अंत में, Fold[#+##&,...]परिणामी बाइनरी सूची को (बेस -10) पूर्णांक में परिवर्तित करता है।

पिछला सबमिशन:

Fold[#+##&,#~NumberDecompose~Reverse@Array[If[#<4,#,Tr[#0/@(#-Range@3)]]&,#]]&

जैसा कि अक्सर होता है (हालांकि ऊपर नहीं), यह गोल्फ संस्करण 20 या उससे अधिक के इनपुट पर सुपर स्लो है, क्योंकि यह ट्राइब्स की एक सूची (नॉन-ऑप्टिमाइज़्ड रिकर्सन) के साथ उत्पन्न होता है, जिसकी लंबाई इनपुट है; बेहतर प्रदर्शन में परिणाम की #तरह अधिक उचित बाध्य द्वारा फाइनल की जगह Round[2Log@#+1]।

— ग्रेग मार्टिन
स्रोत

Whaat? Mathematica में एक 123Tribonacci[]बिल्डिन नहीं है ?

— palsch

1

बिल्कुल नहीं, हालांकि यह पता चला है कि बिलिन का उपयोग करने से थोड़ी मदद मिलती है।

— ग्रेग मार्टिन

5

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

(a!b)c=a:(b!c)(a+b+c)
e#(r,c)|c-e<0=(2*r,c)|1<2=(2*r+1,c-e)
f n=fst$foldr(#)(0,n)$take n$(1!2)3

प्रयोग उदाहरण: f 63-> 104। इसे ऑनलाइन आज़माएं! ।

यह कैसे काम करता है: !1-2-3-जनजातीय अनुक्रम बनाता है। यह देखते हुए 1, 2और 3शुरू पैरामीटर के रूप में, हम पहले ले nअनुक्रम के तत्वों। फिर हम सही फ़ंक्शन से गुना करते हैं, #जो अगले तत्व eको घटाता है nऔर rयदि eआवश्यक हो तो बिट वैल्यू सेट करता है या बिट को परेशान करता है। बिट सेट करना दोहरीकरण rऔर जोड़ना है 1, इसे अनसेट करना केवल दोहरीकरण है।

— nimi
स्रोत

4

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

S=³
3RUµḣ3S;µ<³Ạµ¿µŒPÇÐfṀe@Ð€µḄ

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

मैं लगभग निश्चित हूँ कि जेली में इसे प्राप्त करने के लिए एक छोटा रास्ता है।

कैसे?

S=³ - Link 1, compare sum to input: list
S   - sum
  ³ - 3rd command line argument which is 1st program argument.
 =  - equal?

3RUµḣ3S;µ<³Ạµ¿µŒPÇÐfṀe@Ð€µḄ - Main link: n
3RU                         - range(3) upended -> [3,2,1]
   µ    µ   µ¿              - while
         <³                 - less than input (vectorises)
           Ạ                - all?
    ḣ3S;                    -     head(3), sum, and concatenate
                                  [3,2,1] -> [6,3,2,1] -> [11,6,3,2,1] -> ...
              µ             - monadic chain separation, call the result x
               ŒP           - power set of x - e.g. for [6,3,2,1] -> [[],[6],[3],[2],[1],[6,3],[6,2],[6,1],[3,2],[3,1],[2,1],[6,3,2],[6,3,1],[6,2,1],[3,2,1],[6,3,2,1]]
                  Ðf        - filter keep
                 Ç          -     last link (1) as a monad (those that sum to the input)
                    Ṁ       - maximum (e.g. an input of 63 would yield [[37,20,6],[37,20,3,2,1]], the maximum of which is [37,20,6], the one with the largest numbers used)
                         µ  - monadic chain separation (to have x as the right argument below)
                     e@Ð€   - exists in with reversed arguments mapped over x (e.g. [37,20,6] with x = [68,37,20,11,6,3,2,1] yields [0,1,1,0,1,0,0,0])
                          Ḅ - convert from binary to integer.

— जोनाथन एलन
स्रोत

4

पर्ल 6 , 93 91 बाइट्स

-2 बाइट्स b2gills के लिए धन्यवाद

{my@f=1,2,3,*+*+*...*>$^n;sum @f».&{$_~~any first *.sum==$n,@f.combinations}Z*(2 X**^∞)}

यह काम किस प्रकार करता है

सबसे पहले, यह इनपुट से पहले पहले तत्व तक 1-2-3-ट्रिबोनैचि अनुक्रम उत्पन्न करता है:
```
my @f = 1, 2, 3, *+*+* ... * > $^n;
```
इसके आधार पर यह उस क्रम का सबसेट ढूंढता है जो इनपुट में जुड़ता है:
```
first *.sum==$n, @f.combinations
```
इसके आधार पर, यह निर्दिष्ट करने वाले बूलियंस की एक सूची का निर्माण करता है कि क्या अनुक्रम का प्रत्येक तत्व राशि का हिस्सा है:
```
@f».&{$_~~any ...}
```
और अंत में यह सही 2 की सूची की व्याख्या करता है = आधार 2 के रूप में गलत = 0 मान और इसे (आधार 10) नंबर के रूप में लौटाता है:
```
sum ... Z* (2 X** ^∞)
```

— SMLS
स्रोत

1

आप इसका उपयोग करके *>$^nऔर इसे छोटा कर सकते हैं .sum==$n। इसके अलावा अंतरिक्ष के बीच की जरूरत नहीं है myऔर@f

— ब्रैड गिल्बर्ट b2gills

3

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

n=>(g=(x,y,z)=>(n>x&&g(y,z,x+y+z)*2)+!(n<x||![n-=x]))(1,2,3)

जब तक यह मूल संख्या तक नहीं पहुंचता, तब तक 1-2-3-ट्रिबोनैचि संख्याओं की गणना करता है, फिर जैसा कि पुनरावृत्ति अनइंस्टॉल होता है, बदले में प्रत्येक को घटाना होता है, परिणाम को दोगुना हो जाता है।

संपादित करें: @Arnauld के लिए 1 बाइट धन्यवाद सहेजा गया।

— नील
स्रोत

वाह! बहुत अच्छा। n=>(g=(x,y,z)=>(n>x&&g(y,z,x+y+z)*2)+!(n<x||![n-=x]))(1,2,3)एक बाइट बचा सकता है ?

— अरनौल्ड

@Arnauld मैं का उपयोग कर कुछ के लिए देख रहा था, n<x||लेकिन वह ![]सिर्फ प्रतिभा है।

— नील

2

बैच, 151 148 145 बाइट्स

@set/ar=0,n=%1
@call:c 3 2 1
@echo %r%
@exit/b
:c
@set/as=%1+%2+%3
@if %n% gtr %3 call:c %s% %*
@set/ar*=2
@if %n% geq %3 set/an-=%3,r+=1

मेरे जावास्क्रिप्ट उत्तर का पोर्ट। संपादित करें: रिवर्स ऑर्डर में मेरे सबरूटीन तर्क पास करके 3 बाइट्स सहेजे गए और @प्रत्येक लाइन पर अलग-अलग s का उपयोग करके एक और 3 बाइट्स @echo off।

— नील
स्रोत

2

जेली , 19 18 17 बाइट्स

Ḣx3+
BÇL¡2ị
²Ç€»ċ

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

पृष्ठभूमि

एक पूर्णांक को 1,2,3-त्रिभुज आधार में बदलने की कोशिश करने के बजाय, फिर बाइनरी से पूर्णांक तक, हम इसके विपरीत करेंगे: पूर्णांक को द्विआधारी में परिवर्तित करें, फिर 1,2,3-ट्रिओनआइस बेस से पूर्णांक तक, और वापस उच्चतम जो इनपुट से मेल खाता है। यह आसानी से पूरा होता है।

हम इनपुट 63 के लिए प्रक्रिया का अनुकरण करेंगे , विशेष रूप से वह चरण जहां 104 का परीक्षण किया गया है। बाइनरी में, सबसे महत्वपूर्ण से कम से कम महत्वपूर्ण अंक तक, 104 के बराबर है

 1  1  0  1  0  0  0
37 20 11  6  3  2  1

जहाँ दूसरी पंक्ति उन अंकों के स्थितीय मूल्यों का प्रतिनिधित्व करती है।

हम 1,2,3-जनजातीय अनुक्रम को दाईं ओर बढ़ा सकते हैं, यह देखते हुए कि जोड़े गए अंक एक ही पुनरावर्ती सूत्र का अनुपालन करते हैं। तीन मात्र अंकों के लिए, यह देता है

 1  1  0  1  0  0  0  0  0  0
37 20 11  6  3  2  1  0  1  0

अब, आधार 1,2,3-जनजातीय संख्या के मूल्य की गणना करने के लिए, हम पुनरावर्ती सूत्र का उपयोग कर सकते हैं। चूंकि प्रत्येक संख्या अपने दाईं ओर (ऊपर तालिका में) तीन नंबर का योग है, हम पहले अंक को हटा सकते हैं और शेष सरणी के पहले तीन अंकों में इसे जोड़ सकते हैं। 7 चरणों के बाद , जो कि 104 के बाइनरी अंकों की संख्या के बराबर है , हम केवल तीन अंकों के साथ बचे हैं।

 1  1  0  1  0  0  0  0  0  0
37 20 11  6  3  2  1  0  1  0

    2  1  2  0  0  0  0  0  0
   20 11  6  3  2  1  0  1  0

       3  4  2  0  0  0  0  0
      11  6  3  2  1  0  1  0

          7  5  3  0  0  0  0
          6  3  2  1  0  1  0

            12 10  7  0  0  0
             3  2  1  0  1  0

               22 19 12  0  0
                2  1  0  1  0

                  41 34 22  0
                   1  0  1  0

                     75 63 41
                      0  1  0

अब, चूंकि पहले और अंतिम शेष अंक दोनों में स्थितीय मान 0 है , इसलिए परिणाम मध्यम अंक है, अर्थात, 63 ।

यह काम किस प्रकार करता है

²Ç€»ċ   Main link. Argument: n

²       Yield n². Since 1.839² = 3.381921 > 2, the range [1, ..., n²] will contain
        the answer. Better bounds, at the cost of additional bytes are possible.
 Ç€     Map the the second helper link over [1, ..., n²].
   »    Take the maximum of n and each result.
    ċ   Count the occurrences of n.


BÇL¡2ị  Second helper link. Left argument: k. Right argument: n

B       Convert k to binary. Let's call the result A.
  L     Length; count the number of binary digits. Let's call the result l.
 Ç ¡    Apply the first helper link l times to A.
    2ị  Retrieve the second element.


Ḣ×3+    First helper link. Argument: A (array)

Ḣ       Head; pop and yield the first element of A.
 x3     Repeat it thrice.
   +    Add the result, component by component, to the beheaded A.

— डेनिस
स्रोत

2

जेली ( कांटा ), 17 16 बाइट्स

ḣ3S;µ¡
3RṚÇ³æFṪḄ

@Dennis को 1 बाइट थैंक्स दिया, जिसने इसे बिना चलाए ही गोल्फ कर दिया।

यह जेली के एक कांटे पर निर्भर करता है जहां मैं निराशाजनक रूप से अभी भी एक कुशल फ्रोबेनियस हल परमाणु को लागू करने पर काम कर रहा हूं। जो लोग रुचि रखते हैं, उनके लिए मैं मैथमैटिक की गति से मेल खाना चाहता हूं FrobeniusSolveऔर सौभाग्य से डैनियल लिक्टब्लॉ द्वारा पेपर "मेकिंग चेंज एंड फाइंडिंग रिपीफिट्स: बैलेंसिंग अ नॅप्सैक" में उनके तरीके की व्याख्या है ।

व्याख्या

ḣ3S;µ¡  Helper link. Input: a list
    µ   Create monadic chain
ḣ3        Take the first 3 items
  S       Sum
   ;      Prepend to the list
     ¡  Repeat it n (initial argument from main) times

3RṚÇ³æFṪḄ  Main link. Input: integer n
3          The constant 3
 R         Range. Makes [1, 2, 3]
  Ṛ        Reverse. Makes [3, 2, 1]
   Ç       Call the helper link on that list.
           Generates the first (n+3) 123-Tribonacci values in reverse
    ³      Get n
     æF    Frobenius solve for n using the first n 123-Tribonacci values in reverse
       Ṫ   Tail. Take the last value. The results of Frobenius solve are ordered
           where the last result uses the least
        Ḅ  Unbinary. Convert digits from base 2 to base 10

— मील की दूरी पर
स्रोत

3

आप जानते हैं कि जब आप सुपर-एसॉलंग के कांटे का उपयोग कर रहे हैं तो आप कोड गोल्फ में गहरे उतर रहे हैं।

— Addison Crump

चाहेंगे ḣ3S;µ¡¶3RṚÇ³æFṪḄकाम करते हैं? मेरे पास आपका कांटा स्थापित नहीं है, इसलिए मैं परीक्षण नहीं कर सकता।

— डेनिस

@ डेनिस कि स्टड से इनपुट ले रहे हैं, तर्क नहीं? मुझे तर्कों का उपयोग करने में परेशानी हो रही थी और बस एहसास हुआ कि यह दूसरे तरीके से काम करता है।

— मील

नहीं, यह अभी भी तर्क होना चाहिए। ³पहले तर्क का संदर्भ देता है।

— डेनिस

@ डेनिस एनवीएम, यह तर्कों द्वारा काम करता है, मेरी jelly.pyआखिरी प्रतिबद्धता के बाद इसमें कुछ अन्य बातें थीं।

— मील

1

डीसी , 110 102 बाइट्स

?se1sa2sb3sc_1sf[laddSdlbdsalcdsb++sclf1+sfle>y]dsyx0sk[lk2lf^+skler-se]sr[Lddle!<rlf1-dsf0!>z]dszxlkp

अच्छा लगता है, जैसे महान दिमाग एक जैसा सोचते हैं। जाहिरा तौर पर, मैं जिस एल्गोरिथ्म के साथ आया था, dcवह संयोग की सीमाओं के आसपास है, संयोग से ठीक वैसा ही है जैसा @ LliwTelrac के उत्तर में इस्तेमाल किया गया था। दिलचस्प।

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

— आर। कप
स्रोत

1

अजगर २ , 93 बाइट्स

n=input();y=k=n*n
while y>n:
 x=y=z=0;k-=1
 for t in bin(k):x+=t=='1';x,y,z=y+x,z+x,x
print k

यह मेरे जेली उत्तर का एक बंदरगाह है ।

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

— डेनिस
स्रोत

1

बैश + बीएसडी उपयोगिताओं (ओएस एक्स, आदि), 53 बाइट्स

jot $[2#$1**4]|egrep -v '[2-9]|11(1|$)'|sed $[2#$1]!d

bash + GNU उपयोगिताओं (BSD के तहत भी काम करता है), 59 बाइट्स

seq -f2o%.fp $[2#$1**2]|dc|egrep -v '11(1|$)'|sed $[2#$1]!d

उपरोक्त दोनों में इनपुट और आउटपुट बाइनरी में हैं।

TIO पर GNU संस्करण आज़माएं। (उदाहरण 111111 के इनपुट से जुड़ा हुआ है, जो बाइनरी में 63 है, और 1101000 का आउटपुट है, जो बाइनरी में 104 है।)

मुझे नहीं लगता कि TIO एक BSD विकल्प प्रदान करता है, लेकिन अगर आपके पास एक मैक उपलब्ध है, तो आप उन दोनों को वहां से आज़मा सकते हैं। (59-बाइट प्रोग्राम 53-बाइट प्रोग्राम की तुलना में बहुत तेज़ है।)

दुर्भाग्य से, seqबस के स्थान पर बीएसडी समाधान में नहीं गिराया जा सकता है jot, क्योंकि आउटपुट स्वरूप के लिएseq लिए आउटपुट 999999 से ऊपर के आउटपुट के लिए अलग है। (32 के आसपास इनपुट के लिए एक समस्या होने लगती है, 32 ^ 4> 1000000 के बाद से)

आप इसे GNU उपयोगिताओं के साथ काम करने के लिए jotऊपर से बदल सकते seq -f%.fहैं, लेकिन समान 59 बाइट्स के लिए, आप उपरोक्त GNU समाधान का उपयोग कर सकते हैं, जो बहुत तेज़ है।

— मिशेल स्पेक्टर
स्रोत

आपका आधार 1-2-3-जनजातीय तक आपके आधार पर बाइनरी वापस

पृष्ठभूमि

1-2-3-जनजातीय अनुक्रम

ब्राउन का मानदंड

चुनौती के लिए इसका क्या मतलब है

इस संख्यात्मक प्रतिनिधित्व प्रणाली में कैसे लिखें

परिभाषा (अंत में)

उदाहरण

जावास्क्रिप्ट 117 111 बाइट्स

यह काम किस प्रकार करता है

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

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

परीक्षा

गणितज्ञ, 78 74 बाइट्स

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

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

कैसे?

पर्ल 6 , 93 91 बाइट्स

यह काम किस प्रकार करता है

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

बैच, 151 148 145 बाइट्स

जेली , 19 18 17 बाइट्स

पृष्ठभूमि

यह काम किस प्रकार करता है

जेली ( कांटा ), 17 16 बाइट्स

व्याख्या

डीसी , 110 102 बाइट्स

अजगर २ , 93 बाइट्स

बैश + बीएसडी उपयोगिताओं (ओएस एक्स, आदि), 53 बाइट्स

bash + GNU उपयोगिताओं (BSD के तहत भी काम करता है), 59 बाइट्स