প্রধান বা সর্বোচ্চ ফ্যাক্টর


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, 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
আমি ভবিষ্যতের প্রশ্নের জন্য স্যান্ডবক্স ব্যবহার করার জন্য, তাদের পোস্ট দেওয়ার আগে প্রশ্নের প্রতিক্রিয়া জানানোর জন্য সুপারিশ করছি
জো কিং

@ জোকিং: অনন্তর জন্য আপনাকে অবশ্যই সমস্ত সংখ্যা অনন্ত পর্যন্ত আউটপুট করতে হবে। এটি কেবল আপনার জন্য এবং আপনাকে এটিও নির্ধারণ করতে হবে যে এটির সময় শেষ হয় না বা কিছু হয় না। জে কে: টাইম আউট ত্রুটি সবচেয়ে বেশি সম্ভবত আপনি অনন্তের জন্য পাবেন

4
কেবলমাত্র এটি লক্ষ করতে চেয়েছিলেন যে "যদি এটি 1 এর চেয়ে বেশি সংখ্যক প্রাথমিক সংখ্যা হয়" তবে 1 এর চেয়ে বেশি সত্যই প্রয়োজনীয় নয় কারণ প্রাথমিক সংখ্যাগুলি সর্বদা 1 এর চেয়ে বেশি থাকে
আইভো বেকার

5
সর্বোচ্চ ফ্যাক্টর সংজ্ঞায়িত করুন। আমি নিজেই নম্বরটি ফিরিয়ে দেব? সর্বোচ্চ বিভাজক প্রধানমন্ত্রী? সর্বোচ্চ ফ্যাক্টর যা নিজেই নয়?
নিসা

2
আমি এটি গ্রহণ করি যে আমাদের প্রোগ্রামগুলি কেবলমাত্র আমাদের নির্বাচিত ভাষার সর্বোচ্চ পূর্ণসংখ্যার আকার পর্যন্ত নির্ধারণ করা উচিত (যথেচ্ছ বৃহত্তর পূর্ণসংখ্যার পক্ষে সমর্থন নেই তাদের জন্য)
জেডিএল

উত্তর:


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

জেলি , 9 8 বাইট

@ ডেনিসকে 1 বাইট সংরক্ষণ করা হয়েছে

:ÆfṂ€$~~

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস চালান

মন্তব্য

আমরা আসলে উভয় যে সুবিধা গ্রহণ nanএবং infপরিণত 0যখন একটি bitwise তাদের প্রয়োগ করা হয় জেলি হবে।

:Æ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
আপনি এইবার জাভাস্ক্রিপ্ট ব্যবহার করেন নি? সুন্দর উত্তর

3
আমি সত্যিই পছন্দ করি ~~:ÆfṂ€$~~সহায়ক লিঙ্কটি সরিয়ে একটি বাইট সংরক্ষণ করে।
ডেনিস

@ ডেনিস আহ! $আমি যা খুঁজছিলাম :) ধন্যবাদ!
আর্নৌল্ড

7

আর, 68 62 বাইট

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

শুধুমাত্র বেস আর ব্যবহার করে একটি সমাধান, লাইব্রেরি নেই! জিউসেপিকে ধন্যবাদ 6 বাইট গল্ফ করার জন্য Thanks

scanকোন স্থানগুলি পৃথক সংখ্যার তালিকায় পড়তে ব্যবহার করে, %%কোনটি কারণগুলি তা সনাক্ত করতে identify vতারপরে আরোহী ক্রমে সমস্ত উপাদানগুলির একটি ভেক্টর রয়েছে (1 এবং এন সহ)। revএটিতে খুব ভাল সম্পত্তি রয়েছে যা আমরা যখন কাটিয়েছি তখন আমরা যে vনম্বরটি চাইব তা দ্বিতীয় স্থানে থাকবে, একটি ব্যয়বহুল কল এড়ানো lengthবা tail(যদি nএটি প্রাইম ছিল তবে vএতে থাকে)n 1 , অন্যথায় এতে থাকে n (factors in descending order) 1)।

উদাহরণ আউটপুট ( এখানে টিআইও লিঙ্ক ):

> 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 বাইট যুক্ত করুন।



