40

आपका काम दो दिए गए पूर्णांकों के सबसे बड़े सामान्य भाजक (GCD) को कम से कम कोड के बाइट्स में गणना करना है।

आप किसी भी स्वीकृत मानक तरीकों (जैसे STDIN / STDOUT, फ़ंक्शन पैरामीटर / रिटर्न वैल्यू, कमांड-लाइन तर्क, आदि) के माध्यम से एक प्रोग्राम या फ़ंक्शन, इनपुट और रिटर्न आउटपुट लिख सकते हैं ।

इनपुट दो गैर-नकारात्मक पूर्णांक होंगे। आपको अपनी भाषा के डिफ़ॉल्ट पूर्णांक प्रकार द्वारा समर्थित पूर्ण रेंज को संभालने में सक्षम होना चाहिए, या [0,255]जो भी अधिक हो। आपको गारंटी दी जाती है कि कम से कम एक इनपुट नॉन-जीरो होगा।

आपको बिल्ट-इन का उपयोग करने की अनुमति नहीं है जो कि जीसीडी या एलसीएम (कम से कम सामान्य एकाधिक) की गणना करते हैं।

मानक कोड-गोल्फ नियम लागू होते हैं।

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

0 2     => 2
6 0     => 6
30 42   => 6
15 14   => 1
7 7     => 7
69 25   => 1
21 12   => 3
169 123 => 1
20 142  => 2
101 202 => 101

— माइक शालंत
स्रोत

1

यदि हम asm को उन रजिस्ट्रियों में इनपुट करने की अनुमति दे रहे हैं जो सुविधाजनक हैं, और जो भी reg सुविधाजनक है, उसका परिणाम है, तो हमें निश्चित रूप से फ़ंक्शन, या यहां तक कि कोड टुकड़े (यानी सिर्फ एक फ़ंक्शन बॉडी) की अनुमति देनी चाहिए। मेरे जवाब को एक पूर्ण कार्य बनाते हुए MS के 32 बिट वेक्टरकॉल (एक xchg eax, एक मूव, और एक रिट), या एक स्टैक कॉलिंग कन्वेंशन जैसे अधिक कॉलिंग कन्वेंशन के साथ लगभग 4 बी जोड़ देगा।

— पीटर कॉर्ड्स

@PeterCordes क्षमा करें, मुझे और अधिक विशिष्ट होना चाहिए था। आप पूरी तरह से केवल भालू आवश्यक कोड लिख सकते हैं, लेकिन यदि आप इतने दयालु होंगे कि उक्त कोड को चलाने का तरीका शामिल कर सकें तो यह अच्छा होगा।

— माइक श्लंटा

तो बस gcd कोड गिनें, लेकिन आसपास का कोड प्रदान करें ताकि लोग सत्यापित / प्रयोग / सुधार कर सकें? BTW, दो इनपुटों में से एक के रूप में शून्य के साथ आपके परीक्षण-मामले हमारे x86 मशीन कोड उत्तर तोड़ते हैं। div द्वारा शून्य एक हार्डवेयर अपवाद को जन्म देता है। लिनक्स पर, आपकी प्रक्रिया एक हो जाती है SIGFPE।

— पीटर कॉर्डेस

3

@CodesInChaos मेमोरी और समय सीमाएं आमतौर पर तब तक नजरअंदाज की जाती हैं जब तक कि एल्गोरिथ्म खुद सिद्धांत रूप में सभी इनपुट संभाल सकता है। नियम का अर्थ केवल उन लोगों से बचने के लिए है जो छोरों के लिए मनमाने ढंग से सीमाएं तय करते हैं, जो कि एल्गोरिथ्म को कृत्रिम रूप से इनपुट की एक छोटी श्रृंखला तक सीमित करता है। मैं यह नहीं देख पा रहा हूं कि इसमें कितनी अस्थिरता आती है?

— मार्टिन एंडर

1

gcd (0, n) एरर नहीं n है

— RosLuP

37

रेटिना , १६

^(.+)\1* \1+$
$1

यह यूक्लिड के एल्गोरिथ्म का उपयोग बिल्कुल नहीं करता है - इसके बजाय यह जीसीडी को रेगेक्स मिलान समूहों का उपयोग करता है।

इसे ऑनलाइन आज़माएं। - यह उदाहरण GCD (8,12) की गणना करता है।

2 अंतरिक्ष-पृथक पूर्णांकों के रूप में इनपुट। ध्यान दें कि I / O एकतरफा है। यदि यह स्वीकार्य नहीं है, तो हम यह कर सकते हैं:

रेटिना, ३०

\d+
$*
^(.+)\1* \1+$
$1
1+
$.&

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

जैसा कि @ मार्टिनबटनर बताते हैं, यह बड़ी संख्या के लिए अलग हो जाता है (जैसा कि आम तौर पर किसी भी चीज के लिए होता है)। बहुत कम से कम, INT_MAX के इनपुट के लिए 2GB स्ट्रिंग के आवंटन की आवश्यकता होगी।

— डिजिटल आघात
स्रोत

2

मैं इसके लिए अधिक मतदान करना चाहता हूं

— मिकी टीटी

अब संख्या सीमा के साथ ठीक होना चाहिए। मैंने केवल भाषा की प्राकृतिक संख्या सीमा (या [0,255] यदि यह अधिक है) की आवश्यकता के लिए (ओपी अनुमति के साथ) युक्ति बदल दी है। आपको हालांकि शून्य का समर्थन करना होगा, हालांकि मुझे लगता है कि आपके +एस को बदलना *चाहिए। और आप इसे कम करके लंबे कोड के अंतिम चरण को महत्वपूर्ण रूप से छोटा कर सकते हैं 1।

— मार्टिन एंडर

2

भविष्य के संदर्भ के लिए, मुझे अभी एक वैकल्पिक 16-बाइट समाधान मिला है जो एक मनमाना संख्या में इनपुट के लिए काम करता है (एक सहित) तो यह अन्य संदर्भों में अधिक उपयोगी हो सकता है: retina.tryitonline.net/-

