( कोडिंग.कॉम पर मल्टीप्लेयर गेम (कोड का टकराव) से लिया गया चैलेंज )

चुनौती

निम्नलिखित अनुक्रम का n -th शब्द खोजें : 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...या, इसे और अधिक स्पष्ट करने के लिए,{1}, {1,2}, {1,2,3}, {1,2,3,4}...

यह अनुक्रम 1 से x तक के समवर्ती श्रेणियों से बना है , 1 से शुरू होकर, अनंत तक सभी तरह से।

नियम / आईओ

इनपुट और आउटपुट किसी भी प्रारूप में हो सकते हैं, जब तक यह अलग-अलग हो। इनपुट किसी भी उपयुक्त स्रोत से लिया जा सकता है: STDIN, फ़ाइल, आदि ...

इनपुट 0- या 1-अनुक्रमित हो सकता है, और चयनित अनुक्रमण को पोस्ट में उल्लेख किया जाना चाहिए ।

आपको 255 समावेशी (जिसका अर्थ है 0-अनुक्रमित अधिकतम इनपुट 32640 है) के परिणामस्वरूप कम से कम तक संभालना होगा । यदि आपकी भाषा इसका समर्थन करती है तो उस पर कुछ भी संभाला जाना चाहिए।

यह code-golfसबसे छोटी बाइट गिनती जीत है!

परीक्षण के मामले (0-आधारित अनुक्रमण)

0 -> 1
1 -> 1
5 -> 3
10 -> 1
59 -> 5
100 -> 10
1001 -> 12

code-golf math sequence

— Yytsi
स्रोत

11

OEIS

— गुरुपाद ममदापुर

4

आप शायद कुछ और बड़ा परीक्षण मामलों (जोड़ना चाहिए 59, 100, आदि)

— FlipTack

संबंधित: codegolf.stackexchange.com/questions/103670/…

— JAD

इसके उलट चुनौती है। उस चुनौती से सबसे अच्छा जवाब एक तरह से काम करता है जो उलटा नहीं हो सकता। @JarkoDubbeldam

— devRicher

@devRicher मुझे पता है, बस इसे बाहर रखना और इसका मतलब नकारात्मक नहीं था। मेरा अपना उत्तर वास्तव में प्रतिवर्ती था। संबंधित! = डुप्लिकेट।

— JAD

5

05AB1E , 5 बाइट्स

कार्यक्रम 0-अनुक्रमित है, कोड:

ÌLL¹è

स्पष्टीकरण:

Ì       # Double increment the input
 LL     # List of list on the input
   ¹è   # Get nth element

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

GNG¹¾¼QiNएक पुनरावृत्ति दृष्टिकोण है, लेकिन यह अधिक स्मार्ट था।

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

13

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

([z|k<-[1..],z<-[1..k]]!!)

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

धन्यवाद @DanD -1 बाइट के लिए!

यह एक अनाम फ़ंक्शन है, जो अनंत अनुक्रम को सिर्फ n-थ तत्व को वापस [[1..k]| k<-[1..]]बनाता है: सूची की एक अनंत सूची का उत्पादन करता है [[1],[1,2],[1,2,3],[1,2,3,4],...]:। इन्हें संक्षिप्त करने के लिए हम लिख सकते हैं [z|k<-[1..],z<-[1..k]]कि कौन सा परिणाम है [1,1,2,1,2,3,1,2,3,4,...]और अंत (...!!)में इनपुट n(व्यर्थ अंकन) को स्वीकार करता है और n-th शब्द (0-आधारित) देता है।

— flawr
स्रोत

concatअधिक समझ के साथ प्रतिस्थापित करने से केवल 1 बाइट बचती है ([z|k<-[1..],z<-[1..k]]!!):।

— दान डी।

12

जावास्क्रिप्ट, 29 28 बाइट्स

-1 बाइट अरनौल को धन्यवाद!

f=(n,m)=>n++<m?n:f(n+~m,-~m)

OEIS पर पाए गए 0-अनुक्रमित पुनरावर्ती सूत्र का उपयोग करता है।

जब 1 तर्क के साथ अपेक्षित के रूप में कहा जाता है, तो दूसरे का डिफ़ॉल्ट मान mहोगा undefined। हालांकि, -~undefinedरिटर्न 1, जो हमें m = 1तर्क सूची में एक स्पष्ट बिना पुनरावृत्ति रोलिंग प्राप्त करने की अनुमति देता है (धन्यवाद @ @Ananad!)

टेस्ट स्निपेट:

f=(n,m)=>n++<m?n:f(n+~m,-~m)

let examples = [0, 1, 5, 10, 15, 1000];

examples.forEach(function log(x) {
    console.log(x, " => ", f(x))
});

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

