सबसे बड़े सामान्य भाजक की कल्पना करें

Question

पृष्ठभूमि

सबसे बड़ा सामान्य भाजक ( शॉर्ट के लिए जीसीडी ) एक सुविधाजनक गणितीय कार्य है, क्योंकि इसमें कई उपयोगी गुण हैं। उनमें से एक Bézout की पहचान है : यदि d = gcd(a, b), तो वहाँ पूर्णांक xऔर yऐसे मौजूद हैं d = x*a + y*b। इस चुनौती में, आपका कार्य सरल ASCII कला के साथ इस संपत्ति की कल्पना करना है।

इनपुट

आपके इनपुट दो सकारात्मक पूर्णांक हैं aऔर b, किसी भी उचित प्रारूप में दिए गए हैं। आप अनरीट इनपुट्स (अपनी पसंद के एकल प्रिंट करने योग्य एएससीआईआई चरित्र की पुनरावृत्ति) भी ले सकते हैं, लेकिन आपको संगत होना चाहिए और दोनों इनपुटों के लिए एक ही प्रारूप का उपयोग करना होगा। इनपुट किसी भी क्रम में हो सकते हैं, और वे समान हो सकते हैं।

उत्पादन

आपका आउटपुट sलंबाई की एक स्ट्रिंग है lcm(a, b) + 1( lcm सबसे सामान्य बहु के लिए खड़ा है)। के पात्रों sसे पूर्णांकों का प्रतिनिधित्व 0करने के लिए lcm(a, b)। यदि चरित्र एक से अधिक है, या एक अवधि है, तो s[i]एक लोअरकेस हैoiab. अन्यथा । ध्यान दें कि शून्य हर संख्या का एक गुणक है। अब, Bézout की पहचान की वजह से, वहाँ पात्रों में से कम से कम एक जोड़ी हो जाएगा oमें sजिसका दूरी ठीक है gcd(a, b)। सबसे बाईं ओर की जोड़ी को अपरकेस Oएस द्वारा प्रतिस्थापित किया जाना है ; यह अंतिम आउटपुट है।

उदाहरण

इनपुट पर विचार करें a = 4और b = 6। फिर हमारे पास है , gcd(a, b) = 2और lcm(a, b) = 12इसलिए लंबाई sहोगी 13। के गुणकों aऔरb इस प्रकार हाइलाइट किया जाता है:

0  1  2  3  4  5  6  7  8  9 10 11 12
o  .  .  .  o  .  o  .  o  .  .  .  o

oदूरी दो के साथ एस के दो जोड़े हैं , लेकिन हम केवल सबसे बाएं लोगों को Oएस के साथ बदल देंगे , इसलिए अंतिम आउटपुट है

o...O.O.o...o

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

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

 1  1 -> OO
 2  2 -> O.O
 1  3 -> OOoo
 4  1 -> OOooo
 2  6 -> O.O.o.o
 2  3 -> o.OOo.o
10  2 -> O.O.o.o.o.o
 4  5 -> o...OO..o.o.o..oo...o
 8  6 -> o.....O.O...o...o.o.....o
12 15 -> o...........O..O........o.....o.....o........o..o...........o
19 15 -> o..............o...o..........o.......o......o...........o..o..............OO.............o....o.........o........o.....o............o.o..............o.o............o.....o........o.........o....o.............oo..............o..o...........o......o.......o..........o...o..............o

Comments

जब एकतरफा इनपुट लेते हैं, तो क्या हम किसी भी पात्र को चुन सकते हैं? (विशेष रूप से, कैसे के बारे में ., oया O।) या यह होना चाहिए 1? या 0?

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

@ मार्टिनबटनर यह कोई भी पात्र हो सकता है, जब तक आप संगत हों और दोनों इनपुट के लिए एक ही प्रारूप का उपयोग करें।

— जर्बर्ब

मुझे आश्चर्य है कि आपने अपने परीक्षण मामलों में से 3 और 5 का उपयोग नहीं किया।

— नील

क्या मैं बिल्डिन का उपयोग कर सकता हूं?

— अकांक्षा

@ChristianIrwan हां, सभी बिल्ट-इन की अनुमति है।

— जर्गर्ब

Answer 1

जोल्फ, 52 बाइट्स

on*'.wm9jJΡR m*Yhm8jJDN?<*%Sj%SJ1'o'.}"'o%o"n"O%O"n

मैं इस कोड को दो भागों में विभाजित करूंगा।

on*'.wm9jJ
on         set n
  *'.       to a dot repeated
      m9jJ  the gcd of two numeric inputs