— मार्टिन

1

बस इस बात पर ध्यान दिया गया कि न तो आपके समाधान और न ही मेरी टिप्पणी में से किसी को ऊपर की आवश्यकता है ^, क्योंकि मैच के लिए शुरुआती स्थिति से असफल होना असंभव है।

— मार्टिन एंडर

28

i386 (x86-32) मशीन कोड, 8 बाइट्स (अहस्ताक्षरित के लिए 9B)

+ 1B अगर हमें b = 0इनपुट पर हैंडल करना है।

amd64 (x86-64) मशीन कोड, 9 बाइट्स (अहस्ताक्षरित के लिए 10B, या 64b पूर्णांक हस्ताक्षरित या अहस्ताक्षरित के लिए 14B 13B)

Amd64 पर अहस्ताक्षरित के लिए 10 9B कि इनपुट = 0 के साथ टूट जाता है

इनपुट 32 बिट गैर-शून्य हस्ताक्षरित पूर्णांकों में eaxऔर हैं ecx। में आउटपुट eax।

## 32bit code, signed integers:  eax, ecx
08048420 <gcd0>:
 8048420:       99                      cdq               ; shorter than xor edx,edx
 8048421:       f7 f9                   idiv   ecx
 8048423:       92                      xchg   edx,eax    ; there's a one-byte encoding for xchg eax,r32.  So this is shorter but slower than a mov
 8048424:       91                      xchg   ecx,eax    ; eax = divisor(from ecx), ecx = remainder(from edx), edx = quotient(from eax) which we discard
    ; loop entry point if we need to handle ecx = 0
 8048425:       41                      inc    ecx        ; saves 1B vs. test/jnz in 32bit mode
 8048426:       e2 f8                   loop   8048420 <gcd0>
08048428 <gcd0_end>:
 ; 8B total
 ; result in eax: gcd(a,0) = a

यह लूप संरचना परीक्षण-मामले में विफल रहता है जहां ecx = 0। ( शून्य से विभाजित होने पर divएक #DEहार्डवेयर निष्पादन का कारण बनता है। (लिनक्स पर, कर्नेल एक SIGFPE(फ्लोटिंग पॉइंट अपवाद) वितरित करता है )। यदि लूप एंट्री बिंदु बिंदु इससे पहले सही था inc, तो हम समस्या से बचेंगे। x86-64 संस्करण इसे संभाल सकता है। मुफ्त के लिए, नीचे देखें।

माइक शालंत का जवाब इसके लिए शुरुआती बिंदु था । मेरा लूप उसके जैसा ही काम करता है, लेकिन हस्ताक्षर किए गए पूर्णांकों के लिए क्योंकि cdqएक से एक बाइट कम है xor edx,edx। और हाँ, यह एक या दोनों इनपुट नकारात्मक के साथ सही ढंग से काम करता है। माइक का संस्करण तेजी से चलेगा और यूओपी कैश में कम जगह लेगा ( xchgइंटेल सीपीयू पर 3 यूपीएस है, और loopवास्तव में अधिकांश सीपीयू पर धीमा है ), लेकिन यह संस्करण मशीन-कोड आकार में जीतता है।

मैं पहली बार में नोटिस नहीं किया था कि प्रश्न आवश्यक अहस्ताक्षरित 32 बिट। xor edx,edxइसके बजाय वापस जाने के लिए cdqएक बाइट खर्च होगी। divके रूप में एक ही आकार है idiv, और बाकी सब कुछ वही रह सकता है ( xchgडेटा आंदोलन के लिए और inc/loopअभी भी काम करता है।)

दिलचस्प है, 64 बिट ऑपरेंड-साइज़ ( raxऔर rcx) के लिए, हस्ताक्षरित और अहस्ताक्षरित संस्करण समान आकार हैं। हस्ताक्षरित संस्करण को cqo(2B) के लिए REX उपसर्ग की आवश्यकता है , लेकिन अहस्ताक्षरित संस्करण अभी भी 2B का उपयोग कर सकता है xor edx,edx।

64 बिट कोड में, inc ecx2 बी है: एकल-बाइट inc r32और dec r32ओपकोड को आरईएक्स उपसर्ग के रूप में पुनर्निर्मित किया गया था। inc/loop64 बिट मोड में किसी भी कोड-आकार को नहीं बचाता है, इसलिए आप भी कर सकते हैं test/jnz। 64 बिट पूर्णांक पर संचालन REX उपसर्गों में प्रति निर्देश के अलावा एक loopया एक बाइट जोड़ता है, या jnz। शेष 32 शून्य (उदा gcd((2^32), (2^32 + 1))) में सभी शून्य होना संभव है , इसलिए हमें पूरे आरएक्स का परीक्षण करने की आवश्यकता है और एक बाइट को नहीं बचा सकता है test ecx,ecx। हालाँकि, धीमी jrcxzइन्सान केवल 2B है, और हम इसे लूप के शीर्ष पर रख सकते हैं ताकि ecx=0प्रवेश पर नियंत्रण हो सके :

## 64bit code, unsigned 64 integers:  rax, rcx
0000000000400630 <gcd_u64>:
  400630:       e3 0b                   jrcxz  40063d <gcd_u64_end>   ; handles rcx=0 on input, and smaller than test rcx,rcx/jnz
  400632:       31 d2                   xor    edx,edx                ; same length as cqo
  400634:       48 f7 f1                div    rcx                      ; REX prefixes needed on three insns
  400637:       48 92                   xchg   rdx,rax
  400639:       48 91                   xchg   rcx,rax
  40063b:       eb f3                   jmp    400630 <gcd_u64>
000000000040063d <gcd_u64_end>:
## 0xD = 13 bytes of code
## result in rax: gcd(a,0) = a

32 और 64b संस्करणों के लिए गॉडबोल्ट कंपाइलर एक्सप्लोरर पर स्रोत और एसएसएम आउटपुट कोmain चलाने सहित पूर्ण रन करने योग्य परीक्षण कार्यक्रम । 32bit ( ), 64bit ( ) और x32 ABI ( ) के लिए परीक्षण किया गया और काम कर रहा है ।printf("...", gcd(atoi(argv[1]), atoi(argv[2])) ); -m32-m64-mx32

यह भी शामिल है: केवल बार-बार घटाव का उपयोग करने वाला एक संस्करण , जो कि 9B है जो अहस्ताक्षरित के लिए है, यहां तक कि x86-64 मोड के लिए भी, और इसके एक इनपुट को अनियंत्रित रजिस्टर में ले सकते हैं। हालाँकि, यह प्रविष्टि पर 0 होने के साथ इनपुट को संभाल नहीं सकता है (यह पता लगाता है कि कब subशून्य पैदा करता है, जो x - 0 कभी नहीं करता है)।

32 बिट संस्करण के लिए GNU C इनलाइन asm स्रोत (साथ संकलित gcc -m32 -masm=intel)

int gcd(int a, int b) {
    asm (// ".intel_syntax noprefix\n"
        // "jmp  .Lentry%=\n" // Uncomment to handle div-by-zero, by entering the loop in the middle.  Better: `jecxz / jmp` loop structure like the 64b version
        ".p2align 4\n"                  // align to make size-counting easier
         "gcd0:   cdq\n\t"              // sign extend eax into edx:eax.  One byte shorter than xor edx,edx
         "        idiv    ecx\n"
         "        xchg    eax, edx\n"   // there's a one-byte encoding for xchg eax,r32.  So this is shorter but slower than a mov
         "        xchg    eax, ecx\n"   // eax = divisor(ecx), ecx = remainder(edx), edx = garbage that we will clear later
         ".Lentry%=:\n"
         "        inc     ecx\n"        // saves 1B vs. test/jnz in 32bit mode, none in 64b mode
         "        loop    gcd0\n"
        "gcd0_end:\n"
         : /* outputs */  "+a" (a), "+c"(b)
         : /* inputs */   // given as read-write outputs
         : /* clobbers */ "edx"
        );
    return a;
}

आम तौर पर मैं पूरे फ़ंक्शन को asm में लिखूंगा, लेकिन GNU C इनलाइन asm को एक स्निपेट शामिल करने का सबसे अच्छा तरीका लगता है जो हम जो भी regs चुनते हैं उसमें / आउटपुट हो सकते हैं। जैसा कि आप देख सकते हैं, GNU C इनलाइन asm सिंटैक्स asm को बदसूरत और शोर बनाता है। यह भी एक है करने के लिए वास्तव में मुश्किल रास्ता जानने के एएसएम ।

यह वास्तव में .att_syntax noprefixमोड में संकलित और काम करेगा , क्योंकि उपयोग किए गए सभी इंसन्स या तो सिंगल / नो ऑपरेंड हैं या नहीं xchg। वास्तव में एक उपयोगी अवलोकन नहीं है।

— पीटर कॉर्डेस
स्रोत

2

@ मायके शालंत: धन्यवाद। यदि आप एएसएम को अनुकूलित करना पसंद करते हैं, तो स्टैकओवरफ्लो पर मेरे कुछ जवाबों पर एक नज़र डालें। :)

