दो संख्याओं के सबसे बड़े सामान्य भाजक का प्रधान गुणनखण्ड प्रिंट करें

Question

शीर्षक यह सब कहता है। दो इनपुट 32-बिट पॉजिटिव पूर्णांक m, n >= 2, gcd(m,n)प्राइम फैक्टराइज़ेशन फॉर्म में आउटपुट ।

इनपुट

कमांड लाइन आर्ग या स्टड ठीक की 1 लाइन, जो भी गोल्फ के लिए बेहतर है।

उत्पादन

सिंगल स्पेस एक्सप्लोसिव्स के साथ सीमांकित (कोई अतिरिक्त स्थान नहीं)। आउटपुट कुछ भी नहीं अगर इनपुट अपेक्षाकृत प्रमुख हैं।

उदाहरण:

$ ./factorize 96 162
2^1 3^1

$ ./factorize 14 15


$ ./factorize 196 294
2^1 7^2

नियम

• आप बाह्य संसाधनों, गणित पुस्तकालयों या कारक-निर्माण या जीसीडी के लिए अंतर्निहित कार्यों का उपयोग नहीं कर सकते हैं। उदाहरण: जावा, नहीं java.lang.Math। माणिक, नहीं prime_division, पर्ल, नहीं factor, आदि।

Comments

क्या उत्पादन आप के लिए देख रहे हैं अगर gcd(n,m) == 1?

— भूमिगत

अगर मैं एक अपवाद के साथ बाहर निकलता हूं तो क्या यह ठीक है? यह मुझे कुछ बाइट्स बचा लेगा।

— अंडरग्राउंडोरेल

वास्तव में, मैंने अपना दृष्टिकोण बदल दिया है और अपवाद के साथ बाहर निकलने की कोई आवश्यकता नहीं है। अन्य लोग जानना चाह सकते हैं, हालाँकि।

— भूमिगत

अपवाद के साथ बाहर न निकलें। आउटपुट कुछ भी नहीं है

— डूर्रोन 597

तकनीकी रूप से, q:a+.bया __ q:a+.bजम्मू में नो का उपयोग करता है external resources or math libraries, लेकिन मैं इसे पोस्ट नहीं करूंगा, क्योंकि यह प्रश्न की भावना से बहुत दूर है। मैंने सोचा था कि मैं इसे यहाँ साझा करूँगा।

— atı 8uʎs

Answer 1

पायथन 3, 255 250 237 226 188 180 150 142 137 136 वर्ण

a,b=map(int,input().split())
t,g='',1
while g<a:
 g,p=g+1,0
 if a%g+b%g<1:
  while a%g+b%g<1:a/=g;b/=g;p+=1
  t+='%d^%d '%(g,p)
print(t)

यह आश्चर्यजनक है कि मैं इसे केवल स्किप करने के सामान से कितना छोटा कर सकता हूं (जैसे, आप जानते हैं, जीसीडी ढूंढना)! इसके अलावा, मैं इसे एक फ़ंक्शन बनाकर 10 और चार्ट को कम कर सकता हूं, जो स्टेंट से पढ़ने के बजाय, कुछ अन्य उत्तरों की तरह, 2 ints की अपेक्षा करता है।

Comments

यह तीव्र है! मैं आपके संपादन को देखकर बहुत कुछ सीख रहा हूं और आपको हराने की कोशिश कर रहा हूं। मुझे लगता है कि आपके पास यह एक हो सकता है (हालांकि पायथन जवाबों में से)

— रेनबोलेट

आप को बदलने के द्वारा 1 चरित्र को बचा सकता है while g<a and g<b:के लिएwhile(g<a)*(g<b):

— Rainbolt

@Rusher धन्यवाद दोस्त! आपका उत्तर वह है जिसने मुझे इस पर और अधिक परिश्रम करने के लिए प्रेरित किया :) इसके अलावा आपने जिस ट्रिक की सिफारिश की है वह मुझे a%g+b%gथोड़ा सा जानने के लिए प्रेरित करती है

— ताल

मुझे नहीं लगता कि अन्य खंड आवश्यक है। else:g+=1बस हो सकता है g+=1, जब तक मैं कुछ याद कर रहा हूँ।

— isaacg

@isaacg आपको सही लग रहा है, धन्यवाद!

— ताल

Answer 2

माणिक - 168 117 114 101 100 97

संपादित करें: इसके बारे में सोचने के बाद, मुझे एहसास हुआ कि छलनी की जरूरत नहीं है क्योंकि कारक की प्रधानता को कारक लूप में ध्यान रखा जाता है। इसके अलावा, जैसा कि दूसरों के जवाब से सूचित किया जाता है ( लैनिडर और ताल के हैं, जिन्हें मैंने इसे देखा था, हालांकि ऐसा लगता है कि अन्य लोगों ने भी इसे किया है), अलग-अलग एलसीडी गणना को हटा दिया, क्योंकि वह भी कारक में होता है।
संपादित 2: जरूरत नहीं है do।
संपादित करें 3: इसे और अधिक नीचे निचोड़।
संपादित करें 4: एक और स्थान बाहर खींच लिया।
संपादित करें 5: के uptoबजाय each; ?^ == "^"!

