लिस्ट कॉमन मल्टीपल का चित्रण करें

Question

दो सकारात्मक पूर्णांकों को देखते हुए, A और B, लंबाई के LCM (A, B) के साथ दो रेखाओं को आउटपुट करके उनकी कम से कम सामान्य बहु को दर्शाते हैं, पहली पंक्ति में प्रत्येक एथ डैश को बदलने के बाद और दूसरी पंक्ति में प्रत्येक Bth डैश को वर्टिकल बार के साथ ( )।-|

इस तरह, प्रत्येक पंक्ति का अंत केवल दो |लाइन का स्थान होगा।

उदाहरण के लिए, यदि A = 6 और B = 4, LCM (6, 4) = 12, तो:

two lines of 12 dashes:
------------
------------

replace every 6th dash in the first line with a vertical bar:
-----|-----|
------------

replace every 4th dash in the second line with a vertical bar:
-----|-----|
---|---|---|

इस प्रकार अंतिम उत्पादन होगा

-----|-----|
---|---|---|

इनपुट संख्याओं का क्रम लाइनों के क्रम के अनुरूप होना चाहिए।

बाइट्स में सबसे छोटा कोड जीतता है।

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

A B
line for A
line for B

1 1
|
|

1 2
||
-|

2 1
-|
||

2 2
-|
-|

6 4
-----|-----|
---|---|---|

4 6
---|---|---|
-----|-----|

2 3
-|-|-|
--|--|

3 2
--|--|
-|-|-|

3 6
--|--|
-----|

2 5
-|-|-|-|-|
----|----|

4 3
---|---|---|
--|--|--|--|

10 10
---------|
---------|

10 5
---------|
----|----|

10 6
---------|---------|---------|
-----|-----|-----|-----|-----|

24 8
-----------------------|
-------|-------|-------|

7 8
------|------|------|------|------|------|------|------|
-------|-------|-------|-------|-------|-------|-------|

6 8
-----|-----|-----|-----|
-------|-------|-------|

13 11
------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|
----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|

Comments

@LeakyNun कोडगॉल्फ.स्टैकएक्सचेंज. com/q/94999 से एक उत्तर देना उस से आसान लगता है। किसी भी तरह से, लोगों को ऐसा करने में मज़ा आएगा जो एक सभ्य कारण है।

— काल्विन के शौक

क्या मैं दो तारों के साथ एक सरणी का उत्पादन कर सकता हूं, प्रत्येक पंक्ति के लिए एक?

— ब्लैककैप

@BlackCap नंबर स्ट्रैडआउट या एक फ़ाइल के लिए स्ट्रिंग्स को प्रिंट करें या पूरे मल्टीलाइन स्ट्रिंग को लौटाएं।

— केल्विन के शौक

इनपुट की मनमानी संख्या से निपटने के लिए बोनस?

— आदम

@ हेलकाहोम्बा ओके थैंक्स; 1 और बाइट को बचाया। :) (जैसे कि कोडगॉल्फ चुनौतियों पर इस तरह के सवाल पूछने का कोई अन्य कारण है? पी)

— केविन क्रूज़सेन

Answer 1

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

1 बाइट का धन्यवाद हैल्वर्ड विल्म के लिए और 1 बाइट का धन्यवाद जोनाथन एलन को दिया गया।

