पृष्ठभूमि की कहानी

^{अस्वीकरण: कंगारूओं के बारे में जानकारी बना सकता है।}

कंगारुओं ने विकास के कई चरणों को पार किया। जैसे-जैसे वे बड़े और मजबूत होते हैं, वे ऊंची और लंबी छलांग लगा सकते हैं, और भूख लगने से पहले वे अधिक बार कूद सकते हैं।

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

चरण 2 में , कंगारू छोटी छलांग लगा सकता है, लेकिन भूख लगने से पहले 2 से अधिक नहीं । हम इस तरह एक चरण 2 कंगारू के गतिविधि पैटर्न का प्रतिनिधित्व कर सकते हैं ।

 o o
o o o

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

  o   o   o   o
 o o o o o o o o
o   o   o   o   o

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

एक चरण n कंगारू की गतिविधि पैटर्न में प्रत्येक ओ को असाइन करें इसकी ऊंचाई, अर्थात, 1 से n तक की संख्या , जहां 1 जमीन से और n से उच्चतम स्थिति से मेल खाती है ।
गतिविधि पैटर्न में सभी ऊंचाइयों के योग की गणना करें।

उदाहरण के लिए, एक चरण 3 कंगारू के गतिविधि पैटर्न में निम्नलिखित ऊंचाइयां शामिल हैं।

  3   3   3   3
 2 2 2 2 2 2 2 2
1   1   1   1   1

हमारे पास पाँच 1 का, आठ 2 का और चार 3 का है; योग 5 · 1 + 8 · 2 + 4 · 3 = 33 है ।

कार्य

एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिखें जो इनपुट और प्रिंट के रूप में एक सकारात्मक पूर्णांक n लेता है या एक चरण n कंगारू की गतिविधि के अनुसार पोषण संबंधी आवश्यकताओं को वापस करता है ।

यह कोड-गोल्फ है ; बाइट्स जीतने में सबसे छोटा जवाब हो सकता है!

उदाहरण

 1 ->     1
 2 ->     7
 3 ->    33
 4 ->   121
 5 ->   385
 6 ->  1121
 7 ->  3073
 8 ->  8065
 9 -> 20481
10 -> 50689

— डेनिस
स्रोत

15

मैंने नीचा दिखाया क्योंकि मुझे ऐसी चुनौतियाँ पसंद नहीं हैं जहाँ एक जटिल सेटअप गोल्फ के लिए एक सीधे सूत्र में आता है।

— xnor

3

हालांकि अब तक के सभी उत्तरों में सूत्र का उपयोग किया गया है, मैं आश्वस्त हूं कि समस्या पर हमला करने के अन्य तरीके हैं।

— डेनिस

2

क्या इस क्रम के एससीआई कला उत्पादन को उत्पन्न करने की चुनौती है?

— मील

@ मीलों यकीन नहीं होता। किंदा को खोजना मुश्किल है।

— डेनिस

वोल्फ्राम अल्फा को एक छोटा संस्करण नहीं मिल सका, http://www.wolframalpha.com/input/?i=2%5E(n-1)*(n%5E2-1)%2B1(अजीब मार्कअप क्योंकि एक नियमित URL गड़बड़ हो जाता है)

— कोनिज़ॉन

8

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

²’æ«’‘

प्रत्येक मान की गणना करने के लिए सूत्र ( n ² - 1) 2 ^{n - 1} + 1 का उपयोग करता है। @ Qwerp-Derp की तरह एक प्रमाण प्रदान करने के लिए पर्याप्त था ।

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

व्याख्या

²’æ«’‘  Input: n
²       Square n
 ’      Decrement
  æ«    Bit shift left by
    ’     Decrement of n
     ‘  Increment

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

क्या आपने इसे हाथ से किया, या इसे ऑटो-जेनरेट किया?

— आउटगॉल्फ

इसे J का उपयोग करके पाया और OEIS को खोजा, फिर इसे हाथ से सरल किया

— मील

मैं अपने जवाब को गैर-प्रतिस्पर्धी मानता हूं, इसलिए मैंने इसे स्वीकार कर लिया है।

