Étant donné un nombre naturel, nécrivez un programme ou une fonction pour obtenir une liste de toutes les multiplications possibles à deux facteurs pouvant être utilisées n. Pour mieux comprendre ce qui est prétendu , vous pouvez aller à http://factornumber.com/?page=16777216 pour voir quand nest 16777216nous obtenons la liste suivante:

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

Pas besoin d'imprimer des choses comme ici. L'exigence est que chaque entrée (paire de facteurs) soit bien distinguée les unes des autres et à l'intérieur de chaque paire, le premier facteur soit également bien distingué de l'autre. Si vous choisissez de renvoyer une liste / un tableau, l'élément interne peut être une liste / un tableau avec deux éléments, ou une structure de votre langage qui prend en charge une paire de choses comme C ++ std::pair.

N'imprimez pas la multiplication par 1 entrée, et ne répétez pas les entrées avec le premier facteur commué par le second, car elles sont assez inutiles.

Aucun gagnant; ce sera un golf par code de base linguistique.

Java (OpenJDK 8) , 81 66 65 octets

• -15 octets grâce à Olivier Grégoire.
• -1 octet: ++j<=i/j-> j++<i/j.

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

Essayez-le en ligne!

Ancien (pour référence)

Java (OpenJDK 8) , 126 octets

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

Essayez-le en ligne!

Première soumission de codegolf et première utilisation de lambda. Futur moi, veuillez me pardonner le code.

05AB1E , 8 octets

Ñ‚ø2äн¦

Essayez-le en ligne!

C (gcc) , 58 54 53 octets

• Enregistré un octet grâce à Steadybox .

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

Essayez-le en ligne!

Python 2 , 51 octets

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

Essayez-le en ligne!

51 octets (merci à Luis Mendo pour un octet)

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

Essayez-le en ligne!

51 octets

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

Essayez-le en ligne!

Haskell, 38 octets

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

Essayez-le en ligne!

APL (Dyalog) , 28 octets

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

Essayez-le en ligne!

Perl 6 , 38 octets

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

Essayez-le

Étendu:

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

{~×≜Ċo}ᵘ

Essayez-le en ligne!

Explication

{~×≜Ċ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 ~×partie n'inclut pas de 1 dans sa sortie, donc pour l'entrée N, elle donne [N] au lieu de [1, N] , qui est ensuite éliminé par Ċ. Je ne sais pas vraiment pourquoi ≜est nécessaire ...

Japt , 9 octets

â¬Å£[XZo]

Testez-le en ligne! Renvoie un tableau de tableaux, avec quelques null à la fin; -Rindicateur ajouté pour afficher la sortie plus clairement.

Gelée , 8 octets

½ḊpP⁼¥Ðf

Un lien monadique prenant un nombre et renvoyant une liste de listes (paires) de nombres.

Essayez-le en ligne! (time out sur TIO pour l'16777216exemple car cela créerait une liste de 68,7 milliards de paires et filtrerait vers le bas pour celles avec le bon produit!)

Comment?

½Ḋ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, crée implicitement une plage d'une entrée numérique avant d'agir, et la fonction de plage plante implicitement son entrée, donc avec, disons, n=24le résultat de ½est 4.898...; la gamme devient [1,2,3,4]; et le résultat retiré de la file d'attente est[2,3,4]

** De la même manière que ci-dessus, ple produit cartésien crée des plages pour la saisie numérique - ici, le bon argument est ndonc le bon argument devient [1,2,3,...,n]avant que le produit cartisien réel ait lieu.

Husk , 8 octets

tüOSze↔Ḋ

Essayez-le en ligne!

Explication

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 octets

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

Démo

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

Essayez-le en ligne!

Python 2 , 59 octets

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

Essayez-le en ligne!

Gelée , 9 octets

ÆḌḊµżUṢ€Q

Essayez-le en ligne!

Octave , 42 octets

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

Essayez-le en ligne!

PHP, 70 octets

Sous forme de chaîne (70 octets):

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

En tant que vidage de tableau (71 octets):

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

(Je ne sais pas si je peux utiliser return $ b; au lieu de print_r car il ne produit plus le tableau, sinon je peux économiser 2 octets ici.)

Le tableau donne les résultats comme:

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

Gelée , 12 octets

ÆDµżUḣLHĊ$$Ḋ

Essayez-le en ligne!

Comment ça fonctionne

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

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

Essayez-le en ligne!

est l' Functionopérateur, qui introduit une fonction sans nom avec un paramètre nommé n.

Facteur , 58

Eh bien, il doit y avoir un facteur dans cette question!

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

C'est une citation. callavec le numéro sur la pile, laisse unassoc (un tableau de paires) sur la pile.

Je ne sais jamais si toutes les importations comptent ou non, car elles font partie de la langue. Celui-ci utilise:

USING: math.prime.factors sequences assocs math ;

(S'ils comptent, je devrais chercher une solution plus longue avec des importations plus courtes, ce qui est un peu idiot)

En un mot:

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

Try it online!

How it works:

For every number up to sqrt(n), generate the pair [[x, n/x]], then take the n%xth element of this array. If n%x==0 this is [x, n/x], otherwise it's nil. when done, remove all nil from the list.

Pari/GP, 49 34 38 bytes

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

Try it online!

Set builder notation for all pairs [d, n/d] where d runs through all divisors d of n subject to d > 1 and d <= n/d.

Huge improvement by alephalpha.

Husk, 14 12 bytes

tumoOSe`/⁰Ḋ⁰

Try it online!

Explanation

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

Explanation:

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

Redefines the inbuild unary operator ~ and uses an array comprehension to build the output.

• div(x,y) is neccessary for integer division. x/y saves 5 bytes but the output is ~4=(2,2.0).
• Julia allows chaining the comparisons, saving one byte.
• Looping all the way to x avoids Int(floor(√x)).

APL NARS 99 chars

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: (where not print nothing, it return something it return ⍬ the list null one has to consider as "no solution")

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

I'm pretty sure this can be golfed.

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.