प्रधान या सर्वोच्च कारक


14

चुनौती:

गैर नकारात्मक पूरे संबंधी आंकड़े की एक सरणी को देखते हुए की रेंज में0 to Infinity , चेक उन सभी को अभाज्य हैं या नहीं। (आप चाहें तो इनपुट को एक स्ट्रिंग के रूप में भी ले सकते हैं)

इनपुट:

इनपुट: संख्याओं की एक सरणी

आउटपुट: इनमें से प्रत्येक द्वारा प्रतिस्थापित प्रत्येक तत्व के साथ सरणी:

-1                 -----> If 0, 1
1                  -----> If it is a prime number greater than 1
the highest factor -----> If that number is not prime

-1 (0, 1), 1 (primes> = 2) या दिए गए नंबर का उच्चतम कारक (गैर-primes के लिए) लौटें

उदाहरण:

[1, 2, 3, 4, 10, 11, 13]                        ---> [-1, 1, 1, 2, 5, 1, 1]
[100, 200, 231321, 12312, 0, 111381209, 123123] ---> [50, 100, 77107, 6156, -1, 1, 41041]

ध्यान दें:

इनपुट हमेशा मान्य होगा, अर्थात इसमें केवल संख्याएँ होंगी और दशमलवों का परीक्षण नहीं किया जाएगा। सरणी खाली हो सकती है, यदि हां, तो खाली सरणी लौटाएं।

प्रतिबंध:

यह प्रत्येक भाषा की जीत के लिए बाइट्स में इतना छोटा कोड है।

लीडरबोर्ड:

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक स्कोर अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes


2
मैं भविष्य के प्रश्नों के लिए सैंडबॉक्स का उपयोग करने की अत्यधिक सलाह देता हूं , उन्हें पोस्ट करने से पहले प्रश्नों पर प्रतिक्रिया प्रदान करने के लिए
जो किंग

@ जॉकिंग: अनंत के लिए आपको अनंत तक सभी संख्याओं का उत्पादन करना चाहिए। यह सिर्फ आपके लिए है और आपको यह भी सुनिश्चित करना होगा कि यह समय या कुछ भी नहीं है। JK: टाइम आउट एरर सबसे अधिक संभावित चीज है जो आपको अनंत के लिए

4
बस यह नोट करना चाहता था कि "यदि यह 1 से अधिक अभाज्य संख्या है" 1 से अधिक वास्तव में आवश्यक नहीं है क्योंकि अभाज्य संख्याएँ हमेशा 1 से अधिक होती हैं
इवो ​​बेकर्स

5
उच्चतम कारक को परिभाषित करें। क्या मुझे खुद नंबर लौटाना चाहिए? सर्वोच्च विभाज्य प्रधान? उच्चतम कारक जो स्वयं नहीं है?
निसा

2
मुझे लगता है कि हमारे कार्यक्रम केवल हमारे चुने हुए भाषा के अधिकतम पूर्णांक आकार तक (उन लोगों के लिए जो मनमाने ढंग से बड़े पूर्णांक के लिए समर्थन नहीं करते हैं) के लिए काम करने के लिए आवश्यक हैं
JDL

जवाबों:


9

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

ÆḌṪ€o-

एक नकारात्मक लिंक जो गैर-नकारात्मक पूर्णांक की एक सूची को स्वीकार करता है और -1 से अधिक या उसके बराबर पूर्णांक की सूची को पुन: प्राप्त करता है।

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

कैसे?

ध्यान दें कि:

  • सभी अपराधों में एक ही उचित भाजक (एक) है
  • सभी कंपोजिट में कई उचित भाजक हैं (एक से अधिक अन्य)
  • किसी भी संख्या के पास अपने आप में एक उचित भाजक नहीं है
  • जेली के उचित-विभाजक परमाणु, ÆḌबढ़ते क्रम में उचित भाजक की सूची प्राप्त करते हैं
  • शून्य और किसी के पास कोई उचित भाजक नहीं है (वे न तो प्रधान हैं, न ही समग्र)
  • एक खाली सूची में, जेली की पूंछ परमाणु को लागू करने से शून्य प्राप्त होता है
  • किसी भी संख्या में शून्य का एक उचित भाजक नहीं है (अकेले अधिकतम होने दें)
  • जेली में सभी गैर-शून्य नंबर सत्य हैं, जबकि शून्य गलत है

