N के विभाजकों का योग ज्ञात कीजिए

20

एक प्रोग्राम लिखें जो स्क्रीन पर 1 से एन की सीमा में उपयोगकर्ता द्वारा दर्ज किए गए एक नंबर (1 ≤ N) 100) के भाजक का योग प्रदर्शित करता है।

यह OEIS A000203 है ।

उदाहरण:

इनपुट : 7

7 / 1 = 7
7 / 7 = 1

7 + 1 = 8

आउटपुट: 8

इनपुट: १५

15 / 1 = 15
15 / 3 = 5
15 / 5 = 3
15 / 15 = 1

15 + 5 + 3 + 1 = 24

आउटपुट: 24

इनपुट: २०

20 / 1 = 20
20 / 2 = 10
20 / 4 = 5
20 / 5 = 4
20 / 10 = 2
20 / 20 = 1

20 + 10 + 5 + 4 + 2 + 1 = 42

आउटपुट: ४२

इनपुट: १

1 / 1 = 1

आउटपुट: १

इनपुट: ५

5 / 1 = 5
5 / 5 = 1

5 + 1 = 6

आउटपुट: 6

code-golf  sequence  integer  division  factoring 
— केविन हैली
स्रोत
6
@ H.PWiz मुझे लगता है कि उसका मतलब है "एक नंबर एन के भाजक"
— बेंजीन
मुझे लगता है कि आप भाजक, उर्फ, सिग्मा फ़ंक्शन का मतलब है ?
— स्टीफन
क्षमा करें, मेरा मतलब है "एन के कई का योग"।
— केविन हैली
@ H.PWiz यह उन लोगों का योग है, इसलिए मुझे पता है
— स्टीफन
— @ स्टेफ़ेन

जवाबों:

6

x86-64 मशीन कोड, 23 बाइट्स

89 F9 89 FE EB 0D 89 F8 99 F7 F1 85 D2 99 0F 44 D1 01 D6 E2 F1 96 C3

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

एकल पैरामीटर EDIरजिस्टर में पारित किया जाता है, सिस्टम V AMD64 ABI (जैसा कि * nix- शैली सिस्टम पर उपयोग किया जाता है) के अनुरूप है। परिणाम में वापस आ गया हैEAX रजिस्टर , जैसा कि सभी x86 कॉलिंग सम्मेलनों के साथ है।

एल्गोरिथ्म एक बहुत ही सीधा है, जो अन्य भाषाओं के कई सबमिशन के समान है। हम एन बार लूप करते हैं, हर बार मोडुलो की गणना करते हैं और इसे हमारे चलने वाले कुल में जोड़ते हैं।

असेंबली असेंबली mnemonics:

; unsigned SumOfMultiples(unsigned N  /* (EDI) */)
    mov     ecx, edi      ; make copy of input N, to be used as our loop counter
    mov     esi, edi      ; make copy of input N, to be used as our accumulator
    jmp     CheckEnd      ; jump directly to 'CheckEnd'
AddModulo:
    mov     eax, edi      ; make copy of input N, to be used as input to DIV instruction
    cdq                   ; short way of setting EDX to 0, based on EAX
    div     ecx           ; divide EDX:EAX by ECX, placing remainder in EDX
    test    edx, edx      ; test remainder, and set ZF if it is zero
    cdq                   ; again, set EDX to 0, without clobbering flags
    cmovz   edx, ecx      ; set EDX to ECX only if remainder was zero (EDX = ZF ? 0 : ECX)
    add     esi, edx      ; add EDX to accumulator
CheckEnd:
    loop    AddModulo     ; decrement loop counter (ECX), and keep looping if it != 0
    xchg    eax, esi      ; move result from accumulator (ESI) into EAX
    ret                   ; return, with result in EAX

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

