Stöhr अनुक्रम उत्पन्न करें

Question

मैं रूबी सीख रहा हूं और इस समस्या को हल करने के लिए अपना पहला nontrivial कोड लिखा है।

स्ट्रोह अनुक्रम , एस के पहले n तत्वों को उत्पन्न करने की चुनौती है , जिसे निम्नानुसार परिभाषित किया गया है:

एस [०] = १

एस [एन] सबसे छोटी संख्या है जिसे अनुक्रम में दो अलग-अलग पिछले तत्वों के योग के रूप में व्यक्त नहीं किया जा सकता है।

इस प्रकार अनुक्रम 1, 2, 4, 7 और 10 से शुरू होता है। अगला तत्व 13 है, क्योंकि 11 (= 1 + 10) और 12 (= 2 + 10) पिछले तत्वों के योग हैं, लेकिन 13 नहीं है।

मैं सबसे छोटा कोड ढूंढ रहा हूं। रूबी में मेरा अपना, 108 वर्ण लंबा है, लेकिन शायद मैं यह देखने के लिए इंतजार करूंगी कि दूसरे इसे पोस्ट करने से पहले क्या करते हैं?

Comments

मुझे अब तक के जवाब पसंद हैं। अब, शायद वापस जाने और आवश्यकताओं को बदलने में बहुत देर हो गई है, लेकिन मुझे लगता है कि मुझे उल्लेख करना चाहिए कि मैं विशेष रूप से उन समाधानों में रुचि रखता हूं जो अनुक्रम की परिभाषा का उपयोग करते हैं (यानी, कोड पहले से नहीं जानता है कि अंततः संख्या 3 से ऊपर)। तो: नैतिक बोनस अंक यदि आप ऐसा कर सकते हैं।

— थियोफाइल

गणितीय क्रमों के साथ ऐसी समस्या है। यदि आप पैटर्न जानते हैं, तो यह आमतौर पर छोटा होगा।

यह अनुक्रम बिना किसी उपयोग (?) के अंकगणित है।

— user75200

@ user75200 अनुक्रम अंकगणितीय नहीं है, जैसा कि आप पहले तीन तत्वों में अंतर से देख सकते हैं, लेकिन तीसरे तत्व से शुरू होने वाला परिणाम वास्तव में अंकगणितीय है। इसका उपयोग डाक टिकट समस्या के संबंध में किया जाता है।

— थियोफाइल

Answer 1

एपीएल,,

एपीएल में आप चुन सकते हैं कि आप इंडेक्स 0 या इंडेक्स 1 के साथ काम करना चाहते हैं। आप ऐसा ग्लोबल वैरिएबल ←IO can 0 सेट करके करते हैं।

यदि हम इंडेक्स 0 में काम करना चुनते हैं तो हमारे पास है:

+\3⌊1⌈⍳

स्पष्टीकरण:

⍳    creates a sequence 0...n   (0 1 2 3 4 5)
1⌈   takes whichever is bigger, number in sequence or 1 (1 1 2 3 4 5)
3⌊   takes whichever is lower, number in sequence or 3 (1 1 2 3 3 3)
+\   partial sums for the sequence (1 2 4 7 10 13)

इसे tryapl.org पर आज़माएं

Comments

क्या आप 1 आधारित सूचकांक के साथ काम नहीं कर सकते हैं और फिर 1 से n सरणी बना सकते हैं और बस इसे दूसरे 1 के साथ जोड़ सकते हैं? अगर ऐसा किया जा सकता है, तो क्या यह छोटा है?

— ऑप्टिमाइज़र

मुझे मिला कोड लंबा था। यह 1, 10 वर्णों के लिए मेरा कोड था: + \ 3 ,1, +1 + इसके अलावा, सूचकांक-0 संस्करण तर्क 0 के साथ भी काम करता है, जबकि यह एक नहीं करता है।

— मोरिस ज़ुका

आह। हाँ। एपीएल वास्तव में यहाँ के माध्यम से चमक रहा है ..

— अनुकूलक

Answer 2

हास्केल - 1 1 21

आलसी अनंत क्रम

1:2:[4,7..]

