সম্মিলিত নম্বর সিকোয়েন্সস

Question

সম্মিলিত নম্বর সিকোয়েন্সস

_{এই প্রশ্নের দ্বারা অনুপ্রাণিত}

একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হয়েছে , আপনার কোডটি অবশ্যই প্রথম এন যৌগিক সংখ্যাগুলি আউটপুট করবে ।

ইনপুট আউটপুট

আপনি একটি প্রোগ্রাম বা একটি ফাংশন লিখতে পারেন। ইনপুটটি STDIN বা ফাংশন আর্গুমেন্টের মাধ্যমে হয় এবং আউটপুট হয় STDOUT, বা ফাংশন রিটার্ন মান।

আউটপুট একটি তালিকা, অ্যারে বা স্ট্রিং হতে পারে।

উদাহরণ

 0 -> 
 1 -> 4
 2 -> 4, 6
 3 -> 4, 6, 8
13 -> 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22

---

বিধি

• সর্বদা হিসাবে স্ট্যান্ডার্ড লুফোলগুলি অনুমোদিত নয়।

• প্রাইম বা সম্মিলিত সংখ্যা উত্পন্ন করে অন্তর্নির্মিত অনুমোদিত নয়।

• প্রধান বা সংমিশ্রিত সংখ্যার সাথে সম্পর্কিত বিল্ট-ইনগুলি অনুমোদিত নয়।

Comments

অবশ্যই এটি OEIS এ রয়েছে: A002808

— নিনজাবিয়ারমোনকি

Answer 1

পাইথ - 10 বাইট

একটি বৈধ উত্তর। উইলসনের উপপাদ্য ব্যবহার করুন ।

.f%h.!tZZQ

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

পুরানো উত্তর

পাইথ - 6 টি অক্ষর

প্রাইম ফ্যাক্টরীকরণের জন্য বিল্টিন ব্যবহার করে , প্রাইম চেকিংয়ের জন্য নয়।

.ftPZQ

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

.f  Q         First n that passes filter of lambda Z, uses input for how many
 t            Tail. This makes all that have len-one prime factorization become empty list, and thus falsey.
  P           Prime factorization - primes have a len-one factorization.
   Z          Lambda var

Comments

এইচ, তার সম্পর্কে চিন্তাভাবনা করা উচিত: /

— ডাউনগোট

নিয়মগুলি পরিবর্তন হয়েছে এবং এই উত্তরটি আর কার্যকর হবে না।

— orlp

@orlp আপডেট উত্তর।

— মালটিসেন

@ মালটিসেন এই 10 বাইট না?

— kirbyfan64sos

@ kirbyfan64sos: / আমি দৃশ্যত দৈর্ঘ্যের কাউন্টারটি পড়তে পারি না। স্থাপন করা.

— মাল্টেসেন

Answer 2

পাইথ, 11 বাইট

<S{*M^tSQ2Q

[2, n] এবং কাটা সংকলনের সমস্ত সংমিশ্রনের পণ্যগুলির অত্যধিক বৃহত তালিকা তৈরি করে।

Comments

ইনপুটটি হয় 1বা এটি কাজ করে না 2।

— টুথব্রাশ

Answer 3

টেক্স, 382 বাইট

কারন তুমি পারো.

\newcount\a\newcount\b\newcount\c\newcount\n\newcount\p\newcount\q\let\v\advance\let\e\else\let\z\ifnum
\def\d#1:#2:#3:{\z#1>#2\v#1 by-#2\d#1:#2:#3:\e\z#1=#2#3=1\e#3=0\fi\fi}
\def\i#1:#2:#3:{#3=0\z#1>#2\a=#1\d\a:#2:\c:
\z\c=0\b=#2\v\b by 1\i#1:\the\b:#3:\e#1\par\fi\e#3=1\fi}
\def\l#1:#2:#3:#4:{\i\the#1:2:#4:
\z#4=0\v#2 by 1\fi\z#2<#3\v#1 by 1\l#1:#2:#3:#4:\fi}
\l\p:\n:10:\q:\end

শেষ পংক্তির নম্বরটি হল আপনার সম্মিলিত সংখ্যার সংখ্যা।

এটি একটি সাধারণ বিভাজক পরীক্ষক। বিভক্ত \dহলে চেক । কল সব সম্ভব মতে বিভক্ত তাদের জন্য (অর্থাত < )। প্রথম নম্বরগুলির জন্য তালিকাবদ্ধ করে যার জন্য 0 প্রদান করে।#2#1\i\d#1\l#2\i

অবহেলিত (ভাল, অর্ধ-গল্ফযুক্ত) সংস্করণ:

\newcount\a
\newcount\b
\newcount\c
\newcount\n
\newcount\p
\newcount\q

\def\div#1:#2:#3:{%
  \ifnum#1>#2 %
    \advance#1 by-#2 %
    \div#1:#2:#3:%
  \else%
    \ifnum#1=#2 %
      #3=1%
    \else%
      #3=0%
    \fi%
  \fi%
}