সুন্দর - এর সাথে আরম্ভ করার কথা !
ভাবেননি

6

05 এ বি 1 , 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 হয়। যদিও আপনি এটি দেখতে ভাল আউটপুট পেতে পাদলেখ করতে পারেন।
এমিগিনা

@ এমিগনা আহ, 1-পরিবর্তে <বেশ বোকা ছিল .. Dপরিবর্তে ধন্যবাদ ©...®! এবং আমি সত্যিই ïএখন পাদলেখ মধ্যে রেখেছি ।
কেভিন ক্রুইজসেন

1
বা আরও ভাল:Ñε¨àDd<+
এমিগিনা

আমার 12-বাইটারের চেয়ে অনেক বেশি ভাল।
ম্যাজিক অক্টোপাস উরন

5

জে , 21 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

(>&1)"0 প্রতিটি সংখ্যা 1 এর চেয়ে বেশি?

@. যদি না হয়, ফিরে _1:

(%{.@q:)যদি এটি 2 বা ততোধিক %হয় তবে প্রথম {.মৌলিক সংখ্যাটি দিয়ে সংখ্যাটি ভাগ করুনq:


4

জাপট , 6 বাইট

গল্ফ করার পরে, জোনাথনের সমাধানের সাথে প্রায় অভিন্ন হয়ে উঠেছে short

®â¬Ìª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সরাসরি ব্যবহার করতে বাইটস সংরক্ষণ করে।
জেডিএল

1
জেডিএল কী পরামর্শ দিচ্ছে তা দেখার জন্য এখানে একটি টিআইও লিঙ্ক রয়েছে , পাশাপাশি এটি কোনও বেনামি কার্যক্রমে স্ব্যাপ করে।
জিউসেপে

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
"সম্ভবত কিছু স্পষ্ট কারণ রয়েছে - এটি এখানে কাজ করবে না তবে আমি তা জানি না" -> আপনি এর .∨পরিবর্তে ব্যবহার করতে পারেন |∧(আমি মনে করি আপনি ভুলে গিয়েছিলেন .) তবে এটি একই বাইট গণনা। পিপিসিজিতে (এবং আরও গুরুত্বপূর্ণভাবে ব্র্যাচল্যাগ: পি) আপনাকে স্বাগতম!
20:58

আহ, অবশ্যই! ধন্যবাদ।
সম্পর্কিত নয় স্ট্রিং


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:,-)@>.]

এটি অনলাইন চেষ্টা করুন!

প্রতিটি সংখ্যার জন্য এন এর পরিবর্তে সর্বাধিক (এন, 1) নিন।
অবহেলিত সংখ্যাটিকে তার প্রধান কারণগুলির তালিকায় যুক্ত করুন (1 টির জন্য খালি তালিকা), এবং তালিকার প্রথম আইটেম দ্বারা সংখ্যাটি ভাগ করুন।

এছাড়াও 14 বাইট

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

এটি অনলাইন চেষ্টা করুন!

প্রতিটি সংখ্যাকে এর প্রধান কারণগুলির দ্বারা প্রথমভাগে ভাগ করুন। 0 এর সাথে একটি ডোমেন ত্রুটি উত্থাপন করে q:এবং আমরা 0 এর জন্য খালি তালিকায় 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).

এটি অনলাইন চেষ্টা করুন!

যারা তিন বিরক্তিকর কামিয়ে ধন্যবাদ বাইট রোমশ


আপনাকে প্রাইমগুলি ফিল্টার করতে হবে না - k আয় প্রধানমন্ত্রী কারণের N: তাই এই 8 বাইট হয়ে -®/k v)ªÉ
রোমশ

@ শেগি ধন্যবাদ, পদ্ধতি ডক্স যেহেতু এটি বলে না তাই এটি কেবল প্রাথমিক কারণগুলি প্রদান করে তা জানত না।
নিট

1
ওহ, হ্যাঁ, ভুলে গেছি এর জন্য কিছু সময়ের জন্য পিআর জমা দেওয়ার অর্থ হয়েছে; খুব শীঘ্রই এটি করতে হবে।
শেগি

1