a,b=ARGV.map{|i|i.to_i}
2.upto(a){|d|c=0
[c+=1,a/=d,b/=d]while a%d+b%d<1
print d,?^,c," "if c>0}

आउटपुट (संपादन के बाद भी):

$ ruby factorize.rb 96 162
2^1 3^1 
$ ruby factorize.rb 14 15

$ ruby factorize.rb 196 294
2^1 7^2 

निश्चित रूप से बेहतर बनाया जा सकता है, लेकिन मेरे पहले के लिए बुरा नहीं है।

Comments

आप को बदलने के द्वारा 4 बाइट को हटा सकते हैं map{|i|i.to_i}करने के लिए map &:to_i। आप फ़ाइल के अंत में नई पंक्ति की गणना नहीं करके 5 वीं बाइट निकाल सकते हैं; रूबी इसके बिना काम करती है।

— kernigh

इसके अलावा, आप के $*बजाय उपयोग कर सकते हैं ARGV।

— डानिएरो

Answer 3

अजगर 2 - 254 252 196 185 156 151 134 126 121

i=1
a,b=map(int,raw_input().split())
while b:a,b=b,a%b
while~-a:
 i+=1;j=0
 while a%i<1:j+=1;a/=i
 if j:print`i`+'^'+`j`,

दुभाषिया

repl.it

उदाहरण इनपुट - स्टडिन

100 50

उदाहरण आउटपुट - stdout

2 ^ 1 5 ^ 2

Comments

किस बारे में …`a`+'^'+`f.count(a)`…?

— Ry-

बहुत साफ है, मुझे यह पसंद है

— qwr

@qwr धन्यवाद। मुझे आशा है कि मैं अन्य पायथन उत्तरों को स्ट्रिंग स्वरूपण को समझ सकता हूं और कुछ पात्रों को शेव कर सकता हूं।

— रेनबोल्ट

5 पात्रों को बचाने के f.append(i)लिए स्वैप करें f+=[i]।

— नोलेन रॉयल्टी

और अब आपको f का उपयोग करने की आवश्यकता नहीं है: p (क्यों f=''अभी भी है?)

— Nolen Royalty

Answer 4

जावा - 184 175

यह @Geobits (और @ ताल का जवाब) के एक छोटे से उत्तर से प्रेरित है, लेकिन यह पर्याप्त है कि मैंने अपना जवाब बनाने का फैसला किया।

class G{public static void main(String[]a){for(Integer i=1,q,n=i.valueOf(a[0]),m=i.valueOf(a[1]);m>=++i;System.out.print(q>0?i+"^"+q+" ":""))for(q=0;n%i+m%i<1;n/=i,m/=i)q++;}}

(मानव सत्यापन) परीक्षण दोहन के साथ अघोषित (प्रकार):

class G {
    public static void mainMethod(String[] a) {
        for (Integer i = 1, q, n = i.valueOf(a[0]), m = i.valueOf(a[1]); m >= ++i;
                 System.out.print(q > 0 ? i + "^" + q + " " : ""))
            for (q = 0; n % i + m % i < 1; n /= i, m /= i)
                q++;
    }

    public static void main(String[] a) {
        m(3, 3);
        m(196, 294);
        m(294, 196);
        m(14, 15);
        m(15, 14);
        m(96, 162);
        m(162, 96);
        m(300, 400);
        m(400, 300);
        m(100, 100);
        m(7, 7);
        m(4, 8);
    }

    public static void m(int one, int two) {
        mainMethod(new String[] { String.valueOf(one), String.valueOf(two) });
        System.out.println();
    }
}

Answer 5

डीसी, 96 बाइट्स

?sbsa2sf[q]sk[lalf~lblf~szrlz+0<ksbsale1+selsx]ss[lfn[^]Plen[ ]P]sp[0selsxle0<plf1+dsflb!<w]dswx

यह मानक इनपुट की एक पंक्ति पढ़ता है। इसका उत्पादन एक नई रेखा के साथ समाप्त नहीं होता है। (संपादित करें: यह भी हर कारक के बाद एक अतिरिक्त स्थान का उत्पादन करता है। कुछ अन्य उत्तर अंतरिक्ष को ट्रिम करते हैं, लेकिन यह नहीं करता है।)

उदाहरण:

$ echo 301343045 421880263 | dc factorize.dc
1021^1 59029^1 $ 

टिप्पणियों के साथ कोड:

# dc(1) is a stack language, like Forth. Programs push values on the
# stack, then operate on them. For example, to calculate
#  (2 + 3) * (9 - 4)
# the dc code is
#  [2 3 + 9 4 - *]

# [?] reads a line of input.  We expect two integers >= 2.
# [sb sa] stores the integers in variables.
? sb sa     # a, b = two integers from input

# This program sucks common factors from a and b, looping for
# f = 2, 3, 4, 5, and so on.  This method only sucks prime factors,
# but wastes time when f is not prime.
2 sf        # f = 2

# Code in [...] does not run until the program calls it.

# k = code to break a loop
[
 q           # [q] breaks two levels of [...]
] sk        # k = break

# s = loop to suck factor f from a and b
#  This loop increments e, the exponent for factor f.
#  Please set e = 0 before entering this loop.
[
 # [la lf] puts ( a f ) on the stack.
 # [~] does division and remainder.
             # STACK:
 la lf ~     # ( a/f a%f )
 lb lf ~     # ( a/f a%f b/f b%f )

 # [r] swaps the top two stack values.
 # Hold z = b%f and swap a%f with b/f.
             # STACK:
 sz r lz     # ( a/f b/f a%f b%f )

 # f is a common factor if a%f and b%f are zero.  Because a and b are
 # non-negative, a%f and b%f are zero only if a%f+b%f is zero.
             # STACK:
 +           # ( a/f b/f a%f+b%f )

 # Call k to break loop unless a%f+b%f is zero.  [<k] conditionally
 # calls k if the comparison is true.  Comparisons in dc are
 # backwards, so [3 0 <k] would check 0 < 3.  Because a%f+b%f is never
 # negative, [0 <k] is golf for [0 !=k].
             # STACK:
 0 <k        # ( a/f b/f )

 # f is a common factor, so suck it!
 sb sa       # a = a/f, b = b/f, STACK: ( )
 le 1 + se   # increment e, the exponent for this factor
 ls x        # continue loop, [x] executes s
] ss        # s = loop

# p = code to print "f^e "
[
 # [n] prints a number without a newline.
 # [P] prints a string.
 lf n [^]P
 le n [ ]P

 # DEBUG: Uncomment to print a and b.
 #[(a = ]P la n [, b = ]P lb n [)]P 10P
] sp        # p = print

# w = loop to iterate factors
[
 # Call s loop to suck factor f from a and b, and set exponent e.
 0 se        # e = 0
 ls x        # call s loop

 # DEBUG: Uncomment [c] to clear the stack.  Loop s leaves two junk
 # values ( a/f b/f ) on the stack.  Deleting [c] for code golf saves
 # 1 byte but leaks junk on the stack.
 #c

 # Print "f^e " if 0 < e.  Comparisons in dc are backwards, so
 # [0 le <p] would check e < 0, [le 0 <p] checks 0 < e.
 le 0 <p

 # Increment f.  [d] duplicates top value on stack.
             # STACK:
 lf 1 +      # ( f+1 )
 d           # ( f+1 f+1 )
 sf          # ( f ) as f+1 becomes f

 # Continue loop if b >= f.  This is golf for f <= a and f <= b, as
 # extra iterations of the loop cause no harm.
             # STACK:
 lb          # ( f b )
 !<w         # ( ), continue loop if not b < f
] d sw      # w = loop; STACK: ( w )
x           # enter loop unconditionally; STACK: ( ) at entrance

Answer 6

पॉवरशेल - 82

$a,$b=$args
2..$a|%{$p=0;while(!($a%$_+$b%$_)){$a/=$_;$b/=$_;$p++}if($p){"$_^$p"}}

Comments

यह एक छोटी और पढ़ने में आसान है। यह 2..$aफ़ॉरच-ऑब्जेक्ट लूप में रेंज को पाइप करता है %{...}। पाश के मूल्यों को एकत्र करता है if($p){"$_^$p"}।

— kernigh

Answer 7

जावास्क्रिप्ट (ECMAScript 6 ड्राफ्ट) - 89 वर्ण

f=(m,n,i=2,k=0)=>(m%i|n%i?(k?i+'^'+k+' ':'')+(i>m?'':f(m,n,i+1)):f(m/i,n/i,i,k+1)).trim()

मूल (पुनरावृत्त) उत्तर को नीचे, एक पुनरावर्ती में परिवर्तित करता है।

व्याख्या

f=(m,n,i=2,k=0)=>           // A function with arguments m and n and optional arguments
                            // i (defaults to 2) and k (defaults to 0)
  (
    m%i|n%i                 // if i is not a divisor of m or n then:
      ?(k?i+'^'+k+' '       //   if k is non-zero append  "i^k " to the output
         :'')               //   else append nothing
        +(i>m?''            //   if i>m then terminate
             :f(m,n,i+1))   //   else increment i and reset k to 0
      :f(m/i,n/i,i,k+1)     // else divide m and n by i and increment k
  ).trim()                  // finally strip any extra spaces from the output.

