Cho hai số nguyên dương A và B, minh họa bội số chung nhỏ nhất của chúng bằng cách xuất ra hai dòng dấu gạch ngang ( -) với chiều dài LCM (A, B) sau khi thay thế mỗi dấu gạch ngang Ath trong dòng đầu tiên và mỗi dấu gạch ngang Bth trong dòng thứ hai bằng các thanh dọc ( |).

Theo cách này, cuối mỗi dòng sẽ là nơi duy nhất xếp hàng hai |hàng.

Ví dụ: nếu A = 6 và B = 4, LCM (6, 4) = 12, thì:

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:
-----|-----|
---|---|---|

Do đó, đầu ra cuối cùng sẽ là

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

Thứ tự của các số đầu vào phải tương ứng với thứ tự của các dòng.

Mã ngắn nhất tính bằng byte thắng.

Tủ thử

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
------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|
----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|

Python 3, 80 byte

Đã lưu 1 byte nhờ Halvard Hummel và 1 byte nhờ Jonathan Allan.

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

Kiểm tra nó trực tuyến!

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

Kiểm tra nó trực tuyến! (82 byte - câu trả lời ban đầu)

Đây là điều tốt nhất tôi có thể làm trong Python 2 (81 byte). Có vẻ như tôi không thể bình luận về câu trả lời đó, thay vào đó tôi sẽ chỉ đăng bài này ở đây:

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

Kiểm tra nó trực tuyến!

Nỗ lực đầu tiên ở đây, có lẽ là tối ưu phụ!

Haskell , 57 byte

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

Hãy thử trực tuyến!

Thạch , 12 byte

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

Hãy thử trực tuyến!

MATL , 16 15 byte

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

Đầu vào là một vectơ cột với hai số. Hãy thử trực tuyến!

Là một phần thưởng, đầu vào có thể chứa nhiều hơn hai số . Hãy thử trực tuyến!

Giải trình

'-|'   % 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

R , 109 105 byte

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,,"")}

Hãy thử trực tuyến!

Chức năng ẩn danh. Tính l=lcm(a,b), sau đó tạo một loạt từ 0để lbằng a, sau đó từ lđể 2*lbằng b, thiết lập các chỉ số để |và in ấn như một ma trận với lcột.

Python 2 , 66 byte

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

Hãy thử trực tuyến!

C, 72 byte

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

Husk , 12 byte