\long\def\isprime#1:#2:#3:{%
  #3=0%
  \ifnum#1>#2 %
    \a=#1 %
    \div\a:#2:\c: %
    \ifnum\c=0 %
      \b=#2 %
      \advance\b by 1 %
      \isprime#1:\the\b:#3:%
    \else
      #1\par%
    \fi%
  \else%
    #3=1%
  \fi%
}

\def\listprimes#1:#2:#3:#4:{%
  \isprime\the#1:2:#4: %
  \ifnum#4=0 %
    \advance#2 by 1 %
  \fi
  \ifnum#2<#3 %
    \advance#1 by 1 %
    \listprimes#1:#2:#3:#4: %
  \fi
}

\listprimes\p:\n:11:\q:

\end

Comments

প্রোগ্রামিং ধাঁধা এবং কোড গল্ফ স্বাগতম! একটি ভাষায় দুর্দান্ত প্রথম উত্তর চ্যালেঞ্জের জন্য উপযুক্ত বলে কেউ ভাবেনি। যদিও এটি বেশ দীর্ঘ, এটি টেক্সের মধ্যে স্বতন্ত্র এবং ঝরঝরে উত্তর এবং আমরা অবশ্যই এই জাতীয় উত্তরগুলির প্রশংসা করি।

— তানমাথ

@ ট্যানম্যাথ উষ্ণ অভ্যর্থনার জন্য ধন্যবাদ, আমি বুঝতে পেরেছি যে এটি প্রতিযোগিতা করতে অনেক দীর্ঘ, তবে এটি মজাদার ছিল :)

Answer 4

পাইথন, 57

lambda n:sorted({(k/n+2)*(k%n+2)for k in range(n*n)})[:n]

কম গল্ফড:

def f(n):
 R=range(n)
 return sorted({(a+2)*(b+2)for a in R for b in R})[:n]

ধারণা 0 এবং 1 এর ব্যতীত স্বাভাবিক সংখ্যার সবকিছুর যুগল গুন দ্বারা তারপর, যৌগিক সংখ্যার সেট উৎপন্ন এই সেট বাছাই, এবং প্রথম নিতে হয় nউপাদান। সেটটির কারটিশিয়ান পণ্যটি {2, 3, ..., n+2}নিজের সাথে নেওয়া যথেষ্ট , যা আমরা range(n)2-এ স্থানান্তরিত করে পেতে পারি ।

গল্ফ এই, আমরা দুই মান সংরক্ষণ একটি ক্লাসিক golfing কৌতুক করতে (a,b)মধ্যে range(n)একটি একক মান হিসাবে kমধ্যে range(n*n), এবং তাদের হিসাবে নিষ্কর্ষ a=k/n, b=k%n।

Answer 5

জাভা 8, 98 97 বাইট

i->{int a[]=new int[i],c=3,k=0,d;for(;k<i;c++)for(d=c;d-->2;)if(c%d<1){a[k++]=c;break;}return a;}

বয়লারপ্লেট সহ প্রসারিত:

public class C {
    public static void main(String[] args) {
        Function<Integer, int[]> f = i -> {
            int a[] = new int[i], c = 3;
            for (int k = 0; k < i; c++) {
                for (int d = c; d --> 2;) {
                    if (c % d < 1) {
                        a[k++] = c;
                        break;
                    }
                }
            }
            return a;
        };
        System.out.println(Arrays.toString(f.apply(5)));
    }
}

Answer 6

আর, 53 বাইট

n=scan();t=1:(n*n+3);t[factorial(t-1)%%t!=(t-1)][1:n]

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

এটি উইলসনের উপপাদ্যের উপরও ভিত্তি করে এবং এটির 1:n*nউপরোক্ত উল্লিখিত উপপাদ্য অনুসারে সংক্ষিপ্ত সংখ্যাগুলি বের করে আনা এবং তা করা সবই । আমি যোগ করেছি +3কারণ পূর্ণসংখ্যার n*nজন্য যথেষ্ট n < 3পরিমাণের পরিমাণ নেই

---

এই সমাধানটির সাথে একমাত্র সমস্যাটি হ'ল (দুঃখের সাথে) আর একটি বড় যথেষ্ট ফ্যাক্টরিয়ালটির জন্য নির্ভুলতা হারিয়ে ফেলেছে, এইভাবে এটি সঠিকভাবে কাজ করবে না n > 19

