SUDSI अनुक्रम उत्पन्न करें

15

SUDSI अनुक्रम ( su m, d ifference, s WAP, i ncrement) एक उत्सुक पूर्णांक अनुक्रम है जो अव्यवस्थित व्यवहार को प्रदर्शित करता है। इसे निम्नानुसार उत्पन्न किया जा सकता है:

चलो एस प्राकृतिक संख्या की एक अनंत सूची हो: 1 2 3 4 5 6 ...। चलो एस मैं निरूपित एक अनुक्रमित मैं की वें तत्व एस । तो शुरू में, एस 1 1 है, एस 2 2 है, आदि (कोई एस 0 नहीं है )।

S 1 और S 2 से शुरू ...

  • उनकी राशि की गणना करें: sum = S1 + S2
  • उनके पूर्ण अंतर की गणना करें (छोटा एक बड़ा बड़ा): diff = |S1 - S2|

  • योग और अंतर के सूचकांकों में S में दो मान स्वैप करें :swap(Ssum, Sdiff)

  • आप के साथ काम कर रहे हैं एस के सूचकांक में वृद्धि । तो अगली बार आप S 2 और S 3 के योग और अंतर की गणना करेंगे , और उसके बाद का समय S 3 और S 4 , आदि होगा।

  • इस प्रक्रिया को अनिश्चित काल तक दोहराएं।

यहां एस के पहले कुछ चरण हैं क्योंकि यह प्रक्रिया लागू होती है। कोष्ठक []उन दो मानों को घेरता है जो संक्षिप्त और भिन्न होने वाले हैं।

मूल S :

[1 2] 3 4 5 6 7 8 9 10 11 12 ...

बाद एस 3 ( 3 = 1 + 2) और एस 1 ( 1 = |1 - 2|) लगा दिया जाता था:

3 [2 1] 4 5 6 7 8 9 10 11 12 ...

बाद एस 3 और एस 1 लगा दिया जाता था:

1 2 [3 4] 5 6 7 8 9 10 11 12 ...

बाद एस 7 और एस 1 लगा दिया जाता था:

7 2 3 [4 5] 6 1 8 9 10 11 12 ...

बाद एस 9 और एस 1 लगा दिया जाता था:

9 2 3 4 [5 6] 1 8 7 10 11 12 ...

बाद एस 11 और एस 1 लगा दिया जाता था:

11 2 3 4 5 [6 1] 8 7 10 9 12 ...

बाद एस 7 और एस 5 लगा दिया जाता था:

11 2 3 4 1 6 [5 8] 7 10 9 12 ...

आदि।

SUDSI अनुक्रम को इनमें से प्रत्येक सूची में पहले तत्वों के अनुक्रम के रूप में परिभाषित किया गया है। तो SUDSI अनुक्रम के पहले कुछ शब्द हैं 1 3 1 7 9 11 11।

यहां SUDSI अनुक्रम के पहले 200 शब्द (20 प्रति पंक्ति) हैं:

1 3 1 7 9 11 11 11 15 15 19 19 19 19 19 19 19 19 19 19 
19 19 19 19 19 19 19 19 57 59 59 59 59 59 59 59 59 59 77 79 
81 83 85 87 89 91 91 91 91 91 91 91 91 91 91 91 91 91 115 115 
121 123 125 127 127 127 127 127 137 139 141 143 145 147 147 147 147 147 147 147 
147 147 147 147 167 167 167 167 167 167 167 167 167 167 167 167 167 167 167 167 
167 167 167 167 209 211 211 211 211 211 221 223 223 223 223 223 223 223 223 223 
223 223 243 243 243 243 243 243 257 259 261 263 263 263 263 263 263 263 263 263 
263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 
263 263 325 327 329 331 331 331 331 331 331 331 331 331 349 351 351 351 351 351 
361 363 363 363 363 363 363 363 363 363 363 363 363 363 363 363 363 363 363 363

यह स्पष्ट नहीं है (कम से कम मेरे लिए) कि कोई भविष्य की शर्तों की भविष्यवाणी कैसे कर सकता है। यह कहना केवल सुरक्षित लगता है कि शब्द हमेशा विषम, घटते (दूसरे कार्यकाल के बाद) होते हैं, और यह कि कुछ संख्याएँ बहुत बार दोहराई जाती हैं।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक n और प्रिंट में लेता है या SUDSI अनुक्रम के n वें शब्द को लौटाता है। उदाहरण के लिए, यदि n 1 है, तो आउटपुट है 1, यदि n 2 है, तो आउटपुट है 3, यदि n 200 है, तो आउटपुट है 363।

