Проиллюстрировать наименьшее общее множество

50

Для двух положительных целых чисел, A и B, иллюстрируйте их наименьшее общее кратное число , выводя две строки тире ( -) с длиной LCM (A, B) после замены каждой черты Ath в первой строке и каждой черты Bth во второй строке вертикальными чертами. ( |).

Таким образом, конец каждой строки будет единственным местом в |строке двух .

Например, если 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:
-----|-----|
---|---|---|

Таким образом, окончательный результат будет

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

Порядок ввода чисел должен соответствовать порядку строк.

Самый короткий код в байтах побеждает.

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
------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|
----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|
code-golf  math  ascii-art  number  integer 
— Кальвин Хобби
источник
3
@LeakyNun Расширение ответа от codegolf.stackexchange.com/q/94999 кажется проще, чем от этого. В любом случае, людям будет весело делать это, и это достойная причина, по моему мнению.
— Увлечения Кэлвина
1
Можно ли вывести массив с двумя строками, по одной для каждой строки?
— BlackCap
@BlackCap Нет. Напечатайте строки в стандартный вывод или файл или верните всю многострочную строку.
— Увлечения
2
Бонус за обработку произвольного количества входов?
— Адам
1
@HelkaHomba Хорошо, спасибо; сохранил еще 1 байт. :) (Как будто есть какая-то другая причина задавать такие вопросы о вызовах Codegolf.; P)
— Кевин Круйссен

Ответы:

11

Python 3, 80 байт

Благодаря Халварду Хаммелу удалось сохранить 1 байт, а Джонатан Аллан - 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!
— Лайкони
3
@Laikoni Спасибо! Это похоже на веселое сообщество :-)
— Halvard Hummel
@HalvardHummel Спасибо, опубликую как альтернативу!
Полностью испробовав другой подход, я понял, что ваша версия может быть сделана в 80-х .
— Джонатан Аллан
10

Haskell , 57 байт

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

Попробуйте онлайн!

— Laikoni
источник
Я никогда не видел этот 0^0=1трюк раньше - умный
— BlackCap
@ BlackCap Я не могу требовать это сам, потому что я видел это несколько раз прежде, хотя я не помню, где я видел трюк сначала.
— Лайкони
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
— Луис Мендо
источник
Я думаю, что вы ушли в заблуждение He?
— Sanchises
@ Рассылка Спасибо! Да, это было в предыдущей версии, но это не обязательно
— Луис Мендо,
Кроме того, кажется, это работает нормально без транспонирования? Вы
— задумывались
@Sanchises Без транспонирования не работает для ввода [1; 1]из-за того, что MATL (AB) обрабатывает форму массива с помощью индексации. (В качестве альтернативы, транспонирование может быть заменено Heв конце, именно поэтому оно было изначально там)
— Луис Мендо
Ах да, я подумал, что это было из-за поведения строк, но я не думал об этом крайнем случае.
— Sanchises
5

R , 109 105 байт

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колоннами.

— Giuseppe
источник
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);}
— orlp
источник
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
— Лео
источник
4

Mathematica, 63 байта

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

Попробуйте онлайн!

и еще одна версия, которую пользователь 202729 действительно очень хочет увидеть

Mathematica, 59 байт

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

этот использует специальный символ \[Divides] ∣

— J42161217
источник
Если это Mathematica, вы, вероятно, можете использовать \[Divides]вместо Modоператора для представления делимости, что экономит 4 байта. Также Mathics TIO не следует печатать {Null, Null}.
— user202729
@ user202729 Я исправил печать Mathics.
— J42161217,
3
Я думаю, что ваш первый комментарий был достаточно ясным. Пожалуйста, перестаньте нажимать на меня, чтобы внести изменения, которые вы хотите, точное время, которое вы хотите. Дайте пользователям несколько часов, чтобы ответить. У некоторых из нас есть жизнь вне этого места
— J42161217
3

APL (Dyalog) , 22 байта

Предполагает ⎕IO←0. Принимает A, B в качестве правильного аргумента. Бонус: обрабатывает список ввода любой длины!

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

Попробуйте онлайн!

{... } анонимная лямбда, где ⍵представляет правильный аргумент

 '|-'[… ] Индексировать строку с помощью:

  ∧/ LCM через вход

  ⍳ первое, что много tentegers (от 0 до N-1)

  ⍵∘.| таблица остатков деления с вводом по вертикали и по горизонтали

  × сигнум

  ⌽ перевернуть горизонтально

— Адам
источник
Что означает это первое предположение?
— Увлечения Кэлвина
@HelkaHomba Это означает, что индекс массивов начинается с 0, я полагаю, по умолчанию для интерпретаторов APL.
— Конор О'Брайен,
@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.

— Рик Хичкок
источник
1
Я думал, padStartбыла ES8?
— Нил
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

Скала, 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)

Попробуйте онлайн