Iterative उत्तर: जावास्क्रिप्ट (ECMASCript 6) - 108 (या 121) 98 वर्ण

संस्करण 2:

f=(m,n)=>{for(s='',i=1;++i<=m;s+=k?' '+i+'^'+k:'')for(k=0;m%i+n%i<1;k++)m/=i,n/=i;return s.trim()}

संस्करण 1:

मूल रूप से पूछे गए प्रश्न का उत्तर देना:

f=(m,n)=>{for(o=[],i=2;i<=m;)m%i|n%i?i++:(m/=i,n/=i,o[i]=(o[i]|0)+1);return o.map((x,i)=>i+"^"+x).join(' ')}

या तथ्य के बाद नियम में परिवर्तन का अनुपालन करना:

f=(m,n)=>{for(o=[],i=2;i<=m;)m%i|n%i?i++:(m/=i,n/=i,o[i]=(o[i]|0)+1);return o.map((x,i)=>i+"^"+x).filter(x=>x).join(' ')}

व्याख्या

f=(m,n)=>                        // Create a function f with arguments m and n
{
  o=[]                           // Initialise an empty array for the output
  i=2                            // Start with a divisor of 2
  for(;i<=m;)                    // Loop while the divisor is not greater than m
    m%i|n%i                      // Test the bitwise OR of m%i and n%1 (i.e. whether
                                 // at least one is non-zero)
      ?i++                       // If m%i>0 or n%i>0 then increment i
      :(m/=i,                    // Otherwise: divide m by i;
        n/=i,                    //                   n by i;
        o[i]=(o[i]|0)+1);        // and add 1 to the i-th element of o
  return o.map((x,i)=>i+"^"+x)   // finally map the sparse array o to a sparse array
                                 // of the strings (index+"^"+value)
          .filter(x=>x)          // turn sparse array into non-sparse array
          .join(' ')             // then concatenate and return.
}

उत्पादन

f(96,162)
"2^1 3^1"

f(14,15)
""

f(80, 80)
"2^4 5^1"

f(196,294)
"2^1 7^2"

Comments

अरे आप f(158,237)कृपया परीक्षण करने की कोशिश कर सकते हैं

— ड्यूर्रोन 597

यह अंतरिक्ष यात्रियों के साथ सीमांकित है (यह बस बहुत सी जगह होती है)" 79^1"

— MT0

सही, अन्य समाधानों में ऐसा नहीं है और न ही उदाहरण है। कृपया ठीक करें :)

— डुर्रोन 597

प्रश्न में कुछ भी नहीं, जैसा कि मूल रूप से पूछा गया है, परिभाषित करता है कि व्हॉट्सएप कितना परिभाषित है या इसकी अनुमति नहीं है - जैसा कि मैं इसे देखता हूं, यह आवश्यकताओं को पूरा करता है क्योंकि यह व्हाट्सएप एक्सप्लसर्स के साथ सीमांकित है। हालाँकि, आप जा रहे हैं और नियमों को बदलने के लिए अब आप नहीं हैं?

— MT0

Preexisting नियमों के तहत, कोई यह कह सकता है कि यह कार्यान्वयन आवश्यकता को छोड़ देता है "आउटपुट कुछ भी नहीं अगर इनपुट अपेक्षाकृत प्रमुख हैं।" अभी भी गोल्फ कोड खराब करना गलत लगता है जो इतना सुंदर निकला। आप कितने समय तक filter()कॉल कर सकते हैं ?

— कीन

Answer 8

पर्ल 6: 90 अक्षर, 94 बाइट्स

sub MAIN(*@n){@n.any%$_||(my$p=$p⊎$_;@n»/=»$_;redo)for
2..@n[0];$p.pairs.fmt("%d^%d").say}

कुछ हद तक डी-गोल्फ और टिप्पणी:

sub MAIN (*@n) { # accept any number of input numbers as @n
    (
        # $p is a Bag, e.g., it holds the primes and the number of times each was added
        my $p = $p ⊎ $_; # Add the prime to the bag
        @n »/=» $_; # Divide all the input numbers by the prime

        redo # Redo the loop iteration with the same prime, in case
             # the numbers can be divided by it multiple times
    )
    if @n.all %% $_ # Do the above only if all of @n are divisible by $_
    for 2..@n[0];   # Do the above for all numbers from 2 .. @n[0]

    $p.pairs.fmt("%d^%d").say # Print join " ", "$prime^$count"
}

उपयोग की तरह है:

$ perl6 -e'sub MAIN(*@n){@n.any%$_||(my$p=$p⊎$_;@n»/=»$_;redo)for
2..@n[0];$p.pairs.fmt("%d^%d").say}' 51 153
3^1 17^1

