2 কারণের কারণ

Question

একটি প্রাকৃতিক সংখ্যা দেওয়া একটি nপ্রোগ্রাম লিখুন বা অর্জন করতে ব্যবহার করা যেতে পারে এমন দুটি সম্ভাব্য দুটি গুণকের একটি তালিকা পেতে ফাংশন লিখুন n। ভালভাবে বুঝতে কি ভান করা হয়েছে আপনি যেতে পারেন http://factornumber.com/?page=16777216 যখন দেখতে nহয় 16777216আমরা নিম্নলিখিত তালিকা পাবেন:

   2 × 8388608  
   4 × 4194304  
   8 × 2097152  
  16 × 1048576  
  32 ×  524288  
  64 ×  262144  
 128 ×  131072  
 256 ×   65536  
 512 ×   32768  
1024 ×   16384
2048 ×    8192
4096 ×    4096

এখানে ভালো জিনিস মুদ্রণের প্রয়োজন নেই। প্রয়োজনীয়তাটি হ'ল প্রতিটি এন্ট্রি (উপাদানগুলির জুড়ি) একে অপরের থেকে ভালভাবে পার্থক্য করা হয় এবং প্রতিটি জোড়ের মধ্যে প্রথম ফ্যাক্টরটি একে অপরের থেকেও আলাদা আলাদা হয়। আপনি যদি কোনও তালিকা / অ্যারে ফিরিয়ে দিতে চান তবে অভ্যন্তরের উপাদানটি দুটি উপাদান সহ একটি তালিকা / অ্যারে বা আপনার ভাষার এমন কিছু কাঠামো যা সি ++ এর মতো একজোড়া জিনিস সমর্থন করে std::pair।

1 টি এন্ট্রি দ্বারা গুণটি মুদ্রণ করবেন না, বা দ্বিতীয় দ্বারা চালিত প্রথম ফ্যাক্টর সহ এন্ট্রিগুলি পুনরাবৃত্তি করবেন না কারণ তারা বেশ অকেজো।

কোন বিজয়ী নয়; এটি প্রতি ভাষা ভিত্তিক কোড গল্ফ হবে।

Comments

আপনি সম্ভবত একটি ছোট টেস্ট কেস যুক্ত করতে পারেন, যেমন 30?

— ২২

@cairdcoinheringaahing আপনি ব্যবহার করতে পারেন factornumber.com আরো পরীক্ষার বিষয় তৈরি করতে।

— জোনাথন ফ্রেচ

আমি সম্প্রতি এই "প্রতি ভাষা" প্রতিযোগিতা দেখেছি। আলোচ্য বিষয়টি কি? বেশিরভাগ প্রশ্নাবলি ভাষা অনুসারে 1 বা 2 এর বেশি পান না এবং আপনি এখনও ঠিক হিসাবে একটি এ নির্বাচন করতে পারেন।

— ফেডারেশন এস।

@fedes। এটি সাধারণত কারণ ভাষার (যেমন জাভা বনাম জেলি) তুলনা করার কোনও অর্থ নেই।

— সম্পূর্ণমানবিক

@ টোটালিহুমান হ্যাঁ, আমি জানি আমার উত্তরগুলির বেশিরভাগই ফ্যাক্টর বা এমনকি ছোট্ট টাল্কে। গল্ফিং ভাষার বিরুদ্ধে কোনও সুযোগ নেই। শব্দভাণ্ডার এবং বয়লারপ্ল্যাটারি দ্বারা ভাষা র্যাঙ্কিংয়ের কিছু উপায় থাকতে পারে

— ফেডারেশন এর।

Answer 1

জাভা (ওপেনজেডিকে 8) , 81 66 65 বাইট

• -15 অলিভিয়ার গ্রাগোয়ারকে ধন্যবাদ বাইটস।
• -1 বাইট: ++j<=i/j-> j++<i/j।

i->{for(int j=1;j++<i/j;)if(i%j<1)System.out.println(j+" "+i/j);}

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

---

পুরানো এক (রেফারেন্সের জন্য)

জাভা (ওপেনজেডিকে 8) , 126 বাইট

i->{java.util.stream.IntStream.range(2,i).filter(d->d<=i/d&&i%d==0).forEach(e->System.out.println(""+e+"x"+i/e));return null;}

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

প্রথম কোডগল্ফ জমা দিন এবং প্রথম ল্যাম্বদা ব্যবহার। ভবিষ্যতের স্ব, দয়া করে কোডের জন্য আমাকে ক্ষমা করুন।

Comments

