धनात्मक पूर्णांक के समुच्चय का कम से कम बहु गुणक Aसबसे छोटा उत्तर पूर्णांक होता है Bजैसे कि, प्रत्येक kमें A, एक धनात्मक पूर्णांक मौजूद होता है nजैसे कि k*n = B।

इनपुट के रूप में कम से कम दो सकारात्मक पूर्णांकों को देखते हुए, उनके कम से कम कई सामान्य आउटपुट।

नियम

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

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

[7, 2] -> 14
[8, 1] -> 8
[6, 4, 8] -> 24
[8, 2, 1, 10] -> 40
[9, 6, 2, 1, 5] -> 90
[5, 5, 7, 1, 1] -> 35
[4, 13, 8, 8, 11, 1] -> 1144
[7, 2, 2, 11, 11, 8, 5] -> 3080
[1, 6, 10, 3, 4, 10, 7] -> 420
[5, 2, 9, 10, 3, 4, 4, 4, 7] -> 1260
[9, 7, 10, 9, 7, 8, 5, 10, 1] -> 2520

— मेगो
स्रोत

6

क्योंकि यह एक बहुत ही लगातार गलत धारणा है: सूत्र LCM (a, b) = ab / GCD (a, b) दो से अधिक संख्या (या, उस मामले के लिए, एक नंबर पर!) तक विस्तारित नहीं होता है ।

— ग्रेग मार्टिन

4

दरअसल, 12 1 बाइट

गोल्फिंग सुझावों का अभी भी स्वागत है, हालांकि मुझे यकीन नहीं है कि कच्चे एलसीएम में सुधार कैसे किया जा सकता है। इसे ऑनलाइन आज़माएं!

▲

बिल्ट-इन के बिना एक 12-बाइट संस्करण। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

╗2`╜@♀%ΣY`╓N

Ungolfing

          Implicit input array.
╗         Save array in register 0.
2`...`╓   Starting with f(0), find the first (two) x where f(x) returns a truthy value.
          These two values will be 0 and our LCM.
  ╜         Push array from register 0.
  @         Swap the top two values. Stack: x, array
  ♀%        Map % over x and array, returning (x % item) for each item in array.
  ΣY        If the sum of all the modulos equals 0, x is either 0 or our LCM.

N         Push the last (second) value of our results. This is our LCM.
          Implicit return.

— Sherlock9
स्रोत

आपको एहसास है कि आपको बिलिन का उपयोग करने की अनुमति है, है ना?

— मेगो

1

@Mego मैं इसे जोड़ूंगा, लेकिन मेरी समझ यह थी कि बिल्डिंस हतोत्साहित थे, इसलिए मैंने पहले इसका इस्तेमाल नहीं किया।

— शर्लक

1

बिल बनाने की अनुमति है। वे बिल्कुल भी हतोत्साहित नहीं हैं - मैं बस गैर-बिलिन समाधान को प्रोत्साहित करने के लिए भी शामिल होना चाहता था क्योंकि वे अक्सर बिलिन की तुलना में बहुत अधिक दिलचस्प होते हैं।

— मेगो

1

मैंने पढ़ा है कि वास्तव में, 1 बाइट के रूप में ।

— प्रोग्रामर

2

@ प्रोग्रामर 5000 मुझे लगता है कि हो सकता है कि भाषा को वास्तव में क्यों कहा जाता है ...

— सुकराती फीनिक्स

17

जावास्क्रिप्ट (ईएस 6), 36 बाइट्स

f=(a,i=1)=>a.some(v=>i%v)?f(a,i+1):i

1यह पहले नंबर से शुरू होता है जिसे सभी द्वारा विभाजित किया जा सकता है।

कोड स्निपेट दिखाएं

f=(a,i=1)=>a.some(v=>i%v)?f(a,i+1):i
;