Comments

? पर्ल में एक प्रतीक है? मुझे नहीं पता था।

— डुर्रोन 597

@ ड्यूर्रोन 597 केवल पर्ल 6 :)

— मौक

Answer 9

पर्ल, 144 133 118 114 97 93

($a,$b)=<>=~/\d+/g;for(2..$a){for($n=0;$a%$_+$b%$_<1;$n++,$a/=$_,$b/=$_){}$n&&print"$_^$n ";}

Ungolfed संस्करण:

($a,$b)=<>=~/\d+/g;
for(2..$a){
    for($n=0 ; $a%$_+$b%$_<1 ; $n++,$a/=$_,$b/=$_) {}
    $n&&print"$_^$n ";
}

मैंने सचमुच इस प्रश्न का उत्तर देने के लिए सिर्फ पर्ल सीखना शुरू किया है (यह मेरा पहला पर्ल कोड है), इसलिए मुझे संदेह है कि इसे और नीचे ले जाया जा सकता है।

Comments

हां, मैंने आपके कोड को बारीकी से नहीं देखा है, लेकिन foreachहमेशा forपर्ल 5 में समानार्थी हूं , ताकि 4 वर्णों को काट दिया जाए :)

— मौक

@ मौक़ा मैंने कभी अतिरेक के साथ एक भाषा नहीं देखी ... धन्यवाद :)

— ताल

Answer 10

जावा: 247 241

एक सरणी में कारकों का ट्रैक रखता है और बस उन्हें लूप में प्रिंट करता है।

जावा के लिए निर्णय आकार, ऐसा लगता है।

class G{public static void main(String[]a){Integer i=1;int n=i.valueOf(a[0]),m=i.valueOf(a[1]),f[]=new int[n>m?n:m+1];for(;m>=++i||n>i;){if(n%i+m%i<1){f[i]++;n/=i;m/=i--;}}for(i=2;i<f.length;System.out.print(f[i]>0?i+"^"+f[i]+" ":""),i++);}}

// line breaks below

class G{
    public static void main(String[]a){
        Integer i=1;int n=i.valueOf(a[0]),m=i.valueOf(a[1]),f[]=new int[n>m?n:m+1];
        for(;m>=++i||n>i;){
            if(n%i+m%i<1){
                f[i]++;n/=i;m/=i--;
            }
        }
        for(i=1;i<f.length;System.out.print(f[i]>0?i+"^"+f[i]+" ":""),i++);
    }
}

Comments