†?'-'|TUṪ`%N

Hãy thử trực tuyến!

Vâng, có một lcm dựng sẵn trong Husk. Không, tôi không cần nó.

Phần thưởng: hoạt động với bất kỳ số lượng giá trị đầu vào nào

Giải trình

†?'-'|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

Toán học, 63 byte

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

Hãy thử trực tuyến!

và một phiên bản khác mà user202729 thực sự, thực sự, thực sự muốn xem được đăng

Toán học, 59 byte

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

cái này sử dụng ký tự đặc biệt \[Divides] ∣

05AB1E , 13 byte

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

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

APL (Dyalog) , 22 byte

Giả định ⎕IO←0. Đưa A, B làm đối số đúng. Tiền thưởng: xử lý danh sách đầu vào có độ dài bất kỳ!

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

Hãy thử trực tuyến!

{... } lambda anonymous nơi ⍵đại diện cho lập luận đúng

 '|-'[... ] chỉ số chuỗi với:

  ∧/ LCM trên đầu vào

  ⍳ đầu tiên là nhiều ntegers (0 đến N-1)

  ⍵∘.| phân chia bảng còn lại với đầu vào theo chiều dọc và theo chiều ngang

  × dấu hiệu

  ⌽ lật theo chiều ngang

Octave , 46 38 byte

-8 byte nhờ một số gợi ý của Luis Mendo

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

Hãy thử trực tuyến!

JavaScript (ES6), 69 byte

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

Chạy đệ quy cho đến khi Achia hết cho cả hai avà b- xuất ra một dấu gạch ngang hoặc đường ống dựa trên tính aphân chia của A.

Các chức năng sau đó gọi chính nó, trao đổi avà b.

Các Sbiến ngăn chặn chức năng từ tự xưng là vô hạn.

Các trường hợp thử nghiệm:

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));

JavaScript (ES8), 91 byte

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):''

Sử dụng các thuật toán:

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

Đệ quy gọi chính nó chỉ một lần để đầu ra dòng thứ hai.

Các trường hợp thử nghiệm:

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));

JavaScript (ES6), 93 byte

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):''

Thuật toán tương tự như trước, sử dụng repeatthay vì padStart.

Scala, 98 byte

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

Dùng thử trực tuyến

Java (OpenJDK 8) , 103 byte

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+'|';}

Hãy thử trực tuyến!

110 byte, n giá trị đầu vào

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;}

Hãy thử trực tuyến!

Java 8, 125 118 117 byte

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 byte nhờ @Nevay .
-1 byte bằng cách bắt đầu bằng một dòng mới (được A="",B="\n"thay thế bằng A="\n",B=A).

Giải trình:

Hãy thử nó ở đây.

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

Python 2 , 96 88 byte

Chỉnh sửa: Đã lưu 4 byte nhờ @Leaky Nun

Chỉnh sửa: Đã lưu 4 byte nhờ @Rod

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

Hãy thử trực tuyến!

Python 2 , 89 byte

Không phải là mục nhập Python 2 ngắn nhất, nhưng một cách tiếp cận khác gcd có thể vẫn có thể chơi được.

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)):]

Hãy thử trực tuyến!

Haskell , 66 60 byte

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

Hãy thử trực tuyến!


Cùng chiều dài:

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

Giải pháp cũ:

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

C (gcc) , 121 99 93 92 89 byte

Cái này nên ngắn hơn nhiều, hmmmm ....

#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)}

Hãy thử trực tuyến!

J , 20 byte

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

Hãy thử trực tuyến!

SOGL V0.12 , 19 16 byte

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

Hãy thử nó ở đây!

Giải trình:

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

Xếp chồng lên nhau , 42 38 byte

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

Hãy thử trực tuyến!

Đầu vào dưới dạng một cặp số. Tất cả các trường hợp thử nghiệm đặt cùng nhau trông giống như các tòa nhà.

Giải trình

Điều này đầu tiên đưa lcmhai số đầu vào z. Sau đó, với mỗi số k, chúng tôi tạo ra các z / kchuỗi -có độ dài k - 1, thêm |vào cuối mỗi số và xuất ra từng chuỗi .

Những lần thử trước

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

Những nỗ lực khác

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

45 byte: ['@lcm'!#~@z,[:z\/\#-'-'*\rep'|'#`'|'+out]"!]

45 byte: [:...lcm@x[x'-'*\#<$betailmap'|'#`'|'+out]"!]

53 byte: [:...lcm'-'*@z#-'.'*'('\+')'+'.'+[z\'$1|'repl out]"!]

54 byte: [:...lcm@x{!x'-'*('('n#-'.'*').')''#`'$1|'repl out}"!]

JavaScript (ES6), 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

Đánh giá LCM với chứng nghiện lặp đi lặp lại.

Ít chơi gôn

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
}

Kiểm tra

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>

VBA (Excel), 144 142 byte

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 byte. cảm ơn ngài Washington Guedes.

Ruby , 64 57 byte

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

-7 byte nhờ G B.

Hãy thử trực tuyến!

Than , 32 30 29 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Chỉnh sửa: Đã lưu 1 byte nhờ chỉ @ ASCII.

Google Sheets, 77 byte

Công thức bảng tính ẩn danh nhận đầu vào từ phạm vi A1:B1và đầu ra cho ô gọi

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

-4 byte nhờ vào @EngineerToast

VBA Excel, 79 byte

Hàm cửa sổ ngay lập tức VBE ẩn danh nhận đầu vào từ phạm vi [A1:B1]và xuất trực quan hóa LCM của chúng sang cửa sổ ngay lập tức VBE.

_{Đây là một cổng của câu trả lời Google Sheets của tôi .}

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

Japt , 12 byte

£×/Ury)î|ù-X

Thông dịch viên Japt

Đầu vào như một mảng số. Đầu ra là một chuỗi các chuỗi. Cờ -R cải thiện một chút hình thức đầu ra, nhưng không cần thiết cho logic.

Giải trình:

£              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

Cảm ơn thêm cho Shaggy vì đã tìm thấy một số byte để lưu.