न्यू नेबर सीक्वेंस

24

गैर-नकारात्मक पूर्णांक हमेशा एक ही दो * पड़ोसी होने से ऊब गए हैं, इसलिए वे चीजों को थोड़ा मिश्रण करने का निर्णय लेते हैं। हालांकि, वे आलसी भी हैं और अपनी मूल स्थिति के करीब रहना चाहते हैं।

वे निम्नलिखित एल्गोरिथ्म के साथ आते हैं:

  • पहला तत्व 0 है।
  • nth तत्व सबसे छोटी संख्या जो अभी तक अनुक्रम में मौजूद नहीं है और जो के एक पड़ोसी नहीं है (n−1)th तत्व।

यह निम्न अनंत अनुक्रम उत्पन्न करता है:

0,2,4,1,3,5,7,9,6,8,10,12,14,11,13,15,17,19,16,18,20,22,24,21,23,25,27,29,26,28 ...

0पहला तत्व है। 1अनुक्रम में अभी तक सबसे छोटी संख्या नहीं है, लेकिन यह एक पड़ोसी है 0। अगली सबसे छोटी संख्या है 2, इसलिए यह अनुक्रम का दूसरा तत्व है। अब शेष संख्याएं हैं 1,3,4,5,6,..., लेकिन दोनों के रूप में 1और 3पड़ोसी हैं 2, 4अनुक्रम का तीसरा सदस्य है। जैसा कि 1इसका पड़ोसी नहीं है 4, यह अंततः चौथे तत्व के रूप में अपनी जगह ले सकता है।

काम

एक फ़ंक्शन या प्रोग्राम को संभव के रूप में कुछ बाइट्स में लिखें जो उपरोक्त अनुक्रम उत्पन्न करता है।

आप कर सकते हैं

  • अनुक्रम अनंत रूप से उत्पादन,
  • इनपुट और तत्व को अनुक्रम में वापस करें, याnnth
  • एक इनपुट और अनुक्रम के पहले n तत्वों को वापस करें ।nn

यदि आप दो बाद वाले विकल्पों में से एक का चयन करते हैं, तो शून्य- या एक-अनुक्रमण दोनों ठीक है।

आपको ऊपर दिए गए एल्गोरिथ्म का पालन करने की आवश्यकता नहीं है, कोई भी विधि जो समान अनुक्रम का उत्पादन करती है वह ठीक है।

कोड गोल्फ द्वारा प्रेरित सबसे अच्छा क्रमचय । यह A277618 है ।
* शून्य का शाब्दिक रूप से केवल एक पड़ोसी है और वास्तव में परवाह नहीं करता है।

code-golf  sequence  integer 
— Laikoni
स्रोत
— लैकोनी

जवाबों:

18

जावास्क्रिप्ट (ईएस 6), 13 बाइट्स

लौटता है nअनुक्रम n वेंपद को।

n=>n-2-~++n%5

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

कैसे?

यह गणना करता है:

n−2+((n+2)mod5)

           n |  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 ...
-------------+--------------------------------------------------
       n - 2 | -2 -1  0  1  2  3  4  5  6  7  8  9 10 11 12 ...
 (n+2) mod 5 |  2  3  4  0  1  2  3  4  0  1  2  3  4  0  1 ...
-------------+--------------------------------------------------
         sum |  0  2  4  1  3  5  7  9  6  8 10 12 14 11 13 ...
— Arnauld
स्रोत
3

पिप , 14 बाइट्स

02413@a+a//5*5

nan

an+5=an+5 । हम पहले पांच मूल्यों को हार्ड-कोड करते हैं और वहां से ऑफसेट करते हैं।

या, 12 बाइट्स के लिए सभी का उपयोग करने वाला सूत्र :

a-2+(a+2)%5
— DLosc
स्रोत
2

आम लिस्प , 67 बाइट्स

(defun x(n)(loop for a from 0 to n collect(+(mod(+ a 2)5)(- a 2))))

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

— JRowan
स्रोत
मुझे लगता है कि बस (defun x(n)(+(mod(+ n 2)5)(- n 2))), या (lambda(n)(+(mod(+ n 2)5)(- n 2)))पर्याप्त है: शब्दों के अनुक्रम के बजाय एन-वें शब्द को वापस करना।
— मिशा लावरोव
2

जाप , 8 बाइट्स

U-2Ò°U%5

जाप दुभाषिया

अरनौलद के जावास्क्रिप्ट उत्तर का एक सीधा पोर्ट। लिंक किया गया संस्करण पहले n तत्वों के माध्यम से चलता है, लेकिन यदि -mझंडा हटा दिया जाता है तो यह अभी भी वैध है और इसके बजाय nth तत्व को प्रिंट करता है।

तुलना के लिए, यहाँ भोला संस्करण है जो प्रश्न में दिए गए एल्गोरिथ्म को लागू करता है:

@_aX É«NøZ}a}gNhT

मैं इसके लिए एक स्पष्टीकरण दूंगा:

              NhT    Set N to [0]
@           }g       Get the nth element of N by filling each index with:
 _        }a          The first integer that satisfies:
  aX É                 It is not a neighbor to the previous element
      «NøZ             And it is not already in N
— कामिल दकरी
स्रोत
-3 अपने दूसरे समाधान पर बाइट्स , और शायद आगे सुधार किया जा सकता है।
— झबरा
2

05AB1E , 5 बाइट्स

Ì5%+Í

पोर्ट ऑफ @ जोकिंग के मैथगॉल्फ उत्तर ।

