यदि एक धनात्मक पूर्णांक पास उसके उत्तराधिकारी और उसके पूर्ववर्ती की तुलना में कम (सख्ती से) प्रमुख कारक (गिनती गुणा किए बिना) हैं, तो हम इसे एक कारक-घटिया संख्या कहेंगे । $N > 2$

दूसरे शब्दों में, और , जहां की अनूठी प्रधानमंत्री कारकों की संख्या है । $\omega(N) < \omega(N - 1)$ $\omega(N) < \omega(N + 1)$ $\omega(N)$ $N$

कार्य

आप निम्नलिखित I / O प्रारूपों में से किसी एक को चुन सकते हैं:

पूर्णांक लें और फ़ैक्टर-घटिया संख्या आउटपुट करें । यदि आप इसे चुनते हैं, तो या तो 0 या 1 अनुक्रमित हो सकता है। $N$ $N^{\text{th}}$ $N$
एक सकारात्मक पूर्णांक लें और पहले फ़ैक्टर-घटिया संख्याओं का उत्पादन करें । $N$ $N$
अनुक्रम को अनिश्चित काल के लिए प्रिंट करें।

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

मैं अलग-अलग परीक्षण मामलों को शामिल नहीं करूंगा, क्योंकि प्रतिस्पर्धा के तरीके अलग-अलग हैं, लेकिन आप इस अनुक्रम के पहले 100 शब्दों का उल्लेख कर सकते हैं, जो कि OEIS A101934 है :

11, 13, 19, 23, 25, 27, 29, 37, 41, 43, 47, 49, 53, 59, 61, 64, 67, 71, 73, 79, 81, 83, 89, 97, 101, 103, 107, 109, 113, 121, 125, 131, 137, 139, 149, 151, 155, 157, 163, 167, 169, 173, 179, 181, 191, 193, 197, 199, 211, 221, 223, 227, 229, 233, 239, 241, 243, 251, 259, 263, 265, 269, 271, 277, 281, 283, 289, 293, 307, 309, 311, 313, 317, 331, 337, 341, 343, 347, 349, 353, 359, 361, 365, 367, 371, 373, 379, 383, 389, 397, 401, 407, 409, 419, 421, 431, 433, 439, 441, 443

एक उदाहरण के रूप में, इस क्रम में होता है क्योंकि (5), (2 और 13) और (2 और 3), so और । $25$ $\omega(25) = 1$ $\omega(26) = 2$ $\omega(24) = 2$ $\omega(25) < \omega(24)$ $\omega(25) < \omega(26)$

— श्री Xcoder
स्रोत

क्या मैं n = प्रत्येक मूल्य से पहले एक अग्रणी उत्पादन कर सकता हूं ?

— स्टेडीबॉक्स

@Steadybox Sketchy, लेकिन मैं इसकी अनुमति दूंगा: - /

— श्री Xcoder 12

मैंने इसे एक वैकल्पिक संस्करण के रूप में जोड़ा।

— स्टेडीबॉक्स

7

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

⟨+₁≡-₁⟩{ḋdl}ᵐ⌋>~↰₂?ẉ⊥

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

प्रिंट असीम।

व्याख्या

⟨+₁≡-₁⟩                  Fork: The output of the fork is [Input + 1, Input -1]
       {   }ᵐ            Map:
        ḋdl                (predicate 2) the output is the length of the prime decomposition
                           of the input with no duplicates
             ⌋           Take the minimum result of that map
              >          This minimum is bigger than…
               ~↰₂?      …the output of predicate 2 with Input as input
                  ?ẉ     Write Input followed by a new line if that's the case
                    ⊥    False: backtrack and try another value for Input

— Fatalize
स्रोत

5

जेली , 13 12 बाइट्स

Cr~ÆvÐṂN⁼Wø#

पहले n कारक-गरीब संख्या प्रिंट करता है ।

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

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

Cr~ÆvÐṂN⁼Wø#  Main link. No arguments.

          ø   Wrap the links to the left into a chain and begin a new chain.
           #  Read an integer n from STDIN and call the chain to the left with
              arguments k = 0, 1, 2, ... until n of them return a truthy value.
              Return those n values of k as an array.
