Bei zwei positiven ganzen Zahlen A und B wird das am wenigsten verbreitete Vielfache dargestellt, indem zwei Strichzeilen ( -) mit der Länge LCM (A, B) ausgegeben werden , nachdem jeder Ath-Strich in der ersten Zeile und jeder B-Strich in der zweiten Zeile durch vertikale Striche ersetzt wurden ( |).

Auf diese Weise ist das Ende jeder Zeile die einzige Stelle, an der sich zwei |Zeilen befinden.

Wenn beispielsweise A = 6 und B = 4, ist 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:
-----|-----|
---|---|---|

Somit wäre die endgültige Ausgabe

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

Die Reihenfolge der Eingabenummern sollte der Reihenfolge der Zeilen entsprechen.

Der kürzeste Code in Bytes gewinnt.

Testfälle

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 Bytes

1 Byte dank Halvard Hummel und 1 Byte dank Jonathan Allan gespeichert.

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

Online testen!

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

Online testen! (82 Bytes - erste Antwort)

Dies ist das Beste, was ich in Python 2 tun konnte (81 Byte). Anscheinend kann ich diese Antwort nicht kommentieren. Ich werde dies stattdessen hier posten:

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

Online testen!

Erster Versuch hier wohl suboptimal!

Haskell , 57 Bytes

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

Probieren Sie es online!

Gelee , 12 Bytes

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

Probieren Sie es online!

MATL , 16 15 Bytes

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

Die Eingabe ist ein Spaltenvektor mit den beiden Zahlen. Probieren Sie es online!

Als Bonus kann die Eingabe mehr als zwei Zahlen enthalten . Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Anonyme Funktion. Berechnet l=lcm(a,b)und generiert dann einen Bereich von 0bis lbis aund dann von lbis 2*lbis b, setzt die Indizes auf |und druckt als Matrix mit lSpalten.

Python 2 , 66 Bytes

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

Probieren Sie es online!

C 72 Bytes

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

Schale , 12 Bytes

†?'-'|TUṪ`%N

Probieren Sie es online!

Ja, in Husk ist ein lcm eingebaut. Nein, ich brauche es nicht.

Bonus: Funktioniert mit beliebig vielen Eingabewerten

Erläuterung

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

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

Probieren Sie es online!

und eine andere version die user202729 wirklich, wirklich, wirklich gepostet sehen will

Mathematica, 59 Bytes

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

Dieser verwendet Sonderzeichen \[Divides] ∣

05AB1E , 13 Bytes

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

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

APL (Dyalog) , 22 Bytes

Geht davon aus ⎕IO←0. Nimmt A, B als rechtes Argument. Bonus: Bewältigt Eingabelisten beliebiger Länge!

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

Probieren Sie es online!

{... } anonymer Lambda, wo ⍵das richtige Argument darstellt

 '|-'[… ] Indexiere den String mit:

  ∧/ LCM über den Eingang

  ⍳ zuerst so viele Zahlen (0 bis N-1)

  ⍵∘.| Aufteilung Resttabelle mit der Eingabe vertikal und horizontal

  × signum

  ⌽ horizontal spiegeln

Oktave , 46 38 Bytes

-8 Bytes dank mehrerer Vorschläge von Luis Mendo

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

Probieren Sie es 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))

Läuft rekursiv, bis Adurch beides teilbar ist aund b- gibt einen Bindestrich oder eine Pipe basierend auf ader Teilbarkeit durch aus A.

Die Funktion ruft sich dann durch Vertauschen von aund auf b.

Die SVariable verhindert, dass sich die Funktion unendlich selbst aufruft.

Testfälle:

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

Verwendet die Algorithmen:

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

Ruft sich nur einmal rekursiv auf, um die zweite Zeile auszugeben.

Testfälle:

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

Gleicher Algorithmus wie zuvor mit repeatanstelle von padStart.

Scala, 98 Bytes

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

Probieren Sie es online aus

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

Probieren Sie es online!

110 Bytes, n Eingabewerte

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

Probieren Sie es online!

Java 8, 125 118 117 Bytes

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 Bytes dank @Nevay .
-1 Byte, indem mit einer abschließenden neuen Zeile begonnen wird ( A="",B="\n"ersetzt durch A="\n",B=A).

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

Bearbeiten: 4 Bytes dank @Leaky Nun gespeichert

Bearbeiten: 4 Bytes dank @Rod gespeichert

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

Probieren Sie es online!

Python 2 , 89 Bytes

Nicht der kürzeste Python 2-Eintrag, aber eine andere Herangehensweise als gcd die, die möglicherweise noch zum Golfen geeignet ist.

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

Probieren Sie es online!

Haskell , 66 60 Bytes

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

Probieren Sie es online!


Die gleiche Länge:

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

Alte Lösung:

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 Bytes

Das sollte viel kürzer sein, 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)}

Probieren Sie es online!

J , 20 Bytes

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

Probieren Sie es online!

SOGL V0.12 , 19 16 Bytes

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

Probieren Sie es hier aus!

Erläuterung:

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

Gestapelt , 42 38 Bytes

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

Probieren Sie es online!

Eingabe in Form eines Zahlenpaares. Alle Testfälle sehen zusammen wie Gebäude aus.

Erläuterung

Dies nimmt zuerst die lcmder beiden Eingangsnummern auf z. Dann kerzeugen wir für jede Zahl z / kZeichenfolgen mit -einer Länge k - 1, addieren |sie zum Ende und geben sie jeweils aus.

Bisherige gezählte Versuche

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

Andere Versuche

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

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

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

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

54 Bytes: [:...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

Auswertung der LCM mit wiederholten Abhängigkeiten.

Weniger golfen

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
}

Prüfung

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 Bytes

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 Bytes. Vielen Dank, Sir Washington Guedes.

Ruby , 64 57 Bytes

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

-7 Bytes dank G B.

Probieren Sie es online!

Holzkohle , 32 30 29 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: 1 Byte dank nur @ ASCII gespeichert.

Google Sheets, 77 Bytes

Anonyme Arbeitsblattformel, die Eingaben aus dem Bereich A1:B1und Ausgaben in die aufrufende Zelle übernimmt

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

-4 Bytes dank @EngineerToast

Excel VBA, 79 Bytes

Anonyme VBE-Sofortfensterfunktion, die Eingaben aus dem Bereich entgegennimmt [A1:B1]und eine Visualisierung ihres LCM an das VBE-Sofortfenster ausgibt.

_{Dies ist ein Port meiner Google Sheets-Antwort .}

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

Japt , 12 Bytes

£×/Ury)î|ù-X

Japt Interpreter

Eingaben als Array von Zahlen. Ausgabe als Array von Strings. Das Flag -R verbessert das Erscheinungsbild der Ausgabe geringfügig, ist jedoch für die Logik nicht erforderlich.

Erläuterung:

£              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

Extra danke an Shaggy für das Auffinden einiger Bytes zum Speichern.