import math
def f(*l):
 for k in 0,1:print(l[~k]//math.gcd(*l)*(~-l[k]*"-"+"|"))

इसे ऑनलाइन टेस्ट करें!

lambda*l:"\n".join(l[0]*l[1]//math.gcd(*l)//k*(~-k*"-"+"|")for k in l)
import math

इसे ऑनलाइन टेस्ट करें! (82 बाइट्स - प्रारंभिक उत्तर)

यह सबसे अच्छा मैं पायथन 2 (81 बाइट्स) में कर सकता है। ऐसा लगता है कि मैं उस उत्तर पर टिप्पणी नहीं कर सकता, मैं इसके बजाय यहां यह पोस्ट करूंगा:

from fractions import*
l=a,b=input()
for k in l:print a*b/gcd(*l)/k*(~-k*"-"+"|")

इसे ऑनलाइन टेस्ट करें!

पहला प्रयास यहाँ, शायद उप-इष्टतम!

Comments

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

— लकोनी

@Laikoni धन्यवाद! यह एक मजेदार समुदाय की तरह लगता है :-)

81 बाइट्स

— हैलवार्ड शेमप

@HalvardHummel धन्यवाद, एक विकल्प के रूप में पोस्ट करेंगे!

पूरी तरह से एक अलग दृष्टिकोण की कोशिश करते हुए मुझे एहसास हुआ कि आपका संस्करण 80 में किया जा सकता है ।

— जोनाथन एलन

Answer 2

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

x%y=unlines[["-|"!!(0^mod a b)|a<-[1..lcm x y]]|b<-[x,y]]

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

Comments

मैं उस 0^0=1चाल से पहले कभी नहीं देखा है - चतुर

— BlackCap

@BlackCap मैं खुद इस पर दावा नहीं कर सकता क्योंकि मैंने इसे कुछ समय पहले देखा है, हालांकि मुझे याद नहीं है कि मैंने पहली बार इस ट्रिक को कहाँ देखा था।

— लकोनी

Answer 3

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

Ṭ€ị⁾|-ṁ€æl/Y

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

Answer 4

MATL , 16 15 बाइट्स

'-|'!i&Zm:G\go)

इनपुट दो नंबरों वाला एक कॉलम वेक्टर है। इसे ऑनलाइन आज़माएं!

एक बोनस के रूप में, इनपुट में दो से अधिक नंबर हो सकते हैं । इसे ऑनलाइन आज़माएं!

व्याख्या

'-|'   % Push this string
!      % Transpose. This is needed because of input [1; 1]
i      % Input column vector of 2 (or N) numbers
&Zm    % LCM of the 2 (or N) numbers, say L
:      % Range
G      % Push input again
\      % Modulus, element-wise with broadcast. Gives a 2×L (or N×L) matrix
g      % Convert to logical: gives false for zeros, true for nonzeros
o      % Convert to double: gives 0 for false, 1 for true
)      % Index into string (modular, 1-based). Implicitly display

Comments

मुझे लगता है कि आप एक भटका में छोड़ दिया He?

— बजे

@ धन्यवाद धन्यवाद! हां, यह पिछले संस्करण में था, लेकिन यह आवश्यक नहीं है

— लुइस मेंडो

इसके अलावा, यह बिना किसी बदलाव के ठीक काम करता है? आप चीजों को

— उखाड़ फेंक रहे

MATS [1; 1](AB) अनुक्रमण के साथ सरणी आकृति को कैसे संभालता है, इसके कारण ट्रांसशिप के बिना इनपुट के बिना इनपुट के लिए काम नहीं करता है । (वैकल्पिक रूप से, Heअंत में अंतरण को प्रतिस्थापित किया जा सकता है , यही वजह है कि यह शुरू में वहां था)

— लुइस मेंडू

आह हां मुझे लगा कि यह पंक्ति व्यवहार के कारण वहां था, लेकिन मैंने इस किनारे के मामले के बारे में नहीं सोचा था।

— बजे

Answer 5

आर , 109 105 बाइट्स

function(a,b){q=1:a*b
l=min(q[!q%%a])
x=rep("-",l*2)
x[c(seq(0,l,a),l+seq(0,l,b))]="|"
write(x,"",l,,"")}

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

अनाम फ़ंक्शन। गणना करता है l=lcm(a,b), तो एक सीमा से उत्पन्न 0करने के लिए lसे a, फिर से lकरने के लिए 2*lसे b, करने के लिए सूचकांक की स्थापना |के साथ एक मैट्रिक्स के रूप में और मुद्रण lकॉलम।

Answer 6

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

l=a,b=input()
while a%b:a+=l[0]
for x in l:print a/x*('-'*~-x+'|')

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

Answer 7

सी, 72 बाइट्स

i;f(x,y){for(i=1;i%y|i%x;)putchar(i++%x?45:124);puts("|");y>0&&f(y,-x);}

Answer 8

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