C                 Complement; yield -k+1.
  ~               Bitwise NOT; yield -k-1.
 r                Range; yield [-k+1, -k, -k-1].
     ÐṂ           Yield those elements of [-k+1, -k, -k-1] for which the link to
                  the left returns the minimal value.
   Æv                 Count the number of unique prime factors.
                      Note that, for a negative argument, Æv counts -1 as well, and
                      0 is counted as a/the factor of 0. Negating the the arguments
                      eliminates the edge case 1 (no factors), which would be a
                      false positive otherwise.
                  For a factor-poor number, this yields [-k].
       N          Take the negatives of the resulting integers.
         W        Wrap; yield [k].
        ⁼         Test the results to both sides for equality.

— डेनिस
स्रोत

5

पायथन 2 , 123 119 बाइट्स

q=lambda n:sum(n%i<all(i%j for j in range(2,i))for i in range(2,n+1))
i=2
while 1:
 i+=1
 if q(i-1)>q(i)<q(i+1):print i

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

— छड़ी
स्रोत

@FryAmTheEggman धन्यवाद! यहां तक कि मैंने आपके सुझाव का उपयोग नहीं किया, इसने मुझे एक और दृष्टिकोण पर प्रेरित किया जिसने 4 बाइट्स बचाए: D

— Rod

अच्छा! मुझे यकीन था कि दो बदसूरत

— मेमनों

4

MATL , 26 24 22 बाइट्स

`T@3:q+YFg!sdZSd0>?@QD

अनुक्रम को अनिश्चित काल के लिए प्रिंट करता है।

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

व्याख्या

`         % Do...while loop
  T       %   Push true. Will be used as loop condition
  @       %   Push (1-based) iteration index, k 
  3:q     %   Push [1 2 3] minus 1, that is, [0 1 2]
  +       %   Add, element-wise. Gives [k k+1 k+2]
  YF      %   Exponents of prime-factor decomposition. Gives a 3-row matrix
  g       %   Convert to logical: non-zero numbers become 1
  !s      %   Transpose, sum of each column. Gives a row vector of 3 elements, 
          %   which are the number of unique prime factors of k, k+1 and k+2 
  d       %   Consecutive differences. Gives a row vector of 2 elements
  ZS      %   Sign: replaces each number by -1, 0 or 1
  d       %   Consecutive difference. Gives a single number
  0>      %   Is it positive?
  ?       %   If so
    @Q    %     Push k+1
    D     %     Display
          %   End (implicit)
          % End (implicit). The stack contains true, which (is consumed and)
          % causes an infinite loop

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

3

हस्क , 22 बाइट्स

f(ΠtSM<←ṙ1mȯLup§…←→)tN

अनुक्रम को अनिश्चित काल तक प्रिंट करता है, इसे ऑनलाइन आज़माएं या पहले N को देखें !

इसके बजाय वैकल्पिक रूप §oΛ>←t से इस्तेमाल किया जा सकता है ΠtSM<←।

व्याख्या