ÆḌṪ€o- | Link: list of integers   e.g. [ 0, 1,  2,  5,     10,    5183]
ÆḌ     | proper divisors (vectorises)  [[],[],[1],[1],[1,2,5],[1,71,73]]
  Ṫ€   | tail €ach                     [ 0, 0,  1,  1,      5,      73]
     - | literal minus one
    o  | logical OR (vectorises)       [-1,-1,  1,  1,      5,      73]

8

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

@Dennis के लिए 1 बाइट का धन्यवाद सहेजा गया

:ÆfṂ€$~~

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को चलाएं

टिप्पणी की गई

हम इस तथ्य का लाभ उठाते हैं कि दोनों nanऔर जेली में infहो जाते हैं 0जब एक बिटवाइज़ उन पर लागू नहीं होता है।

:ÆfṂ€$~~ - main link, taking the input list
 ÆfṂ€$   - treat these two links as a monad:
 Æf      -   get the lists of prime factors (0 --> 0; 1 --> empty list; prime --> itself)
    €    -   for each list,
   Ṃ     -   isolate the minimum prime factor (turns empty lists into 0)
:        - divide each entry by its minimum prime factor (0/0 --> nan; 1/0 --> inf)
      ~~ - bitwise NOT x2 (nan or inf --> 0 --> -1; other entries are unchanged)

3
आपने इस समय जावास्क्रिप्ट का उपयोग नहीं किया? अच्छा उत्तर btw

3
मैं वास्तव में पसंद है ~~:ÆfṂ€$~~सहायक लिंक को समाप्त करके एक बाइट बचाता है।
डेनिस

@ डेनिस आह! $जिसकी मुझे तलाश थी वह है। :) धन्यवाद!
अरनौलड

7

आर, 68 62 बाइट्स

Map(function(n,v=rev(which(!n%%1:n)))"if"(n<2,-1,v[2]),scan())

केवल आधार आर, कोई पुस्तकालयों का उपयोग कर एक समाधान! 6 बाइट्स दूर करने के लिए Giuseppe का धन्यवाद।

scanअंतरिक्ष की अलग से सूची में पढ़ने के लिए उपयोग करता है, %%यह पहचानने के लिए कि कौन से कारक हैं। vतब आरोही क्रम (1 और n सहित) में सभी कारकों का एक वेक्टर होता है। यह अच्छा संपत्ति है कि जब हम है revERSE vकरने के लिए, संख्या हम चाहते हैं दूसरे स्थान पर होगा, एक महंगी कॉल से बचने lengthया tail(यदि nप्रधानमंत्री था, vशामिल हैं n 1, और उसमें शामिल n (factors in descending order) 1)।

उदाहरण आउटपुट (TIO लिंक यहां ):

> Map(function(n,v=rev(which(!n%%1:n)))"if"(n<2,-1,v[2]),scan())
1: 0 1 2 3 4 5 6 7 8 9
11: 
Read 10 items
[[1]]
[1] -1

[[2]]
[1] -1

[[3]]
[1] 1

[[4]]
[1] 1

[[5]]
[1] 2

[[6]]
[1] 1

[[7]]
[1] 3

[[8]]
[1] 1

[[9]]
[1] 4

[[10]]
[1] 3

यदि आपको लगता है कि कोई सूची स्वीकार्य रिटर्न प्रकार नहीं है, तो इसके Mapलिए स्वैप करें sapplyऔर 3 बाइट्स जोड़ें।



अच्छा - के साथ शुरू करने के लिए नहीं सोचा था!
JDL

6

05AB1E , 11 9 8 बाइट्स

Ñε¨àDd<+

-3 बाइट्स @Emigna , को बदलने और करने के ©d1-®+लिए धन्यवाद ।Dd<+€¨€àε¨à

केवल मेरा दूसरा 05AB1E उत्तर, तो निश्चित रूप से गोल्फ हो सकता है

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

स्पष्टीकरण:

Ñ           # Divisors of each item in the input-list (including itself)
            #  [1,2,10,3] → [[1],[1,2],[1,2,5,10],[1,2,3]]
 ε          # For each:
  ¨         #  Remove last item (so it's now excluding itself)
            #   [[1],[1,2],[1,2,5,10],[1,2,3]] → [[],[1],[1,2,5],[1,2]]
   à        #  And get the max
            #   [[],[1],[1,2,5],[1,2]] → ['',1,5,2]
    D       # Duplicate the list
     d      # Is it a number (1 if it's a number, 0 otherwise)
            #  ['',1,5,2] → [0,1,1,1]
      <     # Subtract 1
            #  [0,1,1,1] → [-1,0,0,0]
       +    # Add both lists together
            #  ['',1,5,2] and [-1,0,0,0] → ['-1',1,5,2]

1
Dd<+के बजाय काम करना चाहिए ©d1-®+। आप भी जरूरत नहीं है ïक्योंकि वे अभी भी ints हैं। हालांकि यह अच्छे दिखने वाले आउटपुट के लिए पाद लेख में हो सकता है।
एमिग्ना

@Eigna आह, के 1-बजाय <बहुत बेवकूफ था .. के Dबजाय के लिए धन्यवाद ©...®! और मैं वास्तव ïमें अब पाद में डाल दिया हूँ ।
केविन क्रूज़सेन

1
या इससे भी बेहतर:Ñε¨àDd<+
एमिगा

मेरे 12-बाईटर से बहुत बेहतर।
मैजिक ऑक्टोपस Urn

5

जे , 21 बाइट्स

_1:`(%{.@q:)@.(>&1)"0

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

स्पष्टीकरण:

(>&1)"0 क्या प्रत्येक संख्या 1 से अधिक है?

@. यदि नहीं, तो लौटें _1:

(%{.@q:)यदि इसकी 2 या अधिक है, %तो पहले {.प्रमुख कारकों द्वारा संख्या को विभाजित करेंq:


4

जाप , 6 बाइट्स

गोल्फिंग के बाद, जोनाथन के समाधान के समान ही, और लगभग उतना ही छोटा हो गया।

®â¬ÌªJ

कोशिश करो


व्याख्या

®          :Map
 ⬠       :  Proper divisors
   Ì       :  Get last element (returns null if the array is empty)
    ª      :  Logical OR
     J     :  -1

एक बाइट के साथ सहेजें-m
ओलिवर

3

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

lambda l:[max([k for k in range(1,n)if n%k<1]+[-1])for n in l]

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

के लिए 0और 1 range(1,n)खाली है, इसलिए कोड का मूल्यांकन किया जाता है max([]+[-1]) = -1। अभाज्य संख्याओं के लिए, [1, n) में एकमात्र भाजक है 1, जो वांछित आउटपुट है।


नारियल , 50 बाइट्स

map$(n->max([k for k in range(1,n)if n%k<1]+[-1]))

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


3

जावा 8, 105 103 87 बाइट्स

a->{for(int i=a.length,n,x;i-->0;a[i]=n<2?-1:n/x)for(n=a[i],x=1;++x<n;)if(n%x<1)break;}

बाइट को बचाने के लिए एक नया वापस करने के बजाय इनपुट-सरणी को संशोधित करता है।

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

स्पष्टीकरण:

a->{                  // Method with integer-array parameter and no return-type
  for(int i=a.length,n,x;i-->0;
                      //  Loop backward over the array
      a[i]=           //    After every iteration: change the current item to:
           n<2?       //     If the current item is 0 or 1:
            -1        //      Change it to -1
           :          //     Else:
            n/x)      //      Change it to `n` divided by `x`
     for(n=a[i],      //   Set `n` to the current item
         x=1;++x<n;)  //   Inner loop `x` in range [2,`n`)
       if(n%x<1)      //    If `n` is divisible by `x`:
         break;}      //     Stop the inner loop (`x` is now the smallest prime-factor)
                      //   (if the loop finishes without hitting the `break`,
                      //    it means `n` is a prime, and `x` and `n` will be the same)

3

हास्केल, 52 49 बाइट्स

map(\x->last$[d|d<-[1..x-1],mod x d<1]++[-1|x<2])

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

map                     -- for each element in the input array
  \x->                  -- apply the lambda function
    last                -- pick the last element of the following list
     [d|d<-[1..x-1]     --  all d from 1 to x-1 
           ,mod x d<1]  --    where d divides x 
     ++[-1|x<2]         --  followed by -1 if x<2


3

अटैची , 23 बाइट्स

@{Max&-1!Divisors@_@-2}

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

29 बाइट्स, पॉइंटफ्री: @(Max&-1@Last@ProperDivisors)

24 बाइट्स, पॉइंटफ्री भी: @(Max&-1@`@&-2@Divisors)

