ক্রমটি খুব মেটা

Question

আমরা ফাঁকা 1-সূচকযুক্ত ক্রম দিয়ে শুরু করি:

_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,...

N ^তম ধাপে, আমরা প্রতিটি অবশিষ্ট (n) শূন্যস্থান পূরণ করব প্রথম বাকী ফাঁকা থেকে শুরু করে 1 এরও বেশি পূর্ণসংখ্যার সাথে, যেখানে a (n) হল অনুক্রমের n ^তম প্রবেশ।

প্রথম পদক্ষেপের পরে:

2,_,3,_,4,_,5,_,6,_,7,_,8,_,9,_,10,_,11,_,12,_,13,_,...

মনে রাখবেন যে (1) 2 হতে হবে কারণ 1 এর চেয়ে বড় পূর্ণসংখ্যা 2 হয়।

দ্বিতীয় ধাপে, আমরা প্রতিটি (2) শূন্যস্থান পূরণ করি। এটি স্পষ্ট হবে যে ক (2) হতে হবে 2।

2,2,3,_,4,3,5,_,6,4,7,_,8,5,9,_,10,6,11,_,12,7,13,_,...

তৃতীয় ধাপে, আমরা প্রতিটি (3) ফাঁকা পূরণ করি fill ক্রম থেকে, একটি (3) = 3।

2,2,3,2,4,3,5,_,6,4,7,_,8,5,9,3,10,6,11,_,12,7,13,_,...

চতুর্থ ধাপে, আমরা প্রতিটি (4) শূন্যস্থান পূরণ করি। ক্রম থেকে, একটি (4) = 2।

2,2,3,2,4,3,5,2,6,4,7,_,8,5,9,3,10,6,11,3,12,7,13,_,...

অবশেষে:

2,2,3,2,4,3,5,2,6,4,7,2,8,5,9,3,10,6,11,3,12,7,13,2,...

কার্য

প্রদত্ত এন, অনুক্রমের n ^তম উপাদানটি ফিরিয়ে দিন ।

সিকোয়েন্সের প্রথম 10,000,000 পদগুলি এখানে পাওয়া যাবে ।

এটি কোড-গল্ফ । বাইট জিতে সংক্ষিপ্ত উত্তর। স্ট্যান্ডার্ড লুফোলস প্রযোজ্য।

Comments

@ লুইস মেন্ডো ধন্যবাদ, আমি এটি যুক্ত করেছি।

— ফাঁস নুন

শুধু কৌতূহলী, ক্রম থেকে বাদ পড়ার জন্য মিঃ এককটি কী ভুল করেছে?

— ডেড পসসাম

@ ডেডপসসাম ভাল, আপনি যদি প্রতিটি শূন্যস্থান পূরণ করেন তবে আপনি এক ধাপে সম্পন্ন করেছেন।

— ফাঁস নুন

@ ডেডপসাম যদি একটি (এন) হয় তবে এন-তম পদক্ষেপটি প্রজন্মের অবসান ঘটিয়ে প্রতিটি অবশিষ্ট শূন্যস্থান পূরণ করবে।

— ফাঁস নুন

@ কিউব্রুট প্রথম প্রশ্নের সাথে লিঙ্কযুক্ত প্রথম 10,000,000 এর একটি তালিকা সরবরাহ করেছে; শুধু তাদের চক্রান্ত।

— লিকি নুন

Answer 1

হাস্কেল , 80 67 বাইট

g~(a:b)|let k!l=k:take(a-1)l++(k+1)!drop(a-1)l=2!g b
m=g m
(!!)$0:m

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

নিজের বিবেচনায় অসীম তালিকার সংজ্ঞা দেওয়ার জন্য হাস্কেল হ'ল নির্ভুল ভাষা।

Comments

টিআইও লিঙ্কটি প্রত্যাশার মতো কাজ করে, আমার ধারণা স্থির থাকা উচিত আমার প্রশ্ন: আপনি কীভাবে এটি কাজ করে তার একটি ব্যাখ্যা যোগ করতে পারেন?

— জুলিয়ান ওল্ফ

