रंबल अनुक्रम

Question

रोम्बी के तत्वों की गणना करने की कल्पना करें जो बढ़ते हैं [1],[1,3,1],[1,3,5,3,1],…(केवल विषम संख्याएं जैसे कि वे अच्छी तरह से संरेखित करते हैं)। यह इस प्रकार दिखेगा, ध्यान दें कि आप हमेशा के साथ enumerating शुरू करते हैं 1:

                   01
       1        02 03 04
 1   2 3 4   05 06 07 08 09          …
       5        10 11 12
                   13
(1) (1,3,1)    (1,3,5,3,1)    (1,3,5,7,5,3,1)   …

अब यदि आप कॉलम [1],[2],[1,3,5],[4],[5],[2,6,10],…को समेटना शुरू करते हैं ( ) तो आपको रोम्बस अनुक्रम मिलता है । कहा अनुक्रम के ये पहले 100 तत्व हैं:

1,2,9,4,5,18,35,24,9,10,33,60,91,70,45,16,17,54,95,140,189,154,115,72,25,26,81,140,203,270,341,288,231,170,105,36,37,114,195,280,369,462,559,484,405,322,235,144,49,50,153,260,371,486,605,728,855,754,649,540,427,310,189,64,65,198,335,476,621,770,923,1080,1241,1110,975,836,693,546,395,240,81,82,249,420,595,774,957,1144,1335,1530,1729,1564,1395,1222,1045,864,679,490,297,100

आईओ

आप इन तीन इनपुट / आउटपुट विधियों में से एक चुनने के लिए स्वतंत्र हैं (आपको अमान्य इनपुट को संभालने की आवश्यकता नहीं होगी):

• पूर्णांक n आउटपुट को देखते हुए उस क्रम में n th तत्व (0- या 1-अनुक्रमित, आपकी पसंद)
• पूर्णांक n आउटपुट को उस अनुक्रम के पहले n तत्वों को देखते हुए
• अनुक्रम को अनिश्चित काल के लिए प्रिंट / वापस करें

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

कृपया पहले 100 शब्दों को देखें, यहाँ कुछ बड़े उदाहरण दिए गए हैं (1-अनुक्रमित):

101 -> 101
443 -> 1329
1000 -> 49000    
1984 -> 164672
2017 -> 34289
2018 -> 30270
3000 -> 153000

Answer 1

स्नोमैन , 72 बाइट्स