ΡR m*Yhm8jJDN?<*%Sj%SJ1'o'.}"'o%o"n"O%O"n
    *Y                                    multiply (repeat) Y (Y = [])
      hm8jJ                                by the lcm of two inputs + 1
  _m       DN              }              and map the array of that length
             ?<*%Sj%SJ1'o'.               "choose o if i%a*(i%b)<1; otherwise choose ."
 R                          "'            join by empty string
Ρ                            'o%o"n        replace once (capital Rho, 2 bytes): "o"+n+"o"
                                   "O%O"n   with "O"+n+"O"
                                          implicit printing

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

Comments

अब तक की सभी चीजों की तुलना में कम। : P

— R।

@RikerW हाँ! मैं उम्मीद कर रहा हूं कि जोल्फ आखिरकार, एक बार जीत जाएगा।

— कॉनर ओ'ब्रायन

Answer 2

जूलिया, 111 110 107 103 96 बाइट्स

f(a,b)=replace(join([i%a*(i%b)<1?"o":"."for i=0:lcm(a,b)]),"o$(d="."^(gcd(a,b)-1))o","O$(d)O",1)

यह एक फ़ंक्शन है जो दो पूर्णांकों को स्वीकार करता है और एक स्ट्रिंग लौटाता है।

Ungolfed:

function f(a::Int, b::Int)
    # Construct an array of dots and o's
    x = [i % a * (i % b) < 1 ? "o" : "." for i = 0:lcm(a, b)]

    # Join it into a string
    j = join(x)

    # Replace the first pair with distance gcd(a, b) - 1
    replace(j, "o$(d = "."^(gcd(a, b) - 1))o", "O$(d)O", 1) 
end

निमी को एक बाइट धन्यवाद दिया!

Answer 3

रेटिना , 112 109 99 94 91 बाइट्स

^
. 
+r`(?<!^\1+). (.+) 
$'$0
.(?=.* (.+) (.+))(?=\1* |\2* )
o
o(\.*)o((\1\.*o)*) .*
O$1O$2

बहुत प्रतिस्पर्धी नहीं, मुझे लगता है, लेकिन रेटिना में संख्या सिद्धांत हमेशा काफी मजेदार है। :)

इनपुट का उपयोग करते हुए एकरी संख्या के रूप में लेता है . रूप में ।

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

व्याख्या

^
. 

यह .इनपुट के सामने एक और एक जगह सम्मिलित करता है । यह अंततः आउटपुट बन जाएगा।

+r`(?<!^\1+). (.+) 
$'$0

यह aऔर bस्ट्रिंग के LCM को प्रस्तुत करता है। चूंकि हमारे पास पहले से ही है ., हम साथ समाप्त करेंगे lcm(a,b)+1। bजब तक aयह नया उपसर्ग विभाजित नहीं करता है तब तक इसे बार-बार प्रचलित करके पूरा किया जाता है। हम aएक समूह में कैप्चर करते हैं और फिर जांचते हैं कि क्या हम कम से कम एक बार मिलान करके स्ट्रिंग की शुरुआत तक पहुंच सकते हैं। bफिर स्ट्रिंग में डाला जाता है $'जो शायद ही कभी इस्तेमाल किया जाता है जो सबस्टेशन में मैच के बाद सब कुछ सम्मिलित करता है ।

.(?=.* (.+) (.+))(?=\1* |\2* )
o

यह एक ऐसे पदों के पात्रों से मेल खाता है, जो इसके द्वारा विभाजित हैं aया b। यह इस तथ्य का उपयोग करता है कि परिणाम सममित है: चूंकि lcm(a,b)दोनों से विभाजित किया गया है aऔर bउदाहरणों को घटाकर छोड़ दिया जा रहा है aया उन्हें जोड़कर bसही पैटर्न के समान पैदावार 0देता है। पहला लुकहैड बस पकड़ता है aऔर b। दूसरा लुकहैड जांचता है कि पहले स्थान पर प्रत्येक aया bवर्णों में से एक से अधिक है।

o(\.*)o((\1\.*o)*) .*
O$1O$2

जैसा कि विकिपीडिया पर कहा गया है, Bézout की पहचान के अलावा यह सच भी है

सबसे बड़ा सामान्य भाजक dसबसे छोटा धनात्मक पूर्णांक है जिसे लिखा जा सकता है ax + by।