— पीटर कॉर्ड्स

2

@ मायिकश्लंता: मुझे jrcxzuint64_t संस्करण :) में आखिरकार एक उपयोग मिल गया। साथ ही, यह भी ध्यान नहीं दिया कि आपने अहस्ताक्षरित निर्दिष्ट किया है, इसलिए मैंने उसके लिए बाइट की गिनती भी शामिल की है।

— पीटर कॉर्ड्स

आप jecxz32-बिट संस्करण में एक ही प्रभाव का उपयोग क्यों नहीं कर सके ?

— कोडी ग्रे

1

@ कोडीग्रे: inc/loop32-बिट संस्करण में 3 बाइट्स हैं, लेकिन 64-बिट संस्करण में 4 बी। इसका मतलब है कि केवल 64-बिट संस्करण में, इसका उपयोग करने के लिए jrcxzऔर jmpइसके बजाय अतिरिक्त बाइट खर्च नहीं होता है inc / loop।

— पीटर Cordes

क्या आप प्रवेश के रूप में मध्य की ओर इशारा नहीं कर सकते?

— l4m2

14

हेक्सागोनी , 17 बाइट्स

?'?>}!@<\=%)>{\.(

सामने आया:

  ? ' ?
 > } ! @
< \ = % )
 > { \ .
  ( . .

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

इसे साइड-लेंथ 3 में फिट करना एक हवा थी। अंत में उन दो बाइट्स को शेविंग करना नहीं था ... मुझे यकीन नहीं है कि यह इष्टतम है, लेकिन मुझे यकीन है कि मुझे लगता है कि यह करीब है।

व्याख्या

एक और यूक्लिडियन एल्गोरिथ्म कार्यान्वयन।

कार्यक्रम में तीन मेमोरी किनारों का उपयोग किया गया है, जिसे मैं ए , बी और सी कहूंगा, जिसमें मेमोरी पॉइंटर (एमपी) को दिखाया गया है:

यहाँ नियंत्रण प्रवाह आरेख है:

नियंत्रण प्रवाह इनपुट के लिए एक छोटे रैखिक बिट के साथ ग्रे पथ पर शुरू होता है:

?    Read first integer into memory edge A.
'    Move MP backwards onto edge B.
?    Read second integer into B.

ध्यान दें कि कोड अब किनारों के चारों <ओर बाएं कोने में लपेटता है । यह <एक शाखा के रूप में कार्य करता है। यदि वर्तमान किनारा शून्य है (यानी यूक्लिडियन एल्गोरिथ्म समाप्त हो जाता है), तो आईपी बाईं ओर विक्षेपित होता है और लाल पथ लेता है। अन्यथा, यूक्लिडियन एल्गोरिथ्म का एक पुनरावृत्ति ग्रीन पथ पर गणना की जाती है।

हम पहले हरे रास्ते पर विचार करेंगे। ध्यान दें कि >और \सभी दर्पण के रूप में कार्य करते हैं जो केवल निर्देश सूचक को विक्षेपित करते हैं। यह भी ध्यान दें कि नियंत्रण प्रवाह किनारों के चारों ओर तीन बार लपेटता है, एक बार नीचे से ऊपर तक, एक बार दाहिने कोने से नीचे की पंक्ति में और अंत में नीचे के दाहिने कोने से बाएं कोने तक की स्थिति की फिर से जाँच करें। यह भी ध्यान दें कि .नो-ऑप हैं।

एक एकल पुनरावृत्ति के लिए निम्न रैखिक कोड छोड़ता है:

{    Move MP forward onto edge C.
'}   Move to A and back to C. Taken together this is a no-op.
=    Reverse the direction of the MP so that it now points at A and B. 
%    Compute A % B and store it in C.
)(   Increment, decrement. Taken together this is a no-op, but it's
     necessary to ensure that IP wraps to the bottom row instead of
     the top row.

अब हम वापस आ गए हैं जहां हमने शुरू किया था, सिवाय इसके कि तीन किनारों ने अपनी भूमिकाओं को चक्रीय रूप से बदल दिया है (मूल सी अब बी की भूमिका लेता है और मूल बी की भूमिका ए ...)। प्रभाव में, हमने क्रमशः Aऔर Bसाथ में Bऔर A % B, इनपुट जारी किए हैं।

एक बार A % B(एज सी पर ) शून्य है, जीसीडी एज बी पर पाया जा सकता है । फिर से >आईपी को डिफ्लेक्ट करता है, इसलिए लाल रास्ते पर हम अमल करते हैं:

}    Move MP to edge B.
!    Print its value as an integer.
@    Terminate the program.

— मार्टिन एंडर
स्रोत

9

32-बिट लिटिल-एंडियन x86 मशीन कोड, 14 बाइट्स

का उपयोग कर बनाया गया nasm -f bin

d231 f3f7 d889 d389 db85 f475

    gcd0:   xor     edx,edx
            div     ebx
            mov     eax,ebx
            mov     ebx,edx
            test    ebx,ebx
            jnz     gcd0

— माइक शालंत
स्रोत

4

मैंने इसे 8 बाइट्स का उपयोग करके cdqऔर हस्ताक्षरित करके नीचे कर दिया idiv, और xchg eax, r32इसके बजाय एक-बाइट mov। 32bit कोड के लिए: के inc/loopबजाय test/jnz(मैं उपयोग करने के लिए एक रास्ता नहीं देख सकता है jecxz, और वहाँ नहीं है jecxnz)। मैंने अपने अंतिम संस्करण को एक नए उत्तर के रूप में पोस्ट किया क्योंकि मुझे लगता है कि बदलाव इसे न्यायसंगत बनाने के लिए पर्याप्त हैं।

— पीटर कॉर्ड्स

9

टी-एसक्यूएल, 153 169 बाइट्स

किसी ने गोल्फ के लिए सबसे खराब भाषा का उल्लेख किया है?

CREATE FUNCTION G(@ INT,@B INT)RETURNS TABLE RETURN WITH R AS(SELECT 1D,0R UNION ALL SELECT D+1,@%(D+1)+@B%(D+1)FROM R WHERE D<@ and D<@b)SELECT MAX(D)D FROM R WHERE 0=R

एक टेबल वैल्यू फंक्शन बनाता है जो आम डिविजर्स को वर्कआउट करने के लिए एक रिर्सचिव क्वेरी का उपयोग करता है। फिर यह अधिकतम रिटर्न देता है । अब यहाँ मेरे जवाब से प्राप्त GCD निर्धारित करने के लिए यूक्लिडियन एल्गोरिथ्म का उपयोग करता है ।

उदाहरण उपयोग

SELECT * 
FROM (VALUES
        (15,45),
        (45,15),
        (99,7),
        (4,38)
    ) TestSet(A, B)
    CROSS APPLY (SELECT * FROM G(A,B))GCD

A           B           D
----------- ----------- -----------
15          45          15
45          15          15
99          7           1
4           38          2

(4 row(s) affected)

— MickyT
स्रोत

1

यीशु जो क्रिया है।

— साइओस

9

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

ṛß%ðḷṛ?

यूक्लिडियन एल्गोरिदम का पुनरावर्ती कार्यान्वयन। इसे ऑनलाइन आज़माएं!

अगर बिल्ट-इन की मनाही नहीं होती, g(1 बाइट, बिल्ट-इन जीसीडी) एक बेहतर स्कोर हासिल करता।

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

ṛß%ðḷṛ?  Main link. Arguments: a, b

   ð     Convert the chain to the left into a link; start a new, dyadic chain.
 ß       Recursively call the main link...
ṛ %        with b and a % b as arguments.
     ṛ?  If the right argument (b) is non-zero, execute the link.
    ḷ    Else, yield the left argument (a).

— डेनिस
स्रोत

यह लगभग धोखा देने जैसा लगता है, मुझे यह निर्दिष्ट करना पड़ सकता है कि उत्तर बटलिनों का उपयोग नहीं कर सकते ...

— माइक श्लंट

13

यदि आप ऐसा करने का निर्णय लेते हैं, तो आपको इसे जल्दी करना चाहिए। यह वर्तमान में तीन उत्तरों को अमान्य कर देगा।

— डेनिस

ध्यान दें कि वह निर्दिष्ट लंबाई बाइट्स में है - उन वर्णों में अधिकतर> 1 बाइट UTF8 में हैं।

— कोर्टिस

8

@ कॉर्टिस हां, सभी कोड गोल्फ कॉन्टेस्ट डिफ़ॉल्ट रूप से बाइट्स में बनाए जाते हैं। हालांकि, जेली UTF-8 का उपयोग नहीं करता है, लेकिन एक कस्टम कोड पेज जो प्रत्येक 256 वर्णों को एक ही बाइट के रूप में समझता है, को एन्कोड करता है।

— डेनिस

@ डेनिस आह, चतुर।

— cortices

7

हास्केल, 19 बाइट्स

a#0=a
a#b=b#rem a b

प्रयोग उदाहरण: 45 # 35-> 5।

यूक्लिड, फिर से।

पुनश्च: बेशक वहाँ एक निर्मित में gcdभी है।

— nimi
स्रोत

आपको सशर्त जांच से बचने के लिए इनपुट ऑर्डर को उलटने वाले ट्रिक को स्पष्ट करना चाहिए

— गर्व हैस्केलर

@proudhaskeller: क्या ट्रिक? हर कोई इस एल्गोरिथ्म का उपयोग करता है, यानी स्टॉप पर 0या मापांक के साथ चल रहा है।

— nimi

नेवरमाइंड, हर कोई चाल का उपयोग कर रहा है

— गर्वित हैकेलर

यह, कम गोल्फ वाला, लगभग ठीक उसी तरह का हैPrelude

— माइकल क्लेन

6

पायथन 3, 31

Sp3000 के लिए 3 बाइट्स को सहेजा गया।

g=lambda a,b:b and g(b,a%b)or a

— मॉर्गन थ्राप्प
स्रोत

3

पायथन 3.5+ में:from math import*;gcd

— Sp3000

@ Sp3000 अच्छा, मुझे नहीं पता था कि वे इसे गणित में स्थानांतरित कर चुके हैं।

— मॉर्गन थ्रैप

1

जब आप इस पर हों:g=lambda a,b:b and g(b,a%b)or a

— Sp3000

@ Sp3000 धन्यवाद! मैंने अभी एक पुनरावर्ती समाधान समाप्त किया है, लेकिन यह मेरे पास जितना था उससे भी बेहतर है।

— मॉर्गन थ्राप्प

GCD और LCM के लिए बिल्ट-इन अस्वीकृत हैं, इसलिए दूसरा समाधान मान्य नहीं होगा।

— mbomb007

6

MATL , 11 9 बाइट्स

लगता है किसी ने भी अब तक ब्रूट बल का इस्तेमाल नहीं किया है, इसलिए यहां ऐसा है।

ts:\a~f0)

इनपुट दो नंबर ( ;विभाजक के रूप में उपयोग ) के साथ एक कॉलम सरणी है ।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

t     % Take input [a;b] implicitly. Duplicate
s     % Sum. Gives a+b
:     % Array [1,2,...,a+b]
\     % Modulo operation with broadcast. Gives a 2×(a+b) array
a~    % 1×(a+b) array that contains true if the two modulo operations gave 0
f0)   % Index of last true value. Implicitly display

