Dado um número natural, nescreva um programa ou função para obter uma lista de todas as possíveis multiplicações de dois fatores que podem ser usadas para obter n. Para entender melhor o que se pretende você pode ir para http://factornumber.com/?page=16777216 para ver quando né 16777216que recebo a seguinte 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

Não há necessidade de imprimir coisas bonitas como aqui. O requisito é que cada entrada (par de fatores) seja bem distinta uma da outra e, dentro de cada par, o primeiro fator também seja bem distinto da outra. Se você optar por retornar uma lista / matriz, o elemento interno poderá ser uma lista / matriz com dois elementos ou alguma estrutura da sua linguagem que suporte um par de coisas como C ++ std::pair.

Não imprima a multiplicação por 1 entrada, nem repita as entradas com o primeiro fator comutado pela segunda, pois elas são bastante inúteis.

Nenhum vencedor; será um código de idioma por idioma.

Java (OpenJDK 8) , 81 66 65 bytes

• -15 Bytes graças 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);}

Experimente online!

Antigo (para referência)

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

Experimente online!

Primeiro envio de codegolf e primeiro uso de lambda. Eu futuro, por favor, perdoe-me pelo código.

05AB1E , 8 bytes

Ñ‚ø2äн¦

Experimente online!

C (gcc) , 58 54 53 bytes

• Guardou um byte graças ao Steadybox .

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

Experimente online!

Python 2 , 51 bytes

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

Experimente online!

51 bytes (graças a Luis Mendo por um byte)

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

Experimente online!

51 bytes

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

Experimente online!

Haskell, 38 bytes

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

Experimente online!

APL (Dyalog) , 28 bytes

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

Experimente online!

Perl 6 , 38 bytes

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

Tente

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
}

Braquilog , 8 bytes

{~×≜Ċo}ᵘ

Experimente online!

Explicação

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

A ~×peça não inclui 1s em sua saída; portanto, para a entrada N , fornece [N] em vez de [1, N] , que é posteriormente descartado Ċ. Não sei ao certo por que ≜é necessário ...

Japonês , 9 bytes

â¬Å£[XZo]

Teste online! Retorna uma matriz de matrizes, com alguns valores nulos no final; -Rsinalizador adicionado para mostrar a saída mais claramente.

Geléia , 8 bytes

½ḊpP⁼¥Ðf

Um link monádico que pega um número e retorna uma lista de listas (pares) de números.

Experimente online! (o tempo limite é excedido no TIO, por16777216exemplo, pois ele criaria uma lista de 68,7 bilhões de pares e seria filtrada para aqueles com o produto correto!)

Quão?

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

* Ḋ, desenfileirar, faz implicitamente um intervalo de uma entrada numérica antes de agir, e a função range implicitamente coloca sua entrada, assim com, digamos, n=24o resultado de ½é 4.898...; o alcance se torna [1,2,3,4]; e o resultado desenfileirado é[2,3,4]

** Da mesma forma que acima, o pproduto cartesiano faz intervalos para entrada numérica - aqui o argumento correto é, nportanto, o argumento correto torna-se [1,2,3,...,n]antes do produto cartisiano real ocorrer.

Casca , 8 bytes

tüOSze↔Ḋ

Experimente online!

Explicação

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

Demo

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

Experimente Online!

Python 2 , 59 bytes

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

Experimente online!

Geléia , 9 bytes

ÆḌḊµżUṢ€Q

Experimente online!

Oitava , 42 bytes

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

Experimente online!

PHP, 70 bytes

Como sequência (70 bytes):

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

Como despejo de matriz (71 bytes):

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

(não tenho certeza se posso usar return $ b; em vez de print_r, pois ele não gera mais a matriz, caso contrário, posso salvar 2 bytes aqui.)

A matriz fornece os resultados como:

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

Gelatina , 12 bytes

ÆDµżUḣLHĊ$$Ḋ

Experimente online!

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

Experimente online!

é o Functionoperador, que introduz uma função sem nome com o parâmetro nomeado n.

Fator , 58

Bem, tem que haver algum fator nessa questão!

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

É uma citação. callcom o número na pilha, deixa um assoc(uma matriz de pares) na pilha.

Nunca tenho certeza se todas as importações contam ou não, pois fazem parte do idioma. Este usa:

USING: math.prime.factors sequences assocs math ;

(Se contar, devo procurar uma solução mais longa com importações mais curtas, o que é meio bobo)

Como uma palavra:

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

Experimente online!

Como funciona:

Para cada número até sqrt (n), gere o par e [[x, n/x]], em seguida, pegue o n%xth elemento desta matriz. Se for n%x==0esse o [x, n/x]caso, é nil. Quando terminar, remova tudo nilda lista.

Pari / GP , 49 34 38 bytes

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

Experimente online!

Defina a notação do construtor para todos os pares em [d, n/d]que dpercorre todos os divisores dde nsujeito a d > 1e d <= n/d.

Grande melhoria por alefhalpha.

Casca , 14 12 bytes

tumoOSe`/⁰Ḋ⁰

Experimente online!

Explicação

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

Explicação:

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

Adicionar ++ , 18 15 bytes

L,F@pB]dBRBcE#S

Experimente online!

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

Experimente online!

Befunge-93, 56 bytes

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

Experimente Online

Julia 0.6 , 41 bytes

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

Experimente online!

Redefine o operador unbuild inbuild ~e usa uma compreensão de array para criar a saída.

• div(x,y)é necessário para a divisão inteira. x/ysalva 5 bytes, mas a saída é~4=(2,2.0) .
• Julia permite encadear as comparações, economizando um byte.
• Looping todo o caminho para 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 Teste: (onde não imprime nada, retorna algo que retorna ⍬ a lista nula deve ser considerada como "nenhuma solução")

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

Tenho certeza de que isso pode ser jogado.

Basicamente, o algoritmo gera uma lista de todos os divisores da entrada (vamos chamá-lo n ), faz a mesma lista, mas invertida, intercala os dois (por exemplo, se n = 24, então, neste ponto, ele tem [ 1,24,2,12,3,8,4,6,6,4,8,3,12,2,24,1]) e imprime os elementos do índice 2 até metade do comprimento da matriz, imprimindo cada número em uma nova linha e com uma nova linha extra entre cada par.

A maior parte do trabalho é realizada no gerenciamento da pilha.

2 bytes salvos usando a função de incremento.

Perl 5, 50 bytes

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

Ungolfed:

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

Experimente online .