정의

숫자가 0보다 크면 양수입니다.

다수 ( A) 다른 번호 (의 약수 인 B경우) A분할 할 수 B없는 나머지.

예를 들어, 나머지 는 나누지 않고 나눌 수 있기 때문에 2제수입니다 .626

골

당신의 임무는 양수를 취한 다음 모든 제수를 찾는 프로그램 / 함수를 작성하는 것입니다.

제한

• 소인수 또는 인수 분해 관련 내장 기능을 사용할 수 없습니다 .
• 알고리즘의 복잡성이 O (sqrt (n))을 초과 해서는 안됩니다 .

자유

• 출력 목록에 중복이 포함되어있을 수 있습니다.
• 출력 목록을 정렬 할 필요는 없습니다.

채점

이것은 code-golf 입니다. 바이트 단위의 최단 솔루션이 승리합니다.

테스트 케이스

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-loop는 재귀로 바뀌어 두 번째 매개 변수입니다. 재귀 시작은 기본 매개 변수에 의해 수행되므로 필요한 단일 시작 번호만으로 함수가 호출됩니다.

• 블록없이 표현식 기반 함수를 사용하면 return 문을 피할 수 있습니다.
• 삼항 연산자 내의 문자열 보간으로 문자열 연결 및 조건을 결합 할 수 있습니다.

여기의 대부분의 대답 (아직)은 예제의 정확한 출력 형식을 따르지 않으므로 그대로 유지하지만 단점으로는 결과에 단일 후행 쉼표가 포함됩니다.

R , 36 31 바이트

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

온라인으로 사용해보십시오!

Robin Ryder 덕분에 -5 바이트

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

자바 스크립트 (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 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

파이썬 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.

온라인으로 사용해보십시오!

자바 스크립트, 47 바이트

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

Mathematica, 50 바이트

@ flawr 's solution과 유사합니다 .

1에서 n 의 제곱근까지 x에 대한 트레일 나누기를 수행 하고, 나눌 수있는 경우 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}

자바 스크립트 (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;
        }
    }
}

자료

• V1.0 - 87 bytes- 초기 솔루션입니다.

메모

• 에서 Golfed 코드 , 내가 사용 var의 및 int'대신이야 String's와 Int32에있는 동안, 코드를 짧게 만드는의 Ungolfed 코드 와 전체 코드 I 사용 String의와 Int32의 코드를 읽기 쉽게 만들 수 있습니다.

루아, 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))

불행히도 더 잘할 수 없었습니다

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

나는 이것이 모든 숫자에 대해 효과가 있는지 모르겠다.

그러나 복잡성이 옳기 때문에 이미 무언가가 아닙니다.

루비, 56 바이트

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

IA-32 기계 코드, 27 바이트

16 진 덤프 :

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)는 숫자입니다. 어떤 식 으로든 출력의 끝을 표시하지 않습니다. 목록의 끝을 찾기 위해 출력 배열을 0으로 미리 채워야합니다.

이 코드를 사용하는 완전한 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 <divisor"를 검사하여 루프를 종료합니다.

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 # Interactive Compiler) , 40 바이트

업데이트 된 C # 답변 만 제공

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

온라인으로 사용해보십시오!