Một số nguyên Gaussian là một số phức có phần thực và phần ảo là số nguyên.

Các số nguyên Gaussian, giống như các số nguyên thông thường, có thể được biểu diễn dưới dạng một sản phẩm của các số nguyên tố Gaussian, theo cách thức duy nhất. Thách thức ở đây là tính toán các thành phần nguyên tố của một số nguyên Gauss cho trước.

Đầu vào: một số nguyên Gaussian, không bằng 0 và không phải là một đơn vị (nghĩa là 1, -1, i và -i không thể được cung cấp làm đầu vào). Sử dụng bất kỳ định dạng hợp lý, ví dụ:

• 4-5i
• -5 * j + 4
• (4, -5)

Đầu ra: một danh sách các số nguyên Gaussian, là số nguyên tố (nghĩa là không ai trong số chúng có thể được biểu diễn dưới dạng sản phẩm của hai số nguyên Gaussian không đơn vị) và có sản phẩm bằng số đầu vào. Tất cả các số trong danh sách đầu ra phải không tầm thường, tức là không phải 1, -1, i hoặc -i. Bất kỳ định dạng đầu ra hợp lý có thể được sử dụng; nó không nhất thiết phải giống như định dạng đầu vào.

Nếu danh sách đầu ra có nhiều hơn 1 phần tử, thì có thể có một số đầu ra chính xác. Ví dụ: đối với đầu vào 9, đầu ra có thể là [3, 3] hoặc [-3, -3] hoặc [3i, -3i] hoặc [-3i, 3i].

Các trường hợp thử nghiệm, (lấy từ bảng này ; 2 dòng cho mỗi trường hợp thử nghiệm)

2
1+i, 1-i

3i
3i

256
1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i,1+i

7+9i
1+i,2−i,3+2i

27+15i
1+i,3,7−2i

6840+585i
-1-2i, 1+4i, 2+i, 3, 3, 6+i, 6+i

Các hàm tích hợp để bao thanh toán các số nguyên Gaussian không được phép. Bao thanh toán các số nguyên thông thường bằng các hàm tích hợp được cho phép mặc dù.

Thạch , 61 55 byte