किसी भी सामान्य तरीके से इनपुट लें (स्टडिन / कमांड लाइन / फंक्शन arg)। बाइट्स में
सबसे छोटा जवाब जीत जाता है।
(वह साइट यूटीएफ -8 में चीजों को एन्कोड करती है, लेकिन आप किसी भी मौजूदा मौजूदा एन्कोडिंग का उपयोग कर सकते हैं जो आप चाहते हैं।)

मैटी बोनस: (संभावित रूप से इनाम के योग्य)

  • मुझे SUDSI अनुक्रम के बारे में और बताएं। इन नंबरों का अंतर्निहित पैटर्न क्या है और इसके कितने भाग हैं (और इस तरह सामान)? (मैं जिस तरह से OEIS पर SUDSI नहीं मिला ।)
code-golf  number  number-theory  sequence 
— केल्विन के शौक
स्रोत
फिर से। एन्कोडिंग के बारे में भ्रम पैदा करने से बेहतर लिंक नहीं है।
— ऑप्टिमाइज़र
@Optimizer मैं उम्र के लिए एक ही phrasing के साथ उस बाइट काउंटर से जुड़ रहा हूं । यह अचानक से अधिक भ्रम का कारण क्यों बनेगा?
— केल्विन के शौक
1
@orlp मुझे लगता है कि यह एक अच्छी अतिरिक्त सुविधा होगी, लेकिन मैं व्यक्तिगत रूप से कॉपी-पेस्ट करने में सक्षम होने पर भरोसा करता हूं क्योंकि मेरे पास मेरे प्रस्तुतिकरण के लिए शायद ही कभी स्रोत फाइलें हैं।
— मार्टिन एंडर
1
@orlp लेकिन फिर भी किसकी जरूरत होगी? यदि उनके पास फ़ाइल है तो वे सीधे आकार देख सकते हैं। और कुछ ऑपरेटिंग सिस्टमों में अंत में नईलाइन को निकालना इतना आसान नहीं है।
— jimmy23013
2
@ मार्टिनबटनर मैं ऊब गया था: meta.codegolf.stackexchange.com/questions/4944/…
— orlp

जवाबों:

5

पायथ, 45 41 40 38 बाइट्स

MXGH_HhugGm@Gtd,s<>GH2.a-@GH@GhHtQr1yQ

मैंने देखा (जैसा कि मार्टिन ब्यूटनर ने किया था), कि एक क्रमचय कदम की अधिकतम प्रभावित संख्या kहै 2k + 1। लेकिन चूंकि हमारे पास केवल n - 1कदम हैं, हमें केवल संख्याओं की सूची की आवश्यकता है 2n - 1।

इसे ऑनलाइन आज़माएँ: प्रदर्शन

M                       define a function g(G, H): return
                        (G is the list of numbers, H is a tuple)
 XGH_H                     a translation of G
                           (replaces the elements in H with the elements in reversed H)
                           in this application it swaps two values in the list G


                        implicit: Q = input()
 u     tQr1yQ           reduce, G = [1, 2, ..., 2*Q-1]
                        for each H in [0, 1, ..., Q - 2]:
                           G = 
  gG...                        g(G, ...)
h                       print the first element of the resulting list

And the second argument ... of the function call g is:

     ,                  create the tuple (
      s<>GH2               sum(G[H:][:2]), 
            .a-@GH@GhH     abs(G[H],G[H+1])
                        )
m@Gtd                   and map each value d to G[d - 1]
— Jakube
स्रोत
क्या एक पुस्तकालय के बाहर पाइथ का उपयोग करने के लिए जुर्माना है?
— एलेक्स ए।
1
@ एलेक्स ए हाहा, नहीं। लेकिन किताबें वापस नहीं करने के लिए एक है।
— जकुबे
18

मैथेमेटिका, 88 बाइट्स

