Wenn Sie eine natürliche Zahl haben, nschreiben Sie ein Programm oder eine Funktion, um eine Liste aller möglichen Multiplikationen von zwei Faktoren zu erhalten, die verwendet werden können, um zu erreichen n. Um besser zu verstehen, was vorgetäuscht wird, können Sie unter http://factornumber.com/?page=16777216 nachlesen , wann die folgende Liste angezeigtn wird 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

Es ist nicht nötig, Dinge wie hier hübsch zu drucken. Voraussetzung ist, dass jeder Eintrag (Faktorenpaar) gut voneinander unterschieden ist und in jedem Paar auch der erste Faktor gut voneinander unterschieden ist. Wenn Sie eine Liste / ein Array zurückgeben, kann das inside-Element eine Liste / ein Array mit zwei Elementen oder eine Struktur Ihrer Sprache sein, die ein Paar von Dingen wie C ++ unterstützt std::pair.

Drucken Sie weder die Multiplikation mit 1 Eintrag aus, noch wiederholen Sie die Einträge mit dem ersten Faktor, der durch den zweiten ersetzt wird, da dies ziemlich nutzlos ist.

Kein Gewinner; Es wird ein Pro-Sprache-Basiscode für Golf sein.

Java (OpenJDK 8) , 81 66 65 Bytes

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

Probieren Sie es online!

Alte (als Referenz)

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

Probieren Sie es online!

Erste Codegolfeinreichung und erste Lambda-Nutzung. Future Self, bitte vergib mir den Code.

05AB1E , 8 Bytes

Ñ‚ø2äн¦

Probieren Sie es online!

C (gcc) , 58 54 53 Bytes

• Dank Steadybox ein Byte gespeichert .

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

Probieren Sie es online!

Python 2 , 51 Bytes

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

Probieren Sie es online!

51 Bytes (Danke an Luis Mendo für ein Byte)

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

Probieren Sie es online!

51 Bytes

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

Probieren Sie es online!

Haskell, 38 Bytes

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

Probieren Sie es online!

APL (Dyalog) , 28 Bytes

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

Probieren Sie es online!

Perl 6 , 38 Bytes

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

Versuch es

Erweitert:

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

Probieren Sie es online!

Erläuterung

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

Der ~×Teil nicht enthält 1s in seinem Ausgang, so dass für die Eingabe N gibt es [N] anstelle von [1, N] , das durch später ausgesondert wird Ċ. Ich bin mir nicht ganz sicher, warum ≜es gebraucht wird ...

Japt , 9 Bytes

â¬Å£[XZo]

Online testen! Gibt ein Array von Arrays mit einigen Nullen am Ende zurück. -Rflag hinzugefügt, um die Ausgabe deutlicher darzustellen.

Gelee , 8 Bytes

½ḊpP⁼¥Ðf

Ein monadischer Link, der eine Nummer aufnimmt und eine Liste von Listen (Zahlenpaaren) zurückgibt.

Probieren Sie es online! (Timeout bei TIO für die16777216 Beispiel, da eine Liste von 68,7 Milliarden Paaren erstellt und auf diejenigen mit dem richtigen Produkt heruntergefiltert wird!)

Wie?

½Ḋ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, macht implizit einen Bereich einer numerischen Eingabe vor dem Handeln, und die Range-Funktion überlagert implizit ihre Eingabe, so dass zum Beispiel n=24das Ergebnis von ½ist 4.898...; die Reichweite wird [1,2,3,4]; und das Ergebnis in der Warteschlange ist[2,3,4]

** Ähnlich wie oben pmacht das kartesische Produkt Bereiche für die numerische Eingabe - hier ist das richtige Argument ndaher das richtige Argument, [1,2,3,...,n]bevor das eigentliche kartesische Produkt stattfindet.

Husk , 8 Bytes

tüOSze↔Ḋ

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es 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}

Probieren Sie es online!