@ জুলিয়ানওল্ফ এটি মনে হচ্ছে আপনি letপ্যাটার্ন গার্ডগুলির সাথে অপরিচিত । pattern1 | let pattern2 = expr2 = expr1এর অর্থ একই জিনিস pattern1 = let pattern2 = expr2 in expr1(একই কারণে যার [expr1 | let pattern2 = expr2]অর্থ একই জিনিস [let pattern2 = expr2 in expr1])।

— অ্যান্ডারস কাসরগ

আমি letপ্যাটার্ন গার্ডদের মনে রাখতে পারি (বিশেষত তারা ফাংশনগুলি করতে পারে)! এছাড়াও, m=2:2:2`drop`g mএকটি বাইট সংক্ষিপ্ত।

— janর্জন জোহানসেন

(!!)$0:mদুটি বাইট সংক্ষিপ্ত।

— janrjan জোহানসেন

আসলে, আপনি 2:2:কিছুটা বেশি অলসতার সাথে জিনিসগুলি পুরোপুরি ফেলে দিতে পারেন: g ~(a:b)|...এবং m=g m।

— janrjan জোহানসেন

Answer 2

সি, 123 বাইট

f(n){int*p=calloc(n,4),i=0,j,k;for(*p=p[1]=2;i<n;++i)for(j=0,k=i/2?0:2-i;j<n;++j)p[j]||k++%p[i]||(p[j]=k/p[i]+2);n=p[n-1];}

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

walkthrough

f(n){int*p=calloc(n,4),

অনুক্রমের প্রথম এন উপাদানগুলি সংরক্ষণ করার জন্য এন পূর্ণসংখ্যার একটি অ্যারে বরাদ্দ করুন । এই হার্ডকোডগুলি হিসাবে , যা বেশিরভাগ ক্ষেত্রেই নিরাপদ অনুমান এবং অবশ্যই আমি কোড গল্ফের প্রসঙ্গে তৈরি করতে চাই। :)sizeof(int)4

i=0,j,k;

এগুলি সমস্ত কাউন্টার রয়েছে: iআমরা যে পদক্ষেপটি নিয়েছি তার সূচীর jজন্য, খালি স্থানগুলির সন্ধানের ক্রমটি লুপ করা, এবং kকতগুলি ফাঁকা স্থান দেখা গেছে তা গণনা করা।

for(*p=p[1]=2;i<n;++i)

আমরা আমাদের মূল লুপটি শুরু করার আগে, আমরা সিকোয়েন্সের প্রথম দুটি উপাদানগুলির একটি সূচনাতে গোপন করি 2। ( p[0]= *(p + 0)= *p।) এটি গণনা বন্ধ করে দেয় kযদিও, তবে ...

for(j=0,k=i/2?0:2-i;j<n;++j)

... আমরা এর একটি গোড়ালির সূচনাও করি k, যা iকিনা কম কিনা তা পরীক্ষা করে এবং যদি হয় তবে এর 2মানটির সংশোধন করে k। অভ্যন্তরীণ লুপটি এখানেও শুরু হয় যা প্রতিটি ধাপের সময়কালে পুরো ক্রমটি পুনরাবৃত্তি করে।

p[j]||k++%p[i]||(p[j]=k/p[i]+2);

এই লাইনটি সত্যই কিছু ব্যাখ্যা ব্যবহার করতে পারে। আমরা এটিকে প্রসারিত করতে পারি:

if (!(p[j] || ((k++) % p[i]))) {
    p[j] = k / p[i] + 2;
}

সংক্ষিপ্ত প্রচারের মাধ্যমে, এবং তারপরে ডি মরগানের আইন এবং 0সি-তে মিথ্যাবাদী সত্য দ্বারা :

if (p[j] == 0 && ((k++) % p[i]) == 0) {
    p[j] = k / p[i] + 2;
}

এটি মূলত উল্লেখ করে: "যদি এই স্থানটি ফাঁকা থাকে, বৃদ্ধি হয় k। এবং যদি kআগে পদক্ষেপের আকারের একাধিক হত তবে নিম্নলিখিত বিবৃতিটি চালান।" সুতরাং, আমরা প্রতিটি ধাপ আকারের উপাদানগুলির উপর বিবৃতিটি চালিত করি , যা ক্রমটি বর্ণিত হয় ঠিক কীভাবে। বিবৃতি নিজেই সহজ; নেই সব উৎপন্ন হয় 2, 3, 4, ....

