ভাগ্যবান নম্বর উত্পন্ন করুন

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

@ দ্য বেস্টওন আপনি কি ভাবেন? আমি আগে গণিত.স্ট্যাকেক্সচেঞ্জে পোস্ট করেছি: গণিত.স্ট্যাকেক্সেঞ্জাওয়েজ

— রায়ান

@ রায়ান আসলে, আমি আপনার পরামর্শটির ভুল ব্যাখ্যা দিয়েছি। আপনি যেমন এটি গণিতের প্রশ্নে বলেছেন, আমার মনে হয় এটি আকর্ষণীয় হবে।

— 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 আসলে মানচিত্রটি মূল্যায়ন করে না।

প্রথম লুপ চাহিদা বিশেষ-cased রূপান্তর করতে হতে rথেকে 1থেকে 2, যেমন r+=r<2।

পর্যাপ্ত উচ্চতর উপরের সীমাটি 2**nবড় মানগুলির জন্য প্রোগ্রামটিকে খুব ধীর করে তোলে n। n*n+1যথেষ্ট পরিমাণে ব্যবহার করা , তবে একটি চরিত্রের জন্য খরচ হয়। নোট যে n*nকাজ করে না n=1।

Comments

আপনার কেবল n**2সংখ্যা দরকার , না2**n

— অপটিমাইজার

এটি আপনার এক আশ্চর্যজনক ব্যবহার map। আমি আরও ভাল উপায় ছিল কিনা তা ভাবছিলাম ...

— Sp3000

@ অপ্টিমাইজার দুর্ভাগ্যক্রমে, 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উত্পন্ন করে , অসীম লেজ থেকে প্রতিটি তম সংখ্যা ফেলে দেয় ( পূর্বে উত্পাদিত সংখ্যার জন্য অ্যাকাউন্টে অফসেট করে ) এবং সঞ্চয়ের সাথে সেই তালিকায় পুনরাবৃত্তি হয় । ইন , আমরা প্রক্রিয়াটি বিজোড় সংখ্যাগুলি থেকে শুরু করে সূচনা করি এবং সামনে ভাগ্যবান সংখ্যাগুলি পেয়েছি exactly(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]

-2 বাইটস স্পো 3000 ধন্যবাদ।

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 ডি এসোটেরিক প্রোগ্রামিং ভাষা এবং অ্যারের অভাবের কারণে এটি অবশ্যই এই কাজের জন্য উপযুক্ত নয়। আসলে,> <> এ একমাত্র ডেটা টাইপ হ'ল ইন / ফ্লোট / চরের অদ্ভুত মিশ্রণ এবং স্ট্যাকের স্ট্যাকের মধ্যে সবকিছু ঘটে।

রুনডাউন এখানে:

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

সিজেম - 25

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

এটি অনলাইনে চেষ্টা করুন

ব্যাখ্যা:

এই প্রয়োগটি একটি অ্যারে থেকে ধারাবাহিকভাবে নম্বরগুলি সরিয়ে দেয় না, তবে এর আগে কতগুলি সরানো হত তার উপর ভিত্তি করে প্রতিটি সংখ্যা গণনা করে।
প্রতিটি ইনডেক্সের জন্য (0 থেকে এন -1 পর্যন্ত) এবং প্রতিটি পূর্ববর্তী ভাগ্যবান সংখ্যা l, বিপরীত ক্রমে, আমরা i / (l-1) দ্বারা i বৃদ্ধি করি, 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ভাগ্যবান সংখ্যার চেয়ে বেশি গণনা করে (অপসারণ কমান্ডকে Q + 1 বার বলা হয়, Q-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, যেহেতু এটির একটি নাম প্রয়োজন?

— freekvd

জমা দেওয়ার জন্য এটির নামের প্রয়োজন নেই। মতলব / অক্টাভ সমাধান দেখুন। আর ফাংশন অবজেক্টগুলি অন্য ভাষায় নামবিহীন / ল্যাম্বদা ফাংশনগুলির অনুরূপ, যা বৈধ জমা দেওয়া।

— অ্যালেক্স এ।

কি হবে n=scan(n=1)?

— koekenbakker

ওই কাজগুলো! এবং এটি 1 অক্ষর কম। এটি আরও ছোট যদি আমি n = 1 বাদ দিই, ফাংশনটি প্রথমে n এর সমস্ত উপাদানকে উপেক্ষা করবে।

— freekvd

Answer 8

সিজেম, 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-সূচকযুক্ত। এটি অনলাইনে চেষ্টা করুন ।

বাইট সাশ্রয় দেখানোর জন্য @ জাকুবেকে ধন্যবাদ

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

জাভাস্ক্রিপ্ট (ES6) 96 99

প্রথম লুপে গণনা সম্পাদনা করুন - ধন্যবাদ @ ডকম্যাক্স

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)}

— ডকম্যাক্স

আপনার অমীমাংসিতরা এখানে সত্যিই সহায়তা করে না: পি;)

— অপ্টিমাইজার

@ অপ্টিমাইজার অবহেলিত আপডেট হয়েছে - সম্ভবত এখনও খুব বেশি সাহায্য না করে, তবে কমপক্ষে এখনই কাজ করছেন

— 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

খুব উপযুক্ত মন্তব্য এবং পরামর্শের জন্য @ ফ্লোয়ারকে ধন্যবাদ।

মতলব কমান্ড প্রম্পট থেকে উদাহরণ:

>> 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

ধন্যবাদ! আমি এটি অতীতে ব্যবহার করেছি, তবে ভুলে যেতে চাইছি

— লুইস মেন্ডো

@ ফ্লোয়ার ভাল পয়েন্ট। এই উত্তরটি আমার চেয়ে আপনার হয়ে উঠছে! :-)

— লুইস মেন্ডো

নিশ্চিত! আমি স্ট্যাকওভারফ্লোতে প্রায়শই ঝুলতে পারি তবে সেখানে একই মনোভাব রয়েছে। আমি এটিকে সমর্থন করি!

— লুইস মেন্ডো

ভাল যুক্তি! আমি নিশ্চিত না যে আমি যা শিখছি এটি আমার আদর্শ মাতলাব ব্যবহারের জন্য সহায়ক বা আসলে ক্ষতিকারক হবে, যদিও :

— লুইস মেন্ডো

ওয়েল কোডগল্ফ ব্যবহার সম্পর্কে নয়, বরং কোনও ভাষার অপব্যবহার সম্পর্কে

— fla

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

যাও, 326

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)
    }
}

চালুনি তৈরির জন্য গোরোটিন এবং পাইপগুলি ব্যবহার করে সরাসরি এগিয়ে নেওয়া।

Comments

এই কোড গল্ফ, একটি বাইট গণনা যোগ করুন।

— edc65

Answer 18

ম্যাটল্যাব, characters২ টি অক্ষর

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)(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)))))

অবরুদ্ধ সংস্করণ:

(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)