प्रमुख कारकों की गणना करें

27

हमारे पास कुछ समय पहले एक प्रमुख कारक चुनौती थी, लेकिन वह चुनौती लगभग छह साल पुरानी है और मुश्किल से हमारी वर्तमान आवश्यकताओं को पूरा करती है, इसलिए मेरा मानना ​​है कि यह एक नए के लिए समय है।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखिए जो इनपुट 1 से अधिक पूर्णांक लेता है और आउटपुट करता है या इसके प्रमुख कारकों की सूची देता है।

नियम

  • इनपुट और आउटपुट किसी भी मानक विधि और किसी भी मानक प्रारूप द्वारा दिया जा सकता है।
  • डुप्लिकेट कारकों को आउटपुट में शामिल किया जाना चाहिए।
  • आउटपुट किसी भी क्रम में हो सकता है।
  • इनपुट 2 से कम या 2 31 - 1 से अधिक नहीं होगा ।
  • बिल्ट-इन की अनुमति है, लेकिन गैर-बिलिन समाधान सहित इसे प्रोत्साहित किया जाता है।

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

2 -> 2
3 -> 3
4 -> 2, 2
6 -> 2, 3
8 -> 2, 2, 2
12 -> 2, 2, 3
255 -> 3, 5, 17
256 -> 2, 2, 2, 2, 2, 2, 2, 2
1001 -> 7, 11, 13
223092870 -> 2, 3, 5, 7, 11, 13, 17, 19, 23
2147483646 -> 2, 3, 3, 7, 11, 31, 151, 331
2147483647 -> 2147483647

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf  primes  factoring 
— ETHproductions
स्रोत
2
यदि आप बिल्ट-इन को अस्वीकृत कर देते हैं तो यह बहुत बेहतर होगा।
— बफ़र ओवर पढ़ें
2
@ TheBitByte चुनौतियां जो बिल्ट-इन को अस्वीकार करती हैं, आमतौर पर Y चुनौतियों के बिना डू एक्स के रूप में देखी जाती हैं, खासकर क्योंकि यह कभी-कभी यह बताना मुश्किल है कि क्या एक तकनीकी रूप से एक अंतर्निहित है।
— ETHproductions
1
फिर, <5 बाइट समाधान की आमद का आनंद लें! जैसा कि मैंने यह लिखा है, पायथ पहले से ही 1 बाइट में करता है।
— बफ़र ओवर पढ़ें
2
@ TheBitByte इसे मुख्य रूप से भाषा-दर-भाषा चुनौती के रूप में समझता है। पायथन के समाधान, या किसी अन्य भाषा को बिना किसी बेसिन के हरा करने की कोशिश करें।
— इसहाक
1
@ लिसाक खैर, भाषा-दर-भाषा इसे देखने का एक बेहतर तरीका है, मैं सहमत हूं।
— बफ़र ओवर पढ़ें

जवाबों:

15

पायथ , 1 बाइट

P

मुझे इस चुनौती में पाइथ के मौके पसंद हैं।

— isaacg
स्रोत
16
जब तक "P" भाषा साथ आती है और 0 बाइट्स में होती है
— downrep_nation
10

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

f=lambda n,i=2:n/i*[f]and[f(n,i+1),[i]+f(n/i)][n%i<1]

iबारी-बारी से प्रत्येक संभावित भाजक को पकड़ता है। यदि iएक भाजक है, तो इसे प्रस्तुत करता है और इसके साथ पुनरारंभ होता है n/i। एल्स, अगले-उच्चतम भाजक की कोशिश करता है। क्योंकि विभाजकों को बढ़ते क्रम में जांचा जाता है, केवल प्रधान पाए जाते हैं।

55 बाइट्स के लिए एक कार्यक्रम के रूप में:

n=input();i=2
while~-n:
 if n%i:i+=1
 else:n/=i;print i
— XNOR
स्रोत
8

गणितज्ञ, 38 30 बाइट्स

धन्यवाद @MartinEnder 8 बाइट्स के लिए!