Answer 7

সিজেম, 20 18 বাইট

li_5*{_,2>f%0&},<`

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

প্রাইম বা ফ্যাক্টরাইজেশন অপারেটরগুলিতে কোনও বিল্ট ব্যবহার করে না। সংখ্যাগুলি সংমিশ্রিত হওয়ার জন্য মোটামুটি নিষ্ঠুর বলের চেক।

এখানে একটি পর্যবেক্ষণ ব্যবহৃত হয় তা হ'ল আমরা পরীক্ষা করতে হয় এমন সংখ্যার জন্য আমরা সহজেই একটি নিরাপদ উপরের সীমানা গণনা করতে পারি। যেহেতু 4 এর চেয়ে বড় প্রতিটি দ্বিতীয় সংখ্যাটি যৌগিক, 4 + n * 2এটি n-th সংমিশ্রণ সংখ্যার জন্য একটি উপরের আবদ্ধ।

@ ডেনিসের একটি পরামর্শের ভিত্তিতে, সর্বশেষতম বাস্তবায়ন আসলে n * 5উপরের সীমা হিসাবে ব্যবহার করে যা অনেক কম দক্ষ, তবে 2 বাইট সংক্ষিপ্ত।

ব্যাখ্যা:

li    Get and convert input.
_     Copy, will need the value to trim the list at the end.
5*    Calculate upper bound.
{     Start of filter.
  _     Copy value.
  ,     Create list [0 .. value-1].
  2>    Slice off the first two, leaving candidate factors [2 .. value-1].
  f%    Apply modulo with all candidate factors to value.
  0&    Check if one of the modulo results is 0.
},    End of filter.
<     Trim output to n values.
`     Convert list to string.

Answer 8

জাভাস্ক্রিপ্ট ES6, 88 টি অক্ষর

n=>{r=[];for(q=2;r.length!=n;++q)if(/^(..+)\1+$/.test("-".repeat(q)))r.push(q);return r}

Comments

আমি বিশ্বাস করি ভেরিয়েবল অ্যাসাইনমেন্টটি সরানো f=আইনী।

— ড্যাঙ্কমেস

@ ডানকিমেস, হ্যাঁ মনে হচ্ছে। meta.codegolf.stackexchange.com/q/6915/32091

— Qwertiy

এটি 83:n=>eval('for(r=[],q=2;r.length-n;/^(..+)\\1+$/.test("-".repeat(++q))&&r.push(q))r')

— ড্যাঙ্কমেস

@ ডানকিমেস, দুর্দান্ত :)

— কিওয়ারটি

@ কিওয়ার্টি দুঃখিত, আমার অর্থ n&&!r[n-1]: '| এটি হিসাবে একই দৈর্ঘ্যr.length<n - একটি চরিত্রের চেয়ে ছোট r.length!=n- তবে এটি কোড গল্ফ বলে মনে হচ্ছে, তাই না? : -]

— টুথব্রাশ

Answer 9

হাস্কেল, 49 46 বাইট

(`take`[x|x<-[4..],or[mod x y<1|y<-[2..x-1]]])

ব্যবহারের উদাহরণ:

*Main> (`take`[x|x<-[4..],or[mod x y<1|y<-[2..x-1]]]) 13
[4,6,8,9,10,12,14,15,16,18,20,21,22]

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

  [x|x<-[4..]    ]           -- keep all x from the integers starting with 4 where
      ,or                    -- where at least one element of the following list is "True"
    [mod x y<1|y<-[2..x-1]]  -- "x mod y < 1" for all y from [2,3,...x-1]
(`take`[   ])                -- take the first n elements from the xes
                             -- where n is the parameter supplied when calling the function

Answer 10

এফ #, 78 বাইট

fun n->(Array.filter(fun i->Seq.exists((%)i>>(=)0)[2..i-1])[|2..n*n|]).[..n-1]

ব্যাখ্যা:

fun n->                                                                      
                                                           [|2..n*n|]          // Generate an array of integers from 2 to n * n
        Array.filter(fun i->                              )                    // Filter it using the following function on each element
                                                  [2..i-1]                        // Generate a list of possible divisors (from 2 to i-1)
                            Seq.exists(          )                                // Check if at least one of the divisors is valid, that is
                                       (%)i>>(=)0                                    // That i % it is equal to 0. This is equivalent to (fun d -> i % d = 0)
       (                                                             ).[..n-1] // Take the n first elements of the resulting, filtered array

Comments

