Ilustrar el mínimo común múltiplo

50

Dados dos enteros positivos, A y B, ilustran su mínimo común múltiplo generando dos líneas de guiones ( -) con LCM de longitud (A, B) después de reemplazar cada guión Ath en la primera línea y cada guión Bth en la segunda línea con barras verticales ( |)

De esta manera, el final de cada línea será el único lugar donde se |alinean dos.

Por ejemplo, si A = 6 y B = 4, LCM (6, 4) = 12, entonces:

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

Por lo tanto, el resultado final sería

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

El orden de los números de entrada debe corresponder al orden de las líneas.

El código más corto en bytes gana.

Casos de prueba

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
------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|
----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|
Pasatiempos de Calvin
fuente
3
@LeakyNun Ampliar una respuesta desde codegolf.stackexchange.com/q/94999 parece más fácil que desde esa. De cualquier manera, la gente se divertirá haciendo esto, lo cual es una buena razón.
Aficiones de Calvin
1
¿Puedo generar una matriz con dos cadenas, una para cada línea?
BlackCap
@BlackCap No. Imprima las cadenas en stdout o en un archivo o devuelva la cadena completa de varias líneas.
Aficiones de Calvin
2
¿Bonificación por manejar un número arbitrario de entradas?
Adám
1
@HelkaHomba Ok, gracias; guardado 1 byte más. :) (Como si hubiera alguna otra razón para hacer tales preguntas sobre los desafíos de codegolf.; P)
Kevin Cruijssen

Respuestas:

11

Python 3, 80 bytes

Ahorré 1 byte gracias a Halvard Hummel y 1 byte gracias a Jonathan Allan.

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

¡Pruébalo en línea!

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

¡Pruébalo en línea! (82 bytes - respuesta inicial)

Esto es lo mejor que podría hacer en Python 2 (81 bytes). Parece que no puedo comentar sobre esa respuesta, solo publicaré esto aquí:

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

¡Pruébalo en línea!

¡Primer intento aquí, probablemente subóptimo!


fuente
2
Bienvenido a PPCG!
Laikoni
3
@Laikoni ¡Gracias! Esto parece una comunidad divertida :-)
81 bytes
Halvard Hummel
@HalvardHummel Gracias, publicaremos como una alternativa!
Mientras intentaba un enfoque completamente diferente, me di cuenta de que su versión se podía hacer en 80 .
Jonathan Allan
10

Haskell , 57 bytes

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

Pruébalo en línea!

Laikoni
fuente
Nunca he visto ese 0^0=1truco antes - inteligente
BlackCap
@BlackCap No puedo reclamarlo porque lo he visto varias veces antes, aunque no recuerdo dónde vi el truco primero.
Laikoni
6

MATL , 16 15 bytes

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

La entrada es un vector de columna con los dos números. Pruébalo en línea!

Como beneficio adicional, la entrada puede contener más de dos números . Pruébalo en línea!

Explicación

'-|'   % 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
Luis Mendo
fuente
Creo que te fuiste en un callejón He?
Sanchises
@Sanchises Gracias! Sí, estaba en la versión anterior, pero no es necesario
Luis Mendo
Además, ¿esto parece funcionar bien sin la transposición? Has estado pensando demasiado ...;)
Sanchises
@Sanchises Sin la transposición no funciona para la entrada [1; 1], debido a cómo MATL (AB) maneja la forma de la matriz con la indexación. (Alternativamente, la transposición podría reemplazarse Heal final, por lo que inicialmente estaba allí)
Luis Mendo
Ah sí, pensé que estaba allí debido al comportamiento de la fila, pero no pensé en este caso extremo.
Sanchises
5

R , 109105 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,,"")}

Pruébalo en línea!

Función anónima. Calcula l=lcm(a,b), a continuación, genera un intervalo de 0a lpor a, a continuación, a partir lde 2*lpor b, el establecimiento de los índices para |impresión y como una matriz con lcolumnas.

Giuseppe
fuente
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);}
orlp
fuente
4

Casco , 12 bytes

