Dados dois números inteiros positivos, A e B, ilustram seu múltiplo menos comum , produzindo duas linhas de traços ( -) com comprimento LCM (A, B) após substituir todos os traços Ath na primeira linha e cada traço B na segunda linha com barras verticais ( |)

Dessa forma, o final de cada linha será o único lugar |da linha de dois .

Por exemplo, se A = 6 e B = 4, LCM (6, 4) = 12, então:

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

Assim, o resultado final seria

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

A ordem dos números de entrada deve corresponder à ordem das linhas.

O código mais curto em bytes vence.

Casos de teste

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

Economizou 1 byte graças a Halvard Hummel e 1 byte graças a Jonathan Allan.

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

Teste online!

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

Teste online! (82 bytes - resposta inicial)

Este é o melhor que eu poderia fazer no Python 2 (81 bytes). Parece que não posso comentar sobre essa resposta, apenas postarei aqui:

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

Teste online!

Primeira tentativa aqui, provavelmente abaixo do ideal!

Haskell , 57 bytes

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

Experimente online!

Gelatina , 12 bytes

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

Experimente online!

MATL , 16 15 bytes

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

Entrada é um vetor de coluna com os dois números. Experimente online!

Como bônus, a entrada pode conter mais de dois números . Experimente online!

Explicação

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

Experimente online!

Função anônima. Calcula l=lcm(a,b), em seguida, gera um intervalo 0da lpor a, em seguida, a partir lde 2*lpor b, definindo os índices a |e imprimir como uma matriz com lcolunas.

Python 2 , 66 bytes

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

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

Casca , 12 bytes

†?'-'|TUṪ`%N

Experimente online!

Sim, há um lcm embutido no Husk. Não, eu não preciso disso.

Bônus: funciona com qualquer número de valores de entrada

Explicação

†?'-'|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}]&/@{##})&

Experimente online!

e outra versão que user202729 realmente, realmente, realmente quer ver postada

Mathematica, 59 bytes

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

este usa caráter especial \[Divides] ∣

05AB1E , 13 bytes

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

Usa a codificação 05AB1E . Experimente online!

APL (Dyalog) , 22 bytes

Assume ⎕IO←0. Toma A, B como argumento correto. Bônus: lida com a lista de entrada de qualquer tamanho!

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

Experimente online!

{… } Lambda anônima onde ⍵representa o argumento certo

 '|-'[… ] Indexe a string com:

  ∧/ LCM na entrada

  ⍳ primeiro que muitos ntegers (0 a N-1)

  ⍵∘.| tabela restante da divisão com a entrada verticalmente e horizontalmente

  × signum

  ⌽ Virar horizontalmente

Oitava , 46 38 bytes

-8 bytes graças a várias sugestões de Luis Mendo

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

Experimente online!

JavaScript (ES6), 69 bytes

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

Executa recursivamente até que Aseja divisível por ambos ae b- produzindo um traço ou tubo com base na adivisibilidade de A.

A função então se chama, trocando ae b.

A Svariável impede a função de se chamar infinitamente.

Casos de teste:

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 bytes

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

Usa os algoritmos:

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

Recursivamente se chama apenas uma vez para emitir a segunda linha.

Casos de teste:

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 bytes

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

O mesmo algoritmo de antes, usando em repeatvez de 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)

Experimente online

Java (OpenJDK 8) , 103 bytes

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

Experimente online!

110 bytes, n valores de entrada

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

Experimente 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 graças a @Nevay .
-1 byte, começando com uma nova linha à direita (A="",B="\n" substituída por A="\n",B=A).

Explicação:

Experimente aqui.

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

Edit: Salvo 4 bytes graças a @Leaky Nun

Editar: salvou 4 bytes graças a @Rod

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

Experimente online!

Python 2 , 89 bytes

Não é a entrada mais curta do Python 2, mas uma abordagem diferente da gcd que ainda pode ser jogável.

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

Experimente online!

Haskell , 66 60 bytes

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

Experimente online!


Mesmo comprimento:

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

Solução antiga:

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

Isso deve ser muito mais curto, 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)}

Experimente online!

J , 20 bytes

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

Experimente online!

SOGL V0.12 , 19 16 bytes

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

Experimente aqui!

Explicação:

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

Empilhados , 42 38 bytes

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

Experimente online!

Entrada na forma de um par de números. Todos os casos de teste juntos parecem com edifícios.

Explicação

Isso primeiro leva lcmos dois números de entrada z. Então, para cada número k, geramos z / kcadeias -de comprimento k - 1, adicionando| ao final de cada uma e produzindo cada uma.

Tentativas anteriores contadas

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

Outras tentativas

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

Avaliando o LCM com vícios repetidos.

Menos golfe

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
}

Teste

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. obrigado Sir Washington Guedes.

Ruby , 64 57 bytes

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

-7 bytes graças a G B.

Experimente online!

Carvão , 32 30 29 bytes

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

Experimente online! Link é a versão detalhada do código. Editar: salvou 1 byte graças a @ ASCII-only.

Planilhas Google, 77 bytes

Fórmula de planilha anônima que leva a entrada do intervalo A1:B1e as saídas para a célula chamadora

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

-4 bytes graças a @EngineerToast

Excel VBA, 79 bytes

Função de janela imediata VBE anônima que recebe entrada do intervalo [A1:B1]e exibe uma visualização de seu LCM na janela imediata VBE.

_{Esta é uma porta da minha resposta do Planilhas Google .}

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

Japonês , 12 bytes

£×/Ury)î|ù-X

Intérprete Japt

Entradas como uma matriz de números. Saídas como uma matriz de seqüências de caracteres. O sinalizador -R melhora um pouco a aparência da saída, mas não é necessário para a lógica.

Explicação:

£              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

Agradecimentos extras a Shaggy por encontrar alguns bytes para salvar.