सकारात्मक विभाजक खोजें!

11

परिभाषा

एक संख्या सकारात्मक है यदि यह शून्य से अधिक है।

एक संख्या ( A) दूसरी संख्या का विभाजक है ( B) यदि शेष नहीं के साथ Aविभाजित कर सकते हैं B।

उदाहरण के लिए, 2एक भाजक है 6क्योंकि कोई शेष नहीं के साथ 2विभाजित कर सकता है 6।

लक्ष्य

आपका कार्य एक प्रोग्राम / फ़ंक्शन लिखना है जो एक सकारात्मक संख्या लेता है और फिर इसके सभी विभाजक ढूंढता है।

बंधन

  • आप किसी भी अंतर्निहित प्राइम या फैक्टराइजेशन का उपयोग नहीं कर सकते हैं ।
  • आपके एल्गोरिथ्म की जटिलता O (sqrt (n)) से अधिक नहीं होनी चाहिए ।

स्वतंत्रता

  • आउटपुट सूची में डुप्लिकेट हो सकते हैं।
  • आउटपुट सूची को क्रमबद्ध करने की आवश्यकता नहीं है।

स्कोरिंग

यह कोड-गोल्फ है । बाइट्स जीत में सबसे कम समाधान।

परीक्षण के मामलों

input    output
1        1
2        1,2
6        1,2,3,6
9        1,3,9
code-golf  arithmetic  restricted-source  number-theory  restricted-complexity 
— लीक नन
स्रोत
आप शायद विभाजक का मतलब है , कारक नहीं । और मुझे लगता है कि आप एक समय जटिलता चाहते हैं O(sqrt(n))।
— दोष
विभाजक और कारक के बीच अंतर क्या है ?
— लीक नून
हम उदाहरण के लिए एक संख्या के कारकों के बारे में बात करते हैं, यदि इन परिणामों का उत्पाद फिर से मूल संख्या में होता है, लेकिन भाजक आमतौर पर संख्याएं होती हैं जो शेष संख्या के बिना विभाजित होती हैं ।
— दोष
@flawr तदनुसार अपडेट किया गया।
— लीक नून
2
और उदाहरण होने चाहिए। 99 (1 3 9 11 33 99)
— ब्रैड गिल्बर्ट

जवाबों:

4

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 ║
╚═════╩════════════════╝
— lad2025
स्रोत
3

सी # 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 द्वारा प्रस्तुत किया गया है। फॉर-लूप को एक पुनरावर्ती में बदल दिया जाता है, इस प्रकार दूसरा पैरामीटर। पुनरावर्तन प्रारंभ डिफ़ॉल्ट पैरामीटर द्वारा किया जाता है, इस प्रकार फ़ंक्शन को आवश्यक एकल शुरुआती-संख्या के साथ कहा जाता है।

  • ब्लॉक के बिना अभिव्यक्ति आधारित कार्यों का उपयोग रिटर्न स्टेटमेंट से बचता है
  • टर्नरी ऑपरेटर के भीतर स्ट्रिंग प्रक्षेप, स्ट्रिंग संघनन और स्थितियों में शामिल होने की अनुमति देता है

जैसा कि अधिकांश उत्तर यहां (अभी तक) उदाहरणों से सटीक आउटपुट प्रारूप का पालन नहीं करते हैं, मैं इसे वैसे ही रखता हूं, लेकिन एक दोष के रूप में फ़ंक्शन में परिणाम में एक एकल अनुगामी अल्पविराम शामिल होता है।

— Jongleur
स्रोत
अच्छी पहली पोस्ट!
— R
3

आर , 36 31 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-5 बाइट्स रॉबिन राइडर को धन्यवाद

— ग्यूसेप
स्रोत
के n^.5बजाय 32 बाइट्स के साथ sqrt(n)।
— रोबिन राइडर
आप कई बार नकल करके 31 बाइट तक नीचे जा सकते हैं 1।
— रॉबिन राइडर
@RobinRyder चतुर! धन्यवाद।
— ग्यूसेप
2

मतलाब, 48 बाइट्स

