आगे और पीछे गिनें फिर दोगुना

Question

गिनती करते हैं...

2 तक गिनें और 1 से वापस
4
तक गिनें और 1 से वापस 6 तक गिनें और 1 तक वापस जाएं
... ठीक है, आपको यह मिल गया ...

इन सभी को एक साथ रखें और आपको निम्नलिखित अनुक्रम मिलेगा

 {1,2,1,2,3,4,3,2,1,2,3,4,5,6,5,4,3,2,1,2,3,4,5,6,7,8,7,6,5,4,3,2,1,2,3...}

चुनौती 1-अनुक्रमित (या 0-अनुक्रमित) के लिए
पूर्णांक को देखते हुए , इस क्रम के एनटी अवधि को आउटपुट करती है n>0n>=0

परीक्षण के मामलों

Input->Output  

1->1  
68->6  
668->20  
6667->63  
10000->84

नियम

आपका प्रोग्राम एक मिनट के भीतर n = 10000 तक समाधानों की गणना करने में सक्षम होना चाहिए

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

Comments

कौन तय करता है कि एक मिनट में क्या होता है? लेगो से निर्मित एक समय-इष्टतम ट्यूरिंग मशीन वास्तव में लंबा समय लेती है, जबकि एक ही ट्यूरिंग मशीन में सिम्युलेटेड, कहते हैं, सी, संभवतः कुछ सेकंड, या मिनट लेगा, जो कि प्रोसेसर पर निर्भर करता है। इस प्रकार, अगर मैंने कहा कि ट्यूरिंग मशीन विवरण प्रस्तुत करता है, तो क्या यह वैध है?

— आर्थर

@ आर्थर मुझे लगता है कि आप समझ सकते हैं कि मैंने यह प्रतिबंध क्यों लगाया ... मैं एक विशाल सूची का निर्माण करके n = 10000 खोजने के लिए "हमेशा" लेने के लिए एक एल्गोरिथ्म नहीं चाहता था। यहां के अधिकांश लोगों ने शानदार जवाब दिए जो लाखों पाते हैं कुछ लम्हों में।

@BillSteihn मुझे लगता है कि प्रतिबंध अनावश्यक है।

— एरिक आउटोलॉफ़र

@EriktheOutgolfer gode गोल्फ के जवाब मुश्किल हो सकते हैं ... प्रतिबंध के बिना एक जवाब जो 10.000 ट्यूपल्स का उत्पादन करता है [1,2 ... 2n..2,1] मान्य होगा। प्रतिबंध केवल इस तरह के जवाबों के लिए है 'डॉन' टी देखें कि समस्या कहां है। मैं उचित समय पर सभी परीक्षण मामलों को खोजने के लिए आपका उत्तर चाहता हूं।

@StraklSeth यहाँ आम सहमति है कि यह सिद्धांत में काम करना चाहिए, व्यवहार में जरूरी नहीं है।

— एरिक आउटोलॉफ़र

Answer 1

जावास्क्रिप्ट (ईएस 7),  59 ... 44  43 बाइट्स

टाइटस की बदौलत बचा 1 बाइट

अपेक्षित इनपुट: 1-अनुक्रमित।

n=>(n-=(r=(~-n/2)**.5|0)*r*2)<++r*2?n:r*4-n

प्रारंभ में के लिए एक सूत्र से प्रेरित A004738 , जो एक समान अनुक्रम है। लेकिन मैंने इसे पूरी तरह से फिर से लिखना समाप्त कर दिया।

परीक्षण के मामलों

let f=

n=>(n-=(r=(~-n/2)**.5|0)*r*2)<++r*2?n:r*4-n

console.log(f(1))     // -> 1
console.log(f(68))    // -> 6
console.log(f(668))   // -> 20
console.log(f(6667))  // -> 63
console.log(f(10000)) // -> 84

कैसे?

अनुक्रम को एक त्रिकोण के रूप में व्यवस्थित किया जा सकता है, आरोही क्रम में बाएं भाग और अवरोही क्रम में दायां भाग।

नीचे पहली 4 पंक्तियाँ हैं, जिसमें पहले 32 शब्द हैं:

            1 | 2
        1 2 3 | 4 3 2
    1 2 3 4 5 | 6 5 4 3 2
1 2 3 4 5 6 7 | 8 7 6 5 4 3 2

