लकी नंबर जनरेट करें

Question

कहानी:

लुसी ने जॉर्ज से पूछा कि उसका लकी नंबर क्या है। कुछ चिंतन के बाद, जॉर्ज ने जवाब दिया कि उनके पास कई लकी नंबर हैं। कुछ संक्षिप्त भ्रम के बाद, लुसी ने जॉर्ज से पूछा कि उनके पहले nलकी नंबर क्या हैं। जॉर्ज ने तब आपको, उनके दोस्त को, उनके लिए काम करने के लिए एक कार्यक्रम लिखने के लिए कहा।

चुनौती:

आप एक प्रोग्राम / फ़ंक्शन लिखेंगे जो मानक इनपुट / फ़ंक्शन तर्क से एक स्ट्रिंग या पूर्णांक प्राप्त करेगा n। प्रोग्राम / फ़ंक्शन फिर पहले n लकी नंबरों को वापस करेगा / आउटपुट करेगा । भाग्यशाली संख्याओं को एक छलनी के माध्यम से निम्नानुसार परिभाषित किया गया है।

सकारात्मक पूर्णांक के साथ शुरू करें:

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

अब हर दूसरे नंबर को हटा दें:

1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, ...

दूसरी शेष संख्या 3 है , इसलिए हर तीसरे नंबर को हटा दें:

1, 3, 7, 9, 13, 15, 19, 21, 25, ...

अब अगली शेष संख्या 7 है , इसलिए हर सातवें नंबर को हटा दें:

1, 3, 7, 9, 13, 15, 21, 25, ...

इसके बाद हर नौवें नंबर को हटा दें। परिणामी अनुक्रम भाग्यशाली संख्याएं हैं।

जीतना:

कोडगॉल्फ के लिए हमेशा की तरह, सबसे कम बाइट्स जीतती हैं।

हमेशा की तरह, मानक खामियों का उपयोग कर प्रस्तुतियाँ अयोग्य हैं।

Comments

मैं सुझाव देता हूं कि इस पोस्ट में परिभाषा के साथ-साथ पहले दस या इतनी संख्याएँ शामिल हैं।

— xnor

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

— रयान

@ मुझे लगता है कि अनुक्रम उल्लेखनीय रूप से प्राकृतिक संख्या के समान होगा :)

— TheNumberOne

@ TheBestOne आपको ऐसा लगता है? मैंने पहले math.stackexchange: math.stackexchange.com/questions/1153889/…

— रायन

@ रयान वास्तव में, मैंने आपके सुझाव की गलत व्याख्या की। जैसा कि आपने math.se पर अपने प्रश्न में कहा था, मुझे लगता है कि यह दिलचस्प होगा।

— TheNumberOne

Answer 1

अजगर 2, 79

n=input()
L=range(1,2**n)
for r in L:r+=r<2;map(L.remove,L[r-1::r])
print L[:n]

एक सूची पर पुनरावृत्ति करने का जादू जैसा कि लूप इसे संशोधित करता है!

सूची Lसभी पूर्णांकों के साथ 1पर्याप्त रूप से उच्च मूल्य पर शुरू होती है । कोड प्रत्येक तत्व पर iterates rकी L, हर की sublist लेने r'वें तत्व, और उन मूल्यों में से प्रत्येक को हटाने। परिणामस्वरूप, हटाए गए मान इससे अधिक पुनरावृत्त नहीं होते हैं। अंत में, पहले nतत्वों को प्रिंट करें ।

अभिव्यक्ति map(A.remove,B)एक चाल है जिसका मैं लंबे समय से उपयोग करने का इंतजार कर रहा हूं। यह A.removeप्रत्येक तत्व के लिए कहता है B, जिससे सभी तत्वों Bको हटा दिया जाता है A। प्रभावी रूप से, यह सूची में अंतर लेता है, हालांकि इसके लिए Bएक सबलिस्ट होना आवश्यक है A। इसे पायथन 2 की आवश्यकता है, क्योंकि पायथन 3 वास्तव में नक्शे का मूल्यांकन नहीं करेगा।