वैकल्पिक रूप से, एक ही बाइट काउंट के लिए, हमारे पास एक करी फ़ंक्शन हो सकता है जैसे:

f=n=>m=>n++<m?n:f(n+~m)(-~m)

आप इसे कॉल कर सकते हैं f(5)()- यह एक फ़ंक्शन देता है, जिसे जब बुलाया जाता है, तो परिणाम देता है, जैसा कि इस मेटा पोस्ट में वर्णित है ।

— FlipTack
स्रोत

9

जेली , 5 बाइट्स, 1-अनुक्रमित

RRF³ị

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

स्पष्टीकरण:

                                      (Assume N = 4 for the examples)
R      Generate a list of 1 to N      [1, 2, 3, 4]
 R     Generate new lists for each item on the previous list, with that item as N
                                      [[1], [1,2], ...]
  F    Flatten that list              [1, 1, 2, 1, 2, 3 ...]
   ³ị  Use the input number (³) as index (ị) on the list. 
       This is one-based:             [1, 1, 2, 1, 2, 3 ...] 
                                                ^

— steenbergh
स्रोत

8

ऑक्टेव, 39 बाइट्स

@(z)z-(n=ceil((8*z+1)^.5/2-.5))*(n-1)/2

1- आधारित सूचकांक

स्पष्टीकरण:

इस क्रम पर विचार करें:

1   1   2   1   2   3   1   2   3   4   1   2   3   4   5

यदि हम बाद में हमारे पास मौजूद तत्वों की संख्या की गणना करते हैं

1   2        3          4               5

इसलिए त्रिकोणीय संख्या के लिए गॉस सूत्र का उपयोग करके हम z के लिए एक सूत्र बना सकते हैं:

z=n*(n+1)/2

यदि हम इसे n के लिए हल करते हैं तो यह एक द्विघात समीकरण है

n=(sqrt(8*z+1)-1)/2

यह ऑनलाइन की कोशिश करो!

— rahnema1
स्रोत

7

हास्केल, 25 24 बाइट्स

(!!)$[1..]>>= \x->[1..x]

प्रयोग उदाहरण: ((!!)$[1..]>>= \x->[1..x]) 10-> 1। इसे ऑनलाइन आज़माएं! ।

अनाम सूची-से-एक-से-x फ़ंक्शन \x->[1..x](अंतर्निहित enumFromTo 1एक बाइट लंबी है) को अनंत सूची में [1..]मैप करता है और परिणामी सूचियों को एक सूची में सम्मिलित करता है। !!nth तत्व को चुनता है।

एक बाइट के लिए @flawr को धन्यवाद।

— nimi
स्रोत

मुझे लगता है कि आप इसका उपयोग करके इसे छोटा कर सकते हैं (!!)$[1..]>>= \x->[1..x]। कभी कभी मैं वास्तव में चाहते हैं वहाँ लेखन की एक छोटी व्यर्थ रास्ता नहीं था \x->[1..x]:)

— flawr

पुनश्च: आप इसे ऑनलाइन क्यों नहीं जोड़ते हैं ! संपर्क?

— दोषपूर्ण

@flawr: अच्छी तरह से देखा, धन्यवाद! कोशिश करें कि यह ऑनलाइन ghc (या प्रस्तावना) के पुराने संस्करण का उपयोग करता है और अधिकांश उत्तर उपयोग करते हैं <$>जो कि गुंजाइश नहीं है। क्या आप किसी भी ऑनलाइन हास्केल संकलक / दुभाषिया को जानते हैं जो नवीनतम संस्करण का उपयोग करता है? haskell.org केवल अभिव्यक्ति की अनुमति देता है और आप अपने द्वारा दर्ज किए गए कोड के लिंक नहीं बना सकते हैं।

— नमि

1

आह, मैं इसे अपडेट करने के लिए @ डेनिस को बताऊं , वह TIO के निर्माता हैं :)

— त्रुटी

6

ऑक्टेव , 39 बाइट्स

