Dato un numero naturale, nscrivere un programma o una funzione per ottenere un elenco di tutte le possibili due moltiplicazioni di fattori che possono essere utilizzate per ottenere n. Per capire meglio cosa si pretende, puoi visitare http://factornumber.com/?page=16777216 per vedere quando nviene visualizzato 16777216il seguente elenco:

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

Non c'è bisogno di stampare cose come qui. Il requisito è che ogni voce (coppia di fattori) sia ben distinta l'una dall'altra e all'interno di ciascuna coppia, anche il primo fattore sia ben distinto dall'altro. Se si sceglie di restituire un elenco / array, l'elemento inside può essere un elenco / array con due elementi o una struttura della propria lingua che supporta una coppia di cose come C ++ std::pair.

Non stampare la moltiplicazione per 1 voce, né ripetere le voci con il primo fattore commutato dal secondo, poiché sono piuttosto inutili.

Nessun vincitore; sarà un codice golf per lingua base.

Java (OpenJDK 8) , 81 66 65 byte

• -15 byte grazie a 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);}

Provalo online!

Quello vecchio (per riferimento)

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

Provalo online!

Primo invio di codegolf e primo utilizzo lambda. Sé futuro, ti prego di perdonarmi per il codice.

05AB1E , 8 byte

Ñ‚ø2äн¦

Provalo online!

C (gcc) , 58 54 53 byte

• Salvataggio di un byte grazie a Steadybox .

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

Provalo online!

Python 2 , 51 byte

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

Provalo online!

51 byte (grazie a Luis Mendo per un byte)

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

Provalo online!

51 byte

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

Provalo online!

Haskell, 38 byte

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

Provalo online!

APL (Dyalog) , 28 byte

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

Provalo online!

Perl 6 , 38 byte

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

Provalo

Allargato:

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

Provalo online!

Spiegazione

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

La ~×parte non include 1s nel suo output, quindi per l'ingresso N fornisce [N] invece di [1, N] , che viene successivamente abbattuto da Ċ. Non sono del tutto sicuro del perché ≜sia necessario ...

Japt , 9 byte

â¬Å£[XZo]

Provalo online! Restituisce una matrice di array, con alcuni null alla fine; -Rflag aggiunto per mostrare l'output più chiaramente.

Gelatina , 8 byte

½ḊpP⁼¥Ðf

Un collegamento monadico che prende un numero e restituisce un elenco di liste (coppie) di numeri.

Provalo online! (timeout su TIO per il16777216 esempio poiché creerebbe un elenco di 68,7 miliardi di paia e filtrerebbe fino a quelli con il prodotto corretto!)

Come?

½Ḋ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, crea implicitamente un intervallo di un input numerico prima di agire, e la funzione range determina implicitamente il suo input, quindi con, diciamo, n=24il risultato di ½è 4.898...; la gamma diventa [1,2,3,4]; e il risultato dequeued è[2,3,4]

** Analogamente a quanto sopra, il pprodotto cartesiano crea intervalli per l'input numerico: qui l'argomento giusto è nquindi l'argomento giusto [1,2,3,...,n]prima dell'effettivo prodotto cartisiano in corso.

Buccia , 8 byte

tüOSze↔Ḋ

Provalo online!

Spiegazione

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

dimostrazione

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

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

Provalo online!

Gelatina , 9 byte

ÆḌḊµżUṢ€Q

Provalo online!

Ottava , 42 byte

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

Provalo online!

PHP, 70 byte

Come stringa (70 byte):

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

Come dump di array (71 byte):

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

(Non sono sicuro di poter utilizzare return $ b; invece di print_r poiché non genera più l'array, altrimenti posso salvare 2 byte qui.)

La matrice fornisce i risultati come:

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

Gelatina , 12 byte

ÆDµżUḣLHĊ$$Ḋ

Provalo online!

Come funziona

Æ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 Language (Mathematica) , 41 byte

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

Provalo online!

è l' Functionoperatore, che introduce una funzione senza nome con parametro denominato n.

Fattore , 58

Bene, ci deve essere un fattore in questa domanda!

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

È una citazione. callcon il numero in pila, lascia un assoc(un array di coppie) in pila.

Non sono mai sicuro che tutte le importazioni contino o meno, poiché fanno parte della lingua. Questo usa:

USING: math.prime.factors sequences assocs math ;

(Se contano, dovrei cercare una soluzione più lunga con importazioni più brevi, che è un po 'sciocca)

Come una parola:

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

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

Rubino , 43 byte

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

Provalo online!

Come funziona:

Per ogni numero fino a sqrt (n), genera la coppia [[x, n/x]], quindi prendi l' n%xelemento th di questo array. Se n%x==0questo è [x, n/x], altrimenti lo è nil. al termine, rimuovere tutto nildall'elenco.

Pari / GP , 49 34 38 byte

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

Provalo online!

Imposta la notazione del costruttore per tutte le coppie in [d, n/d]cui dscorre tutti i divisori ddi nsoggetto a d > 1e d <= n/d.

Enorme miglioramento di alephalpha.

Buccia , 14 12 byte

tumoOSe`/⁰Ḋ⁰

Provalo online!

Spiegazione

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

Spiegazione:

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

Add++, 18 15 bytes

L,F@pB]dBRBcE#S

Try it online!

How it works

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!

Ridefinisce l'operatore unario inbuild ~e utilizza una comprensione dell'array per creare l'output.

• div(x,y)è necessario per la divisione dei numeri interi. x/ysalva 5 byte ma l'output è~4=(2,2.0) .
• Julia consente di concatenare i confronti, salvando un byte.
• Il looping fino a x evita Int(floor(√x)).

APL NARS 99 caratteri

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: (dove non stampa nulla, restituisce qualcosa restituisce ⍬ l'elenco null si deve considerare come "nessuna soluzione")

  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Ș<łĉ

Sono abbastanza sicuro che questo possa essere giocato a golf.

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.