n=p[n-1];}

মুশকিল-রিটার্ন-ছাড়াই-এ-রিটার্ন ব্যবহার করে যা কাজ করে gcc, আমরা ধারাবাহিকতায় প্রথম এন পদগুলির শেষ উপাদানটিকে "রিটার্ন" করি , যা n তম শব্দ হিসাবে ঘটে ।

Answer 3

পাইথ, 29 বাইট

M?tH?eJ.DtHg1GghG-tHhJ+2hJ2g1

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

কিভাবে এটা কাজ করে

তালিকাগুলি দিয়ে চারপাশে বোকা বানানোর পরিবর্তে এটি একটি সাধারণ পুনরাবৃত্তির সূত্র ব্যবহার করে।

M                                def g(G, H):
 ?tH                                 if H - 1:
      J.DtHg1G                           J = divmod(H - 1, g(1, G))
    ?e                                   if J[-1]:
              ghG-tHhJ                       return g(G + 1, H - 1 - J[0])
                                         else:
                      +2hJ                   return 2 + J[0]
                                     else:
                          2              return 2
                           g1Q   print(g(1, eval(input())))

Answer 4

হাস্কেল , 67 বাইট

0%j=2
i%j|d<-div i$f j=last$d+2:[(i-d-1)%(j+1)|d*f j<i]
f=(%1).pred

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

একটি পুনরাবৃত্ত গণিত সমাধান যা মূলত অ্যান্ডারস ক্যাসেরগের পাইথ উত্তর হিসাবে একই পদ্ধতিতে পরিণত হয়েছিল ।

এই কোডটি ওয়ার্টগুলিতে আচ্ছাদিত - কুৎসিত অংশগুলি দেখে মনে হচ্ছে তারা এলোমেলো হতে পারে, তবে কীভাবে তা দেখলাম না।

ফাংশনটি i%jসত্যই কোনও mod i(f j)>0প্রাসঙ্গিকটিকে দুটি অনুরূপ অভিব্যক্তির মধ্যে একটির মূল্যায়ন কিনা তা যাচাই বাছাই করতে চায় । তবে, উভয় এক্সপ্রেশন ব্যবহার করে div i(f j)। গার্ডের সাথে বাঁধাই এটি উভয় পক্ষেই প্রযোজ্য হবে না। আমি যতদূর জানি, গার্ডকে অন্য রক্ষীদের উপর "বিতরণ" করা যায় না। letএবং whereখুব দীর্ঘ। সুতরাং, lastগার্ডটি ভেরিয়েবলটিকে আবদ্ধ করার সময় কোডটি দুটি এক্সপ্রেশনগুলির মধ্যে একটি বাছাই করতে ব্যবহার করে। বিতৃষ্ণা।

আদর্শভাবে আমরা ব্যবহার করব divModকারণ উভয়ই ব্যবহৃত হয় divএবং modব্যবহৃত হয় তবে (d,m)<-divMod ...এটি দীর্ঘ প্রকাশ expression পরিবর্তে আমরা পরিবর্তিতভাবে মোডের চেক হ'ল নঞ্জেরো হ'ল মূল্য সময়টি divমূল মানের থেকে বিভাজকটি কম হয় কিনা তা দেখে ।

0%j=2যদি Haskell, স্বল্প circuited ক্ষেত্রে প্রয়োজন হবে না div 0, যা এটি না। .predধর্মান্তরিত করার 1-সূচীবদ্ধ ইনপুট শূন্য ইন্ডেক্স, বা অন্য সেখানে হবে -1সংশোধন সর্বত্র।

Comments

আপনি যদি %1-সূচকযুক্ত হন, তবে আপনার পাঁচ বাইট সংশোধন প্রয়োজন - যা কেবল সংযুক্ত। তবে , তাহলে আপনি ইনলাইন করতে fমধ্যে %কোন খরচ, এবং তারপর fবেনামী হয়ে যাতে আপনি দুই বাইট সামগ্রিক সংরক্ষণ করুন।

