দুটি সংখ্যার সর্বাধিক সাধারণ বিভাজকের প্রাথমিক গুণকে মুদ্রণ করুন

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

বিধি

• আপনি জড়িত বা GCD এর জন্য বাহ্যিক সংস্থান, গণিতের গ্রন্থাগার বা অন্তর্নির্মিত ফাংশন ব্যবহার করতে পারবেন না। উদাহরণ: জাভা, না java.lang.Math। রুবি, না prime_division, পার্ল, না factor, ইত্যাদি

Comments

আপনি কি আউটপুট খুঁজছেন gcd(n,m) == 1?

— আন্ডারগ্রাউন্ডোমোনাইল

আমি যদি ব্যাতিক্রম করে বাইরে চলে যাই তবে কি ঠিক আছে? এটি আমার কয়েকটা বাইট সাশ্রয় করবে।

— আন্ডারগ্রাউন্ডোমোনাইল

আসলে, আমি আমার পদ্ধতির পরিবর্তন করেছি এবং ব্যতিক্রম ছাড়া প্রস্থান করার দরকার নেই। অন্যরা যদিও জানতে চাইতে পারে।

— আন্ডারগ্রাউন্ডোমোনাইল

ব্যতিক্রম সহ প্রস্থান করবেন না। আউটপুট কিছুই নয় :)

— durron597

প্রযুক্তিগতভাবে, q:a+.bবা __ q:a+.bজেতে কোনও ব্যবহার হয় না external resources or math libraries, তবে আমি এটি পোস্ট করব না, কারণ এটি প্রশ্নের চেতনা থেকে অনেক দূরে। আমি কেবল ভেবেছিলাম এটি এখানে ভাগ করে নেব।

— 12uʎ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)

এটি আশ্চর্যজনক যে কেবল জিনিসগুলি এড়িয়ে গিয়ে আমি কীভাবে এটি সংক্ষিপ্ত করতে পারি (যেমন, আপনি জানেন, জিসিডি খুঁজে পেয়েছেন)! এছাড়াও আমি স্ট্যান্ডিন থেকে পড়ার পরিবর্তে এই জাতীয় ফাংশন তৈরি করে আরও 2 টি ইনট আশা করি যা অন্যান্য উত্তরগুলির মতো আশা করে 10 টি চর কমিয়ে আনতে পারি।

Comments

এই তীব্র! আমি আপনার সম্পাদনাগুলি দেখে এবং আপনাকে লোকে মারতে চেষ্টা করে অনেক কিছু শিখছি। আমি মনে করি আপনার কাছে এটি থাকতে পারে (পাইথন উত্তরগুলির বাইরে)

— রেইনবোল্ট

আপনি পরিবর্তন করে 1 টি অক্ষর সংরক্ষণ করতে পারবেন while g<a and g<b:করারwhile(g<a)*(g<b):

— Rainbolt

@ রাশার ধন্যবাদ সাথী! আপনার উত্তর এক যে আমাকে প্রেরণা এই :) উপর কঠিন এছাড়াও কৌতুক আপনি জিনিসটা আমাকে অনুপ্রাণিত সুপারিশ কাজ করতে হয় a%g+b%gবিট

— তাল

আমি মনে করি না অন্য ক্লজটি প্রয়োজনীয়। আমি কিছু মিস করছি না, else:g+=1ঠিক হতে g+=1পারে।

— 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 তম বাইট সরিয়ে ফেলতে পারেন; রুবি তা ছাড়া কাজ করে।

— কার্নে

