एक संख्या के तरीकों की संख्या लगातार primes का योग है

Question

1 से अधिक पूर्णांक को देखते हुए, उन तरीकों की संख्या को आउटपुट करें जिन्हें एक या एक से अधिक लगातार अपराधों के योग के रूप में व्यक्त किया जा सकता है।

सम्मन का आदेश मायने नहीं रखता। एक राशि में एक संख्या शामिल हो सकती है (इसलिए किसी भी प्राइम के लिए आउटपुट कम से कम 1. होगा)

यह कोड-गोल्फ है । मानक नियम लागू होते हैं।

संबंधित जानकारी और अनुक्रम के लिए इस OEIS विकी को देखें , जिसमें OEIS A054845 स्वयं अनुक्रम भी शामिल है ।

परीक्षण के मामलों

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

Answer 1

जेली ,  6  5 बाइट्स

-1 डायलन को धन्यवाद

ÆRẆ§ċ

एक मोनडिक लिंक

इसे ऑनलाइन आज़माएं! या टेस्ट-सूट देखें (ध्यान दें कि अंतिम परीक्षा का मामला 60 के दशक के टीआईओ में होगा)।

कैसे?

ÆRẆ§ċ - Link: integer, n
ÆR    - primes from 2 to n inclusive
  Ẇ   - all contiguous substrings
   §  - sum each
    ċ - count occurrences of n

Comments

2æRके रूप में ही हैÆR

— dylnan

@dylnan अच्छा एक धन्यवाद!

— जोनाथन एलन

Answer 2

आर , 95 बाइट्स

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}

इसे ऑनलाइन आज़माएं!

• -24 बाइट्स @Giuseppe को धन्यवाद जिन्होंने मूल रूप से 34421 के साथ-साथ मेरे समाधान में क्रांति ला दी!

Comments

कि primes के साथ आने का एक चतुर तरीका है x!

— Giuseppe

97 बाइट्स

— Giuseppe

@ गुइसेप: वह महान है !! आज मैं बीमार हूँ और मैं कभी भी यह नहीं सोच पा रहा हूँ कि ... (शायद कभी नहीं: पी) मुझे आपके कोड का उपयोग करने में बुरा लग रहा है ... मैं पिछले पर लौट आया, अगर आप एक नया उत्तर देते हैं तो मैं ' ऊपर

— उठना

@ngm 34421 का क्या महत्व है ..? और @digEmAll, मुझे वास्तव में कोई आपत्ति नहीं है; मेरे पास वास्तव में लगातार प्रमुख रकम प्राप्त cumsumकरने के 0लिए पहले कुछ तत्वों का उपयोग करने और स्थापित करने के बारे में कोई संकेत नहीं था । मुख्य गोल्फ बस मुझे पिछले परीक्षण मामले को काम करने की कोशिश कर रहा था, और मुझे सिर्फ यह पता चला कि वह इससे छोटा था outer! मेरे पास पर्याप्त से अधिक प्रतिनिधि हैं (कम से कम जब तक हमें उचित प्रतिनिधि आवश्यकताएं नहीं मिल जाती हैं), और मैं हमेशा अधिक आर गोल्फर को अधिक दृश्यता प्राप्त करने में मदद करने के लिए खुश हूं!

— Giuseppe

@Giuseppe 34421 सबसे छोटी संख्या है जो ठीक 6 तरीकों से लगातार primes का योग है (देखें oeis.org/A054859 )। इस चुनौती के लिए पोस्ट किए गए अधिकांश समाधान या तो उस समय (TIO पर) या उस टेस्ट केस के लिए मेमोरी से बाहर होते हैं। हालाँकि जावा उत्तर को अगला पूर्णांक भी अनुक्रम में मिला (7 के लिए), लेकिन 8. के ​​लिए नहीं

— एनजीएम

Answer 3

05AB1E , 6 बाइट्स

कोड

ÅPŒOQO

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Answer 4

