定义

如果数字大于零，则为正数。

如果数字（A）可以除以无余数，则它是另一个数字（B）的除数。AB

例如，2是6因的除数，2可以除以6余数。

目标

您的任务是编写一个带正数的程序/函数，然后找到所有除数。

限制

• 您不得使用任何与prime 或 factorization相关的内置函数。
• 算法的复杂度不得超过O（sqrt（n））。

自由

• 输出列表可能包含重复项。
• 输出列表不需要排序。

计分

这是代码高尔夫球。以字节为单位的最短解决方案获胜。

测试用例

input    output
1        1
2        1,2
6        1,2,3,6
9        1,3,9

PostgreSQL，176个字节

WITH c AS(SELECT * FROM(SELECT 6v)t,generate_series(1,sqrt(v)::int)s(r)WHERE v%r=0)
SELECT string_agg(r::text,',' ORDER BY r)
FROM(SELECT r FROM c UNION SELECT v/r FROM c)s

SqlFiddleDemo

输入： (SELECT ...v)

这个怎么运作：

• (SELECT ...v) -输入
• generate_series(1, sqrt(v)::int) -从1到sqrt（n）的数字
• WHERE v%r=0 滤除数
• 用公共表表达式包装以引用两次
• SELECT r FROM c UNION SELECT v/r FROM c 产生除数余数并合并
• SELECT string_agg(r::text,',' ORDER BY r) 产生最终的逗号分隔结果

输入为表格：

WITH c AS(SELECT * FROM i,generate_series(1,sqrt(v)::int)s(r)WHERE v%r=0)
SELECT v,string_agg(r::text,',' ORDER BY r)
FROM(SELECT v,r FROM c UNION SELECT v,v/r FROM c)s
GROUP BY v

SqlFiddleDemo

输出：

╔═════╦════════════════╗
║ v   ║   string_agg   ║
╠═════╬════════════════╣
║  1  ║ 1              ║
║  2  ║ 1,2            ║
║  6  ║ 1,2,3,6        ║
║  9  ║ 1,3,9          ║
║ 99  ║ 1,3,9,11,33,99 ║
╚═════╩════════════════╝

C＃6，75个字节

string f(int r,int i=1)=>i*i>r?"":r%i==0?$"{i},{n(r,i+1)}{r/i},":n(r,i+1);

基于downrep_nation的C＃解决方案，但使用C＃6的一些新功能进行递归和深入研究。

基本算法与downrep_nation提出的算法相同。for循环变为递归，即第二个参数。递归启动由默认参数完成，因此仅使用所需的单个起始编号调用该函数。

• 使用不带块的基于表达式的函数避免了return语句
• 三元运算符中的字符串插值允许连接字符串串联和条件

由于此处的大多数答案（仍）并未遵循示例中的确切输出格式，因此我将其保持原样，但缺点是该函数在结果中仅包含一个逗号结尾。

R，36 31字节

n=scan();c(d<-1:n^.5,n/d)^!n%%d

在线尝试！

-5字节感谢Robin Ryder

Matlab，48个字节

n=input('');a=1:n^.5;b=mod(n,a)<1;[a(b),n./a(b)]

J，26个字节

(],%)1+[:I.0=]|~1+i.@<.@%:

说明

(],%)1+[:I.0=]|~1+i.@<.@%:  Input: n
                        %:  Sqrt(n)
                     <.@    Floor(Sqrt(n))
                  i.@       Get the range from 0 to Floor(Sqrt(n)), exclusive
                1+          Add 1 to each
             ]              Get n
              |~            Get the modulo of each in the range by n
           0=               Which values are equal to 0 (divisible by n), 1 if true else 0
       [:I.                 Get the indices of ones
     1+                     Add one to each to get the divisors of n less than sqrt(n)
   %                        Divide n by each divisor
 ]                          Get the divisors
  ,                         Concatenate them and return

JavaScript（ES6）-48个字节

f=n=>[...Array(n+1).keys()].filter(x=>x&&!(n%x))

不是很有效，但是可以！下面的例子：

let f=n=>[...Array(n+1).keys()].filter(x=>x&&!(n%x));
document.querySelector("input").addEventListener("change", function() {
  document.querySelector("output").value = f(Number(this.value)).join(", ");
});

Divisors of <input type="number" min=0 step=1> are: <output></output>

MATL，12字节

tX^:\~ftGw/h

该方法类似于@flawr的答案中的方法。

在线尝试！

说明

t      % take input N. Duplicate.
X^:    % Generate range from 1 to sqrt(N)
\      % modulo (remainder of division)
~f     % indices of zero values: array of divisors up to sqrt(N)
tGw/   % element-wise divide input by those divisors, to produce rest of divisors
h      % concatenate both arrays horizontally

05AB1E，14 12字节

码：

ÐtLDŠÖÏDŠ/ï«