फ़ंक्शन जो केवल सदस्यों की संख्या की आपूर्ति करता है (आह)

flip take$1:2:[4,7..]

Comments

आप है एक इनपुट लेने के लिए और केवल पहले मुद्रित करने के लिए nसंख्या।

— ऑप्टिमाइज़र

@Optimizer ठीक है, तकनीकी रूप से , आप है "पहले उत्पन्न करने के लिए n -यह कहना नहीं है कि आप के रूप में अच्छी उनमें से बाकी उत्पन्न नहीं कर सकते Stöhr अनुक्रम के तत्वों"! यह नहीं कहता कि आपको इनपुट लेना है। swish का मूल कोड वास्तव में किसी भी n के लिए पहला n शब्द उत्पन्न करता है ।

— वैचेगिन

@Chargin ओवरस्मार्ट होने की कोशिश करना कोई नई बात नहीं है। ओपी के शब्दांकन को भी शाब्दिक रूप से लेना और आवश्यकता से अधिक अतिरिक्त उत्पादन करना दोनों को मानक खामियों के रूप में माना जाता है।

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र दरअसल, आलसी होने का मतलब यह है कि जब तक आप इसके लिए नहीं पूछेंगे, तब तक कोई अतिरिक्त आउटपुट उत्पन्न नहीं होगा, और आप अपनी इच्छा के अनुसार कोई भी शब्द पूछ सकते हैं।

— बेंत की मार

@ मेरी समझ में नहीं आता। यहाँ क्या आलसी है?

— ऑप्टिमाइज़र

Answer 3

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

lambda n:[1,2][:n]+range(4,n*3-4,3)

एक पैटर्न का उपयोग कर ...

Comments

आप इसे 4रेंज में शामिल कर सकते हैं :lambda n:[1,2][:n]+range(4,n*3-4,3)

— जकुबे

अच्छा लगा। अब 35 को संपादित।

— लॉजिक नाइट

Answer 4

CJam, 14 बाइट्स

1l~{_p_3e<+}*;

इसका परीक्षण यहां करें।

1 पर शुरू होता है। फिर, S [n] = S [n-1] + मिनट (S [n-1], 3) ।

1l~{_p_3e<+}*;
1              "Push 1.";
 l~            "Read and evaluate input N.";
   {       }*  "Repeat this block N times.":
    _p         "Duplicate the last number and print it.";
      _3e<     "Duplicate it again, and take minimum with 3.";
          +    "Add to last number.";
             ; "Discard final number to prevent output.";

अगर हम 3 को 2 ^h -1 से बदल दें तो यह आसानी से h -örr दृश्यों को सामान्य बनाता है ।

Answer 5

ब्रेनफक, 13 वर्ण

+.+.++.[+++.]

या अगर हम इसे एन आउटपुट तक सीमित करना चाहते हैं तो 30 वर्ण:

,->+.<[->+.<[->++.<[->+++.<]]]

Comments

मुझे लगता है कि आपको पहले nतत्वों को मुद्रित करने की आवश्यकता है , न कि उनमें से एक अनंत धारा ...

— Sp3000

@ Sp3000 आम तौर पर स्वीकृत सांख्यिक इनपुट और आउटपुट के रूप में चारकोड का उपयोग कर रहा है? मेटा पर नहीं मिल रहा है। इसके साथ ही BF कोड को सही करना काफी आसान होगा।

— रैंडमरा

व्यक्तिगत रूप से मुझे यकीन नहीं है कि इसके लिए सामान्य सहमति क्या है, क्षमा करें। मुझे इसमें भी थोड़ी परेशानी हुई है।

— Sp3000