console.log(f([7, 2]));
console.log(f([8, 1]));
console.log(f([6, 4, 8]));
console.log(f([8, 2, 1, 10]));
console.log(f([9, 6, 2, 1, 5]));
console.log(f([5, 5, 7, 1, 1]));
console.log(f([4, 13, 8, 8, 11, 1]));
console.log(f([7, 2, 2, 11, 11, 8, 5]));
console.log(f([1, 6, 10, 3, 4, 10, 7]));
console.log(f([5, 2, 9, 10, 3, 4, 4, 4, 7]));
console.log(f([9, 7, 10, 9, 7, 8, 5, 10, 1]));

स्निपेट का विस्तार करें

— Hedi
स्रोत

बेशक ... मैंने इस तकनीक के साथ एक लूप करने के बारे में सोचा, लेकिन पुनरावृत्ति कम है।

— ETHproductions

1

यह प्रतिभा है ... अगर मुझे याद है, someतो सही है अगर सरणी में कम से कम एक तत्व स्थिति को संतुष्ट करता है, है ना?

— वैलीवेस्ट

12

05AB1E / 2sable , 2 बाइट्स

.¿

इसे ऑनलाइन आज़माएं! 05AB1E
या 2sable में

— acrolith
स्रोत

11

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

æl/

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

वैकल्पिक संस्करण, 6 बाइट्स

ÆE»/ÆẸ

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

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

ÆE»/ÆẸ  Main link. Argument: A (array)

ÆE      Yield all prime exponents of each integer in A.
  »/    Reduce columns (exponents that correspond to the same prime) by maximum.
    ÆẸ  Turn the resulting array of prime exponents into the corresponding integer.

— डेनिस
स्रोत

8

पायथन, 69 65 52 50 बाइट्स

A=lambda l,i=1:any(i%a for a in l)and A(l,i+1)or i

2 बाइट्स ने डेनिस को धन्यवाद दिया!

बहुत सरल पुनरावर्ती समाधान, आपको काम के कुछ परीक्षण मामलों के लिए पुनरावृत्ति की सीमा को थोड़ा अधिक बनाने की आवश्यकता होगी।

— Loovjo
स्रोत

1

anyएक जनरेटर लेता है; आपको कोष्ठक की आवश्यकता नहीं है।

— डेनिस

3

A=lambda l,i=1:all(i%a<1for a in l)or-~A(l,i+1)कुछ और बाइट्स बचाता है।

— डेनिस

8

MATL , 7 बाइट्स

&YFX>^p

कोई बनाया नहीं।

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

व्याख्या

[8, 2, 1, 10]एक उदाहरण के रूप में इनपुट लेते हैं ।

&YF    % Take array implicitly. Push vector of prime factors and matrix of exponents 
       % of factorization, where each row represents one of the input numbers
       %   STACK: [2 3 5], [3 0 0; 1 0 0; 0 0 0; 1 0 1]
X>     % Maximum of each column
       %   STACK: [2 3 5], [3 0 1]
^      % Element-wise power
       %   STACK: [8 1 5]
p      % Product of array
       %   STACK: 40
       % Implicitly display

EDIT (9 जून, 2017): YFदो आउटपुट के साथ रिलीज़ में संशोधित किया गया है 20.1.0 : गैर-कारक प्राइम और उनके (शून्य) एक्सपोर्टर को छोड़ दिया जाता है। यह उपरोक्त कोड को प्रभावित नहीं करता है, जो किसी भी बदलाव की आवश्यकता के बिना काम करता है।

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

6

जूलिया (3 बाइट्स) [गैर-निर्मित में काम करना]

lcm     # Using LCM built-in (3 Bytes)

जैसा कि डेनिस ने बताया, मैं भूल जाता हूं कि जूलिया स्वचालित रूप से इनपुट्स को वेक्टर करती है।

उदाहरण:

println(lcm(1,2,3,4,5,6,7,8,9)) #Prints 2520

— जादू ऑक्टोपस Urn
स्रोत

6

PowerShell v2 +, 73 60 बाइट्स

param($a)for($i=1;($a|?{!($i%$_)}).count-ne$a.count){$i++}$i

