Chuỗi số tổng hợp

_{Lấy cảm hứng từ điều này câu hỏi}

Cho một số nguyên dương n , mã của bạn phải xuất ra n đầu tiên số hỗn hợp .

Đầu ra đầu vào

Bạn có thể viết một chương trình hoặc một chức năng. Đầu vào là thông qua STDIN hoặc đối số chức năng và đầu ra là STDOUT hoặc giá trị trả về của hàm.

Đầu ra có thể là một Danh sách, Mảng hoặc Chuỗi.

Ví dụ

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

Quy tắc

• Như mọi sơ hở tiêu chuẩn không được phép.

• Không được phép tích hợp tạo số nguyên tố hoặc tổng hợp.

• Không được phép tích hợp liên quan đến số nguyên tố hoặc tổng hợp.

Pyth - 10 byte

Một câu trả lời hợp lệ. Sử dụng Định lý Wilson .

.f%h.!tZZQ

Hãy thử trực tuyến tại đây .

Câu trả lời cũ

Bình - 6 ký tự

Sử dụng dựng sẵn cho thừa số nguyên tố , không kiểm tra nguyên tố.

.ftPZQ

Hãy thử trực tuyến tại đây .

.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

Bình thường, 11 byte

<S{*M^tSQ2Q

Tạo danh sách quá lớn các sản phẩm của tất cả các kết hợp [2, n] và cắt ngắn.

TeX, 382 byte

Bởi vì bạn có thể.

\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

Số ở dòng cuối cùng là số lượng tổng hợp bạn muốn có.

Đây là một thử nghiệm chia đơn giản. \dkiểm tra nếu#2 chia #1. \igọi \dcho tất cả các bộ chia có thể (tức là < #1). \lliệt kê các #2số đầu tiên \itrả về 0.

Phiên bản Ungolfed (tốt, nửa golf):

\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

Con trăn, 57

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

Ít chơi gôn hơn:

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

Ý tưởng là tạo ra tập hợp các số tổng hợp bằng cách nhân tất cả các cặp số tự nhiên trừ 0 và 1. Sau đó, sắp xếp tập hợp này và lấy các nphần tử đầu tiên . Nó đủ để lấy sản phẩm của Cartesian {2, 3, ..., n+2}với bộ mà chúng ta có thể nhận được bằng cách range(n)tăng lên 2.

Để golf này, chúng tôi làm một thủ thuật chơi golf kinh điển lưu trữ hai giá trị (a,b)trong range(n)như một giá trị duy nhất ktrong range(n*n), và trích xuất chúng như a=k/n, b=k%n.

Java 8, 98 97 byte

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

Mở rộng, với nồi hơi:

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 byte

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

Làm thế nào nó hoạt động

Điều này cũng dựa trên định lý của Wilson và tất cả những gì nó làm là chạy trên một phạm vi 1:n*nvà trích xuất các số tổng hợp theo định lý đã đề cập ở trên. Tôi đã thêm+3 vì n*nkhông đủ phạm vi cho n < 3số nguyên

Vấn đề duy nhất với giải pháp này là (thật đáng buồn) R mất độ chính xác cho một nhân tố đủ lớn, do đó, điều này sẽ không hoạt động đúng cho n > 19

CJam, 20 18 byte

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

Dùng thử trực tuyến

Không sử dụng bất kỳ toán tử nguyên tố hoặc nhân tố được xây dựng. Kiểm tra lực lượng khá mạnh mẽ cho các số được tổng hợp.

Một quan sát được sử dụng ở đây là chúng ta có thể dễ dàng tính được giới hạn trên an toàn cho các số chúng ta phải kiểm tra. Vì mỗi số thứ hai lớn hơn 4 là hợp số,4 + n * 2 là giới hạn trên của số tổng hợp thứ n.

Dựa trên đề xuất của @Dennis, triển khai mới nhất thực sự sử dụng n * 5 làm giới hạn trên, kém hiệu quả hơn nhiều, nhưng ngắn hơn 2 byte.

Giải trình:

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 ký tự

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

Haskell, 49 46 byte

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

Ví dụ sử dụng:

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

Làm thế nào nó hoạt động

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

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

Giải thích:

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

Ung dung

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 byte

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

Điều này sử dụng Định lý Wilson.

Ung dung:

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

Bản thảo 6 - 107 91 84 byte

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

Hàm trả về một mảng các nsố tổng hợp đầu tiên .

~-nlà một cách viết lạ mắt n-1; Cùng chiều dài, nhưng vui hơn nhiều, phải không?
Lý do duy nhất tôi sử dụngeval là mẫu n=>eval('...returnValue')ngắn hơn 1 ký tựn=>{...return returnValue} .

phiên bản cũ

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

Đầu ra

 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 byte

Lấy cảm hứng mạnh mẽ từ câu trả lời trước đó của Nimi , thay thế vị ngữ bằng một byte ngắn hơn 2 byte dựa trên anylambda không có điểm thay vì hiểu danh sách lồng nhau.

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

Hãy thử trực tuyến!
( cảm ơn Laikoni cho liên kết TIO chính xác)

Giải trình:

[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