n=input('');a=1:n^.5;b=mod(n,a)<1;[a(b),n./a(b)]
— flawr
स्रोत
यह कैसे काम करता है?
— लीक नून
इसके अलावा, आपने एक एल्गोरिथ्म तैयार किया है जिसके बारे में मैं सोच भी नहीं सकता ... मैं कितना बेवकूफ हूं।
— लीक नून
मैं सभी डिविज़ो को ढूंढता हूं sqrt(n)और फिर प्रत्येक डिविज़र dऔर n/dअपनी सूची में डालता हूं।
— दोष
कुछ नियम जोड़े। शायद आपको कुछ बाइट्स बचा सके।
— लीक नन
1
मैंने परीक्षण नहीं किया है, लेकिन क्या आप b=~mod(n,a)1 बाइट बचाने के लिए उपयोग नहीं कर सकते हैं ?
— लुइस मेंडो
2

जे, 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
— मील की दूरी पर
स्रोत
2

जावास्क्रिप्ट (ईएस 6) - 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>
स्निपेट का विस्तार करें

— कामिला स्कोनीसेज़ना
स्रोत
PPCG में आपका स्वागत है!
— लकोनी
हे(n)
1

MATL , 12 बाइट्स

tX^:\~ftGw/h

दृष्टिकोण @ त्रुटिपूर्ण उत्तर के समान है ।

इसे ऑनलाइन आज़माएं!

व्याख्या

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
— लुइस मेंडो
स्रोत
मुझे अक्सर आश्चर्य होता है कि क्या MATL में लिखे गए प्रोग्रामों का कॉम्बिंड कोड एक अच्छा RNG होगा।
— दोष
@flawr जो संभवतः हर कोड गोल्फ भाषा पर लागू होता है :-)
— लुइस मेंडो
1

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 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत
एक स्पष्टीकरण प्रदान करने के लिए देखभाल?
— लीक नून
@ केनीलाऊ जोड़ा गया
— अदनान
1

पायथन 2, 64 बाइट्स

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

यह अनाम फ़ंक्शन divenders की एक सूची आउटपुट करता है। विभाजक की गणना श्रेणी में पूर्णांकों के परीक्षण प्रभाग द्वारा की जाती है [1, ceil(sqrt(n))], जो है O(sqrt(n))। यदि n % x == 0(समतुल्य n%x<1), तो दोनों xऔर के n/xविभाजक हैंn ।

इसे ऑनलाइन आज़माएं

— मै जाऊं
स्रोत
1

जेली , 9 बाइट्स

½Rḍ³Tµ³:;

अन्य उत्तरों के रूप में, यह O (othern) है यदि हम गलत (गलत) धारणा बनाते हैं कि पूर्णांक विभाजन O (1) है ।

यह काम किस प्रकार करता है

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

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत
— डेनिस
0

गणितज्ञ, 50 बाइट्स

@ दोष के समाधान के समान ।

N के वर्गमूल तक x से 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}
— मील की दूरी पर
स्रोत
खैर, इसके लिए 3 बाइट्स की आवश्यकता होती है ...
— लीके नून
@KennyLau हाँ, मैं गलत था, दोबारा जांच होनी चाहिए
— मील की दूरी पर
0

जावास्क्रिप्ट (ईएस 6), 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 बाइट्स से कम हो ...

— नील
स्रोत
0

सी #, 87 बाइट्स

golfed

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

Ungolfed

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के और Int32की, कोड कम करने के लिए समय में Ungolfed कोड और पूर्ण कोड मैं उपयोग Stringकी और Int32के कोड अधिक पठनीय बनाने के लिए।
— auhmaan
स्रोत
मैंने सुना है कि forआम तौर पर की तुलना में बेहतर है while।
— लीक नन
आपके समाधान में O (sqrt (n)) के बजाय O (n) की जटिलता है ...
— Leaky Nun
@ केनीलाऊ यह उस स्थिति पर निर्भर करता है, इस मामले में एक forलूप की लंबाई वही होगी जो whileलूप की है। इस मामले में यह अप्रासंगिक होने या दूसरे होने पर है।
— auhmaan
लेकिन इस मामले में यह आपको एक बाइट बचा सकता है ...
— लीक नून
0