Join@@Table@@@FactorInteger@#&
— जंगहवान मिन
स्रोत
कैसे के बारे में FactorInteger[#][[All, 1]]&? 26 बाइट्स
— डेविड जी। स्टॉर्क
@ DavidG.Stork काम नहीं करेगा क्योंकि यह मुख्य कारकों को नहीं दोहराएगा यदि बिजली 1 से अधिक हो।
— JungHwan Min
4

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

f=(n,x=2)=>n-1?n%x?f(n,x+1):[x,...f(n/x)]:[]

इस तथ्य के कारण बुरी तरह से अक्षम है कि यह अंतिम से सहित प्रत्येक प्रमुख कारक तक 2 से पुनरावृत्ति करता है। आप 5 बाइट्स की कीमत पर नाटकीय रूप से समय की जटिलता में कटौती कर सकते हैं:

f=(n,x=2)=>x*x>n?[n]:n%x?f(n,x+1):[x,...f(n/x,x)]
— ETHproductions
स्रोत
3

दरअसल , 6 बाइट्स

w`in`M

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

स्पष्टीकरण:

w`in`M
w       factor into primes and exponents
 `in`M  repeat each prime # of times equal to exponent
— मै जाऊं
स्रोत
आप शायद अभी उपयोग कर सकते oहैं, है ना?
— ओलिवर
@ ओलिवर हां, लेकिन मैं आमतौर पर पुराने जवाबों को अपडेट नहीं करता।
— मीगो
3

जे, 2 बाइट्स

q:

बॉडी में कम से कम 30 अक्षर होने चाहिए।

— alephalpha
स्रोत
2

टोन-बहरा , 3 बाइट्स

यह भाषा काफी युवा है और वास्तव में अभी तक किसी भी चीज के लिए तैयार नहीं है, लेकिन यह मुख्य कारक कर सकती है:

A/D

यह उपयोगकर्ता इनपुट की प्रतीक्षा करेगा, और फिर प्रमुख कारकों की सूची का उत्पादन करेगा।

— Kade
स्रोत
2

MATLAB, 6 बाइट्स

मुझे लगता है कि इसके लिए किसी स्पष्टीकरण की आवश्यकता नहीं है।

factor
— flawr
स्रोत
1

बैश + कोरुटिल्स, 19 बाइट्स

factor|sed s/.*:.//

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

— डेनिस
स्रोत
आप व्हाट्सएप से दाढ़ी बना सकते हैं यदि व्हाट्सएप आउटपुट के उपयोग से कोई फर्क नहीं पड़ता factor|sed s/.*://। इसके अलावा factor|cut -d: -f2(या factor|cut -d\ -f2अपने वर्तमान उत्पादन से मेल खाने के लिए) एक ही बाइट लंबाई है, लेकिन तेजी से चलाने और कम मेमोरी ओवरहेड का उपयोग करने जा रहा है।
— कालेब
मैं व्हाट्सएप के बारे में ओपी से पूछूंगा। अफसोस की बात है, मुझे factor|cut -d\ -f2-अग्रणी स्थान को खत्म करने की आवश्यकता है, जो अब एक बाइट है।
— डेनिस
1

बैच, 96 बाइट्स

@set/an=%1,f=2,r=0
:l
@set/af+=!!r,r=n%%f
@if %r%==0 echo %f%&set/an/=f
@if %n% gtr 1 goto l
— नील
स्रोत
1

हेक्सागोनी , 58 बाइट्स

अभी तक गोल्फिंग नहीं की गई, लेकिन @ मर्टिनएंडर को वैसे भी इसे नष्ट करने में सक्षम होना चाहिए

एक अनुगामी अंतरिक्ष के साथ कारकों को अलग-अलग अंतरिक्ष-प्रिंट करता है

golfed:

2}\..}$?i6;>(<...=.\'/})."@...>%<..'':\}$"!>~\{=\)=\}&<.\\

बाहर रखा हआ:

     2 } \ . .
    } $ ? i 6 ;
   > ( < . . . =
  . \ ' / } ) . "
 @ . . . > % < . .
  ' ' : \ } $ " !
   > ~ \ { = \ )
    = \ } & < .
     \ \ . . .

स्पष्टीकरण बाद में आ रहा है।

— नीला
स्रोत
1

सी, 92 बाइट्स

int p(int n){for(int i=2;i<n;i++)if(n%i==0)return printf("%d, ",i)+p(n/i);printf("%d\n",n);}

