Doğal bir sayı verildiğinde n, elde etmek için kullanılabilecek tüm olası iki faktör çarpımlarının bir listesini almak için bir program veya işlev yazın n. Eğer gitmek ne gibi davrandı edilir daha iyi anlayabilmek için http://factornumber.com/?page=16777216 zaman görmek nolduğunu 16777216aşağıdaki listesini almak:

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

Burada olduğu gibi güzel şeyler yazdırmaya gerek yok. Gereklilik, her girişin (faktör çifti) birbirinden iyi ayırt edilmesi ve her çiftin içinde, ilk faktörün diğerinden de iyi ayırt edilmesidir. Bir liste / dizi döndürmeyi seçerseniz, iç öğe iki öğe içeren bir liste / dizi veya dilinizin C ++ gibi bir çift şeyi destekleyen bir yapısı olabilir std::pair.

Çarpmayı 1 girişle yazdırmayın veya girişleri ikinci faktör tarafından değiştirilen ilk faktörle tekrarlamayın, çünkü bunlar oldukça işe yaramaz.

Kazanan yok; dil bazında bir kod golf olacak.

Java (OpenJDK 8) , 81 66 65 bayt

• -15 Olivier Grégoire sayesinde bayt.
• -1 Bayt: ++j<=i/j-> j++<i/j.

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

Çevrimiçi deneyin!

Eski olan (referans için)

Java (OpenJDK 8) , 126 bayt

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

Çevrimiçi deneyin!

İlk kodgolf gönderimi ve ilk lambda kullanımı. Gelecekteki benlik, lütfen kod için beni affet.

05AB1E , 8 bayt

Ñ‚ø2äн¦

Çevrimiçi deneyin!

C (gcc) , 58 54 53 bayt

• Steadybox sayesinde bir bayt kaydetti .

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

Çevrimiçi deneyin!

Python 2 , 51 bayt

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

Çevrimiçi deneyin!