((}1vn2nD#`nPnCdU!*2nM1`nR:#nSNaB#`nS2nMNdE;aM|#NdE2nP+#`nSNdE`|aA#nM*))

यह एक सबरूटीन है जो 1-अनुक्रमित इनपुट लेता है और परमवीर के माध्यम से संबंधित आउटपुट देता है +।

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

((        // begin subroutine
 }        // we'll only need 3 variables - b, e, g
 1vn2nD   // b = 0.5
 #`       // retrieve input and swap, now b = input and e = 0.5
 nP       // power, resulting in b=sqrt(input)
 nC       // ceiling - this gives the index i of the rhombus we want
 dU!*     // keep a copy of i in the permavar ! for later use
 2nM1`nR  // generate the range [1, 2i)
 :        // map the following block over the range...
  #nS     // subtract i, resulting in e.g. [-3 -2 -1 0 1 2 3] for i=4
  NaB     // absolute value - [3 2 1 0 1 2 3]
  #`nS    // subtract from i, giving [1 2 3 4 3 2 1]
  2nMNdE  // double and decrement, [1 3 5 7 5 3 1]
 ;aM      // map
 |        // shove the rhombus columns into g
 #NdE2nP  // b = (i-2)^2
 +#`      // move b into e and replace it with the original input
 nSNdE    // subtract the two and decrement, giving input-(i-2)^2-1
 `|aA     // this is the index into the rhombus columns that we want
 #nM*     // multiply by the original input and return
))

यह मूल रूप से श्री Xcoder के उत्तर के रूप में एक ही एल्गोरिथ्म का उपयोग करता है -केवल अंतर यह है कि यहां हम केवल उन रंभाओं के स्तंभ उत्पन्न करते हैं जिनकी हमें आवश्यकता होती है, जो कि छत (sqrt (n)) वें एक है। यह बताने के लिए कि यह क्यों काम करता है, यहां ऐसे इनपुट हैं जो प्रत्येक रोम्बस के अनुरूप हैं:

rhombus #   inputs
1           1
2           2 3 4
3           5 6 7 8 9
4           10 11 12 13 14 15 16
...

ध्यान दें कि बाएं स्तंभ दाएं कॉलम में प्रत्येक तत्व के वर्गमूल की छत से बिल्कुल मेल खाता है। यहाँ से 1-आधारित इंडेक्स प्राप्त करने के लिए, हम बस पिछले रोम्बस के इंडेक्स के वर्ग को घटाते हैं।

Answer 2

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

Ḥ€€’ŒBFị@×

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

एन वें पद (1-अनुक्रमित) को लौटाने वाला एक पूर्ण कार्यक्रम / विवादास्पद लिंक ।

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

कैसे?

~ € $ 'ḤBFị @ × ~ पूर्ण कार्यक्रम। मैं इनपुट एन।

  € ~ श्रेणी में प्रत्येक पूर्णांक X के लिए [1, N]।
Ḥ € ~ रेंज में प्रत्येक पूर्णांक डबल [1, X]।
   '~ घटाना (घटाना 1)।
    ŒB ~ बाउंस (तत्व-वार)। प्रत्येक को पालिंड्रोमाइज करें।
      च ~ चपटा।
       ị @ ~ हमारी सूची में सूचकांक एन में तत्व प्राप्त करें।
         × ~ एन द्वारा गुणा करें।

Comments

वैकल्पिक।

— श्री एक्सकोडर

Answer 3

जावास्क्रिप्ट (ईएस 7), 42 41 बाइट्स

@ ब्वॉयज को 1 बाइट धन्यवाद दिया

0 अनुक्रमित। A004737 से प्राप्त एक बंद-रूप अभिव्यक्ति ।

n=>((k=n**.5|0)-Math.abs(n+k*~k))*2*++n+n

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

let f =

n=>((k=n**.5|0)-Math.abs(n+k*~k))*2*++n+n

console.log(f(101-1))  // 101
console.log(f(443-1))  // 1329
console.log(f(1000-1)) // 49000    
console.log(f(1984-1)) // 164672
console.log(f(2017-1)) // 34289
console.log(f(2018-1)) // 30270
console.log(f(3000-1)) // 153000

Answer 4

बेगुंज, 62 60 बाइट्स

&:1>:00p:*`|
00:-\*:g00:<>2-\-0v!`\g
*.@v+1<g00:<^*2g00_2*1+

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

व्याख्या

हम स्टड से एक-आधारित तत्व संख्या, एन , एन को पढ़कर और एक डुप्लिकेट को सहेजकर शुरू करते हैं।
तब हम यह निर्धारित करते हैं कि हम एक पूर्णांक, आर , जब तक गिनते हैं, तब तक हम किस समभुज में हैं r*r >= n।
रोम्बस, सी के दाहिने हाथ की ओर से कॉलम ऑफसेट है r*r - n।
केंद्र अक्ष के चारों ओर परावर्तित होने वाले ऑफसेट को प्राप्त करने के लिए, हम जांचते हैं कि क्या c >= r।
और अगर है, तो प्रतिबिंबित सी बन जाती है r*2 - 2 - c।
एक बार जब हम परावर्तित ग होते हैं , तो स्तंभ का योग सरलता से होता है (c*2 + 1) * n।

Answer 5

एपीएल (डायलॉग) , 18 बाइट्स

{⍵×2×⌊/|⍵-.5+×⍨⍳⍵}

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

Answer 6

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

_.ạ²€ṂḤ×

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

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

_.ạ²€ṂḤ×  Main link. Argument: n

_.        Subtract 0.5; yield (n - 0.5).
   ²€     Square each; yield [1², 2², ..., n²].
  ạ       Take the absolute differences of (n - 0.5) and each of the squares.
     Ṃ    Take the minimum.
      Ḥ   Unhalve; double the minimum.
       ×  Multiply the result by n.