जावास्क्रिप्ट (ईएस 6), 92 बाइट्स

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 = n

Answer 5

MATL, 15 12 बाइट्स

EZqPYTRYsG=z

इसे MATL ऑनलाइन पर आज़माएं

प्रारंभिक 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

Comments

Toeplitz primes और त्रिकोणीय भाग का मैट्रिक्स, बहुत अच्छा!

— लुइस मेंडू

Answer 6

ब्रेकीलॉग , 14 9 बाइट्स

{⟦ṗˢs+?}ᶜ

इसे ऑनलाइन आज़माएं!
एकाधिक परीक्षण के मामले

(-5 पूरे बाइट्स, @Kroppeb के लिए धन्यवाद!)

स्पष्टीकरण:

{⟦ṗˢ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

Comments

आप इसे लूप के ⟦ṗˢअंदर की गणना करके गोल्फ कर सकते हैं ᶜ। मुझे यह {⟦ṗˢs+;?=}ᶜटेस्ट सूट मिला : इसे ऑनलाइन आज़माएं!

— क्रॉपेब

एहसास मैं जगह ले सकता ;?=है ?और {⟦ṗˢs+?}ᶜ(9 बाइट्स)

— क्रॉपेब

@Kroppeb बेशक! यह एक बहुत ही सुंदर जवाब भी है। धन्यवाद।

— सूंदर -

Answer 7

रेटिना 0.8.2 , 68 बाइट्स

.+
$*_$&$*
_
$`__¶
A`^(__+)\1+$
m)&`^((_)|¶)+¶[_¶]*(?<-2>1)+$(?(2)1)

इसे ऑनलाइन आज़माएं! लिंक में तेजी से परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

m)

मल्टीलाइन मोड में पूरी स्क्रिप्ट को रन करें जहां ^और $हर लाइन पर मेल करें।

.+
$*_$&$*

दो बार यूरी में कनवर्ट करें, पहले _एस का उपयोग करके , फिर 1एस का उपयोग करके ।

_
$`__¶

_$2$$n + 1$

A`^(__+)\1+$

श्रेणी में सभी मिश्रित संख्याओं को हटा दें।

&`^((_)|¶)+¶[_¶]*(?<-2>1)+$(?(2)1)

__1$n$

Answer 8

भूसी , ९ 9 बाइट्स