51 bayt (bir bayt için Luis Mendo'ya teşekkürler)

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

Çevrimiçi deneyin!

51 bayt

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

Çevrimiçi deneyin!

Haskell, 38 bayt

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

Çevrimiçi deneyin!

APL (Dyalog) , 28 bayt

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

Çevrimiçi deneyin!

Perl 6 , 38 bayt

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

Dene

Expanded:

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

{~×≜Ċo}ᵘ

Çevrimiçi deneyin!

açıklama

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

~×Parçası kadar giriş için, kendi çıkışı olarak 1s içermez , N o verir [N] yerine [1, N] , daha sonra tarafından itlaf edilir Ċ. Neden ≜gerekli olduğuna tam olarak emin değilim ...

Japt , 9 bayt

â¬Å£[XZo]

Çevrimiçi test edin! Sonunda bazı null değerleri olan bir dizi dizi döndürür; -Rçıktıyı daha net göstermek için bayrak eklendi.

Jöle , 8 bayt

½ḊpP⁼¥Ðf

Sayı alan ve sayı listelerinin (çiftlerinin) listesini döndüren monadik bir bağlantı.

Çevrimiçi deneyin! (1677721668.7 milyar çiftlik bir liste oluşturacağı ve doğru ürüne sahip olanlara filtreuygulayacağı için TIO'da zaman aşımına uğradı!)

Nasıl?

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

* Ḋ, Sıradan çıkarma, dolaylı önce hareket eden bir sayısal giriş, bir dizi ve aralık fonksiyonu böylece de bunlar dolaylı kat olan giriş, yapar n=24sonucu ½olduğu 4.898...; aralık olur [1,2,3,4]; ve dequeued sonuç[2,3,4]

** Yukarıdakine benzer şekilde p, Kartezyen ürün, sayısal girdi için aralıklar yapar - burada doğru argüman, gerçek nargümanın gerçekleşmesinden [1,2,3,...,n]önce doğru argüman olur .

Kabuk , 8 bayt

tüOSze↔Ḋ

Çevrimiçi deneyin!

açıklama

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 bayt

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

gösteri

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

Çevrimiçi Deneyin!

Python 2 , 59 bayt

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

Çevrimiçi deneyin!

Jöle , 9 bayt

ÆḌḊµżUṢ€Q

Çevrimiçi deneyin!

Oktav , 42 bayt

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

Çevrimiçi deneyin!

PHP, 70 bayt

Dize olarak (70 bayt):

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

Dizi dökümü olarak (71 bayt):

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

(i diziyi çıktısı olmadığı için print_r yerine i $ b;

Dizi aşağıdaki gibi sonuçlar verir:

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

Jöle , 12 bayt

ÆDµżUḣLHĊ$$Ḋ

Çevrimiçi deneyin!

Nasıl çalışır

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

Wolfram Dili (Mathematica) , 41 bayt

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

Çevrimiçi deneyin!

olduğu Functionparametrelerden isimsiz fonksiyonu getirmektedir operatörü n.

Faktör , 58

Bu soruda bazı Faktörler olmalı!

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

Bu bir teklif. callyığındaki sayı ile, yığın üzerinde bir assoc(çiftler dizisi) bırakır .

Dilin bir parçası oldukları için tüm ithalatın önemli olup olmadığından asla emin değilim. Bunu kullanır:

USING: math.prime.factors sequences assocs math ;

(Eğer sayılırlarsa, daha kısa ithalatla daha uzun bir çözüm aramalıyım, bu biraz saçma)

Tek kelimeyle:

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

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

Ruby , 43 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır:

Sqrt (n) 'ye kadar olan her sayı için çifti oluşturun [[x, n/x]], sonra n%xbu dizinin th öğesini alın . Eğer n%x==0bu [x, n/x], aksi takdirde var nil. bittiğinde, nillisteden tümünü kaldırın .

Pari / GP , 49 34 38 bayt

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

Çevrimiçi deneyin!

Tüm çiftleri için ayarla oluşturucu notasyonu tüm bölenler yoluyla çalışır arasında tabi ve .[d, n/d]ddnd > 1d <= n/d

Halepal tarafından büyük gelişme.

Kabuk , 14 12 bayt

tumoOSe`/⁰Ḋ⁰

Çevrimiçi deneyin!

açıklama

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 bayt

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

Açıklama:

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

++ , 18 15 bayt ekle

L,F@pB]dBRBcE#S

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Çevrimiçi deneyin!

Befunge-93, 56 bayt

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

Çevrimiçi Deneyin

Julia 0.6 , 41 bayt

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

Çevrimiçi deneyin!

Inbuild unary operatörünü yeniden tanımlar ~ve çıktıyı oluşturmak için bir dizi kavrama kullanır.

• div(x,y)tamsayı bölme için gereklidir. x/y5 bayt kaydeder, ancak çıkış ~4=(2,2.0).
• Julia karşılaştırmaları zincirlemeye izin vererek bir bayt kurtarır.
• X'e kadar olan döngüyü önler Int(floor(√x)).

APL NARS 99 karakter

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: (hiçbir şey basmazsa, geri döndürdüğü bir şeyi döndürür one liste "çözüm yok" olarak düşünülmelidir)

  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 bayt

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

Bunun golf oynayabileceğinden eminim.

Temel olarak, algoritma girişin tüm bölücülerinin bir listesini oluşturur (diyelim n diyelim ), aynı listeyi yapar, ancak ters çevrilir, ikisini araya ekler (örneğin, n = 24 ise, bu noktada, [ 1,24,2,12,3,8,4,6,6,4,8,3,12,2,24,1]) ve her birini yazdırarak dizin 2'den dizi uzunluğunun yarısına kadar öğeleri yazdırır yeni bir satırda numara ve her çift arasında ekstra yeni bir satır.

İşin çoğu, yığının yönetiminde yapılır.

Artış işlevi kullanılarak 2 bayt kaydedildi.

Perl 5, 50 bayt

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

Ungolfed:

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

Çevrimiçi deneyin .