†?'-'|TUṪ`%N

Pruébalo en línea!

Sí, hay un mcm incorporado en Husk. No, no lo necesito.

Bonificación: funciona con cualquier cantidad de valores de entrada

Explicación

†?'-'|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
León
fuente
4

Mathematica, 63 bytes

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

Pruébalo en línea!

y otra versión que user202729 realmente quiere ver publicada

Mathematica, 59 bytes

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

este usa un caracter especial \[Divides]

J42161217
fuente
Si esto es Mathematica, probablemente pueda usarlo en \[Divides]lugar del Modoperador para representar la divisibilidad, lo que ahorra 4 bytes. También Mathics TIO no debe imprimir el {Null, Null}.
user202729
@ user202729 Arregle la impresión de Mathics.
J42161217
3
Creo que tu primer comentario fue lo suficientemente claro. Por favor, deja de presionarme para hacer los cambios que deseas, la hora exacta que deseas. Dé a los usuarios algunas horas para responder. Algunos de nosotros tenemos una vida fuera de este lugar
J42161217
3

05AB1E , 13 bytes

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

Utiliza la codificación 05AB1E . Pruébalo en línea!

Adnan
fuente
El filtro fue una buena idea, tengo 17 haciéndolo completamente diferente .¿Lε²¹‚%_„-|è}øJ».
Urna mágica de pulpo
3

APL (Dyalog) , 22 bytes

Asume ⎕IO←0. Toma A, B como argumento correcto. Bonificación: maneja la lista de entrada de cualquier longitud.

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

Pruébalo en línea!

{... } lambda anónimo donde representa el argumento correcto

'|-'[... ] indexe la cadena con:

  ∧/ LCM a través de la entrada

   primero que muchos dedos (0 a N-1)

  ⍵∘.| tabla de resto de división con la entrada vertical y horizontalmente

  × signum

   voltear horizontalmente

Adán
fuente
¿Qué significa esa primera suposición?
Aficiones de Calvin
@HelkaHomba Significa que el índice de matrices comienza en 0, un valor predeterminado en los intérpretes APL, creo.
Conor O'Brien
@HelkaHomba Dado que los sistemas APL vienen en sabores basados ​​en 0 y en 1, simplemente escribo la suposición. De lo contrario, uno tendría que tener dos APL. Por ejemplo, ngn / apl puede ejecutar este mismo código sin especificar ⎕IO←0, ya que ese es el valor predeterminado allí.
Adám
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))

Se ejecuta recursivamente hasta que Asea ​​divisible por ambos ay b, generando un guión o una tubería en función de ala divisibilidad por A.

La función se llama a sí misma, intercambiando ay b.

La Svariable evita que la función se llame a sí misma infinitamente.

Casos de prueba:


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

Utiliza los algoritmos:

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

Se llama recursivamente solo una vez para generar la segunda línea.

Casos de prueba:

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

Mismo algoritmo que antes, usando en repeatlugar de padStart.

Rick Hitchcock
fuente
1
Pensé que padStartera ES8?
Neil
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, apenas puedo entender el código que escribí hace un año, pero parece que el tuyo elimina algunos bytes, ¡gracias!
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)

Pruébalo en línea

lechuga cubica
fuente
Hola, bienvenido a PPCG! Esto parece una gran primera respuesta, por lo que +1 de mi parte. No estoy seguro, ya que nunca he programado en Scala, pero puedo *(a-1)estar Jugamos al golf a *~-ay *(b-1)a *~-b? Además, ¿podría agregar un enlace TIO con el código de prueba? (Ah, y ese avatar no me parece muy cúbico.; P)
Kevin Cruijssen
2
¡Gracias! El truco con *~-aes grande, pero por desgracia Scala requiere más soportes: *(~(-a))dejar claro que las concatenaciones *~-, *~, ~-no son nombres de funciones de fantasía. Agregué un enlace TIO.
lechuga cúbica
Ah sí, ~-pueden ser nombres de funciones en Scala. Recuerdo que alguien mencionó eso antes hace bastante tiempo. Eso es lamentable con respecto al golf. Nuevamente bienvenido, y buena primera respuesta.
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+'|';}

Pruébalo en línea!

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

Pruébalo en línea!

Nevay
fuente
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 gracias a @Nevay .
-1 byte comenzando con una nueva línea final ( A="",B="\n"reemplazada por A="\n",B=A).

Explicación:

Pruébalo aquí.

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
Kevin Cruijssen
fuente
1
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
@Nevay Gracias. No puedo creer que me perdí lo más obvio !A.endsWith(t)|!B.endsWith(t)cuando estaba buscando una forma corta de verificar si ambos terminan con |... Y comenzar B con una nueva línea en lugar de ponerla entre ellos en el regreso también es inteligente.
Kevin Cruijssen
2

Python 2 , 96 88 bytes

Editar: Guardado 4 bytes gracias a @Leaky Nun

Editar: Guardado 4 bytes gracias a @Rod

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

Pruébalo en línea!

Halvard Hummel
fuente
88 bytes o 77 bytes para una salida más flexible
Rod
88 bytes
ovs
1
Aparentemente, no es aceptable generar una lista de cadenas. : Reemplazo [...]con '\n'.join(...)para arreglar.
totalmente humano
2

Python 2 , 89 bytes

No es la entrada más corta de Python 2, sino un enfoque diferente al gcd que aún puede ser golfable.

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

Pruébalo en línea!

Jonathan Allan
fuente
2

Haskell , 66 60 bytes

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

Pruébalo en línea!


Mismo largo:

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

Vieja solución:

l!x=[1..div l x]>>([2..x]>>"-")++"|"
a#b|l<-lcm a b=l!a++'\n':l!b
Alondra
fuente
1
Puede guardar un byte con '\n':.
Laikoni
@Laikoni Cuidado, me estoy acercando a ti
BlackCap
1

C (gcc) , 121 99 93 92 89 bytes

Esto debería ser mucho más corto, 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)}

Pruébalo en línea!

cleblanc
fuente
1

SOGL V0.12 , 19 16 bytes

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

Pruébalo aquí!

Explicación:

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
fuente
¿Documentaste antes de implementar? o0
totalmente humano
1
@icrieverytim SOGL tiene muchas, muchas cosas documentadas que no se implementan. : p La documentación es básicamente mi lista TODO (lo cual rara vez hago: p)
dzaima
1

Apilado , 42 38 bytes

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

Pruébalo en línea!

Entrada en forma de un par de números. Todos los casos de prueba juntos se parecen a los edificios.

Explicación

Este primero toma el lcmde los dos números de entrada z. Luego, para cada número k, generamos z / kcadenas de -longitud k - 1, agregando |al final de cada una y generando cada una.

Intentos contados anteriores

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

Otros intentos

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

Conor O'Brien
fuente
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

Evaluación de la LCM con adicciones repetidas.

Menos golf

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
}

Prueba

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

remodelar
fuente
Sí, gracias @WashingtonGuedes. :)
remoel
1

Ruby , 64 57 bytes

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

-7 bytes gracias a G B.

Pruébalo en línea!

Bocadillo
fuente
No es necesario incluir los 'put', si la función devuelve 2 cadenas está bien. Y puede acortarlo utilizando el operador array * (array * '' es equivalente a array.join)
GB
@GB gracias por tu ayuda!
Merienda
1

Carbón , 32 30 29 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: guardado 1 byte gracias a @ ASCII-only.

Neil
fuente
29 bytes
solo ASCII el
@ Solo ASCII ¡Algo nuevo para documentar!
Neil
Gracias por documentar! (lo siento, realmente no tengo ganas de documentar cosas, aunque realmente debería hacerlo), si no le importa, hay algo más que documentar chat.stackexchange.com/transcript/240?m=40270513#40270513 chat.stackexchange. com / transcript / 240? m = 40270838 # 40270838 (no estoy seguro de dónde deben ir los lanzamientos direccionales, no son comandos ni operadores)
Solo ASCII
1

Hojas de cálculo de Google, 77 bytes

Fórmula de hoja de trabajo anónima que toma entradas del rango A1:B1y salidas a la celda que llama

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

-4 Bytes gracias a @EngineerToast

Taylor Scott
fuente
1
¿Se puede suponer que nada más se ingresa en la fila 1? Si es así, puede acortar LCM(A1,B1)a solo LCM(1:1)para guardar 4 bytes. Creo que es razonable suponer una hoja de inicio en blanco y especificar dónde están las entradas y la fórmula.
Ingeniero Brindis
1

Excel VBA, 79 bytes

Función de ventana inmediata anónima de VBE que toma la entrada del rango [A1:B1]y emite una visualización de su LCM a la ventana inmediata de VBE.

Este es un puerto de mi respuesta de Google Sheets .

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

Japt , 12 bytes

£×/Ury)î|ù-X

Intérprete Japt

Entradas como una matriz de números. Salidas como un conjunto de cadenas. El indicador -R mejora ligeramente el aspecto de la salida, pero no es necesario para la lógica.

Explicación:

£              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

Gracias adicionales a Shaggy por encontrar algunos bytes para guardar.

Kamil Drakari
fuente
1
15 bytes
Shaggy
@ Shaggy Interesante, nunca pensé usar esa parte de Japt de esa manera exacta.
Kamil Drakari