Kompozit Sayı Dizileri

_{Bu sorudan ilham alındı}

Pozitif bir n tamsayısı verildiğinde , kodunuz ilk n bileşik sayıyı çıkarmalıdır.

Giriş çıkış

Bir program veya işlev yazabilirsiniz. Girdi STDIN veya işlev bağımsız değişkeni üzerinden yapılır ve çıktı STDOUT veya işlev döndürme değerindedir.

Çıktı bir Liste, Dizi veya Dize olabilir.

Örnekler

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

kurallar

• Her zaman olduğu gibi standart boşluklara izin verilmez.

• Asal veya bileşik sayılar üreten yerleşik yapılara izin verilmez.

• Asal veya bileşik numaralarla ilgili yerleşik yapılara izin verilmez.

Pyth - 10 bayt

Geçerli bir cevap. Wilson Teoremini kullanır .

.f%h.!tZZQ

Burada çevrimiçi deneyin .

Eski cevap

Pyth - 6 karakter

Primer çarpanlara ayırma için değil, birincil çarpanlara ayırma için yerleşik kullanır .

.ftPZQ

Burada çevrimiçi deneyin .

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

<S{*M^tSQ2Q

[2, n] ve kesiklerin tüm kombinasyonlarının aşırı geniş bir ürün listesini oluşturur.

TeX, 382 bayt

Çünkü yapabilirsin.

\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

Son satırdaki sayı, sahip olmak istediğiniz bileşik sayıların sayısıdır.

Bu basit bir bölen test cihazıdır. \dbölünüp #2bölünmediğini denetler #1. tüm olası bölücüler için \içağrı \dyapar (yani < #1). 0 değerini döndüren \lilk #2sayıları listeler \i.

Ungolfed (iyi, yarı golf) versiyon:

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

Daha az golf:

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

Fikir, 0 ve 1 dışındaki tüm doğal sayı çiftlerini çarparak bileşik sayılar kümesi oluşturmaktır. Sonra bu seti sıralayın ve ilk nelemanları alın. Setin Kartezyen ürününü {2, 3, ..., n+2}kendisiyle birlikte almak yeterlidir , ki bu da range(n)2 kata kadar yükselebilir.

Golf için bu, iki değerlerini saklama klasik golf hile yapmak (a,b)içinde range(n)tek bir değer olarak kyer range(n*n)ve bunları ayıklamak a=k/n, b=k%n.

Java 8, 98 97 bayt

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

Boyler plakası ile genişletilmiş:

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 bayt

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

Nasıl çalışır

Bu aynı zamanda Wilson teoremine dayanmaktadır ve tek yaptığı 1:n*nyukarıda belirtilen teoreme göre kompozit sayıları çalıştırmak ve çıkarmaktır. Ekledim +3çünkü tamsayılar n*niçin yeterince büyük bir aralık değiln < 3

Bu çözümle ilgili tek sorun, (ne yazık ki) R'nin yeterince büyük bir faktöriyör için hassasiyeti kaybetmesidir, bu nedenle bu, n > 19

CJam, 20 18 bayt

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

Çevrimiçi deneyin

Yerleşik asal veya çarpanlara ayırma işleçlerini kullanmaz. Kompozit olan sayılar için oldukça kaba kuvvet kontrolü.

Burada kullanılan bir gözlem, test etmemiz gereken sayılar için güvenli bir üst sınırı kolayca hesaplayabilmemizdir. 4'ten büyük her ikinci sayı bileşik olduğundan 4 + n * 2, n'inci bileşik sayı için bir üst sınırdır.

@Dennis'in bir önerisine dayanarak, en son uygulama aslında n * 5üst sınır olarak kullanılır, bu da çok daha az verimlidir, ancak 2 bayt daha kısadır.

Açıklama:

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 karakter

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

Haskell, 49 46 bayt

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

Kullanım örneği:

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

Nasıl çalışır

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

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

Açıklaması:

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 bayt

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

Wilson Teoremini kullanır.

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 bayt

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

İşlev, ilk nbileşik sayıların bir dizisini döndürür .

~-nsüslü bir yazım şeklidir n-1; aynı uzunlukta, ama çok daha eğlenceli, değil mi?
Kullanmamın tek nedeni eval, şablonun n=>eval('...returnValue')1 karakterden kısa olmasıdır n=>{...return returnValue}.

Eski versiyonlar

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

Çıktı

 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 bayt

Nimi'nin önceki cevabından yoğun bir şekilde esinlenerek , yüklemi anyiç içe geçmiş bir liste anlama yerine anlamsız bir lambda ile 2 bayt daha kısa olanla değiştirir.

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

Çevrimiçi deneyin!
( doğru TIO bağlantısı için Laikoni'ye teşekkürler )

Açıklama:

[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