Ungolfed संस्करण:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int prime(int number) {
    for (int i = 2; i < number; i++) {
        if (number % i == 0) {
            printf("%d, ", i);
            return prime(number / i); //you can golf away a few bytes by returning the sum of your recursive function and the return of printf, which is an int
        }                             //this allow you to golf a few more bytes thanks to inline calls
    }
    printf("%d\n", number);
}

int main(int argc, char **argv) {
    prime(atoi(argv[1]));
}
— वैलेन्टिन Mariette
स्रोत
0

पर्ल 6 , 77 64 बाइट्स   

{my$a=$_;.is-prime??$_!!map ->\f{|({$a%f||($a/=f)&&f}...^*!= f)},(2... *>$a)}

कोशिश करो

{my$a=$_;map ->\f{|({$a%f||($a div=f)&&f}...^ f>*)},(2... *>$a)}

इसे आज़माएँ (ध्यान दें: इसे पूरा करने के लिए पर्याप्त समय नहीं मिला है)

100 बाइट्स में एक बहुत अधिक प्रदर्शन संस्करण थोड़ा लंबा है।

{my$a=$_;map ->\f{|({$a.is-prime??($/=$a)&&($a=0)||$/!!($a%f||($a div=f)&&f)}...^ f>*)},(2... *>$a)}

कोशिश करो

विस्तारित: (64 बाइट संस्करण)

{
  my $a = $_;  # the input ｢$_｣ is read-only by default
  map
    -> \f {
      |(              # slip ( flattens into outer list )

        # generate sequence of 0 or more ｢f｣s
        {
          $a % f      # is it not evenly divisible

          ||          # if it is evenly divisible
          ($a div=f)  # divide it
          &&          # and
          f           # return ｢f｣
        }
        ...^   # keep doing that until
        f > *  # ｢f｣ is bigger
      )

    },

    # do that over the following list

    (2 ... * > $a) # generate a sequence from 2
                   # up to whatever the value of $a
                   # is at the time of the check
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
0

VB.NET, 86 बाइट्स

यह कुछ परियोजना यूलर कार्यक्रमों से आसपास बैठे थे। लघुता के हित में अनुकूलन को हटा दिया, और यह परिणाम है। स्वाभाविक रूप से, वीबी बहुत ही क्रियात्मक है, इसलिए यह काफी लंबा है। मैं प्रमुख व्हाट्सएप की गिनती नहीं कर रहा हूं। इसे छोड़ा जा सकता है, लेकिन इसके साथ पढ़ना आसान है।

यह एक पूर्णांक को एक पैरामीटर के रूप में लेता है, और बाद में अल्पविराम के साथ प्रमुख कारकों को प्रिंट करता है। अंत में एक अनुगामी अल्पविराम है।

Sub A(a)
    For i=2To a ' VB re-evaluates a each time, so the /= at the end of the loop shortens this
        While a Mod i=0 ' this is a factor. We've grabbed primes before this, so this must be a prime factor
            Console.Write(i &",") ' output
            a/=i ' "mark" the prime as "used"
        End While
    Next
End Sub
— ब्रायन जे
स्रोत
0

जावा (ओपनजेडके) , 259 बाइट्स

import java.util.*;interface g{static void main(String[]z){int a=new Scanner(System.in).nextInt();int b=0;int[]l={};for(int i=2;i<=a;i++){for(;a%i<1;l[b-1]=i){l=Arrays.copyOf(l,b=l.length+1);a/=i;}}for(int i=0;i<b;i++)System.out.print(l[i]+(i<b-1?", ":""));}}

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

— पावेल
स्रोत
यह देखें कि इस प्रस्तुतिकरण को आगे कैसे बढ़ाया जा सकता है, इसे देखें: gist.github.com/kritiilithos/fde37dc5a8ae54852aa134a6e70ea495 । यदि आपको कुछ स्पष्ट करने की आवश्यकता है, तो 19 वीं बाइट में मुझे पिंग करने के लिए स्वतंत्र महसूस करें :)
— क्रिकेति लिथोस
0

रूबी, 61 बाइट्स

require'prime';->x{x.prime_division.flat_map{|x|[x[0]]*x[1]}}

सबसे छोटा बिल्ट-वर्जन जिसके बारे में मैं सोच सकता था।

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