आप वास्तव में अन्य चर को छोड़ सकते हैं int, जैसा कि आप 4 खो देते हैं, int लेकिन आप उन्हें वापस new int[->> के साथ प्राप्त करते हैं new Integer[।

— ड्यूर्रोन 597

हाँ, और मुझे स्विच n%i<1&&m%i<1करने से एक और तीन मिला n%i+m%i<1।

— जियोबिट्स

आप की जरूरत नहीं है ()। यदि n==m, यह m+1वैसे भी डिफ़ॉल्ट होगा ।

— Geobits

आप इसके m/=i;i=1;साथ बदल सकते हैं m/=i--;यह तेजी से भी चलेगा :)

— डुर्रोन 597

पहले forलूप के बाद ब्रेस आवश्यक हैं?

— यपनिप

Answer 11

जावास्क्रिप्ट (ईसीएमएस्क्रिप्ट 5) 170 164 163 113

मैं बहुत MT0 के नेतृत्व का विरोध नहीं कर सका। मैंने पहले भी रिकर्सन पर विचार किया था, लेकिन गड़बड़ करना बहुत आसान लग रहा था। और यह वास्तव में है। थोड़ी सी भिन्नता सब कुछ मिटा देती है।

वहाँ जो fiddles पसंद के लिए एक बेला है।

function f(a,b,i,e){return i?a%i|b%i?(e?i+'^'+e+' ':'')+(i>a?'':f(a,b,i+1,0)):f(a/i,b/i,i,e+1):f(a,b,2,0).trim()}

Ungolfed:

function f(a,b,i,e){
    return i // Check for factor.
        ?a%i|b%i // Check for indivisibility.
            ?(
                e // Check for exponent.
                    ?i+'^'+e+' ' // Add the current factor to result string.
                    :'' // Omit the current non-factor.
             )+(
                i>a // Check for termination state.
                    ?'' // Stop recursion.
                    :f(a,b,i+1,0) // Go to the next factor.
            )
            :f(a/i,b/i,i,e+1) // Failed indivisibility check. Increment exponent and divide subject values.
        :f(a,b,2,0) // Add default factor and exponent.
        .trim() // Get rid of one extra space that's usually on the end.
}

पुराना संस्करण

function f(a,b){for(var r=[],j=-1,i=2;i<=a;)a%i|b%i?++i:(r[j]&&r[j][0]==i?r[j][1]++:r[++j]=[i,1],a/=i,b/=i);for(j=0;i=r[j];++j)r[j]=i.join('^');return r.join(' ')}

Ungolfed:

function f(a,b){
    for(var r=[],j=-1,i=2;i<=a;)
        // We (mis)use conditional expression `?:` instead of `if(){}else{}`.
        a%i|b%i ? // Bitwise OR saves one character over logical OR, where applicable.
             // In the truth case, `i` has become uninteresting. Just move on.
            ++i : // We don't mind hitting composites because their prime factors have already been drained from `a` and `b`.
            (
                r[j]&&r[j][0]==i ? // Check if `i` is already a listed factor.
                    r[j][1]++ : // Increment the exponent count.
                    r[++j]=[i,1], // Otherwise, add a new factor with exponent 1.

                a/=i,b/=i // Drain a used-up factor from `a` and `b`.
            );

    // The real work's done. Now we just format.
    for(j=0; i=r[j]; ++j)
        r[j]=i.join('^'); // Join each factor to its exponent.

    return r.join(' ') // Join all factors into result string.
}

यहाँ कुछ परीक्षण दिए गए हैं:

[
    f(4, 12),
    f(80, 80),
    f(96,162),
    f(196,294)
];

Comments

यह पुनरावर्ती कार्य f(301343045, 421880263);संभवतः विफल हो गया क्योंकि मेरा ब्राउज़र मुझे उस गहरी पुनरावृत्ति की अनुमति नहीं देगा। टूटे हुए फ़ायरफ़ॉक्स!

— kernigh

निश्चित रूप से। व्यवहार में मैं केवल एक पुनरावर्ती कार्य का उपयोग करूंगा यदि मुझे वास्तव में किसी प्रकार के ढेर की आवश्यकता होती है, जैसे कि पेड़ नेविगेशन या अन्य अंतर्निहित पुनरावर्ती डेटा संरचनाओं के लिए। (निश्चित रूप से, संख्याओं को पुनरावर्ती डेटा-संरचनाओं के रूप में माना जा सकता है, लेकिन हमारे पास उस तथ्य को अनदेखा करने में मदद करने के लिए सभी प्रकार के अच्छे सार हैं।)

— कीन

Answer 12

गोल्फस्क्रिप्ट, 68 बाइट्स

~..),2>*${1$1$%3$2$%+!{.@@/@2$/.}*;}/;;]:D.&{`.[~]D\/,(`"^"\++}%" "*

ध्यान दें कि इस दृष्टिकोण को ओ (बी ^{2) की} आवश्यकता है पूर्णांक "a" और "b" के ) समय और स्थान की ।

एक अतिरिक्त बाइट की कीमत पर, "केवल" O (b) समय और स्थान आवश्यक हैं:

~.),2>31*${1$1$%3$2$%+!{.@@/@2$/.}*;}/;;]:D.&{`.[~]D\/,(`"^"\++}%" "*

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

~.        # Interpret the input string (“a” and “b”) and duplicate “b”.
.),2>     # Push the array [ 2 3 4 ... b ].
*$        # Repeat each element b times and sort: [ 2 ... 2 3 ... 3 ... b ... b ]
{         # For each element “d” of the array:
  1$1$%   # Calculate a % d.
  3$2$%   # Calculate b % d.
  +!      # Add and negate.
  {       # If both “a” and “b” are divisible by “d”:
    .@@/  # Calculate a / d.
    @2$/  # Calculate b / d.
    .     # Create a dummy value.
  }*      #
  ;       # Pop the topmost stack element (non-divisor “d” or dummy value).
}/        #
;;]       # Pop “a” and “b” and collect the remaining stack elements in an array.
:|.&      # Save that array in “D” and intersect it with itself to deduplicate it.
{         # For each element “d” of “D”:
  `.[~]   # Push string "d" and array [d].
  D\/,(`  # Split “D” around [d] and take the length minus 1. This count the occurrences.
  "^"\    # Push the string "^" and swap it between "d" and it's number of occurrences.
  ++      # Concatenate the three strings.
}%        # Collect all strings into an array.
]" "*     # Join by spaces.

Answer 13

पायथन 3 (123)

यह मूल रूप से ताल के उत्तर के समान संरचना का उपयोग करता है ।

a,b=map(int,input().split())
s='';p=1
while p<a:
 c=0;p+=1
 while a%p+b%p<1:a/=p;b/=p;c+=1
 if c:s+='%d^%d '%(p,c)
print(s)

यह पी = ए-ए -1 तक लूप करता है, क्योंकि हम तुरंत पी = ए और ए = मिनट (ए, बी) प्राप्त करने के लिए वेतन वृद्धि करते हैं। अगर b> a, p के बेकार मानों को आजमाने में कोई बुराई नहीं है।