— लुइस मेंडो
स्रोत

5

सी, 38 बाइट्स

g(x,y){while(x^=y^=x^=y%=x);return y;}

— कैसे चेन
स्रोत

1

आपको अपने बाइटकाउंट में फ़ंक्शन की परिभाषा को शामिल करना होगा।

— R

1

@Riker खेद है कि के लिए, मैं परिभाषा गिनती जोड़ते हैं और अपडेट

— कैसे चेन

आप gइसके बजाय फ़ंक्शन को नाम देकर दो बाइट्स बचा सकते हैं gcd।

— स्टेडीबॉक्स

@Steadybox ठीक है, हाँ, पहली बार इस समुदाय में शामिल हों :)

— कैसे चेन

1

PPCG में आपका स्वागत है!

— R

4

सी, 28 बाइट्स

यूक्लिड के एल्गोरिथ्म को लागू करने के बजाय एक सीधा कार्य। शायद एक वैकल्पिक एल्गोरिथ्म का उपयोग करके कोई भी छोटा हो सकता है।

g(a,b){return b?g(b,a%b):a;}

यदि कोई थोड़ा मुख्य आवरण लिखता है

int main(int argc, char **argv)
{
  printf("gcd(%d, %d) = %d\n", atoi(argv[1]), atoi(argv[2]), g(atoi(argv[1]), atoi(argv[2])));
}