— кубический салат
источник
Привет, добро пожаловать в PPCG! Это выглядит как отличный первый ответ, так что +1 от меня. Я не уверен, так как я никогда не программировали в Scala, но может *(a-1)быть golfed к *~-aи *(b-1)к *~-b? Кроме того, не могли бы вы добавить ссылку TIO с тестовым кодом? (О, и этот аватар не кажется мне очень
— кубичным
2
Спасибо! Трюк с *~-aбольшим, но , к сожалению , Scala требует больше скобок: *(~(-a))чтобы понять , что конкатенации *~-, *~, ~-не являются именами функций фантазии. Я добавил ссылку TIO.
— кубический салат
Ах да, ~-могут быть имена функций в Scala. Я помню, как кто-то упоминал об этом раньше. Это неудачно в отношении игры в гольф. Снова добро пожаловать, и хороший первый ответ.
— Кевин Круйссен
3

Java 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
— Кевин Круйссен
источник
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 Спасибо. Не могу поверить, что я упустил самое очевидное, !A.endsWith(t)|!B.endsWith(t)когда искал короткий способ проверить, заканчиваются ли оба с |... И начинать B с новой строки вместо того, чтобы вставлять их между ними при возврате, тоже разумно.
— Кевин Круйссен
2

Python 2 , 96 88 байт

Редактировать: 4 байта сохранены благодаря @ Leaky Nun

Редактировать: 4 байта сохранены благодаря @Rod

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

Попробуйте онлайн!

— Халвард Хаммель
источник
88 байтов или 77 байтов для более гибкого вывода
— Rod
— овс
1
Видимо вывод списка строк недопустим. Я Заменить [...]с , '\n'.join(...)чтобы исправить.
— полностью человек
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
— судейская шапочка
источник
1
Вы можете сохранить байт с помощью '\n':.
— Лайкони
@ 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
— dzaima
источник
Вы документировали перед внедрением? o0
— полностью человек
1
@icrieverytim SOGL имеет много, много задокумны вещей, которые не реализованы. : p Документация - это в основном мой список TODO (что я редко делаю: p)
— dzaima
1

Stacked , 42 38 байтов

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

Попробуйте онлайн!

Ввод в виде пары чисел. Все тестовые наборы вместе выглядят как здания.

объяснение

Это сначала берет lcmиз двух входных чисел в z. Затем для каждого числа 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}"!]

— Конор О'Брайен
источник
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
источник
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 байта. спасибо сэр Вашингтон Гуэдес.

— remoel
источник
Да, спасибо @WashingtonGuedes. :)
— перемотать
1

Рубин , 64 57 байт

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

-7 байт благодаря G B.

Попробуйте онлайн!

— Перекус
источник
Вам не нужно включать 'put', если функция возвращает 2 строки, это нормально. И вы можете сделать его короче, используя оператор array * (array * '' эквивалентен array.join)
— GB
@GB спасибо за вашу помощь!
— Закуска
1

Древесный уголь , 32 30 29 байт

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

Попробуйте онлайн! Ссылка на подробную версию кода. Редактировать: 1 байт сохранен благодаря @ ASCII-only.

— Нил
источник
— только ASCII
@ ASCII-only Что-то новое в документе!
— Нил
Спасибо за документирование! (извините, мне не очень хочется документировать вещи, хотя я действительно должен это делать), если вы не возражаете, есть еще что-то, чтобы документировать chat.stackexchange.com/transcript/240?m=40270513#40270513 chat.stackexchange. com / transcript / 240? m = 40270838 # 40270838 (не уверен, куда должны идти направленные приведения, они не команды и не операторы)
— только для ASCII
1

Google Sheets, 77 байт

Формула анонимного листа, которая принимает входные данные из диапазона A1:B1и выводит их в вызывающую ячейку

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

-4 байта благодаря @EngineerToast

— Тейлор Скотт
источник
1
Можете ли вы предположить, что ничего больше не вводится в строку 1? Если да, то вы можете замкнуты LCM(A1,B1)только LCM(1:1)для сохранения 4 байта. Я думаю, что разумно предположить пустой стартовый лист и указать, где находятся и входные данные, и формула.
— Тост инженера
1

Excel VBA, 79 байт

Функция анонимного непосредственного окна VBE, которая берет входные данные из диапазона [A1:B1]и выводит визуализацию их LCM в непосредственное окно VBE.

Это порт моего ответа в Google Sheets .

?[Rept(Rept("-",A1-1)&"|",LCM(1:1)/A1)]:?[Rept(Rept("-",B1-1)&"|",LCM(1:1)/B1)]
— Тейлор Скотт
источник
1

Japt , 12 байт

£×/Ury)î|ù-X

Japt Переводчик

Входные данные в виде массива чисел. Выходы в виде массива строк. Флаг -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 за то, что он нашел несколько байтов для сохранения.

— Камил Дракари
источник
1
— лохматый
@ Shaggy Интересно, я никогда не думал использовать эту часть Japt именно таким образом.
— Камил Дракари
1
— Shaggy
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.