पहले पाश की जरूरत है विशेष मामलों में परिवर्तित करने के लिए rसे 1करने के लिए 2, के रूप में r+=r<2।

पर्याप्त रूप से उच्च ऊपरी सीमा के 2**nबड़े मूल्यों के लिए कार्यक्रम को बहुत धीमा कर देता है n। n*n+1सुइयों का उपयोग करना , लेकिन एक चरित्र की लागत। ध्यान दें कि n*nकाम नहीं करता है n=1।

Comments

आपको बस n**2संख्याओं की आवश्यकता है , नहीं2**n

— ऑप्टिमाइज़र

mapवहाँ आप का एक अद्भुत उपयोग है । मैं सोच रहा था कि क्या कोई बेहतर तरीका था ...

— Sp3000

@Oimimizer दुर्भाग्य से, n**2+1जब तक कि मामले n=1को माफ नहीं किया जा सकता है।

— xnor

नक्शे का वह प्रयोग शानदार है। जैसे ऑर्डर सेट का उपयोग करना। शायद यह भी इस्तेमाल किया जा सकता है जैसे map(A.index,B)कि ए में बी के तत्वों के अनुक्रमित map(A.count,B)को खोजने के लिए , ए में बी के तत्वों की संख्या को खोजने के लिए, ए map(A.extend,B)के लिए एक चपटे बी सूची को जोड़ने के लिए मन के चश्मे।

— लॉजिक नाइट

Answer 2

हास्केल, 71 69 बाइट्स

s(n:k)p=n:s[m|(i,m)<-zip[p..]k,i`mod`n>0](p+1)
f n=take n$1:s[3,5..]3

एक कार्य को परिभाषित करता है f। अभिव्यक्ति 1:s[3,5..]3भाग्यशाली संख्याओं की अनंत सूची का मूल्यांकन करती है, और fबस nउनमें से पहली बार लेती है take n।

f 20
[1,3,7,9,13,15,21,25,31,33,37,43,49,51,63,67,69,73,75,79]

मैं एक समानांतर सूची समझ का उपयोग करके चलनी से 5 बाइट्स दाढ़ी कर सकता था

s(n:k)p=n:s[m|m<-k|i<-[p..],i`mod`n>0](p+1)

लेकिन -XParallelListCompविस्तार को सक्षम करने के लिए जीएचसी को विनम्र संकलक ध्वज को पारित करने की आवश्यकता होगी ।

छलनी का स्पष्टीकरण

s(n:k)p=               -- Sieving a list with head n and tail k with accumulator p is
 n:                    -- the head n, followed by
  s[m|                 -- the result of sieving the list of numbers m
    (i,m)<-zip[p..]k,  -- where (i,m) is drawn from [(p,k_0),(p+1,k_1),(p+2,k_2),..] and
    i`mod`n>0]         -- i does not divide n,
   (p+1)               -- using p+1 as the accumulator

मूल विचार यह है कि वें भाग्यशाली संख्या का s(n:k)pउत्पादन होता है, अनंत पूंछ से हर वें नंबर को गिराता है ( पहले उत्पादित संख्याओं के लिए खाते से ऑफसेट ), और संचायक के साथ उस सूची में पुन: दर्ज करता है । इसमें , हम विषम संख्याओं से प्रक्रिया शुरू करते हैं , और सामने वाले से निपटते हैं , बिल्कुल भाग्यशाली संख्या प्राप्त करते हैं।(p-1)nnkp(p+1)f31

Answer 3

अजगर 2, 71 69 67

सबसे पहले, मैंने सोचा कि पायथन की सरणी स्लाइसिंग के लिए यह एक बड़ी चुनौती होगी। हालांकि, मुझे एक ठोकर का सामना करना पड़ा, जब मुझे पता चला कि 1 के अलावा एक कदम के साथ स्लाइस केवल समान लंबाई का एक और टुकड़ा उन्हें सौंपा जा सकता है। लेकिन गुगली करने के बाद "अजगर का टुकड़ा हटा दें", मेरा विश्वास बहाल हो गया: मुझे एक मजेदार delबयान मिला जो पूरी तरह से चाल करता है।