इसका तात्पर्य यह है कि GCD oआउटपुट में दो s के बीच सबसे छोटे अंतराल के अनुरूप होगा । इसलिए हमें जीसीडी को खोजने की जहमत नहीं उठानी है। इसके बजाय हम सबसे पहले कम से कम अंतर की तलाश करते हैं। o(\.*)oएक उम्मीदवार अंतर से मेल खाता है और समूह 1 में इसकी चौड़ाई को पकड़ता है। फिर हम समूह 1 और oएस के बीच एक बैकरेस्ट के बीच वैकल्पिक रूप से वैकल्पिक स्थान पर पहुँचने का प्रयास करते हैं (वैकल्पिक अतिरिक्त s के साथ (बीच में गैप के साथ) साथ ही LCM का शेष भाग स्ट्रिंग, लेकिन अंतिम परिणाम निकालने और हटाने के लिए, अंतरिक्ष से शुरू होने वाली हर चीज को त्याग दें ।. s के साथ) के । अगर आगे दाईं ओर एक छोटा गैप है, तो यह मिलान करने में विफल हो जाएगा, क्योंकि हम उस अंतराल को पिछले संदर्भ के साथ नहीं पा सकते हैं। जैसे ही सभी आगे अंतराल कम से कम मौजूदा एक के रूप में व्यापक हैं, यह मेल खाता है। हम LCM- स्ट्रिंग के अंत को समूह 2 में कैप्चर करते हैं और स्ट्रिंग के शेष के साथ मिलान करते हैं .*। हम अपरकेस वापस लिखते हैंOab

Comments

मुझे रेटिना नंबर सिद्धांत के बारे में ज्यादा जानकारी नहीं है, लेकिन इनपुट चरित्र को ऐसी किसी चीज के लिए सेट नहीं किया जाएगा जिसमें बाइट्स से बचने की आवश्यकता न हो? Ie (\.*)=>(a*)

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ हां, लेकिन फिर मुझे इसे .बाद में बदलना होगा , जिसकी लागत चार बाइट (और पलायन से छुटकारा पाने के लिए केवल 3 बचती है )।

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

ओह। ठंडा! बहुत दिलचस्प जवाब।

— कॉनर ओ'ब्रायन

Answer 4

S, 50 चार्ट / 90 बाइट्स

⩥Мū⁽îí+1)ⓜ$%î⅋$%í?⍘.:⍘o)⨝ċɼ(`o⦃⍘.ĘМũ⁽îí-1)}o”,↪$ú⬮

Try it here (Firefox only).

आगे गोल्फ के लिए एक रास्ता होना चाहिए!

व्याख्या

यह एक बुनियादी दो-चरण एल्गोरिथ्म है। यह वास्तव में काफी सरल है।

चरण 1

⩥Мū⁽îí+1)ⓜ$%î⅋$%í?⍘.:⍘o)⨝

सबसे पहले, हम 0 से LCM + 1 तक की सीमा बनाते हैं। फिर हम इसके ऊपर मैप करते हैं, यह जाँचते हुए कि क्या इनपुट में से कोई भी वस्तु वर्तमान सीमा का कारक है। यदि हां, तो हम उस आइटम को एक के साथ बदल देते हैं o; अन्यथा, हम इसे एक के साथ बदल देते हैं .। इसमें शामिल होने से हमें ओ और डॉट्स की एक श्रृंखला मिलती है जिसे हम चरण दो में पास कर सकते हैं।

2 चरण

ċɼ(`o⦃⍘.ĘМũ⁽îí-1)}o”,↪$ú⬮

यह केवल एक बड़ा प्रतिस्थापित कार्य है। एक रेगेक्स के रूप में बनाया जाता है o[dots]o, जहां डॉट्स की मात्रा जीसीडी -1 द्वारा निर्धारित की जाती है। चूंकि यह रेगेक्स वैश्विक नहीं है, यह केवल पहली घटना से मेल खाएगा। के बाद, मैच को O[dots]Oएक टॉपरकेस फ़ंक्शन का उपयोग करके बदल दिया जाता है।

Answer 5

MATL , 72 बाइट्स

संस्करण 6.0.0 का उपयोग करता है , जो इस चुनौती से पहले है। कोड मतलाब में और ओक्टेव में चलता है।

2$tZm1+:1-bbvtbw\A~otbZ}ZdXK1+ltb(3X53$X+1K2$lh*t2=f1)tK+hwg1+Ib('.oO'w)

उदाहरण

>> matl
 > 2$tZm1+:1-bbvtbw\A~otbZ}ZdXK1+ltb(3X53$X+1K2$lh*t2=f1)tK+hwg1+Ib('.oO'w)
 > 
> 1
> 1
OO

>> matl
 > 2$tZm1+:1-bbvtbw\A~otbZ}ZdXK1+ltb(3X53$X+1K2$lh*t2=f1)tK+hwg1+Ib('.oO'w)
 > 
> 2
> 3
o.OOo.o