f(                  )tN  -- filter the tail of the naturals ([2,3…]) by:
  ΠtSM<←ṙ1m(Lup)§…←→     -- | takes a number as argument, example 11
                §…       -- | range of..
                  ←      -- | | the argument decremented (10)
                   →     -- | | to the argument incremented (12)
                         -- | : [10,11,12]
          m(   )         -- | map the following (example on 12) ..
              p          -- | | prime factors: [2,2,3]
             u           -- | | deduplicate: [2,3]
            L            -- | | length: 2
                         -- | : [2,1,2]
        ṙ1               -- | rotate by 1: [1,2,2]
    SM<                  -- | map the function (< X) over the list where X is ..
       ←                 -- | | the first element (1)
                         -- | : [0,1,1]
   t                     -- | tail: [1,1]
  Π                      -- | product: 1
                         -- : [11,13,19,23,25,27,29…

— ბიმო
स्रोत

3

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

.f!-.ml{Pb}tZh

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

यह शुरू में डोप्प के उत्तर पर एक सुझाव था , लेकिन उन्होंने मुझे इसे अलग से पोस्ट करने के लिए कहा ।

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

.f।! - ml। {Pb} tZh | पूरा कार्यक्रम। STDIN से इनपुट लेता है, पहले N को STDOUT में आउटपुट करता है।

.f | (var: Z) पहले N मान को आउटपुट करता है जो विधेय को संतुष्ट करता है।
          } tZh | सूची बनाता है [Z - 1, Z, Z + 1]।
    .म | (var: b) तत्वों को न्यूनतम फ़ंक्शन मान के साथ लें।
        Pb | बी के प्रमुख कारक।
      l {| डेडुप्लिकेट, लंबाई प्राप्त करें।
               | एक कारक-घटिया संख्या के लिए, यह खुद को एक सिंगलटन में लपेटता है।
   - | उससे Z हटाओ।
  ! | तार्किक नकार।

— श्री Xcoder
स्रोत

3

हास्केल, 105 86 बाइट्स

19 बाइट्स बचाने के लिए @Wheat जादूगर, @ ब्रूस फोर्ट, और @ लिकोनी का धन्यवाद।

[n|n<-[2..],d n<d(n-1),d n<d(n+1)] d x=[1|n<-[1..x],x`rem`n<1,all((>0).rem n)[2..n-1]]

— Enderperson1010
स्रोत

का उपयोग करते समय rem ==0और /=0साथ relaced किया जा सकता है <1और >0क्रमशः।

— गेहूं जादूगर

इसके लिए कोई ज़रूरत नहीं है let, dसहायक फ़ंक्शन के रूप में परिभाषित करना ठीक है ( गोल्फिंग नियमों के लिए मार्गदर्शिका देखें )। इसके अलावा sumछोड़ा जा सकता है, तुलना सूचियों पर समान काम करती है। 86 बाइट्स: इसे ऑनलाइन आज़माएं!

— लकोनी

2

ऑक्टेव , 87 83 79 बाइट्स

एक बाइट को बचाने के लिए @Cows के लिए धन्यवाद और ~~तीन~~ छह बाइट बचाने के लिए @Luis मेंडो के लिए धन्यवाद !

f=@(n)nnz(unique(factor(n)));n=9;while++n if[f(n-1) f(n+1)]>f(n)disp(n);end;end

अनुक्रम को अनिश्चित काल के लिए प्रिंट करता है।

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

n =प्रत्येक मूल्य से पहले अग्रणी के साथ 73 बाइट्स :

f=@(n)nnz(unique(factor(n)));n=9;while++n if[f(n-1) f(n+1)]>f(n)n end;end

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

— Steadybox
स्रोत

मुझे लगता है कि फ़ंक्शन एक कम बाइट के लिए fबन सकता है f=@(n)length(unique(factor(n)))।

— कृतिका लिथोस

2

05AB1E , 14 13 बाइट्स

Nth कारक-खराब संख्या (1-अनुक्रमित) को आउटपुट करता है

µ3LN+Íf€gÀć›P

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

व्याख्या

µ                 # loop over N (1,2,3, ...) until counter equals input
 3L               # push the range [1,2,3]
   N+             # add current N
     Í            # subtract 2
      f           # get unique prime factors of each
       €g         # get length of each factor list
         À        # rotate left
          ć       # extract the head
           ›      # check if the remaining elements are strictly greater
            P     # product
                  # if 1, increment counter
                  # implicitly output final N

— Emigna
स्रोत

1

मैं बस के बारे में सुझाव के लिए स्विचन था µ, इसलिए मुझे लगता है कि मैं सिर्फ अपने विकल्प को इंगित करने जा रहा हूँ - N<N>Ÿस्थानापन्न कर सकते हैं 3LN+Í, अगर यह मदद करता है।

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

@ Mr.Xcoder: इसी तरह, ®XŸN+यह भी काम करता है। या 0®X)N+किस मामले में Àजरूरत नहीं होगी। दुर्भाग्य से वे सभी एक ही बाइट काउंट पर समाप्त होते हैं।

— 13

1

अजगर, ३० 25 बाइट्स

#=hTI&>l{PhTKl{PT>l{PtTKT

ये मेरा पहला है असली पायथ गोल्फ है, इसलिए किसी भी टिप्पणी की बहुत सराहना की जाती है।