n=input()
l=range(n*n+9)
for v in l:del l[v&~1::v or 2]
print l[:n]

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

n=input()
l=range(1,n*n+9)
for v in l:del l[v-1%v::v+1/v]
print l[:n]

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

Answer 4

> <> , 121 114 111 बाइट्स

i2+:&:*1\
:})?v:2+>l{
nao2\r~1
)?vv>1+:&:&=?;:[{::nao}]$}l1-[01+}:l3-$%$l1-@@-{$[{~l1
3.\ ff+
!?:<]-1v
~]{43. >

मेरे पास कहने के लिए केवल कुछ शब्द हैं ...

... "अर्घ मेरे दिमाग में दर्द करता है।"

---

व्याख्या

> <> एक 2 डी गूढ़ प्रोग्रामिंग भाषा है और निश्चित रूप से इस कार्य के लिए अनुकूल नहीं है, इसकी वजह सरणियों की कमी है। वास्तव में, एकमात्र डेटा प्रकार> <> int / float / char का अजीब मिश्रण है, और सब कुछ ढेर के ढेर पर होता है।

यहाँ रंडी है:

Line 1:            i2+:&:*1\

i2+:&              Read a char as input (n) and add 2, copying n+2 into the register
:*                 Duplicate and multiply, giving (n+2)^2 on the stack
1\                 Push 1 and go to the next line

Line 2:            >l{:})?v:2+

l{:})?v            Go to the next line if the stack's length is greater than (n+2)^2
:2+                Otherwise duplicate the top of the stack and add 2 to it

Line 3:            \r~1nao2

r~                 Reverse the stack and pop; stack contains the first (n+2)^2 odd integers
1nao               Print 1 (special case)
2\                 Push 2 (let's call this "i" for "iterations") and go to the next line

Line 4:            >1+:&:&=?;:[{::nao}]$}l1-[01+}:l3-$%$l1-@@-{$[{~l1)?vv

1+                 Increment i
:&:&=?;            If i is equal to n+2 (+2 because we started at 2), halt
:[{::nao}]$}       Print the i-th element down (the next lucky number) and also
                   copy it to the top of the stack, while moving i to the bottom
l1-[               Move everything but i to a new stack
0                  Push 0 (let's call this "r" for recursion depth)

Sieve loop:

1+                 Increment r
}:l3-$%$l1-@@-{$[  Move everything up to the last element to be sieved out to a new stack
{~                 Remove said last element
1)?vv              If the length is 1, go to line 6 (sieving complete)
                   Otherwise go to line 5, which repeats this sieve loop by teleporting

Line 6:            :?!v1-]

:?!v1-]            Keep unrolling and decrementing r until r is 0

Line 7:            >~]{43.             

~]                 Pop r and unroll once more (to the stack where i waits)
43.                Loop, performing everything from line 4 all over again

यहाँ एक नकली उदाहरण है जो मोटे तौर पर दर्शाता है कि कैसे काम करता है (यहाँ kभाग्यशाली संख्या है जिसे हम छलनी करते हैं):

[[15 13 11 9 7 5 3 1 k=3 r=0]]     -- move -->
[[15 13] [11 9 7 5 3 1 k=3 r=1]]   -- pop  -->
[[15 13] [9 7 5 3 1 k=3 r=1]]      -- move -->
[[15 13] [9 7] [5 3 1 k=3 r=2]]    -- pop  -->
[[15 13] [9 7] [3 1 k=3 r=2]]      -- move -->
[[15 13] [9 7] [3 1] [k=3 r=3]]    -- pop  -->
[[15 13] [9 7] [3 1] [r=3]]        (now we unroll)

Comments

अब भी जावा से बेहतर है;)