अब, कुछ चर पेश करते हैं:

 row  | range   | ascending part              | descending part
 r    | x to y  | 1, 2, ..., i                | 4(r+1)-(i+1), 4(r+1)-(i+2), ...
------+---------+-----------------------------+-----------------------------------------
  0   |  1 -  2 |                           1 | 4-2
  1   |  3 -  8 |                   1   2   3 | 8-4  8-5  8-6
  2   |  9 - 18 |           1   2   3   4   5 | 12-6 12-7 12-8  12-9  12-10
  3   | 19 - 32 |   1   2   3   4   5   6   7 | 16-8 16-9 16-10 16-11 16-12 16-13 16-14

हम शीर्ष पर 2 तत्वों से शुरू करते हैं और प्रत्येक नई पंक्ति में 4 तत्व जोड़ते हैं। इसलिए, 0-अनुक्रमित पंक्ति आर पर तत्वों की संख्या इस प्रकार व्यक्त की जा सकती है:

a(r) = 4r + 2

पंक्ति आर का 1-अनुक्रमित शुरुआती स्थिति x इस अंकगणितीय श्रृंखला में सभी पूर्ववर्ती शब्दों के योग से दिया गया है, जो निम्न है:

x(r) = r * (2 + a(r - 1)) / 2 + 1
     = r * (2 + 4(r - 1) + 2) / 2 + 1
     = 2r² + 1

पारस्परिक रूप से, अनुक्रम में 1-अनुक्रमित स्थिति n को देखते हुए, इसी पंक्ति को इसके साथ पाया जा सकता है:

r(n) = floor(sqrt((n - 1) / 2))

या जेएस कोड के रूप में:

r = (~-n / 2) ** 0.5 | 0

एक बार जब हम r (n) को जान लेते हैं , तो हम शुरुआती स्थिति x (r) को घटाकर n से घटा देते हैं :

n -= r * r * 2

हम तुलना n के साथ एक (आर) / 2 + 1 = 2R + 2 यह पता लगाने की है कि क्या हम आरोही भाग में या उतरते भाग में कर रहे हैं:

n < ++r * 2 ?

यदि यह अभिव्यक्ति सत्य है, तो हम n पर लौटते हैं । अन्यथा, हम 4 (आर + 1) - एन वापस करते हैं । लेकिन चूंकि r पहले से ही अंतिम विवरण में बढ़ा हुआ था, इसलिए इसे सरल बनाया गया है:

n : r * 4 - n

Comments

ठीक है, मुझे लगता है कि मैं समझ गया। प्रत्येक अप-डाउन भाग की लंबाई 2,6,10,14 है ... इसलिए योग पंक्तिव्यू के वर्ग के साथ बढ़ता है, इसलिए sqrt। बहुत अच्छा!

— जॉलीजॉकर

Answer 2

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

(!!)$do k<-[1,3..];[1..k]++[k+1,k..2]

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

शून्य अनुक्रमित। सूची और इसमें अनुक्रमणिका बनाता है। 2 बाइट बचाने के लिए अर्जन जोहान्सन को धन्यवाद!

---

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

(!!)[min(k-r)r|k<-[0,4..],r<-[1..k-2]]

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

शून्य अनुक्रमित। सूची और इसमें अनुक्रमणिका बनाता है।

---

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

n%k|n<k=1+min(k-n)n|j<-k+4=(n-k)%j
(%2)

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

शून्य अनुक्रमित। एक पुनरावर्ती विधि।

Answer 3

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

f=lambda n,k=2:-~min(n,k-n)*(n<k)or f(n-k,k+4)

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

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

Answer 4

भूसी , 8 बाइट्स

!…ṁoe1DN

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

व्याख्या

