Bir Gauss tamsayı olan gerçek ve sanal parça tamsayılardır kompleks bir sayıdır.

Gauss tamsayıları, sıradan tamsayılar gibi, Gaussian asalların ürünü olarak benzersiz bir şekilde temsil edilebilir. Buradaki zorluk, belirli bir Gauss tamsayı için ana bileşenleri hesaplamaktır.

Giriş: 0'a eşit olmayan ve bir birim olmayan bir Gauss tamsayı (yani, 1, -1, i ve -i girdi olarak verilemez). Herhangi bir mantıklı formatı kullanın, örneğin:

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

Çıktı: Asal olan (yani hiç kimse iki üniteli Gauss olmayan tamsayıya ait bir ürün olarak gösterilemez) ve ürünü giriş numarasına eşit olan bir Gauss tamsayı listesi. Çıktı listesindeki tüm sayılar önemsiz olmamalıdır, yani 1, -1, i veya -i değil. Herhangi bir mantıklı çıktı formatı kullanılabilir; mutlaka giriş formatı ile aynı olmamalıdır.

Çıkış listesinde 1'den fazla eleman varsa, birkaç doğru çıkış mümkündür. Örneğin, giriş 9 için çıkış [3, 3] veya [-3, -3] veya [3i, -3i] veya [-3i, 3i] olabilir.

Test durumları ( bu tablodan alınmış ; her test durumu için 2 satır)

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

Gauss tamsayılarını faktoring için yerleşik işlevlere izin verilmez. Yine de yerleşik tamsayılı fonksiyonlarla faktörü sıralamak mümkündür.

Jöle , 61 55 bayt

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

Çevrimiçi deneyin! (Üstbilgi ve Altbilgi çıktıyı biçimlendirir)

@EricTheOutgolfer sayesinde 6 bayt

Nasıl çalışır

Ḟ,Ċ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 bayt

-rprimeBayrağı kullanır .

Tanrım, ne dağınıklık.

Bu algoritmayı stackoverflow'tan kullanır.

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

Çevrimiçi deneyin!

Python 2 , 250 239 223 215 bayt

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

Çevrimiçi deneyin!

• Fonksiyon Argümanları Kullanırken -11 Bayt
• Çiftleri ayrıştırmak için bir değişken kullanılırken -2² * ² bayt (a,b)
• Sekmeleri ve boşlukları karıştırırken -2³ bayt: ovs sayesinde

Bazı açıklamalar, bir kompleksi mümkün olmadığı kadar, iki kompleksi tekrarlayan bir şekilde ayrıştırır ...

Pas - 212 bayt

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

% 100 doğru çalıştığından% 100 emin değilim, ancak çok çeşitli testler için doğru gibi görünüyor. Bu Jelly'ten daha küçük değildir, fakat en azından yorumlanan dillerden daha küçüktür (şimdiye kadar). Aynı zamanda daha hızlı görünüyor ve bir saniyeden daha kısa bir sürede milyarlarca dolarlık girdilerle çalışabiliyor. Örneğin 1234567890 + 3141592650i (-9487 + 7990i) (- 1 + -1i) (- 395 + 336i) (2 + -1i) (1 + 1i) (3 + 0i) (3 + 0i) (4+ 1i) (- 1 + 1i) (- 1 + 2i), (wolfram alpha'da test etmek için buraya tıklayın)

Bu, tamsayıların saf faktoringi ile aynı fikir olarak başladı, söz konusu tamsayı altındaki her sayıdan geçmek, ayrılıp ayrılmadığını görmek, yapılana kadar tekrarlayın. Sonra, diğer cevaplardan esinlenerek, bir vektörün maddelerini tekrar tekrar faktörler haline getirdi. Bu, bunu bir çok kez yapar, ancak 'hiçbir şey' 'e kadar' olmaz. Yinelemelerin sayısı, makul miktarda girdiyi kapsayacak şekilde seçilmiştir.

Bir tamsayının diğerinden ayrılıp ayrılmadığını test etmek için hala "(a mod b) == 0" kullanır (Gausslar için, yerleşik Rust gaussian modulo kullanırız ve "0" ı norm == 0 olarak kabul ederiz), ancak 'norm (' a / b)! = 1 '"çok fazla" bölünmeyi önler, temelde elde edilen vektörün sadece primerler ile doldurulmasına izin verir, fakat vektörün herhangi bir elemanını birliğe indirmez (0-i, 0 + i, -1 + 0i, 1 + 0i) (soru tarafından yasaklanmıştır).

For-loop sınırları deney boyunca bulundu. y, sıfıra bölme paniklerinin önlenmesi için 1'den yukarıya gider ve Gauss'ların kadranlara yansıması sayesinde x -999'dan 0'a gidebilir (sanırım?). Sınırlamalar ile ilgili olarak, asıl soru geçerli bir girdi / çıktı aralığını göstermedi, bu yüzden "makul bir girdi boyutu" kabul edildi ... (Düzenle ... ancak bunun bu sayıyı nasıl hesaplayacağından emin değilim. "başarısız" olmaya başladım, 999'un altındaki herhangi bir şey tarafından bölünemeyen fakat hala benim için şaşırtıcı derecede küçük Gauss tam sayıları olduğunu hayal ediyorum)

Üzerinde biraz ungolfed sürümünü deneyin play.rust-lang.org

Perl 6 , 141 124 bayt

-17 baytlık Jo King'e teşekkürler

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

Çevrimiçi deneyin!

Pyth , 54 51 45 42 36 bayt

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

Çevrimiçi deneyin!

Şeklinde girişlerini kabul 1+2j- saf biçimde reel veya sanal sayılar başka bir bileşen göz ardı edilebilir (örneğin 9, 2j). Çıktı, yeni bir çizgiyle ayrılmış karmaşık sayılar listesidir, formda (1+2j), tamamen hayali sayılar gerçek kısmı çıkarmaktadır.

Bu, mevcut değerden 1'den büyük ve daha küçük olan tüm Gauss tam sayılarını ve ayrıca değerin kendisini üreten basit iz bölümü kullanır. Bunlar, değerin bir faktörü olanları korumak için filtrelenir ve bir sonraki ana faktör olarak en küçüğüne göre seçilir. Bu çıktıdır ve değer, bir sonraki yinelemenin değerini üretmek için bölünür.

Ayrıca, Pyth Jelly'i dövüyor 😲 (Yine de sürmesini beklemiyorum)

 .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