^{-1 बाइट मिस्टरकॉडर के लिए धन्यवाद ( ¹इसके बजाय नाम तर्क का उपयोग करें 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

Comments

एक पूर्ण कार्यक्रम के रूप में, #¹ṁ∫ṫ↑İp1 बाइट को बचाना चाहिए।

— श्री एक्सकोडर

Answer 9

MATL , 16 बाइट्स

:"GZq@:g2&Y+G=vs

MATL ऑनलाइन पर यह कोशिश करो!

व्याख्या

:"        % 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)

Answer 10

पायथन 2 , 106 104 बाइट्स

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~-o

इसे ऑनलाइन आज़माएं!

Answer 11

स्वच्छ , 100 98 बाइट्स

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

(स्पष्टीकरण पुराने लेकिन तार्किक रूप से समान संस्करण के लिए है)

Comments

34421 के लिए आउटपुट प्राप्त करने के लिए विशेष प्रशंसा।

— एनजीएम

Answer 12

पर्ल 6 , 53 बाइट्स

{+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

Answer 13

जाप, 17 बाइट्स

वहाँ इस से एक छोटा रास्ता होना चाहिए!

अंतिम परीक्षण मामले पर क्रेप्स।

õ 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

Answer 14

जावा 10, 195 194 184 182 बाइट्स

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

-1 बाइट @ceilingcat की बदौलत ।
-10 बाइट्स @SaraJ की बदौलत ।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

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

---

यह मूल रूप से जेली या 05AB1E के उत्तर के समान है, बस 190 बाइट्स अधिक है। XD
यहां प्रत्येक भाग के लिए एक तुलना है, बस मज़े के लिए जोड़ा गया है (और यह देखने के लिए कि जावा इतना क्रियात्मक क्यों है, और ये गोल्फ भाषाएँ इतनी शक्तिशाली हैं):

1. इनपुट लें: (जेली: 0 बाइट्स) अंतर्निहित रूप से ; (05AB1E: 0 बाइट्स) स्पष्ट रूप से ; (जावा 10: 5 बाइट्स)n->{}
2. रेंज में primes की एक सूची बनाएँ [2, n]: (जेली: 2 बाइट्स) Æ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);}
3. सभी निरंतर उप-सूचियां प्राप्त करें: (जेली: 1 बाइट) Ẇ; (05AB1E: 1 बाइट) Œ; (जावा 10: 55 बाइट्स) for(x=L.size(),i=0;i<x;)for(k=i++;k<x;)और(int)L.get(k++);
4. प्रत्येक उप-सूची का योग: (जेली: 1 बाइट) §; (05AB1E: 1 बाइट) O; (जावा 10: 9 बाइट्स) ,sऔर ,s=0औरs+=
5. इनपुट के बराबर गणना करें: (जेली: 1 बाइट) ċ; (05AB1E: 2 बाइट्स) QO; (जावा 10: 15 बाइट्स) ,r=0औरr+=s==n?1:0
6. परिणाम का परिणाम: (जेली: 0 बाइट्स) स्पष्ट रूप से ; (05AB1E: 0 बाइट्स) स्पष्ट रूप से ; (जावा 10: 9 बाइट्स)return r;

Comments

34421 के लिए आउटपुट प्राप्त करने के लिए विशेष प्रशंसा।

— एनजीएम

@ngm :) जावा कई चीजों पर खराब हो सकता है, लेकिन प्रदर्शन-वार यह आमतौर पर बहुत अच्छा है।

— केविन क्रूज़सेन

यहां तक कि पर 218918. टाइम्स काम करता है 3634531. के साथ बाहर

— एन जी एम

@ मैं वास्तव में आश्चर्यचकित हूं कि यह अभी भी 21891812.5 सेकंड के टीबीएच में करने के लिए पर्याप्त तेज है , यह विचार करते हुए कि यह 218918-2 = 218,916एक आंतरिक लूप के अंदर पुनरावृत्तियों को करेगा : nप्रत्येक प्रधानमंत्री के लिए पुनरावृत्तियों; प्रत्येक संख्या के लिए 1 पुनरावृत्ति; और [2,p/2)हर विषम संख्या (लगभग दो बिलियन पुनरावृत्तियों) के लिए पुनरावृत्तियों के बीच कहीं , जिसके बाद यह 19518स्मृति में सूची में जोड़ता है । और फिर यह sum([0,19518]) = 190,485,921दूसरे नेस्टेड लूप में एक अतिरिक्त बार लूप करेगा .. कुल सटीक होने के लिए 2,223,570,640 पुनरावृत्तियों ।

— केविन क्रूज़सेन

@ceilingcat धन्यवाद। जब हम रेंज में जाँच कर रहे हैं , तब से @SaraJ के वैकल्पिक प्राइम चेक के साथ 12 और बाइट्स गोल्फ में सक्षम %iहैं [2, n], इसलिए मुझे जाँच करने की आवश्यकता नहीं होगी i=1। :)

— केविन क्रूज़सेन

Answer 15

फिजिका , 41 बाइट्स

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

Answer 16

हास्केल , 89 बाइट्स

g n=sum[1|a<-[0..n],_<-filter(n==).scanl1(+)$drop a[p|p<-[2..n],all((>0).mod p)[2..p-1]]]

इसे ऑनलाइन आज़माएं!

वैकल्पिक, 89 बाइट्स

f n=length$do a<-[0..n];filter(n==).scanl1(+)$drop a[p|p<-[2..n],all((>0).mod p)[2..p-1]]

इसे ऑनलाइन आज़माएं!