প্রথম প্রথম প্রবেশ! পিপিসিজিতে আপনাকে স্বাগতম! সমস্ত অতিরিক্ত অতিরিক্ত অপসারণ করে এটি 66 বাইটে নেমে গেছে : যদিও আমি আপনার অ্যালগরিদম গল্ফ করতে পারি না।

— অলিভিয়ার গ্রাগোয়ার

Answer 2

05 এ বি 1 ই , 8 বাইট

Ñ‚ø2äн¦

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

Comments

আমার কাছ থেকে +1 এর প্রায় একই সমাধান রয়েছে। আমি এই 8-বাইটারটির কথা ভেবেছি

— মিঃ এক্সকোডার

@ মিঃ এক্সকোডার: হ্যাঁ হ্যাঁ, দুর্দান্ত :) এটি খুব খারাপ যে সেখানে মানচিত্রের প্রয়োজন রয়েছে।

— Emigna

Answer 3

সি (জিসিসি) , 58 54 53 বাইট

• স্টেডিবক্সকে একটি বাইট ধন্যবাদ সংরক্ষণ করা ।

f(N,j){for(j=1;j++*j<N;)N%j||printf("|%d,%d",j,N/j);}

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

Answer 4

পাইথন 2 , 51 বাইট

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

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

---

51 বাইট (একটি বাইটের জন্য লুইস মেন্ডোকে ধন্যবাদ)

lambda n:[(n/k,k)for k in range(1,n)if(k*k<=n)>n%k]

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

---

51 বাইট

lambda n:[(n/k,k)for k in range(1,n)if n/k/k>n%k*n]

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

Comments

আমি এর ব্যবহার পছন্দ করি [f]।

— জোনাথন ফ্রেচ 22

আপনি দ্বিতীয় সংস্করণে 1 বাইট সংরক্ষণ করতে পারবেনlambda n:[(n/k,k)for k in range(1,n)if(k*k<=n)>n%k]

— লুইস মেন্ডো

1512518520 এর জন্য সমস্ত পদ্ধতির মেমোরিরর

— সার্জিওল

Answer 5

হাস্কেল, 38 বাইট

f x=[(a,b)|a<-[2..x],b<-[2..a],a*b==x]

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

Comments

1512518520 এর জন্য সময় শেষ

— সার্জিওল

Answer 6

এপিএল (ডায়ালগ) , 28 বাইট

{(⊢,⍵÷⊢)¨o/⍨0=⍵|⍨o←1↓⍳⌊⍵*.5}

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

Answer 7

পার্ল 6 , 38 বাইট

{map {$^a,$_/$a},grep $_%%*,2.. .sqrt}

চেষ্টা করে দেখুন

সম্প্রসারিত:

{   # bare block lambda with implicit parameter ｢$_｣

  map
    { $^a, $_ / $a },  # map the number with the other factor

    grep
      $_ %% *,         # is the input divisible by *
      2 .. .sqrt       # from 2 to the square root of the input
}

Answer 8

ব্র্যাচল্যাগ , 8 বাইট

{~×≜Ċo}ᵘ

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

ব্যাখ্যা

{~×≜Ċo}ᵘ
{     }ᵘ  List the unique outputs of this predicate.
 ~×       Pick a list of integers whose product is the input.
   ≜      Force concrete values for its elements.
    Ċ     Force its length to be 2.
     o    Sort it and output the result.

~×অংশ তার আউটপুটে 1s অন্তর্ভুক্ত নয়, তাই ইনপুট জন্য এন এটা দেয় [n] পরিবর্তে [1, n] , যা পরে দ্বারা সংগৃহীত হয় Ċ। কেন সম্পূর্ণ ≜প্রয়োজন তা আমি পুরোপুরি নিশ্চিত নই ...

Comments

≜কারণ অন্যথায় সেখানে কোন উপায় পয়েন্ট প্রয়োজন হয় ᵘদৈর্ঘ্য-2 তালিকা যার পণ্য ইনপুট শুধুমাত্র উত্তর যদি আপনি আসলে তালিকার মানের জন্য জিজ্ঞাসা করবেন না হল:।

— এটিকে মারাত্মক রূপ দিন

Answer 9

জাপট , 9 বাইট

â¬Å£[XZo]

এটি অনলাইন পরীক্ষা! শেষে কিছু নাল দিয়ে অ্যারেগুলির একটি অ্যারে প্রদান করে; -Rআরও পরিষ্কারভাবে আউটপুট দেখানোর জন্য পতাকা যুক্ত করা হয়েছে।

Comments

