두 개의 소수는 서로 다른 경우 두 개의 소수로 정의됩니다. 예를 들어, 3과 5는 29와 31과 같이 트윈 프라임입니다.
n 번째 쌍 소수 (n은 STDIN에서 온)를 찾아 STDOUT에 쉼표와 공백으로 구분하여 인쇄하는 프로그램을 작성하십시오. 이것은 코드 골프이므로 가장 짧은 코드가 승리합니다.
샘플 입력 :
3
샘플 출력 :
11, 13
두 개의 소수는 서로 다른 경우 두 개의 소수로 정의됩니다. 예를 들어, 3과 5는 29와 31과 같이 트윈 프라임입니다.
n 번째 쌍 소수 (n은 STDIN에서 온)를 찾아 STDOUT에 쉼표와 공백으로 구분하여 인쇄하는 프로그램을 작성하십시오. 이것은 코드 골프이므로 가장 짧은 코드가 승리합니다.
샘플 입력 :
3
샘플 출력 :
11, 13
답변:
main=putStrLn.(!!)[show n++", "++show(n+2)|n<-[2..],all((>0).rem n)[2..n-1],all((>0).rem(n+2))[2..n]].(+)(-1)=<<readLn
모든 트윈 프라임을 무차별 대입하고 n 번째 쌍을 인쇄합니다 .
interact
대신에 사용 putStrLn
하면 더 나아가서 105로 줄일 수 있습니다.a#b=all((>0).rem a)[2..a-b];main=interact$(!!)[show n++", "++show(n+2)|n<-[2..],n#1,(n+2)#2].(+)(-1).read
Y4]{{:)_{mp}/&!}g}q~*", "*
$ for i in {1..10}; do cjam twin-primes.cjam <<< $i; echo; done
3, 5
5, 7
11, 13
17, 19
29, 31
41, 43
59, 61
71, 73
101, 103
107, 109
Y4] " Push [ 2 4 ]. ";
{ " ";
{ " ";
:) " Increment each integer in the array. ";
_ " Duplicate the array. ";
{mp}/ " For each integer in the array, push 1 if it's prime and 0 otherwise. ";
&! " Compute the logical NOT of the bitwise AND of the two previous integers. ";
}g " If the result is non-zero, repeat the loop. ";
}q~* " Do the above “N” times, where “N” is the integer read from STDIN. ";
", " " Join the array by comma and space. ";
$n=pop;$r='^1$|^(11+?)\1+$';($t=1x$s)=~$r||"11t"=~$r||--$n||die"$s, ",$s+2,$/while++$s
$n=pop;$r=qr/^1$|^(11+?)\1+$/;(1x$s)!~$r&&(1x($s+2))!~$r&&++$i==$n&&say($s,", ",$s+2)&&exit while++$s
$ perl ./twin_primes.pl 10
107, 109
$n = pop; # Pulls twin prime pair counter from @ARGV
$r = qr/^1$|^(11+?)\1+$/; # The money line - a regex that verifies
# if a string of 1's has non-prime length
while ( ++$s ) { # Loop over integers
# '&&' short-circuits
(1 x $s ) !~ $r # Negated regex match evaluates to true if $s is prime
&& (1 x ($s+2) ) !~ $r # Same for $s + 2
&& ++$i == $n # Counter to control which pair to print
&& say( $s, ", ", $s+2 ) # Print the line
&& exit # Terminate program
}
비 우선 순위 정규 표현식의 작동은 이 SO 질문에 설명되어 있습니다.
$n=pop;$r='^1$|^(11+?)\1+$';($t=1x$s)=~$r||"11$t"=~$r||--$n||exit say("$s, ",$s+2)while++$s
n,c,l;main(i){for(scanf("%d",&n),l=2;n;l=c==i?n-=i==l+2,i:l,i+=2)for(c=2;c<i&&i%c++;);printf("%d, %d\n",l-2,l);}
샘플 실행 :
$ for i in $(seq 1 10); do echo $i | ./twinprimes; done
3, 5
5, 7
11, 13
17, 19
29, 31
41, 43
59, 61
71, 73
101, 103
107, 109
Dennis, bebe 및 Alchymist의 도움에 감사드립니다.
scanf
명령 행 인수 대신 사용하여 몇 바이트를 절약 할 수 있습니다 . 또한 글로벌 o=0
이기 때문에 불필요 o
합니다.
main
기본 int 변수를 보유하고, 증분 c
및 i
할당과 명령문 사이에서 코드를 단축 l
할 수 있습니다 . 할당은 첫 번째 for 루프의 세 번째 블록으로 되돌릴 수 있으므로 중괄호가 필요하지 않으며 printf에서 구분 문자 하나만 사용하면 분명히 더 컴팩트하게 만드십시오.
c<=i-1
어리석은 것을 알았습니다 .
i
에서 증가시켜 바이트를 면도하는 방법을 보지 못했습니다 . 팁이 있습니까? l
i
n
1e4,{mp},_2f-&qi(=_2+", "\
10000보다 작은 소수에 적용됩니다. 4
더 큰 숫자 (잠재적으로 최대 10 20 )에 대해 더 높은 지수로 대체 할 수 있지만 프로그램이 느려지고 더 많은 메모리를 사용합니다.
http://cjam.aditsu.net/ 에서 시도 하십시오
설명:
1e4,
배열 생성 [0 1 2 ... 9999] 소수만
{mp},
선택
_2f-
하여 배열을 복사하고 각 항목에서 2를 빼면
&
두 배열을 교차하므로 각 쌍 소수 쌍에서 하위 소수를 찾으면
qi
입력을 읽고 정수로 변환
(=
합니다. 배열에서 해당 (더 낮은) 트윈 소수를 가져오고 소수를
_2+
복사하고 2
", "\
를 추가 하면 두 소수 사이에 쉼표와 공백이 추가됩니다.
Print[#-2,", ",#]&@Nest[NestWhile[NextPrime,#,#2-#!=2&,2]&,1,n]
이것은 실제로 다소 간단한 구현입니다. 단축으로 인해 난독 화가 거의 발생하지 않았습니다.
NextPrime
숫자 다음에 오는 소수를 찾는 내장입니다.
NestWhile[NextPrime,#,#2-#1!=2&,2]&
숫자 뒤의 다음 쌍 소수 쌍의 큰 소수를 찾는 익명 함수입니다.
Nest
이 익명 함수 n
시간을 적용합니다 .
Print[#-2,", ",#]&
사양에 따라 stdout으로 인쇄하는 익명 함수입니다. 슬프게도 이것만으로 63 개의 문자 솔루션 중 18 개의 문자를 차지합니다.
In[1]:= Do[ Print[#-2,", ",#]&@Nest[NestWhile[NextPrime,#,#2-#!=2&,2]&,1,n], {n, 1, 10} ] 3, 5 5, 7 11, 13 17, 19 29, 31 41, 43 59, 61 71, 73 101, 103 107, 109
업데이트 : 이 CJam 솔루션 을 다시 구현하여 두 문자를 저장할 수 있습니다 . 그러나이 알고리즘은의 최대 값을 제한합니다 n
. Nest...
부품을 교체하십시오Intersection[#,#-2][[5]]&@Prime@Range[999]
더 짧고 호환-spidermonkey 쉘을 사용하여 stdin / write stdout (쉼표와 공백)을 읽습니다. 내 PC에서 1 분 만에 10000 번째 쌍 1260989, 1260991을 발견하는 대신 p 배열이 희소하므로 대신
사용 p[n]=o=n
하는 것이 더 짧을 수 있습니다 p.push(o=n)
. 그러나 그것은 훨씬 느리며 어쨌든 코드 길이로 이길 수는 없습니다.
m=readline();for(n=3,o=p=[];m;n+=2)p.every(e=>n%e)&&(m-=n-o<3,p.push(o=n));print(o-2+', '+o)
파이어 폭스 콘솔에서 시도하려면 :
m=prompt();for(n=3,o=p=[];m;n+=2)p.every(e=>n%e)&&(m-=n-o<3,p.push(o=n));alert(o-2+', '+o)
언 골프
모든 첫 m 트윈을 찾은 함수 (가장 큰 값을 반환 함) :
T=m=>{
for (o=n=3, p=[2], t=[]; !t[m-1]; n+=2)
p.every(e => n%e) && (n-o-2 ? 0 : t.push(n), p.push(o=n))
return t
}
예: console.log(T(50))
[5, 7, 13, 19, 31, 43, 61, 73, 103, 109, 139, 151, 181, 193, 199, 229, 241, 271, 283, 313, 349, 421, 433, 463, 523, 571, 601, 619, 643, 661, 811, 823, 829, 859, 883, 1021, 1033, 1051, 1063, 1093, 1153, 1231, 1279, 1291, 1303, 1321, 1429, 1453, 1483, 1489]
마지막 :
L=m=>{
for (o=n=3,p=[2]; m; n+=2)
p.every(e => n%e) && (m -= n-o==2, p.push(o=n))
return o
}
그런 다음 2 줄을 가져 와서 IO를 추가하십시오.
m = prompt()
for (o=n=3, p=[2]; m; n+=2)
p.every(e => n%e) && (m -= n-o==2, p.push(o=n))
alert('o-2+', '+o)
나는 간단한 접근법으로 가기로 결정했다. 함수 t
는 입력으로 소수가 주어진 다음 트윈 소수를 찾습니다 (이것은 f
함수에 포함됩니다 ). 함수 f
는 n 번째 쌍둥이 소수를 찾습니다. 이것은 또한 J로 작성한 최초의 실제 프로그램이기도합니다.
f=:[:(":,', ',":@+&2)(4&p:(,{~-=2:)])^:_@>:^:(]`2:)
예 :
f 1
3, 5
f 2
5, 7
f 3
11, 13
f 4
17, 19
f 5
29, 31
f 100000
18409199, 18409201
눈썹을 바르기 위해 골판을 바르지 마십시오.
twin =: (4&p:)(($:@[)`(,)@.(=(]+2:)))]
f =: ((]-2:),])((0:{twin) ^: (]`(2:)))
f=:[:(":,', ',":@+&2)(4&p:(,{~-=2:)])^:_@>:^:(]`2:)
(4&p:(,{~-=2:)])^:_@>:^:(]`2:)
@>:^:(]`2:) main loop
^:(]`2:) Repeat n times, starting with value of 2
@>: Add one to the current value and apply to the following function.
(4&p:(,{~-=2:)])^:_ Get the next twin prime
^:_ Recurse until there's no change
(,{~-=2:) If next prime - current value == 2, return current value, otherwise the next prime.
4&p: Get the next prime
(":,', ',":@+&2) Format the output and add 2 to the second value.
[: Apply the twin prime to the formatter.
Basically, if n is 4, this creates a recursion tree like this:
let T be the recursion inside t
and numbers between rows the return values of according function
(t * n) 3
-> (t * 4) 3
-> t t t t 3
17 11 5 3
-> (T T) (T T) T T 3
17 13 11 7 5 3
-> 17
using System.Linq;class P{static void Main(string[] args){var i=int.Parse(args[0]);int f=0,c=0;for(int j=1;;j+=2){var b=(Enumerable.Range(1,j).Count(x=>j%x==0)==2);if(f==0 && b){f=j;continue;}if(b){c++;if(c==i){System.Console.WriteLine(f+","+j);break;}j-=2;}f=0;}}}
.Count(x=>j%x==0)==2)
->.Count(x=>j%x<1)<3)
P
대신 Program
매개 변수를 호출 할 수 있습니다a
대신 args
.
)
것이 .Count(...)<3
있습니다. 로 변경 var i=int.Parse(args[0]);int f=0,c=0;
하여 비트를 저장할 수도 있습니다 int i=int.Parse(args[0]),f=0,c=0;
. 루프에서 이니셜 라이저를 추출하여 일부를 추가로 저장할 수 있으므로 c=0;for(int j=1;
=> c=0,j=1;for(;
.
for
루프 본문을 완전히 다시 작성하고 using System
: using System.Linq;class P{static void Main(string[]args){int i=int.Parse(args[0]),f=0,c=0,j=1;for(;;j+=2)if(Enumerable.Range(1,j).Count(x=>j%x<1)>2)f=0;else if(f<1)f=j;else{if(++c==i){System.Console.WriteLine(f+", "+j);break;}j-=2;f=0;}}}
, 238 자 대신 정규화 된 이름을 사용하십시오 .
require'mathn'
n=gets.to_i
a=1
(a+=2;a.prime?&&(a+2).prime?&&n-=1)while n>0
$><<"#{a}, #{a+2}"
온라인 테스트 : http://ideone.com/B2wxnG
$n=<>;$i=3;while($c<$n&&($l=$i++)){$i++until!grep{$i%$_<1}(2..$i-1);$c++if$i-$l<3}print"$l, $i"
언 골프 드 :
$n = <>; # Read from STDIN
$i = 3; # Tiny hack because I know I don't need the number 2
while ($c<$n && ($l = $i++)) { # $c counts the pairs, $l is the last prime
$i++ until ! grep {$i%$_<1} (2..$i-1); # Increase $i until it's not divisible by anything
$c++ if $i-$l < 3 # If $i and $l are twin primes, count it
}
print "$l, $i" # That damned comma added a whole character to my code!
Brute는 CTE가 소수를 찾고, n을 카운트하는 창 함수를 찾은 다음 트윈을 찾기위한 조인을 찾습니다. 출력 <10,000에서 1 분 미만인 출력 <1,000에서 1 초 안에 작동합니다.
골프를 쳤다 (SQLFiddle here ) :
WITH x(i) AS(SELECT 99 UNION ALL SELECT i-2
FROM x WHERE i>3),z AS(SELECT RANK()OVER(ORDER BY x.i)n,x.i
FROM x x LEFT JOIN x y ON x.i%y.i=0 AND y.i NOT IN(x.i,1)
WHERE y.i IS NULL)SELECT LTRIM(a)+', '+LTRIM(b)FROM(SELECT RANK()
OVER(ORDER BY x.i)n,x.i a,y.i b FROM z x,z y WHERE x.n=y.n-1
AND x.i=y.i-2) o WHERE n=3
OPTION(MAXRECURSION 0)
읽기 쉬운:
WITH x(i) AS (
SELECT 99
UNION ALL
SELECT i-2
FROM x
WHERE i > 3
)
,z AS (
SELECT RANK()OVER(ORDER BY x.i)n,x.i
FROM x x
WHERE NOT EXISTS
(SELECT *
FROM x y
WHERE x.i%y.i = 0
AND y.i NOT IN (x.i,1)
)
)
SELECT LTRIM(a)+', '+LTRIM(b)
FROM (
SELECT RANK()OVER(ORDER BY x.i)n,x.i a, y.i b
FROM z x, z y
WHERE x.n = y.n+1
AND x.i = y.i+2
) o
WHERE n = 3
OPTION(MAXRECURSION 0)
~[1 3]\{\{))}%.{:x,{)x\%!},,2=}/*@\-.}do;', '*
온라인 테스트 : 링크
주석이 달린 코드 :
~ # parse the input as an int
[1 3] # add the array [1, 3] on the stack
\ # invert the items on the stack
{ # begin loop
\ # bring the array to the top of the stack
{))}% # add 2 to each of the numbers in the array
.{:x,{)x\%!},,2=}/ # check if numbers are prime (leaves a 0 or 1 for both numbers on the stack)
* # multiply the two 0/1 numbers (will only get 1 if both are 1)
@\- # subtract the result from the inital int
. # copy the new int value on the stack to be consumed by the 'do' loop
}do # repeat until the initial int was taken down to 0
# at this point the array contains the two numbers we're looking for
; # get rid of the 0 from the stack
', '* # format the output
더 작은 것은 아니지만 PHP로 시도하십시오.
$n=$argv[1];function i($k){for($i=2;$i<=(int)($k/2);$i++)if($k%$i==0)return 0;return 1;}function t($t){return (i($t) && i($t+2))?1:0;}$g=1;$d=0;do{if(t($g)==1){if($d<$n){$d++;}else{print_r([$g,$g+2]);break;}}$g++;}while(1);
다음 프라임을 계속 유지하고 홀수 및 짝수 항을 저장 한 다음 차이가 2인지 확인합니다.
int main()
{
int n;
scanf("%d",&n);
int a=2,b=3,k=2,q;
int odd=1;
int p;
if(n>0)
{
while(n)
{
k++;
p=1;
q=ceil(sqrt(k));
for(int i=2;i<=q;i++)
{
if(k%i==0)
{
p=0;
break;
}
}
if(p)
{
if(odd%2==0)a=k;
else b=k;
if(abs(a-b)==2)n--;
odd++;
}
}
}
printf("%d %d\n",a,b);
return 0;
}
for (int i=2;i*i<=k;i++)
a=scan();n=1;p=5;while(n!=a){p=p+1;q=p-2;if(sum(!p%%2:p,!q%%2:q)<3)n=n+1};cat(q,p,sep=", ")
정말 멋진 것은 없습니다.
a=scan()
n=1
p=5
while(n!=a){
p=p+1
q=p-2
if(sum(!p%%2:p,!q%%2:q)<3) # Check that p and q are both primes by checking
n=n+1 # the number of zeroes resulting from
} # p modulo each integers 2 to p and same for q
cat(q,p,sep=", ")
용법:
> a=scan();n=1;p=5;while(n!=a){p=p+1;q=p-2;if(sum(!p%%2:p,!q%%2:q)<3)n=n+1};cat(q,p,sep=", ")
1: 10
2:
Read 1 item
107, 109
stdin에서 읽고 stdout으로 출력하고 input을 위해 "early"를 종료합니다 <= 0
.
t=process.argv[2],c=0,l=1;if(t>0){for(i=0;;i++){p=!Array(i+1).join(1).match(/^1?$|^(11+?)\1+$/);if(p){if(i-2==l){if(c>=t-1){console.log(l+", "+i);break}c++}l=i}}}
사용법 (위의 스크립트는으로 저장 됨 ntp.js
) :
>for /l %x in (0, 1, 10) do node ntp.js %x
>node ntp.js 0
>node ntp.js 1
3, 5
>node ntp.js 2
5, 7
>node ntp.js 3
11, 13
>node ntp.js 4
17, 19
>node ntp.js 5
29, 31
>node ntp.js 6
41, 43
>node ntp.js 7
59, 61
>node ntp.js 8
71, 73
>node ntp.js 9
101, 103
>node ntp.js 10
107, 109
파일 fsoe-pairs.awk
:
{n=2;N=1
for(;;){if(n in L){p=L[n];del L[n]}else{p=n
if(n-N==2)if(!--$0){print N", "n;exit}N=n}P=p+n++
while(P in L)P+=p;L[P]=p}}
그것을 실행 :
$ awk -f fsoe-pairs.awk
1
3, 5
$ awk -f fsoe-pairs.awk
2
5, 7
$ awk -f fsoe-pairs.awk
10
107, 109
(명령 후 첫 번째 줄, 두 번째 줄이 출력됩니다)
이것은 필자가 체의 필요한 부분과 이미 계산 된 프라임 만 저장하는 "소거 층의 부유 체"(내가 설명 할 때까지)라고하는 자체 프라임 생성기 알고리즘을 기반으로합니다.
c=input()
n=3
while c:n+=2;c-=all(n%i&~2for i in range(2,n-2))
print(n-2,n)
무슨 일이야?
첫째, 표현에서 살펴 보자는 all(n%i&~2for i in range(2,n-2))
, 어떤 검사하는 경우(n-2,n)
두 쌍의 프라임 쌍 .
더 간단한 표현 은 range의 모든 제수 를 시도하고 모든 나머지가 0이 아닌지 확인 하여 소수가 소수 all(n%i for i in range(2,n))
인지 간단히 확인합니다 . 이 파이썬 취급 이후 정확히 검사, 등의 다른 모든 번호 등n
i
2<=i<=n-1
all
0
False
True
.
이제 (n-2)%i==0
정확히 n%i==2
제수가 될 때 를 관찰하십시오 i>2
. 그래서, 우리는에 소수성 검사를 수행 할 수 있습니다 n
및 n-2
모두를위한 나머지 확인하여 같은 시간에 0
와 2
. 이것은 다음과 같이 수행 할 수 있습니다 all(n%i not in [0,2] for i in range(2,n-2))
. 우리는 범위의 약수 시도 2<=i<=n-3
를 위해서 n-2
,하지만,이 접미사를 들어n
로 잘 이후 n-1
및 n-2
않는 약수가 될 수 없습니다 n<=4
. 우리는 이 합병증과 약수의 합병증을 피하기 위해 이상한 n
출발을 시도 할 것 5
입니다.i=2
입니다.
우리는 표현 n%i not in [0,2]
을 골라 내고, 거짓이고 다른 숫자는 n%i&~2
기억합니다 . 연산자 우선 순위 는 정확히 필요한 것입니다. 비트 - 보완 입니다 자사의 비트 수 있도록,0
True
(n%i)&(~2)
~2
...11111101
and
완성 의 숫자는 0 2
의 이진 자리 값을 0으로 만듭니다. 이 준다 0
(즉, False
)에 대해서만 0
그리고 2
우리가 원하는 정확히.
휴! 이제이 표현 은 쌍 소수 쌍의 상위 숫자 all(n%i&~2for i in range(2,n-2))
인지 확인합니다 n
. 남아있는 것은 우리가 볼 때까지 반복하는 것 입니다. 입력 된 숫자는 c
어디에 있습니까 c
? 우리는 제수 문제를 피하기 위해 시작하여 5
계산합니다 2
. 우리는 작동 c
할 때마다 감소 n
하고 when 중지 c=0
합니다. 마지막으로, 우리가 끝내는 쌍둥이 소수 쌍을 인쇄합니다.
좀 더 빠른 속도를 제공하는보다 컴팩트 한 T-SQL 트윈 프라임 파인더입니다.
with t(n)as(select 2+number from spt_values where type='p')select*from(select concat(b,', ',a),rank()over(order by a)from(select n,lag(n)over(order by n)from t where not exists(select*from t f where f.n<t.n and t.n%f.n=0))z(a,b)where a=b+2)r(s,k)where k=2
사람이 읽을 수있는 형식 ::
with t(n)as(
select 2+number
from spt_values
where type='p'
)
select *
from(
select concat(b,', ',a),rank() over (order by a)
from(
select n, lag(n) over(order by n)
from t
where not exists(
select 1 from t f
where f.n<t.n and t.n%f.n=0)
) z(a,b)
where a=b+2
) r(s,k)
where k=2
기본 요점은 내장 숫자 표 (master..spt_values type = 'p')와 CTE가 짧은 별명을 사용한다는 것입니다. 우리는 세트에 0 또는 1 개의 사소한 오류를 당길 걱정을 제거하기 위해 2를 추가하므로 이제 2,2050의 후보가 있습니다.
Z 가장 내부 쿼리는 n보다 작은 수로 나눌 수있는 n을 필터링하여 2에서 2050까지의 모든 소수를 가져옵니다. 우리는 멋진 T-SQL 2012 윈도 기능 사용 lag
a와 b는 소수입니다 그래서 지금, Z의 결과를 우리가 이전 결과를 당길 수 P[n]
와 P[n-1]
각각. R 쿼리는 출력 문자열을 생성하고 트윈이 아닌 소수를 필터링하고 K라고 부르는 출력의 시퀀스 번호도 생성합니다. 마지막으로 쿼리 R은 변수를 변경하여 K 번째 트윈 소수를 필터링하고 가져올 수 있습니다.