— डेनिस

17

कॉफ़ीस्क्रिप्ट, 19 बाइट्स

(n)->(n*n-1<<n-1)+1

संपादित करें: 6 बाइट्स काटने के लिए डेनिस को धन्यवाद!

कंगारू संख्या बनाने का सूत्र यह है:

सूत्र की व्याख्या:

की संख्या 1के में K(n)की अंतिम योग है 2^(n - 1) + 1।

अंतिम संख्या में n's की संख्या K(n)है 2^(n - 1), इसलिए सभी का योग nहै n * 2^(n - 1)।

किसी अन्य संख्या ( d) की K(n)अंतिम राशि में संख्या है 2^n, इसलिए सभी की राशि dहोगी d * 2^n।

इस प्रकार, अन्य सभी संख्याओं का योग = (T(n) - (n + 1)) * 2^n, जहां T(n)त्रिकोण संख्या फ़ंक्शन (जिसका सूत्र है T(n) = (n^2 + 1) / 2)।

इस बात को ध्यान में रखते हुए कि हम अंतिम राशि प्राप्त करते हैं
```
  (((n^2 + 1) / 2) - (n + 1)) * 2^n
= (((n + 1) * n / 2) - (n + 1)) * 2^n
= ((n + 1) * (n - 2) / 2) * 2^n
= 2^(n - 1) * (n + 1) * (n - 2)
```

जब हम सभी राशियों को एक साथ जोड़ते हैं, तो हम प्राप्त करते हैं K(n), जो समान है

  (2^(n - 1) * (n + 1) * (n - 2)) + (2^(n - 1) + 1) + (n * 2^(n - 1))
= 2^(n - 1) * ((n + 1) * (n - 2) + n + 1) + 1
= 2^(n - 1) * ((n^2 - n - 2) + n + 1) + 1
= 2^(n - 1) * (n^2 - 1) + 1

... जो ऊपर दिए गए सूत्र के बराबर है।

— clismique
स्रोत

1

PPCG में मैथजैक्स क्यों नहीं है?

— जोनाथन एलन

5

@ जोनाथन हमने किया, लेकिन यह कोड ब्लॉक में डॉलर के संकेतों के साथ कई समस्याओं का कारण बना।

— डेनिस

1

@JonathanAllan मुद्दे थे, लेकिन यह 1 2 3

— मील

वेनिला JS दो बाइट्स छोटी है:n=>(n*n-1<<n-1)+1

— ETHproductions

रुको, MathJax यहाँ काम नहीं करता है? या समीकरण एक छवि क्यों है?

— रुडोल्फजेलिन

7

जावा 7, 35 बाइट्स

int c(int n){return(n*n-1<<n-1)+1;}

— Numberknot
स्रोत

6

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

ŒḄ¡S

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

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

ŒḄ¡S  Main link. Argument: n (integer)

ŒḄ    Bounce; turn the list [a, b, ..., y, z] into [a, b, ..., y, z, y, ..., b, a].
      This casts to range, so the first array to be bounced is [1, ..., n].
      For example, 3 gets mapped to [1, 2, 3, 2, 1].
  ¡   Call the preceding atom n times.
      3 -> [1, 2, 3, 2, 1]
        -> [1, 2, 3, 2, 1, 2, 3, 2, 1]
        -> [1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1]
   S  Compute the sum.

— डेनिस
स्रोत

ओह, इतना कि की क्या उछाल है। काश मुझे पता होता कि कुछ दिनों पहले उस सटीक ऑपरेशन को जाप में शामिल करने से पहले: P

— ETHproductions

5

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

lambda x:(x*x-1<<x-1)+1

मीलों का फार्मूला इस्तेमाल किया।

जोनाथन एलन को -2 बाइट के लिए धन्यवाद।

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

आप की जरूरत नहीं है ~-x। आप उपयोग कर सकते हैं x-1(कम नहीं), क्योंकि घटाव में शिफ्टिंग की तुलना में अधिक पूर्वता है।

— mbomb007