†?'-'|TUṪ`%N

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

हाँ, भूसी में एक lcm निर्मित है। नहीं, मुझे इसकी आवश्यकता नहीं है।

बोनस: किसी भी संख्या में इनपुट मानों के साथ काम करता है

व्याख्या

†?'-'|TUṪ`%N    input:[2,3]
        Ṫ`%N    table of all remainders of positive naturals divided by
                input numbers:
                             [[1,1],[0,2],[1,0],[0,1],[1,2],[0,0],[1,1],[0,2],...
       U        get all elements before the first repeated one:
                             [[1,1],[0,2],[1,0],[0,1],[1,2],[0,0]]
      T         transpose:   
                             [[1,0,1,0,1,0],[1,2,0,1,2,0]]
†?'-'|          replace all truthy elements with '-' and all falsy elements
                with '|': 
                             ["-|-|-|","--|--|"]
                implicit: since this is a full program, join the resulting array
                of strings with newlines, and print to stdout

Answer 9

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

(s=LCM@##;Print[""<>If[i~Mod~#<1,"|","-"]~Table~{i,s}]&/@{##})&

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

और दूसरा संस्करण जो user202729 वास्तव में, वास्तव में, वास्तव में पोस्टेड देखना चाहता है

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

(s=LCM@##;Print[""<>If[#∣i,"|","-"]~Table~{i,s}]&/@{##})&  

यह एक विशेष चरित्र का उपयोग करता है \[Divides] ∣

Comments

यदि यह गणितज्ञ है तो आप शायद विभाजन के प्रतिनिधित्व के लिए ऑपरेटर के \[Divides]बजाय उपयोग कर सकते हैं Mod, जो 4 बाइट्स बचाता है। इसके अलावा मैथिक्स TIO प्रिंट नहीं करना चाहिए {Null, Null}।

— user202729

@ user202729 मैंने मैथिक्स प्रिंट तय किया।

— J42161217

मुझे लगता है कि आपकी पहली टिप्पणी पर्याप्त स्पष्ट थी। कृपया इच्छित परिवर्तन करने के लिए मुझ पर दबाव डालना बंद करें, आप जो सही समय चाहते हैं। उपयोगकर्ताओं को प्रतिक्रिया देने के लिए कुछ घंटे दें। हम में से कुछ इस जगह से बाहर एक जीवन है

— J42161217

Answer 10

05AB1E , 13 बाइट्स

ʒ<'-×'|«¹.¿∍,

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

फ़िल्टर एक अच्छा विचार था, मुझे यह पूरी तरह से अलग करते हुए 17 मिला .¿Lε²¹‚%_„-|è}øJ»।

— मैजिक ऑक्टोपस Urn

Answer 11

एपीएल (डायलॉग) , 22 बाइट्स

मान लेता है ⎕IO←0। A, B को सही तर्क के रूप में लेता है। बोनस: किसी भी लम्बाई की इनपुट सूची को संभालता है!

{'|-'[⌽×⍵∘.|⍳∧/⍵]}

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

{... } अनाम लंबोदर जहां ⍵सही तर्क का प्रतिनिधित्व करता है

 '|-'[... के ] साथ स्ट्रिंग अनुक्रमणिका:

  ∧/ इनपुट के पार एलसीएम

  ⍳ पहले कि कई gers ntegers (0 एन -1 के माध्यम से)

  ⍵∘.| विभाजन की शेष तालिका इनपुट के साथ लंबवत और क्षैतिज रूप से

  × Signum

  ⌽ क्षैतिज फ्लिप

Comments

उस पहली धारणा का क्या मतलब है?

— केल्विन के शौक

@ हेलकाबोम्बा इसका मतलब है कि 0 से शुरू होने वाला एरेक्स इंडेक्स, एपीएल दुभाषियों पर एक डिफ़ॉल्ट, मेरा मानना ​​है।

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

@ हेलकाहोम्बा चूंकि एपीएल सिस्टम 0-आधारित और 1-आधारित दोनों स्वादों में आते हैं, मैं सिर्फ धारणा लिखता हूं। अन्यथा किसी को दो एपीएल करने होंगे। उदा। Ngn / apl यह बहुत समान कोड निर्दिष्ट किए बिना चला सकता है⎕IO←0 , क्योंकि यह वहां डिफ़ॉल्ट है।

— एडम

Answer 12

सप्टक , 46 38 बाइट्स

-8 बाइट्स लुइस मेंडो के कई सुझावों के लिए धन्यवाद

@(a,b)'-|'.'(~mod(1:lcm(a,b),[a;b])+1)

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

Answer 13

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

f=(a,b,S,A=1)=>(A%a?'-':'|')+(A%a|A%b?f(a,b,S,A+1):S?'':`
`+f(b,a,1))

पुनरावृत्ति तब तक चलती है जब तक Aकि दोनों से विभाज्य न हो जाए aऔर b- एक डैश या पाइप के आधार पर आउटपुट होa द्वारा की विभाज्यता A।

फ़ंक्शन तब स्वयं कॉल करता है, स्वैपिंग करता है a और b।

Sचर ही असीम को कॉल करने से समारोह को रोकता है।

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

f=(a,b,S,A=1)=>(A%a?'-':'|')+(A%a|A%b?f(a,b,S,A+1):S?'':`
`+f(b,a,1))

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

---

पिछले उत्तर:

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

f=(a,b,i=2,g=(c,d)=>d?g(d,c%d):c)=>i?'|'.padStart(a,'-').repeat(b/g(a,b))+`
`+f(b,a,i-1):''

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

lcm(a, b) = ab / gcd(a, b)
gcd(c, d) = d ? gcd(d, c%d) : c

दूसरी पंक्ति को आउटपुट करने के लिए केवल एक बार पुन: कॉल करता है।

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

f=(a,b,i=2,g=(c,d)=>d?g(d,c%d):c)=>i?'|'.padStart(a,'-').repeat(b/g(a,b))+`
`+f(b,a,i-1):''

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

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

f=(a,b,i=2,g=(c,d)=>!d=>d?c:g(d,c%d):c)=>i?('-'.repeat(a-1)+'|').repeat(a*bb/g(a,b)/a)+`
`+f(b,a,i-1):''

पहले की तरह ही एल्गोरिथ्म, के repeatबजाय का उपयोग कर padStart।

Comments

मुझे लगा padStartकि ES8 था?

— नील

f=(a,b,A=1)=>(A%a?'-':'|')+(A%a|A%b?f(a,b,A+1):a<0?'':`\n`+f(-b,a))

— l4m2

@ l4m2, मैं मुश्किल से उस कोड को समझ सकता हूं जो मैंने एक साल पहले लिखा था, लेकिन ऐसा लगता है कि आपका कुछ बाइट्स से किनारा कर लेता है, धन्यवाद!

— रिक हिचकॉक

Answer 14

स्काला, 98 बाइट्स

print((a to a*b).find(l=>l%a+l%b==0).map(l=>("-"*(a-1)+"|")*(l/a)+"\n"+("-"*(b-1)+"|")*(l/b)).get)

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

Comments

नमस्ते, PPCG में आपका स्वागत है! यह एक महान प्रथम उत्तर की तरह लगता है, इसलिए +1 मुझसे। मुझे यकीन नहीं है, क्योंकि मैंने कभी भी स्काला में प्रोग्राम नहीं किया है, लेकिन इसे और करने के *(a-1)लिए तैयार किया जा सकता है*~-a*(b-1)*~-b ? इसके अलावा, क्या आप शायद टेस्ट कोड के साथ एक TIO लिंक जोड़ सकते हैं ? (ओह, और वह अवतार मुझे बहुत

— प्यारा

धन्यवाद! साथ चाल *~-aबहुत अच्छा है, लेकिन दुर्भाग्य से स्काला अधिक कोष्ठक की आवश्यकता है: *(~(-a))स्पष्ट करना है कि concatenations *~-, *~, ~-फैंसी फ़ंक्शन नाम नहीं हैं। मैंने एक TIO लिंक जोड़ा।

— घन लेटस

आह हां, ~-स्काला में फ़ंक्शन नाम हो सकते हैं। मुझे याद है कि किसी ने उल्लेख किया है कि कुछ समय पहले। कि गोल्फ के बारे में दुर्भाग्यपूर्ण है। फिर से स्वागत है, और अच्छा पहला जवाब।

— केविन क्रूज़सेन

Answer 15

जावा (ओपनजेडके 8) , 103 बाइट्स

a->b->{String l="",r="|\n";for(int m=0;(++m%a|m%b)>0;r+=m%b<1?'|':'-')l+=m%a<1?'|':'-';return l+r+'|';}

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

110 बाइट्स, एन इनपुट मान

a->{String s="";for(int v:a){for(int i=1,z=1;z>(z=0);s+=i++%v<1?'|':'-')for(int k:a)z|=i%k;s+='\n';}return s;}

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

Answer 16

जावा 8, 125 118 117 बाइट्स

a->b->{String A="\n",B=A,t="|";for(int i=1;!A.endsWith(t)|!B.endsWith(t);B+=i++%b<1?t:"-")A+=i%a<1?t:"-";return A+B;}

-7 बाइट्स @Nevay को धन्यवाद ।
-1 बाइट एक अनुगामी नई-लाइन के साथ शुरू करके ( A="",B="\n"साथ प्रतिस्थापित A="\n",B=A)।

स्पष्टीकरण:

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

a->b->{             // Method with two integer parameters and String return-type
  String A="\n",    //  String top line (starting with a trailing new-line)
         B=A,       //  String bottom-line (starting with a new-line)
         t="|";     //  Temp String "|" which is used multiple times
  for(int i=1;      //  Index-integer, starting at 1
      !A.endsWith(t)|!B.endsWith(t);
                    //  Loop as long as both Strings aren't ending with "|"
      B+=           //    After every iteration: append `B` with:
         i++%b<1?   //     If `i` is divisible by `b`:
                    //     (and increase `i` by 1 in the process)
          t         //      `t` (holding "|")
         :          //     Else:
          "-")      //      A literal "-"
    A+=             //   Append `A` with:
       i%a<1?       //    If `i` is divisible by `a`
        t           //     `t` (holding "|")
       :            //    Else:
        "-";        //     A literal "-"
                    //  End of loop (implicit / single-line body)
  return A+B;       //  Return both lines, separated by the new-line `B` started with
}                   // End of method

Comments

118 बाइट्स: a->b->{String A="",B="\n",k="|";for(int i=0;!A.endsWith(k)|!B.endsWith(k);B+=i%b<1?k:"-")A+=++i%a<1?k:"-";return A+B;}

— नेवई

@ नवीन धन्यवाद विश्वास नहीं कर सकता कि मैं सबसे स्पष्ट बात को याद कर !A.endsWith(t)|!B.endsWith(t)रहा था जब मैं यह जांचने के लिए एक छोटे तरीके की तलाश कर रहा था कि क्या दोनों के साथ समाप्त हो रहा है| .. और बी को एक नई लाइन के साथ शुरू करने के बजाय इसे उनके बीच में रखना भी स्मार्ट है।

— केविन क्रूज़सेन

Answer 17

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

संपादित करें: @Leaky नन के लिए 4 बाइट्स का धन्यवाद सहेजा गया

संपादित करें: @Rod के लिए धन्यवाद 4 बाइट्स सहेजे गए

lambda a,b:b/gcd(a,b)*("-"*~-a+"|")+"\n"+a/gcd(a,b)*("-"*~-b+"|")
from fractions import*

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

Comments

अधिक लचीले आउटपुट के लिए 88 बाइट्स या 77 बाइट्स

— रॉड

88 बाइट्स

— 18

स्पष्ट रूप से तार की एक सूची का उत्पादन स्वीकार्य नहीं है। : मैं ठीक करने के [...]साथ बदलें '\n'.join(...)।

— पूरी तरह से

Answer 18

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

सबसे कम पायथन 2 प्रविष्टि नहीं है, लेकिन एक अलग दृष्टिकोण है gcd जो अभी भी गोल्फ हो सकता है।

a,b=input()
h,p='-|'
x=b*(h*~-a+p),a*(h*~-b+p)
for v in x:print v[~zip(*x).index((p,p)):]

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

Answer 19

हास्केल , 66 60 बाइट्स

a#b=do x<-[a,b];lcm a b`take`cycle(([2..x]>>"-")++"|")++"\n"

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


एक ही लंबाई:

a#b=unlines[take(lcm a b)$cycle$([2..x]>>"-")++"|"|x<-[a,b]]

पुराना समाधान:

l!x=[1..div l x]>>([2..x]>>"-")++"|"
a#b|l<-lcm a b=l!a++'\n':l!b

Comments

आप के साथ एक बाइट बचा सकते हैं '\n':।

— लकोनी

@ लैकोनी केयरफुल, मैं आप पर बंद कर रहा हूं

— ब्लैककप

Answer 20

C (gcc) , 121 99 93 92 89 बाइट्स

यह बहुत छोटा होना चाहिए, हम्म्म्म…।

#define L(x)for(j=-1,i=a;j<i;i+=i%b||i%a)putchar(++j?j%x?45:124:10);
i,j;f(a,b){L(a)L(b)}

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

Answer 21

जे , 20 बाइट्स

'-|'{~*.$&>;&(<:=i.)

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

Comments

यह सुंदर जे

— जोनाह

Answer 22

SOGL V0.12 , 19 16 बाइट्स

2{H┌*┐+..*..g/mP

यह कोशिश करो!

स्पष्टीकरण:

2{                two times do
  H                 decreate ToS - input - by 1
   ┌*               get that many dashes
     ┐+             append a vertical bar
       ..*          push both inputs multiplied           \
          ..g       push gcd(input1, input2)              | LCM - 7 bytes :/
             /      divide the multiblication by the GCD  /
              m     mold the string to that length
               P    print that in a new line

Comments

आपने लागू करने से पहले प्रलेखित किया? o0

— totallyhuman

@icrieverytim SOGL में कई, बहुत सी प्रलेखित चीजें हैं जिन्हें लागू नहीं किया गया है। : पी प्रलेखन मूल रूप से मेरी TODO सूची है (जो कि मैं शायद ही कभी करता हूं: p)

— dzaima

Answer 23

स्टैक किया गया , 42 38 बाइट्स

[:...lcm@z:[:z\/\#-'-'*\rep'|'+out]"!]

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

संख्याओं की एक जोड़ी के रूप में इनपुट। सभी परीक्षण मामलों को एक साथ रखा गया है जैसे कि इमारतों की तरह थोड़े दिखते हैं।

व्याख्या

यह पहले lcmदो इनपुट नंबरों को लेता है z। फिर, प्रत्येक संख्या के लिए k, हम लंबाई के z / kतारों को उत्पन्न करते हैं, प्रत्येक के अंत में जोड़ते हैं, और प्रत्येक को आउटपुट करते हैं।-k - 1|

पिछली बार की गई गिनती

42 बाइट्स: [:...lcm@z:[:z\/\#-'-'*\rep'|'+''#`out]"!]

