두 개의 양의 정수 A와 B가 주어지면 첫 번째 줄의 모든 Ath 대시와 두 번째 줄의 모든 Bth 대시를 세로 막대로 바꾼 후 두 줄의 대시 ( )를 길이 LCM (A, B) 으로 출력 하여 최소 공통 배수 를 나타냅니다. ( ).-|

이런 식으로, 각 라인의 끝은 2 |의 라인업 만됩니다.

예를 들어 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:
-----|-----|
---|---|---|

따라서 최종 출력은

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

입력 번호의 순서는 행의 순서와 일치해야합니다.

바이트 단위의 가장 짧은 코드가 이깁니다.

테스트 케이스

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

파이썬 3, 80 바이트

Halvard Hummel 덕분에 1 바이트를 절약하고 Jonathan Allan 덕분에 1 바이트를 절약했습니다.

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 바이트-초기 답변)

이것이 파이썬 2 (81 바이트)에서 할 수있는 최선입니다. 그 답변에 대해 언급 할 수없는 것 같습니다. 대신 여기에 게시 할 것입니다.

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

온라인으로 테스트하십시오!

첫 번째 시도는 아마도 차선책 일 것입니다!

하스켈 , 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 , 109105 바이트

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컬럼.

파이썬 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);}

껍질 , 12 바이트

†?'-'|TUṪ`%N

온라인으로 사용해보십시오!

예, Husk에는 lcm이 내장되어 있습니다. 아니요, 필요 없습니다.

보너스 : 여러 입력 값에서 작동

설명

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

  ⍳ 먼저 많은 nt ntegers (0에서 N-1까지)

  ⍵∘.| 입력을 수직으로 수평으로 나누는 나머지 테이블

  × 부호

  ⌽ 수평으로 뒤집다

옥타브 , 46 38 바이트

Luis Mendo의 여러 제안 덕분에 -8 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (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나누기 기준으로 대시 또는 파이프를 출력합니다 A.

이 함수는 교환, 자신을 호출 a하고 b.

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

자바 스크립트 (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):''

repeat대신 사용 하는 이전과 동일한 알고리즘 입니다 padStart.

스칼라, 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)

온라인으로 사용해보십시오

자바 (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;}

온라인으로 사용해보십시오!

자바 (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;}

@Nevay 덕분에 -7 바이트 .
후행 줄 바꿈으로 시작하여 -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

파이썬 2 , 96 88 바이트

편집 : @ Leaky Nun 덕분에 4 바이트가 절약되었습니다.

편집 : @Rod 덕분에 4 바이트가 절약되었습니다.

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

온라인으로 사용해보십시오!

파이썬 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)):]

온라인으로 사용해보십시오!

하스켈 , 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. 그런 다음 각 숫자에 대해 length의 문자열을 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}"!]

자바 스크립트 (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을 평가합니다.

덜 골프

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), 144142 바이트

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 바이트 워싱턴 Guedes 선생님 께 감사드립니다.

루비 , 64 57 바이트

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

G B 덕분에 -7 바이트

온라인으로 사용해보십시오!

숯 , 32 30 29 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 : @ASCII 전용 덕분에 1 바이트가 절약되었습니다.

Google 스프레드 시트, 77 바이트

범위에서 입력 A1:B1을 받고 호출 셀로 출력 하는 익명 워크 시트 수식

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

@EngineerToast 덕분에 -4 바이트

Excel VBA, 79 바이트

범위에서 입력을 받고 [A1:B1]LCM의 시각화를 VBE 즉시 창으로 출력하는 익명 VBE 즉시 창 기능 .

_{내 Google 스프레드 시트 답변 의 포트입니다 .}

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

Japt , 12 바이트

£×/Ury)î|ù-X

apt 인터프리터

숫자 배열로 입력합니다. 문자열 배열로 출력합니다. -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에게 감사드립니다.