लूआ, 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))

मैं बेहतर नहीं कर सका, दुर्भाग्य से

— user6245072
स्रोत
1. PPCG में आपका स्वागत है, आशा है कि आप इस साइट का आनंद लेंगे! 2. आप कुछ बाइट्स को बचाने के लिए == 0 से <1 बदल सकते हैं। 3. यदि आप इसके बजाय टर्नरी संरचना का उपयोग कर सकते हैं, तो अंत में, लेकिन मुझे नहीं पता कि यह किसी भी बाइट को बचा सकता है। 4. आपकी एल्गोरिथ्म की जटिलता हे (एन) है जो आवश्यकता को पूरा नहीं करती है।
— लीक नून
ठीक है। क्या सूची को आदेश देने की आवश्यकता है, या उचित रूप से प्रारूपित किया जाना चाहिए?
— user6245072
"आउटपुट सूची में डुप्लिकेट हो सकते हैं। आउटपुट सूची को सॉर्ट करने की आवश्यकता नहीं है।"
— लीक नून
सही लोल। और क्या मुझे परिणाम प्रिंट करने की आवश्यकता है या एक सरणी जिसमें यह पर्याप्त है?
— user6245072
ठीक है, या तो आप इसे प्रिंट करते हैं या आप इसे वापस करते हैं (एक फ़ंक्शन के अंदर)।
— लीक नून
0

पर्ल 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)
— ब्रैड गिल्बर्ट b2gills
स्रोत
0

सी #, 87 बाइट्स

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

मुझे नहीं पता कि यह सभी नंबरों के लिए काम करता है, मुझे संदेह है कि यह करता है।

लेकिन जटिलता सही है, इसलिए यह पहले से ही कुछ है

— downrep_nation
स्रोत
0

IA-32 मशीन कोड, 27 बाइट्स

Hexdump:

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
1
15
2
10
3
6
5
5
6

यदि इनपुट एक पूर्ण वर्ग के करीब है, तो अंतिम जोड़ी दो बार आउटपुट है। यह लूप में चेक के आदेश के कारण है: पहले, यह "शेष = 0" और आउटपुट के लिए जांच करता है, और उसके बाद ही लूप से बाहर निकलने के लिए "भागफल <विभाजक" की जांच करता है।

— anatolyg
स्रोत
0

स्माइलबासिक, 49 बाइट्स

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

इस तथ्य का उपयोग करता है कि D>N/D= D>sqrt(N)सकारात्मक संख्याओं के लिए

— 12Me21
स्रोत
0

सी, 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));}

संपादित करें: इनपुट्स हार्डकोड नहीं होना चाहिए, यह इंगित करने के लिए @Srichilism O'Zaic का धन्यवाद, मैंने argv के माध्यम से इनपुट लेने के लिए मुख्य सबमिशन में संशोधन किया।

— OverclockedSanic
स्रोत
1
है n इनपुट? एक चर में इनपुट डालना कई कारणों से यहाँ इनपुट करने का एक स्वीकृत तरीका नहीं है। आप हमारे स्वीकृत और गैर-स्वीकृत इनपुट और आउटपुट फॉर्म के बारे में अधिक यहाँ देख सकते हैं: codegolf.meta.stackexchange.com/questions/2447/… । और यदि आप किसी विशिष्ट भाषा (जैसे C) के बारे में उत्सुक हैं, तो आप यहाँ देख सकते हैं: codegolf.meta.stackexchange.com/questions/11924/… ।
— तदर्थ गार्फ हंटर
@ SriotchilismO'Zaic हां, nइनपुट है। मैं इसे संशोधित करने की कोशिश करूँगा ताकि यह इनपुट को किसी और तरीके से ले जाए। जानकारी के लिए धन्यवाद!
— ओवरक्लॉक्डसैनिक
0

एपीएल (एनएआरएस), 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
— RosLuP
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.