इतनी त्रिकोणीय संख्या नहीं
चलो अनुक्रम पर विचार \$S\$एक से मिलकर \$1\$और एक \$0\$इसके बाद दो \ _$1\$'है और दो \$0\$और इतने पर:
$$1,0,1,1,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,...$$
(यह ए 118175 है : एकल काले सेल से शुरू होने वाले नियम 220 प्राथमिक सेलुलर ऑटोमेटन के एन-वें पुनरावृत्ति के द्विआधारी प्रतिनिधित्व। )
यह देखते हुए \$n>0\$, आपका कार्य आउटपुट के लिए है \$a(n)\$, की संख्या के रूप में परिभाषित \$1\$'के बीच है \$T(n)\$\ की पहली शर्तें$S\$, कहाँ \ _$T(n)\$द \ _ है$n\$-तथा त्रिकोणीय संख्या ।
पहले कुछ शब्द हैं:
$$1,2,3,6,9,11,15,21,24,28,36,42,46,55,65,70,78,91,99,105,...$$
इसके बारे में सोचने का एक तरीका यह है कि संख्या कितनी होगी$1\$'अप करने के लिए है \$n\$के मूल्यों के साथ भरा एक त्रिकोण के -वें पंक्ति \$S\$:
1 (1)
01 (2)
100 (3)
1110 (6)
00111 (9)
100001 (11)
1111000 (15)
00111111 (21)
000000111 (24)
1111000000 (28)
01111111100 (36)
...
नियमों
आप या तो:
- ले \$n\$इनपुट के रूप में और वापसी \$n\$-तब्द, 1-अनुक्रमित
- ले \$n\$इनपुट के रूप में और वापसी \$n\$-तब्द, ० — अनुक्रमणित
- ले \$n\$इनपुट के रूप में और वापसी \$n\$ पहली शर्तें
- कोई इनपुट न लें और अनुक्रम को हमेशा के लिए प्रिंट करें
यह एक कोड-गोल्फ चुनौती है।
जवाब
जेली , 9 बाइट्स
ḤR>)FŒHṪS
एक राक्षसी लिंक स्वीकार कर रहा है \$n\$जो पैदावार \ _$a(n)\$।
इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।
कैसे?
हम सोच सकते हैं \ की$S\$के रूप में लंबाई के ब्लॉक में बनाया जा रहा \$2i\$जहां प्रत्येक ब्लॉक \ की एक स्ट्रिंग है$i\$लोगों द्वारा पीछा किया \$i\$शून्य: 10 1100 111000 ...।
अगर हम में बंद \$i=x\$और परिणाम को कॉल करें \ _$S_x\$हम जानते हैं कि \$S_x\$ आवश्यक रूप से समान और शून्य शामिल हैं।
हम यह भी जानते हैं कि \ की लंबाई$S_x\$हो जाएगा \$\sum_{i=1}^{x}2i = 2 \sum_{i=1}^{x}i = 2T(x)\$।
तो \ _ का मान$a(x)\$की पहली छमाही में लोगों की गिनती है \$S_x\$।
इसी परिणाम को प्राप्त करने का एक वैकल्पिक तरीका शून्य की गिनती को \ _ की पहली छमाही में घटाना है।$S_x\$से \$T(x)\$और तब से \$S_x\$लोगों को और शून्य की एक समान संख्या में शामिल है इस जरूरी भी की दूसरी छमाही में शून्य की गिनती हो \$S_x\$। इसलिए हम \ का पूरक बन सकते हैं$S_x\$ और लोगों को इसकी दूसरी छमाही में गिनें:
ḤR>)FŒHṪS - Link: integer, n
) - for each (i in [1..n]): e.g. i=3
Ḥ - double 6
R - range [1,2,3,4,5,6]
> - greater than i? [0,0,0,1,1,1]
F - flatten -> [0,1,0,0,1,1,0,0,0,1,1,1,...]
ŒH - split into two equal length parts
Ṫ - tail
S - sum
वोल्फ्राम लैंग्वेज (गणितज्ञ) , 41 बाइट्स
Sum[1-⌈s=√n⌉+Round@s,{n,#(#+1)/2}]&
इसे ऑनलाइन आज़माएं!
@ZippyMagician से -2 बाइट्स
भूसी , 8 बाइट्स
Σ↑ṁṘḋ2NΣ
इसे ऑनलाइन आज़माएं! या पहले 12 मान सत्यापित करें
रिटर्न \$n^{th}\$ अनुक्रम का मूल्य, 1 अनुक्रमित।
व्याख्या
Σ↑ṁṘḋ2NΣ
ṁ N map the following across natural numbers and concatenate
Ṙḋ2 replicate [1,0] n times
↑ take all values
Σ till the triangular number of the input
Σ sum them
पायथन 2 , 47 बाइट्स
f=lambda n,k=8:k>n*-~n*2or(-k**.5%2<1)+f(n,k+4)
इसे ऑनलाइन आज़माएं!
52 बाइट्स
lambda n:sum(-(k+1)**.5%1<.5for k in range(n*-~n/2))
इसे ऑनलाइन आज़माएं!
\ के लिए सूत्र पर आधारित$S\$उस उपयोगकर्ता ने A118175 के OEIS पृष्ठ से नोट किया । हम इसे निम्नलिखित के लिए सरल करते हैं, 0/1 के लिए बुलियन का उपयोग करते हुए एक-अनुक्रमित:$$ S(k) = \mathrm{frac}(-\sqrt{k}) < \frac{1}{2},$$कहाँ \$\mathrm{frac}\$भिन्नात्मक भाग लेता है, यही संख्या और उसके तल के बीच का अंतर है। उदाहरण के लिए, \$\mathrm{frac}(-2.3)=0.7\$। यह \ _ के बराबर है$\sqrt{k}\$ज्यादा से ज्यादा किया जा रहा है \$\frac{1}{2}\$ इसकी छत से कम।
कोड बस बैठता है $$\sum_{k=1}^{n(n+1)/2} S(k),$$लेकिन तर्क स्थानांतरण \$k\$ शून्य-अनुक्रमित पायथन रेंज के लिए एक से एक खाते में।
57 बाइट्स
def f(n):N=n*-~n/2;a=round(N**.5);print(a+N-abs(a*a-N))/2
इसे ऑनलाइन आज़माएं!
आउटपुट तैरता है। एक सीधा अंकगणितीय सूत्र। -1 बाइट के लिए अरनौल को धन्यवाद
हास्केल , 48 बाइट्स
f n=sum$sum[1..n]`take`do z<-[1..];[1,0]<*[1..z]
इसे ऑनलाइन आज़माएं!
हास्केल , 48 बाइट्स
sum.(take.sum.r<*>(([1,0]<*).r=<<).r)
r n=[1..n]
इसे ऑनलाइन आज़माएं!
05AB1E , 12 9 बाइट्स
LxL@˜2äнO
सूची को जनरेट करने के लिए @ जोंथनअल्लन के जेली जवाब से प्रेरणा लेकर -2 बाइट्स [1,0,1,1,0,0,1,1,1,0,0,0,...]।
आउटपुट \$n^{th}\$मान। ( @Ovs से साभार )
इसे ऑनलाइन आज़माएं या पहले 10 परीक्षण मामलों को सत्यापित करें ।
10 बाइट्स संस्करण जो इसके बजाय अनंत अनुक्रम का उत्पादन करते हैं:
∞xL@˜∞£OηO
इसे ऑनलाइन आज़माएं।
स्पष्टीकरण:
L # Push a list in the range [1, (implicit) input]
# i.e. input=5 → [1,2,3,4,5]
x # Double each value (without popping)
# [2,4,6,8,10]
L # Convert each value to a [1,n] list as well
# [[1,2],[1,2,3,4],[1,2,3,4,5,6],[1,2,3,4,5,6,7,8],[1,2,3,4,5,6,7,8,9,10]]
@ # Check for each value in the [1,input] list that it's >= the values in the
# inner ranged lists
# [[1,0],[1,1,0,0],[1,1,1,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,1,0,0,0,0,0]]
˜ # Flatten it
# [1,0,1,1,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,0,0,0,0,0]
2ä # Split it into 2 equal-sized parts
# [[1,0,1,1,0,0,1,1,1,0,0,0,1,1,1],[1,0,0,0,0,1,1,1,1,1,0,0,0,0,0]]
н # Only leave the first item
# [1,0,1,1,0,0,1,1,1,0,0,0,1,1,1]
O # And sum this list
# 9
# (after which this sum is output implicitly as result)
∞ # Push an infinite list of positive integers
# [1,2,3,...]
xL@˜ # Same as above
# [1,0,1,1,0,0,1,1,1,0,0,0,...]
∞ # Push an infinite list again
£ # Split the list into parts of that size
# [[1],[0,1],[1,0,0],[1,1,1,0],...]
O # Sum each inner list
# [1,1,1,3,...]
η # Take the prefixes of that list
# [[1],[1,1],[1,1,1],[1,1,1,3],...]
O # Sum each inner list
# [1,2,3,6,...]
# (after which the infinite list is output implicitly)
जेली , 11 बाइट्स
⁵DxⱮRFḣRS$S
इसे ऑनलाइन आज़माएं!
\ $ N \ $ लेता है , आउटपुट \ $ a (n) \ $ , 1-अनुक्रमित होता है
यह काम किस प्रकार करता है
⁵DxⱮRFḣRS$S - Main link. Takes n on the left
⁵ - 10
D - [1, 0]
R - [1, 2, ..., n]
Ɱ - For each i in [1, 2, ..., n]:
x - Repeat [1, 0] i times
F - Flatten the array
$ - Group the previous two commands into a monad T(n):
R - [1, 2, ..., n]
S - Sum
ḣ - Take the first T(n) elements of the sequence
S - Take the sum, essentially counting the 1s
चारकोल , 24 13 बाइट्स
ＩΣ∕⭆⊕Ｎ⭆10×ιλ²
इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:
Ｎ Input `n`
⭆⊕ Map over inclusive range
⭆10 Map over characters of literal string `10`
λ Current character
× Repeated by
ι Outer index
∕ ² First half of resulting string
Σ Digital sum (i.e. count `1`s)
Ｉ Cast to string
Implicitly print
पिछला 24-बाइट अधिक चाराल-वाई समाधान:
ＮθＧLθψ¤⭆θ⭆²⭆⊕ιλ≔№ＫＡ0θ⎚Ｉθ
इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:
Ｎθ
इनपुट n।
ＧLθψ
साइड के एक खाली दाहिने त्रिकोण को ड्रा करें n।
¤⭆θ⭆²⭆⊕ιλ
स्ट्रिंग का उपयोग करके इसे भरें 010011000111...। (स्ट्रिंग हमेशा त्रिभुज की तुलना में दो गुना लंबी होती है।) चारकोल का भराव क्षेत्र में प्रदान किए गए स्ट्रिंग को भरने के लिए पेंट करता है (उदाहरण के लिए पाई का एक टुकड़ा सेंकना )। ध्यान दें कि 0एस और 1एस स्वैप किए गए हैं।
≔№ＫＡ0θ
0वास्तव में छपे हुए संख्याओं की संख्या प्राप्त करें ।
⎚Ｉθ
कैनवास को साफ़ करें और परिणाम प्रिंट करें।
पायथन 2 , 62 बाइट्स
a=lambda n,k=1:-~n*n>k*k*2and k+a(n,k+1)or max(0,k-~n*n/2-k*k)
इसे ऑनलाइन आज़माएं!
यह पर आधारित है
$$ \begin{align} a(n) &= f(\frac{n\cdot(n+1)}{2}, 1) \\ \\ f(n, k) &= \begin{cases} k+f(n-2k, k+1), & \text{if $n> के$} \\ \operatorname{max}(0, n), & \text{if $n \ ले के$} \end{cases} \end{align} $$
लेकिन शर्तों और आधार मामले को एक एकल पुनरावर्ती फ़ंक्शन में प्राप्त करने के लिए अधिक दृढ़ हैं।
के (ओके) , 30 25 24 बाइट्स
-6 बाइट्स कोल्टिम के लिए धन्यवाद
{+/(x+/!x)#,/x{0,x,1}\1}
इसे ऑनलाइन आज़माएं!
एन-वें पद 1-अनुक्रमित लौटाता है।
जावास्क्रिप्ट (Node.js) , 100 89 85 84 77 बाइट्स
परिवर्तित करें: -11 a**2के लिए a*aऔर आसान बनाने 1-Math.ceil(c)+Math.round(c)के लिए Math.ceil(c)-c<0.5( @xnor )
-4: c=Math.sqrt(b+1)अंदर ले जाएँ Math.ceil(c)और f=( @user ) को छोड़ें
-1: बदलें ... c<0.5से ... c<.5( @xnor )
-7: अनावश्यक निकालें (और ), और परिवर्तन Math.sqrt(... )करने के लिए ... **.5( @Samathingamajig )
a=>(x=0,Array((a*a+a)/2).fill().map((a,b)=>x+=Math.ceil(c=(b+1)**.5)-c<.5),x)
इसे ऑनलाइन आज़माएं!
एपीएल + विन, 26 21 बाइट्स।
एडम के लिए माइनस 5 बाइट्स धन्यवाद।
पूर्णांक के लिए संकेत:
+/(+/m)↑∊(m←⍳⎕)∘.⍴1 0
इसे ऑनलाइन आज़माएं! थिलक्स टू डायलायग क्लासिक
पायथन 3 , 69 बाइट्स
lambda n:sum([j for i in range(1,n+1)for j in[1]*i+i*[0]][:n*-~n//2])
इसे ऑनलाइन आज़माएं!
स्काला, 66 58 51 बाइट्स
n=>1 to n flatMap(i=>""*i+"\0"*i)take(n*n+n>>1)sum
इसे ऑनलाइन आज़माएं
0x01पहले उद्धरण के अंदर एक अनपेक्षित चरित्र है।
एक अनाम फ़ंक्शन जो एक पूर्णांक लेता है nऔर अनुक्रम के nth तत्व (1-अनुक्रमित) को लौटाता है।
हास्केल , 46 बाइट्स
f n=sum[1|a<-[1..n],b<-[1..a],a*a-b<n*(n+1)/2]
इसे ऑनलाइन आज़माएं!
46 बाइट्स
f n=sum[max 0$min a$n*(n+1)/2-a*a+a|a<-[1..n]]
इसे ऑनलाइन आज़माएं!
48 बाइट्स
f n=sum[1|k<-[2,4..n*n+n],even$ceiling$sqrt$2*k]
इसे ऑनलाइन आज़माएं!
सी (जीसीसी) , 84 82 61 बाइट्स
ErikF के लिए धन्यवाद 2 बाइट्स सहेजे गए !!!
c;p;f(n){for(c=p=0,n=n*-~n/2;n>2*p;n-=2*p++)c+=p;c+=n<p?n:p;}
इसे ऑनलाइन आज़माएं!
एक इनपुट \$1\$-बेड नंबर \ _$n\$और रिटर्न \$n^{\text{th}}\$ शब्द।
हास्केल , 50 बाइट्स
r?x|q<-sum[0..x]-r*r,r>q=min q 0|l<-r+1=l+l?x
(0?)
इसे ऑनलाइन आज़माएं!
थोड़े लंबे समय तक लेकिन मौजूदा हास्केल उत्तर से अलग दृष्टिकोण को पूरा करें। यह एक मूल रूप से सभी अंकगणित है जबकि मौजूदा एक खरोंच से सूची बनाता है।
रेटिना 0.8.2 , 41 बाइट्स
.+
$* 1 $`1$.`$*00
((.)+?)(?<-2>.)+$ $1
1
इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:
.+
$* 1 $`1$.`$*00
स्ट्रिंग बनाएं 101100111000... n 1एस और n 0एस तक, जो वांछित त्रिकोण से दोगुना है।
((.)+?)(?<-2>.)+$ $1
स्ट्रिंग के दूसरे छमाही को हटा दें।
1
1शेष की संख्या गिनें ।
जे , 25 बाइट्स
(1#.2&!$&;1 0<@#"{~i.)@>:
इसे ऑनलाइन आज़माएं!
(1#.2&!$&;1 0<@#"{~i.)@>:
( )@>. increment n by 1 and then
i. for every i in 0 … n+1:
1 0 #"{~ take i 1s and i 0s,
<@ and box the result (;1 0;1 1 0 0;…)
2&! T(n) by binominal(n+1, 2)
$&; raze the boxes to a list (1 0 1 1 0 0…)
and take the first T(n) elements
1#. sum the list, i.e. count the 1s
MATL , 15 14 बाइट्स
:"@:t~]vG:s:)z
इनपुट 1-आधारित है।
इसे ऑनलाइन आज़माएं! या पहले मूल्यों को सत्यापित करें ।
यह काम किस प्रकार करता है
% Implicit input: n
: % Range: [1 2 ... n].
" % For each
@ % Push iteration index, k (goes from 1 to n)
: % Range: gives [1 2 ... k]
t % Duplicate
~ % Negate, element-wise: gives [0 0 ... 0] (k zeros)
] % End
v % Concatenate everything into a column vector
G % Push n again
: % Range: [1 2 ... n]
s % Sum: gives n-th triangular number, T(n)
: % Range
) % Index: keeps the first T(n) values
z % Number of nonzeros
% Implicit output
आर , 55 बाइट्स
sum(unlist(Map(rep,list(1:0),e=n<-1:scan()))[1:sum(n)])
इसे ऑनलाइन आज़माएं!
A118175 उत्पन्न करता है और पहला \ _ sums$T(n)\$ शर्तें।
डेसमोस, 85 बाइट्स
\ _$\sum_{n=1}^{x(x+1)/2}(1-\operatorname{ceil}(\sqrt{n})+\operatorname{round}(\sqrt{n}))\$
\sum_{n=1}^{x(x+1)/2}(1-\operatorname{ceil}(\sqrt{n})+\operatorname{round}(\sqrt{n}))
मैं स्वयं एक अच्छा सूत्र नहीं खोज पाया, इसलिए मैंने \ _ का उपयोग किया$a(n) = 1 - \operatorname{ceil}(\sqrt{n+1}) + \operatorname{round}(\sqrt{n+1})\$सूत्र A118175 के पृष्ठ पर उपलब्ध कराया गया ।
गैया , १२ ११ १० बाइट्स
┅2…&¦_2÷eΣ
इसे ऑनलाइन आज़माएं!
एक बाइट को बचाने के लिए जोनाथन एलन के जवाब से अवलोकन का उपयोग करता है (इसलिए ऊपर जाना है कि), अर्थात् पूरक अनुक्रम का निर्माण और दूसरी छमाही में 1s की गिनती पहली छमाही में 1s गिनती के बराबर है।
# implicit input n
┅ # push [1, 2, ..., n]
2… # push [0,1]
&¦ # for each i in [1, 2, ..., n] repeat each element of [0,1] i times
_2÷ # flatten and divide into two sublists of equal length
eΣ # take the second sublist and sum
मैथॉल्फ , 19 12 बाइट्स
╒♂░*mzyh½<iΣ
आउटपुट 1-आधारित \$n^{th}\$ मान।
इसे ऑनलाइन आज़माएं।
मूल 19 बाइट्स उत्तर:
╒♂░*mzykæî‼<≥]╡imΣΣ
आउटपुट 1-आधारित \$n^{th}\$ मान भी।
इसे ऑनलाइन आज़माएं।
स्पष्टीकरण:
╒ # Push a list in the range [1, (implicit) input]
♂░ # Push 10, and convert it to a string: "10"
* # Repeat the "10" each value amount of times: ["10","1010","101010",...]
m # Map over each inner string:
z # Revert sort its digits: ["10","1100","111000",...]
y # Join it together to a single string: "101100111000..."
h # Push its length (without popping the string itself)
½ # Halve it
< # Only keep the first length/2 amount of digits in this string
i # Convert the string to an integer
Σ # And sum its digits
# (after which the entire stack joined together is output implicitly)
╒♂░*mzy # Same as above
# Get its prefixes (unfortunately there isn't a builtin for this):
k # Push the input-integer
æ # Loop that many times,
# using the following four characters as body:
î # Push the 1-based loop index
‼ # Apply the following two commands separated:
< # Slice to get the first n items
≥ # Slice to remove the first n items and leave the remainder
] # After the loop, wrap all values on the stack into a list
╡ # Remove the trailing item
i # Convert each string of 0s/1s to an integer
mΣ # Sum the digits of each inner integer
Σ # And sum the entire list together
# (after which the entire stack joined together is output implicitly)
Raku , 40 बाइट्स
{sum flat({1,0 Xxx++$}...*)[^sum 1..$_]}
इसे ऑनलाइन आज़माएं!
{ ... } ... *एक अनंत अनुक्रम है, जहां ब्रैकेटेड अभिव्यक्ति एक फ़ंक्शन है जो प्रत्येक क्रमिक तत्व उत्पन्न करता है।++$$हर बार जनरेट होने वाले फ़ंक्शन का मूल्यांकन करने पर अनाम राज्य चर में वृद्धि होती है। पहली बार इसे कहा जाता है,++$1 है, फिर 2, आदि।1, 0सिर्फ एक दो-तत्व सूची है।xxप्रतिकृति ऑपरेटर है। क्रॉस-उत्पाद मेटाऑपरेटर के साथ उपसर्गX, अनुक्रम उत्पन्न करने वाले के बढ़ते मूल्य के साथXxxसूची1, 0को पार करता है ।++$(((1), (0)), ((1, 1), (0, 0)), ((1, 1, 1), (0, 0, 0)), ...)flatlazily उस अनंत क्रम को दिए गए अनुक्रम S में समतल करता है, अर्थात1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, ...:।[^sum 1..$_]उस क्रम से पहला N तत्व लेता है, जहाँ N, 1 तक की संख्याओं का योग है$_, जो फ़ंक्शन का तर्क है।- अग्रणी
sumचयनित तत्वों को गाता है।
अर्न -rlx , 14 बाइट्स
&♦r┬f½▀╔î¾rl¥Æ
कोशिश करो!
व्याख्या की
अनपैक्ड: $.(|{|a{a>}\~:+}\
Mutate STDIN from N → [1, N]
$. Partition down middle
(
|..\ Fold N with concatenation
_ Where N is a variable; implied
{ After mapping with block, key of `_`
|..\
~:+ Where N is a one-range to _ * 2
a{ Block with key of `a`
a
> Is greater than
_ Implied
} End block
} End block
Last entry, sum
एक ही झंडे के साथ वैकल्पिक 14 बाइट समाधान: $.(a{~:+a@>a}\):_
अर्न , 23 बाइट्स
W▀Q$µgˆÎ§Ò"ˆÞC5fbA┐V-7J
कोशिश करो! अर्न को एक गोल फिक्स जोड़ने के बारे में सोचकर, यह इस सुंदर उच्च बाइट गिनती में मदद करेगा।
1-अनुक्रमित, Nth शब्द लौटाता है। के आधार पर @ J42161217 के जवाब
व्याख्या की
अनपैक्ड: +{1-(:^:/)+:v(0.5+:/}\~:-*++
+...\ Fold with addition after mapping
~ Over the one-range to
:-*++ n * (n + 1) / 2
{ Begin map, key of `_`
1
- Subtract
(
:^ Ceiling
_ Implied
:/ Square root
)
+ Add
:v(0.5+:/ Round `:/_`, ending implied
} End map
स्विफ्ट , 80 बाइट्स
से अनुकूलित @ovs द्वारा अजगर 2 जवाब
func a(_ n:Int,_ k:Int=1)->Int{-(~n*n)>k*k*2 ? k+a(n,k+1):max(0,k-(~n)*n/2-k*k)}
और अन-गोल्फ फॉर्म:
func a(_ n: Int, _ k: Int = 1) -> Int {
-(~n*n) > k*k*2
? k + a(n, k+1)
: max(0, k - ~n*n/2 - k*k)
}
और यहाँ कुछ नमूना आउटपुट है।
print((1...10).map { a($0) })
// [1, 2, 3, 6, 9, 11, 15, 21, 24, 28]
वास्तव में पुनरावृत्ति के बजाय लूप का उपयोग करना बेहतर हो सकता है। स्विफ्ट में बंद होने (यानी लैम्ब्डा) के साथ कुछ सीमाओं ने मुझे एक फ़ंक्शन घोषणा का उपयोग करने के लिए मजबूर किया, जो बहुत अधिक स्थान लेता है। : /
CJam , 22 बाइट्स
qi),:+{_)mqmo\mqi-}%:+
बिट क्रम में वें स्थिति की round(sqrt(n+1)) - floor(sqrt(n))गणना करने के लिए उपयोग करता है n। (संख्या की पुनरावृत्ति के रूप में इसे प्राप्त करना उत्पन्न करने के लिए छोटा था, लेकिन योग के अंत में एक बाइट बड़ा था।)
इसे ऑनलाइन आज़माएं!
लाल , 109 बाइट्स
func[n][b:[[1]]loop n[append/only b head insert next
copy[0 1]last b]sum take/part load form b n + 1 * n / 2]
इसे ऑनलाइन आज़माएं!
मुझे पता है कि यह बहुत लंबा है - मैं सिर्फ यह देखना चाहता था कि K समाधान (कॉर्टिस @ कोल्टिम) लाल रंग में कैसा दिखेगा :)