— ऑप्टिमाइज़र

मैं इस तथ्य को पसंद करता हूं जिसे naoस्पष्ट रूप से "अब इस बात को प्रिंट करें" के रूप में व्याख्या किया जा सकता है।

— ज़गर्ब

Answer 5

सीजाम - २५

Lri{1$W%{1$\(1e>/+}/)+}/p

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

स्पष्टीकरण:

यह कार्यान्वयन क्रमिक रूप से एक सरणी से संख्याओं को नहीं हटाता है, लेकिन प्रत्येक संख्या की गणना करता है कि कितने आधारों को इससे पहले हटा दिया गया होगा।
प्रत्येक सूचकांक i (0 से n-1) और प्रत्येक पिछले भाग्यशाली संख्या l के लिए, रिवर्स ऑर्डर में, हम i / i (l-1) द्वारा वेतन वृद्धि करते हैं, l = 1 को छोड़कर हम 0 के बजाय 1 का उपयोग करते हैं, और जोड़ते भी हैं अंत में 1।
जैसे i = 4 के लिए हमारे पास पहले 4 नंबर हैं, [1 3 7 9], और गणना करें:
4 + 4 / (9-1) = 4
4 + 4 / (7-1) = 4
4 + 4 / (3 -1) = 6
6 + 6/1 = 12
12 + 1 = 13

L              empty array - the first 0 lucky numbers :)
ri             read and convert to integer (n)
{…}/           for each number (i) from 0 to n-1
    1$         copy the previous array
    W%         reverse the order
    {…}/       for each array element (l)
        1$     copy i
        \(     swap with l and decrement l
        1e>    use 1 if l=1
        /+     divide and add to i
    )+         increment and add the new lucky number to the array
p              pretty print

Comments

दिलचस्प तकनीक :)

— TheNumberOne

Answer 6

पायथ: 23 22 बाइट्स

<u-G%@GhH+0GQ%2r1^hQ2Q

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

स्पष्टीकरण:

<u-G%@GhH+0GQ%2r1^hQ2Q    Q = input()
             %2r1^hQ2     create the list [1, 2, ..., (Q+1)^2-1][::2]
 u          Q%2r1^hQ2     G = [1, 2, ..., (Q+1)^2-1][::2]
                           modify G for each H in [0, 1, 2, ..., Q]:
  -G%:GhH+0G                  G = G - ([0] + G)[::G[H+1]]
                               (minus is remove in Pyth)
<                    Q    print the first Q elements of the resulting list

कम वास्तव में Qभाग्यशाली संख्याओं से अधिक की गणना करता है (निकालें कमांड को क्यू + 1 बार कहा जाता है, क्यू -1 पर्याप्त होना चाहिए)।

Answer 7

आर, 58 बाइट्स

n=scan();s=r=1:n^2;for(j in 1:n)r=r[-max(2,r[j])*s];r[1:n]

लाइन ब्रेक के साथ:

n=scan()              #user input
s=r=1:n^2             #declare r and s simultaneously, both large enough to sieve
for(j in 1:n)
  r=r[-max(2,r[j])*s] #iteratively remove elements by position in vector
r[1:n]                #print

पिछला संस्करण, 62 बाइट्स

function(n){
  s=r=1:n^2             #declare r and s simultaneously, both large enough to sieve
  for(j in 1:n)
    r=r[-max(2,r[j])*s] #iteratively remove elements by position in vector
  r[1:n]                #print
}

पिछला संस्करण, 78 बाइट्स

n=as.numeric(readline())   #ask for user input and convert it to numeric
r=1:n^2                    #create a large enough vector to sieve
for(j in 1:n){             #loop
  r=r[-max(2,r[j])*1:n^2]  #iteratively remove elements by position in vector
}
r[1:n]                     #print

Comments

