जाहिरा तौर पर हाँ! तीन आसान चरणों में।

चरण 1

बता दें कि f ( n ) प्राइम-काउंटिंग फंक्शन ( n से कम या उसके बराबर के प्राइम की संख्या) को दर्शाता है ।

पूर्णांक अनुक्रम s ( n ) को निम्नानुसार परिभाषित करें । प्रत्येक सकारात्मक पूर्णांक n के लिए ,

Initiallize टी करने के लिए एन ।
जब तक t न तो प्रधान है और न ही 1, तब तक t को f ( t ) और पुनरावृति से प्रतिस्थापित करें ।
पुनरावृत्तियों की संख्या s ( n ) है।

चलने की प्रक्रिया समाप्त होने की गारंटी है क्योंकि f ( n ) < n सभी n के लिए ।

उदाहरण के लिए विचार करें n = 25। हम t = 25 को आरंभ करते हैं । चूंकि यह अभाज्य नहीं है और न ही 1 है, इसलिए हम f (25) की गणना करते हैं , जो 9. है। यह t के लिए नया मान बन जाता है । यह प्राइम नहीं है और न ही 1 है, इसलिए हम जारी रखते हैं: f (9) है 4. हम फिर से जारी रखते हैं: f (4) 2 है। चूंकि यह एक प्राइम है जिससे हम यहां रुकते हैं। हमने 3 पुनरावृत्तियों को किया है (25 से 9 तक, फिर 4 से, फिर 2 तक)। इस प्रकार s (25) 3 है।

अनुक्रम के पहले 40 पद इस प्रकार हैं। अनुक्रम OEIS में नहीं है।

0 0 0 1 0 1 0 2 2 2 0 1 0 2 2 2 0 1 0 3 3 3 0 3 3 3 3 3 0 3 0 1 1 1 1 1 0 2 2 2

चरण 2

एक विषम धनात्मक पूर्णांक N को देखते हुए , परिमित अनुक्रम s (1), s (2), ..., s ( N ² ) को एक चौकोर जावक सर्पिल बनाने के लिए N × N सरणी (मैट्रिक्स) का निर्माण करें । उदाहरण के लिए, एन = 5 सर्पिल दिया गया है

s(21)   s(22)   s(23)   s(24)   s(25)
s(20)   s(7)    s(8)    s(9)    s(10)
s(19)   s(6)    s(1)    s(2)    s(11)
s(18)   s(5)    s(4)    s(3)    s(12)
s(17)   s(16)   s(15)   s(14)   s(13)

या, मानों को प्रतिस्थापित करते हुए,

 3       3       0       3       3
 3       0       2       2       2
 0       1       0       0       0
 1       0       1       0       1
 0       2       2       2       0

चरण 3

N × N सरणी को एक ग्रे कलर मैप के साथ, या अपने स्वाद के कुछ अन्य कलर मैप के साथ छवि के रूप में प्रस्तुत करें। नक्शा क्रमिक होना चाहिए, ताकि संख्याओं का क्रम रंगों के कुछ स्पष्ट रूप से स्पष्ट क्रम से मेल खाता हो। नीचे दिए गए परीक्षण मामले कुछ उदाहरण रंग मानचित्र दिखाते हैं।

चुनौती

एक अजीब सकारात्मक पूर्णांक एन को देखते हुए , ऊपर वर्णित छवि का उत्पादन करें।

नियम