এছাড়াও, আপনি এর $*পরিবর্তে ব্যবহার করতে পারেন 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)`…?

— রাই-

খুব পরিষ্কার, আমি এটি পছন্দ করি

— qwr

ধন্যবাদ আমি আশা করি আমি অন্যান্য পাইথন উত্তরগুলি স্ট্রিং ফর্ম্যাটিংটি বুঝতে পারি এবং কয়েকটি অক্ষর শেভ করতে পারি।

— রেইনবোল্ট

5 টি অক্ষর সংরক্ষণ করার f.append(i)জন্য অদলবদল করুন f+=[i]।

— নোলেন রয়্যালটি

এবং এখন আপনার এফ ব্যবহার করার দরকার নেই: পি ( f=''এখনও কেন আছে?)

— নোলেন রয়্যালটি

Answer 4

জাভা - 184 175

এটি @ জিওবিটস (এবং কিছুটা @ তালের উত্তর) দ্বারা অনুপ্রাণিত, তবে এর যথেষ্টই আলাদা যে আমি নিজের উত্তর তৈরি করার সিদ্ধান্ত নিয়েছি।

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

এটি স্ট্যান্ডার্ড ইনপুটটির একটি লাইন পড়ে। এর আউটপুট একটি নতুন লাইন দিয়ে শেষ হয় না। (সম্পাদনা: এটি প্রতিটি ফ্যাক্টরীকরণের পরে অতিরিক্ত স্থান আউটপুটও দেয় the অন্যান্য উত্তরগুলির মধ্যে কয়েকটি স্থান ট্রিম করে তবে এটি একটি হয় না))

উদাহরণ:

$ 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)দয়া করে পরীক্ষার চেষ্টা করতে পারেন

— durron597

এটি " 79^1"

— এক্সপোজারগুলির সাথে সীমানাযুক্ত

ঠিক আছে, অন্যান্য সমাধানগুলির এটি নেই এবং উদাহরণও নেই। দয়া করে ঠিক করুন :)

— durron597

প্রশ্নটিতে কিছুই যেমন আসল জিজ্ঞাসা করা হয়নি, নির্ধারণ করে যে কতটা শ্বেত স্পেস রয়েছে বা অনুমোদিত নয় - যেমনটি আমি দেখছি, এটি প্রয়োজনীয়তা পূরণ করে কারণ এটি সাদা অংশ স্পষ্টকারীদের সাথে সীমিত করা হয়। যাইহোক, আপনি গিয়ে নিয়মগুলি পরিবর্তন করতে যাচ্ছেন এখন আপনি না?

— এমটি0

পূর্বনির্মাণের বিধিগুলির অধীনে, কেউ বলতে পারেন যে এই প্রয়োগকরণ প্রয়োজনীয়তা বাদ দেয় "ইনপুটগুলি তুলনামূলকভাবে প্রাইম হলে আউটপুট কিছুই না।" এখনও গল্ফ কোডটিকে অপ্রস্তুত করা ভুল বলে মনে হচ্ছে যা এত সুন্দর। আপনি কত সংক্ষিপ্ত 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

Per পার্ল একটি প্রতীক? আমি এটা জানতাম না।

— durron597

@ durron597 কেবল পার্ল 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 ";}

অবরুদ্ধ সংস্করণ:

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

আমি আক্ষরিকভাবে এই প্রশ্নের উত্তর দেওয়ার জন্য পার্ল শিখতে শুরু করেছি (এটি আমার প্রথম পার্ল কোড এটি), সুতরাং আমি সন্দেহ করি যে এটি আরও নিচে নামানো যেতে পারে।

Comments

হ্যাঁ, আমি আপনার কোডটি ঘনিষ্ঠভাবে দেখিনি, তবে পার্ল 5 এর foreachসাথে সর্বদা সমার্থক for, যাতে 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[সুতরাং এটি ধোয়া।

— durron597

হ্যাঁ, এবং আমি সুইচিং দ্বারা অন্য তিন পেয়েছিলাম n%i<1&&m%i<1করার n%i+m%i<1।

— জিওবিটস

আপনি প্রয়োজন হবে না ()। যদি n==m, এটি m+1যাইহোক ডিফল্ট হবে ।

— জিওবিটস

আপনি প্রতিস্থাপন করতে পারেন m/=i;i=1;সঙ্গে m/=i--;এটা দ্রুত খুব চালানো হবে :)

— durron597

প্রথম forলুপের পরে বন্ধনীগুলি কী প্রয়োজনীয়?

— Ypnypn

Answer 11

জাভাস্ক্রিপ্ট (ECMAScript 5) 170 164 163 113

এমটি 0 এর নেতৃত্ব অনুসরণ করে আমি প্রতিরোধ করতে পারছিলাম না। আমি পূর্বে পুনরাবৃত্তি বিবেচনা করেছিলাম, তবে এটি জগাখিচুড়ি করা খুব সহজ বলে মনে হয়েছিল। এবং এটা সত্যিই হয়। সামান্যতম প্রকরণটি সবকিছু নষ্ট করে দেয়।

যারা ঝাঁকুনি পছন্দ করেন তাদের জন্য একটি ফ্রিডল রয়েছে।

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>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)

P = a-1 পর্যন্ত লুপ করা যথেষ্ট, যেহেতু আমরা পি = এ এবং এ> = মিনিট (ক, খ) পেতে তাত্ক্ষণিকভাবে বৃদ্ধি করি। যদি বি> এ, পি এর অপ্রয়োজনীয় মান চেষ্টা করে কোন ক্ষতি হয় না।

2.x, আমি মনে করি আমরা প্রতিটি টুকরা মুদ্রণ বদলে একটি স্ট্রিং সঁচায়ক হিসাবে আমরা এটি পেতে দ্বারা অক্ষর সংরক্ষণ করতে পারিনি: if c:print'%d^%d'%(p,c),। দুর্ভাগ্যক্রমে পাইথন 3 এর পিছনে থাকা নতুন লাইন ছাড়া মুদ্রণের কোনও কমপ্যাক্ট উপায় আছে বলে মনে হয় না।

Answer 14

পিএইচপি, 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 আমি আপনার কোডটি মিস করেছি। আসলে এটি প্রায় একই। আমি আমার অজগর স্ক্রিপ্ট সরিয়েছি। আমি আশা করি আমার পাইথন পছন্দ করতে হবে না, আমি ধনুর্বন্ধনী প্রয়োজন

— ম্লেকো

আপনার কোড সরানোর দরকার নেই, আপনি নিজেই এটি নিয়ে এসেছেন। আমি মূলত তাল হিসাবে গেম জিনিসটি নিয়ে এসেছি, সুতরাং দেখে মনে হচ্ছে এটি পাইথন গল্ফকে রূপান্তরিত করে।

— xnor

Answer 15

অজানা - 115 111 96 85

নতুন সংস্করণ কেবল ইনপুটগুলির একটি লাইন পরিচালনা করতে পারে। আমার কেবলমাত্র নিশ্চিত হওয়া দরকার তা নির্দেশ করার জন্য durron597 ধন্যবাদ 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?

— durron597

ঠিক আছে আমি হব ... আপনি ঠিক বলেছেন, আপনি করবেন না: যদি i > b, তবে b % i != 0... ধন্যবাদ :)

— লন্ডির

এই প্রোগ্রামটি ওপেনবিএসডি 5.5-এ অ্যাডকের সাথে কাজ করে না , কারণ NF=0;$ 1 এবং $ 2 মুছতে ব্যর্থ। আউটপুটটি echo 301343045 421880263 | awk -f factorize.awk | sed 's/ */ /g'হ'ল 5 7 1021^1 59029^1কারণ $ 1 হ'ল 5 এবং $ 2 হয় 7. সিডটি ফাঁকা স্ট্রিংগুলিতে ফাঁকা স্ট্রিং হিসাবে যুক্ত হিসাবে 1022, $ 1023, $ 1024, ..., 90 59028 মুদ্রণ করে আসা অতিরিক্ত স্থানগুলি চেপে রাখে।

— kernigh

ধন্যবাদ @ কর্নিহ, এটি নওক, মক এবং গোকে কাজ করে। ডাবল-চেক করা হয়েছে যে $0=z;

— পোস্টিক্সটি এনএফকে

@ লাইল্ডির এই পরিবর্তনটি আমার জন্য প্রোগ্রামটি ঠিক করে দেয়। কোড গল্ফের প্রোগ্রামগুলি পোর্টেবল হওয়ার প্রয়োজন হয় না। ভাগ্যক্রমে $0=z;একই অক্ষরের সংখ্যা NF=0;। যদি $0=z;আরও দীর্ঘ হয়, আমি আপনাকে রাখতে বলব NF=0;।

— kernigh

Answer 16

পিপ , 41 বাইট

প্রতিযোগিতামূলক উত্তর নয়, যেহেতু ভাষা প্রশ্নের চেয়ে নতুন। তবে Golf৮ নম্বর গল্ফস্ক্রিপ্টের চিহ্নটি নামতে হবে।

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

পাইপ, গল্ফস্ক্রিপ্ট, সিজেম, এবং অন্যের মতো নয়। ইনফিক্স অপারেটরগুলির সাথে একটি আবশ্যক ভাষা; এটি অ্যারে-প্রোগ্রামিং ভাষা থেকে কিছুটা অনুপ্রেরণা নেয়। এই টাস্কটি কাজের সময় উভয় দৃষ্টান্ত সুন্দরভাবে প্রদর্শন করে।

(মনে রাখবেন যে এটি পরিচালনা করার জন্য ২০১৫-২০১ commit প্রতিশ্রুতিবদ্ধ হওয়া দরকার, যেহেতু আমি সবেমাত্র দু'একটি বাগ স্থির করেছি)

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)`…?

— রাই-

আমি কীভাবে মিস করেছি তা আমার কোনও ধারণা নেই। বলছোটা। ধন্যবাদ।

— আন্ডারগ্রাউন্ডোমোনাইল

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 ":""}"}

নিখরচায় সংস্করণটি এখানে:

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 টির চেয়ে কম

— durron597

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