说明最小公倍数

50

给定两个正整数，A和B，示出了它们的最小公倍数通过输出破折号（两行-与长度）LCM（A，B）中的第一行和与垂直条第二线每个Bth的破折号替换每个Ath的破折号后（|）。

这样，每行的结尾将是两位的唯一|行。

例如，如果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
------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|
----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|
code-golf  math  ascii-art  number  integer 
— 卡尔文的爱好
source
3
@LeakyNun从扩展的答案codegolf.stackexchange.com/q/94999似乎不是从一个更容易。无论哪种方式，人们都会很乐于做到这一点，这是imo不错的原因。
— 加尔文的爱好
1
我可以输出包含两个字符串的数组，每行一个吗？
— BlackCap
@BlackCap编号。将字符串打印到stdout或文件中，或者返回整个多行字符串。
— 加尔文的爱好
2
处理任意数量输入的奖金？
— 亚当
1
@HelkaHomba好的，谢谢；保存了1个字节。：）（好像还有其他原因可以对代码高尔夫挑战提出这样的问题。； p）
— Kevin Cruijssen

Answers:

11

Python 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个字节-初始答案）

这是我在Python 2（81字节）中可以做的最好的事情。看来我无法对此答案发表评论，我将其张贴在这里：

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

在线测试！

第一次尝试，可能不是最佳选择！

2
欢迎来到PPCG！
— Laikoni
3
@Laikoni谢谢！这似乎是一个有趣的社区：-)
— Halvard Hummel
@HalvardHummel谢谢，将替代发布！
当完全尝试使用不同的方法时，我意识到您的版本可以在80年内完成。
— 乔纳森·艾伦，
10

Haskell，57个字节

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

在线尝试！

— 莱科尼
source
我之前从未见过这种0^0=1技巧-聪明
— BlackCap，
@BlackCap我自己不能声明它，因为我已经看过几次了，尽管我不记得我第一次看到这个技巧了。
— Laikoni
6

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
— 路易斯·门多
source
我想你流浪了He吗？
— Sanchises
@Sanchises谢谢！是的，它是以前的版本，但这不是必需的
— Luis Mendo
另外，这似乎在没有移调的情况下也可以正常工作吗？您一直想得太多...;）
— Sanchises
@Sanchises如果不使用转置[1; 1]，由于MATL（AB）如何使用索引处理数组形状，因此不适用于输入。（或者，可以He在末尾替换掉移调，这就是它最初出现在其中的原因）
— Luis Mendo
嗯，是的，我发现它在那里是因为行的行为，但是我没有想到这种边缘情况。
— Sanchises
5

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

— 朱塞佩
source
4

C，72个字节

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

外壳，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
— 狮子座
source
4

Mathematica，63个字节

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

在线尝试！

和另一个版本，user202729确实非常希望看到发布

Mathematica，59个字节

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

这个使用特殊字符 \[Divides] ∣

— J42161217
source
如果这是Mathematica，则可以使用\[Divides]代替Mod运算符来表示除数，这样可以节省4个字节。此外，Mathics TIO不应打印{Null, Null}。
— user202729
@ user202729我修复了数学打印。
— J42161217
3
我认为您的第一句话很清楚。请停止按我以进行所需的更改，所需的确切时间。给用户一些时间来回应。我们中有些人的生活不在这个地方
— J42161217 '17
3

APL（Dyalog），22字节

假设⎕IO←0。将A，B作为正确的参数。奖励：处理任意长度的输入列表！

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

在线尝试！

{… } 匿名lambda，⍵代表正确的论点

 '|-'[…用以下方式] 索引字符串：

  ∧/ 输入的LCM

  ⍳ 第一，许多ɩ ntegers（0至N-1）

  ⍵∘.| 垂直和水平输入的除法余数表

  × 信号

  ⌽ 水平翻转

— 亚当
source
这个第一个假设是什么意思？
— 加尔文的爱好
@HelkaHomba我认为这意味着数组索引从0开始，这是APL解释器的默认值。
— Conor O'Brien
@HelkaHomba由于APL系统有基于0和1的口味，因此我只写假设。否则，将不得不拥有两个APL。例如，ngn / apl可以运行此完全相同的代码，而无需指定⎕IO←0，因为这是默认设置。
— 亚当
3

JavaScript（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可变防止功能从自称无限。

测试用例：

显示代码段

先前的答案：

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

递归调用一次自己以输出第二行。

测试用例：

显示代码段

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。

— 里克·希区柯克
source
1
我以为padStart是ES8？
— 尼尔于2009年
1
f=(a,b,A=1)=>(A%a?'-':'|')+(A%a|A%b?f(a,b,A+1):a<0?'':`\n`+f(-b,a))
— l4m2
@ l4m2，我几乎看不懂我一年前编写的代码，但看起来确实像您的代码确实删除了一些字节，谢谢！
— 里克·希区柯克
3

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