यह बस तब के दूसरे-से-अंतिम विभाजक हो nजाता है और इसका अधिकतम लाभ उठाता है -1। दो से कम तत्वों वाले सरणी में दूसरा-से-अंतिम तत्व है nil, और Max[-1, nil]है -1@बस इस फ़ंक्शन को वेक्टर करता है, जिससे यह प्रत्येक परमाणु पर लागू होता है।



2

आर + numbers, 88 79 बाइट्स

प्रस्तुतियाँ बनाने के तरीके के बारे में कुछ सलाह के लिए टिप्पणियों के लिए धन्यवाद।

function(y)sapply(y,function(x)"if"(x<2,-1,prod(numbers::primeFactors(x)[-1])))

सबसे छोटे को छोड़कर सभी प्रमुख कारकों के उत्पाद का उपयोग करता है, और यह तथ्य कि एक खाली वेक्टर के तत्वों के उत्पाद को परिभाषित किया गया है 1

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


1
libraryकॉल को छोड़ने और numbers::primeFactorsसीधे उपयोग करने के लिए बाइट्स बचाता है ।
JDL

1
यहां JIOL क्या सुझाव दे रहा है, यह देखने के लिए एक TIO लिंक है, साथ ही एक अनाम फ़ंक्शन के लिए इसे स्वैप करना है।
ग्यूसेप

2

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

{fkt|∧_1}ˢ

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

निम्नलिखित स्पष्टीकरण ज्यादातर संक्षिप्तता के लिए अनिवार्य रूप से प्रकाशित किया जाता है, और ब्रेकीलॉग की घोषणात्मक प्रकृति को सटीक रूप से प्रतिबिंबित नहीं करता है।

{          Start of inline predicate.
           Implicit input to the predicate.
 f         Create a list of all of the input's factors (including itself).
  k        Remove the last item of this list so that it no longer contains the original number.
   t       Take the last item of the list with the last item removed.
           Implicitly unify the output with the aforementioned last item.
    |      If that failed, because one of the lists was empty...
     ∧     discarding the input, (there's probably some obvious reason ∨ won't work here but I don't know what it is)
      _1   unify the output with -1 instead.
        }  End of the inline predicate.
         ˢ For every item of the input, unify it with the predicate's input and get a list of the corresponding outputs.

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


2
"वहाँ शायद कुछ स्पष्ट कारण है but यहाँ काम नहीं करेगा, लेकिन मुझे नहीं पता कि यह क्या है" -> आप .∨इसके बजाय का उपयोग कर सकते हैं |∧(मैं अनुमान लगा रहा हूं कि आप भूल गए हैं .), लेकिन यह एक ही बाइट गिनती है। PPCG (और अधिक महत्वपूर्ण रूप से Brachylog: p) में आपका स्वागत है!
घातक

आह, बिल्कुल! धन्यवाद।
असंबंधित स्ट्रिंग


1

स्टैक्स , 14 13 बाइट्स

ü±p╞Ö*«òτ♀╣â▀

इसे चलाएं और डीबग करें

स्पष्टीकरण (अनपैक्ड):

m|fc%c{vsH1?}U? Full program, implicit input-parsing
m               Map
 |fc%c            Get factorisation and length of it (0 and 1 yield [])
      {     } ?   If length != 0:
       v            Decrement
           ?        If still != 0:
        sH            Last element of factorisation
           ?        Else:
          1           Push 1
              ?   Else:
             U      Push -1

मानचित्र के अंदर छद्मकोड:

f = factorisation(i)
l = length(f)
if l:
    if --l:
        return f[-1]
    else:
        return 1
else:
    return -1

1

पायथ, 12 बाइट्स

me+_1f!%dTSt

इसे यहाँ आज़माएँ

व्याख्या

me+_1f!%dTSt
m            Q    For each number d in the (implicit) input...
          Std     ... get the range [1, ..., d - 1]...
     f!%dT        ... take the ones that are factors of d...
  +_1             ... prepend -1...
 e                ... and take the last.

1

जे , 14 बाइट्स

1(%0{q:,-)@>.]

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

हर नंबर के लिए n (n, 1) के बजाय अधिकतम लें।
नकारात्मक संख्या को उसके प्रमुख कारकों की सूची में जोड़ें (1 के लिए खाली सूची), और सूची में पहले आइटम से संख्या को विभाजित करें।

इसके अलावा 14 बाइट्स

(%0{q:) ::_1"0

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

प्रत्येक संख्या को उसके प्रमुख कारकों में से पहले से विभाजित करें। 0 के साथ एक डोमेन त्रुटि उठाती है q:, और हम 1 के लिए एक खाली सूची में 0 वें आइटम की तलाश करते हैं - यह एक त्रुटि भी है। त्रुटियों के लिए किसी भी संख्या के लिए, −1 लौटें।


बहुत अच्छा समाधान!
गैलेन इवानोव

1

जाप , 14 11 8 बाइट्स

®/k v)ªÉ
®        // For each input number,
 /k v    // return the number divided by it's first prime factor,
     )ªÉ // or -1 if such a number doesn't exist (the previous result is NaN).

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