इनपुट लेता है $a, से ऊपर की ओर लूप $i=1के साथ $i++एक सशर्त पर आधारित है,। हालत को ओटी क्वालीफाई किया ($a|?{!($i%$_)}).countजा रहा है । मतलब, पाश समाप्त होता है जब के तत्वों है कि कर रहे हैं की divisors है के तत्वों के बराबर । फिर, एक एकान्त पाइपलाइन पर छोड़ दिया जाता है, और आउटपुट निहित है।-ne$a.count$a$i$a$i

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

PS C:\Tools\Scripts\golfing> @(7,2),@(8,1),@(6,4,8),@(8,2,1,10),@(9,6,2,1,5),@(5,5,7,1,1),@(4,13,8,8,11,1)|%{($_-join',')+" -> "+(.\least-common-multiple.ps1 $_)}
7,2 -> 14
8,1 -> 8
6,4,8 -> 24
8,2,1,10 -> 40
9,6,2,1,5 -> 90
5,5,7,1,1 -> 35
4,13,8,8,11,1 -> 1144

PS C:\Tools\Scripts\golfing> @(7,2,2,11,11,8,5),@(1,6,10,3,4,10,7),@(5,2,9,10,3,4,4,4,7),@(9,7,10,9,7,8,5,10,1)|%{($_-join',')+" -> "+(.\least-common-multiple.ps1 $_)}
7,2,2,11,11,8,5 -> 3080
1,6,10,3,4,10,7 -> 420
5,2,9,10,3,4,4,4,7 -> 1260
9,7,10,9,7,8,5,10,1 -> 2520

— AdmBorkBork
स्रोत

4

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

LCM

उपयोग:

In[1]:= LCM[9, 7, 10, 9, 7, 8, 5, 10, 1]                                        

Out[1]= 2520

— alephalpha
स्रोत

6

जिस दिन मैथेमेटिका ने जेली का मिलान किया वह एक ऐसा दिन है जिसके बारे में मैंने कभी नहीं सोचा था कि मैं देखूंगा।

— स्टीवन एच।

3

चेडर, 33 बाइट्स

(n,i=1)f->n.any(i&(%))?f(n,i+1):i

कुछ भी नया नहीं।

Ungolfed

(n, i = 1) f ->
  n.any(j -> i % j) ?
    f(n, i + 1) :
    i

मूल रूप से यह एक पर शुरू होता है और यह तब तक बढ़ता रहता है जब तक यह एक एलसीएम नहीं पाता

— Downgoat
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 63 59 बाइट्स

f=([x,...a])=>a[0]?x*f(a)/(g=(m,n)=>n?g(n,m%n):m)(x,f(a)):x

पुन: पिछले दो तत्वों के LCM को ढूँढता है।

— ETHproductions
स्रोत

यह मेरा समाधान क्या होगा:a=>a.reduce((l,n)=>l*n/(g=(m,n)=>n?g(n,m%n):m)(l,n))

— नील

@Neil आप चाहें तो पोस्ट कर सकते हैं। मुझे शक है कि मेरी तकनीक उस कमी को पा सकती है ...

— ETHproductions

3

दिल्लोग एपीएल, 2 बाइट्स

∧/

एलसीएम द्वारा कम कर देता है। इसे TryAPL पर टेस्ट करें ।

— डेनिस
स्रोत

4

100k पर बधाई!

— कॉपर

3

जावास्क्रिप्ट (ईएस 6), 52 बाइट्स

a=>a.reduce((l,n)=>l*n/(g=(m,n)=>n?g(n,m%n):m)(l,n))

मैंने reduceइस उत्तर को जितना हो सकता था, लेकिन मैं स्पष्ट रूप से @ हेडी के उत्तर की सादगी के पास कहीं भी नहीं जा रहा हूं।

— नील
स्रोत

3

जावा 8, 75 59 121 89 बाइट्स

यूक्लिडियन एल्गोरिथ्म और तथ्य का उपयोग करता है कि LCM (ए, बी) = ए * बी / जीसीडी (ए, बी)