— janর্জন জোহানসেন

@ JanrjanJohansen এখানে ইনলাইন দ্বারা আপনি কী বোঝাতে চাইছেন? fবাইট না হারাতে কীভাবে রেফারেন্সগুলি পরিবর্তন করতে হয় তা আমি দেখতে পাচ্ছি না ।

— xnor

divModমনে হয় এটি একটি বাইট সস্তা সস্তা, কারণ এটি শাখা প্রশস্ত করতে দেয় !!(0^m)। এখন পর্যন্ত আমি পেয়েছি:1%j=2;i%j|(d,m)<-divMod(i-1)$j%1=[(i-d-1)%(j+1),d+2]!!(0^m);(%1)

— janrjan জোহানসেন

যেমন আপনি দেখতে পাচ্ছেন, অন্তর্নিহিত 1-reindexing, যা মুছে ফেলা অনুমান করে .pred।

— janrjan জোহানসেন

Answer 5

জাভাস্ক্রিপ্ট (ES6), 98 93 91 বাইট

একটি পুনরাবৃত্তি ফাংশন যা ফলাফল পাওয়া মাত্রই বন্ধ হয়ে যায়।

f=(n,p,a=[...Array(n)])=>a[n-1]||f(n,-~p,a.map(c=>c?c:i?i++%(a[p]||2)?c:++v:(i=1,v=2),i=0))

বিকল্প সংস্করণ, 90 বাইট

শেগি দ্বারা -1 বাইট জন্য প্রস্তাবিত

এই এক সঙ্গে কল করা উচিত f(n)()। যদিও মেটাতে সম্পর্কিত পোস্ট বর্তমানে একটি ইতিবাচক স্কোর দেয়, এই বাক্য গঠনটি আপাতদৃষ্টিতে বিতর্কিত।

n=>g=(p,a=[...Array(n)])=>a[n-1]||g(-~p,a.map(c=>c?c:i?i++%(a[p]||2)?c:++v:(i=1,v=2),i=0))

ডেমো

f=(n,p,a=[...Array(n)])=>a[n-1]||f(n,-~p,a.map(c=>c?c:i?i++%(a[p]||2)?c:++v:(i=1,v=2),i=0))

for(n = 1; n <= 50; n++) {
  console.log('a[' + n + '] = ' + f(n));
}

Comments

n=>g=(p,a=[...Array(n)])=>a[n-1]||g(-~p,a.map(c=>c?c:i?i++%k?c:++v:(i=1,v=2),i=0,k=a[p]||2))92 বাইট জন্য কাজ করা উচিত। সাথে কল করুন f(n)()।

— শেগি

@ শেগি ধন্যবাদ! বিকল্প সংস্করণ হিসাবে যুক্ত করা হয়েছে।

— আর্নল্ড

Answer 6

জাভা 8, 124 বাইট

(i)->{int j=1,a[]=new int[i+1],k,s,n;for(;a[i]<2;){for(k=0,n=2;a[++k]>0;);for(s=a[j++]|2*k;k<=i;k+=s)a[k]=n++;}return a[i];}

লাম্বদা অভিব্যক্তি।

একটি পূর্ণসংখ্যার অ্যারে তৈরি করে এবং অবিচ্ছিন্নভাবে এটিকে পপুলেশন করা অবধি অবধি নবম মানটি পপুলেশন হয়।

শীর্ষে প্রি-ডিক্লেয়ারিং ভেরিয়েবলগুলি যতটা সম্ভব ঘোষণাকে কাটতে যতটা সম্ভব প্রতি হিসাবে int4 বাইট স্পেস যুক্ত করার বিপরীতে ,n2 ব্যয় হয়।

উপর j'হিসাব তম পুনরাবৃত্তির, সংখ্যা' ঐ খালি 'এক এড়িয়ে যেতে হয়েছে সমান a[j](বা 2, যদি ফাঁকা)। এটা কাজ করে যদি প্রথম ফাঁকা স্থান আমরা পূরণ করতে হবে অবস্থানে রয়েছে k, k * a[j]আমাদের 'পদক্ষেপ' দেয় ( s)।