झबरा धन्यवाद करने के लिए उन तीन pesky बाइट बंद मुंडा ।


आपको primes को फ़िल्टर करने की आवश्यकता नहीं है - kके प्रमुख कारक लौटाता है N- तो यह 8 बाइट्स बन जाता है:®/k v)ªÉ
झबरा

@ शुग्गी धन्यवाद, यह नहीं जानता कि यह केवल प्रमुख कारक लौटाता है क्योंकि विधि डॉक्स ऐसा नहीं कहता है।
लीख

1
ओह, हाँ, यह भूल गया। कुछ समय के लिए एक पीआर प्रस्तुत करने का अर्थ है; जल्द ही ऐसा करेंगे।
झबरा

1

जावास्क्रिप्ट (Node.js) , 61 55 बाइट्स

-6 बाइट्स @ धन्यवाद का धन्यवाद

_=>_.map(_=>eval('for(v=_/(d=_>>1);v!=~~v;v=_/--d);d'))

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


स्पष्टीकरण:

_ =>                                     // input i.e : the original array
    _.map(                               // map over all elements of the array
        eval('                           // eval a string
            for(v=_/(d=_>>1);            // set v = _ / _ >> 1 and set that to d
                v!=~~v;                  // and keep going until v !== floor(v)
                        v=_/d--);        // to _ / d again (d was changed)
                    d'                   // return d
            ))                           // end eval and map and function

यह पुराने कोड के लिए अभी भी अपडेट नहीं है।

ES5 अनुकूल के रूप में अच्छी तरह से:

 const primeOrNot = function(input) { // the function with argument input
      return input.map(function(value) { // returns the array after mapping over them
           d = Math.floor(value * 0.5); // multiply each element by 0.5 and floor it 
           for(let v = value / d; v != Math.floor(v);) { // for loop goes until v!=~~v
                d --; // subtract one from d
                v = value / d; // set v again to value / d
           }
           return d; // return d
      })
 };


@ शैगी: धन्यवाद
मुहम्मद सलमान

1

बैश + जीएनयू उपयोगिताओं, 49

  • 9 बाइट्स @Cowsquack की बदौलत बच गए
factor|sed '/:$/c-1
/: \w+$/c1
s%: %/%
y/ /#/'|bc

व्याख्या

  • factor एसटीडीआईएन से इनपुट नंबर पढ़ता है, एक प्रति पंक्ति और प्रारूप में आउटपुट <input number>: <space-separated list of prime factors (ascending)>
  • sed इसे निम्नानुसार संसाधित करता है:
    • /:$/c-1 इनपुट नंबर 0 और 1 का कोई प्रमुख कारक नहीं है और इसे बदल दिया जाता है -1
    • /: \w+$/c1एक अभाज्य गुणक (स्वयं) वाले अंक अभाज्य हैं। इनसे बदलें1
    • s%: %/%बदलें :के साथ /। यह सबसे छोटा कारक देने के लिए सबसे छोटे कारक द्वारा (गैर-अभाज्य) इनपुट संख्या को विभाजित करने के लिए एक अंकगणितीय अभिव्यक्ति बनाता है
    • y/ /#/ अन्य (अनावश्यक) कारकों की सूची निकालें (टिप्पणी करके)
  • bc अंकगणित का मूल्यांकन और प्रदर्शन करें

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


