この質問に触発された
正の整数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
いつものように、標準的な抜け穴は許可されていません。
素数または合成数を生成するビルトインは許可されていません。
素数または合成数に関連するビルトインは許可されていません。
回答:
有効な答え。ウィルソンの定理を使用します。
.f%h.!tZZQ
素数チェックではなく、素因数分解に組み込みを使用します。
.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
できるから。
\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#1\i\d#1\l#2\i0 を返す数字を。
アンゴルフド（まあ、ハーフゴルフ）バージョン：
\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:
\endlambda 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 シフトアップすることで取得できます。
ゴルフこのために、我々は2つの値を格納する古典的なゴルフのトリックを行う(a,b)にはrange(n)単一の値としてkでrange(n*n)、かつ、それらを取り出しますa=k/n, b=k%n。
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)));
}
}
n=scan();t=1:(n*n+3);t[factorial(t-1)%%t!=(t-1)][1:n]
使い方
これはウィルソンの定理にも基づいており1:n*n、上記の定理に従ってある範囲で実行し、合成数を抽出するだけです。整数の範囲が十分でない+3ために追加しましたn*nn < 3
このソリューションの唯一の問題は、（悲しいことに）Rが十分に大きな階乗に対して精度を失うことです。したがって、これは以下に対して適切に動作しません。 n > 19
li_5*{_,2>f%0&},<`
組み込みの素数または因数分解演算子を使用しません。合成されている数値のかなり強引なチェック。
ここで使用される1つの観察は、テストする必要がある数値の安全な上限を簡単に計算できることです。4より大きいすべての2番目の数値は合成で4 + n * 2あるため、n番目の合成数の上限です。
@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.
n=>{r=[];for(q=2;r.length!=n;++q)if(/^(..+)\1+$/.test("-".repeat(q)))r.push(q);return r}
f=は合法だと思います。
n=>eval('for(r=[],q=2;r.length-n;/^(..+)\\1+$/.test("-".repeat(++q))&&r.push(q))r')
n&&!r[n-1]： '| 長さはr.length<n1文字短くr.length!=nなっていますが、これはコードゴルフのはずですよね？：-]
(`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
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
i2回使用するのは少し混乱します。私はF＃にあまり詳しくありませんが、おそらく使用できませんjか？
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;}
非ゴルフ
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;
}
whileによってfor。
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))これはウィルソンの定理を使用しています。
ゴルフをしていない：
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
endn=>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]Nimi の以前の回答に大きく影響されany、ネストされたリスト内包表記ではなく、ポイントフリーラムダに基づく2バイトの短い述語に置き換えられます。
(`take`[x|x<-[4..],any((<)1.gcd x)[2..x-1]])オンラインでお試しください！
（ライコニのおかげで正確な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