@ mbomb007 मुझे पता है, लेकिन कोड जोनाथन एलन ने मुझे इस्तेमाल किया ~-x, इसलिए मैंने इसे अपरिवर्तित छोड़ने का फैसला किया। खैर, ऐसा लगता है कि हर कोई पसंद करता है x-1, हालांकि (डेनिस ने भी कहा कि सटीक बात)।

— को आउटगोल्फर

IMHO, यह अधिक पठनीय है, और यह गणितीय रूप में प्रयुक्त सूत्र की तरह अधिक दिखता है।

— mbomb007

@ mbomb007 ओह आप बहुत हाल ही में जोड़ा इनाम मतलब है? यदि हां, तो मैंने इसे बदल दिया। लेकिन, मैं कुछ तर्क जुटा सकता हूं ... मैं -~(x*x-1<<~-x)रिकॉर्ड के लिए भी कर सकता था , लेकिन -1अब भी मौजूद है, इसलिए मुझे कोड मिश्रण करना पसंद नहीं है ...

— निकली आउटगॉल्फ

मैं इनाम के बारे में कुछ भी नहीं मतलब है। इस उत्तर में प्रयुक्त गणित सूत्र । हम "माइनस 1" लिखते हैं - 1।

— mbomb007

4

लूआ, 105 बाइट्स

s=tonumber(arg[1])e=1 for i=1,s>1 and 2^(s-1)or 0 do e=e+1 for j=2,s-1 do e=e+j*2 end e=e+s end print(e)

डी-golfed:

stage = tonumber(arg[1])
energy = 1
for i = 1, stage > 1 and 2 ^ (stage - 1) or 0 do
    energy = energy + 1
    for j = 2, stage - 1 do
        energy = energy + j * 2
    end
    energy = energy + stage
end
print(energy)

मनोरंजक समस्या!

— टान्नर ग्रेहविक
स्रोत

3

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!

— आउटगॉल्फ

s = tonumber (arg [1]) को कुछ बाइट्स बचाने के लिए s = ... के लिए स्वैप किया जा सकता है। ... इस मामले में arg टेबल को अनपैक करता है, arg [1] देता है। और लुआ के तार उन नंबरों की तरह काम करेंगे, जिनमें केवल एक वैध संख्या कंस्ट्रक्टर होता है, जिसे हम मान सकते हैं कि इनपुट इस मामले में है।

— अताको

4

दरअसल , 8 बाइट्स

;²D@D╙*u

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

स्पष्टीकरण:

यह केवल सूत्र की गणना करता है (n**2 - 1)*(2**(n-1)) + 1।

;²D@D╙*u
;         duplicate n
 ²        square (n**2)
  D       decrement (n**2 - 1)
   @      swap (n)
    D     decrement (n-1)
     ╙    2**(n-1)
      *   product ((n**2 - 1)*(2**(n-1)))
       u  increment ((n**2 - 1)*(2**(n-1))+1)

— मै जाऊं
स्रोत

4

GolfScript , 11 बाइट्स