1
आप ड्रॉप करने में सक्षम हो सकता -rहै, और पहले दो के लिए s's आप उपयोग कर सकते हैं /regex/cvalueगोल्फ के लिए एक बाइट, इस regex को सरल बनाने आगे और अधिक बचा सकता है, और आप केवल जगह से पिछले दो regex के दशक में एक बाइट बचा सकता है :के साथ /, और तब अवांछित भाग को टिप्पणी करना, जैसे, tio.run/##JYlBCoMwFET3c4qABhdSfuZ/…
user41805

@ सहवास बहुत अच्छा - धन्यवाद!
डिजिटल ट्रामा





1

Befunge-98 (FBBI) , 39 बाइट्स

j&:!+f0p1-1:::' -:!j;3k$.nbj;-\%!!j:1+a

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

&अधिक संख्या नहीं होने पर समाप्त होता है । यह TIO प्रोग्राम को समाप्त करने तक कार्यक्रम को 60 सेकंड के लिए स्टाल करने का कारण बनता है। यह Befunge-98 के लिए अपरिहार्य है, कम से कम TIO पर क्योंकि दोनों दुभाषिए ऐसा करते हैं। खेल को हिट करने के बाद, यदि आप मिनट का इंतजार करते हैं तो आउटपुट क्या होगा यह देखने के लिए आप थोड़ी देर के बाद कार्यक्रम को रोक सकते हैं।


अनिवार्य रूप से, हर नई संख्या के लिए, यदि यह 0 है, तो इसे 1 में बदल दिया जाता है। फिर यह एक नंबर के बाद स्टैक पर -1 डालता है, जो 1 से शुरू होता है और इनपुट नंबर तक पहुंचने तक गिना जाता है, जिस स्थिति में यह स्टैक पर दूसरा नंबर प्रिंट करता है (0 या 1 के इनपुट के लिए -1, और अन्य के लिए उच्चतम कारक)। हर बार लूप के माध्यम से, हम इटरेटर के मान को उसके पीछे ढेर में जोड़ देते हैं यदि ( input % iterator == 0)। इसका मतलब यह है कि जब हम इनपुट पर पहुंचते हैं, तो हमें बस पुनरावृति दूर करने और प्रिंट करना होगा। फिर, हम स्टैक को क्लियर करते हैं nऔर रीड इनपुट फंक्शन में लौटते हैं।

मैं बाद में स्पष्टीकरण का विस्तार कर सकता हूं, हम देखेंगे ...


0

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

%(`^0|^1$
-1
\d+
$*
^(1+)\1+$
$.1

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

%(`

प्रत्येक इनपुट नंबर पर लूप।

^0|^1$
-1

विशेष — केस ० और १।

\d+
$*

Unary में परिवर्तित करें (-1 को प्रभावित नहीं करता है)।

^(1+)\1+$
$.1

प्रत्येक संख्या को दशमलव में इसके सबसे बड़े उचित कारक से बदलें।


0

टिनिइलिश , 75 बाइट्स

(load library
(q((L)(map(q((N)(i(l N 2)(- 1)(/ N(min(prime-factors N))))))L

इसे ऑनलाइन आज़माएं! (अनाम फ़ंक्शन को नाम देने के लिए 4 अतिरिक्त बाइट्स शामिल हैं ताकि हम इसे पाद लेख में कह सकें।)

Ungolfed / स्पष्टीकरण

nnnn/ppn

(load library)               Library gives us map, -, /, min, and prime-factors functions

(lambda (L)                  Anonymous function, takes a list of numbers L
 (map                         Map
  (lambda (N)                  Anonymous function, takes a number N
   (if (less? N 2)              If N < 2
    (- 1)                        -1; else
    (/ N                         N divided by
     (min                        the minimum
      (prime-factors N)))))      of the prime factors of N
  L)))                        ... to L
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.