2.X में, मुझे लगता है कि हम प्रत्येक टुकड़े को प्रिंट करके पात्रों को बचा सकते हैं क्योंकि हम इसे एक स्ट्रिंग जमा करने के बजाय प्राप्त करते हैं if c:print'%d^%d'%(p,c),:। पायथन 3, दुर्भाग्य से, अनुगामी न्यूलाइन के बिना प्रिंट करने के लिए एक कॉम्पैक्ट तरीका नहीं है।

Answer 14

PHP, 96

<?php
list(,$a,$b)=$argv;for($s=1;$s++<$a;$c&&print"$s^$c ")for($c=0;1>$a%$s+$b%$s;$a/=$s,$b/=$s)$c++;

Comments

हमें लगभग समान कोड मिला है! मेरा एक सुधार इसके बजाय 1 पर p=0;g+=1शुरू करके एक पंक्ति में संयोजित करना है g, जो आपको इसके बजाय करने की अनुमति देता g<aहै g<=a। मुझे आशा है कि आप अजगर को पसंद करेंगे।

— xnor

@xnor मुझे आपका कोड याद आ गया। वास्तव में यह लगभग समान है। मैंने अपनी अजगर स्क्रिप्ट को हटा दिया। मुझे आशा है कि मुझे अजगर पसंद नहीं होगा, मुझे

— ब्रेड्स की

अपने कोड को हटाने की कोई आवश्यकता नहीं है, आप स्वयं इसे लेकर आए हैं। मैं भी मूल रूप से ताल के रूप में खेल की चीज के साथ आया था, इसलिए यह इस तरह दिखता है जैसे कि पायथन गोल्फ के लिए अभिसरण होता है।

— 11:30 बजे xnor

Answer 15

जाग - 115 111 96 85

नया संस्करण केवल इनपुट की एक पंक्ति को संभाल सकता है। यह इंगित करने के लिए ड्यूर्रोन 597 का धन्यवाद कि मुझे केवल सुनिश्चित करने की आवश्यकता है i <= $1।

{for(i=1;++i<=$1;)for(;$1%i+$2%i==0;f[i]++){$1/=i;$2/=i}$0=z;for(i in f)$i=i"^"f[i]}1

Ungolfed:

{
    #skip finding gcd as a separate step, get it from the factors
    for(i = 1; ++i <= $1;) {
        for(;$1 % i == 0 && $2 % i == 0; f[i]++) {
            $1 /= i;
            $2 /= i;
        }
    }
    $0 = "";
    for(i in f) {
        $i = i "^" f[i];
    }
    print;
}

पहले बार-बार संख्याओं के जोड़े ले सकता था

{a=$1;b=$2;for($0=c;a-b;)if(a>b)a-=b;else b-=a;for(i=2;i<=a;i++){for(j=0;a%i==0;j++)a/=i;$0=$0(j?i"^"j" ":c)}}1

Ungolfed:

{
    a = $1;
    b = $2;
    $0 = "";
    #rip off Euclid
    for(; a != b;) {
        if(a > b) {
            a = a - b;
        } else {
            b = b - a;
        }
    }
    #but not Eratosthenes
    for(i = 2; i <= a; i++) {
        for(j = 0; a % i == 0; j++) {
            a /= i;
        }
        $0 = $0 (j ? i "^" j " " : "");
    }
    print;
}

Comments

क्या आपको जरूरत है &&i<=b?

— डुर्रोन 597

खैर, मैं ... आप सही कह रहे हैं, आप नहीं हैं: अगर i > b, तो b % i != 0... धन्यवाद :)

— laindir

यह प्रोग्राम OpenBSD 5.5 में awk के साथ काम नहीं करता है , क्योंकि NF=0;$ 1 और $ 2 को हटाने में विफल रहता है। से उत्पादन echo 301343045 421880263 | awk -f factorize.awk | sed 's/ */ /g'है 5 7 1021^1 59029^1क्योंकि $ 1 5 और $ 2 7. sed निचोड़ कर रख अतिरिक्त रिक्त स्थान है कि $ 1022, $ 1023, $ 1024, मुद्रण से आते है ..., रिक्त स्थान से जुड़े हुए रिक्त स्ट्रिंग के रूप में $ 59,028।

— kernigh

धन्यवाद @kernigh, यह nawk, mawk और gawk में काम करता है। डबल-चेक किया गया कि $0=z;

— पॉज़िक्स

@laindir यह परिवर्तन मेरे लिए प्रोग्राम को ठीक करता है। कोड गोल्फ को पोर्टेबल होने के लिए कार्यक्रमों की आवश्यकता नहीं होती है। सौभाग्य $0=z;से पात्रों की एक ही संख्या है NF=0;। अगर $0=z;लंबा था, तो मैं आपको रखने के लिए कहूंगा NF=0;।