यह निश्चित है कि ऐसा लगता है कि इसे छोटा बनाने का एक तरीका होना चाहिए, लेकिन मैं इसे नहीं देख सकता। X86 पर कम्प्यूटिंग मोड्यूलो काफी कोड लेता है, क्योंकि आप इसे DIV(या IDIV) निर्देश का उपयोग करते हैं , और वे दोनों निश्चित इनपुट रजिस्टरों ( EDXऔर EAX) का उपयोग करते हैं , जिनमें से मान क्लोबर्ड (क्योंकि वे परिणाम प्राप्त करते हैं, शेष और शेष) भागफल, क्रमशः)।

यहाँ केवल वास्तविक चालें बहुत मानक गोल्फिंग हैं:

  • मैंने कोड को कुछ असामान्य तरीके से संरचित किया है, ताकि मैं CISC- शैली LOOPअनुदेश का उपयोग कर सकूं , जो मूल रूप से अंतर्निहित संचालक के रूप में रजिस्टर के साथ DEC+ का संयोजन है ।JNZECX
  • मैं XCHGइसके बजाय अंत में उपयोग कर रहा हूं MOVक्योंकि पूर्व में एक विशेष 1-बाइट एन्कोडिंग है जब EAXऑपरेंड में से एक है।
  • मैं विभाजन की तैयारी में CDQशून्य का उपयोग करता हूं EDX, भले ही अहस्ताक्षरित विभाजन के लिए आप आमतौर पर शून्य का उपयोग कर रहे हों XOR। हालांकि, XORहमेशा 2 बाइट्स होता है, जबकि CDQकेवल 1 बाइट होता है। मैं CDQफिर EDXसे CMOVZनिर्देश के पहले लूप के अंदर दूसरी बार शून्य का उपयोग करता हूं । यह काम करता है क्योंकि मुझे गारंटी दी जा सकती है कि डिवीजन (इन EAX) का भाग हमेशा अहस्ताक्षरित होता है, इसलिए साइन-एक्सटेंशन 0 के बराबर EDXसेट हो जाएगा EDX।
— कोडी ग्रे
स्रोत
3

जाप , 3 बाइट्स

â)x

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

— powelles
स्रोत
वैकल्पिक:â x
— श्री एक्सकोडर
@ Mr.Xcoder: वास्तव में एक विकल्प नहीं है; यह ठीक वही काम कर रहा है - केवल अंतर ही कोष्ठक की पसंद है।
— झबरा
या झंडे के साथ -x, यह एक बाइट हो सकता है
— इग्नोरेंस
3

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

Tr@Divisors@#&

या @Loki द्वारा एक उत्तर

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

