Cho một số tự nhiên nviết một chương trình hoặc hàm để có được một danh sách tất cả hai phép nhân có thể được sử dụng để đạt được n. Để hiểu rõ hơn về những gì đang giả vờ bạn có thể vào http://factornumber.com/?page=16777216 để xem khi nlà 16777216chúng tôi nhận được danh sách sau đây:

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

Không cần phải in những thứ đẹp như ở đây. Yêu cầu là mỗi mục (cặp yếu tố) được phân biệt tốt với nhau và bên trong mỗi cặp, yếu tố đầu tiên cũng được phân biệt rõ với yếu tố kia. Nếu bạn chọn trả về một danh sách / mảng, phần tử bên trong có thể là một danh sách / mảng có hai thành phần hoặc một số cấu trúc ngôn ngữ của bạn hỗ trợ một cặp điều như C ++ std::pair.

Không in phép nhân với 1 mục, cũng không lặp lại các mục có yếu tố thứ nhất được tính bằng mục thứ hai, vì chúng khá vô dụng.

Không có người chiến thắng; nó sẽ là một golf mã ngôn ngữ cơ sở.

Java (OpenJDK 8) , 81 66 65 byte

• -15 Byte nhờ 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);}

Hãy thử trực tuyến!

Cái cũ (để tham khảo)

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

Hãy thử trực tuyến!

Codegolf đầu tiên nộp và sử dụng lambda đầu tiên. Tương lai bản thân, xin vui lòng tha thứ cho tôi cho mã.

05AB1E , 8 byte

Ñ‚ø2äн¦

Hãy thử trực tuyến!

C (gcc) , 58 54 53 byte

• Đã lưu một byte nhờ Steadybox .

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

Hãy thử trực tuyến!

Python 2 , 51 byte

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

Hãy thử trực tuyến!

51 byte (nhờ Luis Mendo cho một byte)

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

Hãy thử trực tuyến!

51 byte

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

Hãy thử trực tuyến!

Haskell, 38 byte

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

Hãy thử trực tuyến!

APL (Dyalog) , 28 byte

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

Hãy thử trực tuyến!

Perl 6 , 38 byte

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

Thử nó

Mở rộng:

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

Hãy thử trực tuyến!

Giải trình

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

Phần ~×này không bao gồm 1s trong đầu ra của nó, vì vậy đối với đầu vào N, nó cho [N] thay vì [1, N] , mà sau đó được loại bỏ Ċ. Tôi không hoàn toàn chắc chắn tại sao ≜cần thiết ...

Japt , 9 byte

â¬Å£[XZo]

Kiểm tra nó trực tuyến! Trả về một mảng các mảng, với một số null ở cuối; -Rcờ được thêm vào để hiển thị đầu ra rõ ràng hơn.

Thạch , 8 byte

½ḊpP⁼¥Ðf

Một liên kết đơn âm lấy một số và trả về một danh sách các danh sách (cặp) số.

Hãy thử trực tuyến! (16777216ví dụtrên TIO choví dụ vì nó sẽ tạo ra một danh sách 68,7 tỷ cặp và lọc xuống những người có sản phẩm chính xác!)

Làm sao?

½Ḋ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, ngầm định tạo một phạm vi đầu vào số trước khi hành động và hàm phạm vi ngầm ẩn tầng đầu vào của nó, do đó, giả sử, n=24kết quả của ½là 4.898...; phạm vi trở thành [1,2,3,4]; và kết quả đã được giải quyết là[2,3,4]

** Tương tự như trên, psản phẩm của Cartesian, tạo phạm vi cho đầu vào số - ở đây, đối số đúng là ndo đó đối số đúng trở thành [1,2,3,...,n]trước khi sản phẩm Cartisian thực sự diễn ra.

Husk , 8 byte

tüOSze↔Ḋ

Hãy thử trực tuyến!

Giải trình

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

Bản giới thiệu

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

Dùng thử trực tuyến!

Python 2 , 59 byte

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

Hãy thử trực tuyến!

Thạch , 9 byte

ÆḌḊµżUṢ€Q

