সংখ্যার কতগুলি উপায় ক্রমাগত প্রাইমসের যোগফল

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Ẇ§ċ

একটি monadic লিঙ্ক

এটি অনলাইন চেষ্টা করুন! অথবা টেস্ট-স্যুটটি দেখুন (টিআইও-তে 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

— ডাইলানান

@ এল্ডানান ধন্যবাদ একটি ধন্যবাদ!

— জোনাথন অ্যালান

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}

এটি অনলাইন চেষ্টা করুন!

• -২৪ বাইটস @ জিউজেপকে ধন্যবাদ যিনি মূলত আমার সমাধানটিতে 34421 সমর্থন করেও বিপ্লব ঘটিয়েছেন!

Comments

এটি প্রাইমস পর্যন্ত আসা একটি চতুর উপায় x!

— জিউসেপে

97 বাইট

— জিউসেপে

@ জিউসেপ: এটি দুর্দান্ত! আজ আমি অসুস্থ এবং আমি কখনই এটি ভাবতে পারতাম না ... (সম্ভবত কখনই নয়: পি) আপনার কোড ব্যবহার করতে খারাপ লাগছে ... আমি আগেরটিতে ফিরে এসেছি, আপনি যদি নতুন উত্তর পোস্ট করেন তবে আমি ' ll

— upvote

@ngm 34421 এর তাত্পর্য কি ..? এবং @ ডিজিম সব, আমি আসলেই কিছু মনে করি না; টানা প্রাইম অঙ্কের cumsumজন্য প্রথম কয়েকটি উপাদান ব্যবহার এবং সেট করার বিষয়ে আমার সত্যিই কোনও ধারণা ছিল না 0। প্রাইম গল্ফটি ছিল আমার শেষ পরীক্ষার কেসটি কাজ করার চেষ্টা করছিল, এবং আমি কেবল খুঁজে পেলাম যে এটির চেয়েও খাটো ছিল outer! আমার কাছে পর্যাপ্ত প্রতিনিধিত্বের চেয়েও বেশি রয়েছে (কমপক্ষে যতক্ষণ না আমরা যথাযথ প্রতিবেদনের প্রয়োজনীয়তা পান), এবং আমি আর আর গল্ফারদের আরও দৃশ্যমানতা পেতে সহায়তা করতে সর্বদা খুশি!

— জিউসেপ

@ জিউসেপ 34421 হ'ল সর্বকনিষ্ঠ সংখ্যা যা হ'ল 6 উপায়ে পরপর প্রাইমের যোগফল হয় (দেখুন oeis.org/A054859 )। এই চ্যালেঞ্জের জন্য পোস্ট করা বেশিরভাগ সমাধানগুলি পরীক্ষার ক্ষেত্রে যে কোনও সময় (টিআইওতে) বা মেমরির বাইরে চলে যায়। যদিও জাভা উত্তরটি পরবর্তী

— ক্রমিকটিও যথাযথভাবে

Answer 3

05 এ বি 1 ই , 6 বাইট

কোড

ÅPŒOQO

05AB1E এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন!

Answer 4

জাভাস্ক্রিপ্ট (ES6), 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

এমএটিএল, 15 12 বাইট

EZqPYTRYsG=z

এমএটিএল অনলাইন এ চেষ্টা করুন

প্রাথমিক E(2 দ্বারা গুণিত) নিশ্চিত করে যে, প্রাথমিক ইনপুটটির জন্য, পরবর্তী ফলাফল theYs ( 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

প্রাইমস এবং ত্রিভুজাকার অংশের টোপলিটজ ম্যাট্রিক্স, খুব সুন্দর!

— লুইস মেন্ডো

Answer 6

ব্র্যাচল্যাগ , 14 9 বাইট

{⟦ṗˢs+?}ᶜ

এটি অনলাইন চেষ্টা করুন!
একাধিক পরীক্ষার মামলা

(-৫ পুরো বাইটস, @ ক্রপ্পেবকে ধন্যবাদ!)

ব্যাখ্যা:

{⟦ṗˢ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 8 বাইট

^{মিঃ এক্সকোডারকে -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

এমএটিএল , 16 বাইট

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

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. জন্য আউটপুট পাওয়ার জন্য বিশেষ প্রশংসা

— NGM

Answer 12

পার্ল 6 , 53 বাইট

{+grep $_,map {|[\+] $_},[\R,] grep *.is-prime,2..$_}

এটি অনলাইন চেষ্টা করুন!

ত্রিভুজ হ্রাস অপারেটরটি দুইবার ব্যবহার করে। টিআইওর জন্য শেষ পরীক্ষার কেসটি খুব ধীর।

ব্যাখ্যা

{                                                   } # 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 বাইট @ সিলিংক্যাট ধন্যবাদ ।
-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 বাইট আরও বেশি .. এক্সডি
এখানে প্রতিটি অংশের জন্য একটি তুলনা করা হয়েছে, কেবল মজা করার জন্য যুক্ত করা হয়েছে (এবং জাভাটি কেন ভার্বোজ , এবং এই গল্ফ ভাষাগুলি এত শক্তিশালী) তা দেখার জন্য:

1. ইনপুটটি নিন: (জেলি: 0 বাইট) সুস্পষ্টভাবে ; (05AB1E: 0 বাইট) সুস্পষ্টভাবে ; (জাভা 10: 5 বাইট)n->{}
2. পরিসীমাতে প্রাইমগুলির একটি তালিকা তৈরি করুন [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

@ngm :) জাভা অনেক কিছুতে খারাপ হতে পারে তবে পারফরম্যান্স অনুযায়ী এটি সাধারণত বেশ ভাল।

— কেভিন ক্রুইজসেন

এমনকি 218918 এ কাজ করে 36 3634531 এর সাথে টাইমস আউট

— এনজিএম

@ngm আমি আসলে অবাক হয়েছি এটি এখনও 21891812.5 সেকেন্ড টিবিএইচ করার জন্য যথেষ্ট দ্রুত , বিবেচনা করে এটি 218918-2 = 218,916অভ্যন্তরীণ লুপের অভ্যন্তরে পুনরাবৃত্তি করবে : nপ্রতিটি প্রধানের জন্য পুনরাবৃত্তি; প্রতিটি সমান সংখ্যার জন্য 1 পুনরাবৃত্তি; এবং কোথাও [2,p/2)প্রতিটি বিজোড় সংখ্যার জন্য পুনরাবৃত্তি (দুই বিলিয়ন পুনরাবৃত্তির কাছাকাছি), যার পরে এটি 19518মেমরির তালিকায় প্রাইম যুক্ত করে। এবং তারপরে এটি sum([0,19518]) = 190,485,921দ্বিতীয় নেস্ট করা লুপে একটি অতিরিক্ত বার লুপ করবে .. মোট ২২২২২,7070০,40৪০ পুনরাবৃত্তি নির্ভুল হতে হবে ।

— কেভিন ক্রুইজসেন

ধন্যবাদ @ সারাজের বিকল্প প্রাইম চেকটি সহ আরও 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]]

এটি অনলাইন চেষ্টা করুন!