!…ṁoe1DN  Implicit input (an integer).
       N  Positive integers: [1,2,3,4,...
  ṁo      Map and concatenate
      D   double: [2,4,6,8,...
    e1    then pair with 1: [1,2,1,4,1,6,1,8,...
 …        Fill gaps with ranges: [1,2,1,2,3,4,3,2,1,2,3,4,5,6,...
!         Index with input.

Answer 5

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

{({|(1...$+=2...2)}...*)[$_]}

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

0-आधारित

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  (
    # generate an outer sequence

    {           # bare block lambda

      |(        # flatten into outer sequence

        # generate an inner sequence

        1       # start at 1

        ...     # go (upward) towards:

        $       # an anonymous state variable (new one for each outer sequence)
          += 2  # increment by 2

        ...     # go (downward) towards:

        2       # stop at 2 (1 will come from the next inner sequence)

      )
    }

    ...         # keep generating the outer sequence until:
    *           # never stop

  )[ $_ ]       # index into outer sequence
}

भीतर का क्रम 1...$+=2...2पैदा करता है

(1, 2).Seq
(1, 2, 3, 4, 3, 2).Seq
(1, 2, 3, 4, 5, 6, 5, 4, 3, 2).Seq
(1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2).Seq
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2).Seq
...

इसे 1-आधारित 0,होने के लिए {, दूसरे से पहले जोड़ें , या -1बाद में जोड़ें$_

Answer 6

आर, 64 बाइट्स

function(n)unlist(sapply(seq(2,n,2),function(x)c(2:x-1,x:2)))[n]

एक तर्क लेता है कि समारोह n। यह 2:n2 की वृद्धि के साथ एक वेक्टर बनाता है । इनमें से प्रत्येक के लिए, वेक्टर 1:(x-1)और x:2बनाया जाता है। यह कुल मिलाकर की तुलना में लंबा होगा n। हम unlistयह करते हैं, एक वेक्टर प्राप्त करने और n-th प्रविष्टि लेने के लिए ।

Comments

क्या आप इसके 1:n*2बजाय कर सकते हैं seq(2,n,2)? यह आपकी आवश्यकता से बड़ा होगा लेकिन यह ठीक होना चाहिए! इसके अलावा मुझे नहीं लगता कि इस के साथ काम किया है seq(2,n,2)के लिए n=1वैसे भी!

— Giuseppe

Answer 7

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

def f(x):n=int((x/2)**.5);print 2*n-abs(2*n*n+2*n+1-x)+2

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

यह 0-अनुक्रमित है।

-1 बाइट @JustinMariner को धन्यवाद

यह कैसे काम करता है

हम ध्यान दें कि 1-अनुक्रमित n-समूह ( 1, 2, ... 2n ..., 2, 1) 0 से अनुक्रमित किए गए तत्वों से होता 2(n-1)^2है 2n^2।

सूचकांक में तत्व को खोजने के लिए x, हम समूह नंबर मिल सकता है nकि xमें है। कि, हम उस समूह के केंद्र से दूरी की गणना xहै। (यह दूरी है abs(2*n**2+2*n+2-x))।

हालांकि, चूंकि तत्व एक समूह के केंद्र से और कम हो जाते हैं, इसलिए हम समूह के अधिकतम मूल्य से दूरी घटाते हैं।

Comments

मैं इस हिस्से golfed है print 2*n-abs(2*n*n+2*n+1-x)+2- 2*n*n+2*nहो सकता है 2*n*-~nऔर +2+2*nमें बदल सकता है -~n*2, जो हमें शुरुआत जो बाइट (बचाता है करने के लिए ले जाने के लिए अनुमति देता है 53 बाइट्स )

— श्री Xcoder

Answer 8

05AB1E , 8 बाइट्स

कोड:

ÅÈ€1Ÿ¦¹è

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

स्पष्टीकरण:

ÅÈ           # Get all even numbers until input (0, 2, ..., input)
  €1         # Insert 1 after each element
    Ÿ        # Inclusive range (e.g. [1, 4, 1] -> [1, 2, 3, 4, 3, 2, 1])
     ¦       # Remove the first element
      ¹è     # Retrieve the element at the input index

Comments

जब तक आप ¦ को नहीं हटाते हैं तब तक सही ढंग से काम नहीं करता है , जो कि एक बाइट को भी बचाता है :)

— Emigna

€1अजीब है ...

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

Answer 9

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

f=(n,t=2)=>n>t?f(n-t,t+4):n>t/2?t-n+2:n

Answer 10

जेली , 10 , 9 बाइट्स

ḤŒḄṖµ€Fị@

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

इसके अलावा 1 अनुक्रमित, और बहुत तेजी से खत्म होता है।

एक बाइट ने @ErikTheOutgolfer को धन्यवाद दिया!

स्पष्टीकरण:

Hypothetically, चलो कहते हैं कि इनपुट ( a) 3 है।

    µ€      # (Implicit) On each number in range(a):
            #
Ḥ           # Double
            #   [2, 4, 6]
            #
 ŒḄ         # Convert to a range, and Bounce
            #   [[1, 2, 1], [1, 2, 3, 4, 3, 2, 1], [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]]
            #
   Ṗ        # Pop
            #   [[1, 2], [1, 2, 3, 4, 3, 2], [1, 2, 3, 4, 5, 6, 5, 4, 3, 2]]
            #
     F      # Flatten
            #   [1, 2, 1, 2, 3, 4, 3, 2, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2]
            #
      ị@    # Grab the item[a]
            #   1
            #

Comments

आपका कोड समतुल्य है Ḥ€ŒḄ€Ṗ€Fị@, इसलिए आप µ€-1 के लिए उपयोग कर सकते हैं ( €शुरुआत में तीन या अधिक ḤŒḄṖµ€Fị@

— भिक्षुओं

यह वास्तव में होना चाहिए ḤŒḄṖ<newline> ½ĊÇ€Fị@12 के लिए 10,000 की आवश्यकता का अनुपालन करने के लिए (9 बाइट कोड को स्थानीय रूप से चलाने पर मेरे i7 पर 2:20 लगता है और 7GB का उपयोग करता है)

— जोनाथन एलन

Answer 11

MATL , 15 बाइट्स

li:"@EZv4L)]vG)

1 के आधार पर।

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

यह समय TIO के सबसे बड़े परीक्षण मामलों के लिए है, लेकिन मेरे डेस्कटॉप कंप्यूटर (MATLAB R2017a पर चलने वाले कंपाइलर) पर समय के साथ खत्म हो जाता है। बीता हुआ समय प्रदर्शित करने के लिए, Z`कोड के अंत में जोड़ें ।

>> matl 'li:"@EZv4L)]vG)Z`'
> 10000
84
15.8235379852476

व्याख्या

कोड आवश्यकता से कई अधिक शब्द उत्पन्न करता है। विशेष रूप से, यह nअनुक्रम के "टुकड़ों" की गणना करता है , जहां प्रत्येक टुकड़ा एक गिनती और 1 पर वापस होता है।

l       % Push 1
i       % Push input, n
:       % Range [1 2 ...n]
"       % For each k in that range
  @E    %   Push 2*k
  Zv    %   Symmetric range: [1 2 ... 2*k-1 2*k 2*k-1 ... 2 1]
  4L)   %   Remove last entry: [1 2 ... 2*k-1 2*k 2*k-1 ... 2]
]       % End
v       % Concatenate all stack contents into a column vector
G)      % Get n-th entry. Implicitly display