এটি দুর্দান্ত উত্তর, তবে আপনি ভেরিয়েবলটি iদুবার ব্যবহার করেছেন তা কিছুটা বিভ্রান্তিকর । আমি এফ # এর সাথে খুব বেশি পরিচিত নই, তবে আপনি কি ব্যবহার করতে পারবেন না j?

— wizzwizz4

ঠিক আছে, এটি পরিষ্কার করে তোলে। ছায়াময় হওয়ার কারণে এটি কাজ করেছিল তবে আমি অনুমান করি যে জিনিসটি গল্ফ করার সময় আমি পঠনযোগ্যতাটি ভুলে গিয়েছিলাম। ^ _ ^ '

— রাউজো

আমি কখনও এই ধরণের ভুল করি না । সম্ভবত আমি কেন গল্ফ করতে ভাল নই D: -D

— wizzwizz4

Answer 11

সি ++ 109

int main(){int n,i,x=4;cin>>n;while(n){for(i=2;i<x-1;i++){if(x%i==0){cout<<x<<' ';n--;break;}}x++;}return 0;}

Ungolfed

int main(){
int n,i,x=4;cin>>n;
while(n)
{
for(i=2;i<x-1;i++)
{
if(x%i==0){cout<<x<<' ';n--;break;}
}
x++;
}
return 0;
}

Comments

১. নিরবচ্ছিন্ন সংস্করণটির জন্য কেন একটি দুর্দান্ত বিন্যাস তৈরি করবেন না? 2. মনে হচ্ছে আপনার উভয় কোডেই অতিরিক্ত ব্রেস রয়েছে। 3. আপনি whileদ্বারা প্রতিস্থাপন করতে পারেন for।

— কিওয়ারটি

Answer 12

জুলিয়া, 103 বাইট

n->(n>0&&println(4);n>1&&(i=0;c=big(6);while i<n-1 mod(factorial(c-1),c)<1&&(i+=1;println(c));c+=1end))

এটি উইলসনের উপপাদ্যটি ব্যবহার করে।

Ungolfed:

function f(n::Int)
    # Always start with 4
    n > 0 && println(4)

    # Loop until we encounter n composites
    if n > 1
        i = 0
        c = big(6)
        while i < n-1
            if mod(factorial(c-1), c) == 0
                i += 1
                println(c)
            end
            c += 1
        end
    end
end

Answer 13

ইসমাস্ক্রিপ্ট 6 - 107 91 84 বাইট

n=>eval('for(a=[],x=4;n&&!a[~-n];x++)for(y=2;y*2<=x;)if(x%y++<1){a.push(x);break}a')

ফাংশনটি প্রথম nযৌগিক সংখ্যার একটি অ্যারে প্রদান করে ।

~-nলেখার অভিনব উপায় n-1; একই দৈর্ঘ্য, কিন্তু আরও মজা, তাই না?
আমি ব্যবহার করার একমাত্র কারণ evalহ'ল টেমপ্লেটটি n=>eval('...returnValue')1 টির চেয়ে কম অক্ষর n=>{...return returnValue}।

পুরানো সংস্করণ

n=>eval('for(a=[],x=4;n&&!a[~-n];x++){for(z=0,y=2;y*2<=x;)if(x%y++<1)z=1;if(z)a.push(x)}a')

---

n=>eval('for(a=[],i=4;a.length<n;i++)if((x=>{for(y=2,z=1;y*2<=x;)if(x%y++<1)z=0;return!z})(i))a.push(i);a')

আউটপুট

 0 -> []
 1 -> [4]
 2 -> [4, 6]
 3 -> [4, 6, 8]
13 -> [4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22]

Answer 14

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

নিমির পূর্বের উত্তরের দ্বারা ভারীভাবে অনুপ্রাণিত হয়ে , anyনেস্টেড তালিকা বোঝার পরিবর্তে পয়েন্টফ্রি ল্যাম্বডায় ভিত্তি করে 2-বাইট শর্টারের সাথে শিকারীকে প্রতিস্থাপন করুন ।

(`take`[x|x<-[4..],any((<)1.gcd x)[2..x-1]])

এটি অনলাইন চেষ্টা করুন!
( লাইকোনিকে ধন্যবাদ সঠিক টিআইও লিঙ্কের জন্য )

ব্যাখ্যা:

[x|x<-[4..],       -- consider all integers x >=4
[2..x-1]           -- consider all integers smaller than x
any((<)1.gcd x)    -- if for any of them 
    (<)1           -- 1 is smaller than
        .gcd x     -- the gcd of x and the lambda input
                   -- then we found a non-trivial factor and thus the number is composite
(`take`[  ])       -- take the first <argument> entries