तो एक कुछ मूल्यों का परीक्षण कर सकते हैं:

$ ./gcd 6 21
gcd (6, 21) = 3
$ ./gcd 21 6
gcd (21, 6) = 3
$ ./gcd 6 8
gcd (6, 8) = 2
$ ./gcd 1 1
gcd (1, 1) = 1
$ ./gcd 6 16
gcd (6, 16) = 2
$ ./gcd 27 244
gcd (27, 244) = 1

— Cl-
स्रोत

4

भूलभुलैया , 18 बाइट्स

?}
:
)"%{!
( =
}:{

एक त्रुटि के साथ समाप्त होता है, लेकिन त्रुटि संदेश STDERR को जाता है।

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

यह अभी तक काफी इष्टतम महसूस नहीं करता है, लेकिन मैं इस बिंदु पर 3x3 से नीचे लूप को संकुचित करने का एक तरीका नहीं देख रहा हूं।

व्याख्या

यह यूक्लिडियन एल्गोरिथ्म का उपयोग करता है।

सबसे पहले, इनपुट पढ़ने और मुख्य लूप में आने के लिए एक रैखिक बिट है। निर्देश पॉइंटर (आईपी) शीर्ष बाएं कोने में शुरू होता है, पूर्व की ओर।

?    Read first integer from STDIN and push onto main stack.
}    Move the integer over to the auxiliary stack.
     The IP now hits a dead end so it turns around.
?    Read the second integer.
     The IP hits a corner and follows the bend, so it goes south.