@(n){v=1:n,A=triu(v'+0*v),A(A>0)(n)}{3}

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

यह एक वैकल्पिक दृष्टिकोण का उपयोग करता है।

उदाहरण के लिए n=1यह A=triu(v'+0*v)मैट्रिक्स बनाता है

1   1   1   1
0   2   2   2
0   0   3   3
0   0   0   4

जब A(A>0)हम अनुक्रम प्राप्त करते हैं, तो सभी शून्य तत्वों को हटाते हैं और कॉलम को जोड़ते हैं :

1   1  2  1  2  3  1  2  3  4

फिर यह nउस क्रम के -तथ्य शब्द को समाप्त करने की बात है।

— flawr
स्रोत

5

पायथन , 39 36 बाइट्स

-3 बाइट्स डेनिस को धन्यवाद!

एक पुनरावर्ती लैम्ब्डा जो 1-आधारित अनुक्रमण का उपयोग करता है।

f=lambda n,m=1:n*(n<=m)or f(n-m,m+1)

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

हम वर्तमान "वृद्धि" आकार का उपयोग करते हुए नज़र रखते हैं m। यदि इससे nछोटा या बराबर है m, तो यह वर्तमान "वृद्धि" के भीतर फिट बैठता है, और इसलिए हम इसे वापस कर देते हैं। हालाँकि, यदि यह इससे बड़ा है m, तो हम mइसे 1 से जोड़ते हैं mऔर फ़ंक्शन को पुनरावर्ती रूप से कॉल करते हैं (अगले उदय पर आगे बढ़ते हुए)।

— FlipTack
स्रोत

5

आर, 25 बाइट्स

i=scan();sequence(1:i)[i]

सूचकांक 1-आधारित है।

— स्वेन होहेंस्टीन
स्रोत

मैंने आज इस मुखपृष्ठ पर टकराकर देखा, आश्चर्य हुआ कि क्या किसी ने sequenceउत्तर दिया है, और यह देखकर खुश हुआ।

— Giuseppe

4

अजगर , 6 5 बाइट्स

1 बाइट ने @TheBikingviking के लिए धन्यवाद बचाया !

@s._S

यह 0-आधारित इंडेक्सिंग का उपयोग करता है।

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

व्याख्या

@          Index with implicit input into
   ._      all prefixes of
     S     1-based range of implicit input
 s         concatenated into an un-nested list

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

अच्छा! आप बदल सकते हैं .nके साथ s।

— बाइकिंग बाइकिंग

@ साइकिलिंग धन्यवाद!

— लुइस मेंडो

4

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

3 बाइट्स के लिए @MartinEnder को धन्यवाद!

((r=Range)@r@#<>1)[[#]]&

1 अनुक्रमित। यह उन त्रुटियों को फेंकता है जिन्हें अनदेखा करना सुरक्षित है।

व्याख्या

((r=Range)@r@#<>1)[[#]]&
  r=Range                 (* Store Range function in r *)
           r@#            (* Create list {1..n} *)
 (r      )@               (* For each element, generate {1..n} *)
              <>1         (* Join the lists and append a 1; throws errors *)
(                )[[#]]&  (* Take the nth element *)

— जंगहवान मिन
स्रोत

2

Join@@रास्ता बहुत महंगा है;)((r=Range)@r@#<>1)[[#]]&

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

@MartinEnder Woah, इस तथ्य का दुरुपयोग करते हुए कि StringJoinइसका मूल्यांकन नहीं किया गया है ... मुझे यह पसंद है

— JungHwan Min

4

ब्रेनफ * सीके, 78 बाइट्स

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

इनपुट (0-आधारित) और बाइट मान के रूप में आउटपुट लेता है।

आप इसे यहाँ परीक्षण कर सकते हैं।

इनपुट \से पहले दशमलव संख्या (जैसे \1010 के लिए) की आवश्यकता होती है । यदि आउटपुट एक मुद्रण योग्य ASCII वर्ण है, तो आपको इसे देखना चाहिए। अन्यथा, हिट दृश्य मेमोरी -> अंतिम डंप। मुद्रित किया गया मान 3rd सेल (सेल नंबर 2) में है।

स्पष्टीकरण:

सेल 0 (INPUT): इनपुट है और लूप के माध्यम से प्रत्येक बार मेरा 1 घटाया जाता है।

सेल 1 (RESET): हर बार 1 के हिसाब से वेतन वृद्धि। ऐसा करने के लिए, हर बार लूप के माध्यम से हम 1 जोड़ते हैं और यदि वे समान नहीं हैं तो हम 1 घटाते हैं।

सेल 2 (TERM): 1 प्रत्येक लूप द्वारा वेतन वृद्धि और 0 पर सेट है यदि यह RESET से मेल खाता है। ऐसा करने के लिए, मैं केवल होल्ड से मान वापस कॉपी करता हूं यदि यह सेल RESET के बराबर नहीं है।

सेल 3 (एक्वल): यह जांचने के लिए उपयोग किया जाता है कि क्या RESET और TERM बराबर हैं।

सेल 4 (होल्ड): का उपयोग बराबरी की जाँच के बाद RESET और TERM बैक के मूल्यों को कॉपी करने के लिए किया जाता है।

,>+<              # get input and put a 1 in RESET
[                 # for INPUT to 0
  >[->>+>+<<<]    # copy RESET to EQUAL and HOLD
  >>>[-<<<+>>>]   # copy HOLD back into RESET
  <<+             # add 1 to TERM
  [->->+<<]       # subtract TERM from EQUAL and copy it to HOLD
  >[              # if RESET and TERM were not equal
    <<-           # subtract 1 from RESET
    >>>[-<<+>>]   # copy HOLD back to TERM
    <[-]          # zero out EQUAL
  ]               # end if
  >[-]            # zero out HOLD
  <<<+            # add 1 to RESET (this cancels out the subtraction if
                  #     RESET did not equal TERM)
  <-              # subtract 1 from INPUT
]>>+.             # end for and add 1 because the sequence resets to 1 not 0

— रिले
स्रोत

बहुत बढ़िया! मैं इसका परीक्षण करूंगा और पुरस्कार के तुरंत बाद पुरस्कार दूंगा। एक स्पष्टीकरण जोड़ने मन? :)

— यती

@TuukkaX मैं उस पर काम कर रहा था :) मैं आज रात के समय में कुछ और जोड़ने की कोशिश करूँगा।

— रिले

काम करने लगता है :) बाउंटी 20 घंटे में उपलब्ध है।

— यति

@TuukkaX ध्यान रखें कि बाउंटी को ध्यान खींचने के लिए सभी 7 दिनों के लिए उपलब्ध होना चाहिए, फिर अंतिम दिन प्रदान किया जाएगा।

— mbomb007

@ mbomb007 हम्म। मैंने घोषणा की कि मैं पहली बार बाउंटी को ब्रेनफ * सीके समाधान प्रस्तुत करने के लिए पुरस्कार दूंगा, जिसका अर्थ है कि बाउंटी के लिए प्रतियोगिता समाप्त हो गई है। हालाँकि, अन्य लोग वही कर रहे हैं जिसका आपने उल्लेख किया है, और यह उन बिंदुओं की भरपाई करने का एक अच्छा तरीका है जो मैंने खो दिए थे। धन्यवाद :)

— यति

3

Pyke, 6 बाइट्स

OmSsQ@

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

O      -    input+2
 mS    -   map(range(1,i+1), range(^))
   s   -  sum(^)
    Q@ - ^[input]

0 अनुक्रमित।

— नीला
स्रोत

3

आर, 43 41 बाइट्स

संपादित करें: A002262 + 1 (0 अनुक्रमित) का उपयोग करके एक संक्षिप्त पुनरावर्ती दृष्टिकोण मिला :

f=function(n,m=1)`if`(n<m,n+1,f(n-m,m+1))

पुराना संस्करण:

n=scan();n-choose(floor((1+sqrt(8*n))/2),2)

OEIS से 1-अनुक्रमित सूत्र।

— Billywob
स्रोत

यह ऑनलाइन की कोशिश करो! यह ठीक काम करने लगता है। :)

— आर। काप

मैं आपके समाधान की तुलना में कुछ बाइट्स बचाने में कामयाब रहा। मेरा जवाब देखिए।

— JAD

3

पर्ल 6 , 21 बाइट्स

{map(|^*,^∞)[$_]+1}

0 अनुक्रमित। इसे ऑनलाइन आज़माएं!

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

{                 }  # A lambda.
         ^∞          # Range from 0 to Inf-1. (Same byte count as 0..*, but cooler.)
 map( ^*,  )         # Map each number n to the range 0..(n-1),
     |               # And slip each range into the outer list.
            [$_]     # Index the sequence with the lambda argument.
                +1   # Add 1.

पर्ल 6 , 21 बाइट्स

{[\,](1..*).flat[$_]}

0 अनुक्रमित। इसे ऑनलाइन आज़माएं!

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

{                   }  # A lambda.
      1..*             # Range from 1 to infinity.
 [ ,](    )            # Fold it with the comma operator,
  \                    # and return all intermediate results, e.g. (1), (1,2), (1,2,3)...
           .flat       # Flatten the sequence.
                [$_]   # Index it with the lambda argument.

— SMLS
स्रोत

2

इन समाधानों में से कोई भी JungHawn Min's जितना छोटा नहीं है , लेकिन वे वैकल्पिक दृष्टिकोण हैं, जो मुझे लगता है कि कुछ है। दोनों अनाम कार्य (1-अनुक्रमित) धनात्मक पूर्णांक इनपुट ले रहे हैं और एक सकारात्मक पूर्णांक लौटा रहे हैं।

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

-#^2-#&@⌈√(2#)-3/2⌉/2+#&

इस समारोह के लिए एक वास्तविक गणितीय सूत्र! (3-बाइट वर्ण का अनुवाद द्वारा भाग में अधिक पठनीय बना दिया ⌈, √और ⌉):

# - ((#^2 + #) / 2 &)[Ceiling[Sqrt[2 * #] - 3/2]] &

Ceiling[Sqrt[2 * #] - 1/2]हमें बताता है कि इनपुट को किस सूची में रखा गया है, जिसमें से हम एक को घटाते हैं, ताकि हम यह बता सकें कि इनपुट पर पहुंचने से पहले कौन सी सबलिस्ट समाप्त हो जाती है; फिर ((#^2 + #) / 2 &)गणना करता है कि हम जिस किसी की परवाह करते हैं, #उससे पहले सभी तत्वों में कितने तत्व होते हैं, जिन्हें हम अपना उत्तर प्राप्त करने के लिए इनपुट से घटाते हैं । (कुछ वें त्रिकोणीय संख्या के (#^2 + #) / 2लिए परिचित सूत्र को नोटिस करेंगे #; Ceiling[Sqrt[2 * #] - 1/2]अनिवार्य रूप से उलटा कार्य है।)

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

If[#2<=#,#2,#0[#+1,#2-#]]&[1,#]&

पुनरावर्ती समाधान, मूल रूप से बिलीवॉब के उत्तर और अन्य में जैसा है।

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

2

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

शून्य अनुक्रमित

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

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

स्टैक क्लीन, 48 बाइट्स

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

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

व्याख्या

यह मोडुलो फ़ंक्शन का एक संशोधित संस्करण है । विभाजक के रूप में एक निरंतर संख्या का उपयोग करने के बजाय यह विभाजक को बढ़ाता है जब हर बार भाजक इसे (एक बार बाहर पाश लूप) से घटाया जाता है।

एनोटेट कोड

(<>())       # Switch to the opposite stack and push 1 (the initial divisor)
{            # (outside loop) While top of stack is not 0...
  (          # Push...
    ({}())   # Push the divisor plus 1
  [()])      # ...minus one (ie push a copy of the original divisor
  {          # (inner loop) While the top of stack does not equal zero
    ({}[()]) # Decrement the top of the active stack
    <>       # Switch stacks
  }{}        # (inside loop) End loop and pop zero off the top of stack)
}            # (outside loop) End loop
<>           # Switch stacks (to the one with the divisor)
([{}()]{})   # Calculate the result

— 0 '
स्रोत

2

जावा 8, 85 73 55 बाइट्स

n->f(n,1)+1int f(int n,int m){return n<m?n:f(n-m,m+1);}

OEIS में दिए गए फॉर्मूले के साथ 0-अनुक्रमित पुनरावर्ती दृष्टिकोण :

a(n) = 1 + A002262(n)।
A002262 : के a(n)=f(n,1)साथ f(n,m) = if n<m then n else f(n-m,m+1)।

इसे यहाँ आज़माएँ।

पुराना उत्तर ( 85 56 बाइट्स):

n->{int m=~-(int)Math.sqrt(8*n+1)/2;return n-m*-~m/2+1;}

OEIS में दिए गए अन्य 0-अनुक्रमित सूत्र का उपयोग किया :

n-th शब्द है n - m*(m+1)/2 + 1, जहां m = floor((sqrt(8*n+1) - 1) / 2)।

इसे यहाँ आज़माएँ।

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

1

पर्ल , 30 बाइट्स

कोड + -pध्वज के 29 बाइट्स ।

map{$\-=$c++if$c<++$\}0..$_}{

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

— बापू
स्रोत

1

MATL, 8 बाइट्स

:"@:]vG)

यह समाधान 1-आधारित अनुक्रमण का उपयोग करता है

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

व्याख्या

        Implicitly grab input (N)
:       Create an array from [1...N]
"       For each element (A) in this array...
  @:    Create an array from [1....A]
]       End for loop
v       Vertically concatenate everything on the stack
G       Explicitly grab the input again
)       And use it to index into the vertically concatenated array
        Implicitly display the result

— Suever
स्रोत

1

ऐसा नहीं है कि यह एक बहुत मायने रखती है, लेकिन अगर आप को स्थानांतरित कोड तेज हो गया है vके बाद]

— लुइस Mendo

1

@LuisMendo आह अच्छी बात! मुझे छोटा और तेज पसंद है !

— Suever

लेकिन यह एक छोटी-सी परिधि है और निश्चित रूप से! :-)

— लुइस मेंडो

1

QBIC , 21 बाइट्स, 1-अनुक्रमित

:[a|[b|~q=a|_Xc\q=q+1

स्पष्टीकरण:

:      Get 'a' from the cmd line
[a|    FOR (b = 1; b <= a; b++) This creates an outer loop from 1 to N
[b|    FOR (c = 1; c <= b; c++) This creates an iteration, yielding the 1, 12, 123 pattern
       'q' stores how many terms we've seen. It starts at 1 b default.
~q=a   if we are at the desired term (q == a)
|_Xc   Then quit, and print 'c' (the current number in the sequence)
\q=q+1 Else, increase 'q' and run again.

थोड़ा और अधिक दिलचस्प दृष्टिकोण, लेकिन 10 बाइट्स लंबे समय तक:

:{~b+q>=a|_xa-b|\b=b+q┘q=q+1

यह कार्यक्रम इस ब्रैकेट और सभी पिछले वाले ( 1 at loop 1, 3 at loop 2, 6 at loop 3 ...) में कुल संख्याओं की लगातार गणना करता है । जब वह काउंटर मांगे गए अनुक्रमणिका N से अधिक हो जाता है, तो X को वर्तमान ब्रैकेट से लौटाएं, जहाँ X, N की पिछली राशि है।

— steenbergh
स्रोत

1

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

->n{(0..n).find{|x|0>=n-=x}+n}

1-आधारित अनुक्रमण

— जीबी
स्रोत

1

आर, 37 बाइट्स

n=scan();for(i in 2:n)T=c(T,1:i);T[n]

इनपुट से लेता है n, और पहले nदृश्यों के लिए अनुक्रम बनाता है । यह उच्चतर इनपुट पर इसे कुछ हद तक अक्षम बनाता है, लेकिन यह ठीक होना चाहिए। यह तब n-th प्रविष्टि, 1-अनुक्रमित लौटाता है।

क्रम से शुरू करके एक अच्छी छोटी चाल का उपयोग करता है T, जो कि डिफ़ॉल्ट रूप से TRUEया 1है।

— JAD
स्रोत

1

C11, 48 बाइट्स

int f(int x){int q=1;while(x>q)x-=q++;return x;}

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

C ++ और Java में भी काम करता है।

एक ही बाइट गिनती के लिए एक विकल्प:

int f(int x){int q=0;while(x>++q)x-=q;return x;}

— AlexRacer
स्रोत

उम्म .. न तो अधिकांश परीक्षण मामलों के लिए काम करने लगता है .. इसे यहाँ आज़माएं

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

1

ब्रेनफक, 141 बाइट्स

मुझे पता है कि मुझे इनाम के लिए बहुत देर हो चुकी है, लेकिन मैं सिर्फ यह देखना चाहता था कि जिस एल्गोरिथ्म के बारे में मैंने सोचा था कि कितने बाइट्स होंगे।

यह कार्यक्रम शून्य-अनुक्रमित है।

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

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

डायनामिक (अनंत) मेमोरी का चयन करें , या यह काम नहीं करेगा
इनपुट मानों का परीक्षण करने के लिए> सेल आकार (बिट्स) को 16 या 32 में255 बदलें ।
दुभाषिया बताते हैं कि इनपुट कैसे दिया जाता है। के इनपुट के लिए दशमलव इनपुट उपयोग के \5लिए 5।
- अधिकतम दशमलव मान जिसके साथ आप इनपुट का परीक्षण कर सकते हैं \999
- हेक्स इनपुट उच्च सेल-आकार के रूप में जा सकता है।

स्पष्टीकरण:

यह कदम से टूटे हुए कार्यक्रम को दर्शाता है, यह दर्शाता है कि इनपुट के लिए क्या होता है 5। #दुभाषिया के लिए आदर्श मेमोरी डंप स्थानों में रखा जाता है।

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

,>+<                       (5) 1
[[->>+>+<<<]>>[-<<+>>]       5 1 (0) 5
<[->+>>+<<<]>[-<+>]>>+       5 1 0 5 (2)
[[-<->>+<]>[-<+>]<<<<] (0) 0 4 1 0 3 2 0 0
>>[>>>]                      4 1 0 3 2 0 (0) 0
                             1 1 0 (0) 2 0
>[.#[<<<]]<<<<                4 1 0 (3) 2 0 0 0
<<<[[-]>>>[-<+<<+>>>]<[->+<]<<<<<]>>> (3) 1 0 3 2 0 0 0
[>>>]<<<]>[.#>]

Tape structure:
    (cell_1 cell_2 temp), (cell_1 cell_2 temp), ...

Take Input;
If not zero:
  copy last pair to the right and add one to its cell_2
  subtract each cell_2 from each cell_1 (leaving each cell_2 intact)
  move checking from left to right: 
    If cell_1 is zero and cell_2 isn't:
      print cell_2
    Else:
      copy last cell_1 back, overwriting each previous cell_1
Else:
  right one and print result

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

डायनामिक (अनंत) मेमोरी का चयन करें , या यह काम नहीं करेगा
डंप मेमोरी पर चार: #

टिप्पणियाँ:

इसे दूसरे दुभाषिया पर चलाने के लिए जो शुरुआती सेल के बाईं ओर जाने की अनुमति नहीं देता है (इसीलिए मैं डायनेमिक मेमोरी का उपयोग करता हूं), >शुरुआत में एक झुंड में डाल दिया । इनपुट मान के आधार पर आवश्यक संख्या भिन्न हो सकती है, लेकिन O (1) है।

— mbomb007
स्रोत

1

टिनिइलिश (उत्तर), 90 बाइट्स (0-अनुक्रमित)

(d r(q((n j x)(i n(i(e j x)(r(s n 1)1(s x(s 0 1)))(r(s n 1)(s j(s 0 1))x))j
(q((n)(r n 1 1

या, गैर-प्रतिस्पर्धात्मक (इस चुनौती को पोस्ट किए जाने के बाद एक विशेषता का उपयोग करके), 80 बाइट्स :

(d r(q((n j x)(i n(i(e j x)(r(s n 1)1(a x 1))(r(s n 1)(a j 1)x))j
(q((n)(r n 1 1

पहली पंक्ति एक सहायक फ़ंक्शन को परिभाषित करती है r, और दूसरी पंक्ति एक अनाम फ़ंक्शन है nजो अनुक्रम का नौवां कार्यकाल लेती है और वापस करती है। मैंने इसे एक उत्तर प्रस्तुत करने के रूप में निर्दिष्ट किया है, क्योंकि हर पंक्ति के अंत में उत्तर ऑटोोकम्प्लीट कोष्ठक है, न कि केवल कार्यक्रम के अंत में। उन कैविटीज़ के साथ, यहाँ एक संस्करण ऑनलाइन काम करने की कोशिश में संशोधित किया गया है , और यहाँ 54 के माध्यम से आदानों के खिलाफ एक अनऑर्गोडेड संस्करण चलता है।

व्याख्या

मैं यहाँ नॉनकम्पेटिंग संस्करण का उपयोग करूँगा। अंतर केवल इतना है कि आधिकारिक संस्करण को दो घटाव के रूप में लागू करना है।

(d r           Define r to be:
 (q(           A lambda function (= a list of two elements, quoted to prevent evaluation):
  (n j x)       Arguments n, j (the range counter), and x (the range limit)
  (i n          If n is truthy, i.e. nonzero:
   (i(e j x)     If counter equals limit:
    (r            Call r recursively on:
     (s n 1)       n-1
     1             counter reset to 1
     (a x 1))      limit increased by 1
    (r           Else, call r recursively on:
     (s n 1)       n-1
     (a j 1)       counter increased by 1
     x))           same limit
   j))))        Else, we're done; return the counter value

(q(            Lambda function:
 (n)            Argument n
 (r n 1 1)))    Call r with n, counter = 1, range limit = 1

— DLosc
स्रोत

1

सी, 54 बाइट्स

कम से कम सी समाधान नहीं है, लेकिन इसमें निरंतर समय में चलने की योग्यता है (कोई लूप नहीं है, बस गणित)। यह शून्य-आधारित अनुक्रमण का उपयोग करता है:

x;f(n){x=floor(sqrt(8*n+1)-1)/2;return 1+n-x*(x+1)/2;}

Ungolfed:

int f(int n) {
    int x = floor(sqrt(8*n+1)-1)/2; //calculate the number of the current subsequence (zero based)
    return 1+n-x*(x+1)/2;   //x*(x+1)/2 is the zero based index of the `1` starting the subsequence
}

इसके साथ टेस्ट करें:

#include <math.h>
#include <assert.h>
#include <stdio.h>

x;f(n){x=floor(sqrt(8*n+1)-1)/2;return 1+n-x*(x+1)/2;}

int main(){
    int i;
    for(i = 0; i < 10; i++) printf("%d ", f(i));
    printf("\n");

    assert(f(0) == 1);
    assert(f(1) == 1);
    assert(f(5) == 3);
    assert(f(10) == 1);
    assert(f(59) == 5);
    assert(f(100) == 10);
    assert(f(1001) == 12);
}

— cmaster
स्रोत

1

सी, 103 बाइट्स

एक भिखारी के लिए यह ठीक है, मुझे लगता है :)।

int main(){int n,c,i,j;scanf("%d",&n);while(c<n){for(i=1;i<=j;i++){c++;if(c==n)printf("%d",i);}j++;}}

या स्वरूपित तरीका

#include <stdio.h>

int main() {
    int n,c,i,j;
    scanf("%d",&n);
    while(c<n) 
    {
        for(i=1;i<=j;i++)
        {
            c++;
            if(c==n) printf("%d",i);
        }
        j++;
    }
}

— मोहम्मद मदखानह
स्रोत

1

यदि आप n,c,i,jग्लोबल्स घोषित करते हैं , तो यह गारंटी दी जाती है कि वे 0 से आरंभिक हैं, जो स्थानीय लोगों के लिए सही नहीं है।

— feersum

मुझे पता था कि इसमें ऐसी अनुभवहीन गलतियाँ होंगी। nअनुक्रम में इनपुट या n-th संख्या है, cएक काउंटर है, iऔर jलूप तत्व हैं; j1 होगा तब 2 तब 3 iहोगा जबकि 1 तब 1,2 फिर 1,2,3 और इसी तरह होगा। @ Qwerp-Derp

— मोहम्मद मडखान

मुझे यकीन नहीं है कि अगर मैं ठीक-ठीक समझ गया हूं कि आपका क्या मतलब है, लेकिन शुरुआती मूल्य इस कोड में 0 होंगे चाहे मैंने उन्हें ग्लोबल्स या स्थानीय घोषित किया हो। कृपया मुझे ठीक करें ıf मैं गलत हूं 0 =)। @ फ़ेर्सुम

— मोहम्मद मदखान

नहीं,

— असिंचित

1

डीसी , 21 बाइट्स, 0-आधारित अनुक्रमण

?d8*1+v1-2/d1+*2/-1+p

ऑनलाइन डीसी कार्यक्रम की कोशिश करो!

स्पष्टीकरण:

?      Push input number n.
d      Duplicate n at the top of the stack.
8*1+   Replace n at the top of the stack with 8n+1.
v      Replace 8n+1 at the top of the stack with the floor of its square root.
1-2/   Subtract 1, and divide by 2 (ignoring any fractional part).

स्टैक के शीर्ष पर अब सबसे बड़ा त्रिकोणीय संख्या का सूचकांक k है जो <= n है।

d1+*2/ Compute k(k+1)/2, which is the greatest triangular number <= n.
-      Subtract n-(the greatest triangular number <= n). The first n is on the stack in position 2, because the input number n was duplicated at the top of the stack at the very beginning of the program, and only one of the values was popped and used (until now).
1+     Add 1 because the desired sequence starts over again at 1 (not 0) at every triangular number.
p      Print the answer.

इस dc प्रोग्राम को एक प्रतिस्पर्धात्मक आकार की बैश स्क्रिप्ट में बदला जा सकता है:

बैश + यूनिक्स उपयोगिताओं, 28 बाइट्स, 0-आधारित अनुक्रमण

dc -e"?d8*1+v1-2/d1+*2/-1+p"

ऑनलाइन कार्यक्रम की कोशिश करो!

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

1

सी, 81 44 बाइट्स

सीधे पुनरावृत्ति विधि, 0 अनुक्रमित, और कुछ कोमल मालिश के साथ;

m=1,c=1;f(n){for(;n--;c=c^m?c+1:!!++m);c=c;}

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

— Ahemone
स्रोत

1

यह ऑनलाइन की कोशिश करो! यह काम करता हैं। :)

— आर। कप

वृद्धि और रीसेट अनुक्रम का एन-वें कार्यकाल

चुनौती

नियम / आईओ

परीक्षण के मामले (0-आधारित अनुक्रमण)

05AB1E , 5 बाइट्स

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

जावास्क्रिप्ट, 29 28 बाइट्स

जेली , 5 बाइट्स, 1-अनुक्रमित

ऑक्टेव, 39 बाइट्स

हास्केल, 25 24 बाइट्स

ऑक्टेव , 39 बाइट्स

पायथन , 39 36 बाइट्स

आर, 25 बाइट्स

अजगर , 6 5 बाइट्स

व्याख्या

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

ब्रेनफ * सीके, 78 बाइट्स

Pyke, 6 बाइट्स

आर, 43 41 बाइट्स

पर्ल 6 , 21 बाइट्स

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

पर्ल 6 , 21 बाइट्स

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

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

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

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

स्टैक क्लीन, 48 बाइट्स

व्याख्या

एनोटेट कोड

जावा 8, 85 73 55 बाइट्स

पर्ल , 30 बाइट्स

MATL, 8 बाइट्स

QBIC , 21 बाइट्स, 1-अनुक्रमित

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

आर, 37 बाइट्स

C11, 48 बाइट्स

ब्रेनफक, 141 बाइट्स

स्पष्टीकरण:

टिनिइलिश (उत्तर), 90 बाइट्स (0-अनुक्रमित)

व्याख्या

सी, 54 बाइट्स

सी, 103 बाइट्स

डीसी , 21 बाइट्स, 0-आधारित अनुक्रमण

बैश + यूनिक्स उपयोगिताओं, 28 बाइट्स, 0-आधारित अनुक्रमण

सी, 81 44 बाइट्स