Xcoder के लिए एक बड़ा धन्यवाद!

व्याख्या

#                         | Loop until error
 =hT                      | Add one to T (initially 10)
    I&                    | If both...
      >l{PhTKl{PT         | The number of unique prime factors of T+1 is greater than that of T (store in K) 
                 >l{PtTK  | And the number of unique prime factors of T-1 is greater than K (from before)
                        T | Then implicitly print T

TIO ।

— डैनियल
स्रोत

14 बाइट्स: .f!-.ml{Pb}tZh(प्रिंट पहले एन) ( .fपहले पुन: प्राप्त करता n मूल्यों उस पर एक शर्त को पूरा [1,2,3,...]और एक चर का उपयोग करता है Z, }tZhपूर्णांक रेंज उत्पन्न करता है [Z - 1 ... Z + 1], .m(के साथ कम से कम समारोह मूल्य के साथ तत्वों की सूची वापसी b), l{Pbअलग divisors की गिनती हो जाता है, -छोड देता है Zसूची से, !तार्किक निषेध लागू होता है)

— श्री Xcoder

1

@ Mr.Xcoder, वाह मुझे नहीं लगता कि मैंने कभी भी जल्द ही मिल गया होगा! क्या आप यह नहीं कहेंगे कि यह अपने स्वयं के उत्तर का गुण है?

— डैनियल

@ डोप्प्प ओके तो, मैंने इसे अलग से पोस्ट किया । Pyth गोल्फिंग में आपका स्वागत है!

— श्री Xcoder

अपने दृष्टिकोण का उपयोग कर 25 बाइट्स ।

— मिस्टर एक्सकोडर

नहीं। hहै +1, tहै -1जबकि, Kएक चर जो बिना सौंप दिया जाता है है =। उदाहरण के लिए, K4असाइन करता Kहै 4। इसके बाद आप इसका उपयोग कर सकते हैं K।

— मिस्टर एक्सकोडर

1

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

0-अनुक्रमित Nth कारक-खराब संख्या देता है।

f=(i,n=9)=>(P=(n,i=k=1)=>++k>n?0:n%k?P(n,1):i+P(n/k--,0))(n)>P(++n)&P(n)<P(n+1)&&!i--?n:f(i,n)

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

कैसे?

हम पहले P () फ़ंक्शन को परिभाषित करते हैं जो किसी दिए गए पूर्णांक के अद्वितीय प्रमुख कारकों की संख्या देता है।

P = (                   // P = recursive function taking:
  n,                    //   n = input number to test
  i =                   //   i = flag to increment the number of prime factors
  k = 1                 //   k = current divisor
) =>                    //
  ++k > n ?             // increment k; if k is greater than n:
    0                   //   stop recursion
  :                     // else:
    n % k ?             //   if k is not a divisor of n:
      P(n, 1)           //     do a recursive call with n unchanged and i = 1
    :                   //   else:
      i +               //     add i and
      P(n / k--, 0)     //     do a recursive call with n / k and i = 0; decrement k

रैपिंग कोड अब इस प्रकार है:

f = (                   // given:
  i,                    //   i = input index
  n = 9                 //   n = counter
) =>                    //
  P(n) > P(++n) &       // increment n; if P(n - 1) is greater than P(n)
  P(n) < P(n + 1) &&    // and P(n) is less than P(n + 1)
  !i-- ?                // and we have reached the correct index:
    n                   //   return n
  :                     // else:
    f(i, n)             //   go on with the next value

— Arnauld
स्रोत

1

जाप , 29 27 26 बाइट

इस पर पूरी तरह से खुश नहीं है, लेकिन कम से कम यह मेरे पहले प्रयास से बेहतर है जो 40 बाइट्स से अधिक था!

Nअनुक्रम में वें संख्या को आउटपुट करता है , 1-अनुक्रमित।

È=Jõ_+X k â ÊÃé)e>Xo)«´U}a

कोशिश करो

व्याख्या

पूर्णांक का निहित इनपुट U।

È                       }a

Xनिम्नलिखित फ़ंक्शन से गुजरने पर पहला पूर्णांक लौटाएं जो सही आए।

=Jõ             )