DivisorSum[#,#&]&
— J42161217
स्रोत
@ जेनेमी बहुत अच्छा है, धन्यवाद! इसे लिखने का एक समतुल्य और मज़ेदार तरीका यह भी है: DivisorSum [#, # &] &
— Rebel-Scum
@ जीनमैथी हम्म, यह और भी बेहतर है: कुल @ डिवोर्स @ केवल 15 वर्ण लंबा है! और यह काम करता है: उदाहरण के लिए कुल @ Divisers @ 15 उम्मीद के मुताबिक 24 देता है। गणितज्ञ FTW :)
— विद्रोही-स्कम
2
@ लोकी और Tr@Divisors@#&इससे भी बेहतर ;-)
— J42161217
1
@ लोकी प्रोग्राम को एक फंक्शन होना चाहिए जो f=एक इनपुट f [x] लेता है, इसीलिए मैं इसे इस तरह प्रस्तुत करता हूं। PPCG में आपका स्वागत है
— J42161217
3
आप Tr@*Divisorsएक बाइट से दाढ़ी बनाने के लिए उपयोग कर सकते हैं ।
— 1
3

सी, सी ++, सी #, डी, जावा, 65 62 बाइट्स

int d(int n){int s=0,i=1;for(;i<=n;++i)s+=n%i>0?0:i;return s;}

यह समानता के कारण सभी 5 प्रोग्रामिंग भाषाओं में काम करता है।

सी, सी ++ और डी अनुकूलन: 62 60 बाइट्स

C ++ और D में, पूर्णांक रूप से बूलियन्स में बदल जाते हैं (शून्य => असत्य, शून्य नहीं = सत्य), इसलिए आपको होने की आवश्यकता नहीं है !=0

int d(int n){int s=0,i=1;for(;i<=n;++i)s+=n%i?0:i;return s;}

डी ऑप्टिमाइज़ेशन: गोल्फ टेम्प्लेट सिस्टम, 55 बाइट्स

T d(T)(T n){T s,i=1;for(;i<=n;++i)s+=n%i?0:i;return s;}

परीक्षण के लिए कोड :

सी :

printf("%d %d %d %d %d", d(7), d(15), d(20), d(1), d(5));

C ++:

std::cout << d(7) << ' ' << d(15) << ' ' << d(20) << ' ' << d(1) << ' ' << d(5);

सी# :

class FindSum
{
    int d(int n) { int s = 0, i = 1; for (; i <= n; ++i) s += n % i > 0 ? 0 : i; return s; }

    static void Main(string[] args)
    {
        var f = new FindSum();
        Console.WriteLine(string.Format("{0}, {1}, {2}, {3}, {4}", f.d(7), f.d(15), f.d(20), f.d(1), f.d(5)));
    }
}

D: 

writeln(d(7));
writeln(d(15));
writeln(d(20));
writeln(d(1));
writeln(d(5));

जावा :

public class FindSum {
    int d(int n){int s=0,i=1;for(;i<=n;++i)s+=n%i>0?0:i;return s;}

    public static void main(String[] args) {
        FindSum f = new FindSum();
        System.out.println(String.format("%d, %d, %d, %d, %d", f.d(7), f.d(15), f.d(20), f.d(1), f.d(5)));
    }
}
— HatsuPointerKun
स्रोत
कुछ बातें: सबसे पहले, मुझे नहीं लगता कि आपको किसी भी भाषा में n%i/ के आसपास कोष्ठक की आवश्यकता है n%i!=0। दूसरा, आपका पहला समाधान n%i>0इसके बजाय सक्षम होना चाहिए n%i!=0। तीसरा, डी का समाधान T d(T)(T n){T s,i=1;for(;i<=n;++i)s+=n%i?0:i;return s;}टेम्पलेट सिस्टम और डिफ़ॉल्ट मानों का दुरुपयोग करके हो सकता है।
— 13
3

शनाप , ४४ 43 बाइट्स

मिस्टर एक्सकोडर की बदौलत -1 बाय (अपनी ही भाषा में मुझे बताया गया था)

 $n return:{s=0for d:range(n+1)if n%d<1s+=d}

यह एक फ़ंक्शन है ( $Shnap में एक फ़ंक्शन शुरू करता है)।

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

स्पष्टीकरण:

$ n                        //Start function with parameter n
    return: {              //Technically, we are returning a scope-block, which evaluates to the last statement run
        s = 0              //Our result
        for d : range(n+1) //For each value in the iterator range(n+1)
            if n % d < 1  // If n is divisible by d
                s += d     // Add d to the sum
                           // Since (s += d) returns (s + d), and a scope-block returns the last run statement, this will be the last statement and equal to our result
    }

नॉनकमेटिंग, 19 बाइट्स

कई भाषा अपडेट के बाद, अब इसे 19 बाइट तक घटाया जा सकता है:

$n=>sum(factors(n))

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

— सोक्रेटिक फीनिक्स
स्रोत
1
==0है <1( ४३ बाइट्स )
— श्री एक्सकोडर
@श्री। Xcoder धन्यवाद ... मैं outgolfed था ... अपनी भाषा में ... जो गूढ़ भी नहीं है xD
— सुकराती फीनिक्स
2

पायथन, 44 बाइट्स

lambda k:sum(i*(k%i<1)for i in range(1,1+k))
  • स्टीफन के लिए धन्यवाद, व्हॉट्सएप को हटाकर 1 बाइट बचाएं।
  • जोनाथन फ्रेच के लिए धन्यवाद, अगर गुणा करने के लिए बदलकर एक और 1 बाइट बचाएं।
— TSH
स्रोत
2

जे, 23 बाइट्स

[:+/](([:=&0]|[)#])1+i.

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

जे प्रशंसकों के लिए, एक चतुर 13 बाइट समाधान है : >:@#.~/.~&.q:लेकिन चूंकि यह मेरा आविष्कार नहीं था इसलिए मैं इसे अपने आधिकारिक उत्तर के रूप में पोस्ट नहीं कर रहा हूं।

मेरा अपना समाधान बस 1. फ़िल्टर करता है, विभाजक ढूंढता है, फिर उन्हें रकम देता है। इसका क्रूस डायडिक कांटा है

](([:=&0]|[)#])

ध्यान दें कि इस संदर्भ ]में 1..n है, और [स्वयं n है। इसलिए ]|[1.11 एन के प्रत्येक तत्व को विभाजित करते समय अवशेष हैं, और =&0आपको बताता है कि क्या वे 0 के बराबर हैं।

— जोनाह
स्रोत
2
13 बाइट्स के लिए यह बराबर होना चाहिए:+1#.i.*0=i.|]
— मील
@ मीलों, यह वास्तव में अच्छा है। यह हिस्सा i.|]मेरे दृष्टिकोण पर एक महान सुधार है। मैं हालांकि इस भाग को पूरी तरह से नहीं समझता: +1#.i.- क्या आप इसे समझा सकते हैं?
— योना
2
1#.आधार 1 रूपांतरण है, जो इसके बराबर है +/"1। पहले i.|]अवशेष प्राप्त करने के लिए, फिर 0=0 (भाजक) के बराबर वाले को खोजने के लिए, फिर i.*सीमा में गैर-विभाजक को शून्य करने के लिए, फिर योग का उपयोग करें 1#., फिर +अपने आप को जोड़ दें क्योंकि i.एक विशेष श्रेणी है।
— मील
2

MATL , 6 बाइट्स

t:\~fs

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

-4 बाइट्स @LuisMendo को धन्यवाद

10 बाइट्स

एक लूप का उपयोग करके मेरा पिछला समाधान

:"G@\~@*vs

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

3 बाइट्स

बिल्ट-इन का उपयोग करना

Z\s

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

— Cinaski
स्रोत
2

जावास्क्रिप्ट, 54 44 बाइट्स

n=>[...Array(x=n)].reduce(y=>y+!(n%x)*x--,0)

झबरा के लिए धन्यवाद 10 बाइट्स बचाता है

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

const f = n=>[...Array(x=n)].reduce(y=>y+!(n%x)*x--,0)

console.log(f(7))
console.log(f(15))
console.log(f(20))
console.log(f(1))
console.log(f(5))
स्निपेट का विस्तार करें

— powelles
स्रोत
2

ब्रेन-फ्लैक , 96 बाइट्स

((({})<>){<(([()]{})){<>(({})(<()>))<>{(({})){({}[()])<>}{}}{}<>([{}()]({})){((<{}{}>))}}{}>{}})

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

स्पष्टीकरण:

अब सुधारों से पुराना।

एल्गोरिदम का दिल यह है:

({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]({})) turns |N, M...| into |N mod M, M...|
{((<{}{}>))} if the top of stack is not zero, replace it and the second with zero

यह मॉड पर एक संशोधन है जो हमें देगा Mअगर यह एक कारक है Nऔर 0अन्यथा। पूर्ण कोड नीचे है।

((({})<>) place input, N on both stacks
{ Loop to find factors
 <
  (([()]{})) Decrement and Duplicate; get next factor to check
  { if not zero
   (<>({})<>) Copy N from other stack
   ({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]({})){((<{}{}>))} Code explained above
  }
  {} drop the zero
 >
 {} add the factor
}) push the sum
— MegaTom
स्रोत
क्या आपके पास स्पष्टीकरण है?
— गेहूं जादूगर
@FunkyComputerMan मैं अब एक हो गया!
— MegaTom
2

आर , 31 26 बाइट्स

function(N)(x=1:N)%*%!N%%x

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

1x1मैट्रिक्स लौटाता है ।

निम्न के !N%%xतत्वों dकी गणना करता 1:Nहै:d->(1 if d divides N, 0 otherwise)

फिर x%*%x!N%%xमैट्रिक्स उत्पाद है, 1:Nजिसके योग में परिणाम xकहाँ !N%%xहै 1। साफ! तकनीकी रूप से लुइस मेंडो के ऑक्टेव उत्तर का एक बंदरगाह लेकिन मैंने केवल इसके बारे में सोचा था।

आर + संख्या, 14 बाइट्स

numbers::Sigma

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

— ग्यूसेप
स्रोत
पहले एक के लिए आप 2 बाइट्स बचा सकते हैंN=scan();
— gstats
@gstats हाँ, लेकिन फिर मुझे प्रति मेटा चर्चा में +4 बाइट्स मिलनी चाहिए । यदि आपके पास एक मजबूत राय है, तो आप जारको के उत्तर पर वजन कर सकते हैं लेकिन जैसा कि किसी ने भी कोई विकल्प नहीं सुझाया है, जो मेरे दिमाग में है।
— ग्यूसेप
क्या दूसरा नहीं होना चाहिए numbers::Sigma(N)? इस तरह यह फ़ंक्शन के स्रोत कोड को आउटपुट करता है Sigma।
— रुई बरदास -
@RuiBarradas एक फ़ंक्शन पूरी तरह से अच्छा सबमिशन है। इसका परीक्षण करने के लिए, आपको स्पष्ट रूप से इसे कॉल करना होगा जैसा कि मैं पहली सबमिशन में करता हूं।
— Giuseppe
1

जावास्क्रिप्ट, 31 बाइट्स

f=(n,i=n)=>i&&!(n%i)*i+f(n,i-1)
— TSH
स्रोत
1

VBA (एक्सेल), 73 बाइट्स

a=Cells(1,1)
x=1
While x<=a
If a Mod x = 0 Then b=b+x
x=x+1
Wend
MsgBox b
— remoel
स्रोत
यह उत्तर अमान्य है क्योंकि यह स्निपेट्स का एक संग्रह है जिसे स्टैंड के रूप में एकल इकाई के रूप में नहीं चलाया जा सकता है। इसे वैध बनाने के लिए आपको इसे सबरूटीन या अनाम VBE तत्काल विंडो फ़ंक्शन में परिवर्तित करना होगा।
— टेलर स्कॉट
आपने जो कहा था, उसमें मैं बहुत परिचित नहीं हूं। क्या आप मेरी थोड़ी और मदद कर सकते हैं?
— रीमूवल १el ’
इस पोस्ट को वैध बनाने के लिए आपको इसे निम्न में से किसी एक प्रारूप में बदलना होगा, 1 - सबरूटीन, 2 - फ़ंक्शन, 3 - बेनामी VBE तत्काल विंडो फ़ंक्शन (एक एकल पंक्ति जिसे तत्काल विंडो में निष्पादित किया जा सकता है); आपके कार्यान्वयन के लिए, इस का सबसे सरल कार्यान्वयन एक उप-थूथन में बदलना होगा, जिसके साथ लपेटकर Sub Y... End Sub85 बाइट समाधान प्राप्त करने के लिएSub y A=Cells(1,1) x=1 While x<=A If A Mod x=0 Then b=b+x x=x+1 Wend MsgBox b End Sub
— टेलर स्कॉट
यही कारण है कि हालांकि काफी भारी 72 बाइट समाधान करने के लिए नीचे अनुकूलित किया जा सकता है Sub y While x<=[A1] x=x+1 If [A1]Mod x=0Then b=b+x Wend Debug.?b End Subजो कि यह एक साफ मॉड्यूल में चलाया जाता है मान लिया गया है (x = डिफ़ॉल्ट पूर्णांक मूल्य, 0) और VBE तत्काल खिड़की के आउटपुट ( ?autoformats लिए Print )
— टेलर स्कॉट
इसके अलावा, और यह पहचानते हुए कि आपका समाधान उप-कॉल के माध्यम से इनपुट नहीं लेता है, इसे तब 50 बाइट्स के लिए VBE तत्काल विंडो फ़ंक्शन में परिवर्तित किया जा सकता While x<=[A1]:x=x+1:b=IIf([A1]Mod x,b,b+x):Wend:?bहै x, जो मानता है कि , b0 का डिफ़ॉल्ट मान है और VBE तत्काल विंडो से आउटपुट VBE तत्काल खिड़की ?के बराबर है Debug.Print )
— टेलर स्कॉट
1

अजगर , 6 बाइट्स

s*M{yP

यहाँ कोशिश करो!

पायथ में विभाजकों के लिए अंतर्निहित नहीं है, इसलिए मुझे लगता है कि यह उचित है।

व्याख्या

s * M {yP - निहित इनपुट के साथ पूरा कार्यक्रम।

     पी - इनपुट के प्रमुख कारक।
    y - इसके प्रमुख कारकों का अधिकार।
   {- डेडुप्लिकेट।
 * एम - गुणा के साथ नक्शा।
s - सम।
          - परिणाम को स्पष्ट रूप से प्रदर्शित करें।

यह देखते हुए 20, उदाहरण के लिए, यह क्या हमारे कार्यक्रम प्रत्येक निर्देश के बाद करता है:

  • P: [2, 2, 5]।

  • y: [[], [2], [2], [5], [2, 2], [2, 5], [2, 5], [2, 2, 5]]।

  • {: [[], [2], [5], [2, 2], [2, 5], [2, 2, 5]]।

  • *M: [1, 2, 5, 4, 10, 20]।

  • s: 42।

— श्री Xcoder
स्रोत
1

भूसी , 5 बाइट्स

ṁΠuṖp

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

कैसे?

--u .p - पूर्ण कार्यक्रम, निहित इनपुट।

     पी - प्रमुख कारक।
    Et - पॉवर्स।
   u - डुप्लिकेट निकालें।
product - प्रत्येक सूची, योग और अनुमानित उत्पादन के उत्पाद प्राप्त करें।

चैट में सुझावों के लिए ज़गरब को धन्यवाद!

— श्री Xcoder
स्रोत
0

बैश + जीएनयू उपयोगिताओं, 36

bc<<<`seq -f"n=%g;a+=n*!$1%%n;" $1`a

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

शुद्ध बैश, ४१

for((;++i<=$1;a+=$1%i?0:i))
{
:
}
echo $a

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

मैंने पहले एक फैंसी बैश विस्तार उत्तर की कोशिश की, लेकिन यह ऊपर के साधारण लूप की तुलना में अधिक लंबा था:

echo $[$(eval echo +\\\(n={1..$1},$1%n?0:n\\\))]
— डिजिटल आघात
स्रोत
0

++ , 9 बाइट्स जोड़ें

D,f,@,dFs

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

मैं स्पष्ट रूप से यहाँ बहुत देर से मिला। यह एक फ़ंक्शन को परिभाषित करता है जो कारकों को प्राप्त करता है, फिर उन्हें रकम देता है।

— केर्ड सिक्काहिरिंग
स्रोत
0

QBIC , 17 बाइट्स

[:|~b%a|\p=p+a}?p

व्याख्या

[:|      FOR a = 1; a <= b (read from cmd line); a++
~b%a|    IF b modulo a has a remainder THEN - empty block - 
\p=p+a   ELSE add divisor 'a' to running total 'p'
}        END IF, NEXT
?p       PRINT p
— steenbergh
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.