জাভাস্ক্রিপ্ট (নোড.জেএস) , 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 বাইটস সংরক্ষিত @ কউসকেউকে ধন্যবাদ
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জন্য /regex/cvalueআপনি গল্ফ বাইট ব্যবহার করতে পারেন , এই রেজেক্সকে আরও সহজ করে তুললে আরও সাশ্রয় হয় এবং আপনি কেবলমাত্র দুটি :দিয়ে প্রতিস্থাপন করে শেষ দুটি রেজেক্সের একটি বাইট সংরক্ষণ করতে পারেন /, এবং তারপরে অযাচিত অংশটি সম্পর্কে মন্তব্য করা, টিও.আরুন
##

@ সম্প্রদায়টি খুব ভাল - ধন্যবাদ!
ডিজিটাল ট্রমা


1

জাভাস্ক্রিপ্ট (নোড.জেএস) , 37 বাইট

x=>x.map(a=>(f=t=>a%--t<1?t:f(t))(a))

এটি অনলাইন চেষ্টা করুন!

বড় ইনপুট জন্য পুনরাবৃত্তি, স্ট্যাক ওভারফ্লো

জাভাস্ক্রিপ্ট (নোড.জেএস) , 41 বাইট

x=>x.map(a=>eval('for(t=a;a%--t!=0;);t'))

এটি অনলাইন চেষ্টা করুন!




1

বেফুঞ্জ -98 (এফবিবিআই) , 39 বাইট

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

এটি অনলাইন চেষ্টা করুন!

সাথে শেষ হয় &যখন কোনও সংখ্যা নেই তখন । এটি টিআইও প্রোগ্রাম শেষ না হওয়া পর্যন্ত 60 সেকেন্ডের জন্য প্রোগ্রামটিকে স্টল করে। এটি বেফুঞ্জ -৯৮ এর জন্য অনিবার্য, কমপক্ষে টিআইও-তে কারণ উভয় দোভাষী এই কাজটি করেন। হিট প্লে করার পরে, আপনি যদি মিনিট অপেক্ষা না করেন তবে আউটপুট কী হবে তা দেখার জন্য আপনি কিছুক্ষণ পরে প্রোগ্রামটি বন্ধ করতে পারেন।


মূলত, প্রতিটি নতুন সংখ্যার জন্য, যদি এটি 0 হয় তবে এটি 1 এ পরিণত হয় Then স্ট্যাকের দ্বিতীয় সংখ্যাটি মুদ্রণ করে (0 বা 1 এর ইনপুট জন্য -1 এবং অন্যদের জন্য সর্বোচ্চ ফ্যাক্টর)। প্রতিবার লুপের মাধ্যমে, আমরা এর পিছনে স্ট্যাকটিতে পুনরাবৃত্তির মান যুক্ত করি যদি (input % iterator == 0 ) হয় । এর অর্থ হ'ল আমরা যখন ইনপুটটি পাব, তখন কেবল কেবল পুনরুক্তি এবং মুদ্রণ ফেলে দিতে হবে। তারপরে, আমরা স্ট্যাকটি সাফ করে দিয়েছিn করে রিড ইনপুট ফাংশনে ফিরে আসি।

আমি পরে ব্যাখ্যাটি প্রসারিত করতে পারি, আমরা দেখব ...


0

রেটিনা 0.8.2 , 33 বাইট

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

এটি অনলাইন চেষ্টা করুন! লিঙ্কে সেই পরীক্ষাগুলি অন্তর্ভুক্ত রয়েছে যা খুব ধীর নয়। ব্যাখ্যা:

%(`

প্রতিটি ইনপুট নম্বর লুপ।

^0|^1$
-1

বিশেষ ক্ষেত্রে 0 এবং 1।

\d+
$*

আনরিতে রূপান্তর করুন (-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 / ব্যাখ্যা

প্রাইম জন্য 1 ফিরে আসা পর্যবেক্ষণ এন এবং বৃহত্তম ফ্যাক্টর কম এন সংমিশ্রনের জন্য এন প্রত্যাবর্তনের মধ্যে একত্রিত করা যেতে পারে এন/পি কোথায় পি এর মধ্যে ক্ষুদ্রতম প্রধান উপাদান এন

(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
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.