16 बाइट्स बंद। @Carusocomputing को धन्यवाद
मल्टी-इनपुट + 62 बाइट्स जोड़े गए
32 बाइट्स बंद। @Olivier Grégoire को धन्यवाद

कोड:

public static int lcm(int l, int c){
  for(int i=1;i<=l&&i<=c;++i) 
    if (i%l==0&&i%c==0)
      return l*c/i;
}
public static int lcm(int...x){
  int y=x[0];
  for(int j:x){
    y=lcm(j,y);
  }
  return y;
}

लाइन-ब्रेक निकालें:

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

l->{int l=1;for(int n:a)l=l*n/g(l,n);return l;}

— रोमन ग्रैफ़
स्रोत

तकनीकी तौर पर एक टुकड़ा है, लेकिन आप जोड़ने अगर n->{...}मेरा मानना है कि यह वैध जावा 8. हो जाता है

— जादू ऑक्टोपस कलश

धन्यवाद। मैं जावा में लैम्ब्डा देखने के लिए अभ्यस्त होने की कोशिश कर रहा हूं। लैम्ब्डा के साथ आप संभवतः कुछ लूप के लिए गोल्फ कर सकते हैं। लेकिन मैं नहीं जानता कि कैसे।

— रोमन ग्रैफ़

हाँ, वह सब कुछ जावा में एक बाद का सामान है; आप शायद इसे पायथन में सीखने से बेहतर होंगे :)।

— मैजिक ऑक्टोपस उर्फ़

जब तक मैं कुछ याद कर रहा हूं, यह

— Pinkfloydx33

यदि आप GCD की गणना करते हैं, तो आप बहुत अधिक गोल्फ कर सकते हैं int g(int a,int b){return b<1?a:g(b,a%b);}:। LCM तब बन सकता है int l(int[]a){int l=1;for(int n:a)l=l*n/g(l,n);return l;}, कुल 99 बाइट्स के लिए।

— ओलिवियर ग्रेजायर

2

MATL , 3 बाइट्स

&Zm

यह सरणी इनपुट के साथ अंतर्निहित फ़ंक्शन का उपयोग करता है।

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

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

2

ब्रेकीलॉग , 17 बाइट्स

,.#>=g:?z:%a#=h0,

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

व्याख्या

,.#>=               Output is a strictly positive integer
     g:?z           Zip the Output with the Input
         :%a        Compute Output mod I for each I in the Input
            #=h0,   All results must be equal to 0

— Fatalize
स्रोत

2

पर्ल 6 , 10 बाइट्स

{[lcm] @_}

मूल रूप से समान:

sub ( *@_ ) { @_.reduce: &infix:< lcm > }

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

जे, 11 बाइट्स

>./&.(_&q:)

एलसीएम बिलिन का उपयोग करके 3 बाइट्स के लिए एक समाधान है ।

*./

व्याख्या

>./&.(_&q:)  Input: array of integers A
      _&q:   Get the prime exponents of each integer in A
>./&         Reduce by maximum on the lists
   &. _&q:   Convert the list of exponents back to an integer

*./  Input: array of integers A
  /  Reduce using
*.     LCM

— मील की दूरी पर
स्रोत

2

सीजाम, 18 17 16 बाइट्स

मार्टिन बायर की बदौलत 1 बाइट बच गई।

एलसीएम मिलने तक वृद्धि।

q~0{)_2$f%:+}g\;

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

— Neorej
स्रोत

1

मैं सीजेएम से पूरी तरह परिचित नहीं हूं, लेकिन पुन: प्रयोज्यता नियम कार्यों के लिए है, न कि पूर्ण कार्यक्रमों के लिए। यदि आपका 17-बाइट समाधान एक पूर्ण प्रोग्राम है जो लगातार रन भर में काम करता है, तो यह ठीक है।

— मेघ

2

रैकेट 13 बाइट्स

Lcm रैकेट में एक अंतर्निहित कार्य है:

(apply lcm l)

परिक्षण:

(define (f l)
   (apply lcm l))

(f (list 7 2)) 
(f (list 8 1)) 
(f (list 6 4 8)) 
(f (list 8 2 1 10)) 
(f (list 9 6 2 1 5))
(f (list 5 5 7 1 1)) 
(f (list 4 13 8 8 11 1))
(f (list 7 2 2 11 11 8 5))
(f (list 1 6 10 3 4 10 7))
(f (list 5 2 9 10 3 4 4 4 7)) 
(f (list 9 7 10 9 7 8 5 10 1))

आउटपुट:

— rnso
स्रोत

आह। आप उस वाक्य रचना का उपयोग कैसे कर सकते हैं। मैंने हमेशा रैकेट सीखने की कोशिश की तो मैंने हार मान ली।

— रोमन ग्रफ

1

कोष्ठक में पहला शब्द एक प्रक्रिया नाम है, बाकी इसके तर्क हैं। यदि एक तर्क एक प्रक्रिया है, तो इसे अपने स्वयं के ब्रैकेट में होना चाहिए। मान (गैर-प्रक्रियाएँ) कोष्ठक के बिना लिखे गए हैं। मुझे लगता है कि यह कार्यात्मक प्रोग्रामिंग पर तनाव के अतिरिक्त लाभ के साथ एक उत्कृष्ट सामान्य प्रयोजन वाली भाषा है। लिस्प से व्युत्पन्न होने के कारण, किसी को प्रोग्रामिंग के उस क्षेत्र को कवर करने का भी एहसास होता है।

— rnso

मुझे लिस्प की तुलना में रैकेट और स्कीम में कोडिंग कीवर्ड और भाषा आसान लगती है।

— rnso

हां, लेकिन क्या मैंने कहा कि मैं लिस्प को समझता हूं? मुझे जेली या जावा जैसी भाषाएं ज्यादा पसंद हैं।

— रोमन ग्रफ

1

जावा और रैकेट के बीच मुख्य वाक्यविन्यास अंतर f (a, b) बनाम (फैब), x + y + z बनाम (+ xyz), x == y बनाम (eq? Xy) और x = 2 बनाम (परिभाषित 3 x 2) है? , या यदि पहले से परिभाषित है, (सेट! x 2)। इसके अलावा सार्वजनिक स्थैतिक शून्य या इंट चार स्ट्रिंग आदि जैसे प्रकारों को घोषित करने की आवश्यकता नहीं है। आशा है कि आपको रैकेट में फिर से दिलचस्पी है।

— 3

2

आर, 36 बाइट्स (बिलिन नहीं)

v=scan();i=1;while(any(i%%v))i=i+1;i

इनपुट लेता है। फिर मॉड लेकर प्रत्येक पॉजिटिव पूर्णांक का परीक्षण करता है।

— user5957401
स्रोत

मेरा मानना है कि आपको cati

— Giuseppe

@Giuseppe जब मैं इसे चलाता हूं, तो मूल्य ठीक प्रिंट होता है।

— user5957401

यहाँ चर्चा देखें , लेकिन मुझे लगता ec=Tहै कि इसके लिए +5 के बजाय +4 के लिए ठीक है cat()।

— ग्यूसेप

1

परवाह किए बिना, यह कुछ नीचे golfed किया जा सकता है v=scan();while(any((F=F+1)%%v)){};Fके साथ cat()या ec=Tक्रमशः यह 40 या 39 बाइट्स बनाने,। और +1, बहुत अच्छा तरीका।

— ग्यूसेप

1

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