সুতরাং আমি মনে করি বাইট গণনার জন্য `-R` বিবেচনা করা উচিত ...

— সার্জিওল

@ সার্জিওল, না, এক্ষেত্রে এটি আরও ভাল পঠনযোগ্যতার জন্য আউটপুট ফর্ম্যাট করার জন্য।

— শেগি

nullশেষ পর্যন্ত আমার ফিল্টার করা বাদে আমার কাছে ঠিক সমাধান ছিল ।

— শেগি

Answer 10

জেলি , 8 বাইট

½ḊpP⁼¥Ðf

একটি মোনাডিক লিঙ্ক একটি সংখ্যা নিয়েছে এবং সংখ্যার তালিকাগুলির তালিকা (জোড়া) ফিরিয়ে দেয়।

এটি অনলাইন চেষ্টা করুন! (16777216উদাহরণস্বরূপটিআইওর সময়সীমা বেরিয়ে আসারকারণ এটি 68 68..7 বিলিয়ন জোড়ের একটি তালিকা তৈরি করবে এবং সঠিক পণ্যের সাথে তাদের ফিল্টার করবে!)

কিভাবে?

½ḊpP⁼¥Ðf - Link: number, n     e.g. 144
½        - square root of n          12
 Ḋ       - dequeue*                 [2,3,4,5,6,7,8,9,10,11,12]
  p      - Cartesian product**      [[2,1],[2,2],...[2,144],[3,1],...,[3,144],...,[12,144]
      Ðf - filter keep if:
     ¥   -   last two links as a dyad (n is on the right):
   P     -     product
    ⁼    -     equals
         -                          [[2,72],[3,48],[4,36],[6,24],[8,18],[9,16],[12,12]]

* Ḋ, প্রসূত, অভিনয়ের আগে স্পষ্টতই একটি সংখ্যার ইনপুট একটি পরিসীমা তৈরি করে, এবং পরিসীমা ফাংশন সুস্পষ্টভাবে তার ইনপুটটি মেঝেতে ছড়িয়ে দেয়, তাই বলে, n=24এর ফলাফল ½হয় 4.898...; পরিসীমা হয়ে যায় [1,2,3,4]; এবং ফলস্বরূপ ফলাফল[2,3,4]

** একইভাবে উপরের দিকে, pকার্টেসিয়ান পণ্য, অঙ্কের ইনপুট জন্য ব্যাপ্তি তৈরি করে - এখানে সঠিক যুক্তি nতাই সঠিক যুক্তি [1,2,3,...,n]প্রকৃত কার্টিসিয়ান পণ্য গ্রহণের আগে হওয়ার আগে হয়ে যায় ।

Answer 11

কাস্তে , 8 বাইট

tüOSze↔Ḋ

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

ব্যাখ্যা

tüOSze↔Ḋ  Implicit input, say n=30.
       Ḋ  List of divisors: [1,2,3,5,6,10,15,30]
      ↔   Reverse: [30,15,10,6,5,3,2,1]
   Sze    Zip with original: [[1,30],[2,15],[3,10],[5,6],[6,5],[10,3],[15,2],[30,1]]
 üO       Deduplicate by sort: [[1,30],[2,15],[3,10],[5,6]]
t         Drop first pair: [[2,15],[3,10],[5,6]]

Answer 12

জাভাস্ক্রিপ্ট (ES6), 55 বাইট

n=>eval('for(k=1,a=[];k*++k<n;n%k||a.push([k,n/k]));a')

ডেমো

let f =

n=>eval('for(k=1,a=[];k*++k<n;n%k||a.push([k,n/k]));a')

console.log(JSON.stringify(f(6)))
console.log(JSON.stringify(f(7)))
console.log(JSON.stringify(f(16777216)))

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

Comments

এটা আমার বা এই জন্য ব্যর্থ হয় 6?

— নীল

@ নীল "আমরা এটি ঠিক করতে পারি " " (প্রতিবেদনের জন্য ধন্যবাদ!)

— অ্যারনল্ড

আমি পরীক্ষার জন্য কীভাবে একটি নম্বর সরবরাহ করতে পারি?

— সার্জিওল

You can Try it online!

— Arnauld

Answer 13

Python 2, 59 bytes

lambda N:{(n,N/n,n)[n>N/n:][:2]for n in range(2,N)if N%n<1}

Try it online!

Comments

tio.run/##FcnRCoMgFAbgVzk3AwVh84AQsu0RfIHqwig3YfsNk2BEz27r7oNv/… — Memory error?

— sergiol

@sergiol Yes, a MemoryError, since Python tries to evaluate range(2,N) and store it as a list, yet the allocated memory does not suffice. One could try replace range with xrange (Python 2's range generator), though this exceeds TIO's one minute of maximum runtime. On a machine with enough memory and time, this program should terminate and return the correct answer.

— Jonathan Frech

Answer 14

Jelly, 9 bytes

ÆḌḊµżUṢ€Q

Try it online!

Answer 15

Octave, 42 bytes

@(n)[y=find(~mod(n,x=2:n)&x.^2<=n)+1;n./y]

Try it online!

Answer 16

PHP, 70 bytes

As string (70 bytes):

$i++;while($i++<sqrt($a=$argv[1])){echo !($a%$i)?" {$i}x".($a/$i):'';}

As array dump (71 bytes):

$i++;while($i++<sqrt($a=$argv[1]))!($a%$i)?$b[$i]=$a/$i:'';print_r($b);

(im not sure if i can use return $b; instead of print_r since it no longer outputs the array, otherwise i can save 2 bytes here. )

The array gives the results like:

Array
(
    [2] => 8388608
    [4] => 4194304
    [8] => 2097152
    [16] => 1048576

Comments

"If you choose to return a list/array" To me it means you can print or return as you see fit.

— fede s.

On second thought, returning should be valid for a function, and printing for a program. You seem to have a snippet/program, not a function, so I'd say in this case you should be printing.

— fede s.

Answer 17

Jelly, 12 bytes

ÆDµżUḣLHĊ$$Ḋ

Try it online!

How it works

ÆDµżUḣLHĊ$$Ḋ - Main monadic link;
             - Argument: n (integer) e.g. 30
ÆD           - Divisors                   [1, 2, 3, 5, 6, 10, 15, 30]
    U        - Reverse                    [30, 15, 10, 6, 5, 3, 2, 1]
   ż         - Interleave                 [[1, 30], [2, 15], [3, 10], [5, 6], [6, 5], [10, 3], [15, 2], [30, 1]]
         $$  - Last 3 links as a monad
      L      -   Length                   8
       H     -   Halve                    4
        Ċ    -   Ceiling                  4
     ḣ       - Take first elements        [[1, 30], [2, 15], [3, 10], [5, 6]]
           Ḋ - Dequeue                    [[2, 15], [3, 10], [5, 6]]

Answer 18

Wolfram Language (Mathematica), 41 bytes

nRest@Union[Sort@{#,n/#}&/@Divisors@n]

Try it online!

 is the Function operator, which introduces an unnamed function with named parameter n.

Answer 19

Factor, 58

Well, there has to be some Factor in this question!

[ divisors dup reverse zip dup length 1 + 2 /i head rest ]

It's a quotation. call it with the number on the stack, leaves an assoc (an array of pairs) on the stack.

I'm never sure if all the imports count or not, as they're part of the language. This one uses:

USING: math.prime.factors sequences assocs math ;

(If they count, I should look for a longer solution with shorter imports, which is kind of silly)

As a word:

: 2-factors ( x -- a ) divisors dup reverse zip dup length 1 + 2 /i head rest ;

50 2-factors .
 --> { { 2 25 } { 5 10 } }

Answer 20

Ruby, 43 bytes

->n{(2..n**0.5).map{|x|[[x,n/x]][n%x]}-[p]}

Try it online!

How it works:

For every number up to sqrt(n), generate the pair [[x, n/x]], then take the n%xth element of this array. If n%x==0 this is [x, n/x], otherwise it's nil. when done, remove all nil from the list.

Answer 21

Pari/GP, 49 34 38 bytes

n->[[d,n/d]|d<-divisors(n),d>1&d<=n/d]

Try it online!

Set builder notation for all pairs [d, n/d] where d runs through all divisors d of n subject to d > 1 and d <= n/d.

Huge improvement by alephalpha.

Comments

n->[[d,n/d]|d<-divisors(n),d<=n/d]

— alephalpha

@alephalpha Good one. But had to change it a bit because it output also the factorization with 1.

— Jeppe Stig Nielsen

Answer 22

Husk, 14 12 bytes

tumoOSe`/⁰Ḋ⁰

Try it online!

Explanation

tum(OSe`/⁰)Ḋ⁰  -- input ⁰, eg. 30
           Ḋ⁰  -- divisors [1..⁰]: [1,2,3,5,6,10,15,30]
  m(      )    -- map the following function (example on 10):
     Se        --   create list with 10 and ..
       `/⁰     --   .. flipped division by ⁰ (30/10): [10,3]
    O          --   sort: [3,10]
               -- [[1,30],[2,15],[3,10],[5,6],[5,6],[3,10],[2,15],[1,30]]
 u             -- remove duplicates: [[1,30],[2,15],[3,10],[5,6]]
t              -- tail: [[2,15],[3,10],[5,6]]

Answer 23

APL+WIN, 32 bytes

m,[.1]n÷m←(0=m|n)/m←1↓⍳⌊(n←⎕)*.5

Explanation:

(n←⎕) Prompts for screen input

m←(0=m|n)/m←1↓⍳⌊(n←⎕)*.5 Calculates the factors dropping the first

m,[.1]n÷ Identifies the pairs and concatenates into a list.

Answer 24

Add++, 18 15 bytes

L,F@pB]dBRBcE#S

Try it online!

How it works

L,   - Create a lambda function
     - Example argument:     30
  F  - Factors;     STACK = [1 2 3 5 6 10 15]
  @  - Reverse;     STACK = [15 10 6 5 3 2 1]
  p  - Pop;         STACK = [15 10 6 5 3 2]
  B] - Wrap;        STACK = [[15 10 6 5 3 2]]
  d  - Duplicate;   STACK = [[15 10 6 5 3 2] [15 10 6 5 3 2]]
  BR - Reverse;     STACK = [[15 10 6 5 3 2] [2 3 5 6 10 15]]
  Bc - Zip;         STACK = [[15 2] [10 3] [6 5] [5 6] [3 10] [2 15]]
  E# - Sort each;   STACK = [[2 15] [3 10] [5 6] [5 6] [3 10] [2 15]]
  S  - Deduplicate; STACK = [[[2 15] [3 10] [5 6]]]

Answer 25

Mathematica, 53 bytes

Array[s[[{#,-#}]]&,⌈Length[s=Divisors@#]/2⌉-1,2]&

Try it online!

Answer 26

Befunge-93, 56 bytes

&1vg00,+55./.:   <
+1< v`\g00/g00:p00
_ ^@_::00g%!00g\#v

Try It Online

Answer 27

Julia 0.6, 41 bytes

~x=[(y,div(x,y))for y=2:x if x%y<1>y^2-x]

Try it online!

Redefines the inbuild unary operator ~ and uses an array comprehension to build the output.

• div(x,y) is neccessary for integer division. x/y saves 5 bytes but the output is ~4=(2,2.0).
• Julia allows chaining the comparisons, saving one byte.
• Looping all the way to x avoids Int(floor(√x)).

Answer 28

APL NARS 99 chars

r←f w;i;h
r←⍬⋄i←1⋄→0×⍳0≠⍴⍴w⋄→0×⍳''≡0↑w⋄→0×⍳w≠⌊w⋄→0×⍳w≠+w
A:i+←1⋄→A×⍳∼0=i∣w⋄→0×⍳i>h←w÷i⋄r←r,⊂i h⋄→A

9+46+41+3=99 Test: (where not print nothing, it return something it return ⍬ the list null one has to consider as "no solution")

  f 101    

  f 1 2 3

  f '1'

  f '123'

  f 33 1.23

  f 1.23

  ⎕←⊃f 16777216      
   2 8388608
   4 4194304
   8 2097152
  16 1048576
  32  524288
  64  262144
 128  131072
 256   65536
 512   32768
1024   16384
2048    8192
4096    4096
  f 123
3 41 

Answer 29

Pyt, 67 65 bytes

←ĐðĐ0↔/⅟ƖŽĐŁ₂20`ŕ3ȘĐ05Ș↔ŕ↔Đ4Ș⇹3Ș⦋ƥ⇹⁺Ɩ3ȘĐ05Ș↔ŕ↔Đ4Ș⇹3Ș⦋ƤĐ3Ș⁺ƖĐ3Ș<łĉ

I'm pretty sure this can be golfed.

Basically, the algorithm generates a list of all of the divisors of the input (let's call it n), makes the same list, but flipped, interleaves the two (e.g., if n=24, then, at this point, it has [1,24,2,12,3,8,4,6,6,4,8,3,12,2,24,1]), and prints out the elements from index 2 until half the array length, printing each number on a new line, and with an extra new line in between every pair.

Most of the work is done in actually managing the stack.

Saved 2 bytes by using increment function.

Answer 30

Perl 5, 50 bytes

sub{map[$_,$_[0]/$_],grep!($_[0]%$_),2..sqrt$_[0]}

Ungolfed:

sub {
    return map  { [$_, $_[0] / $_] }
           grep { !($_[0] % $_) }
           (2 .. sqrt($_[0]));
}

Try it online.