Hãy thử trực tuyến!

Octave , 42 byte

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

Hãy thử trực tuyến!

PHP, 70 byte

Dưới dạng chuỗi (70 byte):

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

Như kết xuất mảng (71 byte):

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

(tôi không chắc liệu tôi có thể sử dụng return $ b hay không; thay vì print_r vì nó không còn xuất ra mảng nữa, nếu không tôi có thể lưu 2 byte ở đây.)

Mảng cho kết quả như sau:

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

Thạch , 12 byte

ÆDµżUḣLHĊ$$Ḋ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Ngôn ngữ Wolfram (Mathicala) , 41 byte

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

Hãy thử trực tuyến!

là Functiontoán tử, giới thiệu một hàm không tên với tham số được đặt tên n.

Yếu tố , 58

Vâng, phải có một số yếu tố trong câu hỏi này!

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

Đó là một trích dẫn. callnó với số trên ngăn xếp, để lại một assoc(một mảng các cặp) trên ngăn xếp.

Tôi không bao giờ chắc chắn nếu tất cả hàng nhập khẩu có được tính hay không, vì chúng là một phần của ngôn ngữ. Cái này sử dụng:

USING: math.prime.factors sequences assocs math ;

(Nếu họ tính, tôi nên tìm kiếm một giải pháp dài hơn với hàng nhập khẩu ngắn hơn, đó là loại ngớ ngẩn)

Như một từ:

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

Đối với mỗi số lên đến sqrt (n), tạo cặp [[x, n/x]], sau đó lấy n%xphần tử thứ của mảng này. Nếu n%x==0đây là [x, n/x], nếu không nó nil. khi hoàn thành, loại bỏ tất cả nilkhỏi danh sách.

Pari / GP , 49 34 38 byte

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

Hãy thử trực tuyến!

Set ký hiệu xây dựng cho tất cả các cặp [d, n/d]ở đâu dchạy qua tất cả các ước dcủa nđối tượngd > 1 và d <= n/d.

Cải thiện rất lớn bởi alephalpha.

Husk , 14 12 byte

tumoOSe`/⁰Ḋ⁰

Hãy thử trực tuyến!

Giải trình

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 + THẮNG, 32 byte

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

Giải trình:

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

Thêm ++ , 18 15 byte

L,F@pB]dBRBcE#S

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Toán học, 53 byte

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

Hãy thử trực tuyến!

Befunge-93, 56 byte

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

Dùng thử trực tuyến

Julia 0,6 , 41 byte

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

Hãy thử trực tuyến!

Xác định lại toán tử đơn nguyên inbuild ~và sử dụng một sự hiểu biết mảng để xây dựng đầu ra.

• div(x,y)là cần thiết cho phân chia số nguyên. x/ytiết kiệm 5 byte nhưng đầu ra là ~4=(2,2.0).
• Julia cho phép xâu chuỗi các phép so sánh, tiết kiệm một byte.
• Vòng lặp tất cả các cách để x tránh Int(floor(√x)).

APL NARS 99 ký tự

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 Kiểm tra: (trong trường hợp không in gì, nó trả lại một cái gì đó nó trả về list danh sách null người ta phải xem là "không có giải pháp")

  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 byte

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

Tôi khá chắc chắn rằng điều này có thể được chơi golf.

Về cơ bản, thuật toán tạo ra một danh sách tất cả các ước của đầu vào (hãy gọi nó là n ), tạo cùng một danh sách, nhưng lật, xen kẽ hai (ví dụ: nếu n = 24, thì tại thời điểm này, nó có [ 1,24,2,12,3,8,4,6,6,4,8,3,12,2,24,1]) và in ra các phần tử từ chỉ số 2 cho đến một nửa chiều dài mảng, in từng phần số trên một dòng mới và có thêm một dòng mới ở giữa mỗi cặp.

Hầu hết các công việc được thực hiện trong việc thực sự quản lý ngăn xếp.

Đã lưu 2 byte bằng cách sử dụng hàm tăng.

Perl 5, 50 byte

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

Ung dung:

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

Hãy thử trực tuyến .