Dado un número natural, nescriba un programa o función para obtener una lista de todas las multiplicaciones posibles de dos factores que se pueden usar para lograr n. Para entender mejor lo que se pretende se puede ir a http://factornumber.com/?page=16777216 para ver cuando nes 16777216que obtenemos la siguiente lista:

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

No es necesario imprimir cosas bonitas como aquí. El requisito es que cada entrada (par de factores) se distinga bien entre sí y dentro de cada par, el primer factor también se distingue bien del otro. Si elige devolver una lista / matriz, el elemento interno puede ser una lista / matriz con dos elementos, o alguna estructura de su lenguaje que admita un par de cosas como C ++ std::pair.

No imprima la multiplicación por 1 entrada, ni repita las entradas con el primer factor conmutado por el segundo, ya que son bastante inútiles.

Sin ganador; será un código de golf por idioma.

Java (OpenJDK 8) , 81 66 65 bytes

• -15 Bytes gracias 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);}

Pruébalo en línea!

Viejo (para referencia)

Java (OpenJDK 8) , 126 bytes

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

Pruébalo en línea!

Primer envío de codegolf y primer uso de lambda. Yo futuro, perdóname por el código.

05AB1E , 8 bytes

Ñ‚ø2äн¦

Pruébalo en línea!

C (gcc) , 58 54 53 bytes

• Guardado un byte gracias a Steadybox .

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

Pruébalo en línea!

Python 2 , 51 bytes

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

Pruébalo en línea!

51 bytes (gracias a Luis Mendo por un byte)

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

Pruébalo en línea!

51 bytes

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

Pruébalo en línea!

Haskell, 38 bytes

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

Pruébalo en línea!

APL (Dyalog) , 28 bytes

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

Pruébalo en línea!

Perl 6 , 38 bytes

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

Intentalo

Expandido:

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

{~×≜Ċo}ᵘ

Pruébalo en línea!

Explicación

{~×≜Ċ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 no incluye 1s en su salida, por lo que para la entrada N da [N] en lugar de [1, N] , que luego se selecciona Ċ. No estoy completamente seguro de por qué ≜es necesario ...

Japt , 9 bytes

â¬Å£[XZo]

¡Pruébalo en línea! Devuelve una matriz de matrices, con algunos nulos al final; -Rbandera agregada para mostrar la salida más claramente.

Jalea , 8 bytes

½ḊpP⁼¥Ðf

Un enlace monádico que toma un número y devuelve una lista de listas (pares) de números.

Pruébalo en línea! (se agota el tiempo de espera de TIO para el16777216ejemplo, ya que crearía una lista de 68.7 mil millones de pares y se filtraría a aquellos con el producto correcto)

¿Cómo?

½Ḋ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, hace implícitamente un rango de una entrada numérica antes de actuar, y la función de rango pone implícitamente su entrada, por lo que, por ejemplo, con n=24el resultado de ½es 4.898...; el rango se vuelve [1,2,3,4]; y el resultado retrasado es[2,3,4]

** De manera similar a lo anterior, el pproducto cartesiano crea rangos para la entrada numérica; aquí, el argumento correcto es, npor lo tanto, el argumento correcto se convierte en [1,2,3,...,n]anterior a que tenga lugar el producto cartisiano real.

Casco , 8 bytes

tüOSze↔Ḋ

Pruébalo en línea!

Explicación

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 bytes

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

Manifestación

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

¡Pruébelo en línea!

Python 2 , 59 bytes

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

Pruébalo en línea!

Jalea , 9 bytes

ÆḌḊµżUṢ€Q

Pruébalo en línea!

Octava , 42 bytes

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

Pruébalo en línea!

PHP, 70 bytes

Como cadena (70 bytes):

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

Como volcado de matriz (71 bytes):

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

(No estoy seguro de si puedo usar return $ b; en lugar de print_r ya que ya no genera la matriz, de lo contrario, puedo guardar 2 bytes aquí).

La matriz da los resultados como:

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

Jalea , 12 bytes

ÆDµżUḣLHĊ$$Ḋ

Pruébalo en línea!

Cómo funciona

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

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

Pruébalo en línea!

es el Functionoperador, que introduce una función sin nombre con parámetro con nombre n.

Factor , 58

Bueno, tiene que haber algún factor en esta pregunta.

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

Es una cita callcon el número en la pila, deja un assoc(un conjunto de pares) en la pila.

Nunca estoy seguro de si todas las importaciones cuentan o no, ya que son parte del lenguaje. Este usa:

USING: math.prime.factors sequences assocs math ;

(Si cuentan, debería buscar una solución más larga con importaciones más cortas, lo cual es un poco tonto)

Como una palabra:

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

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

Ruby , 43 bytes

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

Pruébalo en línea!

Cómo funciona:

Para cada número hasta sqrt (n), genere el par [[x, n/x]], luego tome el n%xelemento th de esta matriz. Si n%x==0es así [x, n/x], de lo contrario lo es nil. cuando termine, elimine todo nilde la lista.

Pari / GP , 49 34 38 bytes

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

Pruébalo en línea!

Establezca la notación de constructor para todos los pares [d, n/d]donde se dejecuta a través de todos los divisores dde nsujeto a d > 1y d <= n/d.

Gran mejora por alephalpha.

Casco , 14 12 bytes

tumoOSe`/⁰Ḋ⁰

Pruébalo en línea!

Explicación

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 bytes

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

Explicación:

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

Agregar ++ , 18 15 bytes

L,F@pB]dBRBcE#S

Pruébalo en línea!

Cómo funciona

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

Pruébalo en línea!

Befunge-93, 56 bytes

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

Pruébalo en línea

Julia 0.6 , 41 bytes

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

Pruébalo en línea!

Redefine el operador unario incorporado ~y utiliza una comprensión de matriz para generar la salida.

• div(x,y)es necesario para la división de enteros. x/yahorra 5 bytes pero la salida es~4=(2,2.0) .
• Julia permite encadenar las comparaciones, ahorrando un byte.
• Looping todo el camino a x evita Int(floor(√x)).

APL NARS 99 caracteres

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 Prueba: (donde no imprime nada, devuelve algo que devuelve ⍬ la lista nula que hay que considerar como "sin solución")

  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 bytes

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

Estoy bastante seguro de que esto se puede jugar al golf.

Básicamente, el algoritmo genera una lista de todos los divisores de la entrada (llamémosla n ), hace la misma lista, pero invertida, intercala los dos (por ejemplo, si n = 24, entonces, en este punto, tiene [ 1,24,2,12,3,8,4,6,6,4,8,3,12,2,24,1]) e imprime los elementos desde el índice 2 hasta la mitad de la longitud de la matriz, imprimiendo cada uno número en una nueva línea, y con una nueva línea adicional entre cada par.

La mayor parte del trabajo se realiza en la gestión real de la pila.

Se guardaron 2 bytes utilizando la función de incremento.

Perl 5, 50 bytes

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

Sin golf:

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

Pruébalo en línea .