पहले n तत्वों के लिए, मुझे लगता है कि मैं कर सकता था -> + +। <[-> </> <-> </>> <-> </>> (29 वर्ण), लेकिन यह उतना सुरुचिपूर्ण नहीं है। । और मुझे नहीं लगता कि इनपुट और आउटपुट के लिए भाषा विशेष रूप से ASCII कोड का उपयोग करने तक सीमित है।

— jgosar

आपके कोड को प्रश्न का उत्तर देना होगा, भले ही वह सुरुचिपूर्ण न हो। मैं पोस्ट को संपादित करने और उत्तर को सही करने का सुझाव दूंगा ,->+.<[->+.<[->++.<[->+++.<]]]। (आपने शुरुआत में इनपुट रीडिंग कॉमा को याद किया।)

— यादृच्छिक

Answer 6

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

def f(n):
 if n<1:return[1]
 x=f(n-1);y=set(x)|{a+b for a in x for b in x if a!=b};return x+[min([a for a in range(1,max(y)+2)if{a}-y])]

सीधे परिभाषा से। मुझे यकीन नहीं है कि मैं इसे कितना गोल्फ सकता हूं - यह निश्चित रूप से मेरी अपेक्षा से बहुत अधिक लंबा है।

Answer 7

जे, 14 चरस

यह सिर्फ [1,2, 4+3*k (k=0..n-1) ]अनुक्रम को हार्डकोड करता है और पहले लेता है N।

   ({.1,2,4+3*i.) 10
1 2 4 7 10 13 16 19 22 25

।

जे, 18 वर्ण

यह एक रैखिक संयोजन का उपयोग करता है [0,1,2,3...], [1,1,0,0...]और [0,1,1,1...]। कम होना चाहिए, लेकिन यह गोल्फ के लिए प्रतीत नहीं हो सकता।

   ((3&*+<&2-2**)@i.) 10
1 2 4 7 10 13 16 19 22 25

Answer 8

प्रस्तावना , ३२ २०

संपादित करें: ... अब दो बार आवाज़ों के साथ!

?(1-)
4 +3
2  ^
1 !^

यह पायथन दुभाषिया के साथ मानता है NUMERIC_OUTPUT = True। ब्रेनफक सबमिशन की तरह यह उत्तर मानता है कि इनपुट एक कोड बिंदु के रूप में दिया गया है। यह आंशिक रूप से इस मेटा चर्चा के लिए और अधिक ध्यान आकर्षित करने के लिए है (और आंशिक रूप से, क्योंकि मुझे प्रेयले से प्यार है)। इसलिए यदि आप पहले 32 नंबर प्रिंट करना चाहते हैं, तो कहते हैं, आपको एसटीडीआईएन पर एक जगह डालनी होगी। बेशक, इसका मतलब है कि वैध इनपुट्स की ऊपरी सीमा है, लेकिन यह जवाब वैसे भी नहीं जीत रहा है, इसलिए मुझे लगता है कि प्रस्तावना की सीमाओं के भीतर यह ठीक है।

व्याख्या

प्रील्यूड में, सभी लाइनों को समानांतर में निष्पादित किया जाता है, जो कि अपने स्वयं के स्टैक के साथ होती है, जो अनंत राशि के ज़ीरो से आरंभ होती है। केवल एक ही निर्देश सूचक (स्तंभों की ओर इशारा करते हुए) है, इसलिए यदि आप एक स्वर में एक लूप दर्ज करते हैं, तो अन्य सभी आवाज़ें इसके साथ लूप करेंगी।

निम्नलिखित में मैंने कोड को स्थानांतरित किया है, ताकि मैं कॉलम के बजाय लाइनों को एनोटेट कर सकूं:

?421  Read a character into the first stack. Push 4, 2, 1 onto the other stacks, respectively.
      Generally, the fourth stack will hold the next number to be printed, the third stack the
      one after that, and the second stack the number two steps ahead.
(     Start a loop if the input wasn't 0.
1+ !  Push a 1 onto the first stack. Add the top elements in the second stack. On the first
      iteration this will be 0 and 4, so it does nothing. On all further iterations
      this will increment the last number by 3.
-3^^  Subtract one from the first stack. Push a 3 onto the second stack for the next iteration.
      Copy the last value from the second to the third, and the third to the fourth stack.
)     If the top of the first stack is not 0, jump back to the column after the (.

Answer 9

जावास्क्रिप्ट (ईएस 6) 92

समस्या की परिभाषा पर आधारित एक पुनरावर्ती कार्य के रूप में

S=(n,v=1,s=[],r=0)=>[for(a of s)for(b of s)r+=(a-b&&a+b==v)]|r||(s.push(v),--n)?S(n,v+1,s):s

पैटर्न 1,2, 1 + 3 * k: 58 का उपयोग करना

S=(n)=>(i=>{for(t=1;n>r.push(t+=i);i+=(i<3));})(0,r=[])||r

साइड नोट: h-Stöhr अनुक्रम को खोजना ( hकेवल 2 के बजाय संख्या तक के योग को सत्यापित करना )। Rसमारोह सूची तत्वों की दी गई संख्या के ऊपर के सभी संभव रकम कोशिश करता है।

S=(n,h=2,s=[],v=1,R=(t,v,l,i=0,r=t,w)=>{
  for(;r&&l&&v[i];i++)
    w=[...v],r=!R(t-w.splice(i,1),w,l-1)
  return!r;
})=>R(v,s,h)||(s.push(v),--n)?S(n,h,s,v+1):s

लगभग बराबर (और ES5 संगत) Ungolfed

function S(n, v, s)
{
  var r=0,a,b
  v = v||1
  s = s||[]
  for(a of s)
    for(b of s)
    {
      if (a != b && a+b == v) 
        r++;
    }
  if (r == 0) 
  {
    s.push(v);
    --n;
  }
  if (n != 0)
     return S(n,v+1,s)
  else
     return s
}

FireFox / FireBug कंसोल में टेस्ट करें । सरल कार्य:

S(20)

[1, 2, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 31, 34, 37, 40, 43, 46, 49, 52, 55]

उन्नत समारोह:

S(10,5)

[1, 2, 4, 8, 16, 32, 63, 94, 125, 156]

Answer 10

> <> (मछली) , 49२ ६५ ४ ९ ४६ चर

1n1-:?!;' 'o2n1-v
v1&no' ':<4&;!?:<
>-:?!;&3+^

इनपुट दुभाषिया को आपूर्ति की जाती है:

>fish.py stohr.fish -v 10
1 2 4 7 10 13 16 19 22 25

मेरा पहला> <> कार्यक्रम, सुझाव की सराहना की।

Comments

ओह अच्छा! मैं उम्मीद कर रहा था कि कोई एक> <> प्रोग्राम लिखेगा।

— थियोफाइल

Answer 11

> <>, 31 बाइट्स

4i1nao:?!;2nao1-:?!;$:nao3+$d0.

एक ही चर में पढ़ता है, अपने कोड बिंदु (जैसे स्थान = 32) का उपयोग करता है और प्रत्येक पंक्ति पर संख्याओं को प्रिंट करता है।

Answer 12

पर्ल 6 22/30

मैं यह देखने जा रहा हूं कि क्या Perl6 मेरे लिए अनुक्रम को घटा सकता है या नहीं।

ऐसा करने के लिए मैंने पर्ल में निर्मित आरईपीएल का उपयोग किया

$ perl6
> 1,2,4,7...*
Unable to deduce arithmetic or geometric sequence from 2,4,7 (or did you really mean '..'?)
> 1,2,4,7,10...*
1 2 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 ...

हम्म, मैं उस पैटर्न को देखता हूं जिसे पर्ल ने घटाया था। अगले मूल्य को प्राप्त करने के लिए 4 के बाद आप सिर्फ 3 जोड़ दें।

1,2,4,*+3...*

जो एक चरित्र को बचाता है जो कोड को Stöhr अनुक्रम 13 वर्णों में लंबी संख्याओं की अनंत सूची प्राप्त करने के लिए बनाता है।

यह कोड केवल REPL में कुछ उपयोगी करता है क्योंकि यह हमारे लिए परिणाम का संकेत प्रिंट करता है। इसे प्रिंट करने के लिए अन्यथा आपको परिणामों को प्रिंट करने के लिए पर्ल को स्पष्ट रूप से बताना होगा।

$ perl6 -e 'say 1,2,4,*+3...*'

( * + 3बस एक कोड संदर्भ प्राप्त करने का एक तरीका है जो 3 रिटर्न देता है यह केवल तर्क है। इसे लिखने के अन्य तरीके होंगे { $_ + 3 }, या -> $i { $i + 3 }, { $^i + 3 }या sub ($i){ $i + 3 })

---

पहले n तत्वों को उत्पन्न करने के लिए कुछ कॉल करने योग्य बनाने का सबसे छोटा तरीका तत्वों का एक टुकड़ा प्राप्त करना है।

{(1,2,4,*+3...*)[^$_]} # 22

शून्य संदर्भ में जो पहले $_मान उत्पन्न करेगा , फिर उन्हें तुरंत फेंक दें।

शून्य संदर्भ के अलावा किसी भी चीज़ में यह एक अनाम कोड ब्लॉक (एक नाम के बिना एक मूल सबरूटीन) बनाता है जो एक तर्क लेता है।

# store it in a scalar variable
my $sub = {(1,2,4,*+3...*)[^$_]};
say $sub.(5);
# 1 2 4 7 10

# use it immediately
say {(1,2,4,*+3...*)[^$_]}.(5);
# 1 2 4 7 10

# pretend it always had a name
my &Stöhr-first = {(1,2,4,*+3...*)[^$_]};
say Stöhr-first 5;

अगर आपको वास्तव में लगता है कि इस चुनौती के लिए एक वैध के रूप में अर्हता प्राप्त करने के लिए एक नाम होना चाहिए, तो आप शायद ऐसा करेंगे:

sub s(\n){(1,2,4,*+3...*)[^n]} # 30

हालांकि s, प्रतिस्थापन संचालक के लिए भी इसका उपयोग किया जाता है, इसे कॉल करने के लिए परेंस गैर-वैकल्पिक होते हैं। (आप इसे एक अलग नाम दे सकते हैं जो मुझे लगता है)

say s(5);
# 1 2 4 7 10

Comments

जब तक अन्यथा चुनौती में निर्दिष्ट नहीं किया जाता है, गोल्फ चुनौतियों को कोड करने के लिए प्रस्तुतियाँ केवल स्निपेट नहीं, बल्कि पूरे कार्यक्रम या कार्य होने चाहिए ।

— मार्टिन एंडर

@ मार्टिनबटनर निष्पक्ष होना 1,2,4,*+3...*वास्तव में एक वस्तु बनाता है जो आवश्यक मूल्यों को उत्पन्न करेगा। मुझे लगता है कि कई लोगों को वास्तव में कुछ बनाना होगा नहीं लगता कि प्रतिदेय कि Perl6 में की तरह चारों ओर कुछ।

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

Answer 13

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

जावा 313 चार (स्क्रीन पर इसे फिट करने के लिए +4)

import java.util.*;public class S{public static void main(String[] a){
Set<Integer> S=new HashSet<Integer>();S.add(1);int i=1,k=0;
while(S.size()<=new Integer(a[0])){if(S.contains(i)){}else{k=0;for(int j:S){
for(int l:S){if(l!=j){if((j+l)==i)k=1;}}}if(k==0)S.add(i);}i++;}for(int x:S)
{System.out.println(x);}}}

हमेशा सुधार के लिए कोई सुझाव या संकेत प्राप्त करने के लिए आभारी

Answer 14

T-SQL 204

मान लेता है कि इनपुट @N नामक चर में है। यदि आप चाहें तो मैं एक प्रक्रिया कर सकता हूं, लेकिन टी-एसक्यूएल में STD_IN प्राप्त करने का एक अच्छा तरीका नहीं है।

इसके अलावा, नैतिक बोनस के लिए याय!

DECLARE @Q INT=0,@B INT=2
DECLARE @ TABLE(A INT)WHILE @N>0
BEGIN
SET @N-=1
WHILE @B>1
BEGIN
SET @Q+=1
SELECT @B=COUNT(*)FROM @ C,@ B WHERE C.A+B.A=@Q
END
INSERT INTO @ VALUES(@Q)SET @B=2
END
SELECT*FROM @

Comments

अच्छा! मैं SQL के बारे में बहुत कुछ नहीं जानता-यहाँ @N का उपयोग कैसे किया जाता है? मैं देखता हूं कि यह शुरुआत के करीब है, लेकिन फिर बाद में इसका संदर्भ नहीं लगता।

— थियोफाइल

ऐसा लगता @Nहै कि लूप के लिए "i" है।

— जैकब

याकूब सही है। @N लूप के लिए "i" है, जो एसक्यूएल में थोड़ी देर का लूप है। अनिवार्य रूप से यह अपने आप से तालिका में जुड़ जाता है और उन जोड़ियों को ढूंढता है जो @Q में जोड़ते हैं। यदि कम से कम दो जोड़े हैं (अर्थात केवल अपने साथ एक संख्या नहीं है), तो यह इसे छोड़ देता है। अन्यथा, यह इसे तालिका में जोड़ता है। @ तालिका का नाम है।

— bmarks

Answer 15

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

हम्म, अभी भी कोई गणितज्ञ जवाब नहीं? यहाँ दो हैं:

NestList[#+3~Min~#&,1,#-1]&
Array[i=1/2;i+=3~Min~i&,#]&

दोनों एक अनाम शुद्ध फ़ंक्शन को परिभाषित करते हैं जो पूर्णांक प्राप्त करता है और पूर्णांकों की सूची देता है। यह मेरे सीजेएम सबमिशन के समान पुनरावृत्ति संबंध पर आधारित है। ध्यान दें कि Array-based कोड से शुरू होता है 1/2, क्योंकि मूल्य वापस आने से पहले पुनरावृत्ति संबंध हमेशा लागू होता है।

Answer 16

जावा, ४६

n->IntStream.iterate(2,x->x==2?1:x+3).limit(n)

Comments

यह जावा 8.

— Ypnypn

Answer 17

अजगर - पास भी नहीं (139)

इस धारणा के तहत कार्य करना कि यह आसानी से गणना योग्य नहीं था जैसा कि दूसरों ने किया है, सबसे छोटा समाधान जो मैंने पाया है वह नीचे है:

from itertools import combinations as C
x,i,n=[],1,input()
while len(x)<=n:
 if i not in [sum(y) for y in C(x,2)]:x.append(i)
 i+=1
print n

Answer 18

क्लोजर - 130 118

(defn s[n](last(take n(iterate #(if(<(count %)3)(conj %(+ (apply + %)1))(conj %(+(last %)(second %)(first %))))[1]))))

अन-गोल्फ संस्करण:

(defn stohr [n]
  (last
    (take n
      (iterate #(if (< (count %) 3)
                   (conj % (+ (apply + %) 1))
                   (conj % (+ (last %) (second %) (first %)))) [1]))))

साझा करें और आनंद लें।

Answer 19

रूबी - १० - 88 88

q=->n{*k=1;(m=k[-1];k<<([*m+1..2*m]-k.combination(2).map{|i,j|i+j})[0])while k.size<n;k}

यह अनुक्रम की परिभाषा का उपयोग करता है।

अधिक पठनीय संस्करण:

q=->n{
    *k=1
    (
        m = k[-1]
        k << ([*m+1..2*m] - k.combination(2).map{|i,j|i+j})[0]
    ) while k.size < n
    k
}

प्रिंट q [10]

[१, २, ४, 4, १०, १३, १६, १ ९, २२, २५]

Comments

रूबी गोल्फ टिप्स: के *k=1बजाय k=[1]। foo while barके बजाय while bar;foo;end। [*s..e]के बजाय (s..e).to_a। .mapके बजाय to_a.map। {|a,b|a+b}के बजाय {|i|i.inject(:+)}।

— हिस्टोक्रेट

@ हिस्टोक्रेट थैंक्स, यह बहुत मददगार है!

— थियोफाइल

Answer 20

STATA 51

di 1 2 _r(a) 
loc b=3*$a-2
forv x=4(3)`b'{
di `x'
}

Answer 21

टीआई-बेसिक, 41 27 30 बाइट्स

अपने कैलकुलेटर के लिए

Input N:For(I,1,N:I:If I>2:(I-2)3+1:Disp Ans:End

Answer 22

जीएमएल , 67 बाइट्स

n=argument0;for(i=1;i<=n;i++){t=i;if i>2t=(i-2)*3+1show_message(t)}