说明：

Ð             # Triplicate input.
 tL           # Push the list [1, ..., sqrt(input)].
   D          # Duplicate that list.
    Š         # Pop a,b,c and push c,a,b.
     Ö        # Check for each if a % b == 0.
      Ï       # Only keep the truthy elements.
       D      # Duplicate the list.
        Š     # Pop a,b,c and push c,a,b
         /ï   # Integer divide
           «  # Concatenate to the initial array and implicitly print.

使用CP-1252编码。在线尝试！。

Python 2，64字节

lambda n:sum([[x,n/x]for x in range(1,int(n**.5+1))if n%x<1],[])

此匿名函数输出除数列表。除数是通过试算范围内的整数来计算的[1, ceil(sqrt(n))]，即O(sqrt(n))。如果n % x == 0（等于n%x<1），则x和n/x均为的除数n。

在线尝试

果冻，9 字节

½Rḍ³Tµ³:;

另一个答案是，如果我们假设整数除法为O（1），则为O（√n ）。。

这个怎么运作

½Rḍ³Tµ³:;  Main link. Argument: n

½          Compute the square root of n.
 R         Construct the range from 1 to the square root.
  ḍ³       Test each integer of that range for divisibility by n.
    T      Get the indices of truthy elements.
     µ     Begin a new, monadic chain. Argument: A (list of divisors)
      ³:   Divide n by each divisor.
        ;  Concatenate the quotients with A.

在线尝试！

Javascript，47个字节

d=(n,f=1,s='')=>n==f?s+n:d(n,f+1,n%f?s:s+f+',')

Mathematica，50个字节

类似于@flawr的解决方案。

对x执行从1到n的平方根的路径除法，如果可除，将其另存为x和n / x到列表中。