Comments

अच्छा! TIO कभी-कभी धीमा होता है ...

खैर, यहां सुस्ती का मुख्य कारण एल्गोरिथ्म है (जो आवश्यकता से बहुत अधिक शब्द उत्पन्न करता है)। इसके अलावा, MATL संकलक विशेष रूप से तेज़ नहीं है

— लुइस मेंडो

Answer 12

भूसी , 12 10 बाइट्स

!ṁ§¤+hḣṫİ0

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

1-अनुक्रमित, काफी तेज काम करता है

व्याख्या

!ṁ§¤+hḣṫİ0
 ṁ      İ0    Map the following function over the even numbers and concatenate the results together
  §   ḣṫ      Get the ranges 1-n and n-1, then... 
   ¤+h         remove the last element from both of them and concatenate them together
!             Return the element of the resulting list at the given index

Comments

8 बाइट्स का उपयोग करते हुए…

— जर्गब ऑग

@Zgarb एक महान विचार है और आपको संभवतः इसे अपने उत्तर के रूप में पोस्ट करना चाहिए :)

— सिंह

किया हुआ।

— ज़गारब

Answer 13

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

Flatten[{1}~Join~Table[Join[Rest[p=Range@i],Reverse@Most@p],{i,2,Round[2Sqrt@#],2}]][[#]]&

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

Answer 14

रेटिना , 62 बाइट्स

.+
$*
^((^.|\2..)*)\1.
6$*1$2$2;1
(?=.+;(.+))\1(.+).*;\2.*
$.2

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। इनपुट 1-अनुक्रमित है। पहला चरण केवल यूनिरी रूपांतरण के लिए दशमलव है। दूसरा चरण उच्चतम वर्ग संख्या को sसख्ती से आधे से कम पाता है n; $1है s², जबकि $2है 2s-1। यह दो मूल्यों की गणना करता है, पहले वर्तमान अप / डाउन रन में संख्याओं की संख्या, जो है 4(s+1) = 4s+4 = 2$2+6, और दूसरी बात उस रन के भीतर की स्थिति, जो कि है n-2s² = n-(2$1+1)+1 = n-$&+1, जिसके लिए सख्त असमानता को लागू करने के लिए उपयोग किए 1जाने के लिए केवल एक की आवश्यकता होती है 1। अंतिम चरण तब उस स्थिति से गिनती के शुरू और अंत दोनों तक चलता है और निचला परिणाम लेता है और इसे दशमलव में परिवर्तित करता है।

Answer 15

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

(t=z=1;While[(x=3-4t+2t^2)<#,t++;z=x];If[#-z>2t-2,4t-5+z-#,#-z+1])&

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

Answer 16

पर्ल 5 , 43 + 1 (-पी) = 44 बाइट्स

$_=($n=2*int sqrt$_/2)+2-abs$n/2*$n+$n+1-$_

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

मैं सीधे n-वें तत्व की गणना करने के लिए एक सूत्र पर काम कर रहा था। तब मैंने देखा कि @ fireflame241 ने वह काम किया था, और मैंने इसे पर्ल में रखा।

# पर्ल 5 , 50 + 1 (-n) = 51 बाइट्स

push@r,1..++$",reverse 2..++$"while@r<$_;say$r[$_]

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

परिणाम 0 अनुक्रमित हैं।

Answer 17

हास्केल , 115 81 बाइट्स

y%x=snd(span(<x)$scanl(+)y[y+1,y+3..])!!0
g 1=1
g x|1%x>2%x=1+g(x-1)|1>0=g(x-1)-1

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

यहां कुछ जादू चल रहा है। अगर मैं एक सामान्य दृष्टिकोण का उपयोग करता था, तो शायद कम हो सकता है।

व्याख्या

पहले हम परिभाषित करते हैं %। %एक फ़ंक्शन है जो दो चर लेता है x, और y। यह एक सूची का निर्माण करता है scanl(+)y[y+1,y+3..]और उस सूची के पहले तत्व को इससे अधिक पाता है x। scanl(+)बस पुनरावृत्त रकम का प्रदर्शन करता है, हम जो त्रिकोणीय संख्याएँ प्राप्त करेंगे scanl(+)0[1..], वह वर्ग संख्याएँ प्राप्त करने के लिए जो हम करेंगे scanl(+)0[1,3..]। विशेष रूप से जिन दो सूचियों का हम निर्माण कर रहे हैं वे हैं scanl(+)2[3,5..]और scanl(+)1[2,4..]ये पैटर्न के विभक्ति बिंदु हैं।

अब हम मुख्य फ़ंक्शन को परिभाषित करते हैं gजो एक लेता है x। यदि xहम एक है 1क्योंकि यह पहला मूल्य है। अन्यथा हम अगले दो विभक्ति बिंदुओं की जांच करते हैं, यदि नीचे का विभेदन बड़ा होता है 1%x>2xतो हम उत्तराधिकारी को g$x-1वापस कर देते हैं अन्यथा हम पूर्ववर्ती को वापस कर देते हैं g$x-1।

ठीक है, लेकिन वह काम क्यों करता है?

सबसे पहले "जिस तरह से हम वर्टिकल पाते हैं, उसके साथ व्हाट्सएप?" एक ही प्रकार के लगातार कोने के बीच की दूरी को नोट करना महत्वपूर्ण है। आप देखेंगे कि हर बार अंतर 2 बढ़ रहे हैं। यह समझ में आता है क्योंकि त्रिकोण आधार हर बार 2 से व्यापक हो जाते हैं। हम सूची सूची का उपयोग करके सूची को निरंतर अंतर बना सकते हैं, जैसे [2,4..]हम उपयोग करते हैंscanl(+) इन सूचियों को हमारी शीर्ष सूची में बदलने के लिए करते हैं, पहले शीर्ष के स्थान और पहले अंतर के आधार पर।

तो अब जब हमारे पास उर्ध्व और अधोमुख सिंद्धात खोजने का एक तरीका है तो हम उस जानकारी का उपयोग मूल्यों को प्राप्त करने के लिए कर सकते हैं। हम कहते हैं कि पहला मूल्य 1अन्यथा हमें उत्तराधिकारी या पूर्ववर्ती को लेना होगा। यदि अगला शीर्ष एक ऊपर की ओर है तो हम पूर्ववर्ती को लेना चाहते हैं, अन्यथा हम उत्तराधिकारी को लेते हैं।

हास्केल , 56 51 46 बाइट्स

यहाँ कम गणित और कम बाइट के साथ मेरा बेहतर समाधान है।

d x|e<-[1..x-1]=e++map(x+1-)e
(([1..]>>=d)!!0)

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

Answer 18

पाइके , 14 बाइट्स

SF}SDtO_+)sQt@

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

S              -    range(1, input)
 F}SDtO_+)     -   for i in ^:
  }            -      ^ * 2
   S           -     range(1, ^)
        +      -    ^ + v
     tO_       -     ^[1:-1:-1]
          s    -  sum(^)
           Qt@ - ^[input-1]

Answer 19

सी # (.NET कोर) , 120 बाइट्स

स्पष्टीकरण: बहुत सरल, पहला नेस्टेड लूप हमारे अधिकतम तक चढ़ता है, दूसरा वापस नीचे चढ़ता है। 2 में से प्रत्येक के लिए दोहराव।

x=>{var a=0;for(int i=2,j=0;j<x;i+=2){for(var b=1;b<=i&j<x;b++,j++){a=b;}for(var c=i-1;c>1&j<x;c--,j++){a=c;}}return a;}

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

Answer 20

रूबी , 78 75 बाइट्स

स्टेप हेण के लिए 1 बाइट धन्यवाद

श्री एक्सकोडर को 1 बाइट का धन्यवाद दिया

->n{a=0;b=2;c=1;n.times{if a==b then c=0;b+=2;end;c=1if a<2;a+=c<1?-1:1};a}

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

उम्मीद है कि मैं और अधिक नीचे bytecount खींचने के लिए कुछ सुझाव मिल सकता है। मैंने एक सरल तरीका अपनाने की कोशिश की।

Comments

PPCG में आपका स्वागत है! c=1 ifको गोल्फ दिया जा सकता हैc=1if

— स्टीफन

76 बाइट्स:->n{a=0;b=2;c=1;n.times{if a==b then c=0;b+=2;end;c=1if a==1;a+=c<1?-1:1};a}

— मिस्टर एक्सकोडर

Answer 21

जावा (ओपनजेडके 8) , 53 बाइट्स

n->{int i=2;for(;n>i;i+=4)n-=i;return n>i/2?i-n+2:n;}

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

-2 बाइट्स नेवे का धन्यवाद।

1 अनुक्रमित।

टीएल; डीआर हम अनुक्रम को सुविधाजनक विखंडू में विभाजित करते हैं, पाते हैं कि चंक nअंदर है, फिर nthचंक में स्थिति ढूंढें ।

यहां, हम उस अनुक्रम को विभाजित कर सकते हैं [[1,2],[1,2,3,4,3,2],[1,2,3,4,5,6,5,4,3,2],...], जो हमें चंक साइज़ देता है 4i-2। से शुरू करते हुए i=2, हम एक समय में एक चंक से ऊपर की ओर बढ़ते iहुए n, अनिवार्य रूप से घटाते हैं । एक बार जब हम संतुष्ट हो जाते हैं n<=i, तो हम जानते nहैं कि वर्तमान चंक में सही मूल्य की स्थिति है।

हम तो तुलना करके मूल्य प्राप्त nकरने के लिए i, हिस्सा के आकार। प्रत्येक चंक का मध्यबिंदु बराबर होता है i/2+1; यदि nइससे कम है, तो हम बस वापस कर देंगे n। यदि nअधिक से अधिक है, हम वापसी i-n+2।

उदाहरण

n = 16, i = 2

Is n > i? Yes, n = n - 2 = 14, i = i + 4 = 6
Is n > i? Yes, n = n - 6 = 8, i = i + 4 = 10
Is n > i? No, stop looping.
10 / 2 + 1 = 6
Is n > 6? Yes, return i - n + 2 = 8 - 6 + 2 = 4

Comments

आप की जरूरत नहीं है +1, return n>i/2?i-n+2:nपर्याप्त है।

— नेवई

हुह। धन्यवाद, पूर्णांक विभाजन।

— Xanderhall

Answer 22

अजगर 2 , 5! बाइट्स (120 बाइट्स: पी)

r=range
a=[]
for i in r(2,998,2): 
	for j in r(1,i+1): a.append(j)
	for j in r(i-1,1,-1): a.append(j)
print a[input()-1]

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

सीधा, सूची बनाता है और फिर input'th तत्व लेता है

Comments

धन्यवाद जिसने भी वोट दिया! अब मेरे पास ५० प्रतिनिधि हैं तो मैं टिप्पणी कर सकता हूं! dabs तीव्रता से

— हुसैन रज़ा

Answer 23

पायथन 3 , 184 156 बाइट्स

l,n,r=list,next,range
h=lambda x:l(r(1,x))+l(r(x-2,1,-1))
def g():
	x=3
	while True:yield from h(x);x+=2
def f(i):
	x=g()
	for _ in r(i-1):n(x)
	return n(x)

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

"आलसी" मूल्यांकन के लिए पायथन जनरेटर के साथ गोल्फ

Answer 24

QBIC , 47 बाइट्स

g=q{p=p+1~p=:|_Xg\g=g+q~g=1or g>=r|r=r+1┘q=q*-1

व्याख्या

g=q         var g is the current value of the sequence; set to 1 at the start
{           DO infinitely
p=p+1       raise the step counter (var p)
~p=:|_Xg    IF p equals the input term a (read from cmd line) THEN QUIT, printing g
\           ELSE
g=g+q       raise (or decrement) g by q (q is 1 at the start of QBIC)
~g=1        IF g is at the lower bound of a subsequence
    or g>=r OR g is at the upper bound (r start as 2 in QBIC)
|r=r+1      THEN increment r (this happens once on lower bound, and once on upper, 
            total of 2 raise per subsequence)
┘q=q*-1     and switch q from 1 to -1

Answer 25

रोड़ा , 54 बाइट्स

f n{seq 1,n|{|i|seq 1,2*i;seq 2*i-1,2}_|head n+2|tail}

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

के साथ बुलाना: try f(n)

यह फ़ंक्शन जल्दी से उत्तर देता है, लेकिन बाद में कुछ अनावश्यक गणना करता है और अंततः मेमोरी से बाहर निकल जाता है।

जैसा कि फ़ंक्शन वास्तविक उत्तर को शीघ्र ही कॉल करने के बाद लौटाता है (स्पष्ट रूप से एक मिनट के तहत), मुझे लगता है कि यह उत्तर मान्य है।

(समानता के कारण बाहर निकलने से पहले रोड़ा कार्यों में मूल्यों को वापस कर सकते हैं।)

Answer 26

सी # (.NET कोर) , 99 95 86 बाइट्स

n=>{int i=1,t=2,d=0;for(;n>1;){i+=1-2*d;if(i==t){d++;t+=2;}if(i==1)d--;n--;}return i;}

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

लंबर फंक्शन जो पूर्णांक बनाता और ले जाता है। एकल लूप जो गिनती को ऊपर और नीचे संभालता है।

Answer 27

PHP, 65 + 1 बाइट्स

for($x=$d=$z=1;--$argn;)$d=($x+=$d)>1?$x>$z?-1:$d:!!$z+=2;echo$x;

ऑनलाइन के साथ पाइप के रूप में चलाएं -Rया इसे आज़माएं (या अन्य संस्करणों में से किसी एक को अनइंस्टॉल करें)।

Tsh port पुनरावर्ती जावास्क्रिप्ट का एक बंदरगाह 66 बाइट्स लेता है:

function f($n,$t=2){return$t<2*$n?$t<$n?f($n-$t,$t+4):$t-$n+2:$n;}

Arnauld takess समाधान का एक बंदरगाह 62 + 1 लेता है:

$n=$argn;echo($n-=($r=(~-$n/2)**.5|0)*$r*2)<++$r*2?$n:$r*4-$n;

Xanderhall´s Java के एक गोल्फ पोर्ट में अब तक का सबसे छोटा कोड है (55 + 1 बाइट्स):

for($n=$argn;$n+2>$i+=4;)$n-=$i-2;echo$n*2>$i?$i-$n:$n;

Answer 28

पायथ ,  19  18 बाइट्स

-yhKs@/Q2 2a*yKhKt

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