इसे ऑनलाइन आज़माएं या पहले 100 नंबरों को सत्यापित करें ।

स्पष्टीकरण:

Ì        # Increase the (implicit) input by 2
 5%      # Take modulo-5
   +     # Add the (implicit) input to it
    Í    # Decrease by 2 (and output implicitly)
— केविन क्रूज़सेन
स्रोत
2

स्वच्छ , 31 बाइट्स

सबका उपयोग का सूत्र।

import StdEnv
?n=n-2+(n+2)rem 5

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

साफ , 80 बाइट्स

मेरा प्रारंभिक दृष्टिकोण, पहली nवस्तुओं को वापस करना।

import StdEnv
$n=iter n(\l=l++[hd[i\\i<-[0..]|all((<>)i)l&&abs(i-last l)>1]])[0]

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

— Οurous
स्रोत
2

जे , 30 बाइट्स

{.2}.[:,_5,./\2(i.-4 0$~])@,~]

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

पहले की सूची लौटाता है n नंबरों

यह समाधान स्पष्ट रूप से गैर-प्रतिस्पर्धात्मक है, लेकिन मैं एक सरणी-आधारित पद्धति का प्रयास करना चाहता था।

स्पष्टीकरण:

का तर्क है n

2 ,] - इनपुट के लिए 2 संलग्न करें

   (2,~]) 10
10 2

()@ - और इस सूची का उपयोग करें:

i.- n0..2n-1 रेंज में संख्याओं के साथ एक मैट्रिक्स x 2 बनाएं :

   i.10 2
 0  1
 2  3
 4  5
 6  7
 8  9
10 11
12 13
14 15
16 17
18 19

4 0$~]- ~तर्कों को उलट देता है, इसलिए यह है] $ 4 0 - 4 nx को दोहराते हुए मैट्रिक्स x 2 बनाता है

   4 0$~10 2
4 0
4 0
4 0
4 0
4 0
4 0
4 0
4 0
4 0
4 0

- पहले से दूसरे मैट्रिक्स को घटाएं, ताकि पहला कॉलम 2 पदों के साथ "विलंबित" हो

   2(i.-4 0$~])@,~] 10
_4  1
_2  3
 0  5
 2  7
 4  9
 6 11
 8 13
10 15
12 17
14 19

_5,./\ 5 पंक्तियों के गैर-अतिव्यापी समूहों में मैट्रिक्स को पीछे छोड़ें और स्तंभों को सिलाई करें

   _5,./\2(i.-4 0$~])@,~] 10
_4 _2  0  2  4
 1  3  5  7  9

 6  8 10 12 14
11 13 15 17 19

[:, पूरे ऐरे को उठाएं

   ,_5,./\2(i.-4 0$~])@,~] 10
_4 _2 0 2 4 1 3 5 7 9 6 8 10 12 14 11 13 15 17 19

2}. - पहले 2 नंबर ड्रॉप करें

   2}.,_5,./\2(i.-4 0$~])@,~] 10
0 2 4 1 3 5 7 9 6 8 10 12 14 11 13 15 17 19

{.पहले nनंबर लें

   ({.2}.[:,_5,./\2(i.-4 0$~])@,~]) 10
0 2 4 1 3 5 7 9 6 8

जे , 9 बाइट्स

+_2+5|2+]

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

nवें तत्व को लौटाता है ।

पोर्ट ऑफ़ अरनल्ड का जवाब

— गैलेन इवानोव
स्रोत
1

x86 मशीन कोड, 16 बाइट्स

00000000: 31d2 89c8 4949 4040 b305 f7f3 9201 c8c3 1...II@@........

सभा:

section .text
	global func
func:	;function uses fastcall conventions, 1st arg in ecx, returns in eax
	;reset edx to 0 so division works
	xor edx, edx

	mov eax, ecx
	;calculate ecx (1st func arg) - 2
	dec ecx
	dec ecx

	;calculate (ecx+2) mod 5
	inc eax
	inc eax
	mov bl, 5
	div ebx
	xchg eax, edx
	
	;add (ecx-2) and ((ecx+2) mod 5), returning in eax
	add eax, ecx
	ret

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

— Logern
स्रोत
1

एक्सेल, 17 बाइट्स

=A1-2+MOD(A1+2,5)

कुछ भी स्मार्ट नहीं है। सामान्य सूत्र लागू करता है।

— Wernisch
स्रोत
1

QBasic, 30 बाइट्स

INPUT x 
x=x+2 
?-4+x*2-(x\5)*5

पॉज़िशन में सूची की 0-अनुक्रमित प्रविष्टि देता है x।

इसे ऑनलाइन आज़माएं! (ध्यान दें कि ?इसका विस्तार PRINTइसलिए किया गया क्योंकि दुभाषिया अन्यथा विफल हो जाता है ...)

— steenbergh
स्रोत
1

आर , 25 बाइट्स

n=1:scan()-1;n-2+(n+2)%%5

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

पोर्ट ऑफ रॉबर्ट एस के जवाब (और केवल 4 बाइट्स जोड़कर) आर वैक्टर को संभालने में उत्कृष्ट होने के लिए धन्यवाद।

पहले n मान को आउटपुट करता है।

— Sumner18
स्रोत
0

टीआई-बेसिक, 11 बाइट्स

Ans-2+remainder(Ans+2,5

इनपुट में है Ans।
आउटपुटए(n)।

अन्य उत्तरों का एक सरल पोर्ट।

नोट: TI-BASIC एक टोकन भाषा है। कैरेक्टर काउंट बाइट काउंट नहीं के बराबर होता है ।

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