İki pozitif tamsayı verildiğinde, A ve B, ilk satırdaki her Ath çizgisini ve ikinci satırdaki her Bth çizgisini dikey çubuklarla değiştirdikten sonra iki çizgi çizgisi ( ) uzunluğu LCM (A, B) ile çıkarıp en az ortak katlarını gösterir . ( ).-|

Bu şekilde, her çizginin sonu, iki sıranın tek sırası olacaktır |.

Örneğin, eğer A = 6 ve B = 4 ise, LCM (6, 4) = 12 ise:

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

Böylece nihai çıktı

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

Giriş numaralarının sırası, satırların sırasına karşılık gelmelidir.

Bayt cinsinden en kısa kod kazanır.

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 bayt

Halvard Hummel'e 1 byte, Jonathan Allan'a 1 byte kaydedildi.

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

Çevrimiçi test edin!

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

Çevrimiçi test edin! (82 bayt - ilk cevap)

Python 2'de (81 bytes) yapabileceğimin en iyisi bu. Görünüşe göre bu cevap hakkında yorum yapamam, bunun yerine bunu buraya gönderirim:

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

Çevrimiçi test edin!

Burada ilk girişimi, muhtemelen alt optimal!

Haskell , 57 bayt

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

Çevrimiçi deneyin!

Jöle , 12 bayt

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

Çevrimiçi deneyin!

Matl , 16 15 bayt

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

Giriş, iki sayının bulunduğu bir sütun vektörüdür. Çevrimiçi deneyin!

Bonus olarak, giriş ikiden fazla sayı içerebilir . Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Anonim işlev Hesaplar l=lcm(a,b)ve ardından bir dizi oluşturur 0için ltarafından ao andan itibaren, lhiç 2*ltarafından biçin endeks ayarı, |bir matris olarak ve baskı lsütunlar.

Python 2 , 66 bayt

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

Çevrimiçi deneyin!

C, 72 bayt

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

Kabuğu , 12 bayt

†?'-'|TUṪ`%N

Çevrimiçi deneyin!

Evet, Husk'ta bir 1cm yerleşik var. Hayır, ihtiyacım yok.

Bonus: Herhangi bir sayıda giriş değeriyle çalışır

açıklama

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

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

Çevrimiçi deneyin!

ve user202729 gerçekten, gerçekten, gerçekten yayınlanan görmek istiyor başka bir sürümü

Mathematica, 59 bayt

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

bu özel karakter kullanır \[Divides] ∣

05AB1E , 13 bayt

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

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

APL (Dyalog) , 22 bayt

Varsayım ⎕IO←0. A, B'yi doğru argüman olarak alır. Bonus: herhangi bir uzunlukta giriş listesini işler!

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

Çevrimiçi deneyin!

{… Doğru argümanı temsil eden } anonim lambda⍵

 '|-'[… ] İle dizeyi indeksleyin:

  ∧/ Giriş boyunca LCM

  ⍳ İlk önce o kadar çok sayıda insan (0 ila N-1)

  ⍵∘.| yatay ve dikey olarak girişe sahip bölüm kalan tablosu

  × sinyalnum

  ⌽ Yatay olarak çevir

Octave , 46 38 bayt

Luis Mendo'nun önerileriyle -8 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 69 bayt

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

AHer ikisi tarafından bölünebilir olana kadar tekrarlı bir şekilde çalışır ave b- tarafından bölünebilirliği esas alan bir kısa çizgi veya boru açıkarır A.

İşlev daha sonra kendini çağırır ave değiştirir b.

SKademesiz Kendisine işlevini önler.

Test Durumları:

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 bayt

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

Algoritmaları kullanır:

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

İkinci satırın çıktısını almak için tekrarlı olarak kendisini yalnızca bir kez çağırır.

Test Durumları:

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 bayt

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

Daha önce olduğu gibi aynı algoritma repeatyerine kullanarak padStart.

Scala, 98 bayt

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

Çevrimiçi deneyin

Java (OpenJDK 8) , 103 bayt

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

Çevrimiçi deneyin!

110 bayt, n giriş değeri

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

Çevrimiçi deneyin!

Java 8, 125 118 117 bayt

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

@Nevay sayesinde -7 bayt .
-1 bayt, takip eden yeni satırla başlayarak (ile A="",B="\n"değiştirilir A="\n",B=A).

Açıklama:

Burada dene.

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 bayt

Düzenleme: @Leaky Nun sayesinde 4 bayt kaydedildi

Düzenleme: @Rod sayesinde 4 bayt kaydedildi

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

Çevrimiçi deneyin!

Python 2 , 89 bayt

En kısa Python 2 girişi değil , yine de golf oynamaktan daha farklı bir yaklaşım 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)):]

Çevrimiçi deneyin!

Haskell , 66 60 bayt

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

Çevrimiçi deneyin!


Aynı uzunluk:

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

Eski çözüm:

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 bayt

Bu daha kısa olmalı, 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)}

Çevrimiçi deneyin!

J , 20 bayt

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

Çevrimiçi deneyin!

SOGL V0.12 , 19 16 bayt

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

Burada dene!

Açıklama:

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

Yığılmış , 42 38 bayt

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

Çevrimiçi deneyin!

Bir çift sayı biçiminde girin. Bir araya getirilen tüm test vakaları binalar gibi görünüyor.

açıklama

Bu, ilk önce lcmiki giriş numarasının içine girer z. Sonra, her sayı için uzunluk dizgileri küretiyoruz , her birinin sonuna ekliyoruz ve her birini çıkarıyoruz.z / k-k - 1|

Önceki sayılan girişimler

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

Diğer girişimler

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

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

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

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

54 bayt: [:...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'nin tekrarlanan bağımlılıklar ile değerlendirilmesi.

Daha az golf oynadı

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
}

Ölçek

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 bayt

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 bayt. Teşekkürler Sir Washington Guedes.

Ruby , 64 57 bayt

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

G7 sayesinde -7 bayt

Çevrimiçi deneyin!

Kömür , 32 30 29 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Düzenleme: sadece @ ASCII-sayesinde 1 bayt kaydedildi.

Google Sayfaları, 77 Bayt

Aralıktan girdi alan A1:B1ve çağıran hücreye çıktı alan adsız çalışma formülü

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

@EngineerToast sayesinde -4 bayt

Excel VBA, 79 Bayt

Aralıktan girdi alan anonim VBE acil pencere işlevi [A1:B1] ve LCM'lerinin görselleştirmesini .

_{Bu, Google Sayfalar cevabımın bir bağlantı noktasıdır .}

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

Japt , 12 bayt

£×/Ury)î|ù-X

Japt Tercüman

Sayı dizisi olarak giriş yapar. Bir dizi dizisi olarak çıktı verir. -R bayrağı çıktının nasıl göründüğünü biraz iyileştirir, ancak mantık için gerekli değildir.

Açıklama:

£              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'ye, kaydedilecek bazı baytları buldukları için teşekkür ederiz.