64 बाइट्स: बदलें n=as.numeric(readline())करने के लिए function(n){...}। यह एक फ़ंक्शन ऑब्जेक्ट बनाता है जिसे असाइन और कॉल किया जा सकता है। forलूप में घुंघराले ब्रेसिज़ को गिराएं।

— एलेक्स ए।

धन्यवाद @ एलेक्स! हालांकि यह 66 है, क्योंकि इसे एक नाम की आवश्यकता है?

— फ़्रीक्वेड

इसे प्रस्तुत करने के लिए किसी नाम की आवश्यकता नहीं है। मतलाब / ऑक्टेव समाधान देखें। फंक्शन ऑब्जेक्ट्स अन्य भाषाओं में अनाम / लंबो कार्यों के समान हैं, जो मान्य प्रस्तुतियाँ हैं।

— एलेक्स ए।

किस बारे में n=scan(n=1)?

— koekenbakker

यह काम करता है! और यह 1 वर्ण कम है। यह छोटा है अगर मैं n = 1 छोड़ता हूं, तो फ़ंक्शन पहले के बाद n के सभी तत्वों को अनदेखा करता है।

— फ़्रीक्वेड

Answer 8

CJam, 32 30 बाइट्स

3ri:N#,N{0\__I1e>)=%-+}fI(;N<p

STDIN से इनपुट लेता है।

कोड स्पष्टीकरण :

