ลำดับหมายเลขคอมโพสิต

_{แรงบันดาลใจจากคำถามนี้}

รับจำนวนเต็มบวกnรหัสของคุณจะต้องส่งออกจำนวน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

กฎระเบียบ

• เช่นเดียวกับช่องโหว่มาตรฐานจะไม่ได้รับอนุญาต

• บิวด์อินที่สร้างหมายเลขเฉพาะหรือคอมโพสิตไม่ได้รับอนุญาต

• ไม่อนุญาตให้ใช้ตัวบิวด์ที่เกี่ยวข้องกับหมายเลขเฉพาะหรือคอมโพสิต

Pyth - 10 ไบต์

คำตอบที่ถูกต้อง ใช้ทฤษฏีของวิลสัน

.f%h.!tZZQ

ลองมันออนไลน์ได้ที่นี่

คำตอบเก่า

Pyth - 6 ตัวอักษร

ใช้ builtin สำหรับการแยกตัวประกอบเฉพาะไม่ใช่การตรวจจับเฉพาะ

.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

Pyth, 11 ไบต์

<S{*M^tSQ2Q

สร้างรายการผลิตภัณฑ์ที่มีขนาดใหญ่เกินไปของชุดค่าผสมทั้งหมดของ [2, n] และตัดปลาย

TeX, 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การตรวจสอบถ้าแบ่ง#2 เรียกร้อง ให้หารที่เป็นไปได้ทั้งหมด (เช่น < ) แสดงรายการตัวเลขแรกที่ส่งกลับ 0#1\i\d#1\l#2\i

เวอร์ชัน Ungolfed (ดี, กอล์ฟครึ่งลูก):

\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

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

การกอล์ฟนี้เราทำเคล็ดลับการเล่นกอล์ฟคลาสสิกของการจัดเก็บค่าทั้งสอง(a,b)ในrange(n)ฐานะที่เป็นค่าเดียวkในและแยกพวกเขาเป็นrange(n*n)a=k/n, b=k%n

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

R, 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จำนวนเต็ม

ปัญหาเดียวของวิธีนี้คือ (เศร้า) R สูญเสียความแม่นยำสำหรับแฟคทอเรียลใหญ่พอดังนั้นสิ่งนี้จะไม่ทำงานอย่างถูกต้องสำหรับ n > 19

CJam, 20 18 ไบต์

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

ลองออนไลน์

ห้ามใช้ตัวดำเนินการเฉพาะหรือบิวด์อินที่สร้างขึ้น การตรวจสอบกำลังแบบเดรัจฉานอย่างยุติธรรมสำหรับตัวเลขที่ประกอบกัน

การสังเกตหนึ่งที่ใช้ที่นี่คือเราสามารถคำนวณขอบเขตบนที่ปลอดภัยสำหรับตัวเลขที่เราต้องทดสอบได้อย่างง่ายดาย เนื่องจากทุก ๆ วินาทีที่มีค่ามากกว่า 4 คือคอมโพสิต4 + n * 2จึงเป็นขอบเขตสูงสุดสำหรับหมายเลขคอมโพสิต n-th

ตามข้อเสนอแนะโดย @Dennis การใช้งานล่าสุดจริง ๆ แล้วใช้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.

Javascript ES6, 88 ตัวอักษร

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

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

F #, 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

C ++ 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;
}

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

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

Haskell , 44 ไบต์

แรงบันดาลใจอย่างหนักจากคำตอบก่อนหน้าของ Nimiแทนที่ภาคแสดงด้วยคำที่สั้นกว่า 2 ไบต์โดยanyใช้แลมบ์ฟรีที่ไม่มีจุดแทนการเข้าใจรายการแบบซ้อน

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

ลองออนไลน์!
( ขอบคุณ Laikoniสำหรับลิงก์ TIO ที่ถูกต้อง)

คำอธิบาย:

[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