รับจำนวนเต็มบวกสองตัว A และ B แสดงให้เห็นถึงผลคูณที่น้อยที่สุดของพวกมันโดยแสดงเครื่องหมายขีดคั่นสองบรรทัด ( -) ด้วยความยาวLCM (A, B) หลังจากเปลี่ยนทุกเส้นประ Ath ในบรรทัดแรกและเส้นประ 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:
-----|-----|
---|---|---|

ดังนั้นผลลัพธ์สุดท้ายจะเป็น

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

ลำดับของหมายเลขอินพุตควรสอดคล้องกับลำดับของบรรทัด

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

Testcases

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 ไบต์

บันทึก 1 ไบต์ขอบคุณ Halvard Hummel และ 1 ไบต์ขอบคุณ Jonathan Allan

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 ไบต์ - คำตอบเริ่มต้น)

นี่คือสิ่งที่ดีที่สุดที่ฉันสามารถทำได้ใน Python 2 (81 ไบต์) ดูเหมือนว่าฉันไม่สามารถแสดงความคิดเห็นกับคำตอบนั้นฉันจะโพสต์ที่นี่แทน:

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

ทดสอบออนไลน์!

ความพยายามครั้งแรกที่นี่อาจย่อยที่ดีที่สุด!

Haskell , 57 ไบต์

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

ลองออนไลน์!

เยลลี่ 12 ไบต์

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

ลองออนไลน์!

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

R , 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คอลัมน์

Python 2 , 66 ไบต์

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

ลองออนไลน์!

C, 72 ไบต์

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

Huskขนาด 12 ไบต์

†?'-'|TUṪ`%N

ลองออนไลน์!

ใช่มี lcm ในตัวอยู่ใน Husk ไม่ฉันไม่ต้องการมัน

โบนัส: ทำงานได้กับค่าอินพุตจำนวนเท่าใดก็ได้

คำอธิบาย

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

Mathematica, 63 ไบต์

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

ลองออนไลน์!

และอีกเวอร์ชั่นที่ user202729 จริงๆต้องการเห็นโพสต์จริงๆ

Mathematica, 59 ไบต์

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

อันนี้ใช้อักขระพิเศษ \[Divides] ∣

05AB1E , 13 ไบต์

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

ใช้การเข้ารหัส05AB1E ลองออนไลน์!

APL (Dyalog) 22 ไบต์

⎕IO←0ถือว่า รับ A, B เป็นอาร์กิวเมนต์ที่ถูกต้อง โบนัส:จัดการรายการอินพุตที่มีความยาวเท่าใดก็ได้!

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

ลองออนไลน์!

{… } แลมบ์ดานิรนามซึ่ง⍵แสดงถึงการโต้แย้งที่ถูกต้อง

 '|-'[... ทำ] ดัชนีสตริงด้วย:

  ∧/ LCM ข้ามอินพุต

  ⍳ ครั้งแรกที่หลายɩ ntegers (0 ผ่าน N-1)

  ⍵∘.| ส่วนที่เหลือของตารางที่มีการป้อนข้อมูลในแนวตั้งและแนวนอน

  × Signum

  ⌽ พลิกแนวนอน

คู่ , 46 38 ไบต์

-8 ไบต์ขอบคุณคำแนะนำหลายอย่างโดย Luis Mendo

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

ลองออนไลน์!

JavaScript (ES6), 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's Aหารโดย

ฟังก์ชั่นแล้วเรียกตัวเอง, การแลกเปลี่ยนและab

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

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

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

ขั้นตอนวิธีการเช่นเดียวกับก่อนใช้แทนrepeatpadStart

สกาลา 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)

ลองออนไลน์

Java (OpenJDK 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 ไบต์ n ค่าอินพุต

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

ลองออนไลน์!

Java 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

Python 2 , 96 88 ไบต์

แก้ไข:บันทึกแล้ว 4 ไบต์ด้วย@Leaky Nun

แก้ไข:บันทึกแล้ว 4 ไบต์ขอบคุณ@Rod

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

ลองออนไลน์!

Python 2 , 89 ไบต์

ไม่ใช่รายการ Python 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)):]

ลองออนไลน์!

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

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

ลองออนไลน์!

J , 20 ไบต์

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

ลองออนไลน์!

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

ซ้อนกัน , 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}"!]

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

การประเมิน LCM ด้วยการเสพติดซ้ำแล้วซ้ำอีก

น้อย golfed

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>

VBA (Excel), 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 ไบต์ ขอบคุณ Sir Washington Guedes

Ruby , 64 57 ไบต์

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

-7 ไบต์ขอบคุณ G G

ลองออนไลน์!

ถ่าน , 32 30 29 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด แก้ไข: บันทึก 1 ไบต์ต้องขอบคุณ @ ASCII-only

Google ชีตขนาด 77 ไบต์

สูตรเวิร์กชีทแบบไม่ระบุชื่อที่รับอินพุตจากช่วงA1:B1และเอาต์พุตไปยังเซลล์ที่เรียก

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

-4 ไบต์ขอบคุณ@EngineerToast

Excel VBA ขนาด 79 ไบต์

ฟังก์ชันหน้าต่างแบบไม่ระบุชื่อ VBE แบบทันทีที่รับอินพุตจากช่วง[A1:B1]และแสดงผลการสร้างภาพ LCM ของพวกเขาไปยังหน้าต่างทันที VBE

_{นี้เป็นท่าเรือของฉันคำตอบของ Google แผ่น}

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

Japt , 12 ไบต์

£×/Ury)î|ù-X

ล่าม Japt

อินพุตเป็นอาร์เรย์ของตัวเลข เอาต์พุตเป็นอาร์เรย์ของสตริง แฟล็ก -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

ขอขอบคุณ Shaggy สำหรับการค้นหาไบต์เพื่อบันทึก