क्या मैं 'Redivosite' नंबर हूं?

26

Redivosite इस चुनौती के एकमात्र उद्देश्य के लिए आविष्कार किया गया एक पोर्टमंटेउ शब्द है। यह रिडक्शन, डिवीजन और कम्पोजिट का मिश्रण है।

परिभाषा

पूर्णांक N> 6 को देखते हुए :

  • यदि N अभाज्य है, N एक Redivosite Number नहीं है।
  • यदि एन समग्र है:
    • बार-बार की गणना एन '= एन / डी + डी + 1 जब तक एन' प्रधानमंत्री, जहां घ के सबसे छोटे भाजक है एन 1 से अधिक
    • एन एक Redivosite नंबर यदि और केवल यदि का अंतिम मूल्य एन ' का एक भाजक है एन

नीचे 100 पहले Redivosite नंबर (पोस्टिंग के समय कोई OEIS प्रविष्टि) नहीं हैं:

14,42,44,49,66,70,143,153,168,169,176,195,204,260,287,294,322,350,414,462,518,553,572,575,592,629,651,702,726,735,775,806,850,869,889,891,913,950,1014,1023,1027,1071,1118,1173,1177,1197,1221,1235,1254,1260,1302,1364,1403,1430,1441,1554,1598,1610,1615,1628,1650,1673,1683,1687,1690,1703,1710,1736,1771,1840,1957,1974,2046,2067,2139,2196,2231,2254,2257,2288,2310,2318,2353,2392,2409,2432,2480,2522,2544,2635,2640,2650,2652,2684,2717,2758,2760,2784,2822,2835

उदाहरण

  • N = 13 : 13 अभाज्य है, इसलिए 13 एक परिशिष्ट संख्या नहीं है
  • एन = 32 : 32/2 + 3 = 19; 19 एक भाजक या 32 नहीं है, इसलिए 32 एक Redivosite नंबर नहीं है
  • एन = 260 : 260/2 + 3 = 133, 133/7 + 8 = 27, 27/3 + 4 = 13; 13 एक भाजक या 260 है, इसलिए 260 एक Redivosite नंबर है

आपका कार्य

  • एक पूर्णांक N को देखते हुए , एक सत्य मान लौटाएं यदि यह एक Redivosite नंबर या अन्यथा गलत मान है। (आप किसी भी दो अलग-अलग मूल्यों को भी आउटपुट कर सकते हैं, जब तक वे सुसंगत हैं।)
  • इनपुट 6 से बड़ा होने की गारंटी है ।
  • यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!
code-golf  decision-problem  integer  division 
— Arnauld
स्रोत
13
मैं वास्तव में इन सभी "संख्या अनुक्रम" की चुनौतियों का सामना करना चाहता हूं जो कि एक निश्चित संपत्ति के साथ संख्याओं के अनुक्रम हैं बस निर्णय समस्याओं के रूप में पूछा जाएगा। मुझे अत्यधिक संदेह है कि इन्हें सीधे उत्पन्न करने का कोई तरीका है, इसलिए निर्णय समस्या को हल करने के लिए एकमात्र संभव समाधान है और फिर इसे लूप में लपेटें जो एनटीटी या पहले एन या सभी पूर्णांकों को ढूंढता है जो इस संपत्ति को संतुष्ट करते हैं।
— मार्टिन एंडर
3
मुझे अनुक्रम चुनौतियां पसंद हैं जो सामान्य रूप से निर्णय-समस्या नहीं हैं , लेकिन इसके लिए मुझे लगता है कि निर्णय-समस्या एक बेहतर फिट होगी। मुझे इस तरह के शब्दों के बीच कोई संबंध नहीं दिखाई देता है जैसे कि आप एक चालाक तरीके से n वें या पहले n को प्रिंट करते हैं , इसलिए शायद n को इनपुट के रूप में ले सकते हैं और यदि यह फिर से रीडिवोजिट है तो जाँच करें ?
— श्री Xcoder
1
@MartinEnder और Mr.Xcoder मेरा प्रारंभिक उद्देश्य था (इसलिए मूल शीर्षक जिसे मैंने अभी-अभी रोलबैक किया है) और मैंने अपना विचार बदल दिया। मुझे लगता है कि यह किसी भी WIP समाधान को बर्बाद नहीं करना चाहिए (आपके द्वारा कहे गए कारणों के लिए), इसलिए मैंने इसे संपादित किया है।
— अरनुलद
5
@ Mr.Xcoder हाँ, यही मेरा मतलब है। मुझे ऐसी अनुक्रम चुनौतियाँ नहीं हैं जो वास्तव में एक अनुक्रम के रूप में समझ में आती हैं (या तो क्योंकि आप a(n)सीधे गणना कर सकते हैं, या क्योंकि आप अन्य लोगों से एक शब्द की गणना कर सकते हैं)। धन्यवाद, चुनौती बदलने के लिए, अरनौल। :)
— मार्टिन एंडर