— कर्नेल

Answer 16

पिप , 41 बाइट्स

प्रतिस्पर्धा का जवाब नहीं, क्योंकि भाषा सवाल से नई है। लेकिन 68 के उस गोल्फस्क्रिप्ट मार्क को नीचे आने की जरूरत थी।

Fi2,++a{p:0T$|g%i{++pg/:i}Ipx.:i.'^.p.s}x

एक अंतरिक्ष में आउटपुट समाप्त होता है; यदि यह समस्या है, तो निम्न संस्करण भी 41 बाइट्स ( -sध्वज सहित ) है:

Fi2,++a{p:0T$|g%i{++pg/:i}IplAE:i.'^.p}l

प्रारूपित, स्पष्टीकरण के साथ:

F i 2,++a {      For i in range(2,a+1); note ++ used to avoid parentheses in 2,(a+1)
  p:0            p will store the greatest power of i that divides both numbers
  T $+(g%i) {    Loop till the sum of g%i is nonzero, where g is a list initialized
                  from cmdline args
    ++p          As long as g%i is [0 0], increment p...
    g/:i         ...and divide both numbers in g by i
  }
  I p            If p is nonzero, i went into both numbers at least once
    x.:i.'^.p.s  Append i^p and a space to the result
}
x                Print the result

गोल्फस्क्रिप्ट, सीजाम, एट अल के विपरीत पिप। infix ऑपरेटरों के साथ एक अनिवार्य भाषा है; यह सरणी-प्रोग्रामिंग भाषाओं से कुछ प्रेरणा भी लेता है। यह कार्य अच्छी तरह से काम पर दोनों प्रतिमानों को प्रदर्शित करता है।

(ध्यान दें कि इसे चलाने के लिए 2015-4-20 की प्रतिबद्धता की आवश्यकता है, क्योंकि मैंने अभी एक-दो बग तय किए हैं।)

Answer 17

पायथन 2 - 262 बाइट्स

n,m=input(),input()
f=lambda i:set(filter(lambda x:i%x<1,range(1,i+1)))
g=max(f(n)&f(m))
p=[]
while g-1:
 p+=[min(filter(lambda x:x>1 and x%2!=(x==2)and not any(map(lambda y:x%y<1,range(2,x))),f(g)))]
 g/=p[-1]
print ' '.join(`a`+^+`p.count(a)`for a in set(p))

लाइन 6 को काम चाहिए।

Comments

किस बारे में …`a`+'^'+`f.count(a)`…?

— Ry-

मुझे नहीं पता कि मैं कैसे चूक गया। चीज़। धन्यवाद।

— अंडरग्राउंडमोरल

Answer 18

ग्रोवी: 174 चार्ट

यह ग्रूवी के समाधान का एक हिस्सा है।

int i=1, n=args[0]as int, m=args[1]as int;s=n>m?n:m+1;f=new int[s];while(m>=++i||n>i){if(n%i+m%i<1){f[i]++;n/=i;m/=i--;}};(s-1).times{y=it+1;x=f[y];print"${x>0?"$y^$x ":""}"}

यहाँ ungolfed संस्करण है:

int i = 1, n = args[0] as int, m = args[1] as int

s = n>m?n:m+1
f = new int[s]

while (m>=++i||n>i) {
    if (n%i+m%i<1) {
        f[i]++;n/=i;m/=i--;
    }
}
(s-1).times {
    y=it+1
    x=f[y]
    print"${x>0?"$y^$x ":""}"
}

Comments

आश्चर्य है कि आपने मेरा के बजाय जियोबिट्स के पोर्ट को चुना, क्योंकि मेरा चरित्र 56 वर्णों का है

— ड्यूर्रोन 597

Answer 19

आर: 139

a=scan();q=1:a[1];n=max(q[!a[1]%%q&!a[2]%%q]);m=rep(0,n);for(i in 2:n){while(!n%%i){m[i]=m[i]+1;n=n/i};if(m[i])cat(paste0(i,"^",m[i])," ")}

इंडेंटेशन के साथ:

a=scan() #Take space-separated numeric input from stdin
q=1:a[1]
n=max(q[!a[1]%%q&!a[2]%%q]) #gcd
m=rep(0,n)
for(i in 2:n){
    while(!n%%i){ #prime factorization
        m[i]=m[i]+1
        n=n/i
        }
    if(m[i])cat(paste0(i,"^",m[i])," ")
    }

उपयोग:

> a=scan();q=1:a[1];n=max(q[!a[1]%%q&!a[2]%%q]);m=rep(0,n);for(i in 2:n){while(!n%%i){m[i]=m[i]+1;n=n/i};if(m[i])cat(paste0(i,"^",m[i])," ")}
1: 196 294
3: 
Read 2 items
2^1  7^2