:    Duplicate the second integer.
)    Increment.
     The IP is now at a junction. The top of the stack is guaranteed to be
     positive, so the IP turns left, to go east.
"    No-op.
%    Modulo. Since `n % (n+1) == n`, we end up with the second input on the stack.

अब हम एक प्रकार का टाइम-डू लूप दर्ज करते हैं जो यूक्लिडियन एल्गोरिथ्म की गणना करता है। स्टैक के सबसे ऊपर होते हैं aऔर b(शून्य के एक अंतर्निहित अनंत राशि के शीर्ष पर, लेकिन हमें उन की आवश्यकता नहीं होगी)। हम एक-दूसरे की ओर बढ़ते हुए, ढेर की ओर का प्रतिनिधित्व करेंगे:

    Main     Auxiliary
[ ... 0 a  |  b 0 ... ]

एक बार aशून्य होने पर लूप समाप्त हो जाता है। एक लूप पुनरावृत्ति निम्नानुसार काम करती है:

=    Swap a and b.           [ ... 0 b  |  a 0 ... ]
{    Pull a from aux.        [ ... 0 b a  |  0 ... ]
:    Duplicate.              [ ... 0 b a a  |  0 ... ]
}    Move a to aux.          [ ... 0 b a  |  a 0 ... ]
()   Increment, decrement, together a no-op.
%    Modulo.                 [ ... 0 (b%a)  |  a 0 ... ]

आप देख सकते हैं, हम बदल दिया है aऔर bसाथ b%aऔर aक्रमशः।

अंत में, एक बार b%aशून्य होने पर, IP पूर्व की ओर बढ़ता रहता है और निष्पादित होता है:

{    Pull the non-zero value, i.e. the GCD, over from aux.
!    Print it.
     The IP hits a dead end and turns around.
{    Pull a zero from aux.
%    Attempt modulo. This fails due to division by 0 and the program terminates.

— मार्टिन एंडर
स्रोत

4

जूलिया, 21 15 बाइट्स

a\b=a>0?b%a\a:b

यूक्लिडियन एल्गोरिदम का पुनरावर्ती कार्यान्वयन। इसे ऑनलाइन आज़माएं!

अगर बिल्ट-इन की मनाही नहीं होती, gcd(3 बाइट्स, बिल्ट-इन जीसीडी) एक बेहतर स्कोर हासिल करते।

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

a\b=             Redefine the binary operator \ as follows:
    a>0?     :       If a > 0:
        b%a\a        Resursively apply \ to b%a and a. Return the result.
              b      Else, return b.

— डेनिस
स्रोत

4

क्यूबिक्स , 10 12 बाइट्स

?v%uII/;O@

इसे यहाँ आज़माएँ

यह घन पर लपेटता है:

    ? v
    % u
I I / ; O @ . .
. . . . . . . .
    . .
    . .

यूक्लिडियन विधि का उपयोग करता है।

IIदो नंबर एसटीडीआईएन से पकड़े गए हैं और स्टैक
/फ्लो पर लगाए गए हैं जो कि
%मॉड ऑफ द स्टैक के ऊपर दर्शाए गए हैं । शेष को स्टैक के शीर्ष पर छोड़ दिया जाता है
?यदि टीआईओएस 0 तो आगे बढ़ें, अन्यथा दाएं मुड़ें
vयदि 0 नहीं तो नीचे से रीडायरेक्ट करें और uमॉड पर दो बार दाईं ओर मुड़ें
/यदि 0 क्यूब के आसपास रिफ्लेक्टर
;ड्रॉप टीओएस, Oआउटपुट टीओएस और @अंत में जाएं।

— MickyT
स्रोत

मैंने सिर्फ एक 12-बाइट क्यूबिक्स उत्तर लिखा, फिर जवाबों के माध्यम से स्क्रॉल करना शुरू कर दिया कि क्या मुझे दोनों को संभालने की जरूरत है 0,xऔर x,0... फिर मैं इस पर आया। अच्छा है!

— ETHproductions

4

सी #, 24 बाइट्स

x=(a,b)=>b<1?a:x(b,a%b);

— मॉर्गन थ्राप्प
स्रोत

3

विंडोज बैच, 76 बाइट्स

पुनरावर्ती कार्य। इसे GCD a bफ़ाइल नाम के साथ कॉल करें gcd।

:g
if %2 equ 0 (set f=%1
goto d)
set/a r=%1 %% %2
call :g %2 %r%
:d
echo %f%

— Timtech
स्रोत

3

MATL, 7 बाइट्स

pG1$Zm/

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

व्याख्या

चूँकि हम अंतर्निहित GCD फ़ंक्शन ( ZdMATL में) का स्पष्ट रूप से उपयोग नहीं कर सकते हैं , मैंने इस तथ्य का दोहन किया है कि सबसे कम aऔर कई bबार सबसे बड़ा सामान्य भाजक aऔर bके उत्पाद के बराबर है aऔर b।

p       % Grab the input implicitly and multiply the two elements
G       % Grab the input again, explicitly this time
1$Zm    % Compute the least-common multiple
/       % Divide the two to get the greatest common denominator

— Suever
स्रोत

आप दो अलग-अलग इनपुट के साथ एक बाइट बचा सकते हैं:*1MZm/

— लुइस मेंडो

3

रैकेट (स्कीम), 44 बाइट्स

रैकेट में यूक्लिड कार्यान्वयन (योजना)

(define(g a b)(if(= 0 b)a(g b(modulo a b))))

संपादित करें: @Numeri का समाधान योग्य नहीं देखा। किसी तरह हमें स्वतंत्र रूप से सटीक समान कोड मिला

— kronicmage
स्रोत

क्या यह दोनों में काम करता है?

— NoOneIsHere

@NoOneIsHere हाँ, यह दोनों में काम करता है

— क्रोनिकमेज

3

> <> , 32 बाइट्स

::{::}@(?\=?v{:}-
.!09}}${{/;n/>

स्टैक से दो मानों को स्वीकार करता है और उनके जीसीडी का उत्पादन करने के लिए यूक्लिडियन एल्गोरिथ्म लागू करता है।

आप इसे यहाँ आज़मा सकते हैं !

> <> में बेहतर जवाब के लिए, सोक की जाँच करें !

— हारून
स्रोत

1

मुझे आज एक नई भाषा मिली :)

— nsane

3

ReRegex , 23 बाइट्स

रेटिना के उत्तर के लिए समान रूप से काम करता है।

^(_*)\1* \1*$/$1/#input

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

— Ataco
स्रोत

2

जीएमएल, 57 बाइट्स

a=argument0
b=argument1
while b{t=b;b=a mod b;a=t}return a

— Timtech
स्रोत

2

डेल्फी 7, 148

खैर, मुझे लगता है कि मैंने गोल्फ के लिए सबसे नई भाषा ढूंढ ली है।

unit a;interface function g(a,b:integer):integer;implementation function g(a,b:integer):integer;begin if b=0then g:=a else g:=g(b,a mod b);end;end.

— मॉर्गन थ्राप्प
स्रोत

ओह मैं नहीं जानता, कोष्ठकों के गोल्फ के लिए बहुत गरीब है

— MickyT

2

हून, 20 बाइट्स

|=
{@ @}
d:(egcd +<)

-

हून # 2, 39 बाइट्स

|=
{a/@ b/@}
?~
b
a
$(a b, b (mod a b))

अजीब तरह से, जीसीडी के लिए हून के स्टडलिब में एकमात्र कार्यान्वयन अपने आरएसए क्रिप्टो के लिए उपयोग में है, जो कुछ अन्य मूल्यों को भी लौटाता है। मुझे इसे एक फ़ंक्शन में लपेटना है जो केवल dआउटपुट से लेता है ।

अन्य कार्यान्वयन केवल डिफ़ॉल्ट पुनरावर्ती GCD परिभाषा है।

— RenderSettings
स्रोत

2

पायथन 3.5, 70 82 73 बाइट्स:

lambda*a:max([i for i in range(1,max(*a)+1)if not sum(g%i for g in[*a])])

notमें इस मामले में यकीन है कि योग सभी नंबरों को कर देगा *argsसापेक्ष iशून्य कर रहे हैं।

इसके अलावा, अब यह लैंबडा फ़ंक्शन गणित मॉड्यूल >=2के gcdफ़ंक्शन के विपरीत , जब तक आप इसे चाहते हैं, तब तक इसे जितने मूल्यों में ले जा सकते हैं, मान सकते हैं । उदाहरण के लिए, यह मूल्यों में ले सकता है 2,4,6,8,10और 2 का सही GCD लौटा सकता है।

— आर। कप
स्रोत

1

आप मल्टीचेर चर नामों के लिए गिरफ्त में हैं। (या फ़ंक्शन तर्क, लेकिन जो भी हो)

— कैलक्यूलेटरफलाइन

2

रूबी, 23 बाइट्स

g=->a,b{b>0?a:g[b,a%b]}

याद रखें कि माणिक ब्लॉक को g [...] या g.call (...) के साथ कहा जाता है, बजाय g (...)

voidpigeon को आंशिक क्रेडिट

— लुइस मूसली
स्रोत

2

इसके बजाय g.call(a,b)आप उपयोग कर सकते हैं g[a,b]। इसके बजाय proc{|a,b|, आप उपयोग कर सकते हैं ->a,b{।

— afuous

1

आप अन्य ऑपरेंड के ऑर्डर को स्विच करने और स्विच b>0करने के बजाय एक बाइट भी बचा सकते हैं b<=0।

— afuous

2

एआरएम मशीन कोड, 12 बाइट्स:

सभा:

gcd: cmp r0, r1
     sublt r0, r0, r1
     bne gcd

वर्तमान में यह संकलन नहीं किया जा सकता है, लेकिन ARM में प्रत्येक निर्देश 4 बाइट्स लेता है। संभवत: इसे THUMB-2 मोड का उपयोग करके नीचे गिराया जा सकता है।

— स्टायरोफोम मक्खी
स्रोत

अच्छा काम करने वाला कोई भी व्यक्ति जो मशीन कोड में ऐसा करता है, मुझे गंभीर प्रॉप्स मिलते हैं।

— माइक श्लंता

यह केवल घटाव का उपयोग करके यूक्लिड के अहंकार पर एक प्रयास प्रतीत होता है , लेकिन मुझे नहीं लगता कि यह काम करता है। यदि r0 > r1तब subltकुछ नहीं करेंगे ( ltविधेय मिथ्या है) और bneअनंत लूप होगा। मुझे लगता है कि आपको स्वैप की आवश्यकता है यदि नहीं lt, तो एक ही लूप कर सकते हैं b-=aया a-=bआवश्यकतानुसार। या एक नकारात्मक अगर उप उत्पादित कैरी (उर्फ उधार)।

— पीटर कॉर्डेस

यह एआरएम अनुदेश सेट गाइड वास्तव में भविष्यवाणी के लिए एक उदाहरण के रूप में एक घटाव जीसीडी एल्गोरिथ्म का उपयोग करता है। (पृष्ठ २५)। वे cmp r0, r1/ subgt r0, r0, r1/ sublt r1, r1, r0/ का उपयोग करते हैं bne gcd। एआरएम निर्देशों में यह 16 बी है, शायद थंब 2 निर्देशों में 12?

— पीटर कॉर्डेस

1

86 पर, मैं के साथ 9 बाइट्स में कामयाब रहे: sub ecx, eax/ jae .no_swap/ add ecx,eax/ xchg ecx,eax/ jne। तो एक cmp के बजाय, मैं अभी उप, फिर पूर्ववत करें और स्वैप करें यदि उप को दूसरे तरीके से जाना चाहिए। मैंने इसका परीक्षण किया, और यह काम करता है। ( गलत समय पर बाहर addनहीं jneनिकलेंगे, क्योंकि यह तब तक एक शून्य का उत्पादन नहीं कर सकता है जब तक कि किसी एक इनपुट के साथ शुरू करने के लिए शून्य नहीं था, और वह समर्थन नहीं करता है। अपडेट: हमें इनपुट के शून्य होने का समर्थन करने की आवश्यकता है: /)

— पीटर कॉर्डेस

Thumb2 के लिए, एक iteनिर्देश है: if- then- अन्यथा। Cmp / sub one way / उप मार्ग के लिए एकदम सही होना चाहिए।

— पीटर कॉर्डेस

2

टीआई-बेसिक, 10 बाइट्स

Prompt A,B:gcd(A,B

नए नियम की वजह से गैर-प्रतिस्पर्धात्मक जीडीबी बिल्ट-इन की मनाही है

gcd(बिल्ट-इन के बिना 17 बाइट समाधान

Prompt A,B:abs(AB)/lcm(A,B

नए नियम की वजह से गैर-प्रतिस्‍पर्द्धी lcm बिल्‍ट-इन निषिद्ध है

बिना gcd(या lcm(निर्मित में 27 बाइट समाधान :

Prompt A,B:While B:B→T:BfPart(A/B→B:T→A:End:A

बिना gcd(या lcm(बिल्ट-इन के 35 बाइट पुनरावर्ती समाधान (2.53 एमपी ऑपरेटिंग सिस्टम या उच्चतर की आवश्यकता है prgmG ) , का नाम होना चाहिए :

If Ans(2:Then:{Ans(2),remainder(Ans(1),Ans(2:prgmG:Else:Disp Ans(1:End

आप पुनरावर्ती संस्करण के लिए तर्क पारित करेंगे {A,B}ताकि उदाहरण के {1071, 462}:prgmGलिए उपज होगी 21।

— Timtech
स्रोत

रंग मुझे प्रभावित करता है।

— माइक श्लंता

आपको शायद इस बात का उल्लेख करना चाहिए कि अंतिम के रूप में सहेजने की आवश्यकता है prgmG।

— एक स्पेगेटो

2

05AB1E , 10 बाइट्स

कोड:

EàF¹N%O>iN

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

बिल्ट-इन के साथ:

¿

स्पष्टीकरण:

¿   # Implicit input, computes the greatest common divisor.
    # Input can be in the form a \n b, which computes gcd(a, b)
    # Input can also be a list in the form [a, b, c, ...], which computes the gcd of
      multiple numbers.

इसे ऑनलाइन आज़माएं! या कई नंबरों के साथ प्रयास करें ।

— अदनान
स्रोत

2

Oracle SQL 11.2, 104 118 बाइट्स

SELECT MAX(:1+:2-LEVEL+1)FROM DUAL WHERE(MOD(:1,:1+:2-LEVEL+1)+MOD(:2,:1+:2-LEVEL+1))*:1*:2=0 CONNECT BY LEVEL<=:1+:2;

0 के इनपुट के लिए निश्चित

— Jeto
स्रोत

यदि इनपुट में से कोई एक शून्य है तो सही तरीके से काम नहीं करता है।

— ईगोर स्क्रीप्टुनॉफ़

यह आपको कुछ बचा सकता हैSELECT MAX(LEVEL)FROM DUAL WHERE MOD(:1,LEVEL)+MOD(:2,LEVEL)=0 CONNECT BY LEVEL<=:1+:2;

— मिकी टीटी

2

> <> , 12 + 3 = 15 बाइट्स

:?!\:}%
;n~/

स्टैक पर मौजूद इनपुट संख्याओं की अपेक्षा करता है, इसलिए -vध्वज के लिए +3 बाइट्स । इसे ऑनलाइन आज़माएं!

यूक्लिडियन एल्गोरिथ्म का एक और कार्यान्वयन।

— सोक
स्रोत

महत्तम सामान्य भाजक

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

रेटिना , १६

रेटिना, ३०

i386 (x86-32) मशीन कोड, 8 बाइट्स (अहस्ताक्षरित के लिए 9B)

amd64 (x86-64) मशीन कोड, 9 बाइट्स (अहस्ताक्षरित के लिए 10B, या 64b पूर्णांक हस्ताक्षरित या अहस्ताक्षरित के लिए 14B 13B)

Amd64 पर अहस्ताक्षरित के लिए 10 9B कि इनपुट = 0 के साथ टूट जाता है

हेक्सागोनी , 17 बाइट्स

व्याख्या

32-बिट लिटिल-एंडियन x86 मशीन कोड, 14 बाइट्स

टी-एसक्यूएल, 153 169 बाइट्स

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

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

हास्केल, 19 बाइट्स

पायथन 3, 31

MATL , 11 9 बाइट्स

व्याख्या

सी, 38 बाइट्स

सी, 28 बाइट्स

भूलभुलैया , 18 बाइट्स

व्याख्या

जूलिया, 21 15 बाइट्स

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

क्यूबिक्स , 10 12 बाइट्स

सी #, 24 बाइट्स

विंडोज बैच, 76 बाइट्स

MATL, 7 बाइट्स

रैकेट (स्कीम), 44 बाइट्स

> <> , 32 बाइट्स

ReRegex , 23 बाइट्स

जीएमएल, 57 बाइट्स

डेल्फी 7, ​​148

हून, 20 बाइट्स

हून # 2, 39 बाइट्स

पायथन 3.5, 70 82 73 बाइट्स:

रूबी, 23 बाइट्स

एआरएम मशीन कोड, 12 बाइट्स:

टीआई-बेसिक, 10 बाइट्स

05AB1E , 10 बाइट्स

Oracle SQL 11.2, 104 118 बाइट्स

> <> , 12 + 3 = 15 बाइट्स

डेल्फी 7, 148