अन्य प्रयास

43 बाइट्स: [:...lcm@z:[:z\/\#-'-'*\rep'|'#`'|'+out]"!]

45 बाइट्स: ['@lcm'!#~@z,[:z\/\#-'-'*\rep'|'#`'|'+out]"!]

45 बाइट्स: [:...lcm@x[x'-'*\#<$betailmap'|'#`'|'+out]"!]

53 बाइट्स: [:...lcm'-'*@z#-'.'*'('\+')'+'.'+[z\'$1|'repl out]"!]

54 बाइट्स: [:...lcm@x{!x'-'*('('n#-'.'*').')''#`'$1|'repl out}"!]

Answer 24

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

f=(a,b,t=`
`,l=0,R=n=>'-'.repeat(n-1)+'|')=>l||1/t?f(a,b,l<0?t+R(b,l+=b):R(a,l-=a)+t,l):t

बार-बार व्यसनों के साथ एलसीएम का मूल्यांकन।

कम गोल्फ वाला

F=(a,b, sa='', sb='', la=0, lb=0)=>
{
    var R=n=>'-'.repeat(n-1)+'|'
    if (la != lb || la == 0)
    {
        if (la < lb) {
            sa += R(a)
            la += a
        }
        else
        {
            sb += R(b)
            lb += b
        }
        return F(a, b, sa, sb, la, lb)
    }
    else
        return sa+'\n'+sb
}

परीक्षा

f=(a,b,t=`
`,l=0,R=n=>'-'.repeat(n-1)+'|')=>l||1/t?f(a,b,l<0?t+R(b,l+=b):R(a,l-=a)+t,l):t

function update()
{
  var [a,b]=I.value.match(/\d+/g)
  R.textContent = f(+a,+b)
}  

update()

<input id=I oninput='update()' value='4 6'>
<pre id=R></pre>

Answer 25

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

Sub q()
a=[a1]
b=[a2]
Do Until c=d And d="|"
e=e+1
c=IIf(e Mod a,"-","|")
d=IIf(e Mod b,"-","|")
f=f& c
g=g& d
Loop
Debug.? f& vbCr& g
End Sub

-2 बाइट्स। धन्यवाद सर वाशिंगटन गेडेस।

Comments

हां, आप का धन्यवाद। :)

— रेमोएल

Answer 26

रूबी , 64 57 बाइट्स

->a,b{[a,b].map{|n|(1..a.lcm(b)).map{|x|x%n>0??-:?|}*''}}

-7 बाइट्स जी बी के लिए धन्यवाद।

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

Comments

यदि फ़ंक्शन 2 स्ट्रिंग्स ठीक है, तो आपको 'पुट्स' को शामिल करने की आवश्यकता नहीं है। और आप सरणी * ऑपरेटर (सरणी * '' array.join के बराबर है) का उपयोग करके इसे छोटा बना सकते हैं

— GB

@ आपकी मदद के लिए धन्यवाद!

— स्नैक

Answer 27

चारकोल , 32 30 29 बाइट्स

ＮθＮη≔θζＷ﹪ζη≦⁺θζＥ⟦θη⟧…⁺×-⁻ι¹|ζ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: @ ASCII- केवल के लिए 1 बाइट धन्यवाद सहेजा गया।

Comments

29 बाइट्स

— केवल

@ ASCII- केवल दस्तावेज़ के लिए कुछ नया!

— नील

दस्तावेजीकरण के लिए धन्यवाद! (क्षमा करें, मुझे वास्तव में ऐसी चीजों का दस्तावेजीकरण करने का मन नहीं है, हालांकि मुझे वास्तव में ऐसा करना चाहिए ), अगर आपको कोई आपत्ति नहीं है तो चैट.stackexchange.com/transcript/240?m=40270513#40270513 चैट .stackexchange दस्तावेज़ में कुछ और नहीं है । com / transcript / 240; m = 40270838 # 40270838 (निश्चित नहीं कि दिशात्मक जातियां कहां जाएं, वे आज्ञा नहीं हैं और न ही वे संचालक हैं)

— ASCII-only

Answer 28

गूगल शीट्स, 77 बाइट्स

बेनामी वर्कशीट फॉर्मूला जो इनपुट से रेंज A1:B1और आउटपुट से कॉलिंग सेल तक ले जाता है

=REPT(REPT("-",A1-1)&"|",LCM(1:1)/A1)&"
"&REPT(REPT("-",B1-1)&"|",LCM(1:1)/B1

-4 बाइट्स @EngineerToast के लिए धन्यवाद

Comments

क्या आप मान सकते हैं कि पंक्ति 1 के अलावा और कुछ भी इनपुट नहीं है? यदि हां, तो आप LCM(A1,B1)केवल LCM(1:1)4 बाइट्स को बचाने के लिए छोटा कर सकते हैं । मुझे लगता है कि एक खाली शुरुआती पत्रक को मानना ​​और यह निर्दिष्ट करना उचित है कि इनपुट और सूत्र दोनों कहां हैं।

— इंजीनियर टोस्ट

Answer 29

एक्सेल VBA, 79 बाइट्स

अनाम VBE तत्काल विंडो फ़ंक्शन जो सीमा से इनपुट लेता है [A1:B1]और VBE तत्काल विंडो के लिए उनके LCM के एक दृश्य को आउटपुट करता है।

_{यह मेरे Google पत्रक जवाब का एक पोर्ट है ।}

?[Rept(Rept("-",A1-1)&"|",LCM(1:1)/A1)]:?[Rept(Rept("-",B1-1)&"|",LCM(1:1)/B1)]

Answer 30

जाप , 12 बाइट्स

£×/Ury)î|ù-X

जाप दुभाषिया

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

स्पष्टीकरण:

£              For each of the two inputs as X, print...
        |           The string "|"
         ù-X        Left-padded with "-" until it is X characters long
       î            Repeated until its length is
 ×/Ury)             The Least Common Multiple

बचाने के लिए कुछ बाइट्स खोजने के लिए झबरा के लिए अतिरिक्त धन्यवाद।

Comments

15 बाइट्स

— झबरा

@ शैगी दिलचस्प है, मैंने कभी भी उस सटीक तरीके से जाप के उस हिस्से का उपयोग करने के लिए नहीं सोचा था।

— कामिल दकरी

एक और कुछ बाइट्स को बंद कर दिया गया

— झबरा