.U/*bZibZ

एक प्रोग्राम जो STDIN पर एक सूची का इनपुट लेता है और परिणाम प्रिंट करता है।

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

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

.U/*bZibZ  Program. Input: Q
.U         Reduce Q by (implicit input fill):
   *bZ      Product of current and next value
  /   ibZ   divided by GCD of current and next value
           Implicitly print

— TheBikingViking
स्रोत

1

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

foldr1 lcm

प्रयोग उदाहरण: foldl1 lcm [5,2,9,10,3,4,4,4,7]-> 1260।

— nimi
स्रोत

1

सी #, 50 + 18 = 68 बाइट्स

विधि डिफिनिटेशन के लिए 50 बाइट्स, LINQ आयात के लिए +18 बाइट्स।

using System.Linq;int L(int[]n,int i=1)=>n.All(x=>1>i%x)?i:L(n,i+1);

बहुत सुंदर अन्य उत्तरों के रूप में बहुत अधिक है। यह LCM पाता है जब तक पुनरावर्ती मायने रखता है। मैं थोड़ा आश्चर्यचकित था कि इसे StackOverflowException नहीं मिली, इसलिए मेरे पास एक गैर-पुनरावर्ती संस्करण भी है जो वास्तव में सिर्फ 1 बाइट लंबा है।

using System.Linq;n=>{for(int i=1;;i++)if(n.All(x=>1>i%x))return i;};

Ungolfed:

using System.Linq;            // Import LINQ
int L(int[] n, int i = 1) =>  // Function declaration
    n.All(x => 1 > i % x)     // Check if each x in n divides i
        ? i                   // And if so return i
        : L(n, i + 1)         // Otherwise increment i and recurse
;

— दूध
स्रोत

1

पिप , 10 बाइट्स

W$+o%g++oo

"हर संख्या का प्रयास करें जब तक एक काम करता है" रणनीति का उपयोग करता है। इसे ऑनलाइन आज़माएं!

            o is preinitialized to 1, g is list of cmdline args
   o%g      Mod o by each arg
 $+         Sum (truthy if any nonzero, falsy if all zero)
W           Loop while that expression is truthy:
      ++o     Increment o
         o  Autoprint o

— DLosc
स्रोत

1

PHP, 42 74 बाइट्स

for(;($p=++$f*$argv[1])%$argv[2];);echo$p;

सीधे आगे: 1 ऊपर से
लूप $f; यदि शेष के बिना $f*$aविभाजित होता है $b, तो एलसीएम पाया जाता है।

मैं पूरी तरह से at least... के मापदंडों की किसी भी संख्या के लिए कोड यहाँ था:

for(;$i<$argc;)for($p=$argv[$i=1]*++$f;++$i<$argc&$p%$argv[$i]<1;);echo$p;

$f1 से ऊपर की ओर लूप जबकि आंतरिक लूप $ argc तक नहीं चला है।
लूप $iसे 2करने के लिए $argc-1, जबकि $f*$argv[1]विभाजित के माध्यम से $argv[$i]एक शेष के बिना।
दोनों लूप टूटे: प्रिंट $f*$argument 1।

— टाइटस
स्रोत

1

प्रोलोग (एसडब्ल्यूआई) , 46 बाइट्स

l([],1).
l([X|Y],P):-l(Y,Q),P is X*Q/gcd(X,Q).

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

एक अन्य समाधान, 59 बाइट्स:

l(A,X):-between(1,inf,X),forall(member(Y,A),X mod Y=:=0),!.

— eush77
स्रोत

1

पायथन 3, 83 बाइट्स

import math,functools as i
t=lambda t:i.reduce(lambda a,b:int(a*b/math.gcd(a,b)),t)

— Hydreigos
स्रोत

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

— लकोनी

आप एक ऑनलाइन परीक्षण साइट की तरह एक लिंक शामिल करना चाह सकते हैं इसे ऑनलाइन आज़माएं! इसलिए अपने जवाब को सत्यापित करना दूसरों के लिए आसान है।

— लकोनी

1

Brachylog v2, 8 बाइट्स

{×↙Xℕ₁}ᵛ

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

यह मज़ाकिया है कि चुनौती में दी गई परिभाषा पर यह नक्शे सीधे कैसे चलता है।

{     }ᵛ    Each element of
            the input
 ×          multiplied by
  ↙X        some arbitrary and inconsistent integer
    ℕ₁      is a natural number,
       ᵛ    which is the same for each element,
            and is the output.

एक संदिग्ध धीमी लेकिन काफी कम समाधान:

Brachylog v2, 5 बाइट्स

f⊇p~d

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

आउटपुट चर के माध्यम से इनपुट लेता है और इनपुट चर के माध्यम से आउटपुट देता है। पहले चार परीक्षण मामलों के माध्यम से ही सही, लेकिन मैं अभी भी पांचवें पर इंतजार कर रहा हूं ... आमतौर पर, मैं अभी भी इसे अपना प्राथमिक समाधान बनाऊंगा और भरोसा करूंगा कि यह सही ढंग से काम करता है, लेकिन मुझे नहीं पता कि यह क्यों नहीं है पुष्टि की है कि 90 का LCM है 9, 6, 2, 1, 5जब मैंने इसे 90 मिनट पहले दिया था।

(संपादित करें: इसने 16 घंटे से अधिक समय तक जवाब की पुष्टि की, और 5, 5, 7, 1, 1लगभग दो दिनों के बाद एलसीएम के साथ इसे उत्पन्न किया ।)

         The output variable
   ~d    with duplicates removed
  p      is a permutation of
 ⊇       a sublist of
f        the factors of
         the input variable.

और एक और पूरी तरह से अलग भविष्यवाणी करता है कि गलती से अधिक-या-कम फ़ेटलेट के ब्रेकीलॉग v1 समाधान का अनुवाद करता है:

Brachylog v2, 10 बाइट्स

;.gᵗ↔z%ᵛ0<

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

यह इस समाधान के लिए तैयार किया गया था कि मैं इस चुनौती के लिए तैयार हो जाऊं, इससे पहले कि मुझे पता चले कि आउटपुट पूर्णांक होने तक सीमित नहीं है।

 .            The output
; gᵗ↔z        paired with each element of
              the input,
      %ᵛ      when the first element of each pair is taken mod the second, is always
        0     zero.
              Furthermore, the output
         <    is strictly greater than
        0     zero.

— असंबंधित स्ट्रिंग
स्रोत

0

पायथ - 7 6 बाइट्स

कोई बनाया नहीं।

*F{sPM

इसे यहाँ ऑनलाइन आज़माएँ ।

— Maltysen
स्रोत

4

[4]बार-बार आने वाले प्रमुख कारक के साथ, या कुछ और पर विफल होता है।

— isaacg

आम एकाधिक

नियम

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

दरअसल, 12 1 बाइट

जावास्क्रिप्ट (ईएस 6), 36 बाइट्स

05AB1E / 2sable , 2 बाइट्स

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

वैकल्पिक संस्करण, 6 बाइट्स

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

पायथन, 69 65 52 50 बाइट्स

MATL , 7 बाइट्स

व्याख्या

जूलिया (3 बाइट्स) [गैर-निर्मित में काम करना]

उदाहरण:

PowerShell v2 +, 73 60 बाइट्स

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

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

चेडर, 33 बाइट्स

Ungolfed

जावास्क्रिप्ट (ईएस 6), 63 59 बाइट्स

दिल्लोग एपीएल, 2 बाइट्स

जावास्क्रिप्ट (ईएस 6), 52 बाइट्स

जावा 8, 75 59 121 89 बाइट्स

MATL , 3 बाइट्स

ब्रेकीलॉग , 17 बाइट्स

व्याख्या

पर्ल 6 , 10 बाइट्स

जे, 11 बाइट्स

व्याख्या

सीजाम, 18 17 16 बाइट्स

रैकेट 13 बाइट्स

आर, 36 बाइट्स (बिलिन नहीं)

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

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

सी #, 50 + 18 = 68 बाइट्स

पिप , 10 बाइट्स

PHP, 42 74 बाइट्स

प्रोलोग (एसडब्ल्यूआई) , 46 बाइट्स

पायथन 3, 83 बाइट्स

Brachylog v2, 8 बाइट्स

Brachylog v2, 5 बाइट्स

Brachylog v2, 10 बाइट्स

पायथ - 7 6 बाइट्स