Учитывая натуральное число, nнапишите программу или функцию, чтобы получить список всех двух возможных умножений, которые можно использовать для достижения n. Для того, чтобы лучше понять , что делал вид , вы можете пойти в http://factornumber.com/?page=16777216 , чтобы увидеть , когда nэто 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

Не нужно красиво печатать такие вещи, как здесь. Требование состоит в том, что каждая запись (пара факторов) хорошо отличается друг от друга, и внутри каждой пары первый фактор также хорошо отличается от другого. Если вы решите вернуть список / массив, внутренним элементом может быть список / массив с двумя элементами или некоторая структура вашего языка, которая поддерживает пару вещей, таких как C ++ std::pair.

Не печатайте умножение на 1 запись и не повторяйте записи с первым коэффициентом, замененным вторым, поскольку они довольно бесполезны.

Нет победителя; это будет в зависимости от языка кода.

Java (OpenJDK 8) , 81 66 65 байт

• -15 байт благодаря Оливье Грегуару.
• -1 байт: ++j<=i/j-> j++<i/j.

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

Попробуйте онлайн!

Старый (для справки)

Java (OpenJDK 8) , 126 байт

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

Попробуйте онлайн!

Первый кодгольф представить и первый лямбда-использование. Будущее я, пожалуйста, прости меня за код.

05AB1E , 8 байтов

Ñ‚ø2äн¦

Попробуйте онлайн!

C (gcc) , 58 54 53 байта

• Сохраненный байт благодаря Steadybox .

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

Попробуйте онлайн!

Python 2 , 51 байт

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

Попробуйте онлайн!

51 байт (спасибо Луису Мендо за байт)

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

Попробуйте онлайн!

51 байт

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

Попробуйте онлайн!

Haskell, 38 байт

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

Попробуйте онлайн!

APL (Dyalog) , 28 байт

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

Попробуйте онлайн!

Perl 6 , 38 байт

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

Попытайся

Expanded:

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

Брахилог , 8 байт

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

~×Часть не включает в себя 1s в своем выходе, так что для ввода Н это дает [N] , вместо [1, N] , который затем с помощью забит Ċ. Я не совсем уверен, зачем ≜это нужно ...

Japt , 9 байт

â¬Å£[XZo]

Проверьте это онлайн! Возвращает массив массивов, с некоторыми нулями в конце;-Rдобавлен флаг, чтобы показать результат более четко.

Желе , 8 байт

½ḊpP⁼¥Ðf

Монадическая ссылка, принимающая число и возвращающая список списков (пар) чисел.

Попробуйте онлайн! (Тайм-аут для TIO для16777216примера, так как он создаст список из 68,7 миллиардов пар и отфильтрует их с нужным продуктом!)

Как?

½Ḋ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, неявно создает диапазон числового ввода до начала действия, а функция range неявно ограничивает свой ввод, так что, скажем, n=24результат ½is 4.898...; диапазон становится [1,2,3,4]; и исключенный результат[2,3,4]

** Как и выше, pдекартово произведение задает диапазоны для числового ввода - здесь правильный аргумент, nследовательно, правильный аргумент становится [1,2,3,...,n]до того, как произойдет фактическое картезианское произведение.

Шелуха , 8 байт

tüOSze↔Ḋ

Попробуйте онлайн!

объяснение

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 байт

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

демонстрация

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

Попробуйте онлайн!

Python 2 , 59 байт

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

Попробуйте онлайн!

Желе , 9 байт

ÆḌḊµżUṢ€Q

Попробуйте онлайн!

Октава , 42 байта

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

Попробуйте онлайн!

PHP, 70 байт

В виде строки (70 байт):

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

В качестве дампа массива (71 байт):

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

(Я не уверен, что могу использовать return $ b; вместо print_r, поскольку он больше не выводит массив, иначе я могу сохранить 2 байта здесь.)

Массив дает результаты как:

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

Желе , 12 байт

ÆDµżUḣLHĊ$$Ḋ

Попробуйте онлайн!

Как это устроено

Æ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 байт

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

Попробуйте онлайн!

является Functionоператором, который вводит безымянную функцию с именованным параметром n.

Фактор , 58

Ну, в этом вопросе должен быть какой-то фактор!

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

Это цитата. callон с номером в стеке, оставляет assoc(массив пар) в стеке.

Я никогда не уверен, считается ли весь импорт или нет, так как он является частью языка. Этот использует:

USING: math.prime.factors sequences assocs math ;

(Если они имеют значение, я должен искать более длинное решение с более коротким импортом, что довольно глупо)

Как слово:

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

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

Рубин , 43 байта

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

Попробуйте онлайн!

Как это устроено:

Для каждого числа до sqrt (n) сгенерируйте пару [[x, n/x]], затем возьмите n%xth-й элемент этого массива. Если n%x==0это так [x, n/x], то иначе nil. когда закончите, удалите все nilиз списка.

Par / GP , 49 34 38 байт

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

Попробуйте онлайн!

Установите нотацию строителя для всех пар, [d, n/d]где dпроходит через все делители dв nзависимости от d > 1и d <= n/d.

Огромное улучшение от алефалии.

Шелуха , 14 12 байт

tumoOSe`/⁰Ḋ⁰

Попробуйте онлайн!

объяснение

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 байта

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

Объяснение:

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

Добавить ++ , 18 15 байт

L,F@pB]dBRBcE#S

Попробуйте онлайн!

Как это устроено

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 байта

Array[s[[{#,-#}]]&,⌈Length[s=Divisors@#]/2⌉-1,2]&

Попробуйте онлайн!

Befunge-93, 56 байт

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

Попробуйте онлайн

Юлия 0,6 , 41 байт

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

Попробуйте онлайн!

Переопределяет встроенный унарный оператор ~и использует понимание массива для построения вывода.

• div(x,y)необходим для целочисленного деления. x/yсохраняет 5 байтов, но вывод~4=(2,2.0) .
• Юлия позволяет создавать цепочки сравнений, сохраняя один байт.
• Цикл до х избегает Int(floor(√x)).

APL NARS 99 символов

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 Тест: (где не печатать ничего, он возвращает что-то, что возвращает - список нулевой, который нужно рассматривать как «нет решения»)

  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 

Пыть , 67 65 байт

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

Я уверен, что это можно сыграть в гольф.

По сути, алгоритм генерирует список всех делителей входных данных (назовем его n ), создает один и тот же список, но переворачивает, перемежает их два (например, если n = 24, то в этот момент он имеет [ 1,24,2,12,3,8,4,6,6,4,8,3,12,2,24,1]), и распечатывает элементы из индекса 2 до половины длины массива, печатая каждый номер на новой строке и с дополнительной новой строкой между каждой парой.

Большая часть работы выполняется на самом деле управления стеком.

Сохранено 2 байта с помощью функции приращения.

Perl 5, 50 байт

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

Ungolfed:

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

Попробуйте онлайн .