जवाबों:

9

हास्केल, 91 85 83 80 75 74 बाइट्स

n#m=([n#(div m d+d+1)|d<-[2..m-1],mod m d<1]++[mod n m<1&&m<n])!!0
f x=x#x

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

f x=x#x                           -- call # with x for both parameters
n#m               
         |d<-[2..m-1],mod m d<1   -- for all divisors d of m
    [n#(div m d+d+1)           ]  -- make a list of recursive calls to #,
                                  -- but with m set to m/d+d+1
   ++ [mod n m<1&&m<n]            -- append the Redivosite-ness of n (m divides n,
                                  -- but is not equal to n)
                           !!0    -- pick the last element of the list
                                  -- -> if there's no d, i.e. m is prime, the
                                  --    Redivosite value is picked, else the
                                  --    result of the call to # with the smallest d

संपादित करें: @ बियू के लिए -2 बाइट्स, @ हविवि के लिए -3 बाइट्स धन्यवाद और -जॉन जोसेन को -5 -6 बाइट्स धन्यवाद

— nimi
स्रोत
2
— अर्जन जोहान्सन
वास्तव में, उस 74
— Ørr जोहान्सन
@ .RjanJohansen: फिर से धन्यवाद।
— nimi
6

भूसी , 14 बाइट्स

?¬Ṡ¦ΩṗoΓ~+→Πpṗ

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

-3 H.PWiz के लिए धन्यवाद ।

— आउटग्रॉफर को एरिक करें
स्रोत
14 क्लीनर के साथ 14 बाइट्सΩ
— H.PWiz
@ H.PWiz बस समझ में नहीं आता है Γ...
— आउटगॉल्फ
यहाँ Γ, एक सूची दी [क, ख, ग ...] लागू होगी ~+→Πकरने के लिए aऔर [b,c...]। ~+→Πको जोड़ता a+1है product[b,c...]। aसबसे छोटा भाजक है, product[b,c...]हैN/d
— H.PWiz
@ H.PWiz और मैंने प्रमुख कारकों का उपयोग करने के बारे में सोचा ...
— 21
6

सी (जीसीसी) , 94 89 बाइट्स

m,n;o(k){for(m=1;m++<k;)if(k%m<1)return m;}
F(N){for(n=N;m=o(n),m-n;n=n/m-~m);N=m<N>N%n;}

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

व्याख्या

m,n;                  // two global integers
o(k){                 // determine k's smallest divisor
 for(m=1;m++<k;)      // loop through integers 2 to n (inclusive)
  if(k%m<1)return m;} // return found divisor
F(N){                 // determine N's redivosity
 for(n=N;             // save N's initial value
  m=o(n),             // calculate n's smallest divisor (no name clash regarding m)
  m-n;                // loop while o(n)!=n, meaning n is not prime
                      //  (if N was prime, the loop will never be entered)
  n=n/m-~m);          // redivosite procedure, empty loop body
 N=m<N>N%n;}          // m<N evaluates to 0 or 1 depending on N being prime,
                      //  N%n==0 determines whether or not N is divisible by n,
                      //  meaning N could be redivosite => m<N&&N%n==0
                      //  <=> m<N&&N%n<1 <=> m<N&&1>N%n <=> (m<N)>N%n <=> m<N>N%n
— जोनाथन फ्रेच
स्रोत
4

जेली , 14 बाइट्स

ÆḌḊ
Ç.ịS‘µÇ¿eÇ

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

यह काम किस प्रकार करता है

ÆḌḊ         Helper link. Argument: k

ÆḌ          Yield k's proper (including 1, but not k) divisors.
  Ḋ         Dequeue; remove the first element (1).


Ç.ịS‘µÇ¿eÇ  Main link. Argument: n

     µ      Combine the links to the left into a chain.
      Ç¿    While the helper link, called with argument n, returns a truthy result,
            i.e., while n is composite, call the chain to the left and update n.
Ç             Call the helper link.
 .ị           At-index 0.5; return the elements at indices 0 (last) and 1 (first).
              This yields [n/d, d].
   S          Take the sum.
    ‘         Increment.
        Ç   Call the helper link on the original value of n.
       e    Test if the result of the while loop belongs to the proper divisors.
— डेनिस
स्रोत
4

पायथन 2 , 97 91 बाइट्स

r=0;e=d=i=input()
while r-e:e=i;r=[j for j in range(2,i+1)if i%j<1][0];i=i/r-~r
d%e<1<d/e<q

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

निर्गम कोड के माध्यम से आउटपुट।

Ungolfed:

r = 0                             # r is the lowest divisor of the current number,
                                  # initialized to 0 for the while loop condition.
e = d = i = input()               # d remains unchanged, e is the current number
                                  # and i is the next number.
while r != e:                     # If the number is equal to its lowest divisor,
                                  # it is prime and we need to end the loop.
    e = i                         # current number := next number
    r = [j for j in range(2, i+1) # List all divisors of the number in the range [2; number + 1)
         if i%j < 1][0]           # and take the first (lowest) one.
    i = i/r+r+1                   # Calculate the next number.
                                  # We now arrived at a prime number.
print d%e == 0 and d != e         # Print True if our current number divides the input
                                  # and is distinct from the input.
                                  # If our current number is equal to the input,
                                  # the input is prime.

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

— OVS
स्रोत
3

05AB1E , 17 16 बाइट्स

[Dp#Òć©sP+>]Ö®p*

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

व्याख्या

[                  # start loop
 Dp#               # break if current value is prime
    Ò              # get prime factors of current value
     ć©            # extract the smallest (d) and store a copy in register
       sP          # take the product of the rest of the factors
         +>        # add the smallest (d) and increment
           ]       # end loop
            Ö      # check if the input is divisible by the resulting prime
             ®p    # check if the last (d) is prime (true for all composite input)
               *   # multiply
— Emigna
स्रोत
2

अजगर , 20 बाइट्स

<P_QiI.WtPHh+/ZKhPZK

यहाँ कोशिश करो!

यह काम किस प्रकार करता है

iI.WtPHh + / ZKhPZK || पूरा कार्यक्रम।

  .W || जबकि क्रियात्मक। यह तर्क, ए और बी के रूप में दो कार्य करता है।
                 || जबकि A (मान) सत्य है, मान को B (मान) में बदल दें। 
                 || प्रारंभिक मूल्य इनपुट है।
    tPH || पहला कार्य, ए। एक ही तर्क देता है, एच।
     PH || .. एच के प्रमुख कारक।
    टी || .. पूंछ (पहले तत्व को हटा दें)। जबकि सत्य (H समग्र है):
       h + / ZKhPZK || दूसरा कार्य, बी एक तर्क देता है, जेड:
         / जेड || .. डिवाइड जेड, द्वारा:
           खाप || .. इसका सबसे कम मुख्य कारक है, और असाइन करें कि के।   
       ज || .. वृद्धि।
        + के || और के।
आईआई || जांचें कि परिणाम (अंतिम मान) इनपुट को विभाजित करता है या नहीं।

और पहले 4 बाइट्स ( <P_Q) सिर्फ यह जांचें कि इनपुट प्राइम नहीं है।

एमिग्ना की मदद से , मैं 3 बाइट्स बचाने में कामयाब रहा।

— श्री एक्सकोडर
स्रोत
क्या आप भाग के head(P)बजाय कुछ का उपयोग कर सकते हैं fiITZ2, क्योंकि 1 से अधिक छोटा भाजक हमेशा प्रधान रहेगा?
— 17
@Emigna Ninja'd, फिक्स्ड और धन्यवाद!
— श्री Xcoder
2

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

def f(N):
	n=N;s=[0]*-~N
	for p in range(2,N):
		if s[p]<1:
			for q in range(p*p,N+1,p):s[q]=s[q]or p
	while s[n]:n=n//s[n]-~s[n]
	return s[N]>1>N%n

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

चलनी दृष्टिकोण का उपयोग करना। O(N log log N)बड़े N(लेकिन O(N)मेमोरी में पूर्णांक संग्रहीत करता है ) के साथ भी तेज होना चाहिए ( एराटोस्थनीज की छलनी का समय जटिलता )

ध्यान दें:

  • यह सिद्ध किया जा सकता है कि सभी मध्यवर्ती मूल्य nअधिक नहीं होते हैं N, और यह विश्वास करने के बजाय N > 7 pहो सकता है ।range(2,N)range(2,N+1)
  • /काम नहीं करता है, //का उपयोग करना चाहिए, क्योंकि सूची सूचकांक।
  • rangeएक और चर में संग्रह करने में मदद नहीं करता है, दुर्भाग्य से।

स्पष्टीकरण:

  • -~N== N+1।
  • सबसे पहले, सरणी sको N+1शून्य से आरंभ किया जाता है (पायथन 0-इंडेक्सिंग है, इसलिए सूचकांक हैं 0..N)
  • प्रारंभ करने के बाद, s[n]होने की उम्मीद है 0अगर nएक प्रमुख है, और pके लिए pकम से कम प्रधानमंत्री जो विभाजित nकरता है, तो nएक समग्र है। s[0]और s[1]मूल्य महत्वपूर्ण नहीं हैं।

  • प्रत्येक pश्रेणी के लिए [2 .. N-1]:

    • यदि s[p] < 1(वह है s[p] == 0), तो pएक अभाज्य है, और प्रत्येक के qलिए एक से अधिक है pऔर s[q] == 0, असाइन करें s[q] = p।

  • अंतिम 2 पंक्तियाँ सीधी हैं, सिवाय इसके कि n//s[n]-~s[n]== (n // s[n]) + s[n] + 1।

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

def f(N):
	n=N;s=[0]*-~N
	for p in range(N,1,-1):s[2*p::p]=(N-p)//p*[p]
	while s[n]:n=n//s[n]-~s[n]
	return s[N]>1>N%n

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

थोड़ा खराब प्रदर्शन की कीमत पर। (यह O(N log N)समय जटिलता में चलता है , पायथन स्लाइस का उचित कार्यान्वयन मानें)

समकक्ष पूर्ण कार्यक्रम 117 बाइट्स है ।

— user202729
स्रोत
आप 149 बाइट के n//s[n]-~s[n]बदले उपयोग कर सकते हैं n//s[n]+s[n]+1।
— मिस्टर एक्सकोडर
@ Mr.Xcoder धन्यवाद!
— user202729
इसके अलावा मुझे लगता है कि or pहो सकता है|p
— श्री Xcoder
@ Mr.Xcoder नहीं, or pतार्किक प्रदर्शन करता है या, जबकि |pबिटवाइज़ या करता है। वह है, a or bहै b if a == 0 else a।
— user202729
आप किसी अन्य के बजाय स्लाइसfor का उपयोगfor करने के लिए बाहरी को संशोधित कर सकते हैं । यह rangeउलटा है, इसलिए निचले सूचकांक बड़े लोगों को अधिलेखित कर देंगे, और 2*pआपके द्वारा टुकड़ा को शुरू करने से प्रतिस्थापित नहीं होगा s[0]या नहीं होगा s[p]।
— रॉड
1

जाप, 25 24 बाइट्स

मुझे डर है कि मैं इसके साथ गलत दिशा में चला गया हूं, लेकिन मैं एक अलग दृष्टिकोण की कोशिश करने के लिए समय से बाहर चला गया हूं।

0झूठे या 1सच्चे के लिए आउटपुट ।

j ?V©vU :ßU/(U=k g)+°UNg

कोशिश करो

— झबरा
स्रोत
0

पर्ल 5 , 291 + 1 (-ए) = 292 बाइट्स

एक मूल प्रधानमंत्री चेकर नहीं होने के लिए डार्ल पर्ल। 

use POSIX;&r($_,$_);
sub p{$n=shift;if($n<=1){return;}if($n==2||$n==3){return 1;}if($n%2==0||$n%3==0){return;}for(5..ceil($n/2)){if($n%$_==0){return;}}return 1;}
sub r{$n=shift;$o=shift;if(&p($n)){print $o%$n==0&&$n!=$o?1:0;last;}for(2..ceil($n/2)){if($n%$_==0){&r(($n/$_)+$_+1, $o);last;}}}

अनगुल्ड संस्करण,

use POSIX;
&r($_,$_);
sub p{
    my $n=shift;
    if($n<=1){
        return;
    }
    if($n==2||$n==3){
        return 1;
    }
    if($n%2==0||$n%3==0){
        return;
    }
    for(5..ceil($n/2)){
        if($n%$_==0){
            return;
        }
    }
    return 1;
}
sub r{
    my $n=shift;
    my $o=shift;
    if(&p($n)){
        print $o%$n==0&&$n!=$o ? 1 : 0;
        last;
    }
    for(2..ceil($n/2)){
        if($n%$_==0){
            &r(($n/$_)+$_+1, $o);
            last;
        }
    }
}

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

— जेफ्री एच।
स्रोत
0

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

पुनरावर्ती पैटर्न प्रतिस्थापन का उपयोग करके सीधा कार्यान्वयन

("es" प्रतीक के साथ "\" डिवाइसेस को प्रतिस्थापित करने से 7 बाइट्स बचते हैं)

(g=!PrimeQ@#&)@#&&(#//.x_/;g@x:>x/(c=Divisors[x][[2]])+c+1)\[Divides]#&

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

— केली लोवदर
स्रोत
0

जे , 35 बाइट्स

(~:*0=|~)(1+d+]%d=.0{q:)^:(0&p:)^:_

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

पहला प्राइम फैक्टर होने वाला न्यूनतम विभाजक @ डेनिस जेली समाधान (पहले मैं उपयोग कर रहा था <./@q:) से चुराया गया था ।

पुनरावृत्ति करने का एक बेहतर तरीका होना चाहिए, लेकिन मैं इसे ढूंढ नहीं सकता। मैंने प्रायोगिक परीक्षण ( ^:(0&p:)) करने से बचने के बारे में सोचा और इसके बजाय प्रतिकूल का उपयोग किया, लेकिन ऐसा लगता है कि थोड़ा लंबा हो जाएगा क्योंकि आपको एक _2{और कुछ बदलावों की आवश्यकता होगी जो शुद्ध कमी नहीं दे सकते हैं।

मैं वास्तव में महसूस करता हूं कि मौलिकता की जांच के आसपास भी परेसान होने से बचने का एक तरीका होना चाहिए।

स्पष्टीकरण (विस्तारित)

(~: * 0 = |~)(1 + d + ] % d =. 0 { q:) ^: (0&p:) ^:_ Input: N
             (1 + d + ] % d =. 0 { q:) ^: (0&p:) ^:_ Find the final N'
                                       ^:        ^:_  Do while
                                           0&p:       N is not prime
                                   q:                 Get prime factors (in order)
                               0 {                    Take first (smallest divisor)
                          d =.                        Assign this value to d
             1 + d + ] %  d                           Compute (N/d) + 1 + d
(~: * 0 = |~)                                        Is it redivosite?
      0 = |~                                          N = 0 (mod N'), i.e. N'|N
    *                                                 And
 ~:                                                   N =/= N', i.e. N is not prime
— गोभी
स्रोत
0

एपीएल नार, 43 चार्ट, 85 बाइट्स

{(⍵≤6)∨0π⍵:0⋄⍵{1=⍴t←π⍵:0=⍵|⍺⋄⍺∇1+↑t+⍵÷↑t}⍵}

(उम्मीद है कि यह सभी नंबर> 6 के लिए अभिसरण) परीक्षण:

h←{(⍵≤6)∨0π⍵:0⋄⍵{1=⍴t←π⍵:0=⍵|⍺⋄⍺∇1+↑t+⍵÷↑t}⍵}
v←⍳100     
v,¨h¨v
   1 0  2 0  3 0  4 0  5 0  6 0  7 0  8 0  9 0  10 0  11 0
   12 0  13 0  14 1  15 0  16 0  17 0  18 0  19 0  20 0  
   21 0  22 0  23 0  24 0  25 0  26 0  27 0  28 0  29 0  
   30 0  31 0  32 0  33 0  34 0  35 0  36 0  37 0  38 0  
   39 0  40 0  41 0  42 1  43 0  44 1  45 0  46 0  47 0  
   48 0  49 1  50 0  51 0  52 0  53 0  54 0  55 0  56 0  
   57 0  58 0  59 0  60 0  61 0  62 0  63 0  64 0  65 0  
   66 1  67 0  68 0  69 0  70 1  71 0  72 0  73 0  74 0  
   75 0  76 0  77 0  78 0  79 0  80 0  81 0  82 0  83 0  
   84 0  85 0  86 0  87 0  88 0  89 0  90 0  91 0  92 0  
   93 0  94 0  95 0  96 0  97 0  98 0  99 0  100 0

2 अनाम फ़ंक्शंस का उपयोग करने का विचार मुझे अन्य Apl समाधान के लिए मिलता है।

 {(⍵≤60)∨π⍵:0⋄ -- if arg ⍵ is prime or <=6 return 0
  ⍵{1=⍴t←π⍵:0=⍵|⍺⋄ -- if list of factors ⍵ has length 1 (it is prime)
                    -- then return ⍺mod⍵==0
  ⍺∇1+↑t+⍵÷↑t}⍵}   -- else recall this function with args ⍺ and 1+↑t+⍵÷↑t
— RosLuP
स्रोत
0

पाइट , 44 बाइट्स

←⁻0`ŕ⁺ĐĐϼ↓Đ3Ș⇹÷+⁺Đṗ¬⇹⁻⇹łŕáĐ0⦋Đ↔ĐŁ⁻⦋⁺|¬⇹ṗ⇹3Ș⊽

स्पष्टीकरण के लिए नीचे दिए गए कोड को देखें - केवल अंतर (1) हैं जो एन लूप की शुरुआत में वेतन वृद्धि के लिए खाते से पहले घटाया जाता है, और (2) यह OR के बजाय NOR का उपयोग करता है।

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


मैंने प्रश्न को फिर से पढ़ने से पहले इसे बनाया और देखा कि यह केवल एक सच्चा / झूठ चाहता था।

पाइट, 52 बाइट्स

60`ŕ⁺ĐĐϼ↓Đ3Ș⇹÷+⁺Đṗ¬⇹⁻⇹łŕáĐ0⦋Đ↔ĐŁ⁻⦋⁺|¬⇹Đṗ⇹3Ș∨ł⇹Đƥ⇹ŕ1ł

Redivosite संख्याओं की एक अनंत सूची प्रिंट करता है।

स्पष्टीकरण:

6                                                            Push 6
 0                                                           Push unused character
  `                   ł                     ł      ł         Return point for all three loops
   ŕ                                                         Remove top of stack
    ⁺                                                        Increment top of stack (n)
     ĐĐ                                                      Triplicate top of stack (n)
       ϼ↓                                                    Get smallest prime factor of n (returns 1 if n is prime) 
         Đ                                                   Duplicate top of stack
          3Ș⇹                                                Manipulate stack so that the top is (in descending order): [d,(N,N'),d]
             ÷+⁺                                             Calculates N'=(N,N')/d+d+1
                Đṗ¬                                          Is N' not prime?
                   ⇹⁻⇹                                       Decrement N' (so the increment at the beginning doesn't change the value), and keep the boolean on top - end of innermost loop (it loops if top of stack is true)
                       ŕ                                     Remove top of stack
                        á                                    Convert stack to array
                         Đ                                   Duplicate array
                          0⦋Đ                                Get the first element (N)
                             ↔ĐŁ⁻⦋                           Get the last element ((final N')-1)
                                  ⁺                          Increment to get (final N')
                                   |¬                        Does N' not divide N?
                                     ⇹Đṗ                     Is N prime?
                                        ⇹3Ș∨                 Is N prime or does N' not divide N? - end of second loop (loops if top of stack is true)
                                             ⇹Đƥ⇹ŕ           Print N, and reduce stack to [N]
                                                  1          Push garbage (pushes 1 so that the outermost loop does not terminate)


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

— mudkip201
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.