3ri:N#,                          "Read the input in N and get first 3^N whole numbers";
       N{0\__I1e>)=%-+}fI        "Run the code block N times, storing index in I";
         0\__                    "Put 0 before the array and take 2 copies";
             I1e>)=              "Take min(2, I + 1) th index from the copy";
                   %             "Take every array[ min (2, I + 1)] element from the array";
                    -+           "Remove it from the list and prepend 0 to the list";
                         (;N<p   "Print number index 1 to N";

इसे यहाँ ऑनलाइन आज़माएँ

Answer 9

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

n=input()
L=range(-1,n*n+9,2)
i=2
while L[i:]:L=sorted(set(L)-set(L[L[i]::L[i]]));i+=1
print L[1:n+1]

बस एक सीधा कार्यान्वयन।

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

J%2r1h^Q2VJI>JhN=J-J%@JhN+2J;<JQ

ऊपर दिए गए दृष्टिकोण के समान है, लेकिन चीजें 1-अनुक्रमित के बजाय 0-अनुक्रमित हैं। इसे ऑनलाइन आज़माएं ।

एक बाइट सेविंग इंगित करने के लिए @Jakube का धन्यवाद।

Answer 10

मैथेमेटिका, 80 बाइट्स

(For[l=Range[#^2];i=1,(m=l[[i++]]~Max~2)<=Length@l,l=l~Drop~{m,-1,m}];l[[;;#]])&

परिभाषा के सीधे-आगे कार्यान्वयन। कुछ अन्य जवाबों के रूप में, एक सीमा से शुरू होता 1है और फिर फ़िल्टर होता रहता है।n2

Answer 11

पर्ल, 86 81 78

86:

@a=(1..($k=<>)**2);for$n(@a){$i=1;@a=map{$i++%($n+($n<2))?$_:()}@a;$k-=$k&&print"$n "}

अद्यतन: जाहिर है, 81 grep{...}से बेहतर है map{...?$_:()}:

@a=(1..($k=<>)**2);for$n(@a){$i=1;@a=grep{$i++%($n+($n<2))}@a;$k-=$k&&print"$n "}

अद्यतन: ठीक है, वास्तव में एक लाइनर अब। मेरे लिए रोकना संभव नहीं। (?) 78:

@a=(1..($k=<>)**2);for$n(@a){$k-=$i=$k&&print"$n ";@a=grep{$i++%($n+=$n<2)}@a}

Answer 12

ऑक्टेव, 139 83 72

function r=l(n)r=1:2:n^2;for(i=2:n)h=r(i);r(h:h:end)=[];end;r=r(1:n);end

Ungolfed:

function r=l(n)
  r=1:2:n^2;
  for(i=2:n)
    h=r(i);
    r(h:h:end)=[];
  end
r=r(1:n);  # reduce it to only N lucky numbers
end

Answer 13

जे, 60 52 बाइट्स

   ({.}.@((>:@{.,]#~0<({~{.)|i.@#)@]^:[2,1+2*i.@*:@>:)) 8
1 3 7 9 13 15 21 25

स्पष्टीकरण (दाएं से बाएं):

2,1+2*i.@*:@>:  generates the list 2 1 3 5 7 9... with (n+1)^2 odd numbers
^:[             repeats n times the following
@]                using the list
0<({~{.)|i.@#     is the remainder of the indexes of the lists elements with the first element positive (i.e. index divisible by first element)
]#~               keep those elements from the list
>:@{.,            concatenate a first element with the value of the current one +1
}.@             drop first element
{.              take the first n element

2,1+2*i.@*:@>:जिस तरह से बहुत लंबा लगता है, लेकिन मैं केवल 1 बाइट को स्वैप करके इसे छोटा कर सकते हैं *:के साथ !सूची तेजी से बढ़ने बना रही है।

Answer 14

जावास्क्रिप्ट (ईएस 6) 96 99

पहले लूप में नीचे की गिनती संपादित करें - धन्यवाद @DocMax

F=n=>(i=>{
  for(o=[1];--i;)o[i]=i-~i;
  for(;++i<n;)o=o.filter((x,j)=>++j%o[i]);
})(n*n)||o.slice(0,n)

Ungolfed

F=n=>{
  for (i = n*n, o = [1]; --i;)
    o[i] = i+i+1;
  for (; ++i < n; )
    o = o.filter((x, j) => (j+1) % o[i])
  return o.slice(0,n)
}

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

F(57)

उत्पादन

[1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79, 87, 93, 99, 105, 111, 115, 127, 129, 133, 135, 141, 151, 159, 163, 169, 171, 189, 193, 195, 201, 205, 211, 219, 223, 231, 235, 237, 241, 259, 261, 267, 273, 283, 285, 289, 297, 303]

Comments

आप पहले लूप के साथ नीचे और दूसरे के साथ ऊपर गिनती करके 1 को बचा सकते हैं:F=n=>{for(o=[1],i=n*n;--i;)o[i]=2*i+1;for(;++i<n;o=o.filter((x,j)=>++j%o[i]));return o.slice(0,n)}

— डॉकमैक्स

आपका अनगुल्ड वास्तव में यहाँ मदद नहीं करता है: P;)

— अनुकूलक

@ ऑप्टिमाइज़र ने अपडेट नहीं किया - शायद अभी भी बहुत मदद नहीं की है, लेकिन कम से कम अब काम कर रहा है

— edc65

मैं "बस एक स्वरूपण परिवर्तन में मदद नहीं करेगा पर लाइनों पर अधिक मतलब था, कृपया टिप्पणियाँ प्रदान करें :)"

— अनुकूलक

Answer 15

मतलाब, 104 बाइट्स

function x=f(n)
k=1;N=n;x=0;while nnz(x)<n
x=1:N;m=1;while m-nnz(x)
m=x(x>m);x(m:m:end)=[];end
N=N+2;end

बहुत उपयुक्त टिप्पणियों और सुझावों के लिए @flawr के लिए धन्यवाद।

माटलाब कमांड प्रॉम्प्ट से उदाहरण:

>> f(40)
ans =
  Columns 1 through 22
     1     3     7     9    13    15    21    25    31    33    37    43    49    51    63    67    69    73    75    79    87    93
  Columns 23 through 40
    99   105   111   115   127   129   133   135   141   151   159   163   169   171   189   193   195   201

Comments

धन्यवाद! मैं अतीत में इस्तेमाल किया था, लेकिन भूल जाते हैं

— लुइस मेंडो

@flawr अच्छा बिंदु। यह उत्तर तुम्हारा होने से ज्यादा तुम्हारा है! :-)

— लुइस मेंडो

ज़रूर! मैं स्टैकऑवरफ्लो में अधिक बार बाहर घूमता हूं, लेकिन यह वही भावना है। मैं इसकी सराहना करता हूं!

— लुइस मेंडो

अच्छी बात! मुझे यकीन नहीं है कि मैं यह सब सीख रहा हूं, यह मेरे मानक मैटलैब उपयोग के लिए उपयोगी या वास्तव में हानिकारक होगा, हालांकि :-P

— लुइस मेंडो

खैर कोडगॉल्फ उपयोग के बारे में नहीं है, बल्कि एक भाषा के दुरुपयोग के बारे में है ^ ^

— दोष

Answer 16

बैश + कोरुटिल्स, 136

मुझे यह और अधिक नीचे गोल्फ की उम्मीद थी, लेकिन ओह अच्छी तरह से। हर दिन नहीं कि आप एक शेल स्क्रिप्ट में एक पुनरावर्ती फ़ंक्शन में पाइप करें:

f(){
mapfile -tn$2 a
(($1>$2))&&{
tr \  \\n<<<${a[@]}
sed $[${a[-1]}-$2]~${a[-1]}d
}|f $1 $[$2+1]||echo ${a[@]}
}
yes|sed -n 1~2=|f $1 2

आउटपुट:

$ ./lucky.sh 23
1 3 7 9 13 15 21 25 31 33 37 43 49 51 63 67 69 73 75 79 87 93 99
$ 

---

बैश + कोरुटिल्स, 104

अधिक सरल कार्यान्वयन का उपयोग करने वाला छोटा:

a=(`seq 1 2 $[3+$1**2]`)
for((;i++<$1;));{
a=($(tr \  \\n<<<${a[@]}|sed 0~${a[i]}d))
}
echo ${a[@]:0:$1}

Answer 17

जाओ, ३२६

package main
import"fmt"
func s(k, p int,in chan int)chan int{
    o := make(chan int)
    go func(){
        for p>0{
            o<-<-in;p--
        }
        for{
            <-in
            for i:=1;i<k;i++{o<-<-in}
        }
    }()
    return o
}
func main(){
    n := 20
    fmt.Print(1)
    c := make(chan int)
    go func(c chan int){
        for i:=3;;i+=2{c<-i}
    }(c)
    for i:=1;i<n;i++{
        v := <-c
        fmt.Print(" ", v)
        c = s(v, v-i-2, c)
    }
}

सीधे आगे कार्यान्वयन goroutine और पाइप का उपयोग करने के लिए sirs बनाने के लिए।

Comments

यह कोड गोल्फ, कृपया एक बाइट गिनती जोड़ें।

— edc65

Answer 18

MATLAB, 62 वर्ण

n=input('');o=1:2:n^2;for i=2:n;o(o(i):o(i):end)=[];end;o(1:n)

मैंने पहली बार चुनौती को गलत बताया - मेरा संशोधित संस्करण अब वास्तव में छोटा है।

Answer 19

रैकेट 196 बाइट्स

N तक भाग्यशाली संख्या पैदा करता है:

(λ(n)(let loop((l(filter odd?(range 1 n)))(i 1))(define x(list-ref l i))(set! l(for/list((j(length l))
#:unless(= 0(modulo(add1 j)x)))(list-ref l j)))(if(>= i(sub1(length l)))l(loop l(add1 i)))))

Ungolfed संस्करण:

(define f
 (λ(n)
    (let loop ((l (filter odd? (range 1 n))) (i 1))
      (define x (list-ref l i))
      (set! l (for/list ((j (length l)) #:unless (= 0 (modulo (add1 j) x)))
                (list-ref l j)))
      (if (>= i (sub1 (length l)))
          l
          (loop l (add1 i)))))
  )

परिक्षण:

(f 100)

आउटपुट:

'(1 3 7 9 13 15 21 25 31 33 37 43 49 51 63 67 69 73 75 79 87 93 99)