Last[f@n_:=n;(r=f@1;{f@a,f@b}={f[b=+##],f[a=Abs[#-#2]]};r)&@@f/@{#,#+1}&/@Range@Input[]]

यह एक पूर्ण कार्यक्रम है, एक प्रॉम्प्ट से इनपुट को पढ़ना। यह परिभाषा का बहुत सीधा कार्यान्वयन है, जहां मैं वर्तमान अनुक्रम का ट्रैक रख रहा हूं f(जिनके मान f[n]डिफ़ॉल्ट हैं n)।

यहाँ थोड़ा अधिक पठनीय संस्करण है:

Last[
  f@n_ := n;
  (
    r = f@1;
    {f@a,f@b} = {f[b=+##],f[a=Abs[#-#2]]};
    r
  ) & @@ f /@ {#,#+1} & /@ Range @ Input[]
]

कुछ विश्लेषण

मैंने अनुक्रम के पहले 2000 तत्वों को प्लॉट किया है (यह वास्तव में बाद में अधिक दिलचस्प नहीं है):

यहां छवि विवरण दर्ज करें

तो अनुक्रम अनिवार्य रूप से ढलान 2 के साथ रैखिक है और हमेशा उन चरणों में से कुछ होते हैं। ऐसा लगता है कि कदम बहुत तेज़ी से बढ़ते हैं (यदि वे भी बंधे नहीं हैं), क्योंकि वे मुश्किल से ध्यान देने योग्य बन जाते हैं क्योंकि आप अपने अंकों की संख्या बढ़ाते हैं।

हम रेखीय विकास को काफी आसानी से सही ठहरा सकते हैं (यह थोड़ा सा हाथ से काम है, लेकिन मुझे लगता है कि यह प्रेरण द्वारा एक कठोर प्रमाण तक पकड़ सकता है): शुरू में, क्रमचय कदम की अधिकतम प्रभावित संख्या nहै n + (n+1) = 2n + 1। यह भी ध्यान रखें कि इन नंबरों हमेशा में ले जाया जाएगा 1, के बाद से |n - (n+1)| = 1। इसलिए यह आश्चर्यजनक नहीं है कि हमें संख्याएँ मिलती हैं जो लगभग 2nअनुक्रम में हैं। हालांकि, हम यह भी ध्यान दें सकता है कि अप करने के लिए कदम के लिए n , एस n + 1 हमेशा से घिरा है n + 1 , जिसका अर्थ है कि कोई अदला-बदली कदम दो नंबर जो दोनों से अधिक हैं स्वैप कर सकते हैं n । इसलिए, जिन संख्याओं को अभी भी संसाधित करने की आवश्यकता है, वे उनके प्रारंभिक मूल्य से कम या बराबर होंगे। इसलिये,2n + 1 यह भी अनुक्रम के लिए ही बाध्य है।

मुझे लगता है कि कदमों की लंबाई के लिए एक तर्क खोजना मुश्किल हो जाएगा।

— मार्टिन एंडर
स्रोत
3
एक अच्छा समाधान के लिए +1 लेकिन ज्यादातर बहुत दिलचस्प और जानकारीपूर्ण विश्लेषण के लिए!
— एलेक्स ए।
4

CJam, 45 40 39 बाइट्स

बस एक भोला दृष्टिकोण। आगे गोल्फ हो सकता है। एक सरणी स्वैप फ़ंक्शन बहुत अधिक याद आ रही है।

ri_K*,\{\:L>2<L1$:+:S@:-z:DL=tDSL=t}/1=

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

ri_                             "Read the input, convert to integer and copy it";
   K*,                          "Multiply the copy by 20 and get 0 to 20*input-1 array";
      \{ ... }/1=               "Swap and put input on stack and run the loop that many";
                                "times. After the loop, take the second element as";
                                "we have a 0 based array while series is 1 based";
{\:L>2<L1$:+:S@:-z:DL=tDSL=t}
 \:L                            "Swap to put iteration index behind the array";
                                "and store array in L";
    >2<                         "In each loop, the iteration index will be on stack";
                                "Get the two elements from the array starting at that";
       L1$                      "Put the array on stack and copy the tuple";
          :+:S                  "Get the sum and store it in S";
              @:-z:D            "Get the absolute difference of the tuple and store in D";
                    L=t         "Put the element at S diff at sum index";
                       DSL=t    "Put the element at S sum at diff index";

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत
4

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

f#n=let b=f$n+1;l=f n+b;r=abs$f n-b;y x|x==l=f r|x==r=f l|1<2=f x in y
p n=foldl(#)id[1..n-1]$1

उपयोग उदाहरण: p 70->139

मैं अनुक्रम को किसी सूची या सरणी में संग्रहीत नहीं करता। मैं बार-बार पहचाने जाने वाले फ़ंक्शन को मौजूदा चरण के दो तत्वों के साथ एक फ़ंक्शन में अपडेट करता हूं। nचरणों के बाद मैं परिणामी फ़ंक्शन को पैरामीटर के साथ कॉल करता हूं 1।

— nimi
स्रोत
1

Pyth, 55 53 51

शायद आगे गोल्फ हो सकता है। nमैं वास्तव में बड़े के लिए धीमा हो सकता हूं क्योंकि मुझे यह पता लगाने के लिए आलसी था कि मुझे एक सरणी की कितनी लंबी आवश्यकता होगी और बस एक का उपयोग किया जाएगा n^n।

यह इंगित करने के लिए कि मैं अधिकतम का उपयोग कर सकता हूं, अस्थिरता और मार्टिन ब्यूटनर के लिए धन्यवाद 3n।

KU*3QFNr1QJ@KN=G@tKNAJG,+JG.a-JG=Y@KJ XXKJ@KGGY)@K1

व्याख्या

                   Q = input (implicit)
KU*3Q              K = range(3 * Q)
FNr1Q              for N in range(1, Q):
 J@KN               J = K[N]
 =G@tKN             G = K[1:][N]
 AJG,+JG.a-JG       J, G = J + G, abs(J - G)
 =Y@KJ              Y = K[J]
 XXKJ@KGGY          K[J], K[G] = K[G], Y
)
@K1                print K[1]
— PurkkaKoodari
स्रोत
मैंने कुछ परीक्षण चलाए, और ऐसा लगता है कि आवश्यक सूची की लंबाई अधिकतम के लिए , 2*nबड़े के लिए परिवर्तित होती है । n3*nn=1
— अस्थिरता
@Volatility अनिवार्य रूप से, अधिक से अधिक है 2n+1, के रूप में आप कहते हैं पर यह अधिकतम है जो 3के लिए n=1और (एक तरह से) के लिए converges 2n। यह बहुत आश्चर्य की बात नहीं है क्योंकि यह अनपेक्षित अनुक्रम के लिए अधिकतम है, और इस प्रक्रिया में कोई भी कदम उस संख्या को नहीं बढ़ा सकता है जो अभी भी आगे है। मैं इसे अपने उत्तर में जोड़ सकता हूं।
— मार्टिन एंडर
मुझे लगता है कि आप पहले से ही .aअच्छे काम के लिए अपना विस्तार कर रहे हैं! रास्ते में बहुत अधिक उपहार हैं, लेकिन
— इसहाक
@orlp, मैं वास्तव में कोड लिखते समय डॉक्स पढ़ने के लिए हुआ था (मैं आमतौर doc.txtपर एक मैनुअल के लिए गिटहब का उपयोग करता हूं ) और अपडेट देखा। सौभाग्य से, जैसा कि मैंने अभी इसे छोड़ दिया है और एक कस्टम कार्यान्वयन लिखा है ...
— PurkkaKoodari
1

पायथन 2, 117 106 101

j=input();a=range(3*j)
for i in range(1,j):b,c=a[i:i+2];d=abs(b-c);a[b+c],a[d]=a[d],a[b+c]
print a[1]

dictमनमाना सूचकांकों का उपयोग करने के लिए मूल्यों को बचाने के लिए (मानचित्र) का उपयोग करता है । वें आइटम को g(n)वापस करने वाला एक फ़ंक्शन है n। फिर सिर्फ input-1बार पुनरावृति करता है और पहले आइटम को आउटपुट करता है।

यह पता चला है कि यह मेरे पाइथ उत्तर से विधियों का उपयोग करके छोटा है।

5 बाइट बचाने के लिए xnor का धन्यवाद ।

— PurkkaKoodari
स्रोत
आप सूची अनपैकिंग का उपयोग कर सकते हैं b,c=a[i:i+2]:। इसके अलावा, b+cयह काफी कम है कि इसे एक चर में सहेजना sसिर्फ दो बार लिखने पर वर्ण खो देता है।
— xnor
1

150 जाओ

func f(j int){a:=make([]int,j*2);for i:=range a{a[i]=i};for i:=1;i<j;i++{b,c:=a[i],a[i+1];v:=b-c;if v<0{v*=-1};a[b+c],a[v]=a[v],a[b+c]};println(a[1])}

अघोषित, कुछ भी मुश्किल नहीं, ज्यादातर @ Pietu1998 से चुराया गया

func f(j int) {
    a := make([]int, j*2) // Build the array we will be working on
    for i := range a {
        a[i] = i
    }
    for i := 1; i < j; i++ {
        b, c := a[i], a[i+1]
        v := b - c
        if v < 0 {
            v *= -1
        }
        a[b+c], a[v] = a[v], a[b+c]
    }
    println(a[1])
}

http://play.golang.org/p/IWkT0c4Ev5

— क्रिस्टोफ़र साल्-स्टोर्गार्ड
स्रोत
1

जावा, 162

int f(int n){int a[]=new int[2*n],s,d,x,t;for(x=0;x<2*n;)a[x]=++x;for(x=0;++x<n;){s=a[x]+a[x-1]-1;d=Math.abs(a[x]-a[x-1])-1;t=a[s];a[s]=a[d];a[d]=t;}return a[0];}

व्याख्या

int f(int n) {
    int a[] = new int[2 * n], sum, diff, x, temp;
    for (x = 0; x < 2 * n;) {
        a[x] = ++x;  // set initial array
    }
    for (x = 0; ++x < n;) {
        sum = a[x] + a[x - 1] - 1;
        diff = Math.abs(a[x] - a[x - 1]) - 1;
        temp = a[sum];
        a[sum] = a[diff];
        a[diff] = temp;
    }
    return a[0];
}
— Ypnypn
स्रोत
आप दूसरे लूप बॉडी को स्टेटमेंट के इन्क्रीमेंट क्लॉज में ले जाकर दो बाइट्स बचा सकते हैं। (सेमीकोला के बजाय कॉमाटा के साथ बयानों को अलग करें।)
— AJMansfield
1

डीसी, 134 132 131 बाइट्स

[_1*]sOdsn2*ddslsSsa[ladd:S1-dsa0<P]dsPx1d0rsN:N[la1+dsad;SdS@r1+;SdS@rL@L@r+Ss-d0>Od;SrLsdSsrLs;Sr:S:S1;SladsN:Nlaln>G]dsGxln1-;Nf

का प्रयोग करें echo $n $code | dc, जहां $nहै n और $codeहै ... कोड ( हांफी )। स्वाद के लिए बोली।

संपादित करें: जब तक आप मुझे स्पष्टीकरण देने के लिए तैयार नहीं करते, तब तक मैं इसके आसपास नहीं पहुंचूंगा।

— जो
स्रोत
क्या मुझे `-ई` के लिए तीन बाइट्स जोड़ने की आवश्यकता है?
— जो
@Sir, यह पता चला है कि तुम नहीं! [ codegolf.stackexchange.com/questions/25670/…
— जो
क्या वह खुद से बातचीत थी?
— NoOneIsHere
@NoOneIsHere: हां, निश्चित था। यह किसी के लिए भी एक सवाल था, लेकिन मुझे इसका जवाब मिल गया।
— जो
0

पर्ल 5, 131

एक भोली समाधान (यानी परिभाषा का प्रत्यक्ष कार्यान्वयन)। एक सबरूटीन, यह 1वांछित लंबाई की सूची के रूप में इनपुट लेता है ।

{map$a[$_]=$_,1..3*@_;($a[$a[$_-1]+$a[$_]],$a[abs($a[$_-1]-$a[$_])])=($a[abs($a[$_-1]-$a[$_])],$a[$a[$_-1]+$a[$_]])for 2..@_;$a[1]}

उदाहरण के लिए इसके आउटपुट की कल्पना करें print sub...->(1,1,1,1,1)।

स्पष्टीकरण:

map$a[$_]=$_,1..3*@_सरणी का निर्माण करता है @a, प्रत्येक पूर्णांक को 1 से 3 गुना @_(इनपुट) के आकार से अनुक्रमित करता है ।

($a[$a[$_-1]+$a[$_]],$a[abs($a[$_-1]-$a[$_])])=($a[abs($a[$_-1]-$a[$_])],$a[$a[$_-1]+$a[$_]])for 2..@_बार-बार स्विचरू को दोहराता है (आकार के मुकाबले एक कम बार @_), 2 से लेकर आकार के रूप में स्विच $a[$a[$_-1]+$a[$_]]करना ।$a[abs($a[$_-1]-$a[$_])]$_@_

और फिर सबरूटिन लौट आता है $a[1]।

— msh210
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.