~.2?(2@(?*)

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

4 बाइट्स निकालने के लिए धन्यवाद मार्टिन एंडर (8478)।

स्पष्टीकरण:

            Implicit input                 ["A"]
~           Eval                           [A]
 .          Duplicate                      [A A]
  2         Push 2                         [A A 2]
   ?        Power                          [A A^2]
    (       Decrement                      [A A^2-1]
     2      Push 2                         [A A^2-1 2]
      @     Rotate three top elements left [A^2-1 2 A]
       (    Decrement                      [A^2-1 2 A-1]
        ?   Power                          [A^2-1 2^(A-1)]
         *  Multiply                       [(A^2-1)*2^(A-1)]
          ) Increment                      [(A^2-1)*2^(A-1)+1]
            Implicit output                []

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

4

सीजेएम, 11 बाइट्स

ri_2#(\(m<)

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

स्पष्टीकरण:

r           e# Get token.       ["A"]
 i          e# Integer.         [A]
  _         e# Duplicate.       [A A]
   2#       e# Square.          [A A^2]
     (      e# Decrement.       [A A^2-1]
      \     e# Swap.            [A^2-1 A]
       (    e# Decrement.       [A^2-1 A-1]
        m<  e# Left bitshift.   [(A^2-1)*2^(A-1)]
          ) e# Increment.       [(A^2-1)*2^(A-1)+1]
            e# Implicit output.

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

केवल अगर मुझे ज़रूरत नहीं थी ri...

— आउटगॉल्फ

3

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

(#*#-1)2^#/2+1&

बिटशफ्ट ऑपरेटर नहीं है, इसलिए हमें वास्तविक घातांक करने की आवश्यकता है, लेकिन फिर यह घातांक घटने के बजाय 2 से विभाजित करने के लिए छोटा है।

— मार्टिन एंडर
स्रोत

3

सी, 26 बाइट्स

मैक्रो के रूप में:

#define f(x)-~(x*x-1<<~-x)

एक समारोह के रूप में (27):

f(x){return-~(x*x-1<<~-x);}

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

यदि पैरामीटर एक अभिव्यक्ति है तो मैक्रो संस्करण गलत परिणाम देगा। विचार करें f(1+2)।

— कैस्परल्ड

1

@kasperd पैरामीटर एक अभिव्यक्ति नहीं होगा। एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिखें जो इनपुट और प्रिंट के रूप में एक सकारात्मक पूर्णांक n लेता है या एक चरण n कंगारू की गतिविधि के अनुसार पोषण संबंधी आवश्यकताओं को वापस करता है ।

— आउटगॉल्फ

आपका उद्धरण एक पूर्ण कार्यक्रम या एक फ़ंक्शन कहता है । लेकिन एक मैक्रो न तो है।

— कास्परड

@kasperd मूल रूप से, मुझे लगता है कि यह एक फ़ंक्शन की तरह है, लेकिन मूल्यांकन के बिना। इसके अलावा, मैंने नीचे "वास्तविक" फ़ंक्शन प्रदान किया है, यदि आप यही चाहते हैं।

— आउटगॉल्फ

3

05AB1E , 7 बाइट्स

n<¹<o*>

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

व्याख्या

n<        # n^2
     *    # *
  ¹<o     # 2^(n-1)
      >   # + 1

— Emigna
स्रोत

2

सी #, 18 बाइट्स

n=>(n*n-1<<n-1)+1;

बेनामी समारोह Qwerp-Derp के उत्कृष्ट गणितीय विश्लेषण पर आधारित है ।

परीक्षण मामलों के साथ पूरा कार्यक्रम:

using System;

namespace KangarooSequence
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,int>f= n=>(n*n-1<<n-1)+1;

            //test cases:
            for (int i = 1; i <= 10; i++)
                Console.WriteLine(i + " -> " + f(i));
            /* will display:
            1 -> 1
            2 -> 7
            3 -> 33
            4 -> 121
            5 -> 385
            6 -> 1121
            7 -> 3073
            8 -> 8065
            9 -> 20481
            10 -> 50689
            */
        }
    }
}

— adrianmp
स्रोत

2

बैच, 30 बाइट्स

@cmd/cset/a"(%1*%1-1<<%1-1)+1"

खैर, यह वैसे भी जावा धड़कता है।

— नील
स्रोत

2

MATL , 7 बाइट्स

UqGqW*Q

अन्य उत्तरों से सूत्र का उपयोग करता है।

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

U    % Implicit input. Square
q    % Decrement by 1
G    % Push input again
q    % Decrement by 1
W    % 2 raised to that
*    % Multiply
Q    % Increment by 1. Implicit display

— लुइस मेंडो
स्रोत

2

ओएसिस , 9 बाइट्स

2n<mn²<*>

मुझे आश्चर्य है कि कोई अंतर्निर्मित नहीं है 2^n।

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

स्पष्टीकरण:

2n<m        # 2^(n-1) (why is m exponentiation?)
    n²<     # n^2-1
       *    # (2^(n-1))*(n^2-1)
        >   # (2^(n-1))*(n^2-1)+1

— DanTheMan
स्रोत

डच में mप्रतिपादक achtsverheffing है, और रचनात्मकता की कमी है। इसके अलावा, बहुत सारे ऑपरेटरों को अभी तक लागू नहीं किया गया है, आलस्य और शिथिलता के कारण।

— अदनान

1

रैकेट 33 बाइट्स

@ Qwerp-Derp द्वारा समझाया गया सूत्र का उपयोग करना

(+(*(expt 2(- n 1))(-(* n n)1))1)

Ungolfed:

(define (f n)
  (+ (*(expt 2
            (- n 1))
      (-(* n n)
        1))
    1))

परिक्षण:

(for/list((i(range 1 11)))(f i))

आउटपुट:

'(1 7 33 121 385 1121 3073 8065 20481 50689)

— rnso
स्रोत

1

रूबी, 21 बाइट्स

@ Qwerp-Derp ने मूल रूप से भारी उठाने का काम किया।

माणिक में पूर्वता के कारण, ऐसा लगता है कि हमें कुछ परगनों की आवश्यकता है:

->(n){(n*n-1<<n-1)+1}

— डेविड लजंग मैडिसन स्टेलर
स्रोत

1

स्काला, 23 बाइट्स

(n:Int)=>(n*n-1<<n-1)+1

घातांक के रूप में बिट शिफ्ट का उपयोग करता है

— corvus_192
स्रोत

1

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

h.<t*QQt

pyth.herokuapp.com

स्पष्टीकरण:

     Q   Input
      Q  Input
    *    Multiply
   t     Decrement
       t Decrement the input
 .<      Left bitshift
h        Increment

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

1

आर, 26 बाइट्स

बेशर्मी से फॉर्मूला लागू किया

n=scan();2^(n-1)*(n^2-1)+1

— Billywob
स्रोत

1

जे , 11 बाइट्स

1-<:2&*1-*:

पहले मिले उसी फॉर्मूले के आधार पर ।

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

व्याख्या

1-<:2&*1-*:  Input: integer n
         *:  Square n
       1-    Subtract it from 1
  <:         Decrement n
    2&*      Multiply the value 1-n^2 by two n-1 times
1-           Subtract it from 1 and return

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

0

ग्रूवी (22 बाइट्स)

{(it--**2-1)*2**it+1}

संरक्षित नहीं करता है n, लेकिन इस प्रतियोगिता में अन्य सभी के समान सूत्र का उपयोग करता है। कोष्ठक के लिए आवश्यक होने के कारण, क्षय के साथ 1 बाइट बचाया।

परीक्षा

(1..10).collect{(it--**2-1)*2**it+1}

[1, 7, 33, 121, 385, 1121, 3073, 8065, 20481, 50689]

— जादू ऑक्टोपस Urn
स्रोत

0

जेएस-फोर्थ, 32 बाइट्स

सुपर शॉर्ट नहीं है, लेकिन यह जावा से छोटा है। यह फ़ंक्शन स्टैक पर परिणाम को आगे बढ़ाता है। इसके लिए जेएस-फोर्थ की आवश्यकता है क्योंकि मैं उपयोग करता हूं <<।

: f dup dup * 1- over 1- << 1+ ;

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

— mbomb007
स्रोत

कंगारू अनुक्रम की गणना करें

पृष्ठभूमि की कहानी

कार्य

उदाहरण

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

व्याख्या

कॉफ़ीस्क्रिप्ट, 19 बाइट्स

सूत्र की व्याख्या:

जावा 7, 35 बाइट्स

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

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

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

लूआ, 105 बाइट्स

दरअसल , 8 बाइट्स

GolfScript , 11 बाइट्स

सीजेएम, 11 बाइट्स

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

सी, 26 बाइट्स

05AB1E , 7 बाइट्स

सी #, 18 बाइट्स

बैच, 30 बाइट्स

MATL , 7 बाइट्स

ओएसिस , 9 बाइट्स

स्पष्टीकरण:

रैकेट 33 बाइट्स

रूबी, 21 बाइट्स

स्काला, 23 बाइट्स

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

आर, 26 बाइट्स

जे , 11 बाइट्स

व्याख्या

ग्रूवी (22 बाइट्स)

परीक्षा

जेएस-फोर्थ, 32 बाइट्स