(#2/#)~Join~#&@@{Cases[Range@Sqrt@#,x_/;x∣#],#}&

• 请注意，∣以UTF-8表示需要3个字节，因此以48个字符串以UTF-8表示需要50个字节。

用法

  f = (#2/#)~Join~#&@@{Cases[Range@Sqrt@#,x_/;x∣#],#}&
  f[1]
{1, 1}
  f[2]
{2, 1}
  f[6]
{6, 3, 1, 2}
  f[9]
{9, 3, 1, 3}

JavaScript（ES6），66 62字节

f=(n,d=1)=>d*d>n?[]:d*d-n?n%d?f(n,d+1):[d,...f(n,d+1),n/d]:[d]

我以为我会写一个返回重复数据删除列表的版本，实际上原来要短4个字节...

C＃，87个字节

打高尔夫球

String m(int v){var o="1";int i=1;while(++i<=v/2)if(v%i==0)o+=","+i;o+=","+v;return o;}

不打高尔夫球

String m( Int32 v ) {
    String o = "1";
    Int32 i = 1;

    while (++i <= v / 2)
        if (v % i == 0)
            o += "," + i;

    o += "," + v;

    return o;
}

完整代码

using System;
using System.Collections.Generic;

namespace N {
    class P {
        static void Main( string[] args ) {
            List<Int32> li = new List<Int32>() {
                1, 2, 6, 9,
            };

            foreach (Int32 i in li) {
                Console.WriteLine( i + " »> " + m( i ) );
            }

            Console.ReadLine();
        }

        static String m( Int32 v ) {
            String o = "1";
            Int32 i = 1;

            while (++i <= v / 2)
                if (v % i == 0)
                    o += "," + i;

            o += "," + v;

            return o;
        }
    }
}

发布

• 1.0 - 87 bytes-初始溶液。

笔记

• 在Golfed代码中，使用var'和int'代替String'和Int32'使代码更短，而在Ungolfed代码和完整代码中，我使用String'和Int32'使代码更具可读性。

Lua，83个字节

s=''x=io.read()for i=1,x do if x%i==0 then s=s..i..', 'end end print(s:sub(1,#s-2))

不幸的是我做得更好

Perl 6，40个字节

{|(my@a=grep $_%%*,^.sqrt+1),|($_ X/@a)}

说明：

{
  # this block has an implicit parameter named $_

  # slip this list into outer list:
  |(

    my @a = grep
                 # Whatever lambda:
                 # checks if the block's parameter ($_)
                 # is divisible by (%%) this lambda's parameter (*)

                 $_ %% *,

                 # upto and exclude the sqrt of the argument
                 # then shift the Range up by one
                 ^.sqrt+1
                 # (0 ..^ $_.sqrt) + 1

                 # would be clearer if written as:
                 # 1 .. $_.sqrt+1
  ),
  # slip this list into outer list
  |(

    # take the argument and divide it by each value in @a
    $_ X/ @a

    # should use X[div] instead of X[/] so that it would return
    # Ints instead of Rats
  )
}

用法：

my &divisors = {|(my@a=grep $_%%*,^.sqrt+1),|($_ X/@a)}

.say for (1,2,6,9,10,50,99)».&divisors

(1 1)
(1 2 2 1)
(1 2 3 6 3 2)
(1 3 9 3)
(1 2 10 5)
(1 2 5 50 25 10)
(1 3 9 99 33 11)

c＃，87个字节

void f(int r){for(int i=1;i<=Math.Sqrt(r);i++){if(r%i==0)Console.WriteLine(i+" "+r/i);}

我不知道这是否适用于所有数字，我怀疑是这样。

但是复杂性是正确的，所以那已经不是什么了

Ruby，56个字节

->n{a=[];(1..Math.sqrt(n)).map{|e|a<<e<<n/e if n%e<1};a}

IA-32机器代码，27个字节

十六进制转储：

60 33 db 8b f9 33 c0 92 43 50 f7 f3 85 d2 75 04
ab 93 ab 93 3b c3 5a 77 ec 61 c3

源代码（MS Visual Studio语法）：

    pushad;
    xor ebx, ebx;
    mov edi, ecx;
myloop:
    xor eax, eax;
    xchg eax, edx;
    inc ebx;
    push eax;
    div ebx;
    test edx, edx;
    jnz skip_output;
    stosd;
    xchg eax, ebx;
    stosd;
    xchg eax, ebx;
skip_output:
    cmp eax, ebx;
    pop edx;
    ja myloop;
    popad;
    ret;

第一个参数（ecx）是要输出的指针，第二个参数（edx）是数字。它不会以任何方式标记输出的结束。应该用零预填充输出数组以找到列表的末尾。

使用此代码的完整C ++程序：

#include <cstdint>
#include <vector>
#include <iostream>
#include <sstream>
__declspec(naked) void _fastcall doit(uint32_t* d, uint32_t n) {
    _asm {
        pushad;
        xor ebx, ebx;
        mov edi, ecx;
    myloop:
        xor eax, eax;
        xchg eax, edx;
        inc ebx;
        push eax;
        div ebx;
        test edx, edx;
        jnz skip_output;
        stosd;
        xchg eax, ebx;
        stosd;
        xchg eax, ebx;
    skip_output:
        cmp eax, ebx;
        pop edx;
        ja myloop;
        popad;
        ret;
    }
}
int main(int argc, char* argv[]) {
    uint32_t n;
    std::stringstream(argv[1]) >> n;
    std::vector<uint32_t> list(2 * sqrt(n) + 3); // c++ initializes with zeros
    doit(list.data(), n);
    for (auto i = list.begin(); *i; ++i)
        std::cout << *i << '\n';
}

即使遵循规范，输出也会出现一些小故障（无需排序；无需唯一性）。

输入：69

输出：

69
1
23
3

除数成对出现。

输入：100

输出：

100
1
50
2
25
4
20
5
10
10

对于完美的平方，最后的除数输出两次（与自身成对）。

输入：30

输出：

30
1
15
2
10
3
6
5
5
6

如果输入接近理想平方，则最后一对输出两次。这是因为循环中检查的顺序：首先，它检查“ remainder = 0”并输出，然后才检查“ quotient <除数”以退出循环。

SmileBASIC，49个字节

INPUT N
FOR D=1TO N/D
IF N MOD D<1THEN?D,N/D
NEXT

将D>N/D= D>sqrt(N)用作正数

C，87 81字节

由@ceilingcat改进，81个字节：

i,j;main(n,b)int**b;{for(;j=sqrt(n=atoi(b[1]))/++i;n%i||printf("%u,%u,",i,n/i));}

在线尝试！

我的原始答案是87个字节：

i;main(int n,char**b){n=atoi(b[1]);for(;(int)sqrt(n)/++i;n%i?:printf("%u,%u,",i,n/i));}

使用编译gcc div.c -o div -lm并运行./div <n>。

奖励：具有O（n）时间复杂度和硬编码n（46字节+的长度n）的更短变体：

i,n=/*INSERT VALUE HERE*/;main(){for(;n/++i;n%i?:printf("%u,",i));}

编辑：感谢@Sriotchilism O'Zaic指出不应对输入进行硬编码，我修改了主要提交内容以通过argv接受输入。

APL（NARS），22个字符，44个字节

{v∪⍵÷v←k/⍨0=⍵∣⍨k←⍳⌊√⍵}

测试：

  f←{v∪⍵÷v←k/⍨0=⍵∣⍨k←⍳⌊√⍵}
  f 1
1 
  f 2
1 2 
  f 6
1 2 6 3 
  f 9
1 3 9 
  f 90
1 2 3 5 6 9 90 45 30 18 15 10 

C＃（Visual C＃交互式编译器），40字节

仅提供更新的C＃答案

n=>Enumerable.Range(1,n).Where(x=>n%x<1)

在线尝试！