सर्पिल बाहरी होना चाहिए, लेकिन दक्षिणावर्त या काउंटर-क्लॉकवाइज हो सकता है, और दाएं (ऊपर के उदाहरण में), बाएं, नीचे या ऊपर बढ़ना शुरू कर सकता है।
क्षैतिज और ऊर्ध्वाधर कुल्हाड़ियों के तराजू को समान होने की आवश्यकता नहीं है। इसके अलावा अक्ष लेबल, कलरबार और इसी तरह के तत्व वैकल्पिक हैं। जब तक सर्पिल को स्पष्ट रूप से देखा जा सकता है, तब तक छवि वैध है।
छवियाँ किसी भी मानक साधन द्वारा आउटपुट की जा सकती हैं । विशेष रूप से, छवि को स्क्रीन पर प्रदर्शित किया जा सकता है, या एक ग्राफिक्स फ़ाइल का उत्पादन किया जा सकता है, या आरजीबी मूल्यों की एक सरणी आउटपुट हो सकती है। यदि फ़ाइल या एरे को आउटपुट करते हैं, तो कृपया इसका उदाहरण पोस्ट करें कि यह प्रदर्शित होने पर कैसा दिखता है।
इनपुट के साधन और प्रारूप हमेशा की तरह लचीले होते हैं । एक कार्यक्रम या एक समारोह प्रदान किया जा सकता है । मानक खामियों को मना किया जाता है ।
बाइट्स में सबसे छोटा कोड जीतता है।

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

निम्नलिखित चित्र (पूर्ण संकल्प के लिए क्लिक करें) एन के कई मूल्यों के अनुरूप हैं । एक क्लॉक-वाइज, राइट-फर्स्ट सर्पिल का उपयोग किया जाता है, जैसा कि ऊपर दिए गए उदाहरण में है। चित्र कई वैध रंग मानचित्रों को भी चित्रित करते हैं।

एन = 301:
एन = 501:
एन = 701:

— लुइस मेंडो
स्रोत

अगर s(n)संशोधित किए बिना कुछ प्लॉटिंग फ़ंक्शन / पैकेज में मूल्यों की एक सरणी को खिलाया जा सकता है (मुझे लगता imshowहै कि matplotlib उदाहरण के लिए इसे संभाल सकता है) क्या यह एक स्वीकार्य आउटपुट फॉर्म है?

— डायलाॅन

@dylnan ज़रूर, जब तक यह स्क्रीन पर छवि को प्लॉट करता है या एक फाइल का उत्पादन करता है, यह मान्य है। वास्तव में मैंने कुछ उदाहरणों के साथ उदाहरण प्रस्तुत किए हैं जिनका आप उल्लेख करते हैं। बस मूल्यों के स्केलिंग से सावधान रहें। उदाहरण के लिए यह स्वीकार्य नहीं है यदि 1 से ऊपर के सभी मूल्यों को एक ही रंग दिया जाता है, जैसा कि मैटलैब (और संभवतः मैटलपोटलिब का) imshowकरता है

— लुइस

अच्छी बात। यकीन नहीं imshowहोता अगर ऐसा होता है।

— डायलन

1

@ kamoroso94 कृपया यहाँ

— लुइस

1

हाँ बहुत स्पष्ट

— क्रिस्टोफर

3

डायलॉग एपीएल, 94 बाइट्स

'P2'
2⍴n←⎕
9
(⍪0){×≢⍵:(≢⍺)((⍉∘⌽⍺,↑)∇↓)⍵⋄⍺}2↓{⍵⌊1+⍵[+\p]}⍣≡9×~p←1=⊃+/(≠⍨,≠⍨,~⍴⍨(×⍨n)-2×≢)¨,\×⍳n

मान लिया गया है ⎕IO=0

n = 701 के लिए आउटपुट (.pg से .png में परिवर्तित):

— NGN
स्रोत

10

MATLAB - 197 185 178 175 184 163 162 148 142 140 बाइट्स

12 बाइट्स, एंडर और एंड्रास के लिए धन्यवाद, और दोनों को एक साथ रखने के लिए लुइस के लिए बहुत धन्यवाद। रेवको के लिए 16 धन्यवाद, दोष के लिए 6 धन्यवाद

function F(n)
p=@primes
s=@isprime
for a=2:n^2
c=0
if~s(a)
b=nnz(p(a))
while~s(b)
b=nnz(p(b))
c=c+1
end
end
d(a)=c
end
imagesc(d(spiral(n)))

N=301( F(301)) के लिए परिणाम :

स्पष्टीकरण:

function F(n)
p=@primes % Handle
s=@isprime % Handle
for a=2:n^2 % Loop over all numbers
    c=0 % Set initial count
    if~s(a) % If not a prime
        b=nnz(p(a)) % Count primes
        while~s(b) % Stop if b is a prime. Since the code starts at 2, it never reaches 1 anyway
            b=nnz(p(b)) % count again
            c=c+1 % increase count
        end
    end
    d(a)=c % store count
end
imagesc(d(spiral(n))) % plot

— Adriaan
स्रोत

8

वोल्फ्राम भाषा (गणितज्ञ) , 124 बाइट्स

12 बाइट्स बचाने के लिए मार्टिन एंडर को धन्यवाद !

Image[#/Max@#]&[Array[(n=0;Max[4#2#2-Max[+##,3#2-#],4#
#-{+##,3#-#2}]+1//.x_?CompositeQ:>PrimePi[++n;x];n)&,{#,#},(1-#)/2]]&

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

उत्पन्न छवि है:

सर्पिल मूल्य का क्लोज्ड फॉर्म फॉर्मूला सीधे इस उत्तर से लिया गया है ।

— user202729
स्रोत

5

#/2-.5एक बाइट बचाता है।

— user202729

8

हाहा, क्या आप खुद को सुझाव दे रहे हैं?

— लुइस मेंडो

6

@ user202729 काम करने के लिए प्रतीत नहीं होता है।

— 14:20 पर उपयोगकर्ता 202729

18

मेरा मतलब आपके आंतरिक संवाद को बाधित करना नहीं था :-P

— लुइस मेंडो

pजब तक आपको इसकी आवश्यकता न हो , तब तक परिभाषा दें:...,{y,p=(1-#)/2,-p},{x,p,-p}

— मार्टिन एंडर

7

MATLAB: 115 114 110 बाइट्स

एक लाइनर ( स्क्रिप्ट में फ़ंक्शन के रूप में R2016b + रन ) 115 बाइट्स

I=@(N)imagesc(arrayfun(@(x)s(x,0),spiral(N)));function k=s(n,k);if n>1&~isprime(n);k=s(nnz(primes(n)),k+1);end;end

फ़ंक्शन को एक अलग फ़ाइल में डालना, जैसा कि त्रुटिपूर्ण द्वारा सुझाया गया है, और अतिरिक्त फ़ाइल नियम के अनुसार 1 अतिरिक्त बाइट का उपयोग करना है

फ़ाइल में s.m, कोड + फ़ाइल के लिए 64 + 1 बाइट्स

function k=s(n,k);if n>1&~isprime(n);k=s(nnz(primes(n)),k+1);end

कमांड विंडो को परिभाषित करने के लिए I, 45 बाइट्स

I=@(N)imagesc(arrayfun(@(x)s(x,0),spiral(N)))

कुल: 110 बाइट्स

यह whileअन्य MATLAB कार्यान्वयन ( gnovice , Adriaan ) की तरह लूपिंग के बजाय पुनरावृत्ति का उपयोग करता है । इसे स्क्रिप्ट (R2016b या नए में) के रूप में चलाएं, यह फ़ंक्शन को परिभाषित करता है Iजिसे चलाया जा सकता हैI(n) ।

संरचित संस्करण:

% Anonymous function for use, i.e. I(301)
% Uses arrayfun to avoid for loop, spiral to create spiral!
I=@(N)imagesc(arrayfun(@(x)s(x,0),spiral(N)));

% Function for recursively calculating the s(n) value
function k=s(n,k)
    % Condition for re-iterating. Otherwise return k unchanged
    if n>1 && ~isprime(n)
        % Increment k and re-iterate
        k = s( nnz(primes(n)), k+1 );
    end
end

उदाहरण:

I(301)

टिप्पणियाँ:

मैंने sफ़ंक्शन को भी अनाम बनाने की कोशिश की , निश्चित रूप से इससे गिनती काफी कम हो जाएगी। हालाँकि, 2 मुद्दे हैं:
1. अनाम फ़ंक्शंस का उपयोग करते समय अनंत पुनरावृत्ति से बचना मुश्किल है, क्योंकि MATLAB के पास ब्रेक की स्थिति की पेशकश करने के लिए एक टर्नरी ऑपरेटर नहीं है। एक प्रकार का टर्नरी ऑपरेटर (नीचे देखें) को बोड करना भी बाइट का खर्च करता है क्योंकि हमें दो बार स्थिति की आवश्यकता होती है।
2. यदि आप पुनरावर्ती ( यहां देखें ) जो बाइट जोड़ता है, तो आपको अपने आप को एक अनाम फ़ंक्शन पास करना होगा ।
निकटतम मैं इसके लिए आया था निम्नलिखित पंक्तियों का उपयोग किया, शायद इसे काम करने के लिए बदला जा सकता है:

    % Condition, since we need to use it twice 
    c=@(n)n>1&&~isprime(n);
    % This uses a bodged ternary operator, multiplying the two possible outputs by
    % c(n) and ~c(n) and adding to return effectively only one of them
    % An attempt was made to use &&'s short-circuiting to avoid infinite recursion
    % but this doesn't seem to work!
    S=@(S,n,k)~c(n)*k+c(n)&&S(S,nnz(primes(n)),k+1);

— Wolfie
स्रोत

6

MATLAB - 126 121 ^* बाइट्स

मैंने एड्रियन की तुलना में अधिक वेक्टर दृष्टिकोण का प्रयास किया और अधिक बाइट्स को बंद करने में सक्षम था। यहाँ एकल लाइन समाधान है:

function t(n),M=1:n^2;c=0;i=1;s=@isprime;v=cumsum(s(M));while any(i),i=M>1&~s(M);c=c+i;M(i)=v(M(i));end;imagesc(c(spiral(n)))

और यहाँ अच्छी तरह से स्वरूपित समाधान है:

function t(n),
  M = 1:n^2;
  c = 0;
  i = 1;
  s = @isprime;
  v = cumsum(s(M));
  while any(i),         % *See below
    i = M > 1 & ~s(M);
    c = c+i;
    M(i) = v(M(i));
  end;
  imagesc(c(spiral(n)))

^*नोट: यदि आप अनावश्यक पुनरावृत्तियों के मीट्रिक क्रेपटन की अनुमति देने के इच्छुक हैं, तो आप पंक्ति while any(i), को 5 बाइट्स में बदल सकते हैं और सहेज सकते हैं for m=v, ।

— gnovice
स्रोत

अच्छा! मुझे पसंद है कि आप कैसे cumsumवेक्टर बनाने और बचने के लिए उपयोग करते हैंnnz(primes(...)

— लुइस मेंडो

1

अगर मैं सही ढंग से समझूं, तो यह आवश्यक (गति की लागत पर) से अधिक बार पुनरावृति करने के लिए चोट नहीं करता है। तो आप while any(i)द्वारा प्रतिस्थापित कर सकते हैं for m=M। अगर कोड को चलाने में घंटों लग जाते हैं तो कौन परवाह करता है :-)

— लुइस मेंडो

2

@LuisMendo: ज़रूर, क्यों नहीं? यह पहले से ही जरूरत से ज्यादा एक बार पुनरावृत्ति करता है, क्या एक और n^2या पुनरावृत्तियों चोट लगी है! ;)

— gnovice

1

ये हुई ना बात! आप तेजी से चलने वाले संस्करण को भी रख सकते हैं, लेकिन बाइट की गिनती छोटी है

— लुइस मेंडो

2

पायथन 3, 299 265 बाइट्स

जोनाथन फ्रेच और NoOneIsHere से सुझावों को प्रारूपित करने के लिए 5 बाइट्स का धन्यवाद। केवल एक बार बुलाया गया था जो एक फ़ंक्शन परिभाषा को हटाकर एक अतिरिक्त 34 बाइट्स निकाल दिया।

यह कुछ अन्य लोगों की तुलना में थोड़ा अधिक लंबा है, क्योंकि अजगर को प्रधानता, या एक सर्पिल को निर्धारित करने की कमान नहीं है। यह अपेक्षाकृत जल्दी चलता है, लेकिन एक मिनट के लिएn = 700 ।

from pylab import*
def S(n):
 q=arange(n*n+1);t=ones_like(q)
 for i in q[2:]:t[2*i::i]=0
 c=lambda i:0 if t[i]else 1+c(sum(t[2:i]));S=[c(x)for x in q]
 t=r_[[[S[1]]]]
 while any(array(t.shape)<n):m=t.shape;i=multiply(*m)+1;t=vstack([S[i:i+m[0]],rot90(t)])
 return t

इसके साथ परीक्षण करें

n = 7
x = S(n)
imshow(x, interpolation='none')
colorbar()
show(block=False)

— user2699
स्रोत

1

संभव 294 बाइट्स (अप्रकाशित)।

— जोनाथन फ्रीच

1

एक त्वरित बात: आप importऔर के बीच की जगह को हटा सकते हैं *।

— NoOneIsHere

2

जे, 121 बाइट्स

load 'viewmat'
a=:3 :'viewmat{:@((p:inv@{.,>:@{:)^:(-.@((=1:)+.1&p:)@{.)^:_)@(,0:)"0(,1+(i.@#+>./)@{:)@|:@|.^:(+:<:y),.1'

एक फ़ंक्शन को परिभाषित करता है:

a=:3 :'viewmat{:@((p:inv@{.,>:@{:)^:(-.@((=1:)+.1&p:)@{.)^:_)@(,0:)"0(,1+(i.@#+>./)@{:)@|:@|.^:(+:<:y),.1' | Full fuction
                                                                     (,1+(i.@#+>./)@{:)@|:@|.^:(+:<:y),.1  | Creates the number spiral
              {:@((p:inv@{.,>:@{:)^:(-.@((=1:)+.1&p:)@{.)^:_)@(,0:)"0                                      | Applies S(n) to each element
       viewmat                                                                                             | View the array as an image

— बोलस बूसियर
स्रोत

2

आर, 231 बाइट्स

function(n){p=function(n)sum(!n%%2:n)<2;M=matrix(0,n,n);M[n^2%/%2+cumsum(c(1,head(rep(rep(c(1,-n,-1,n),l=2*n-1),rev(n-seq(n*2-1)%/%2)),-1)))]=sapply(1:(n^2),function(x){y=0;while(x>2&!p(x)){x=sum(sapply(2:x,p));y=y+1};y});image(M)}

थोड़ा कम गोल्फ:

function(n){
    p=function(n)sum(!n%%2:n)<2 #"is.prime" function
    M=matrix(0,n,n)             #empty matrix
    indices=n^2%/%2+cumsum(c(1,head(rep(rep(c(1,-n,-1,n),l=2*n-1),rev(n-seq(n*2-1)%/%2)),-1)))
    values=sapply(1:(n^2),function(x){
        y=0
        while(x>2&!p(x)){
            x=sum(sapply(2:x,p))
            y=y+1
            }
        y})
    M[indices]=values
    image(M) #Plotting
}

अनाम फ़ंक्शन। एक ग्राफिक विंडो में आउटपुट। स्केल लाल पैमाने पर होता है जिसमें सबसे गहरे शेड 0 के बराबर होते हैं और बढ़ते हुए शेड्स साफ होते हैं।

N = 101 के परिणाम:

— plannapus
स्रोत

क्या वर्गाकार पेड़ों की छड़ें अपराधों से उत्पन्न हो सकती हैं?

चरण 1

चरण 2

चरण 3

चुनौती

नियम

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

डायलॉग एपीएल, 94 बाइट्स

MATLAB - 197 185 178 175 184 163 162 148 142 140 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 124 बाइट्स

MATLAB: 115 114 110 बाइट्स

MATLAB - 126 121 * बाइट्स

पायथन 3, 299 265 बाइट्स

जे, 121 बाइट्स

आर, 231 बाइट्स

MATLAB - 126 121 ^* बाइट्स