Gelee , 9 Bytes

ÆḌḊµżUṢ€Q

Probieren Sie es online!

Oktave , 42 Bytes

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

Probieren Sie es online!

PHP, 70 Bytes

Als Zeichenkette (70 Bytes):

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

Als Array-Dump (71 Bytes):

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

(Ich bin mir nicht sicher, ob ich return $ b verwenden kann; anstelle von print_r, da es das Array nicht mehr ausgibt, ansonsten kann ich hier 2 Bytes sparen.)

Das Array liefert folgende Ergebnisse:

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

Gelee , 12 Bytes

ÆDµżUḣLHĊ$$Ḋ

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online!

ist der FunctionOperator, der eine unbenannte Funktion mit benannten Parametern einführt n.

Faktor 58

Nun, in dieser Frage muss es einen Faktor geben!

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

Es ist ein Zitat. calles mit der Zahl auf dem Stapel, lässt ein assoc(ein Array von Paaren) auf dem Stapel.

Ich bin mir nie sicher, ob alle Importe zählen oder nicht, da sie Teil der Sprache sind. Dieser verwendet:

USING: math.prime.factors sequences assocs math ;

(Wenn sie zählen, sollte ich nach einer längeren Lösung mit kürzeren Importen suchen, was irgendwie albern ist.)

Als ein Wort:

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

Probieren Sie es online!

Wie es funktioniert:

Generieren Sie für jede Zahl bis zu sqrt (n) das Paar [[x, n/x]]und nehmen Sie dann das n%xdritte Element dieses Arrays. Wenn n%x==0ja, ist es [x, n/x]anders nil. Wenn Sie fertig sind, entfernen Sie alle nilaus der Liste.

Pari / GP , 49 34 38 Bytes

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

Probieren Sie es online!

Legen Sie die Builder-Notation für alle Paare fest, bei [d, n/d]denen dalle Teiler dvon nsubject to d > 1and durchlaufen werden d <= n/d.

Riesige Besserung durch Alephalpha.

Schale , 14 12 Bytes

tumoOSe`/⁰Ḋ⁰

Probieren Sie es online!

Erläuterung

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

Erläuterung:

(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

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online!

Befunge-93, 56 Bytes

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

Probieren Sie es online

Julia 0,6 , 41 Bytes

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

Probieren Sie es online!

Definiert den eingebauten unären Operator neu ~und verwendet ein Array-Verständnis, um die Ausgabe zu erstellen.

• div(x,y)wird für die Ganzzahldivision benötigt. x/ySpart 5 Bytes, aber die Ausgabe ist ~4=(2,2.0).
• Julia erlaubt die Verkettung der Vergleiche und spart ein Byte.
• Looping bis x vermeidet Int(floor(√x)).

APL NARS 99 Zeichen

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: (Wo nichts gedruckt wird, wird etwas zurückgegeben, das zurückgegeben wird. Die Liste null muss als "keine Lösung" betrachtet werden.)

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

Ich bin mir ziemlich sicher, dass das Golf spielen kann.

Grundsätzlich generiert der Algorithmus eine Liste aller Teiler der Eingabe (nennen wir es n ), erstellt dieselbe Liste, kippt sie jedoch und verschachtelt die beiden (z. B. wenn n = 24, dann hat er an dieser Stelle [ 1,24,2,12,3,8,4,6,6,4,8,3,12,24,1]) und druckt die Elemente von Index 2 bis zur Hälfte der Array-Länge aus, wobei jeweils gedruckt wird Nummer in einer neuen Zeile und mit einer zusätzlichen neuen Zeile zwischen jedem Paar.

Der größte Teil der Arbeit wird in der eigentlichen Verwaltung des Stacks erledigt.

2 Bytes mit der Inkrementierungsfunktion gespeichert.

Perl 5, 50 Bytes

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

Ungolfed:

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

Probieren Sie es online aus .