在线尝试

— 立方生菜
source
嗨，欢迎来到PPCG！这似乎是一个很好的第一答案，所以我+1。我不知道，因为我从来没有在斯卡拉编程，但可以*(a-1)被golfed来*~-a和*(b-1)到*~-b？另外，您可以添加带有测试代码的TIO链接吗？（哦，那头像对我来说似乎不是很立体。； p）
— Kevin Cruijssen
2
谢谢！与诀窍*~-a是伟大的，但不幸的是斯卡拉需要更多的括号：*(~(-a))要明确的是，串连*~-，*~，~-是不花哨的功能名称。我添加了一个TIO链接。
— 立方莴苣
可以，~-可以是Scala中的函数名称。我记得不久前有人提到过。关于高尔夫，那是不幸的。再次欢迎，并且是很好的第一答案。
— 凯文·克鲁伊森
3

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

在线尝试！

— 内维
source
3

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

-7个字节，感谢@Nevay。
-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
— 凯文·克鲁伊森
source
1
118字节：a->b->{String A="",B="\n",k="|";for(int i=0;!A.endsWith(k)|!B.endsWith(k);B+=i%b<1?k:"-")A+=++i%a<1?k:"-";return A+B;}
— Nevay
@Nevay谢谢。不能相信我!A.endsWith(t)|!B.endsWith(t)在寻找一种简短的方法来检查它们是否都以|。结尾时错过了最明显的事情。以换行符开头B而不是将它们放在返回之间也很聪明。
— 凯文·克鲁伊森
2

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

在线尝试！

— 乔纳森·艾伦
source
2

Haskell，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
— 黑帽
source
1
您可以使用保存一个字节'\n':。
— Laikoni
@Laikoni小心，因为我已经关上你
— 莺
1

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
— 宰马
source
您在实施之前记录了文档？o0
— 完全人类的
1
@icrieverytim SOGL有很多，很多未实现的documentated事情。：p文档基本上是我的待办事项清单（我很少这样做：p）
— dzaima
1

堆叠，42 38字节

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

在线尝试！

以一对数字的形式输入。放在一起的所有测试用例看起来都像建筑物。

说明

首先lcm，将两个输入数字中的一个输入z。然后，对于每个数字k，我们生成一个length的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}"!]

— 科纳·奥布莱恩
source
1

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反复成瘾。

少打高尔夫球

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>
展开摘要

— edc65
source
1

VBA（Excel）中，144个 142字节

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个字节。感谢华盛顿·圭迪斯爵士。

— 磨砂
source
是的，谢谢@WashingtonGuedes。:)
— 消除
1

红宝石，64 57字节

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

-7个字节，感谢GB。

在线尝试！

— 小吃
source
您不需要包含“ puts”，如果函数返回2个字符串就可以了。您可以使用array *运算符（array *''等同于array.join）来缩短它的长度
— GB
@GB感谢您的帮助！
— 零食
1

木炭，32 30 29字节

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

在线尝试！链接是详细版本的代码。编辑：由于仅@ASCII，节省了1个字节。

— 尼尔
source
— 的纯ASCII码
仅限@ASCII文件新内容！
— 尼尔
感谢您的记录！（对不起，尽管我确实应该这样做，但我并不真正想记录事物），如果您不介意的话，还有更多文档可以记录chat.stackexchange.com/transcript/240?m=40270513#40270513 chat.stackexchange。 com / transcript / 240？m = 40270838＃40270838（不确定定向转换应放在何处，它们不是命令，也不是运算符）
— ASCII码，仅ASCII
1

Google表格，77字节

匿名工作表公式，该公式从范围输​​入A1:B1并输出到调用单元格

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

-4字节感谢@EngineerToast

— 泰勒·斯科特
source
1
您可以假定第1行没有其他输入吗？如果是这样，您可以简称LCM(A1,B1)为仅LCM(1:1)保存4个字节。我认为假设一个空白的起始表并指定输入和公式在哪里是合理的。
— Engineer Toast
1

Excel VBA，79字节

匿名VBE立即窗口功能，该功能从范围获取输入[A1:B1]并将其LCM的可视化输出到VBE立即窗口。

这是我的Google表格答案的一部分。

?[Rept(Rept("-",A1-1)&"|",LCM(1:1)/A1)]:?[Rept(Rept("-",B1-1)&"|",LCM(1:1)/B1)]
— 泰勒·斯科特
source
1

Japt，12个字节

£×/Ury)î|ù-X

日语翻译

输入为数字数组。输出为字符串数组。-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找到一些要保存的字节。

— 卡米尔（Kamil Drakari）
source
1
— 粗野的
@Shaggy有趣的是，我从没想过要以那种确切的方式使用Japt的那部分。
— 卡米尔·德拉卡里
1
— Shaggy
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.