1보다 큰 정수가 주어지면 하나 이상의 연속 소수의 합으로 표현할 수있는 방법의 수를 출력하십시오.
소환의 순서는 중요하지 않습니다. 합은 단일 숫자로 구성 될 수 있습니다 (따라서 소수에 대한 출력은 1 이상임).
이것은 code-golf 입니다. 표준 규칙이 적용됩니다.
시퀀스 자체 OEIS A054845를 포함한 관련 정보 및 시퀀스는 이 OEIS 위키 를 참조하십시오 .
2 => 1
3 => 1
4 => 0
5 => 2
6 => 0
7 => 1
8 => 1
10 => 1
36 => 2
41 => 3
42 => 1
43 => 1
44 => 0
311 => 5
1151 => 4
34421 => 6
답변:
Dylnan 덕분에 -1
ÆRẆ§ċ
모나 딕 링크
온라인으로 사용해보십시오! 또는 테스트 슈트를 참조하십시오(최종 테스트 사례는 TIO에서 60 초에 시간이 초과됨에 유의하십시오).
ÆRẆ§ċ - Link: integer, n
ÆR - primes from 2 to n inclusive
Ẇ - all contiguous substrings
§ - sum each
ċ - count occurrences of n
function(x,P=2){for(i in 2:x)P=c(P,i[all(i%%P)])
for(i in 1:x){F=F+sum(cumsum(P)==x)
P[i]=0}
F}x!
cumsum처음 몇 가지 요소를 사용 하고 설정하는 것에 대한 단서가 없었습니다 0. 프라임 골프는 단지 마지막 테스트 케이스를 작동 시키려고 노력한 것입니다 outer. 나는 충분한 담당자 이상을 보유하고 있으며 (적어도 적절한 담당자 요구 사항을 얻을 때까지), 더 많은 R 골퍼가 더 많은 가시성을 확보 할 수 있도록 항상 기쁩니다!
n=>(a=[],k=1,g=s=>k>n?0:!s+g(s>0?s-(p=d=>k%--d?p(d):d<2&&a.push(k)&&k)(++k):s+a.shift()))(n)n => ( // n = input
a = [], // a[] = array holding the list of consecutive primes
k = 1, // k = current number to test
g = s => // g = recursive function taking s = n - sum(a)
k > n ? // if k is greater than n:
0 // stop recursion
: // else:
!s + // increment the final result if s = 0
g( // add the result of a recursive call to g():
s > 0 ? // if s is positive:
s - ( // subtract from s the result of p():
p = d => k % --d ? // p() = recursive helper function looking
p(d) // for the highest divisor d of k,
: // starting with d = k - 1
d < 2 && // if d is less than 2 (i.e. k is prime):
a.push(k) && // append k to a[]
k // and return k (else: return false)
)(++k) // increment k and call p(k)
: // else:
s + a.shift() // remove the first entry from a[]
// and add it to s
) // end of recursive call
)(n) // initial call to g() with s = nEZqPYTRYsG=z
초기 값 E(2를 곱한 값 )은 소수 입력의 경우 후자 Ys( cumsum) 의 결과에 행렬의 제로 부분에서 반복되는 입력 소수 (따라서 카운트를 어지럽히 지 않음)가 없도록합니다.
% Implicit input, say 5
E % Double the input
Zq % Get list of primes upto (and including) that
% Stack: [2 3 5 7]
P % Reverse that list
YT % Toeplitz matrix of that
% Stack: [7 5 3 2
5 7 5 3
3 5 7 5
2 3 5 7]
R % `triu` - upper triangular portion of matrix
% Stack: [7 5 3 2
0 7 5 3
0 0 7 5
0 0 0 7]
Ys % Cumulative sum along each column
% Stack: [7 5 3 2
7 12 8 5
7 12 15 10
7 12 15 17]
G= % Compare against input - 1s where equal, 0s where not
z % Count the number of non-zeros
{⟦ṗˢs+?}ᶜ
(@Kroppeb 덕분에 5 바이트 전체!)
{⟦ṗˢs+?}ᶜ
{ }ᶜ Count the number of ways this predicate can succeed:
⟦ Range from 0 to input
ṗˢ Select only the prime numbers
s The list of prime numbers has a substring (contiguous subset)
+ Whose sum
? Is the input
;?=by by 를 대체 ?하고 얻을 수 있음을 {⟦ṗˢs+?}ᶜ
.+
$*_$&$*
_
$`__¶
A`^(__+)\1+$
m)&`^((_)|¶)+¶[_¶]*(?<-2>1)+$(?(2)1)
온라인으로 사용해보십시오! 더 빠른 테스트 사례가 포함되어 있습니다. 설명:
m)
멀티 라인 모드 어디에서 전체 스크립트를 실행 ^하고 $모든 라인에 일치합니다.
.+
$*_$&$*
먼저 _s를 사용한 다음 1s 를 사용 하여 단항으로 두 번 변환하십시오 .
_
$`__¶
_
A`^(__+)\1+$
범위 내의 모든 복합 번호를 삭제하십시오.
&`^((_)|¶)+¶[_¶]*(?<-2>1)+$(?(2)1)
__1
Mr.Xcoder 덕분에 -1 바이트 ( ¹대신에 named argument 사용 S)!
#¹ṁ∫ṫ↑İp
#¹ṁ∫ṫ↑İp -- example input: 3
#¹ -- count the occurrences of 3 in
İp -- | primes: [2,3,5,7..]
↑ -- | take 3: [2,3,5]
ṫ -- | tails: [[2,3,5],[3,5],[5]]
ṁ -- | map and flatten
∫ -- | | cumulative sums
-- | : [2,5,10,3,8,5]
-- : 1
#¹ṁ∫ṫ↑İp1 바이트를 저장해야합니다.
:"GZq@:g2&Y+G=vs
:" % Input (implicit): n. For each k in [1 2 ... n]
G % Push n
Zq % Primes up to that
@:g % Push vector of k ones
2&Y+ % Convolution, removing the edges
G= % True for entries that equal n
v % Concatenate vertically with previous results
s % Sum
% End (implicit). Display (implicit)
P=k=o=1
p=[]
i=input()
exec'o+=P%k*sum(p)==i;P*=k*k;k+=1;p+=P%k*[k];exec"p=p[i<sum(p):];"*k;'*i
print~-oimport StdEnv,StdLib
$n=sum[1\\z<-inits[i\\i<-[2..n]|all(\j=i/j*j<i)[2..i-1]],s<-tails z|sum s==n]
$ :: Int -> Int아래에 설명 된대로 작동 하는 기능 을 정의합니다 .
$ n // the function $ of n is
= sum [ // the sum of
1 // 1, for every
\\ z <- inits [ // prefix z of
i // i, for every
\\ i <- [2..n] // integer i between 2 and n
| and [ // where every
i/j*j < i // j does not divide i
\\ j <- [2..i-1] // for every j between 2 and i-1
]
]
, s <- tails z // ... and suffix s of the prefix z
| sum s == n // where the sum of the suffix is equal to n
]
(설명은 오래되었지만 논리적으로 동일한 버전입니다)
{+grep $_,map {|[\+] $_},[\R,] grep *.is-prime,2..$_}삼각형 축소 연산자를 두 번 사용합니다. 마지막 테스트 사례는 TIO에 비해 너무 느립니다.
{ } # Anonymous block
grep *.is-prime,2..$_ # List of primes up to n
[\R,] # All sublists (2) (3 2) (5 3 2) (7 5 3 2) ...
map {|[\+] $_}, # Partial sums for each, flattened
+grep $_, # Count number of occurrences이보다 더 짧은 방법이 있습니다!
마지막 테스트 사례를 마무리합니다.
õ fj x@ZãYÄ x@¶Xx
:Implicit input of integer U
õ :Range [1,U]
fj :Filter primes
@ :Map each integer at 0-based index Y in array Z
YÄ : Y+1
Zã : Subsections of Z of that length
@ : Map each array X
Xx : Reduce by addition
¶ : Check for equality with U
x : Reduce by addition
x :Reduce by addition
n->{var L=new java.util.Stack();int i=1,k,x,s,r=0;for(;i++<n;){for(k=1;i%++k>0;);if(k==i)L.add(i);}for(x=L.size(),i=0;i<x;)for(k=i++,s=0;k<x;r+=s==n?1:0)s+=(int)L.get(k++);return r;}@ceilingcat 덕분에 -1 바이트 . @SaraJ
덕분에 -10 바이트 .
설명:
n->{ // Method with integer as both parameter and return-type
var L=new java.util.Stack();
// List of primes, starting empty
int i=1,k,x,s, // Temp integers
r=0; // Result-counter, starting at 0
for(;i++<n;){ // Loop `i` in the range [2, `n`]
for(k=1; // Set `k` to 1
i%++k>0;); // Inner loop which increases `k` by 1 before every iteration,
// and continues as long as `i` is not divisible by `k`
if(k==i) // If `k` is now still the same as `i`; a.k.a. if `i` is a prime:
L.add(i);} // Add the prime to the List
for(x=L.size(), // Get the amount of primes in the List
i=0;i<x;) // Loop `i` in the range [0, amount_of_primes)
for(s=0, // (Re)set the sum to 0
k=i++;k<x; // Inner loop `k` in the range [`i`, amount_of_primes)
r+=s==n? // After every iteration, if the sum is equal to the input:
1 // Increase the result-counter by 1
: // Else:
0) // Leave the result-counter the same by adding 0
s+=(int)L.get(k++);
// Add the next prime (at index `k`) to the sum
return r;} // And finally return the result-counter기본적으로 Jelly 또는 05AB1E 답변 과 비슷하며 190 바이트 만 더 있습니다. XD
여기에 각 부분에 대한 비교가 재미를 위해 추가되었으며 Java가 왜 그렇게 장황한 지, 이러한 골프 언어가 강력한 이유를 알 수 있습니다.
n->{}[2, n]. (Jelly : 2 bytes) ÆR; (05AB1E : 2 바이트)ÅP ; (자바 10:95 바이트)var L=new java.util.Stack();int i=1,k,x,s,r=0;for(;i++<n;){for(k=1;i%++k>0;);if(k==i)L.add(i);}Ẇ; (05AB1E : 1 바이트) Œ; (자바 10:55 바이트)for(x=L.size(),i=0;i<x;)for(k=i++;k<x;) 및(int)L.get(k++);§; (05AB1E : 1 바이트) O; (Java 10 : 9 바이트) ,s및,s=0 과s+=ċ; (05AB1E : 2 바이트) QO; (자바 10:15 바이트),r=0 및r+=s==n?1:0return r;218918수행한다는 점을 고려할 때 여전히 12.5 초 tbh에서 충분히 빠르다는 것에 놀랐습니다 . 모든 소수에 대한 반복; 모든 짝수에 대해 1 회 반복; 그리고 모든 홀수 (약 20 억 반복)에 대한 반복 사이 에 메모리의 목록에 소수를 추가합니다 . 그런 다음 두 번째 중첩 루프에서 추가 시간을 반복합니다. 총 2,223,570,640 반복이 정확 합니다. 218918-2 = 218,916n[2,p/2)19518sum([0,19518]) = 190,485,921
%i 면서 범위 내에서 체크하고 있기 때문에 후행을 뺀 [2, n]것이므로 확인할 필요가 없습니다 i=1. :)
->x:Count[Sum@Sublists[PrimeQ$$[…x]];x]
->x:Count[Sum@Sublists[PrimeQ$$[…x]];x] // Full program.
->x: // Define an anonymous function with parameter x.
[…x] // Range [0 ... x] (inclusive).
$$ // Filter-keep those that...
PrimeQ // Are prime.
Sublists[...] // Get all their sublists.
Sum@ // Then sum each sublist.
Count[...;x] // Count the number of times x occurs in the result.
g n=sum[1|a<-[0..n],_<-filter(n==).scanl1(+)$drop a[p|p<-[2..n],all((>0).mod p)[2..p-1]]]f n=length$do a<-[0..n];filter(n==).scanl1(+)$drop a[p|p<-[2..n],all((>0).mod p)[2..p-1]]
2æR과 동일ÆR