Diberi nomor alami, ntuliskan program atau fungsi untuk mendapatkan daftar semua kemungkinan dua faktor perkalian yang dapat digunakan untuk mencapainya n. Untuk memahami lebih baik apa yang berpura-pura dapat Anda pergi ke http://factornumber.com/?page=16777216 untuk melihat ketika nadalah 16777216kita mendapatkan daftar berikut:

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

Tidak perlu cukup mencetak hal-hal seperti di sini. Syaratnya adalah bahwa setiap entri (pasangan faktor) dibedakan dengan baik satu sama lain dan di dalam masing-masing pasangan, faktor pertama juga dibedakan dengan baik dari yang lain. Jika Anda memilih untuk mengembalikan daftar / array, elemen di dalam bisa berupa daftar / array dengan dua elemen, atau beberapa struktur bahasa Anda yang mendukung sepasang hal seperti C ++ std::pair.

Jangan cetak perkalian dengan 1 entri, atau ulangi entri dengan faktor pertama dirubah oleh yang kedua, karena mereka cukup berguna.

Tidak ada pemenang; itu akan menjadi kode dasar per bahasa golf.

Java (OpenJDK 8) , 81 66 65 byte

• -15 Bytes berkat Olivier Grégoire.
• -1 Byte: ++j<=i/j-> j++<i/j.

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

Cobalah online!

Yang lama (untuk referensi)

Java (OpenJDK 8) , 126 byte

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;}

Cobalah online!

Codegolf pertama yang mengirim dan penggunaan lambda pertama. Masa depan diri saya, maafkan saya untuk kode.

05AB1E , 8 byte

Ñ‚ø2äн¦

Cobalah online!

C (gcc) , 58 54 53 byte

• Menyimpan satu byte berkat Steadybox .

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

Cobalah online!

Python 2 , 51 byte

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

Cobalah online!

51 byte (terima kasih kepada Luis Mendo untuk satu byte)

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

Cobalah online!

51 byte

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

Cobalah online!

Haskell, 38 byte

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

Cobalah online!

APL (Dyalog) , 28 byte

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

Cobalah online!

Perl 6 , 38 byte

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

Cobalah

Diperluas:

{   # 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
}

Brachylog , 8 byte

{~×≜Ċo}ᵘ

Cobalah online!

Penjelasan

{~×≜Ċ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.

Bagian ~×ini tidak termasuk 1s dalam outputnya, jadi untuk input N ia memberikan [N] bukannya [1, N] , yang kemudian diambil oleh Ċ. Saya tidak sepenuhnya yakin mengapa ≜diperlukan ...

Japt , 9 byte

â¬Å£[XZo]

Uji secara online! Mengembalikan array array, dengan beberapa null di akhir; -Rbendera ditambahkan untuk menampilkan keluaran lebih jelas.

Jelly , 8 byte

½ḊpP⁼¥Ðf

Tautan monadik yang mengambil nomor dan mengembalikan daftar daftar (pasangan) angka.

Cobalah online! (waktu habis pada TIO untuk16777216 contoh karena akan membuat daftar 68,7 miliar pasangan dan menyaring ke mereka yang memiliki produk yang benar!)

Bagaimana?

½Ḋ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]]

* Ḋ , dequeue, secara implisit membuat kisaran input numerik sebelum berakting, dan fungsi rentang secara implisit menempatkan inputnya, jadi dengan, katakanlah, n=24hasilnya ½adalah 4.898...; rentangnya menjadi [1,2,3,4]; dan hasil dequeued adalah[2,3,4]

** Demikian pula untuk di atas,, pproduk Cartesian, membuat rentang untuk input numerik - di sini argumen yang tepat nkarenanya argumen yang tepat menjadi[1,2,3,...,n] sebelum produk Cartisian aktual terjadi.

Sekam , 8 byte

tüOSze↔Ḋ

Cobalah online!

Penjelasan

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

JavaScript (ES6), 55 byte

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

Demo

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

Cobalah secara Online!

Python 2 , 59 byte

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

Cobalah online!

Jelly , 9 byte

ÆḌḊµżUṢ€Q

Cobalah online!

Oktaf , 42 byte

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

Cobalah online!

PHP, 70 byte

Sebagai string (70 byte):

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

Sebagai dump array (71 byte):

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

(saya tidak yakin apakah saya dapat menggunakan return $ b; alih-alih print_r karena tidak lagi menampilkan array, jika tidak saya dapat menyimpan 2 byte di sini.)

Array memberikan hasil seperti:

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

Jelly , 12 byte

ÆDµżUḣLHĊ$$Ḋ

Cobalah online!

Bagaimana itu bekerja

Æ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]]

Bahasa Wolfram (Mathematica) , 41 byte

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

Cobalah online!

adalah Functionoperator, yang memperkenalkan fungsi tanpa nama dengan parameter bernama n.

Faktor , 58

Nah, pasti ada beberapa Faktor dalam pertanyaan ini!

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

Ini kutipan. calldengan nomor pada tumpukan, meninggalkan assoc(array pasangan) pada tumpukan.

Saya tidak pernah yakin apakah semua impor dihitung atau tidak, karena mereka adalah bagian dari bahasa. Yang ini menggunakan:

USING: math.prime.factors sequences assocs math ;

(Jika mereka menghitung, saya harus mencari solusi yang lebih panjang dengan impor yang lebih pendek, yang agak konyol)

Sebagai sebuah kata:

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

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

Ruby , 43 byte

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

Cobalah online!

Bagaimana itu bekerja:

Untuk setiap angka hingga sqrt (n), hasilkan pasangan [[x, n/x]], lalu ambil n%xelemen th dari array ini. Jika n%x==0ini [x, n/x], sebaliknya itu nil. setelah selesai, hapus semua nildari daftar.

Pari / GP , 49 34 38 byte

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

Cobalah online!

Tetapkan notasi pembangun untuk semua pasangan [d, n/d]tempat dmenjalankan semua pembagi subjek ddari dan .nd > 1d <= n/d

Perbaikan besar oleh alephalpha.

Sekam , 14 12 byte

tumoOSe`/⁰Ḋ⁰

Cobalah online!

Penjelasan

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

APL + WIN, 32 byte

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

Penjelasan:

(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.

Tambahkan ++ , 18 15 byte

L,F@pB]dBRBcE#S

Cobalah online!

Bagaimana itu bekerja

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

Mathematica, 53 bytes

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

Try it online!

Befunge-93, 56 bytes

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

Try It Online

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

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 

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.

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.