>> matl
 > 2$tZm1+:1-bbvtbw\A~otbZ}ZdXK1+ltb(3X53$X+1K2$lh*t2=f1)tK+hwg1+Ib('.oO'w)
 > 
> 12
> 15
o...........O..O........o.....o.....o........o..o...........o

व्याख्या

मुझे नहीं पता कि यह कैसे काम करता है। मैंने बस पात्रों को यादृच्छिक रूप से टाइप किया। मुझे लगता है कि इसमें कुछ संलिप्तता है।

संपादित करें: इसे ऑनलाइन आज़माएं! लिंक में कोड को भाषा में परिवर्तन के अनुरूप करने के लिए थोड़ा संशोधित किया गया है (2 जून 2016 तक)।

Comments

आप 72 बाइट प्रोग्राम को रैंडमली टाइप नहीं कर सकते। बाद में संभावना की गणना करेगा (सोने के बाद और थोड़ी देर के लिए अनुक्रिया)

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

Answer 6

जाप , 83 बाइट्स

'.pD=U*V/(C=(G=@Y?G$($YX%Y :X} $($UV)+1 £Y%U©Y%V?".:o"} $.replace($E=`o{'.pC-1}o`Eu

अभी पूरी तरह से गोल्फ नहीं है ... और गोल्फ नहीं बनना चाहता: /

Comments

के rस्थान पर उपयोग नहीं कर सकते $.replace($?

— ETHproductions 2

@ अगर मुझे पता नहीं चला कि बिना जी फ्लैग के कैसे बदला जा सकता है, तो नहीं, मैं नहीं कर सकता।

— निकेल

Answer 7

जावास्क्रिप्ट, 170 164 161 153 145 141 136 बाइट्स

(a,b)=>[...Array(a*b/(c=(g=(a,b)=>b?g(b,a%b):a)(a,b))+1)].map((x,i)=>i%a&&i%b?'.':'o').join``.replace(`o${e='.'.repeat(c-1)}o`,`O${e}O`)

यह काफी lonnnggggg है ...।

डेमो , स्पष्ट रूप से परिभाषित चर क्योंकि दुभाषिया सख्त मोड का उपयोग करता है।

Comments

के i%a<1||i%b<1?'o':'.'साथ बदलने की कोशिश करेंi%a&&i%b?'.':'o'

— मामा फन रोल

अरे हाँ, मुझे लगता है कि आप उर्फ ​​में शामिल हो सकते हैं।

— मामा फन रोल

@, N alsouɐɯɹɐ ɯ oɯ धन्यवाद, सरल दोहराने के साथ सरणियों की जगह भी।

— निकेल

ओह, तो उस स्थिति में, आपको शायद तब तक उर्फ ​​में शामिल नहीं होना चाहिए जब तक कि आपके पास इसकी 3 घटनाएं न हों।

— मामा फन रोल

[...Array((d=a*b/(c=(g=(a,b)=>b?g(b,a%b):a)(a,b)))+1).keys()].map(i=>i%a&&i%b?'.':'o')आपको दो बाइट्स बचाता है। (मैंने 'और' और 'ओ' बनाने के लिए स्ट्रिंग इंडेक्सिंग का उपयोग करने की भी कोशिश की, लेकिन वास्तव में दो बाइट का खर्च होता है।)

— नील

Answer 8

पायथन 2, 217 200 191 बाइट्स

यह थोड़ा कुंद है, लेकिन यह काम करता है। किसी भी गोल्फिंग टिप्स की सराहना की जाती है, खासकर यदि आप जानते हैं कि s[i] = s[v] = "o"मुझे उस समस्या को कैसे ठीक करना है, जहां वह "ओ" समझेगी!

g=lambda a,b:b and g(b,a%b)or a
def f(a,b):
 h=g(a,b);x=1+a*b/h;s=["."]*x;v=k=0
 for i in range(x):
    if(i%a)*(i%b)<1:
     if k:s[i]="o"
     else:k=i==h+v;s[i]=s[v]="oO"[k]
     v=i
 return''.join(s)

Ungolfed:

def gcd(a,b):                           # recursive gcd function
    if b:
        return g(b,a%b)
    else:
        return a
def f(a,b):
    h = gcd(a,b)
    x = 1 + a*b/h                       # 1 + lcm(a,b)
    s = ["."] * x
    v = 0
    k = 0
    for i in range(x):
        if i%a == 0 and i % b == 0:
            if k == 0:
                k = (i == h+v)          # correct distance apart?
                if k:                   # if "O" just found
                    s[i] = s[v] = "O"
                else:
                    s[i] = s[v] = "o"
            else:
                s[i] = "o"              # if "O" already found, always "o"
            v = i                       # If we found an "o" or an "O", i is the new v
    return ''.join(s)