Ḟ,Ċ1ḍP
Ḟ,ĊḤp/-,1p`¤×€×1,ıFs2S€⁸÷ÇÐfỊÐḟ1;Ṫð,÷@\ḟ1
Ç€F$ÐL

Hãy thử trực tuyến! (Header và Footer định dạng đầu ra)

-6 byte nhờ @EricTheOutgolfer

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

Ḟ,Ċ1ḍP  - helper function: determines if a complex number is Gaussian
Ḟ,Ċ       - real, complex components
   1ḍ     - set each to if 1 divides them
     P    - all

Ḟ,ĊḤp/-,1p`¤×€×1,ıFs2S€⁸÷ÇÐfỊÐḟ1;Ṫð,÷@\ḟ1 - helper: outputs a factor pair of the input
Ḟ,ĊḤp/                   - creates a list of possible factors a+bi, a,b>=0
      -,1p`¤×€           - extend to the other three quadrants 
              ×1,ıFs2S€  - convert to  actual complex numbers 
⁸÷                       - get quotient with input complex number
  ÇÐf                    - keep only Gaussian numbers (using helper function)
     ỊÐḟ                 - remove units (i,-i,1,-1)
        1;               - append a 1 to deal with primes having no non-unit factors
          Ṫð,÷@\         - convert to a factor pair
                ḟ1       - remove 1s
Ç€F$ÐL
Ç€      - factor each number
   $    - and
  F     - flatten the list
    ÐL  - until factoring each number and flattening does not change the list

Ruby , 258 256 249 246 + 8 = 264 257 254 byte

Sử dụng -rprimecờ.

Trời ạ, thật là bừa bộn.

Sử dụng thuật toán này từ stackoverflow.

->c{m=->x,y{x-y*eval("%d+%di"%(x/y).rect)};a=c.abs2.prime_division.flat_map{|b,e|b%4<2?(1..e).map{k=(2..d=b).find{|n|n**(~-b/2)%b==b-1}**(~-b/4)%b+1i;d,k=k,m[d,k]while k!=0;c/=d=m[c,d]==0?d:d.conj;d}:(c/=b<3?(b=1+1i)**e:b**e/=2;[b]*e)};a[0]*=c;a}

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

Python 2 , 250 239 223 215 byte

e,i,w=complex,int,abs
def f(*Z):
 if Z:
	z=Z[0];q=i(w(z));Q=4*q*q
	while Q>0:
 	 a=Q/q-q;b=Q%q-q;x=e(a,b)
 	 if w(x)>1:
		y=z/x
		if w(y)>1 and y==e(i(y.real),i(y.imag)):f(x,y);z=Q=0
 	 Q-=1
	if z:print z
	f(*Z[1:])

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

• -11 byte khi sử dụng nhiều đối số chức năng
• -2² * ² byte khi sử dụng một biến để phân tích các cặp (a,b)
• -2³ byte khi trộn các tab và dấu cách: nhờ vào các ô

Một số giải thích đệ quy phân tách một phức thành hai phức cho đến khi không thể phân tách được ...

Rust - 212 byte

use num::complex::Complex as C;fn f(a:&mut Vec<C<i64>>){for _ in 0..2{for x in -999..0{for y in 1..999{for i in 0..a.len(){let b=C::new(x,y);if(a[i]%b).norm_sqr()==0&&(a[i]/b).norm_sqr()>1{a[i]/=b;a.push(b)}}}}}}

Tôi không chắc chắn 100% nếu điều này hoạt động chính xác 100%, nhưng dường như là chính xác cho một loạt các thử nghiệm. Điều này không nhỏ hơn Jelly, nhưng ít nhất nó nhỏ hơn các ngôn ngữ được dịch (cho đến nay). Nó dường như cũng nhanh hơn và có thể hoạt động thông qua các đầu vào của một tỷ độ trong chưa đầy một giây. Ví dụ: các yếu tố 1234567890 + 3141592650i là (-9487 + 7990i) (- 1 + -1i) (- 395 + 336i) (2 + -1i) (1 + 1i) (3 + 0i) (3 + 0i) (4+ 1i) (- 1 + 1i) (- 1 + 2i), (bấm vào đây để kiểm tra trên wolfram alpha)

Điều này bắt đầu như một ý tưởng giống như bao thanh toán ngây thơ của các số nguyên, để đi qua từng số bên dưới số nguyên trong câu hỏi, xem nếu nó chia, lặp lại cho đến khi hoàn thành. Sau đó, lấy cảm hứng từ các câu trả lời khác, nó biến hình ... nó lặp đi lặp lại các yếu tố trong một vectơ. Nó làm điều này một số lần tốt, nhưng không "cho đến khi" bất cứ điều gì. Số lần lặp đã được chọn để bao gồm một lượng tốt các đầu vào hợp lý.

Nó vẫn sử dụng "(a b a / b)! = 1 'ngăn chia "quá nhiều", về cơ bản cho phép vectơ kết quả chỉ được điền vào các số nguyên tố, nhưng không đưa bất kỳ phần tử nào của vectơ xuống thống nhất (0-i, 0 + i, -1 + 0i, 1 + 0i) (bị cấm bởi câu hỏi).

Các giới hạn vòng lặp for đã được tìm thấy thông qua thử nghiệm. y đi từ 1 lên để ngăn chặn sự hoảng loạn chia cho 0 và x có thể đi từ -999 đến 0 nhờ sự phản chiếu của Gaussian trên các góc phần tư (tôi nghĩ sao?). Liên quan đến các hạn chế, câu hỏi ban đầu không chỉ ra phạm vi đầu vào / đầu ra hợp lệ, do đó, "kích thước đầu vào hợp lý" được giả sử ... (Chỉnh sửa ... tuy nhiên tôi không chắc chắn chính xác cách tính số này sẽ bắt đầu "thất bại", tôi tưởng tượng có những số nguyên Gaussian không chia hết cho bất cứ thứ gì dưới 999 nhưng vẫn nhỏ đáng ngạc nhiên đối với tôi)

Hãy thử phiên bản hơi vô dụng trên play.rust-lang.org

Perl 6 , 141 124 byte

Cảm ơn Jo King vì -17 byte

sub f($_){{$!=0+|sqrt .abs²-$^a²;{($!=$_/my \w=$^b+$a*i)==$!.floor&&.abs>w.abs>1>return f w&$!}for -$!..$!}for ^.abs;.say}

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

Pyth , 54 51 45 42 36 byte

 .W>H1cZ
h+.aDf!%cZT1>#1.jM^s_BM.aZ2

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

Chấp nhận đầu vào theo hình thức 1+2j- số thuần túy thật hay tưởng tượng có thể bỏ qua các thành phần khác (ví dụ 9, 2j). Đầu ra là một danh sách các số phức được phân tách bằng dòng mới, ở dạng (1+2j), với các số hoàn toàn là tưởng tượng bỏ qua phần thực.

Điều này sử dụng phân chia đường đơn giản, tạo ra tất cả các số nguyên gaussian có cường độ lớn hơn 1 và nhỏ hơn giá trị hiện tại, cộng với chính giá trị đó. Chúng được lọc để giữ những yếu tố là một yếu tố của giá trị và nhỏ nhất theo độ lớn được chọn làm yếu tố chính tiếp theo. Đây là đầu ra và giá trị được chia cho nó để tạo ra giá trị cho lần lặp tiếp theo.

Ngoài ra, Pyth đập Jelly (Tôi không mong đợi nó sẽ kéo dài)

 .W>H1cZ¶h+.aDf!%cZT1>#1.jM^s_BM.aZ2ZQ   Implicit: Q=eval(input())
                                         Newline replaced with ¶, trailing ZQ inferred
 .W                                  Q   While <condition>, execute <inner>, with starting value Q
   >H1                                   Condition function, input H
   >H1                                     Is magnitude of H > 1?
                                           This ensures loop continues until H is a unit, i.e. 1, -1, j, or -j)
      cZ¶h+.aDf!%cZT1>#1.jM^s_BM.aZ2Z    Inner function, input Z
                                .aZ        Take magnitude of Z

                             _BM           Pair each number in 0-indexed range with its negation
                            s              Flatten
                           ^       2       Cartesian product of the above with itself
                        .jM                Convert each pair to a complex number
                      #                    Filter the above to keep those element where...
                     > 1                   ... the magnitude is greater than 1 (removes units)
              f                            Filter the above, as T, to keep where:
                 cZT                         Divide Z by T
                %   1                        Mod real and imaginary parts by 1 separately
                                             If result of division is a gaussian integer, the mod will give (0+0j)
               !                             Logical NOT - maps (0+0j) to true, all else to false
                                           Result of filter are those gaussian integers which evenly divide Z
           .aD                             Sort the above by their magnitudes
          +                         Z      Append Z - if Z is ±1±1j, the filtered list will be empty
         h                                 Take first element, i.e. smallest factor
        ¶                                  Print with a newline
      cZ                                   Divide Z by that factor - this is new input for next iteration
                                         Output of the while loop is always 1 (or -1, j, or -j) - leading space suppesses output