सरणी [-1,0,1]को असाइन करें X।

 _+X      Ã

उस सरणी के प्रत्येक तत्व को एक फ़ंक्शन के माध्यम से पास करें जो सबसे पहले वर्तमान मूल्य को जोड़ता है X।

k â Ê

परिणाम की लंबाई ( Ê) अद्वितीय ( â) प्रमुख कारक ( k) प्राप्त करें।

é

परिणामस्वरूप सरणी को दाईं ओर घुमाएं।

e>Xo)

पॉप ( o) अंतिम तत्व से Xऔर जाँच करें कि क्या सभी शेष तत्व इससे अधिक हैं।

«´U

यदि हां, तो गिरावट Uऔर जाँच करें कि क्या यह 0 के बराबर है।

— झबरा
स्रोत

1

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

n,g=9,lambda m,k=2,p=1:m//k and(m%k<p%k)+g(m,k+1,p*k*k)
while 1:n+=1;g(n-1)>g(n)<g(n+1)!=print(n)

सिद्धांत रूप में, यह अनुक्रम को अनिश्चित काल तक प्रिंट करता है। प्रयोग में,g अंततः पुनरावृत्ति सीमा से अधिक है।

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

— डेनिस
स्रोत

1

सी (जीसीसी) , 126 बाइट्स

j,t;o(n){for(j=t=0;j++<n;)if(n%j<1)for(t--;j>1>n%j;)n/=j;t=~t;}
m(J){for(J=3;;J++)if(o(J-1)>o(J)&o(J)<o(J+1))printf("%d,",J);}

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

— जोनाथन फ्रेच
स्रोत

0

क्लीन , 130 123 117 बाइट्स

import StdEnv
?n=[1\\q<-[p\\p<-[2..n]|and[gcd p i<2\\i<-[2..p-1]]]|n rem q<1]
f=[n\\n<-[3..]| ?n<min(?(n-1))(?(n+1))]

अनुक्रम की शर्तों की एक अनंत संख्या के बराबर है। चूँकि यह सभी नेस्टेड कॉम्प्रिहेंशन है, इसलिए यह ग्राफ़ की कमी का बहुत अच्छी तरह से फायदा नहीं उठा सकता है और इसलिए यह इतने बुरे एल्गोरिथम के लिए भी काफी धीमा है।

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

— Οurous
स्रोत

0

APL NARS, 124 बाइट्स, 62 वर्ण

{(⍵>1E4)∨⍵≤0:¯1⋄x←9+⍳10×⍵⋄⍵↑(∊{v←⍴∘∪∘π¨⍵+2-⍳3⋄2=+/v>2⌷v}¨x)/x}

इसे 1E4 तक जवाब देना चाहिए, फिर -1 एरर लौटाएं; यह मान लें कि 9..10xgugument में पर्याप्त संख्याएं हैं; परीक्षा:

  z←{(⍵>1E4)∨⍵≤0:¯1⋄x←9+⍳10×⍵⋄⍵↑(∊{v←⍴∘∪∘π¨⍵+2-⍳3⋄2=+/v>2⌷v}¨x)/x}  
  z 0
¯1
  z 1
11 
  z 20
11 13 19 23 25 27 29 37 41 43 47 49 53 59 61 64 67 71 73 79

— RosLuP
स्रोत

4

लगभग 150 बाइट्स?

— झबरा

@ शैगी हाँ यह एक अनुमानित मूल्य था; लेकिन + - यह एक गोल्फ के लिए सही है ...

— RosLuP

मेरी गिनती से स्कोर यहाँ 147 बाइट्स है, 152 नहीं (वर्णों की संख्या अप्रासंगिक है)। आगे पढ़े: codegolf.meta.stackexchange.com/q/9428/58974

— झबरा

@ नंबर १५२ एक फाइल के बाइट्स में आकार होगा जिसमें केवल वह कोड होता है (कॉपी अतीत, उस कोड को एक नोटपैड (विंडो) डॉक्यूमेंट में सेव करें और उस फाइल की "प्रॉपर्टी" देखें)

— RosLuP

यही नहीं हम यहां बाइट्स की गिनती करते हैं।

— झबरा