Ilustre o mínimo múltiplo comum


50

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

3
@LeakyNun Estender uma resposta de codegolf.stackexchange.com/q/94999 parece mais fácil do que a partir dessa. De qualquer maneira, as pessoas vão se divertir fazendo isso, o que é uma razão decente.
Hobbies de Calvin

11
Posso gerar uma matriz com duas strings, uma para cada linha?
BlackCap 25/09

@BlackCap No. Imprima as strings em stdout ou em um arquivo ou retorne a string multilinha inteira.
Hobbies de Calvin

2
Bônus por lidar com número arbitrário de insumos?
Adám 25/09/17

11
@HelkaHomba Ok thanks; economizou mais 1 byte. :) (Como se não houver qualquer outro motivo para fazer tais perguntas sobre os desafios codegolf; p.)
Kevin Cruijssen

Respostas:


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!


2
Bem-vindo ao PPCG!
Laikoni 25/09

3
@Laikoni Obrigado! Esta parece ser uma comunidade divertida :-)


@HalvardHummel Obrigado, publicará como alternativa!

Ao tentar uma abordagem totalmente diferente, percebi que sua versão poderia ser feita em 80 .
Jonathan Allan



6

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

Eu acho que você saiu de rua He?
Sanchises 28/09

@Sanchises Thanks! Sim, estava na versão anterior, mas não é necessário.
Luis Mendo

Além disso, isso parece funcionar muito bem sem a transposição? Você tem pensado demais nas coisas ...;)
Sanchises 28/09

@Sanchises Sem a transposição, ela não funciona para entrada [1; 1], devido ao modo como o MATL (AB) lida com a forma da matriz com a indexação. (Alternativamente, a transposta poderia ser substituída por He, no final, o qual é por isso que foi inicialmente ali)
Luis Mendo

Ah, sim, achei que estava lá por causa do comportamento da linha, mas não pensei nesse caso extremo.
Sanchises 28/09

5

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.



4

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

4

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

4

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]


Se este for o Mathematica, você provavelmente poderá usar o operador em \[Divides]vez de Modrepresentar a divisibilidade, o que economiza 4 bytes. O Mathio TIO também não deve imprimir o arquivo {Null, Null}.
user202729

@ user202729 Corrigi a impressão Mathics.
precisa saber é o seguinte

3
Penso que o seu primeiro comentário foi suficientemente claro. Por favor, pare de me pressionar para fazer as alterações que você deseja, na hora exata que deseja. Dê aos usuários algumas horas para responder. Alguns de nós têm uma vida fora deste lugar
J42161217


3

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


O que essa primeira suposição significa?
Calvin's Hobbies

@HelkaHomba Isso significa que o índice de matrizes começa em 0, um padrão para os intérpretes da APL, acredito.
Conor O'Brien

@HelkaHomba Como os sistemas APL são baseados em 0 e 1, acabei de escrever o pressuposto. Caso contrário, seria necessário ter dois APLs. Por exemplo, ngn / apl pode executar esse mesmo código sem especificar ⎕IO←0, pois esse é o padrão lá.
Adám 26/09/17


3

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:


Respostas anteriores:

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:

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.


11
Eu pensei que padStartera ES8?
Neil

11
f=(a,b,A=1)=>(A%a?'-':'|')+(A%a|A%b?f(a,b,A+1):a<0?'':`\n`+f(-b,a))
L4m2 22/10

@ l4m2, mal consigo entender o código que escrevi há um ano, mas parece que o seu raspa alguns bytes, obrigado!
Rick Hitchcock

3

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


Olá, seja bem-vindo ao PPCG! Parece uma ótima primeira resposta, portanto, marque com +1. Eu não tenho certeza, desde que eu nunca programado em Scala, mas pode *(a-1)ser golfed de *~-ae *(b-1)para *~-b? Além disso, você poderia adicionar um link TIO com código de teste? (Oh, e que avatar não parece muito cúbico para mim; p.)
Kevin Cruijssen

2
Obrigado! O truque com *~-aé grande, mas infelizmente Scala requer mais suportes: *(~(-a))deixar claro que as concatenações *~-, *~, ~-não são nomes de função extravagantes. Eu adicionei um link TIO.
alface cúbica

Ah, sim, ~-podem ser nomes de funções no Scala. Lembro-me de alguém mencionando isso antes há muito tempo. Isso é lamentável em relação ao golfe. Mais uma vez bem-vindo e boa primeira resposta.
Kevin Cruijssen

3

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!


3

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

11
118 bytes: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

Obrigado @Nevay. Não posso acreditar que perdi a coisa mais óbvia !A.endsWith(t)|!B.endsWith(t)quando estava procurando uma maneira curta de verificar se as duas terminavam com |.. E iniciar B com uma nova linha em vez de colocá-la entre elas no retorno também é inteligente.
Kevin Cruijssen


2

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!


2

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

11
Você pode salvar um byte com '\n':.
Laikoni 25/09

@Laikoni Cuidado, estou chegando perto de você
BlackCap 26/17

1

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!



1

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

Você documentou antes de implementar? o0
totallyhuman

11
@icrieverytim SOGL tem muitas, muitas coisas documentadas que não são implementadas. : p A documentação é basicamente a minha lista TODO (que eu raramente fazer: p)
dzaima

1

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}"!]


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

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>


1

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.


Sim Obrigado, @WashingtonGuedes. :)
remoel 27/09/17

1

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!


Você não precisa incluir os 'put', se a função retornar 2 strings, tudo bem. E você pode torná-lo mais curto usando a array * operador (array * '' é equivalente a Array.join)
GB

@ GB obrigado pela sua ajuda!
Snack

1

Carvão , 32 30 29 bytes

NθNη≔θζW﹪ζη≦⁺θζE⟦θη⟧…⁺×-⁻ι¹|ζ

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



@ Somente ASCII Algo novo para documentar!
Neil

Obrigado por documentar! (desculpe, eu realmente não sinto como documentar as coisas, embora eu deveria realmente fazê-lo), se você não se importa há um pouco mais para documento chat.stackexchange.com/transcript/240?m=40270513#40270513 chat.stackexchange. ? com / transcrição / 240 m = 40270838 # 40270838 (não tenho certeza onde os moldes direcionais deve ir, eles não são comandos nem são operadores)
ASCII-only

1

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


11
Você pode presumir que nada mais é inserido na linha 1? Nesse caso, você pode LCM(A1,B1)criar um curto - circuito LCM(1:1)para salvar apenas 4 bytes. Eu acho que é razoável presumir uma planilha inicial em branco e especificar onde estão as entradas e a fórmula.
Engineer Toast

1

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

1

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.



@ Shaggy Interessante, nunca pensei em usar essa parte do Japt dessa maneira exata.
Kamil Drakari # 23/18

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.