Diberi dua bilangan bulat positif, A dan B, mengilustrasikan kelipatan paling umum mereka dengan mengeluarkan dua garis garis ( -) dengan panjang LCM (A, B) setelah mengganti setiap tanda hubung Ath di baris pertama dan setiap tanda ht B di baris kedua dengan garis vertikal ( |).

Dengan cara ini, akhir setiap baris akan menjadi satu-satunya tempat |baris dua.

Misalnya, jika A = 6 dan B = 4, LCM (6, 4) = 12, jadi:

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

Dengan demikian hasil akhir akan

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

Urutan nomor input harus sesuai dengan urutan garis.

Kode terpendek dalam byte menang.

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 byte

Disimpan 1 byte berkat Halvard Hummel dan 1 byte terima kasih kepada Jonathan Allan.

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

Uji secara online!

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

Uji secara online! (82 byte - jawaban awal)

Ini adalah yang terbaik yang bisa saya lakukan dalam Python 2 (81 byte). Sepertinya saya tidak bisa mengomentari jawaban itu, saya hanya akan memposting ini di sini:

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

Uji secara online!

Upaya pertama di sini, mungkin kurang optimal!

Haskell , 57 byte

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

Cobalah online!

Jelly , 12 byte

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

Cobalah online!

MATL , 16 15 byte

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

Input adalah vektor kolom dengan dua angka. Cobalah online!

Sebagai bonus, input dapat berisi lebih dari dua angka . Cobalah online!

Penjelasan

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

Cobalah online!

Fungsi anonim. Menghitung l=lcm(a,b), kemudian menghasilkan rentang dari 0ke loleh a, kemudian dari lke 2*loleh b, mengatur indeks ke |dan mencetak sebagai matriks dengan lkolom.

Python 2 , 66 byte

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

Cobalah online!

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

Sekam , 12 byte

†?'-'|TUṪ`%N

Cobalah online!

Ya, ada lcm bawaan di Husk. Tidak, saya tidak membutuhkannya.

Bonus: bekerja dengan sejumlah nilai input

Penjelasan

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

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

Cobalah online!

dan versi lain yang pengguna202729 benar-benar ingin melihat diposting

Mathematica, 59 byte

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

yang ini menggunakan karakter khusus \[Divides] ∣

05AB1E , 13 byte

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

Menggunakan penyandian 05AB1E . Cobalah online!

APL (Dyalog) , 22 byte

Diasumsikan ⎕IO←0. Mengambil A, B sebagai argumen yang benar. Bonus: menangani daftar input dengan panjang berapa pun!

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

Cobalah online!

{... } lambda anonim di mana ⍵mewakili argumen yang tepat

 '|-'[... ] mengindeks string dengan:

  ∧/ LCM di input

  ⍳ pertama yang banyak ɩ ntegers (0 hingga N-1)

  ⍵∘.| tabel sisa pembagian dengan input secara vertikal dan horizontal

  × signum

  ⌽ balik secara horizontal

Oktaf , 46 38 byte

-8 Bytes berkat beberapa saran oleh Luis Mendo

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

Cobalah online!

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

Berjalan secara rekursif sampai Ahabis oleh keduanya adan b- mengeluarkan tanda hubung atau pipa berdasarkan apembagian oleh A.

Fungsi ini kemudian memanggil dirinya sendiri, menukar adan b.

The Svariabel mencegah fungsi dari memanggil itu sendiri jauh.

Kasus uji:

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

Menggunakan algoritma:

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

Secara rekursif menyebut dirinya hanya sekali untuk menampilkan baris kedua.

Kasus uji:

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

Algoritma yang sama seperti sebelumnya, menggunakan repeatbukan 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)

Cobalah online

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

Cobalah online!

110 byte, n nilai input

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

Cobalah online!

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 berkat @Nevay .
-1 byte dengan memulai dengan baris baru trailing ( A="",B="\n"diganti dengan A="\n",B=A).

Penjelasan:

Coba di sini.

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

Sunting: Disimpan 4 byte berkat @Leaky Nun

Sunting: Disimpan 4 byte berkat @Rod

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

Cobalah online!

Python 2 , 89 byte

Bukan entri Python 2 terpendek, tetapi pendekatan yang berbeda dari gcd yang mungkin masih golf.

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

Cobalah online!

Haskell , 66 60 byte

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

Cobalah online!


Sama panjang:

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

Solusi lama:

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

Ini harusnya jauh lebih pendek, 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)}

Cobalah online!

J , 20 byte

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

Cobalah online!

SOGL V0.12 , 19 16 byte

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

Coba Di Sini!

Penjelasan:

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

Ditumpuk , 42 38 byte

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

Cobalah online!

Masukan dalam bentuk sepasang angka. Semua test case disatukan terlihat seperti bangunan.

Penjelasan

Ini pertama-tama akan lcmmemasukkan dua nomor input z. Kemudian, untuk setiap angka k, kami menghasilkan z / kstring dengan -panjang k - 1, menambahkan |ke akhir masing-masing, dan menghasilkan masing-masing.

Upaya yang dihitung sebelumnya

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

Upaya lain

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

Mengevaluasi LCM dengan kecanduan berulang.

Kurang golf

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
}

Uji

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. Terima kasih, Sir Washington Guedes.

Ruby , 64 57 byte

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

-7 byte berkat G B.

Cobalah online!

Arang , 32 30 29 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Sunting: Disimpan 1 byte berkat hanya @ ASCII.

Google Sheets, 77 Bytes

Rumus lembar kerja anonim yang mengambil input dari rentang A1:B1dan keluaran ke sel panggilan

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

-4 Bytes berkat @EngineerToast

Excel VBA, 79 Bytes

Fungsi jendela langsung VBE anonim yang mengambil input dari kisaran [A1:B1]dan menampilkan visualisasi LCM mereka ke jendela langsung VBE.

_{Ini adalah port jawaban Google Sheets saya .}

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

Japt , 12 byte

£×/Ury)î|ù-X

Japt Interpreter

Input sebagai array angka. Output sebagai array string. Bendera -R sedikit meningkatkan bagaimana output terlihat, tetapi tidak perlu untuk logika.

Penjelasan:

£              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

Terima kasih ekstra untuk Shaggy karena menemukan beberapa byte untuk disimpan.